hdicoreArt.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_ART__
#define __HDI_CORE_ART__
 
#if defined(HDI_CORE_AIP_MODE)
 
#include "hdicoreArtboardRect.h"
#include "hdicoreTypes.h"
 
namespace hdi
{
    namespace aip
    {
        class Art;
    }
 
    namespace core
    {
        namespace ai
        {
            class Dictionary;
        }
        
        class Artboard;
        class ArtStyle;
        class CustomArt;
        class Layer;
        class MaskArt;
        class MeshArt;
        class PathArt;
        class Pattern;
        class PlacedArt;
        class RasterArt;
        class Symbol;
        class TextArt;
        class UID;
    
        class Art
        {
            public:
                typedef std::vector< std::shared_ptr<Artboard> > ArtboardVector;
                typedef std::vector< std::shared_ptr<Art> > ArtVector;
                typedef std::vector<MatchArtSpec> MatchArtSpecVector;
            
                enum BoundsOptions
                {
                    // Includes hidden and unpainted objects if they are not guides. Ignores direction handles.
                    VisibleBounds                   = 1 << 0,
                    
                    // When off, NoStrokeBounds, NoExtendedBounds, and ExcludeUnpaintedObjectBounds can be combined to
                    // ignore certain aspects of the visual bounds.
                    ControlBounds                   = 1 << 1,
                    
                    // Strokes, effects, and other appearance attributes that may make an object extend past the bezier
                    // outlines are ignored.
                    NoStrokeBounds                  = 1 << 2,
                    
                    // Implies NoStrokeBounds, but additionally excludes text characters for text on a path or area
                    // text, measuring only the path.
                    NoExtendedBounds                = 1 << 3,
                    
                    // Use the setting of the "Use Preview Bounds" user preference to control whether the strokes and
                    // other appearance attributes are included. Cannot be used with NoStrokeBounds (NoStrokeBounds will
                    // take precedence).
                    StrokeDependsOnPref             = 1 << 4,
                    
                    // Exclude hidden objects. Can be set with ControlBounds or VisibleBounds.
                    ExcludeHiddenObjectBounds       = 1 << 5,
                    
                    // Excludes objects with no fill and no stroke.
                    ExcludeUnpaintedObjectBounds    = 1 << 6,
                    
                    // Excludes guides. Can be set with ControlBounds or VisibleBounds.
                    ExcludeGuideBounds              = 1 << 7
                };
                
                enum ExpandOptions
                {
                    ExpandPluginArt         = 1 << 0,
                    ExpandText              = 1 << 1,
                    ExpandStroke            = 1 << 2,
                    ExpandPattern           = 1 << 3,
                    ExpandGradientToMesh    = 1 << 4,
                    ExpandGradientToPaths   = 1 << 5,
                    ExpandSymbolInstances   = 1 << 6,
                    ExpandOneAtATime        = 1 << 7,
                    ExpandShowProgressBar   = 1 << 8,
                    ExpandLockedObjects     = 1 << 9
                };
                
                enum TransformOptions
                {
                    // No transform
                    TransformOptionNone             = 0,
                    
                    // Apply transform to art objects (almost always used)
                    TransformOptionObjects          = 1 << 0,
                    
                    // Apply transform to gradient fills
                    TransformOptionFillGradients    = 1 << 1,
                    
                    // Apply transform to pattern fills
                    TransformOptionFillPatterns     = 1 << 2,
                    
                    // Apply transform to gradient strokes
                    TransformOptionStrokeGradients  = 1 << 3,
                    
                    // Apply transform to pattern strokes
                    TransformOptionStrokePatterns   = 1 << 4,
                    
                    // Apply transform to any opacity masks (if they are set as linked)
                    TransformOptionLinkedMasks      = 1 << 5,
                    
                    // Apply the transformation recursively
                    TransformOptionChildren         = 1 << 6,
                    
                    // Apply the transformation only to selected segments of path art
                    TransformOptionSelectedSegsOnly = 1 << 7
                };
 
                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<Art> art() const;
 
 
                    private:
                        // Only Art can construct a new Iterator object
                        friend class Art;
 
                        void* __data;
                
                        Iterator();
                    
                        explicit Iterator(const Art& art_);
                };
        
                typedef std::unique_ptr<Iterator> IteratorUP;
                typedef std::shared_ptr<Iterator> IteratorSP;
                typedef std::weak_ptr<Iterator> IteratorWP;
            
