hdicoreaiEntry.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_AI_ENTRY__
#define __HDI_CORE_AI_ENTRY__
 
#if defined(HDI_CORE_AIP_MODE)
 
#include "hdicoreTypes.h"
 
namespace hdi
{
    namespace aip
    {
        class IllustratorEntry;
    }
 
    namespace core
    {
        class Art;
        class UID;
 
        namespace ai
        {
            class Array;
            class Dictionary;
 
            class Entry
            {
                public:
                    enum Type
                    {
                        UnknownType             = 0,
                        BoolType                = 10,
                        IntType                 = 20,
                        FloatType               = 30,
                        StringType              = 40,
                        BinaryType              = 50,   // Reserved for future use
                        DictionaryType          = 60,
                        ArrayType               = 70,
                        AngleType               = 80,   // Reserved for future use
                        ArtboardPointType       = 90,   // Reserved for future use
                        ArtboardRectType        = 100,  // Reserved for future use
                        ArtboardSegPointType    = 110,  // Reserved for future use
                        ArtColorType            = 120,  // Reserved for future use
                        ArtStyleType            = 130,  // Reserved for future use
                        BezierType              = 140,  // Reserved for future use
                        ColorType               = 150,  // Reserved for future use
                        DashStyleType           = 160,  // Reserved for future use
                        DashStyleMapType        = 170,  // Reserved for future use
                        FillStyleType           = 180,  // Reserved for future use
                        FillStyleMapType        = 190,  // Reserved for future use
                        FontType                = 200,  // Reserved for future use
                        HitDataType             = 210,  // Reserved for future use
                        PathStyleType           = 220,  // Reserved for future use
                        PathStyleMapType        = 230,  // Reserved for future use
                        PointType               = 240,  // Reserved for future use
                        RectType                = 250,  // Reserved for future use
                        SegPointType            = 260,  // Reserved for future use
                        SizeType                = 270,  // Reserved for future use
                        StrokeStyleType         = 280,  // Reserved for future use
                        StrokeStyleMapType      = 290,  // Reserved for future use
                        TransformMatrixType     = 300,  // Reserved for future use
                        UIDType                 = 310,
                        ArtType                 = UIDType
                    };
            
                    Entry();
 
                    Entry(const Entry& e_);
                
                    Entry(const AIEntryRef aiEntry_);
 
                    virtual ~Entry();
            
                    virtual Entry& operator=(const Entry& rhs_);
                
                    virtual bool operator==(const Entry& rhs_) const;
                    
                    virtual bool operator!=(const Entry& rhs_) const;
 
                    virtual bool isEmpty() const;
 
                    virtual AIEntryRef aiEntryRef() const;
 
                    virtual Type entryType() const;
 
                    virtual bool asArray(Array& array__) const;
 
                    virtual bool asBool(bool& value__) const;
 
                    virtual bool asDict(Dictionary& dict__) const;
 
                    virtual bool asInt(int64_t& value__) const;
 
                    virtual bool asFloat(double& value__) const;
 
                    virtual bool asString(std::string& value__) const;
 
                    virtual bool asUID(UID& uid__) const;
 
                    virtual bool asArt(Art& art__) const;
 
                    static Entry FromArray(const Array& value_);
 
                    static Entry FromBool(const bool value_);
 
                    static Entry FromDict(const Dictionary& value_);
 
                    static Entry FromInt(const int64_t value_);
 
                    static Entry FromFloat(const double value_);
 
                    static Entry FromString(const std::string& value_);
 
                    static Entry FromUID(const UID& value_);
 
                    static Entry FromArt(const Art& value_);
 
 
                private:
                    friend aip::IllustratorEntry* __accessImpl(const Entry&);
                    friend Entry __accessCtor(const aip::IllustratorEntry&);
 
                    aip::IllustratorEntry* __impl;
 
                    Entry(const aip::IllustratorEntry&);
            };
            
            typedef std::unique_ptr<Entry> EntryUP;
            typedef std::shared_ptr<Entry> EntrySP;
            typedef std::weak_ptr<Entry> EntryWP;
            
            extern aip::IllustratorEntry* __accessImpl(const Entry&);
            extern Entry __accessCtor(const aip::IllustratorEntry&);
        }
    }
}
 
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_AI_ENTRY__