hdicoreArtColor.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_ART_COLOR__
#define __HDI_CORE_ART_COLOR__
 
#include "hdicoreAngle.h"
#include "hdicoreSize.h"
 
#if defined(HDI_CORE_AIP_MODE)
    #include "hdicoreArtboardPoint.h"
    #include "hdicoreTransformMatrix.h"
#endif
    
namespace hdi
{
    #if defined(HDI_CORE_AIP_MODE)
        namespace aip
        {
            class ArtColor;
        }
    #endif
 
    namespace core
    {
        class Color;
        
        #if defined(HDI_CORE_AIP_MODE)
            class Gradient;
            class Pattern;
        #endif

        class ArtColor
        {
            public:
                enum Type
                {
                    TypeUnknown         = 0,
                    
                    // Basic colors
                    TypeNone            = 1 << 0,
                    TypeGray            = 1 << 1,
                    TypeRGB             = 1 << 2,
                    TypeCMYK            = 1 << 3,
                    TypeLab             = 1 << 4,
                    TypeHSB             = 1 << 5,   // Same as HSV
                    
                    #if defined(HDI_CORE_AIP_MODE)
                        // "Named" colors
                        TypeNamedRGB        = 1 << 10,
                        TypeNamedCMYK       = 1 << 11,
                        TypeNamedLab        = 1 << 12,
                    
                        // Other
                        TypePattern         = 1 << 20,
                        TypeGradient        = 1 << 21,
                    #endif
                    // HDI_CORE_AIP_MODE
                    
                    // Helpers
                    AnonymousTypes  = (TypeGray | TypeRGB | TypeCMYK | TypeLab | TypeHSB),
                    
                    #if defined(HDI_CORE_AIP_MODE)
                        NamedTypes      = (TypeNamedRGB | TypeNamedCMYK | TypeNamedLab)
                    #endif
                };
 
                #if defined(HDI_CORE_AIP_MODE)
                    enum NamedFlags
                    {
                        NoFlag                  = 0,
                        SpotColorFlag           = 1 << 0,
                        RegistrationColorFlag   = 1 << 1
                    };
                #endif
                // HDI_CORE_AIP_MODE
                
                class Channels
                {
                    public:
                        struct RGB
                        {
                            double red;
                        
                            double green;
                        
                            double blue;
                            
                            (RGB)();

                            (RGB)(const RGB& obj_);

                            (RGB)(const double r_, const double g_, const double b_);

                            virtual (~RGB)();

                            RGB& operator=(const RGB& rhs_);
                            
                            bool operator==(const RGB& rhs_) const;
                            
                            bool operator!=(const RGB& rhs_) const;
                        };
        
                        typedef std::unique_ptr<RGB> RGBUP;
                        typedef std::shared_ptr<RGB> RGBSP;
                        typedef std::weak_ptr<RGB> RGBWP;
                        
                        struct CMYK
                        {
                            double cyan;
                        
                            double magenta;
                        
                            double yellow;
                        
                            double black;
                            
                            (CMYK)();

                            (CMYK)(const CMYK& obj_);

                            (CMYK)(const double c_, const double m_, const double y_, const double k_);

                            virtual (~CMYK)();

                            CMYK& operator=(const CMYK& rhs_);
                            
                            bool operator==(const CMYK& rhs_) const;
                            
                            bool operator!=(const CMYK& rhs_) const;
                        };
        
                        typedef std::unique_ptr<CMYK> CMYKUP;
                        typedef std::shared_ptr<CMYK> CMYKSP;
                        typedef std::weak_ptr<CMYK> CMYKWP;
                    
                        struct Lab
                        {
                            double lightness;
                        
                            double a;
                        
                            double b;
                            
                            Lab();

                            Lab(const Lab& obj_);

                            Lab(const double l_, const double a_, const double b_);

                            virtual ~Lab();

                            Lab& operator=(const Lab& rhs_);
                            
                            bool operator==(const Lab& rhs_) const;
                            
                            bool operator!=(const Lab& rhs_) const;
                        };
        
                        typedef std::unique_ptr<Lab> LabUP;
                        typedef std::shared_ptr<Lab> LabSP;
                        typedef std::weak_ptr<Lab> LabWP;
                    
                        struct HSB
                        {
                            Angle hue;
                        
                            double saturation;
                        
                            double brightness;
                            
