hdicoreGradient.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_GRADIENT__
#define __HDI_CORE_GRADIENT__
 
#if defined(HDI_CORE_AIP_MODE)
 
#include "hdicoreArtColor.h"
 
namespace hdi
{
    namespace aip
    {
        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::unique_ptr<Stop> StopUP;
                typedef std::shared_ptr<Stop> StopSP;
                typedef std::weak_ptr<Stop> StopWP;
 
                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::unique_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 aip::Gradient* __accessImpl(const Gradient&);
                friend Gradient __accessCtor(aip::Gradient*&);
 
                Gradient(aip::Gradient*&);
        };
        
        typedef std::unique_ptr<Gradient> GradientUP;
        typedef std::shared_ptr<Gradient> GradientSP;
        typedef std::weak_ptr<Gradient> GradientWP;
        
        extern aip::Gradient* __accessImpl(const Gradient&);
        extern Gradient __accessCtor(aip::Gradient*&);
    }
}
 
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_GRADIENT__