hdicoreDocument.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_DOCUMENT__
#define __HDI_CORE_DOCUMENT__
 
#include "hdicorePoint.h"
#include "hdicoreSize.h"
#include "hdicoreTypes.h"
 
namespace hdi
{
    #if defined(HDI_CORE_AIP_MODE)
        namespace aip
        {
            class Document;
        }
    #elif defined(HDI_CORE_PSP_MODE)
        namespace psp
        {
            class Document;
        }
    #endif
    
    namespace core
    {
        class Layer;
    
        #if defined(HDI_CORE_AIP_MODE)
            class ArtStyle;
            class Symbol;
        #elif defined(HDI_CORE_PSP_MODE)
            class XMPMeta;
        #endif
    
        class Document
        {
            public:
                #if defined(HDI_CORE_AIP_MODE)
                    class Preset
                    {
                        public:
                            enum PreviewMode
                            {
                                PreviewModeDefault      = 10,
                                PreviewModePixel        = 20,
                                PreviewModeOverprint    = 30
                            };
 
                            enum TransparencyGrid
                            {
                                TransparencyGridNone        = 0,
                                TransparencyGridLightGray   = 10,
                                TransparencyGridGray        = 20,
                                TransparencyGridDarkGray    = 30,
                                TransparencyGridRed         = 40,
                                TransparencyGridOrange      = 50,
                                TransparencyGridGreen       = 60,
                                TransparencyGridBlue        = 70,
                                TransparencyGridPurple      = 80
                            };
 
                            enum RasterResolution
                            {
                                RasterResolutionScreen  = 10,   // 72 ppi
                                RasterResolutionMedium  = 20,   // 150 ppi
                                RasterResolutionHigh    = 30    // 300 ppi
                            };
 
                            enum ArtboardLayout
                            {
                                ArtboardLayoutColumn            = 10,
                                ArtboardLayoutRowLR             = 20,
                                ArtboardLayoutRowRL             = 30,
                                ArtboardLayoutGridByRowLR       = 40,
                                ArtboardLayoutGridByColumnLR    = 50,
                                ArtboardLayoutGridByRowRL       = 60,
                                ArtboardLayoutGridByColumnRL    = 70
                            };
 
                            static const uint32_t maxArtboardCount = 1000;
                        
                            std::string title;
                            
                            Size size;
                            
                            uint32_t artboardCount;
 
                            ArtboardLayout artboardLayout;
                            
                            double artboardSpacing;
 
                            uint32_t artboardRowOrColumnSize;
 
                            DocumentColorModel colorModel;
 
                            RulerUnits rulerUnits;
 
                            PreviewMode previewMode;
 
                            TransparencyGrid transparencyGrid;
 
                            RasterResolution rasterResolution;
                            
                            Preset();
                            
                            virtual ~Preset();
                    };
                #endif
                // HDI_CORE_AIP_MODE
 
                Document();
 
                Document(const Document& doc_);
                
                #if defined(HDI_CORE_AIP_MODE)
                    Document(const AIDocumentHandle aiDoc_);
 
                    Document(const std::string& preset_, const bool showDialog_);
 
                    Document(const Preset& preset_, const bool showDialog_);
                #elif defined(HDI_CORE_PSP_MODE)
                    Document(const int32_t psDoc_);
                #endif
 
                virtual ~Document();
            
                virtual Document& operator=(const Document& rhs_);
 
                #if defined(HDI_CORE_AIP_MODE)
                    virtual AIDocumentHandle aiDocumentHandle() const;
                #elif defined(HDI_CORE_PSP_MODE)
                    virtual int32_t psDocumentID() const;
                #endif
 
                virtual bool isEmpty() const;
 
                virtual void save() const;
 
                virtual void close() const;
 
                virtual void activate() const;
 
                virtual void print(const bool showDialog_) const;
 
                virtual std::string url() const;
 
                virtual bool exists() const;
            