                            HSB();

                            HSB(const HSB& obj_);

                            HSB(const Angle& h_, const double s_, const double b_);

                            virtual ~HSB();

                            HSB& operator=(const HSB& rhs_);
                            
                            bool operator==(const HSB& rhs_) const;
                            
                            bool operator!=(const HSB& rhs_) const;
                        };
        
                        typedef std::unique_ptr<HSB> HSBUP;
                        typedef std::shared_ptr<HSB> HSBSP;
                        typedef std::weak_ptr<HSB> HSBWP;
                        
                        Type master;
                    
                        double gray;
                        
                        RGB rgb;
                        
                        CMYK cmyk;
                        
                        Lab lab;
                        
                        HSB hsb;

                        Channels();

                        Channels(const Channels& obj_);

                        Channels(
                            const Type master_,
                            const double gray_,
                            const RGB& rgb_,
                            const CMYK& cmyk_,
                            const Lab& lab_,
                            const HSB& hsb_
                        );

                        virtual ~Channels();

                        Channels& operator=(const Channels& rhs_);
                };
        
                typedef std::unique_ptr<Channels> ChannelsUP;
                typedef std::shared_ptr<Channels> ChannelsSP;
                typedef std::weak_ptr<Channels> ChannelsWP;
 
                #if defined(HDI_CORE_AIP_MODE)
                    class GradientStyle
                    {
                        public:
                            core::Gradient* gradient;

                            core::ArtboardPoint origin;

                            core::Angle angle;

                            double length;

                            core::TransformMatrix matrix;

                            core::Angle highlightAngle;

                            double highlightLength;

                            GradientStyle();

                            GradientStyle(const GradientStyle& grad_);

                            GradientStyle(
                                const core::Gradient& gradient_,
                                const core::ArtboardPoint& origin_,
                                const core::Angle& angle_,
                                const double length_,
                                const core::TransformMatrix& matrix_,
                                const core::Angle& hiliteAngle_,
                                const double hiliteLength_
                            );

                            virtual ~GradientStyle();

                            GradientStyle& operator=(const GradientStyle& rhs_);
                    };
            
                    typedef std::unique_ptr<GradientStyle> GradientStyleUP;
                    typedef std::shared_ptr<GradientStyle> GradientStyleSP;
                    typedef std::weak_ptr<GradientStyle> GradientStyleWP;

                    class PatternStyle
                    {
                        public:
                            core::Pattern* pattern;

                            double shiftDistance;

                            core::Angle shiftAngle;

                            double scaleX;

                            double scaleY;

                            core::Angle rotation;

                            bool reflect;

                            core::Angle reflectAngle;

                            core::Angle shearAngle;

                            core::Angle shearAxis;

                            core::TransformMatrix transform;

                            PatternStyle();

                            PatternStyle(const PatternStyle& patt_);

                            PatternStyle(
                                const core::Pattern& pattern_,
                                const double shiftDist_,
                                const core::Angle& shiftAngle_,
                                const double scaleX_,
                                const double scaleY_,
                                const core::Angle& rotation_,
                                const bool reflect_,
                                const core::Angle& reflectAngle_,
                                const core::Angle& shearAngle_,
                                const core::Angle& shearAxis_,
                                const core::TransformMatrix& transform_
                            );

                            virtual ~PatternStyle();

                            PatternStyle& operator=(const PatternStyle& rhs_);
                    };
            
                    typedef std::unique_ptr<PatternStyle> PatternStyleUP;
                    typedef std::shared_ptr<PatternStyle> PatternStyleSP;
                    typedef std::weak_ptr<PatternStyle> PatternStyleWP;
                #endif
                // HDI_CORE_AIP_MODE

                ArtColor(const ArtColor& c_);

                ArtColor(const Color& c_);

                ArtColor(const double grayVal_);

                ArtColor(const double rVal_, const double gVal_, const double bVal_);

                ArtColor(const double cVal_, const double mVal_, const double yVal_, const double kVal_);
            
                #if defined(HDI_CORE_AIP_MODE)
                    ArtColor(const GradientStyle& gs_);
                
                    ArtColor(const PatternStyle& ps_);
                #endif
                // HDI_CORE_AIP_MODE

                ArtColor();

                static ArtColor FromLab(const double lVal_, const double aVal_, const double bVal_);

