hdicoreLayer.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_LAYER__
#define __HDI_CORE_LAYER__
 
#include "hdicoreTypes.h"
#include "hdicoreColor.h"
#include "hdicoreRect.h"
 
namespace hdi
{
    #if defined(HDI_CORE_AIP_MODE)
        namespace aip
        {
            class Layer;
        }
    #elif defined(HDI_CORE_PSP_MODE)
        namespace psp
        {
            class Layer;
        }
    #endif
 
    namespace core
    {
        #if defined(HDI_CORE_AIP_MODE)
            class Art;
            class Artboard;
        #endif
 
        class Layer
        {
            public:
                #if defined(HDI_CORE_AIP_MODE)
                    class Iterator
                    {
                        public:
                            Iterator(const Iterator& iter_);
                        
                            ~Iterator();
                            
                            Iterator& operator=(const Iterator& rhs_);
                            
                            bool operator==(const Iterator& rhs_) const;
                            
                            bool operator!=(const Iterator& rhs_) const;
 
                            Iterator& operator++();
 
                            Iterator operator++(int);
 
                            Iterator& operator--();
 
                            Iterator operator--(int);
 
                            bool atEnd() const;
 
                            std::unique_ptr<Layer> layer() const;
 
 
                        private:
                            // Only Layer can construct a new Iterator object
                            friend class Layer;
 
                            void* __data;
                    
                            Iterator();
                        
                            explicit Iterator(const Layer& layer_);
                    };
            
                    typedef std::unique_ptr<Iterator> IteratorUP;
                    typedef std::shared_ptr<Iterator> IteratorSP;
                    typedef std::weak_ptr<Iterator> IteratorWP;
            
                    typedef Color ColorType;
                #endif
                // HDI_CORE_AIP_MODE
            
                #if defined(HDI_CORE_PSP_MODE)
                    enum ColorType
                    {
                        ColorTypeUnknown    = 0,
                        ColorTypeNone       = 10,
                        ColorTypeRed        = 20,
                        ColorTypeOrange     = 30,
                        ColorTypeYellow     = 40,
                        ColorTypeGreen      = 50,
                        ColorTypeBlue       = 60,
                        ColorTypeViolet     = 70,
                        ColorTypeGray       = 80
                    };
                
                    enum LockingState
                    {
                        LockingStateNone                = 0,
                        LockingStateArtboardAutonest    = 1 << 0,
                        LockingStateComposite           = 1 << 1,
                        LockingStatePosition            = 1 << 2,
                        LockingStateTransparency        = 1 << 3,
                        LockingStateAll                 = 0xffffffff
                    };
                #endif
                // HDI_CORE_PSP_MODE
 
                Layer();
            
                Layer(const Layer& layer_);
                
                #if defined(HDI_CORE_AIP_MODE)
                    Layer(const AILayerHandle aiLayer_);
 
                    Layer(const PaintOrder order_, const Layer* const prep_ = NULL);
                #elif defined(HDI_CORE_PSP_MODE)
                    Layer(const int32_t psLayer_);
                #endif
 
                virtual ~Layer();
                
                virtual Layer& operator=(const Layer& rhs_);
 
                #if defined(HDI_CORE_AIP_MODE)
                    virtual AILayerHandle aiLayerHandle() const;
                #elif defined(HDI_CORE_PSP_MODE)
                    virtual int32_t psLayerID() const;
                #endif
 
                virtual bool isEmpty() const;
 
                virtual bool dispose();
 
                #if defined(HDI_CORE_AIP_MODE)
                    virtual bool editable() const;
 
                    virtual void setEditable(const bool editable_);
 
                    virtual bool locked() const;
 
                    virtual void setLocked(const bool locked_);
 
                    virtual bool hasArt() const;
 
                    virtual bool hasSelectedArt() const;
 
                    virtual void deselectArt() const;
 
