hdicoreRasterArt.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_RASTER_ART__
#define __HDI_CORE_RASTER_ART__
 
#if defined(HDI_CORE_AIP_MODE)
 
#include "hdicoreArtboardRect.h"
#include "hdicoreTransformMatrix.h"
 
namespace hdi
{
    namespace core
    {
        class Art;
    
        class RasterArt
        {
            public:
                enum Flags
                {
                    UnknownFlag         = 0,
                    
                    // Used only for 1-bit gray images. When set, the 1-bit data is to be used as a mask. In this case
                    // the path style of the image indicates the color that the bits of the image with a value of 1 are
                    // painted.
                    MaskImageFlag       = 1 << 0,
                    
                    // Used only for 1-bit gray images. Reverses the sense of the component values so that for a gray
                    // image 0=white and 1=black and for an image mask the 0 value pixels are painted.
                    InvertBitsFlag      = 1 << 1,
 
                    // Used only for 8-bit spot color rasters, or 16-bit if there is an extra alpha channel. When set,
                    // the gray component values are interpreted in the subtractive color spaces.
                    GraySubtractiveFlag = 1 << 2
                };
                
                enum ColorSpace
                {
                    UnknownColorSpace           = 0,
                    
                    // Each pixel value for a gray color space has a single component describing a grayscale value. The
                    // gray color space is additive so the minimum value represents black and the maximum represents
                    // white.
                    GrayColorSpace              = 1,
                    
                    // Each pixel value for a RGB color space has three components which represent red, green and blue
                    // respectively. The RGB color space is additive.
                    RGBColorSpace               = 2,
                    
                    // Each pixel value for a CMYK color space has four components which represent cyan, magenta, yellow
                    // and black respectively. The CMYK color space is subtractive.
                    CMYKColorSpace              = 3,
                    
                    // Not valid as an image type; can occur only in placed linked files
                    LabColorSpace               = 4,
                    
                    // Each pixel value for a separation color space has a single component describing a tint value. The
                    // separation color space is subtractive so the minimum value represents white and the maximum
                    // represents black.
                    SeparationColorSpace        = 5,
                    
                    // Each pixel value for an NChannel color space has of a variable number of components which
                    // represent individual channels in the NChannel color space. The process components of the color
                    // space could be either additive or subtractive. The spot components of the color space are
                    // subtractive.
                    NChannelColorSpace          = 6,
                    
                    // Each pixel value for an indexed color space has a single component describing an index value into
                    // a color lookup table. The number of components in the color lookup table depends on the base
                    // color space of the indexed color space.
                    IndexedColorSpace           = 7,
                    
                    // Flag indicating that the color model has an alpha channel. The alpha component appears after the
                    // color components.
                    ColorSpaceHasAlpha          = 0x10,
                    
                    // A gray color space with an alpha channel
                    AlphaGrayColorSpace         = (GrayColorSpace | ColorSpaceHasAlpha),
 
                    // An RGB color space with an alpha channel
                    AlphaRGBColorSpace          = (RGBColorSpace  | ColorSpaceHasAlpha),
 
                    // A CMYK color space with an alpha channel
                    AlphaCMYKColorSpace         = (CMYKColorSpace | ColorSpaceHasAlpha),
 
                    // A Lab color space with an alpha channel
                    AlphaLabColorSpace          = (LabColorSpace | ColorSpaceHasAlpha),
 
                    // A separation color space with an alpha channel
                    AlphaSeparationColorSpace   = (SeparationColorSpace | ColorSpaceHasAlpha),
 
                    // An NChannel color space with an alpha channel
                    AlphaNChannelColorSpace     = (NChannelColorSpace | ColorSpaceHasAlpha),
 
                    // An indexed color space with an alpha channel
                    AlphaIndexedColorSpace      = (IndexedColorSpace | ColorSpaceHasAlpha),
    
                    InvalidColorSpace           = 0xFF
                };
            
                struct Record
                {
                    Flags flags;
                    
                    Size dimensions;
                    
                    int16_t bitsPerPx;
                    
                    int32_t rowBytes;
                    
                    ColorSpace colorSpace;
                    
                    ColorSpace originalColorSpace;
                
                    Record();
                    
                    Record(const Record& rec_);
                    
                    Record(
                        const Flags flags_,
                        const Size& dim_,
                        const int16_t bitsPerPx_,
                        const int32_t rowBytes_,
                        const ColorSpace colorSpace_,
                        const ColorSpace origColorSpace_
                    );
                    
                    virtual ~Record();
                    
                    Record& operator=(const Record& rhs_);
                    
                    bool operator==(const Record& rhs_);
                    
                    bool operator!=(const Record& rhs_);
                };
                
                ~RasterArt();
                
                Record info() const;
                
                void setInfo(const Record& rec_);
                
                std::string filePath() const;
                
                void setFilePath(const std::string& path_);
                
                core::TransformMatrix matrix() const;
                
                void setMatrix(const core::TransformMatrix& matrix_);
                
                core::ArtboardRect bounds() const;
                
                void setBounds(const core::ArtboardRect& b_);
                
                bool overprint() const;
                
                void setOverprint(const bool op_);
 
                bool colorized(bool& additive__) const;
 
                void clearColorization();
                
 
            private:
                // Only Art can construct a new RasterArt object
                friend class Art;
 
                void* __data;
                
                RasterArt();
 
                RasterArt(void* const art_);
            
                RasterArt(const RasterArt&);
            
                RasterArt& operator=(const RasterArt&);
        };
    }
}
 
hdi::core::RasterArt::Flags operator|(
    const hdi::core::RasterArt::Flags lhs_,
    const hdi::core::RasterArt::Flags rhs_
);
 
hdi::core::RasterArt::Flags& operator|=(
    hdi::core::RasterArt::Flags& lhs__,
    const hdi::core::RasterArt::Flags rhs_
);
 
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_RASTER_ART__