                virtual bool operator==(const Document& rhs_) const;
            
                virtual bool operator!=(const Document& rhs_) const;
                
                #if defined(HDI_CORE_AIP_MODE)
                    uint32_t artStyleCount() const;
                    
                    std::unique_ptr<ArtStyle> artStyleAtIndex(const uint32_t index_) const;
                    
                    uint32_t symbolDefCount() const;
                    
                    std::unique_ptr<Symbol> symbolDefAtIndex(const uint32_t index_) const;
                #endif
                // HDI_CORE_AIP_MODE
            
                #if defined(HDI_CORE_PSP_MODE)
                    virtual Point center() const;
                
                    virtual Size dimensions() const;
                
                    virtual void setDimensions(const Size& s_, const ImageInterpolation ii_);
                
                    virtual ColorSpace colorSpace() const;
                
                    virtual void setColorSpace(const ColorSpace cs_, const bool ml_);
                
                    virtual double resolution() const;
                
                    virtual void setResolution(const double res_, const ImageInterpolation ii_);
 
                    virtual int16_t depth() const;
 
                    virtual void setDepth(const int16_t d_);
 
                    virtual Point rulerOrigin() const;
            
                    virtual bool smartGuidesVisible() const;
            
                    virtual bool guidesVisible() const;
        
                    virtual bool rulersVisible() const;
            
                    virtual bool hasBackgroundLayer() const;
 
                    virtual std::unique_ptr<Layer> backgroundLayer() const;
                
                    virtual double zoomLevel() const;
                
                    virtual double pixelScaleFactor() const;
                
                    virtual std::string colorProfile() const;
 
                    virtual std::string formatName() const;
 
                    virtual uint32_t layerCount() const;
 
                    virtual std::unique_ptr<Layer> firstLayer() const;
 
                    virtual std::unique_ptr<Layer> lastLayer() const;
 
                    virtual std::unique_ptr<Layer> layerByTitle(const std::string& title_) const;
 
                    virtual std::unique_ptr<Layer> layerAtIndex(const uint32_t index_) const;
 
                    virtual std::unique_ptr<Layer> insertLayer(const uint32_t pos_);
 
                    virtual std::unique_ptr<Layer> currentLayer();
 
                    virtual void setCurrentLayer(const Layer& layer_);
            
                    virtual uint32_t channelCount() const;
            
                    virtual std::string channelName(const uint32_t ci_) const;
            
                    virtual bool channelVisible(const uint32_t ci_) const;
            
                    virtual void setCurrentChannel(const uint32_t ci_);
            
                    virtual std::unique_ptr<XMPMeta> getXMP() const;
            
                    virtual void setXMP(const XMPMeta& xmp_);
                #endif
                // HDI_CORE_PSP_MODE
 
 
            private:
                #if defined(HDI_CORE_AIP_MODE)
                    friend aip::Document* __accessImpl(const Document&);
                    friend Document __accessCtor(aip::Document*&);
                    
                    Document(aip::Document*&);
                #elif defined(HDI_CORE_PSP_MODE)
                    friend psp::Document* __accessImpl(const Document&);
                    friend Document __accessCtor(psp::Document*&);
                    
                    Document(psp::Document*&);
                #endif
 
                void* __data;
                
                void* __impl() const;
        };
        
        typedef std::unique_ptr<Document> DocumentUP;
        typedef std::shared_ptr<Document> DocumentSP;
        typedef std::weak_ptr<Document> DocumentWP;
        
        #if defined(HDI_CORE_AIP_MODE)
            extern aip::Document* __accessImpl(const Document&);
            extern Document __accessCtor(aip::Document*&);
        #elif defined(HDI_CORE_PSP_MODE)
            extern psp::Document* __accessImpl(const Document&);
            extern Document __accessCtor(psp::Document*&);
        #endif
    }
}
 
#endif
// __HDI_CORE_DOCUMENT__