                Art();
            
                Art(const Art& art_);
                
                Art(const AIArtHandle aiArt_);
                
                Art(const AISafeArtHandle aiArt_);
        
                Art(const std::string& uuid_);
 
                Art(const ArtType type_, const PaintOrder order_, const Art* const prep_ = NULL);
                
                Art(
                    const ArtboardPoint& anchor_,
                    const TextOrientation dir_,
                    const PaintOrder order_,
                    const Art* const prep_ = NULL
                );
 
                virtual ~Art();
                
                virtual Art& operator=(const Art& rhs_);
 
                virtual bool dispose();
 
                virtual bool disposeChildren();
 
                virtual std::unique_ptr<Art> duplicate(const PaintOrder order_, const Art* const prep_ = NULL) const;
 
                virtual AIArtHandle aiArtHandle() const;
                
                virtual AISafeArtHandle aiSafeArtHandle() const;
        
                virtual std::string uuid() const;
 
                virtual bool isEmpty() const;
                
                virtual bool valid() const;
                
                virtual bool operator==(const Art& rhs_) const;
                
                virtual bool operator!=(const Art& rhs_) const;
 
                virtual ArtType artType() const;
                
                virtual std::unique_ptr<UID> uid() const;
 
                virtual CustomArt* const customArt() const;
 
                virtual MaskArt* const mask() const;
 
                virtual MeshArt* const mesh() const;
 
                virtual PathArt* const path() const;
 
                virtual PlacedArt* const placed() const;
 
                virtual RasterArt* const raster() const;
 
                virtual TextArt* const text() const;
 
                virtual void markDirty();
 
                virtual void markClean();
 
                virtual void select();
 
                virtual void deselect();
                
                virtual bool selected() const;
                
                virtual bool fullySelected() const;
 
                virtual void setSelected(const bool select_);
                
                virtual bool editable() const;
 
                virtual void setEditable(const bool editable_);
                
                virtual bool locked() const;
 
                virtual void setLocked(const bool lock_);
                
                virtual bool hidden() const;
 
                virtual void setHidden(const bool hidden_);
                
                virtual bool anyAncestorSelected() const;
                
                virtual bool anyAncestorLocked() const;
                
                virtual bool anyAncestorHidden() const;
 
                virtual ArtAttribute allAttributes() const;
 
                virtual void setAllAttributes(const ArtAttribute attrs_);
 
                virtual bool attribute(const ArtAttribute attr_) const;
 
                virtual void setAttribute(const ArtAttribute attr_, const bool enable_);
 
                virtual std::unique_ptr<ai::Dictionary> dictionary() const;
 
                virtual ArtboardRect strokeBounds() const;
 
                virtual ArtboardRect noStrokeBounds() const;
 
                virtual ArtboardRect bounds(const BoundsOptions opts_) const;
 
                virtual void updateBounds();
 
                virtual ArtboardRect transformBounds(const TransformMatrix& transform_, const BoundsOptions opts_) const;
 
                virtual bool updateLinks(const bool force_ = false);
 
                virtual double x() const;
 
                virtual double y() const;
 
                virtual double width() const;
 
                virtual double height() const;
 
                virtual double perimeter() const;
 
                virtual double area() const;
 
                virtual bool centerPointVisible() const;
 
                virtual void setCenterPointVisible(const bool visible_);
 
                virtual std::unique_ptr<Artboard> artboard() const;
                
                virtual ArtboardVector allArtboards() const;
 
                virtual std::unique_ptr<Layer> layer() const;
 
                virtual uint32_t childCount() const;
 
                virtual std::unique_ptr<Art> parent() const;
 
                virtual std::unique_ptr<Art> firstChild() const;
 
                virtual std::unique_ptr<Art> lastChild() const;
 
                virtual std::unique_ptr<Art> sibling() const;
 
                virtual std::unique_ptr<Art> priorSibling() const;
 
                virtual std::unique_ptr<Symbol> symbol() const;
                
                virtual bool setSymbol(const Symbol& sym_);
                
                virtual ArtVector matchingChildren(const MatchArtSpecVector& specs_) const;
 
                virtual bool hasFill() const;
 
                virtual bool hasStroke() const;
 
                virtual bool isLayerGroup() const;
                
                virtual bool isClipGroup() const;
            
                virtual void setIsClipGroup(const bool clip_);
 
