hdicoreGradient.h

Go to the documentation of this file.

#ifndef __HDI_CORE_GRADIENT__
#define __HDI_CORE_GRADIENT__

#include "hdicoreArtColor.h"

namespace hdi
{
    namespace plugin
    {
        class Gradient;
    }

    namespace core
    {
        class Gradient
        {
            public:
                enum Type
                {
                    UnknownGradientType = 0,
                    LinearGradientType  = 10,
                    RadialGradientType  = 20
                };
                
                class Stop
                {
                    public:
                        double midPoint;
                        
                        double rampPoint;
                        
                        ArtColor color;
                        
                        double opacity;
                        
                        Stop();
                        
                        Stop(const Stop& s_);
                        
                        Stop(
                            const double midPt_,
                            const double rampPt_,
                            const ArtColor& color_,
                            const double opacity_
                        );

                        virtual ~Stop();
                        
                        Stop& operator=(const Stop& rhs_);
                };
        
                typedef std::auto_ptr<Stop> StopAP;

                Gradient();
            
                Gradient(const Gradient& grad_);
                
                static Gradient create();

                virtual ~Gradient();
                
                virtual Gradient& operator=(const Gradient& rhs_);

                virtual bool dispose();

                virtual AIGradientHandle aiGradientHandle() const;

                virtual bool isEmpty() const;
                
                virtual bool valid() const;
                
                virtual Type gradientType() const;
                
                virtual void setGradientType(const Type type_);
                
                virtual bool operator==(const Gradient& rhs_) const;
                
                virtual bool operator!=(const Gradient& rhs_) const;

                virtual std::string name() const;
                
                virtual void setName(const std::string& name_);
                
                virtual int16_t stopCount() const;

                virtual std::auto_ptr<Stop> stopAtIndex(const int16_t index_);

                virtual bool setStopAtIndex(const int16_t index_, const Stop& stop_);

                virtual bool insertStopAtIndex(const int16_t index_, Stop& stop__);

                virtual bool removeStopAtIndex(const int16_t index_, Stop& stop__);

                virtual bool colorAtPosition(const double tVal_, ArtColor& color__);


            protected:
                void* _data;
                
                void* _impl() const;


            private:
                friend plugin::Gradient* __accessImpl(const Gradient&);
                friend Gradient __accessCtor(plugin::Gradient*&);

                Gradient(plugin::Gradient*&);
        };
        
        typedef std::auto_ptr<Gradient> GradientAP;
        
        extern plugin::Gradient* __accessImpl(const Gradient&);
        extern Gradient __accessCtor(plugin::Gradient*&);
    }
}

#endif
// __HDI_CORE_GRADIENT__