hdicorePathStyle.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_PATH_STYLE__
#define __HDI_CORE_PATH_STYLE__
 
#if defined(HDI_CORE_AIP_MODE)
 
#include "hdicoreArtColor.h"
 
namespace hdi
{
    namespace core
    {
        class DashStyle
        {
            public:
                static const int16_t maxDashComponents = 6;
 
                class Map
                {
                    public:
                        bool lengths[ maxDashComponents ];
                        
                        bool count;
                        
                        bool offset;
                        
                        Map(const bool default_ = false);
 
                        Map(const Map& map_);
 
                        virtual ~Map();
 
                        Map& operator=(const Map& rhs_);
                };
        
                typedef std::unique_ptr<Map> MapUP;
                typedef std::shared_ptr<Map> MapSP;
                typedef std::weak_ptr<Map> MapWP;
 
                double lengths[ maxDashComponents ];
            
                int16_t count;
                
                double offset;
                
                DashStyle();
 
                DashStyle(const DashStyle& style_);
 
                virtual ~DashStyle();
 
                DashStyle& operator=(const DashStyle& rhs_);
        };
        
        typedef std::unique_ptr<DashStyle> DashStyleUP;
        typedef std::shared_ptr<DashStyle> DashStyleSP;
        typedef std::weak_ptr<DashStyle> DashStyleWP;
        
        class FillStyle
        {
            public:
                class Map
                {
                    public:
                        bool color;
                        
                        bool overprint;
                        
                        Map(const bool default_ = false);
 
                        Map(const Map& map_);
 
                        virtual ~Map();
 
                        Map& operator=(const Map& rhs_);
                };
        
                typedef std::unique_ptr<Map> MapUP;
                typedef std::shared_ptr<Map> MapSP;
                typedef std::weak_ptr<Map> MapWP;
                
                ArtColor color;
 
                bool overprint;
                
                FillStyle();
 
                FillStyle(const FillStyle& style_);
 
                virtual ~FillStyle();
 
                FillStyle& operator=(const FillStyle& rhs_);
        };
        
        typedef std::unique_ptr<FillStyle> FillStyleUP;
        typedef std::shared_ptr<FillStyle> FillStyleSP;
        typedef std::weak_ptr<FillStyle> FillStyleWP;
        
        class StrokeStyle
        {
            public:
                enum CapStyle
                {
                    ButtCap         = 100,
                    RoundCap        = 110,
                    ProjectingCap   = 120,
                    SquareCap       = ProjectingCap
                };
                
                enum JoinStyle
                {
                    MiterJoin   = 100,
                    RoundJoin   = 110,
                    BevelJoin   = 120
                };
                
                class Map
                {
                    public:
                        bool color;
                        
                        bool overprint;
                        
                        bool width;
                        
                        DashStyle::Map dash;
                        
                        bool cap;
                        
                        bool join;
                        
                        bool miterLimit;
                        
                        Map(const bool default_ = false);
 
                        Map(const Map& map_);
 
                        virtual ~Map();
 
                        Map& operator=(const Map& rhs_);
                };
        
                typedef std::unique_ptr<Map> MapUP;
                typedef std::shared_ptr<Map> MapSP;
                typedef std::weak_ptr<Map> MapWP;
 
                ArtColor color;
 
                bool overprint;
 
                double width;
 
                DashStyle dash;
 
                CapStyle cap;
 
                JoinStyle join;
                
                double miterLimit;
                
                StrokeStyle();
 
                StrokeStyle(const StrokeStyle& style_);
 
                virtual ~StrokeStyle();
 
                StrokeStyle& operator=(const StrokeStyle& rhs_);
        };
        
        typedef std::unique_ptr<StrokeStyle> StrokeStyleUP;
        typedef std::shared_ptr<StrokeStyle> StrokeStyleSP;
        typedef std::weak_ptr<StrokeStyle> StrokeStyleWP;
        
        class PathStyle
        {
            public:
                class Map
                {
                    public:
                        bool useFill;
                        
                        FillStyle::Map fill;
                        
                        bool useStroke;
                        
                        StrokeStyle::Map stroke;
                        
                        bool evenodd;
                        
                        bool resolution;
 
                        Map(const Map& map_);
                        
                        Map(const bool default_ = false);
 
                        virtual ~Map();
 
                        Map& operator=(const Map& rhs_);
                };
        
                typedef std::unique_ptr<Map> MapUP;
                typedef std::shared_ptr<Map> MapSP;
                typedef std::weak_ptr<Map> MapWP;
 
                bool useFill;
                
                FillStyle fill;
                
                bool useStroke;
 
                StrokeStyle stroke;
                
                bool evenodd;
                
                double resolution;
 
                PathStyle();
 
                PathStyle(const PathStyle& style_);
 
                virtual ~PathStyle();
 
                PathStyle& operator=(const PathStyle& rhs_);
        };
        
        typedef std::unique_ptr<PathStyle> PathStyleUP;
        typedef std::shared_ptr<PathStyle> PathStyleSP;
        typedef std::weak_ptr<PathStyle> PathStyleWP;
    }
}
 
#endif
// HDI_CORE_AIP_MODE
 
#endif
// __HDI_CORE_PATH_STYLE__