hdicoreArtStyle.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_ART_STYLE__
#define __HDI_CORE_ART_STYLE__
 
#if defined(HDI_CORE_AIP_MODE)
 
#include "hdicoreArtboardPoint.h"
#include "hdicoreLiveEffect.h"
#include "hdicorePathStyle.h"
#include "hdicoreTypes.h"
 
namespace hdi
{
    namespace aip
    {
        class ArtStyle;
    }
    
    namespace core
    {
        class ArtStyle
        {
            public:
                class BlendField;
                class Effect;
                class PaintField;
                
                struct PaintData
                {
                    ArtboardPoint fillRelativeGradientOrigin;
                    
                    double fillRelativeGradientLength;
                    
                    double fillGradientAspectRatio;
 
                    ArtboardPoint strokeRelativeGradientOrigin;
                    
                    double strokeRelativeGradientLength;
                    
                    double strokeGradientAspectRatio;
                    
                    PaintData();
                    
                    PaintData(const PaintData& pd_);
                    
                    virtual ~PaintData();
                    
                    PaintData& operator=(const PaintData& rhs_);
                };
        
                typedef std::unique_ptr<PaintData> PaintDataUP;
                typedef std::shared_ptr<PaintData> PaintDataSP;
                typedef std::weak_ptr<PaintData> PaintDataWP;
                
                class BlendField
                {
                    public:
                        BlendField();
                    
                        BlendField(const BlendField& bf_);
                        
                        virtual ~BlendField();
                        
                        BlendField& operator=(const BlendField& rhs_);
 
                        bool isEmpty() const;
 
                        bool isDefault() const;
                        
                        void setDefault();
                    
                        bool visible() const;
                        
                        void setVisible(const bool visible_);
                        
                        BlendMode mode() const;
 
                        void setMode(const BlendMode mode_);
 
                        double opacity() const;
                        
                        void setOpacity(const double o_);
                        
                        bool isolated() const;
                        
                        void setIsolated(const bool iso_);
 
                        BlendKnockout knockout() const;
 
                        void setKnockout(const BlendKnockout ko_);
                        
                        bool alphaIsShape() const;
                        
                        void setAlphaIsShape(const bool alpha_);
                    
 
                    private:
                        friend class ArtStyle;
                        friend class PaintField;
                    
                        void* __data;
                };
        
                typedef std::unique_ptr<BlendField> BlendFieldUP;
                typedef std::shared_ptr<BlendField> BlendFieldSP;
                typedef std::weak_ptr<BlendField> BlendFieldWP;
            
                class Effect
                {
                    public:
                        Effect();
                        
                        Effect(const Effect& e_);
                        
                        virtual ~Effect();
                        
                        Effect& operator=(const Effect& rhs_);
 
                        bool isEmpty() const;
                    
                        bool visible() const;
                        
                        void setVisible(const bool visible_);
                        
                        std::unique_ptr<LiveEffect> liveEffect() const;
 
                        void setLiveEffect(const LiveEffect& le_);
                        
                        std::unique_ptr<LiveEffect::Parameters> parameters() const;
                        
                        void setParameters(const LiveEffect::Parameters& p_);
                    
 
                    private:
                        friend class ArtStyle;
                        friend class PaintField;
                    
                        void* __data;
                };
        
                typedef std::unique_ptr<Effect> EffectUP;
                typedef std::shared_ptr<Effect> EffectSP;
                typedef std::weak_ptr<Effect> EffectWP;
                
                class PaintField
                {
                    public:
                        PaintField();
                        
                        PaintField(const PaintField& pf_);
                        
                        virtual ~PaintField();
                        
                        PaintField& operator=(const PaintField& rhs_);
 
                        bool isEmpty() const;
                        
                        bool visible() const;
                        
                        void setVisible(const bool visible_);
 
                        bool isFill() const;
                        
                        bool fill(FillStyle& fs__, PaintData& pd__);
                        
                        void setFill(const FillStyle& fs_, const PaintData& pd_);
                        
                        bool isStroke() const;
                        
                        bool stroke(StrokeStyle& ss__, PaintData& pd__);
                        
                        void setStroke(const StrokeStyle& ss_, const PaintData& pd_);
                        
                        int32_t colorPosition() const;
                        
                        void setColorPosition(const int32_t pos_);
                        
                        bool evenOdd() const;
                        
                        void setEvenOdd(const bool eo_);
                        