                static ArtColor FromHSB(const Angle& hVal_, const double sVal_, const double bVal_);

                virtual ~ArtColor();
 
                #if defined(HDI_CORE_PSP_MODE)
                    virtual bool isEmpty() const;
                #endif
                // HDI_CORE_PSP_MODE

                virtual Type colorType() const;
 
                #if defined(HDI_CORE_AIP_MODE)
                    virtual std::string name() const;
                #endif
                // HDI_CORE_AIP_MODE

                virtual ArtColor asGray() const;

                virtual ArtColor asRGB() const;

                virtual ArtColor asLab() const;

                virtual ArtColor asHSB() const;

                virtual ArtColor asCMYK() const;

                virtual Channels channels() const;
 
                #if defined(HDI_CORE_AIP_MODE)
                    virtual GradientStyle gradient() const;

                    virtual PatternStyle pattern() const;

                    virtual bool makeNamed(
                        const std::string& name_,
                        const double tint_ = 0.0,
                        const NamedFlags flags_ = SpotColorFlag
                    );
                
                    virtual double namedTint() const;

                    virtual NamedFlags namedFlags() const;
                #endif
                // HDI_CORE_AIP_MODE

                virtual ArtColor& operator=(const ArtColor& rhs_);

                virtual bool operator==(const ArtColor& rhs_) const;

                virtual bool operator!=(const ArtColor& rhs_) const;

                static ArtColor red();

                static ArtColor orange();

                static ArtColor yellow();

                static ArtColor green();

                static ArtColor cyan();

                static ArtColor blue();

                static ArtColor purple();

                static ArtColor magenta();

                static ArtColor white();

                static ArtColor lightGray();

                static ArtColor gray();

                static ArtColor darkGray();

                static ArtColor black();

                static ArtColor none();
            
                #if defined(HDI_CORE_PSP_MODE)
                    static bool fastConvert8(
                        const Type from_,
                        const uint8_t in1_,
                        const uint8_t in2_,
                        const uint8_t in3_,
                        const uint8_t in4_,
                        const Type to_,
                        uint8_t& out1_,
                        uint8_t& out2_,
                        uint8_t& out3_,
                        uint8_t& out4_
                    );
            
                    static bool fastConvert16(
                        const Type from_,
                        const uint16_t in1_,
                        const uint16_t in2_,
                        const uint16_t in3_,
                        const uint16_t in4_,
                        const Type to_,
                        uint16_t& out1_,
                        uint16_t& out2_,
                        uint16_t& out3_,
                        uint16_t& out4_
                    );
            
                    static bool fastConvertBitmap8(
                        const Type from_,
                        const Type to_,
                        uint32_t* const bitmap__,
                        const uint32_t nPixels_
                    );
            
                    static bool fastConvertBitmap16(
                        const Type from_,
                        const Type to_,
                        uint64_t* const bitmap__,
                        const uint32_t nPixels_
                    );
                #endif
                // HDI_CORE_PSP_MODE
 
 
            private:
                #if defined(HDI_CORE_AIP_MODE)
                    friend aip::ArtColor* __accessImpl(const ArtColor&);
                    friend ArtColor __accessCtor(const aip::ArtColor&);

                    aip::ArtColor* __impl;

                    ArtColor(const aip::ArtColor&);
                #elif defined(HDI_CORE_PSP_MODE)
                    void* __impl;
                #endif
        };
        
        typedef std::unique_ptr<ArtColor> ArtColorUP;
        typedef std::shared_ptr<ArtColor> ArtColorSP;
        typedef std::weak_ptr<ArtColor> ArtColorWP;
        
        #if defined(HDI_CORE_AIP_MODE)
            extern aip::ArtColor* __accessImpl(const ArtColor&);
            extern ArtColor __accessCtor(const aip::ArtColor&);
        #endif
        // HDI_CORE_AIP_MODE
    }
}
 
#if defined(HDI_CORE_AIP_MODE)
    hdi::core::ArtColor::NamedFlags operator|(
        const hdi::core::ArtColor::NamedFlags lhs_,
        const hdi::core::ArtColor::NamedFlags rhs_
    );
 
    hdi::core::ArtColor::NamedFlags& operator|=(
        hdi::core::ArtColor::NamedFlags& lhs__,
        const hdi::core::ArtColor::NamedFlags rhs_
    );
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_ART_COLOR__