                    virtual std::unique_ptr<Art> group() const;
 
                    virtual std::unique_ptr<Layer> parent() const;
 
                    virtual std::unique_ptr<Layer> firstChild() const;
 
                    virtual std::unique_ptr<Layer> sibling() const;
 
                    virtual std::unique_ptr<Layer> priorSibling() const;
 
                    virtual std::unique_ptr<Layer> nextPreorderLayer() const;
 
                    virtual bool preview() const;
 
                    virtual void setPreview(const bool preview_);
 
                    virtual bool printed() const;
 
                    virtual void setPrinted(const bool printed_);
 
                    virtual bool dimsPlacedImages() const;
                    
                    virtual void setDimsPlacedImages(const bool dim_);
                
                    virtual bool convertToGroup();
 
                    Iterator begin() const;
                #endif
                // HDI_CORE_AIP_MODE
            
                #if defined(HDI_CORE_PSP_MODE)
                    virtual LockingState locked() const;
 
                    virtual void setLocked(const LockingState locked_);
 
                    virtual bool background() const;
 
                    virtual bool fxVisible() const;
 
                    virtual void setFXVisible(const bool visible_);
 
                    virtual double opacity() const;
 
                    virtual void setOpacity(const double o_);
 
                    virtual bool preserveTransparency() const;
 
                    virtual void setPreserveTransparency(const bool pres_);
 
                    virtual BlendMode blendMode() const;
                
                    virtual void setBlendMode(const BlendMode bm_);
            
                    virtual Rect bounds() const;
                
                    virtual Rect boundsNoEffects() const;
                    
                    virtual Rect boundsNoMask() const;
                #endif
                // HDI_CORE_PSP_MODE
 
                virtual std::string name() const;
 
                virtual void setName(const std::string& name_);
 
                virtual void show();
 
                virtual void hide();
 
                virtual bool visible() const;
 
                virtual void setVisible(const bool visible_);
 
                virtual bool active() const;
 
                virtual ColorType color() const;
 
                virtual void setColor(const ColorType color_);
                
                virtual bool operator==(const Layer& rhs_) const;
                
                virtual bool operator!=(const Layer& rhs_) const;
 
                virtual bool valid() const;
 
 
            private:
                #if defined(HDI_CORE_AIP_MODE)
                    friend class CurrentDocument;
                    
                    friend aip::Layer* __accessImpl(const Layer&);
                    friend Layer __accessCtor(aip::Layer*&);
 
                    Layer(aip::Layer*&);
                #elif defined(HDI_CORE_PSP_MODE)
                    friend class Document;
                    
                    friend psp::Layer* __accessImpl(const Layer&);
                    friend Layer __accessCtor(psp::Layer*&);
 
                    Layer(psp::Layer*&);
                #endif
 
                void* __data;
                
                void* __impl() const;
        };
        
        typedef std::unique_ptr<Layer> LayerUP;
        typedef std::shared_ptr<Layer> LayerSP;
        typedef std::weak_ptr<Layer> LayerWP;
 
        #if defined(HDI_CORE_AIP_MODE)
            extern aip::Layer* __accessImpl(const Layer&);
            extern Layer __accessCtor(aip::Layer*&);
        #elif defined(HDI_CORE_PSP_MODE)
            extern psp::Layer* __accessImpl(const Layer&);
            extern Layer __accessCtor(psp::Layer*&);
        #endif
    }
}
 
#if defined(HDI_CORE_PSP_MODE)
    hdi::core::Layer::LockingState operator|(
        const hdi::core::Layer::LockingState lhs_,
        const hdi::core::Layer::LockingState rhs_
    );
 
    hdi::core::Layer::LockingState& operator|=(
        hdi::core::Layer::LockingState& lhs__,
        const hdi::core::Layer::LockingState rhs_
    );
#endif
// HDI_CORE_PSP_MODE
 
#endif
// __HDI_CORE_LAYER__