hdicoreLayer.h

Go to the documentation of this file.

#ifndef __HDI_CORE_LAYER__
#define __HDI_CORE_LAYER__

#include "hdicoreTypes.h"
#include "hdicoreColor.h"

namespace hdi
{
    namespace plugin
    {
        class Layer;
    }

    namespace core
    {
        class Art;

        class Layer
        {
            public:
                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::auto_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::auto_ptr<Iterator> IteratorAP;

                Layer();
            
                Layer(const Layer& layer_);
                
                Layer(const AILayerHandle aiLayer_);

                Layer(const PaintOrder order_, const Layer* const prep_ = NULL);

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

                virtual AILayerHandle aiLayerHandle() const;

                virtual bool isEmpty() const;

                virtual bool dispose();

                virtual bool editable() const;

                virtual void setEditable(const bool editable_);

                virtual bool locked() const;

                virtual void setLocked(const bool locked_);

                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 std::auto_ptr<Art> group() const;

                virtual bool active() const;

                virtual bool hasArt() const;

                virtual bool hasSelectedArt() const;

                virtual void deselectArt() const;

                virtual Color color() const;

                virtual void setColor(const Color& color_);

                virtual std::auto_ptr<Layer> parent() const;

                virtual std::auto_ptr<Layer> firstChild() const;

                virtual std::auto_ptr<Layer> sibling() const;

                virtual std::auto_ptr<Layer> priorSibling() const;

                virtual std::auto_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();
                
                virtual bool operator==(const Layer& rhs_) const;
                
                virtual bool operator!=(const Layer& rhs_) const;

                virtual bool valid() const;

                Iterator begin() const;


            private:
                friend class CurrentDocument;

                friend plugin::Layer* __accessImpl(const Layer&);
                friend Layer __accessCtor(plugin::Layer*&);

                void* __data;
                
                void* __impl() const;

                Layer(plugin::Layer*&);
        };
        
        typedef std::auto_ptr<Layer> LayerAP;

        extern plugin::Layer* __accessImpl(const Layer&);
        extern Layer __accessCtor(plugin::Layer*&);
    }
}

#endif
// __HDI_CORE_LAYER__