                        int32_t effectCount() const;
                    
                        std::unique_ptr<Effect> effectAtIndex(const int32_t index_) const;
                        
                        bool liveEffectInfo(LiveEffect& le__, LiveEffect::Parameters& p__);
                        
                        void setLiveEffectInfo(const LiveEffect& le_, const LiveEffect::Parameters& p_);
 
                        std::unique_ptr<BlendField> blend() const;
                    
 
                    private:
                        friend class ArtStyle;
                    
                        void* __data;
                };
        
                typedef std::unique_ptr<PaintField> PaintFieldUP;
                typedef std::shared_ptr<PaintField> PaintFieldSP;
                typedef std::weak_ptr<PaintField> PaintFieldWP;
            
                enum Type
                {
                    UnknownType = 0,
                    SimpleType  = 10,   // Has only one fill and one stroke
                    ActiveType  = 20    // Can have multiple fills and strokes
                };
                
                enum Attributes
                {
                    NoAttributes                    = 0,
                    HasFillAttribute                = 1 << 0,
                    HasStrokeAttribute              = 1 << 1,
                    PatternsAttribute               = 1 << 2,
                    CustomColorsAttribute           = 1 << 3,
                    FillGradientsAttribute          = 1 << 4,
                    FillRadialGradientsAttribute    = 1 << 5,
                    StrokeGradientsAttribute        = 1 << 6,
                    StrokeRadialGradientsAttribute  = 1 << 7,
                    TransparencyAttribute           = 1 << 8,
                    BrushesAttribute                = 1 << 9,
                    EffectsAttribute                = 1 << 10,
                    ScalableEffectsAttribute        = 1 << 11
                };
 
                ArtStyle();
 
                ArtStyle(const ArtStyle& a_);
                
                ArtStyle(const AIArtStyleHandle aiArtStyle_);
 
                virtual ~ArtStyle();
            
                virtual ArtStyle& operator=(const ArtStyle& rhs_);
                
                virtual bool operator==(const ArtStyle& rhs_) const;
                
                virtual bool operator!=(const ArtStyle& rhs_) const;
 
                virtual AIArtStyleHandle aiArtStyleHandle() const;
                
                virtual bool valid();
 
                virtual std::string name() const;
 
                virtual void setName(const std::string& name_);
 
                virtual bool isAnonymous() const;
 
                virtual Type styleType() const;
 
                virtual Attributes attributes() const;
                
                virtual bool visible() const;
                
                virtual bool hasFillOrStroke() const;
                
                virtual bool hasEffects() const;
                
                virtual bool hasTransparency() const;
 
                virtual int32_t paintFieldCount() const;
                
                virtual std::unique_ptr<PaintField> paintFieldAtIndex(const int32_t index_) const;
                
                virtual std::unique_ptr<PaintField> focusFill() const;
                
                virtual std::unique_ptr<PaintField> focusStroke() const;
 
                virtual int32_t preEffectCount() const;
                
                virtual std::unique_ptr<Effect> preEffectAtIndex(const int32_t index_) const;
                
                virtual int32_t postEffectCount() const;
                
                virtual std::unique_ptr<Effect> postEffectAtIndex(const int32_t index_) const;
 
                virtual std::unique_ptr<BlendField> blendField() const;
 
 
            private:
                friend aip::ArtStyle* __accessImpl(const ArtStyle&);
                friend ArtStyle __accessCtor(aip::ArtStyle*&);
 
                void* __data;
                
                void* __impl() const;
 
                ArtStyle(aip::ArtStyle*&);
        };
        
        typedef std::unique_ptr<ArtStyle> ArtStyleUP;
        typedef std::shared_ptr<ArtStyle> ArtStyleSP;
        typedef std::weak_ptr<ArtStyle> ArtStyleWP;
        
        extern aip::ArtStyle* __accessImpl(const ArtStyle&);
        extern ArtStyle __accessCtor(aip::ArtStyle*&);
    }
}
 
hdi::core::ArtStyle::Attributes operator|(
    const hdi::core::ArtStyle::Attributes lhs_,
    const hdi::core::ArtStyle::Attributes rhs_
);
 
hdi::core::ArtStyle::Attributes& operator|=(
    hdi::core::ArtStyle::Attributes& lhs__,
    const hdi::core::ArtStyle::Attributes rhs_
);
 
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_ART_STYLE__