ofxsParam.h

Go to the documentation of this file.

#ifndef _ofxsParam_H_
#define _ofxsParam_H_

/*
  OFX Support Library, a library that skins the OFX plug-in API with C++ classes.
  Copyright (C) 2004-2005 The Foundry Visionmongers Ltd
  Author Bruno Nicoletti bruno@thefoundry.co.uk

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,
      this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice,
      this list of conditions and the following disclaimer in the documentation
      and/or other materials provided with the distribution.
    * Neither the name The Foundry Visionmongers Ltd, nor the names of its 
      contributors may be used to endorse or promote products derived from this
      software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The Foundry Visionmongers Ltd
1 Wardour St
London W1D 6PA
England



*/


#include "ofxsCore.h"

#define mDeclareProtectedAssignAndCC(CLASS) \
  CLASS &operator=(const CLASS &v1) {assert(false); return *this;}      \
  CLASS(const CLASS &v) {assert(false); } 

namespace OFX {

    class ParamInteractDescriptor;
    /* forward class declarations of the  descriptors */
    class ParamDescriptor;
    class ValueParamDescriptor;
    class IntParamDescriptor;
    class Int2DParamDescriptor;
    class Int3DParamDescriptor;    
    class DoubleParamDescriptor;
    class Double2DParamDescriptor;
    class Double3DParamDescriptor;    
    class StringParamDescriptor;
    class RGBAParamDescriptor;
    class RGBParamDescriptor;
    class BooleanParamDescriptor;
    class ChoiceParamDescriptor;
    class GroupParamDescriptor;
    class PageParamDescriptor;
    class PushButtonParamDescriptor;
    class CustomParamDescriptor;
    class ParamSetDescriptor;

    /* forward class declarations of the instances */
    class Param;
    class ValueParam;
    class IntParam;
    class Int2DParam;
    class Int3DParam;    
    class DoubleParam;
    class Double2DParam;
    class Double3DParam;    
    class RGBAParam;
    class RGBParam;
    class StringParam;
    class BooleanParam;
    class ChoiceParam;
    class CustomParam;
    class GroupParam;
    class PageParam;
    class PushButtonParam;
    class ParamSet;


    enum ParamTypeEnum {eDummyParam,
                        eStringParam,
                        eIntParam,
                        eInt2DParam,
                        eInt3DParam,
                        eDoubleParam,
                        eDouble2DParam,
                        eDouble3DParam,
                        eRGBParam,
                        eRGBAParam,
                        eBooleanParam,
                        eChoiceParam,
                        eCustomParam,
                        eGroupParam,
                        ePageParam,
                        ePushButtonParam};

    enum CacheInvalidationEnum {eCacheInvalidateValueChange,
                                eCacheInvalidateValueChangeToEnd,
                                eCacheInvalidateValueAll};

    enum KeySearchEnum {eKeySearchBackwards,
                        eKeySearchNear,
                        eKeySearchForwards};

    enum StringTypeEnum {
        eStringTypeSingleLine,
        eStringTypeMultiLine,
        eStringTypeFilePath,
        eStringTypeDirectoryPath,
        eStringTypeLabel
    };

    enum DoubleTypeEnum {
        eDoubleTypePlain,
        eDoubleTypeAngle,
        eDoubleTypeScale,
        eDoubleTypeTime,
        eDoubleTypeAbsoluteTime,
        eDoubleTypeNormalisedX,
        eDoubleTypeNormalisedY,
        eDoubleTypeNormalisedXAbsolute,
        eDoubleTypeNormalisedYAbsolute,
        eDoubleTypeNormalisedXY,
        eDoubleTypeNormalisedXYAbsolute    
    };

    const char *
    mapParamTypeEnumToString(ParamTypeEnum v);


    class ParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(ParamDescriptor);
        ParamDescriptor(void) {assert(false);}

    protected :
        std::string    _paramName;
        ParamTypeEnum  _paramType;
        PropertySet    _paramProps;