                virtual bool isDimension() const;
 
                virtual std::unique_ptr<ArtStyle> style() const;
 
                virtual void setStyle(const ArtStyle& style_);
 
                virtual bool isStyled() const;
 
                virtual std::unique_ptr<Art> styledArt() const;
 
                virtual void flattenStyledArt();
 
                virtual BlendMode blendMode() const;
 
                virtual void setBlendMode(const BlendMode mode_);
 
                virtual double opacity() const;
                
                virtual void setOpacity(const double o_);
 
                virtual BlendKnockout knockout() const;
 
                virtual BlendKnockout inheritedKnockout() const;
 
                virtual void setKnockout(const BlendKnockout ko_);
 
                virtual void reorder(const PaintOrder order_, const Art* const prep_ = NULL);
 
                virtual void expand(const ExpandOptions opts_, const uint32_t steps_);
 
                virtual void rotate(const Angle& angle_, const bool deep_ = false);
 
                virtual void rotate(const Angle& angle_, const BoundsPinPointType pinPt_, const bool deep_ = false);
 
                virtual void rotate(const Angle& angle_, const ArtboardPoint& origin_, const bool deep_ = false);
 
                virtual void scale(const double scaler_, const bool deep_ = false);
 
                virtual void scale(const double scaler_, const BoundsPinPointType pinPt_, const bool deep_ = false);
 
                virtual void scale(const double scaler_, const ArtboardPoint& origin_, const bool deep_ = false);
 
                virtual void scale(const double xScaler_, const double yScaler_, const bool deep_ = false);
 
                virtual void scale(
                    const double xScaler_,
                    const double yScaler_,
                    const BoundsPinPointType pinPt_,
                    const bool deep_ = false
                );
 
                virtual void scale(
                    const double xScaler_,
                    const double yScaler_,
                    const ArtboardPoint& origin_,
                    const bool deep_ = false
                );
 
                virtual void offset(const double x_, const double y_, const bool deep_ = false);
 
                virtual void move(
                    const ArtboardPoint& newOrigin_,
                    const BoundsPinPointType pinPt_,
                    const bool deep_ = false
                );
 
                virtual void move(
                    const ArtboardPoint& newOrigin_,
                    const ArtboardPoint& origin_,
                    const bool deep_ = false
                );
 
                virtual void transform(const TransformMatrix& matrix_, const bool deep_ = false);
 
                virtual void transformWithOptions(const TransformMatrix& matrix_, const TransformOptions options_);
 
                virtual void transformStrokes(const double scaler_, const bool children_);
 
                virtual bool canIsolate() const;
 
                virtual bool isIsolated() const;
 
                virtual bool isolate(const bool hideOtherArt_);
 
                Iterator begin() const;
 
 
            private:
                friend aip::Art* __accessImpl(const Art&);
                friend Art __accessCtor(aip::Art*&);
 
                void* __data;
                
                void* __impl() const;
 
                Art(aip::Art*&);
        };
        
        typedef std::unique_ptr<Art> ArtUP;
        typedef std::shared_ptr<Art> ArtSP;
        typedef std::weak_ptr<Art> ArtWP;
        
        extern aip::Art* __accessImpl(const Art&);
        extern Art __accessCtor(aip::Art*&);
    }
}
 
hdi::core::Art::BoundsOptions operator|(
    const hdi::core::Art::BoundsOptions lhs_,
    const hdi::core::Art::BoundsOptions rhs_
);
 
hdi::core::Art::BoundsOptions& operator|=(
    hdi::core::Art::BoundsOptions& lhs__,
    const hdi::core::Art::BoundsOptions rhs_
);
 
hdi::core::Art::ExpandOptions operator|(
    const hdi::core::Art::ExpandOptions lhs_,
    const hdi::core::Art::ExpandOptions rhs_
);
 
hdi::core::Art::ExpandOptions& operator|=(
    hdi::core::Art::ExpandOptions& lhs__,
    const hdi::core::Art::ExpandOptions rhs_
);
 
hdi::core::Art::TransformOptions operator|(
    const hdi::core::Art::TransformOptions lhs_,
    const hdi::core::Art::TransformOptions rhs_
);
 
hdi::core::Art::TransformOptions& operator|=(
    hdi::core::Art::TransformOptions& lhs__,
    const hdi::core::Art::TransformOptions rhs_
);
 
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_ART__