        ParamDescriptor(const std::string &name, ParamTypeEnum type, OfxPropertySetHandle props);

        friend class ParamSetDescriptor;
    public :
        virtual ~ParamDescriptor();

        ParamTypeEnum getType(void) const {return _paramType;}

        const std::string &getName(void) const {return _paramName;}

      PropertySet &getPropertySet()
      {
        return _paramProps;
      }


        void setLabels(const std::string &label, const std::string &shortLabel, const std::string &longLabel);

        void setHint(const std::string &hint);

        void setScriptName(const std::string &hint);

        void setIsSecret(bool v);

        void setParent(const GroupParamDescriptor &v);
    
        void setEnabled(bool v);
    };


    class DummyParamDescriptor : public ParamDescriptor {
    public :
        DummyParamDescriptor(const std::string &name) 
          : ParamDescriptor(name, eDummyParam, 0)
        {}  
    };


    class ValueParamDescriptor : public ParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(ValueParamDescriptor);
        ValueParamDescriptor(void) {assert(false);}

    protected :
        ValueParamDescriptor(const std::string &name, ParamTypeEnum type, OfxPropertySetHandle props);

        friend class ParamSetDescriptor;
        std::auto_ptr<ParamInteractDescriptor> _interact;
    public :
        ~ValueParamDescriptor();

        void setAnimates(bool v);

        void setIsPersistant(bool v);

        void setEvaluateOnChange(bool v);
    
        void setCacheInvalidation(CacheInvalidationEnum v);

        void setCanUndo(bool v);

        void setInteractDescriptor(ParamInteractDescriptor* desc);
    };


    class StringParamDescriptor : public ValueParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(StringParamDescriptor);
        StringParamDescriptor(void) {assert(false);}

    protected :
        StringParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        friend class ParamSetDescriptor;

    public :
        void setDefault(const std::string &v);

        void setStringType(StringTypeEnum v);

        void setFilePathExists(bool v);    
    };


    class IntParamDescriptor : public ValueParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(IntParamDescriptor);
        IntParamDescriptor(void) {assert(false);}

    protected :
        IntParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        friend class ParamSetDescriptor;

    public :
        void setDefault(int v);

        void setRange(int min, int max);

        void setDisplayRange(int min, int max);
    };
    

    class Int2DParamDescriptor : public ValueParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(Int2DParamDescriptor);
        Int2DParamDescriptor(void) {assert(false);}

    protected :
        Int2DParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        friend class ParamSetDescriptor;

    public :
        void setDimensionLabels(const std::string &x,
                                const std::string &y);

        void setDefault(int x, int y);

        void setRange(int minX, int minY,
                      int maxX, int maxY);

        void setDisplayRange(int minX, int minY,
                            int maxX, int maxY);
    };
  

    class Int3DParamDescriptor : public ValueParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(Int3DParamDescriptor);
        Int3DParamDescriptor(void) {assert(false);}

    protected :
        Int3DParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        friend class ParamSetDescriptor;

    public :
        void setDimensionLabels(const std::string &x,
                                const std::string &y,
                                const std::string &z);

        void setDefault(int x, int y, int z);

        void setRange(int minX, int minY, int minZ,
                      int maxX, int maxY, int maxZ);

        void setDisplayRange(int minX, int minY, int minZ,
                            int maxX, int maxY, int maxZ);
    };


    class BaseDoubleParamDescriptor : public ValueParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(BaseDoubleParamDescriptor);
        BaseDoubleParamDescriptor(void) {assert(false);}

    protected :
        BaseDoubleParamDescriptor(const std::string &name, ParamTypeEnum type, OfxPropertySetHandle props);

        friend class ParamSetDescriptor;
    public :
        void setDoubleType(DoubleTypeEnum v);

        void setIncrement(double v);

        void setDigits(int v);
    };
  

    class DoubleParamDescriptor : public BaseDoubleParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(DoubleParamDescriptor);
        DoubleParamDescriptor(void) {assert(false);}

    protected :
        DoubleParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        friend class ParamSetDescriptor;

    public :
        void setShowTimeMarker(bool v);

        void setDefault(double v);

        void setRange(double min, double max);

        void setDisplayRange(double min, double max);
    };
  

    class Double2DParamDescriptor : public BaseDoubleParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(Double2DParamDescriptor);
        Double2DParamDescriptor(void) {assert(false);}

    protected :
        Double2DParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        friend class ParamSetDescriptor;

    public :
        void setDimensionLabels(const std::string &x,
                                const std::string &y);

        void setDefault(double x, double y);

        void setRange(double minX, double minY,
                      double maxX, double maxY);

        void setDisplayRange(double minX, double minY,
                            double maxX, double maxY);
    };
  

    class Double3DParamDescriptor : public BaseDoubleParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(Double3DParamDescriptor);
        Double3DParamDescriptor(void) {assert(false);}

    protected :
        Double3DParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        friend class ParamSetDescriptor;

    public :
        void setDimensionLabels(const std::string &x,
                                const std::string &y,
                                const std::string &z);

        void setDefault(double x, double y, double z);

        void setRange(double minX, double minY, double minZ,
                      double maxX, double maxY, double maxZ);

        void setDisplayRange(double minX, double minY, double minZ,
                            double maxX, double maxY, double maxZ);
    };


    class RGBParamDescriptor : public ValueParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(RGBParamDescriptor);
        RGBParamDescriptor(void) {assert(false);}

    protected :
        RGBParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        // so it can make one
        friend class ParamSetDescriptor;
    public :
        void setDefault(double r, double g, double b);
    };


    class RGBAParamDescriptor : public ValueParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(RGBAParamDescriptor);
        RGBAParamDescriptor(void) {assert(false);}

    protected :
        RGBAParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        // so it can make one
        friend class ParamSetDescriptor;
    public :
        void setDefault(double r, double g, double b, double a);
    };


    class BooleanParamDescriptor : public ValueParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(BooleanParamDescriptor);
        BooleanParamDescriptor(void) {assert(false);}

    protected :
        BooleanParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        // so it can make one
        friend class ParamSetDescriptor;
    public :
        void setDefault(bool v);
    };
  

    class ChoiceParamDescriptor : public ValueParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(ChoiceParamDescriptor);
        ChoiceParamDescriptor(void) {assert(false);}

    protected :
        ChoiceParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        // so it can make one
        friend class ParamSetDescriptor;
    public :
        void setDefault(int v);

        void appendOption(const std::string &v);
    
        int getNOptions(void);
    
        void resetOptions(void);
    };


    class GroupParamDescriptor : public ParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(GroupParamDescriptor);
        GroupParamDescriptor(void) {assert(false);}

    protected :
        GroupParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        // so it can make one
        friend class ParamSetDescriptor;
    public :
    };


    class PageParamDescriptor : public ParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(PageParamDescriptor);
        PageParamDescriptor(void) {assert(false);}

    protected :
        PageParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        // so it can make one
        friend class ParamSetDescriptor;
    public :

        void addChild(const ParamDescriptor &p);

        static DummyParamDescriptor gSkipRow;

        static DummyParamDescriptor gSkipColumn;
    };


    class PushButtonParamDescriptor : public ParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(PushButtonParamDescriptor);
        PushButtonParamDescriptor(void) {assert(false);}

    protected :
        PushButtonParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        // so it can make one
        friend class ParamSetDescriptor;
    public :
    };


    class CustomParamDescriptor : public ValueParamDescriptor {
    protected :
        mDeclareProtectedAssignAndCC(CustomParamDescriptor);
        CustomParamDescriptor(void) {assert(false);}

    protected :
        CustomParamDescriptor(const std::string &name, OfxPropertySetHandle props);

        // so it can make one
        friend class ParamSetDescriptor;
    public :
        void setDefault(const std::string &v);    
    };


    class ParamSetDescriptor { 
    protected :
        mDeclareProtectedAssignAndCC(ParamSetDescriptor);

        void defineRawParam(const std::string &name, ParamTypeEnum paramType, OfxPropertySetHandle &props);

        template <class T> bool
        defineParamDescriptor(const std::string &name, ParamTypeEnum paramType, T * &paramPtr)
        {
            paramPtr = NULL;

            // have we made it already in this param set and is it of the correct type
            if(ParamDescriptor *param  = findPreviouslyDefinedParam(name)) {
                if(param->getType() == paramType) {
                    paramPtr = (T *) param; // could be a dynamic cast here
                    return true;
                }
                else
                    return false; // SHOULD THROW SOMETHING HERE!!!!!!!
            }
            else {
                // ok define one and add it in
                OfxPropertySetHandle props;
                defineRawParam(name, paramType, props);
    
                // make out support descriptor class
                paramPtr = new T(name, props);

                // add it to our map of described ones
                _definedParams[name] = paramPtr;
            }
            return true;
        }

    protected :
        PropertySet _paramSetProps;

        OfxParamSetHandle _paramSetHandle;

        std::map<std::string, ParamDescriptor *> _definedParams;

        ParamSetDescriptor(void);

        void setParamSetHandle(OfxParamSetHandle h);

        ParamDescriptor *findPreviouslyDefinedParam(const std::string &name);

    public :
        virtual ~ParamSetDescriptor();
        ParamDescriptor* getParamDescriptor(const std::string& name) const;

        void setPageParamOrder(PageParamDescriptor &p);

        IntParamDescriptor *defineIntParam(const std::string &name);

        Int2DParamDescriptor *defineInt2DParam(const std::string &name);

        Int3DParamDescriptor *defineInt3DParam(const std::string &name);
    
        DoubleParamDescriptor *defineDoubleParam(const std::string &name);

        Double2DParamDescriptor *defineDouble2DParam(const std::string &name);

        Double3DParamDescriptor *defineDouble3DParam(const std::string &name);
    
        StringParamDescriptor *defineStringParam(const std::string &name);

        RGBAParamDescriptor *defineRGBAParam(const std::string &name);

        RGBParamDescriptor *defineRGBParam(const std::string &name);

        BooleanParamDescriptor *defineBooleanParam(const std::string &name);

        ChoiceParamDescriptor *defineChoiceParam(const std::string &name);

        GroupParamDescriptor *defineGroupParam(const std::string &name);

        PageParamDescriptor *definePageParam(const std::string &name);

        PushButtonParamDescriptor *definePushButtonParam(const std::string &name);

        CustomParamDescriptor *defineCustomParam(const std::string &name);
    };


    class Param {
    protected :
        // don't ever use these!
        Param &operator=(const Param &v1) {assert(false); return *this;} 
        Param(const Param &v) : _paramSet(v._paramSet) {assert(false); } 
        Param(void) {assert(false);}
    
    protected :
        std::string    _paramName;
        ParamTypeEnum  _paramType;
        PropertySet    _paramProps;
        OfxParamHandle _paramHandle;
        const ParamSet      *_paramSet; // who do I belong to

        Param(const ParamSet *paramSet, const std::string &name, ParamTypeEnum type, OfxParamHandle handle);

        friend class ParamSet;
    public :
        virtual ~Param();

        const std::string &getName(void) const;
    
        void setLabels(const std::string &label, const std::string &shortLabel, const std::string &longLabel);

        ParamTypeEnum getType(void) const {return _paramType;}

        void setIsSecret(bool v);

        void setHint(const std::string &hint);

        void setEnabled(bool v);

        void getLabels(std::string &label, std::string &shortLabel, std::string &longLabel) const;
    
        bool getIsSecret(void) const;

        bool getIsEnable(void) const;
    
        std::string getHint(void) const;

        std::string getScriptName(void) const;

        GroupParam *getParent(void) const;
    };
  

    class ValueParam : public Param {
    protected :
        mDeclareProtectedAssignAndCC(ValueParam);
        ValueParam(void) {assert(false);}
    protected :
        ValueParam(const ParamSet *paramSet, const std::string &name, ParamTypeEnum type, OfxParamHandle handle);
      
        friend class ParamSet;
    public :
        ~ValueParam();

        void setEvaluateOnChange(bool v);
    
        bool getIsAnimating(void) const;

        bool getIsAutoKeying(void) const;
    
        bool getIsPersistant(void) const;
    
        bool getEvaluateOnChange(void) const;

        CacheInvalidationEnum getCacheInvalidation(void) const;

        unsigned int getNumKeys(void);

        double getKeyTime(int nthKey) throw(OFX::Exception::Suite, std::out_of_range);

        int getKeyIndex(double time, 
                        KeySearchEnum searchDir);
    
        void deleteKeyAtTime(double time);

        void deleteAllKeys(void);
    };


    class IntParam : public ValueParam {
    protected :
        mDeclareProtectedAssignAndCC(IntParam);
        IntParam(void) {assert(false);}

    protected :
        IntParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        friend class ParamSet;
    public :
        void setDefault(int v);

        void setRange(int min, int max);

        void setDisplayRange(int min, int max);

        void getDefault(int &v);

        int getDefault(void) {int v; getDefault(v); return v;}

        void getRange(int &min, int &max);

        void getDisplayRange(int &min, int &max);

        void  getValue(int &v);

        int getValue(void) {int v; getValue(v); return v;}

        void getValueAtTime(double t, int &v);

        int getValueAtTime(double t) {int v; getValueAtTime(t, v); return v;}

        void setValue(int v);

        void setValueAtTime(double t, int v);
    };  


    class Int2DParam : public ValueParam {
    protected :
        mDeclareProtectedAssignAndCC(Int2DParam);
        Int2DParam(void) {assert(false);}

    protected :
        Int2DParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        friend class ParamSet;
    public :
        void setDefault(int x, int y);

        void setDefault(const OfxPointI &v) {setDefault(v.x, v.y);}

        void setRange(int minX, int minY,
                      int maxX, int maxY);

        void setDisplayRange(int minX, int minY,
                            int maxX, int maxY);

        void getDefault(int &x, int &y);

        OfxPointI getDefault(void) {OfxPointI v; getDefault(v.x, v.y); return v;}

        void getRange(int &minX, int &minY,
                      int& maxX, int &maxY);

        void getDisplayRange(int &minX, int &minY,
                            int &maxX, int &maxY);

        void getValue(int &x, int &y);

        OfxPointI getValue(void) {OfxPointI v; getValue(v.x, v.y); return v;}

        void getValueAtTime(double t, int &x, int &y);

        OfxPointI getValueAtTime(double t) {OfxPointI v; getValueAtTime(t, v.x, v.y); return v;}

        void setValue(int x, int y);

        void setValue(const OfxPointI &v) {setValue(v.x, v.y);}

        void setValueAtTime(double t, int x, int y);

        void setValueAtTime(double t, const OfxPointI &v) {setValueAtTime(t, v.x, v.y);}
    };  


    class Int3DParam : public ValueParam {
    protected :
        mDeclareProtectedAssignAndCC(Int3DParam);
        Int3DParam(void) {assert(false);}

    protected :
        Int3DParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        friend class ParamSet;
    public :
        void setDefault(int x, int y, int z);

        void setRange(int minX, int minY, int minZ,
                      int maxX, int maxY, int maxZ);

        void setDisplayRange(int minX, int minY, int minZ,
                            int maxX, int maxY, int maxZ);

        void getDefault(int &x, int &y, int &z);

        void getRange(int &minX, int &minY, int &minZ,
                      int& maxX, int &maxY, int &maxZ);

        void getDisplayRange(int &minX, int &minY, int &minZ,
                            int& maxX, int &maxY, int &maxZ);

        void getValue(int &x, int &y, int &z);

        void getValueAtTime(double t, int &x, int &y, int &z);

        void setValue(int x, int y, int z);

        void setValueAtTime(double t, int x, int y, int z);
    };  


    class BaseDoubleParam : public ValueParam {
    protected :
        mDeclareProtectedAssignAndCC(BaseDoubleParam);
        BaseDoubleParam(void) {assert(false);}

    protected :
        BaseDoubleParam(const ParamSet *paramSet, const std::string &name, ParamTypeEnum type, OfxParamHandle handle);

        friend class ParamSet;
    public :
        void setIncrement(double v);

        void setDigits(int v);

        void getIncrement(double &v);

        void getDigits(int &v);

        void getDoubleType(DoubleTypeEnum &v);
    };


    class DoubleParam : public BaseDoubleParam {
    protected :
        mDeclareProtectedAssignAndCC(DoubleParam);
        DoubleParam(void) {assert(false);}

    protected :
        DoubleParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        friend class ParamSet;
    public :
        void setDefault(double v);

        void setShowTimeMarker(bool v);

        void setRange(double min, double max);

        void setDisplayRange(double min, double max);

        void getDefault(double &v);

        double getDefault(void) {double v; getDefault(v); return v;}

        void getRange(double &min, double &max);

        void getDisplayRange(double &min, double &max);

        void getValue(double &v);

        double getValue(void) {double v; getValue(v); return v;}

        void getValueAtTime(double t, double &v);

        double getValueAtTime(double t) {double v; getValueAtTime(t, v); return v;}

        void setValue(double v);

        void setValueAtTime(double t, double v);

        void differentiate(double t, double &v);

        double differentiate(double t) {double v; differentiate(t, v); return v;}

        void integrate(double t1, double t2, double &v);

        double integrate(double t1, double t2) {double v; integrate(t1, t2, v); return v;}
    };  


    class Double2DParam : public BaseDoubleParam {
    protected :
        mDeclareProtectedAssignAndCC(Double2DParam);
        Double2DParam(void) {assert(false);}

    protected :
        Double2DParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        friend class ParamSet;
    public :
        void setDefault(double x, double y);

        void setRange(double minX, double minY,
                      double maxX, double maxY);

        void setDisplayRange(double minX, double minY,
                            double maxX, double maxY);

        void getDefault(double &x, double &y);

        void getRange(double &minX, double &minY,
                      double& maxX, double &maxY);

        void getDisplayRange(double &minX, double &minY,
                            double &maxX, double &maxY);

        void getValue(double &x, double &y);

        void getValueAtTime(double t, double &x, double &y);

        void setValue(double x, double y);

        void setValueAtTime(double t, double x, double y);

        void differentiate(double t, double &x, double &y);

        OfxPointD differentiate(double t) {OfxPointD v; differentiate(t, v.x, v.y); return v;}

        void integrate(double t1, double t2, double &x, double &y);

        OfxPointD integrate(double t1, double t2) {OfxPointD v; integrate(t1, t2, v.x, v.y); return v;}
    };  


    class Double3DParam : public BaseDoubleParam {
    protected :
        mDeclareProtectedAssignAndCC(Double3DParam);
        Double3DParam(void) {assert(false);}

    protected :
        Double3DParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        friend class ParamSet;
    public :
        void setDefault(double x, double y, double z);

        void setRange(double minX, double minY, double minZ,
                      double maxX, double maxY, double maxZ);

        void setDisplayRange(double minX, double minY, double minZ,
                            double maxX, double maxY, double maxZ);

        void getDefault(double &x, double &y, double &z);

        void getRange(double &minX, double &minY, double &minZ,
                      double& maxX, double &maxY, double &maxZ);

        void getDisplayRange(double &minX, double &minY, double &minZ,
                            double& maxX, double &maxY, double &maxZ);

        void getValue(double &x, double &y, double &z);

        void getValueAtTime(double t, double &x, double &y, double &z);

        void setValue(double x, double y, double z);

        void setValueAtTime(double t, double x, double y, double z);

        void differentiate(double t, double &x, double &y, double &z);

        Ofx3DPointD differentiate(double t) {Ofx3DPointD v; differentiate(t, v.x, v.y, v.z); return v;}

        void integrate(double t1, double t2, double &x, double &y, double &z);

        Ofx3DPointD integrate(double t1, double t2) {Ofx3DPointD v; integrate(t1, t2, v.x, v.y, v.z); return v;}
    };  
  

    class RGBParam : public ValueParam {
    protected :
        mDeclareProtectedAssignAndCC(RGBParam);
        RGBParam(void) {assert(false);}

    protected :
        RGBParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        friend class ParamSet;
    public :
        void setDefault(double r, double g, double b);

        void getDefault(double &r, double &g, double &b);

        void getValue(double &r, double &g, double &b);

        void getValueAtTime(double t, double &r, double &g, double &b);

        void setValue(double r, double g, double b);

        void setValueAtTime(double t, double r, double g, double b);
    };  
 
  

    class RGBAParam : public ValueParam {
    protected :
        mDeclareProtectedAssignAndCC(RGBAParam);
        RGBAParam(void) {assert(false);}

    protected :
        RGBAParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        friend class ParamSet;
    public :
        void setDefault(double r, double g, double b, double a);

        void getDefault(double &r, double &g, double &b, double &a);

        void getValue(double &r, double &g, double &b, double &a);

        void getValueAtTime(double t, double &r, double &g, double &b, double &a);

        void setValue(double r, double g, double b, double a);

        void setValueAtTime(double t, double r, double g, double b, double a);
    };  


    class StringParam : public ValueParam {
    protected :
        mDeclareProtectedAssignAndCC(StringParam);
        StringParam(void) {assert(false);}

    protected :
        StringParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        friend class ParamSet;

    public :
        void setDefault(const std::string &v);

        void getDefault(std::string &v);

        void getValue(std::string &v);

        void getValueAtTime(double t, std::string &v);

        void setValue(const std::string &v);

        void setValueAtTime(double t, const std::string &v);
    };


    class ChoiceParam : public ValueParam {
    protected :
        mDeclareProtectedAssignAndCC(ChoiceParam);
        ChoiceParam(void) {assert(false);}

    protected :
        ChoiceParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        // so it can make one
        friend class ParamSet;
    public :
        void setDefault(int v);

        void getDefault(int &v);

        int getNOptions(void);

        void appendOption(const std::string &v);
    
        void resetOptions(void);

        void getValue(int &v);

        void getValueAtTime(double t, int &v);

        void setValue(int v);

        void setValueAtTime(double t, int v);
    };


    class BooleanParam : public ValueParam {
    protected :
        mDeclareProtectedAssignAndCC(BooleanParam);
        BooleanParam(void) {assert(false);}

    protected :
        BooleanParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        // so it can make one
        friend class ParamSet;
    public :
        void setDefault(bool v);

        void getDefault(bool &v);

        bool getDefault(void) {bool v; getDefault(v); return v;}

        void getValue(bool &v);

        bool getValue(void) {bool v; getValue(v); return v;}

        void getValueAtTime(double t, bool &v);

        bool getValueAtTime(double t) {bool v; getValueAtTime(t, v); return v;}

        void setValue(bool v);

        void setValueAtTime(double t, bool v);
    };


    class GroupParam : public Param {
    protected :
        mDeclareProtectedAssignAndCC(GroupParam);
        GroupParam(void) {assert(false);}

    protected :
        GroupParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        // so it can make one
        friend class ParamSet;
    public :
    };


    class PageParam : public Param {
    protected :
        mDeclareProtectedAssignAndCC(PageParam);
        PageParam(void) {assert(false);}

    protected :
        PageParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        // so it can make one
        friend class ParamSet;
    public :
    };


    class CustomParam : public ValueParam {
    protected :
        mDeclareProtectedAssignAndCC(CustomParam);
        CustomParam(void) {assert(false);}

    protected :
        CustomParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        // so it can make one
        friend class ParamSet;
    public :
        void setDefault(const std::string &v);    

        void getDefault(std::string &v);    

        void getValue(std::string &v);

        void getValueAtTime(double t, std::string &v);

        void setValue(const std::string &v);

        void setValueAtTime(double t, const std::string &v);
    };


    class PushButtonParam : public Param {
    protected :
        mDeclareProtectedAssignAndCC(PushButtonParam);
        PushButtonParam(void) {assert(false);}

    protected :
        PushButtonParam(const ParamSet *paramSet, const std::string &name, OfxParamHandle handle);

        // so it can make one
        friend class ParamSet;
    public :
    };


    class ParamSet { 
    protected :
        mDeclareProtectedAssignAndCC(ParamSet);
        ParamTypeEnum getParamType(const std::string& name) const;
    private :
        PropertySet _paramSetProps;

        OfxParamSetHandle _paramSetHandle;

        mutable std::map<std::string, Param *> _fetchedParams;

        Param *findPreviouslyFetchedParam(const std::string &name) const;

        void fetchRawParam(const std::string &name, ParamTypeEnum paramType, OfxParamHandle &handle) const;


        template <class T> void
        fetchParam(const std::string &name, ParamTypeEnum paramType, T * &paramPtr) const
        {
            paramPtr = NULL;

            // have we made it already in this param set and is it an int?
            if(Param *param  = findPreviouslyFetchedParam(name)) {
                if(param->getType() == paramType) {
                    paramPtr = (T *) param; // could be a dynamic cast here
                }
                else
                  throw OFX::Exception::TypeRequest("Fetching param and attempting to return the wrong type");
            }
            else {
                // ok define one and add it in
                OfxParamHandle paramHandle;
                fetchRawParam(name, paramType, paramHandle);
    
                // make out support descriptor class
                paramPtr = new T(this, name, paramHandle);

                // add it to our map of described ones
                _fetchedParams[name] = paramPtr;
            }
        }

    protected :
        ParamSet(void);

        void setParamSetHandle(OfxParamSetHandle h);

    public :
        virtual ~ParamSet();

        bool paramExists(const std::string& name) const;

        void beginEditBlock(const std::string &name);

        void endEditBlock();

        Param* getParam(const std::string& name) const;

        IntParam *fetchIntParam(const std::string &name) const;

        Int2DParam *fetchInt2DParam(const std::string &name) const;

        Int3DParam *fetchInt3DParam(const std::string &name) const;
    
        DoubleParam *fetchDoubleParam(const std::string &name) const;

        Double2DParam *fetchDouble2DParam(const std::string &name) const;

        Double3DParam *fetchDouble3DParam(const std::string &name) const;
    
        StringParam *fetchStringParam(const std::string &name) const;

        RGBAParam *fetchRGBAParam(const std::string &name) const;

        RGBParam *fetchRGBParam(const std::string &name) const;

        BooleanParam *fetchBooleanParam(const std::string &name) const;

        ChoiceParam *fetchChoiceParam(const std::string &name) const;

        GroupParam *fetchGroupParam(const std::string &name) const;

        PageParam *fetchPageParam(const std::string &name) const;

        PushButtonParam *fetchPushButtonParam(const std::string &name) const;

        CustomParam *fetchCustomParam(const std::string &name) const;
    };

};

// undeclare the protected assign and CC macro
#undef mDeclareProtectedAssignAndCC

#endif

---