util_draw_dtk.hpp

Go to the documentation of this file.

#ifndef _UTIL_DRAW_DTK_HPP_
#define _UTIL_DRAW_DTK_HPP_
 
#include "util/BaseTypes/dtk_dir.hpp"
#include "util/BaseTypes/dtk_object.hpp"
#include "util/BaseTypes/dtk_pnt.hpp"
#include "util/BaseTypes/dtk_rgb.hpp"
#include "util/BaseTypes/dtk_string.hpp"
#include "util/BaseTypes/dtk_transfo.hpp"
#include "util/dtk_val.hpp"
#include "struct/str_def.h"
#include "util/error_dtk.hpp"
#include "util/util_draw_ptr_dtk.hpp"
#include "util/util_ent_dtk.hpp"
#include "util/util_geom_dtk.hpp"
#include "util/util_geom_ptr_dtk.hpp"
#include "util/util_ptr_dtk.hpp"
#include "util/util_stl_dtk.hpp"
#include "util/util_topology_ptr_dtk.hpp"
#include <cmath>
#include "def/define.h"
#include "dtk/config.hpp"
#include <iosfwd>
#include <type_traits>
#include <unordered_map>
 
// #ifdef _DEBUG   ----->  Never use this condition , DEBUG_DTK only for internal use
// #   ifndef _DEBUG_DTK
// #       define _DEBUG_DTK
// #   endif
// #endif
 
//Forward declarations
//Text_or_character will be removed in V2026.1
struct text_or_character_def;
typedef struct text_or_character_def Text_or_character;
 
struct polyline_def;
typedef struct polyline_def Polyline_detk;
 
 
 
class Dtk_Connector;
class Dtk_ConnectorPart;
 
typedef Dtk_SmartPtr<Dtk_Connector>   Dtk_ConnectorPtr;
typedef Dtk_SmartPtr<Dtk_ConnectorPart> Dtk_ConnectorPartPtr;
 
typedef Dtk_tab<Dtk_ConnectorPtr>   Dtk_ConnectorTab;
typedef Dtk_tab<Dtk_ConnectorPartPtr>   Dtk_ConnectorPartTab;
 
enum DTK_FDT_MODIFIER {
     DTK_FDT_MODIFIER_NOT_SET = 0,
     DTK_FDT_MODIFIER_MAX_MATERIAL = 1,
     DTK_FDT_MODIFIER_LEAST_MATERIAL = 2,
     DTK_FDT_MODIFIER_REGARDLESS_OF_FEATURE_SIZE = 3,
     DTK_FDT_MODIFIER_NONE = 9
};
enum DTK_DATUM_COMPOSING_RULE {
     DTK_UNKNOWN = 0,
     DTK_WITH_HIERARCHY,
     DTK_WITHOUT_HIERARCHY,
     DTK_INDIFFERENT_HIERARCHY
};
 
 
 
enum Dtk_Unit {
     DTK_UNIT_UNKNOWN = 0,
     // Length
     DTK_UNIT_MM,
     DTK_UNIT_CM,
     DTK_UNIT_M,
     DTK_UNIT_KM,
     DTK_UNIT_INCH,
     DTK_UNIT_FOOT,
     // Angle
     DTK_UNIT_DEGREE,
     DTK_UNIT_RADIAN,
     DTK_UNIT_GRADE,
     // Degree, Minute, Second
     DTK_UNIT_DMS
};
 
enum Dtk_anchor_type {
     DTK_ANCHOR_TOP_LEFT = 0,
     DTK_ANCHOR_TOP_CENTER,
     DTK_ANCHOR_TOP_RIGHT,
     DTK_ANCHOR_MIDDLE_LEFT,
     DTK_ANCHOR_MIDDLE_CENTER,
     DTK_ANCHOR_MIDDLE_RIGHT,
     DTK_ANCHOR_BOTTOM_LEFT,
     DTK_ANCHOR_BOTTOM_CENTER,
     DTK_ANCHOR_BOTTOM_RIGHT,
     DTK_NB_ANCHOR_TYPES
};
 
enum Dtk_alignment_type {
     DTK_ALIGN_NONE = 0,
     DTK_ALIGN_LEFT,
     DTK_ALIGN_RIGHT,
     DTK_ALIGN_CENTER,
     DTK_ALIGN_JUSTIFIED
};
 
enum Dtk_justication_type {
     DTK_JUSTIFY_LEFT = 0,
     DTK_JUSTIFY_CENTER,
     DTK_JUSTIFY_RIGHT
};
 
enum Dtk_frame_type {
     DTK_FRAME_TYPE_NONE = 0,
     DTK_FRAME_TYPE_RECTANGLE = 1,
     DTK_FRAME_TYPE_SQUARE = 2,
     DTK_FRAME_TYPE_CIRCLE = 3,
     DTK_FRAME_TYPE_SCORED_CIRCLE = 4,
     DTK_FRAME_TYPE_DIAMOND = 5,
     DTK_FRAME_TYPE_TRIANGLE = 6,
     DTK_FRAME_TYPE_FLAG_RIGHT = 7,
     DTK_FRAME_TYPE_FLAG_LEFT = 8,
     DTK_FRAME_TYPE_FLAG_BOTH = 9,
     DTK_FRAME_TYPE_OBLONG = 10,
     DTK_FRAME_TYPE_OBLONG_RIGHT = 11,
     DTK_FRAME_TYPE_OBLONG_LEFT = 12,
     DTK_FRAME_TYPE_ELLIPSE = 13,
     DTK_FRAME_TYPE_STICKING = 14,
     DTK_FRAME_TYPE_SET = 15,
     DTK_FRAME_TYPE_FIXED_SUPPORT = 16,
     DTK_FRAME_TYPE_NOTA = 17,
     DTK_FRAME_TYPE_SYMMETRICAL_PART = 18,
     DTK_FRAME_TYPE_SYMMETRICAL_SET = 19,
     DTK_FRAME_TYPE_SCORED_RECTANGLE = 20,
    DTK_FRAME_TYPE_PARALLELOGRAM = 21,
    DTK_FRAME_TYPE_OCTANGLE = 22,
    DTK_FRAME_TYPE_FLAG_RIGHT_TRIANGLE = 23,
    DTK_FRAME_TYPE_SQUARE_CIRCLE = 24,
    DTK_FRAME_TYPE_PENTAGON = 25,
    DTK_FRAME_TYPE_HEXAGON = 26,
    DTK_FRAME_TYPE_POLYGON = 27,
    DTK_FRAME_TYPE_UNDERLINE = 28
};
 
class Dtk_Font
{
public:
     enum FontTypeEnum {
          FontUnknown = 0,
          FontTruescript,
          FontPostscript,
          FontOpentype
     };
protected:     
     Dtk_string _name;
     FontTypeEnum _font_type;
     Dtk_Size_t _ID;
public:
     ~Dtk_Font();
 
     Dtk_Font();
 
     Dtk_Font(const Dtk_Font& in);
     Dtk_Font( Dtk_Font&& in) DTK_NOEXCEPT;
 
     Dtk_string& Name();
 
     const Dtk_string& Name() const;
 
     FontTypeEnum& FontType();
 
     const FontTypeEnum& FontType() const;
 
     Dtk_Size_t& ID();
 
     const Dtk_Size_t& ID() const;
 
     Dtk_Font& operator=(const Dtk_Font & in);
     Dtk_Font& operator=(Dtk_Font&& in ) DTK_NOEXCEPT;
};
 
class Dtk_TextStyle
{
public:
     enum FontStyleEnum {
          StyleRegular = 0,
          StyleBold,
          StyleItalic,
          StyleBoldItalic
     };
    static inline Dtk_string FontStyleEnumToString( const FontStyleEnum& inEnum )
    {
        switch( inEnum )
        {
            default:
            case StyleRegular: return L"StyleRegular";
            case StyleBold: return L"StyleBold";
            case StyleItalic: return L"StyleItalic";
            case StyleBoldItalic: return L"StyleBoldItalic";
        }
    }
     enum TextAttributeEnum {
          AttributeNone = 0,
          AttributeUnderline = 1,
          AttributeStrikethrough = 2,
          AttributeOverline = 4,
          AttributeSuperscript = 8,
          AttributeSubscript = 16
     };
     enum TextJustificationEnum {
          JustificationLeft = 0,
          JustificationCenter,
          JustificationRight,
          JustificationNone
     };
    static inline Dtk_string TextJustificationEnumToString( const TextJustificationEnum& inEnum )
    {
        switch( inEnum )
        {
            default:
            case JustificationLeft: return L"JustificationLeft";
            case JustificationCenter: return L"JustificationCenter";
            case JustificationRight: return L"JustificationRight";
            case JustificationNone: return L"JustificationNone";
        }
    }
protected:
 
     Dtk_Font _font;
     FontStyleEnum _font_style;
     TextAttributeEnum _attributes;
     TextJustificationEnum _justification;
     Dtk_Double64 _char_height;
     Dtk_Double64 _char_spacing;
     Dtk_Double64 _char_width;
     Dtk_Double64 _line_spacing;
     Dtk_Double64 _slant;
     Dtk_Double64 _ratio;
     Dtk_Double64 _pitch;
public:
     ~Dtk_TextStyle();
 
     Dtk_TextStyle();
 
     Dtk_TextStyle(const Dtk_TextStyle & in );
     Dtk_TextStyle( Dtk_TextStyle && in ) DTK_NOEXCEPT;
 
     Dtk_TextStyle& operator =(const Dtk_TextStyle & in);
     Dtk_TextStyle& operator =( Dtk_TextStyle && in) DTK_NOEXCEPT;
 
     Dtk_Font& Font();
 
     const Dtk_Font& Font() const;
 
     FontStyleEnum& FontStyle();
 
     const FontStyleEnum& FontStyle() const;
 
     TextAttributeEnum& Attributes();
 
     const TextAttributeEnum& Attributes() const;
 
     TextJustificationEnum& Justification();
 
     const TextJustificationEnum& Justification() const;
 
     Dtk_Double64& CharHeight();
 
     const Dtk_Double64& CharHeight() const;
 
     Dtk_Double64& CharSpacing();
 
     const Dtk_Double64& CharSpacing() const;
 
     Dtk_Double64& CharWidth();
 
     const Dtk_Double64& CharWidth() const;
 
     Dtk_Double64& LineSpacing();
 
     const Dtk_Double64& LineSpacing() const;
 
     Dtk_Double64& Slant();
 
     const Dtk_Double64& Slant() const;
 
     Dtk_Double64& Ratio();
 
     const Dtk_Double64& Ratio() const;
 
     Dtk_Double64& Pitch();
 
     const Dtk_Double64& Pitch() const;
 
};
 
class Dtk_Oriented2dBBox
{
protected:
     Dtk_pnt _BottomLeftPnt;
     Dtk_dir _XLocalVector;
     Dtk_dir _YLocalVector;
     Dtk_Double64 _XLength;
     Dtk_Double64 _YLength;
 
    inline void _Init()
    {
        Dtk_Size_t i = 0;
 
        for (i = 0; i < 3; i++)
        {
            _BottomLeftPnt[i] = 0.0;
            _XLocalVector[i] = 0.0;
            _YLocalVector[i] = 0.0;
        }
        _XLocalVector[0] = 1.0;
        _YLocalVector[1] = 1.0;
        _XLength = 0.0;
        _YLength = 0.0;
    }
 
    inline void _Copy(const Dtk_Oriented2dBBox &s)
    {
        _BottomLeftPnt = s._BottomLeftPnt;
        _XLocalVector = s._XLocalVector;
        _YLocalVector = s._YLocalVector;
        _XLength = s._XLength;
        _YLength = s._YLength;
    }
 
    inline void _Reset() {}
public:
     Dtk_Oriented2dBBox();
 
     Dtk_Oriented2dBBox(const Dtk_pnt &inBottomLeft,
          const Dtk_Double64 &inXLength, const Dtk_Double64 inYLenght,
          const Dtk_dir &inRefAxis = Dtk_dir(1,0,0),
          const Dtk_dir &inNormalAxis = Dtk_dir(0,0,1));
 
     Dtk_Oriented2dBBox(const Dtk_Oriented2dBBox & in);
 
     ~Dtk_Oriented2dBBox();
 
    inline void Clear()
    {
        _Reset();
        _Init();
    }
 
     Dtk_Oriented2dBBox& operator=(const Dtk_Oriented2dBBox &in);
 
     Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     inline Dtk_pnt BottomLeftPoint() const
     {
          return _BottomLeftPnt;
     }
 
     inline Dtk_pnt GetBottomLeftPoint() const
     {
          return BottomLeftPoint();
     }
 
     inline Dtk_pnt GetMiddleLeftPoint() const
     {
          return _BottomLeftPnt + 0.5*_YLength*_YLocalVector;
     }
 
     inline Dtk_pnt GetTopLeftPoint() const
     {
          return _BottomLeftPnt + _YLength*_YLocalVector;
     }
 
     inline Dtk_pnt GetBottomCenterPoint() const
     {
          return _BottomLeftPnt + 0.5*_XLength*_XLocalVector;
     }
 
     inline Dtk_pnt GetMiddleCenterPoint() const
     {
          return _BottomLeftPnt + 0.5*_YLength*_YLocalVector
               + 0.5*_XLength*_XLocalVector;
     }
 
     inline Dtk_pnt GetTopCenterPoint() const
     {
          return _BottomLeftPnt + _YLength*_YLocalVector
               + 0.5*_XLength*_XLocalVector;
     }
 
     inline Dtk_pnt GetBottomRightPoint() const
     {
          return _BottomLeftPnt + _XLength*_XLocalVector;
     }
 
     inline Dtk_pnt GetMiddleRightPoint() const
     {
          return _BottomLeftPnt + 0.5*_YLength*_YLocalVector
               + _XLength*_XLocalVector;
     }
 
     inline Dtk_pnt GetTopRightPoint() const
     {
          return _BottomLeftPnt + _YLength*_YLocalVector + _XLength*_XLocalVector;
     }
 
     inline Dtk_Double64 GetXLength() const
     {
          return _XLength;
     }
 
     inline Dtk_Double64 GetYLength() const
     {
          return _YLength;
     }
 
     inline Dtk_dir XLocalVector() const
     {
          return _XLocalVector;
     }
 
     inline Dtk_dir YLocalVector() const
     {
          return _YLocalVector;
     }
 
     inline void SetXLocalVector(const Dtk_dir& inNewXVector)
     {
          _XLocalVector = inNewXVector;
          _XLocalVector.normalize();
     }
 
     inline void SetYLocalVector(const Dtk_dir& inNewYVector)
     {
          _YLocalVector = inNewYVector;
          _YLocalVector.normalize();
     }
 
     inline void SetLocalVectors(const Dtk_dir& inNewXVector,
          const Dtk_dir& inNewYVector)
     {
          _XLocalVector = inNewXVector;
          _YLocalVector = inNewYVector;
          _XLocalVector.normalize();
          _YLocalVector.normalize();
          Dtk_dir TmpZ = _XLocalVector / _YLocalVector;
          _YLocalVector = TmpZ / _XLocalVector;
     }
 
     Dtk_bool IsInside(const Dtk_pnt &inPoint) const;
 
     void Merge(const Dtk_pnt &inPoint);
 
     void Merge(const Dtk_Oriented2dBBox &inOriented2dBBox);
 
     void Translate(const Dtk_dir &inTranslation);
 
     void Rotate(const Dtk_Double64 &inAngleInRadian);
 
     void Transform(const Dtk_transfo &inTransfo);
 
     void Reverse();
 
     void Extend(const Dtk_Double64 &inXExtend, const Dtk_Double64 &inYExtend);
 
     void Extend(const Dtk_Double64 &inTopExtend,
          const Dtk_Double64 &inBottomExtend,
          const Dtk_Double64 &inLeftExtend,
          const Dtk_Double64 &inRightExtend);
 
     inline Dtk_pnt& BottomLeftPoint()
     {
          return _BottomLeftPnt;
     }
 
     inline Dtk_dir& XLocalVector()
     {
          return _XLocalVector;
     }
 
     inline Dtk_dir& YLocalVector()
     {
          return _YLocalVector;
     }
 
     void SetXLength(const Dtk_Double64 &inNewXlength);
 
     void SetYLength(const Dtk_Double64 &inNewXlength);
 
     void SetBottomLeftPoint(const Dtk_pnt &inNewPoint);
 
     void SetMiddleLeftPoint(const Dtk_pnt &inNewPoint);
 
     void SetTopLeftPoint(const Dtk_pnt &inNewPoint);
 
     void SetBottomCenterPoint(const Dtk_pnt &inNewPoint);
 
     void SetMiddleCenterPoint(const Dtk_pnt &inNewPoint);
 
     void SetTopCenterPoint(const Dtk_pnt &inNewPoint);
 
     void SetBottomRightPoint(const Dtk_pnt &inNewPoint);
 
     void SetMiddleRightPoint(const Dtk_pnt &inNewPoint);
 
     void SetTopRightPoint(const Dtk_pnt &inNewPoint);
 
     Dtk_pnt GetPoint(const enum Dtk_anchor_type& inAnchorType) const;
 
     void SetPoint(const Dtk_pnt &inNewPoint,
          const enum Dtk_anchor_type& inAnchorType);
 
     Dtk_ErrorStatus ProcessDistance(const Dtk_Oriented2dBBox& inReferenceBBox,
          Dtk_Double64& outTopOffSet, Dtk_Double64& outBottomOffSet,
          Dtk_Double64& outRightOffSet, Dtk_Double64& outLeftOffSet) const;
 
     Dtk_Int32 ProcessIntersectionWithLine(
          const Dtk_LinePtr inLine,
          Dtk_pnt& outIntersectionPnt1,
          Dtk_pnt& outIntersectionPnt2,
          Dtk_Double64& outIntersectionParam1,
          Dtk_Double64& outIntersectionParam2,
          const Dtk_bool& inTestComplanarity = DTK_FALSE ) const;
 
    Dtk_Int32 ProcessIntersectionWithLine(
        const Dtk_pnt& inPntA,
        const Dtk_pnt& inPntB,
        Dtk_pnt& outIntersectionPnt1,
        Dtk_pnt& outIntersectionPnt2,
        const Dtk_bool& inTestComplanarity = DTK_FALSE ) const;
 
    Dtk_Int32 ProcessIntersectionWithSegment(
        const Dtk_pnt& inPntA,
        const Dtk_pnt& inPntB,
        Dtk_pnt& outIntersectionPnt1,
        Dtk_pnt& outIntersectionPnt2,
        const Dtk_bool& inTestComplanarity = DTK_FALSE ) const;
 
     Dtk_Int32 ProcessIntersectionWithSegment(
          const Dtk_pnt& inPntA,
          const Dtk_pnt& inPntB,
          Dtk_tab<Dtk_pnt>& outIntersectionPnts,
          const Dtk_bool& inTestComplanarity = DTK_FALSE) const;
 
 
    Dtk_Int32 ProcessIntersectionWithCircle(
        const Dtk_pnt& inCenter,
        const Dtk_Double64& inRadius,
        Dtk_tab<Dtk_pnt>& outIntersectionPnts) const;
};
 
class Dtk_Frame
{
protected:
    Dtk_frame_type              _FrameType;
    Dtk_tab< Dtk_CurvePtr >     _RelatedGeomElements;
    inline void _Init()
    {
        _FrameType = DTK_FRAME_TYPE_NONE;
    }
    inline void _Copy(const Dtk_Frame &s)
    {
        _FrameType = s._FrameType;
        for( Dtk_Size_t i = 0 ; i < s._RelatedGeomElements.size() ; i++)
        {
            Dtk_CurvePtr c;
            s._RelatedGeomElements[i].Clone(c);
            _RelatedGeomElements.push_back(c);
        }
    }
    inline void _Reset(){}
public:
 
     Dtk_Frame( const Dtk_frame_type& inFrameType, Dtk_tab< Dtk_CurvePtr > inRelatedGeometricalElts )
          : _FrameType( inFrameType ), _RelatedGeomElements( std::move( inRelatedGeometricalElts ) ) { }
 
     Dtk_Frame( const Dtk_Frame &in ) : _FrameType( in._FrameType ), _RelatedGeomElements( in._RelatedGeomElements ) { }
     Dtk_Frame( Dtk_Frame &&in ) DTK_NOEXCEPT : _FrameType( in._FrameType ), _RelatedGeomElements( std::move( in._RelatedGeomElements ) ) { }
 
    inline Dtk_Frame()
    {
        _Init();
    }
 
    inline ~Dtk_Frame(){ _Reset();}
 
    inline void Clear()
    {
        _FrameType = DTK_FRAME_TYPE_NONE;
        _RelatedGeomElements.clear();
    }
 
 
    inline void SetFrameData(
        const Dtk_frame_type& inFrameType,
        Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements )
    {
        this->_FrameType = inFrameType;
        this->_RelatedGeomElements = std::move( inRelatedGeomElements );
    }
    inline const Dtk_frame_type& GetFrameType() const {return _FrameType;}
 
    Dtk_ErrorStatus CreateGeometries(Dtk_tab< Dtk_CurvePtr >& outGeoms) const;
 
    Dtk_ErrorStatus Translate(const Dtk_dir &inTranslateDir);
 
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    Dtk_Frame& operator=(const Dtk_Frame & in);
    Dtk_Frame& operator=( Dtk_Frame && in ) DTK_NOEXCEPT;
};
class Dtk_CompositeText;
 
class DTK_Text_subtype
{
private:
     int p;
public:
     DTK_Text_subtype(int in=0);
     void Append(int in);
    Dtk_bool IsNotDefined() const;
    Dtk_bool IsDual() const;
    Dtk_bool IsLeftText() const;
    Dtk_bool IsRightText() const;
    Dtk_bool IsUpText() const;
    Dtk_bool IsDownText() const;
    Dtk_bool IsPrefix() const;
    Dtk_bool IsSuffix() const;
    Dtk_bool IsChamfersign() const;
    Dtk_bool IsChamferright() const;
    Dtk_bool IsMainvalpart() const;
    Dtk_bool IsBasisval() const;
    Dtk_bool IsPow() const;
    Dtk_bool IsUpperFrac() const;
    Dtk_bool IsLowerFrac() const;
    Dtk_bool IsValSplitPart1() const;
    Dtk_bool IsValSplitPart2() const;
    Dtk_bool IsValSplitPart3() const;
    Dtk_bool IsTolBloc() const;
    Dtk_bool IsTolValPart() const;
    Dtk_bool IsTolUpperTol() const;
    Dtk_bool IsTolLowerTol() const;
    Dtk_bool IsTolSymetricalTol() const;
    Dtk_bool IsTolSign() const;
    Dtk_bool IsTolPrefix() const;
     Dtk_bool IsTolLeftParenthesis() const;
    Dtk_bool IsTolRightParenthesis() const;
     Dtk_bool IsUrl() const;
     Dtk_bool IsFractionBar() const;
     Dtk_bool IsSeparator() const;
    Dtk_string Dump() const;
};
 
 
 
 
class Dtk_Text
{
public:
     enum MirroringTypeEnum {
          NoMirroring = 0,
          HorizontalMirroring,
          VerticalMirroring
     };
 
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
 
private:
     void _Init();
     void _Copy(const Dtk_Text& s);
     void _Reset();
 
public:
     ~Dtk_Text();
 
     Dtk_Text();
 
     Dtk_Text(const Dtk_Text &s);
 
     Dtk_Text( Dtk_Text &&s) DTK_NOEXCEPT;
 
     Dtk_Text(Dtk_string inTextString,
          const Dtk_Oriented2dBBox &inInnerBox,
          const Dtk_Oriented2dBBox &inOuterBox,
          const Dtk_anchor_type &inAnchorType,
          const DTK_Text_type &inTextType,
          const Dtk_Int32 &inHorizontalVerticalType,
          const Dtk_InfoPtr &inInfos,
          const Dtk_TextStyle &inTextStyle,
          const Dtk_Double64 &inSlant,
          const Dtk_Int32 &inFontIndex,
          const Dtk_Int32 &inMirroringType);
 
     Dtk_Text( Dtk_string inTextString,
          const Dtk_Oriented2dBBox &inInnerBox,
          const Dtk_Oriented2dBBox &inOuterBox,
          const Dtk_Double64 &inSlant,
          const Dtk_bool &inHorizontalVerticalType,
          const DTK_Text_type &inTextType, const Dtk_InfoPtr &inInfos,
          const Dtk_TextStyle &inTextStyle);
 
     Dtk_Text& operator=(const Dtk_Text & in);
     Dtk_Text& operator=( Dtk_Text && in) DTK_NOEXCEPT;
 
 
    Dtk_bool IsEmpty() const;
 
    void SetFrameType( const Dtk_frame_type& inFrameType, Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements);
 
    void GetFrame(Dtk_Frame& outFrame) const;
 
     Dtk_frame_type FrameType() const;
 
     DTK_Text_type& TextType();
 
     const DTK_Text_type& TextType() const;
 
     DTK_Text_subtype& TextSubType();
 
     const DTK_Text_subtype& TextSubType() const;
 
 
     const Dtk_dir& InnerXAxis() const;
 
     const Dtk_dir& OuterXAxis() const;
 
     Dtk_dir& InnerXAxis();
 
     Dtk_dir& OuterXAxis();
 
     const Dtk_dir& InnerYAxis() const;
 
     const Dtk_dir& OuterYAxis() const;
 
     Dtk_dir& InnerYAxis();
 
     Dtk_dir& OuterYAxis();
 
     const Dtk_pnt& InnerLocation() const;
 
     const Dtk_pnt& OuterLocation() const;
 
     Dtk_pnt& InnerLocation();
 
     Dtk_pnt& OuterLocation();
 
     Dtk_string& Text();
 
     const Dtk_string& Text() const;
 
     Dtk_TextStyle& TextStyle();
 
     const Dtk_TextStyle& TextStyle() const;
 
     const Dtk_bool& VerticallyOrientedStatus() const;
 
     Dtk_ErrorStatus SetVerticallyOrientedStatus(
          const Dtk_bool &inVerticallyOrientedStatus);
 
     Dtk_anchor_type& AnchorType();
 
     const Dtk_anchor_type& AnchorType() const;
 
     const Dtk_InfoPtr& GetInfo() const;
 
     Dtk_InfoPtr& GetInfo();
 
     Dtk_ErrorStatus SetInnerRotationAngle(const Dtk_Double64 &inRotationAngle,
          const Dtk_dir &inXAxis = Dtk_dir(1,0,0),
          const Dtk_dir &inYAxis = Dtk_dir(0,1,0));
 
     Dtk_ErrorStatus SetOuterRotationAngle(const Dtk_Double64 &inRotationAngle,
          const Dtk_dir &inXAxis = Dtk_dir(1,0,0),
          const Dtk_dir &inYAxis = Dtk_dir(0,1,0));
 
     Dtk_Double64 GetInnerRotationAngle(const Dtk_dir &inXAxis = Dtk_dir(1,0,0),
          const Dtk_dir &inYAxis = Dtk_dir(0,1,0));
 
     Dtk_Double64 GetOuterRotationAngle(const Dtk_dir &inXAxis = Dtk_dir(1,0,0),
          const Dtk_dir &inYAxis = Dtk_dir(0,1,0));
 
     Dtk_ErrorStatus InnerTranslate(const Dtk_dir &inTranslateDir);
 
     Dtk_ErrorStatus OuterTranslate(const Dtk_dir &inTranslateDir);
 
     Dtk_ErrorStatus Translate(const Dtk_dir &inTranslateDir);
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     Dtk_ErrorStatus Reverse();
 
     void SetInnerXYAxis(const Dtk_dir &inXAxis, const Dtk_dir &inYAxis);
 
     void SetOuterXYAxis(const Dtk_dir &inXAxis, const Dtk_dir &inYAxis);
 
     void GetInnerXYAxis(Dtk_dir &outXAxis, Dtk_dir &outYAxis) const;
 
     void GetOuterXYAxis(Dtk_dir &outXAxis, Dtk_dir &outYAxis) const;
 
     void SetInnerXLength(const Dtk_Double64 &inXLength);
 
     void SetInnerYLength(const Dtk_Double64 &inYLength);
 
     void SetOuterXLength(const Dtk_Double64 &inXLength);
 
     void SetOuterYLength(const Dtk_Double64 &inYLength);
 
     MirroringTypeEnum ProcessMirroringType(
          const Dtk_dir &inZAxis = Dtk_dir(0,0,1)) const;
 
     Dtk_Double64 ProcessRotationAngle(
          const Dtk_dir &inZAxis = Dtk_dir(0,0,1)) const;
 
     Dtk_Int32 ProcessTextNumLines() const;
 
     Dtk_pnt ProcessBottomLeftAnchorPoint() const;
 
    const Dtk_Oriented2dBBox& GetInnerBoundingBox() const;
    Dtk_Oriented2dBBox& GetInnerBoundingBox();
 
    const Dtk_Oriented2dBBox& GetOuterBoundingBox() const;
    Dtk_Oriented2dBBox& GetOuterBoundingBox();
 
     Dtk_ErrorStatus SetInnerBoundingBox(const Dtk_Oriented2dBBox& innerBoundingBox);
 
      Dtk_ErrorStatus SetOuterBoundingBox(const Dtk_Oriented2dBBox& outerBoundingBox);
 
     //SetAsDeprecated("Undefined", "Use SetInnerBoundingBox")
     Dtk_ErrorStatus SetInnerAnchorPoint(const Dtk_pnt& inNewOrigin,
          const Dtk_anchor_type& inLocationAnchorType);
    Dtk_ErrorStatus SetInnerAnchorPointWithTranslation(const Dtk_pnt &new_origin,
        const Dtk_anchor_type location_anchor_type);
 
     Dtk_ErrorStatus SetOuterAnchorPoint(const Dtk_pnt& inNewOrigin,
          const Dtk_anchor_type& inLocationAnchorType);
    Dtk_ErrorStatus SetOuterAnchorPointWithTranslation(const Dtk_pnt &new_origin,
        const Dtk_anchor_type location_anchor_type);
 
     Dtk_ErrorStatus CreateFrameAsGeometry(
          Dtk_tab<Dtk_CurvePtr> &outGeoms) const;
 
 
     SetAsDeprecated( "2020.2", "Text_or_character is OBSOLETE : use ExplodeText" )
     Text_or_character ** ConvertToText_or_character(
          Dtk_Int32 &outNumTexts) const;
 
     Dtk_Text *ExplodeText(Dtk_Int32 **outNumFontArray,
          Dtk_Int32 &outNumTexts) const;
 
     friend Dtk_CompositeText operator+(const Dtk_Text &s1, const Dtk_Text &s2);
};
 
class Dtk_CompositeText
{
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
 
private:
     void _Init();
     void _Copy(const Dtk_CompositeText& s);
     void _Reset();
 
public:
     ~Dtk_CompositeText();
 
     Dtk_CompositeText();
 
     Dtk_CompositeText(const Dtk_CompositeText& t);
 
     Dtk_CompositeText( Dtk_CompositeText&& t) DTK_NOEXCEPT;
 
     Dtk_CompositeText(const Dtk_Size_t& inNumTexts);
 
     Dtk_CompositeText( Dtk_Text inText);
 
     Dtk_CompositeText( Dtk_tab<Dtk_Text> inTexts);
 
     Dtk_CompositeText& operator=(const Dtk_CompositeText& in);
 
     Dtk_CompositeText& operator=( Dtk_CompositeText&& in ) DTK_NOEXCEPT;
 
    void Clear();
 
     Dtk_Text& operator[](Dtk_Size_t inPos);
 
     const Dtk_Text& operator[](Dtk_Size_t inPos) const;
 
     Dtk_Size_t GetNumTexts() const;
 
     friend Dtk_CompositeText operator+(
          Dtk_CompositeText s1, Dtk_CompositeText s2);
 
    Dtk_CompositeText& operator+=( Dtk_CompositeText s2);
 
     SetAsDeprecated("Undefined", "Use GetOuterBoundingBox")
     Dtk_ErrorStatus GetOuterAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     const Dtk_Oriented2dBBox GetInnerBoundingBox() const;
 
     const Dtk_Oriented2dBBox GetOuterBoundingBox( Dtk_bool inIncludeInvisible = DTK_TRUE ) const;
 
     const Dtk_Oriented2dBBox GetInnerBoundingBox(Dtk_ErrorStatus &outError)
          const;
 
     const Dtk_Oriented2dBBox GetOuterBoundingBox(Dtk_ErrorStatus &outError,
          Dtk_bool inIncludeInvisible = DTK_TRUE )
          const;
 
     const Dtk_Double64& GetWrappingWidth() const;
 
     void SetWrappingWidth(const Dtk_Double64 &inWrappingWidth);
 
     Dtk_ErrorStatus SetInnerAnchorPoint(const Dtk_pnt& inNewLocationPnt,
          const Dtk_anchor_type &inNewAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_Int32 &inStartingGetText = -1,
          const Dtk_Int32 &inNumGetTexts = -1,
          const Dtk_Int32 &inStartingSetText = -1,
          const Dtk_Int32 &inNumSetTexts = -1);
 
     Dtk_ErrorStatus SetOuterAnchorPoint(const Dtk_pnt& inNewLocationPnt,
          const Dtk_anchor_type &inNewAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_Int32 &inStartingGetText = -1,
          const Dtk_Int32 &inNumGetTexts = -1,
          const Dtk_Int32 &inStartingSetText = -1,
          const Dtk_Int32 &inNumSetTexts = -1);
 
     Dtk_ErrorStatus CreateFrameAsGeometry(
          Dtk_tab<Dtk_CurvePtr> &outGeoms) const;
 
     Dtk_ErrorStatus SetInnerXAxis(const Dtk_dir &inXAxis);
 
     Dtk_ErrorStatus SetOuterXAxis(const Dtk_dir &inXAxis);
 
     Dtk_ErrorStatus SetInnerYAxis(const Dtk_dir &axis_dir);
 
     Dtk_ErrorStatus SetOuterYAxis(const Dtk_dir &axis_dir);
 
     Dtk_ErrorStatus SetInnerXYAxis(const Dtk_dir &inXaxis,
          const Dtk_dir &inYaxis);
 
     Dtk_ErrorStatus SetOuterXYAxis(const Dtk_dir &inXaxis,
          const Dtk_dir &inYaxis);
 
     const Dtk_InfoPtr& GetInfo() const;
 
     Dtk_InfoPtr& GetInfo();
 
     Dtk_ErrorStatus Reverse();
 
     void AddText( Dtk_Text inText);
 
     void ReplaceTexts(const Dtk_tab<Dtk_Text> &inTexts);
 
     Dtk_string ConvertToDtk_string() const;
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     Dtk_ErrorStatus Translate(const Dtk_dir &inTranslateDir);
};
 
class Dtk_2dEntity : public Dtk_Entity
{
protected:
    struct Dtk_Handle; // Not defined here
    Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_2D_ENTITY
     };
     virtual ~Dtk_2dEntity();
 
     Dtk_2dEntity();
 
     Dtk_2dEntity(const Dtk_2dEntity&in);
     Dtk_2dEntity( Dtk_2dEntity&& in ) DTK_NOEXCEPT;
    virtual Dtk_Object* Clone() = 0;
 
protected:
    void _Init();
    void _Reset();
    void _Copy(const Dtk_2dEntity &s);
     friend class Dtk_SmartPtr<Dtk_2dEntity>;
public:
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_2dEntity* DtkDynamicCast(Dtk_Object *s);
 
     virtual type_detk get_type_detk() const = 0;
 
    Dtk_2dEntity& operator=(const Dtk_2dEntity & in);
    Dtk_2dEntity& operator=( Dtk_2dEntity && in) DTK_NOEXCEPT;
 
     virtual Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo)=0;
 
    void AddAdditionnalGeometry( const Dtk_EntityPtr& inAdditionnalGeometry);
 
    void AddAdditionnalGeometries(const Dtk_tab<Dtk_EntityPtr>& inAdditionnalGeometries);
 
    void AddAdditionnalTexts( Dtk_CompositeText inAddtionnalTexts);
 
    const Dtk_tab< Dtk_EntityPtr >& GetAdditionnalGeometries() const;
 
    const Dtk_CompositeText& GetAdditionnalTexts() const;
};
 
class Dtk_Leader:public Dtk_Object
{
public:
 
    class ApplicationZone
    {
    public:
        enum ApplicationZoneEnum
        {
            Default     = 0,
            AllAround   = 1,
            AllOver     = 2,
        };
        static inline Dtk_string ApplicationZoneEnumToString(const ApplicationZoneEnum& inEnum)
        {
            switch( inEnum )
            {
            default:
            case Default:           return L"Default";
            case AllAround:         return L"AllAround";
            case AllOver:           return L"AllOver";
            }
        }
    protected:
        ApplicationZoneEnum         _ApplicationZoneType;
        Dtk_tab< Dtk_CurvePtr >     _RelatedGeomElements;
        inline void _Init()
        {
            _ApplicationZoneType = Default;
        }
        inline void _Copy(const ApplicationZone &s)
        {
            _ApplicationZoneType = s._ApplicationZoneType;
            Dtk_Size_t i, NumElts = s._RelatedGeomElements.size();
            for( i = 0 ; i < NumElts ; i++)
            {
                Dtk_CurvePtr c;
                s._RelatedGeomElements[i].Clone(c);
                _RelatedGeomElements.push_back(c);
            }
        }
        inline void _Reset(){ _RelatedGeomElements.clear();}
    public:
 
        ApplicationZone(const ApplicationZoneEnum& inApplicationZoneType,
            const Dtk_tab< Dtk_CurvePtr >& inRelatedGeometricalElts);
 
        inline ApplicationZone()
        {
            _Init();
        }
 
        inline ~ApplicationZone(){ _Reset();}
 
        inline void Clear()
        {
            _ApplicationZoneType = Default;
            _RelatedGeomElements.clear();
        }
 
        inline void SetApplicationData(
            const ApplicationZoneEnum& inApplicationZoneType,
            Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements )
        {
            this->_ApplicationZoneType = inApplicationZoneType;
            this->_RelatedGeomElements = std::move( inRelatedGeomElements );
        }
        inline ApplicationZoneEnum GetApplicationZoneType() const {return _ApplicationZoneType;}
 
        inline void GetGeometries(Dtk_tab< Dtk_CurvePtr >& outGeoms) const
        {
            Dtk_Size_t i,nb = this->_RelatedGeomElements.size();
            outGeoms.resize(nb);
            for(i=0;i<nb;i++)
                this->_RelatedGeomElements[i].Clone(outGeoms[i]);
        }
 
        inline Dtk_ErrorStatus Translate(const Dtk_dir &inTranslateDir)
        {
            Dtk_transfo TmpMatrix;
            TmpMatrix.addTranslate( inTranslateDir );
            return Transform( TmpMatrix );
        }
        inline Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo)
        {
               if( inTransfo == Dtk_transfo() )
                    return dtkNoError;
            Dtk_Size_t i, NumGeoms = _RelatedGeomElements.size();
            for (i = 0; i < NumGeoms; i++)
            { _RelatedGeomElements[i]->Transform( inTransfo ); }
            return dtkNoError;
        }
 
        inline ApplicationZone& operator=(const ApplicationZone & in)
        {
            if (&in == this)
            {
                return *this;
            }
            _Reset();
            _Copy(in);
            return *this;
        }
          inline ApplicationZone& operator=( ApplicationZone&& in ) DTK_NOEXCEPT
          {
               if( &in == this )
               {
                    return *this;
               }
               _ApplicationZoneType = in._ApplicationZoneType;
               _RelatedGeomElements = std::move( in._RelatedGeomElements );
               return *this;
          }
    };
 
     enum LeaderTerminatorTypeEnum {
          TerminatorTypeNone = 0,
          TerminatorTypeOpenArrow,
          TerminatorTypeClosedArrow,
          TerminatorTypeFillArrow,
          TerminatorTypeCrossArrow,
          TerminatorTypeCircle,
          TerminatorTypeFilledCircle,
          TerminatorTypeSquare,
          TerminatorTypeFilledSquare,
          TerminatorTypeSlash,
          TerminatorTypeCrossedCircle,
          TerminatorTypeXCircle,
          TerminatorTypeTriangle,
          TerminatorTypeFilledTriangle,
          TerminatorTypePlus,
          TerminatorTypeXCross,
          TerminatorTypeIntegral,
          TerminatorTypeCircleCenter,
          TerminatorTypeDoubleOpenArrow,
          TerminatorTypeDoubleCloseArrow,
          TerminatorTypeDoubleFillArrow,
          TerminatorTypeDoubleTriangle,
          TerminatorTypeTopOpenArrow,
          TerminatorTypeBottomOpenArrow,
          TerminatorTypeTopFillArrow,
          TerminatorTypeBottomFillArrow,
          TerminatorTypeDoubleCrossArrow,
 
     };
    static inline Dtk_string LeaderTerminatorTypeEnumToString(const LeaderTerminatorTypeEnum& inEnum)
    {
        switch( inEnum )
        {
        case TerminatorTypeNone:                    return L"TerminatorTypeNone";
        case TerminatorTypeOpenArrow:               return L"TerminatorTypeOpenArrow";
        case TerminatorTypeClosedArrow:             return L"TerminatorTypeClosedArrow";
        case TerminatorTypeFillArrow:               return L"TerminatorTypeFillArrow";
        case TerminatorTypeCrossArrow:              return L"TerminatorTypeCrossArrow";
        case TerminatorTypeCircle:                  return L"TerminatorTypeCircle";
        case TerminatorTypeFilledCircle:            return L"TerminatorTypeFilledCircle";
        case TerminatorTypeSquare:                  return L"TerminatorTypeSquare";
        case TerminatorTypeFilledSquare:            return L"TerminatorTypeFilledSquare";
        case TerminatorTypeSlash:                   return L"TerminatorTypeSlash";
        case TerminatorTypeCrossedCircle:           return L"TerminatorTypeCrossedCircle";
        case TerminatorTypeXCircle:                 return L"TerminatorTypeXCircle";
        case TerminatorTypeTriangle:                return L"TerminatorTypeTriangle";
        case TerminatorTypeFilledTriangle:          return L"TerminatorTypeFilledTriangle";
        case TerminatorTypePlus:                    return L"TerminatorTypePlus";
        case TerminatorTypeXCross:                  return L"TerminatorTypeXCross";
        case TerminatorTypeIntegral:                return L"TerminatorTypeIntegral";
        case TerminatorTypeCircleCenter:            return L"TerminatorTypeCircleCenter";
        case TerminatorTypeDoubleOpenArrow:         return L"TerminatorTypeDoubleOpenArrow";
        case TerminatorTypeDoubleCloseArrow:        return L"TerminatorTypeDoubleCloseArrow";
        case TerminatorTypeDoubleFillArrow:         return L"TerminatorTypeDoubleFillArrow";
        case TerminatorTypeDoubleTriangle:          return L"TerminatorTypeDoubleTriangle";
          case TerminatorTypeTopOpenArrow:            return L"TerminatorTypeTopOpenArrow";
          case TerminatorTypeBottomOpenArrow:         return L"TerminatorTypeBottomOpenArrow";
          case TerminatorTypeTopFillArrow:            return L"TerminatorTypeTopFillArrow";
          case TerminatorTypeBottomFillArrow:         return L"TerminatorTypeBottomFillArrow";
          case TerminatorTypeDoubleCrossArrow:        return L"TerminatorTypeDoubleCrossArrow";
 
        default:                                    return L"Unknown";
        }
    }
     enum IncludeOptions
     {
          IncludeAll = -1,
          IncludeNone = 0,
          IncludeLeaderCurve = 1,
          IncludeLeaderArrowHead = 2,
          IncludeLeaderExtensionLine = 4,
          IncludeLeaderApplicationZone = 8,
     };
     
     class ArrowHead
     {
     protected:
          Dtk_InfoPtr                        m_Infos;
          LeaderTerminatorTypeEnum m_HeadType;
          Dtk_pnt                            m_ArrowLocation;
          Dtk_dir                            m_RefDir;
          Dtk_dir                            m_AxisDir;
 
          inline void _Init()
          {
               m_Infos = Dtk_Info::create();
               m_HeadType = TerminatorTypeOpenArrow;
               //m_RefDir;// = Dtk_dir( 1.0, 0.0, 0.0 );
               //m_AxisDir;// = Dtk_dir( 0.0, 1.0, 0.0 );
          }
          inline void _Copy( const ArrowHead &s )
          {
               s.m_Infos.Clone( m_Infos );
               m_HeadType = s.m_HeadType;
               m_ArrowLocation = s.m_ArrowLocation;
               m_RefDir = s.m_RefDir;
               m_AxisDir = s.m_AxisDir;
          }
          inline void _Reset()
          {
               m_Infos = NULL;
               m_HeadType = TerminatorTypeOpenArrow;
               //m_RefDir;// = Dtk_dir( 1.0, 0.0, 0.0 );
               //m_AxisDir;// = Dtk_dir( 0.0, 1.0, 0.0 );
          }
     protected:
     public:
          inline ArrowHead(
               const Dtk_Double64 inWidth,
               const Dtk_Double64 inHeight,
               const Dtk_pnt& inArrowLocation,
               const LeaderTerminatorTypeEnum inTerminatorType,
               const Dtk_InfoPtr& inInfos,
               const Dtk_dir& inRefDir,
               const Dtk_dir& inAxisDir )
          {
               SetData( inWidth, inHeight, inArrowLocation, inTerminatorType, inInfos, inRefDir, inAxisDir );
          }
          inline ArrowHead() { _Init(); }
          inline ~ArrowHead() { _Reset(); }
 
          inline void SetData( const Dtk_Double64 inWidth,
                           const Dtk_Double64 inHeight,
                           const Dtk_pnt& inArrowLocation,
                           const LeaderTerminatorTypeEnum inTerminatorType,
                           const Dtk_InfoPtr& inInfos,
                           const Dtk_dir& inRefDir,
                           const Dtk_dir& inAxisDir )
          {
               m_HeadType = inTerminatorType;
               m_ArrowLocation = inArrowLocation;
               m_RefDir = inRefDir;
               m_AxisDir = inAxisDir;
               SetWidthHeight( inWidth, inHeight );
               m_Infos = inInfos;
          }
          inline const Dtk_InfoPtr& GetInfo() const { return m_Infos; }
          inline Dtk_InfoPtr& GetInfo() { return m_Infos; }
          inline const Dtk_pnt& GetArrowLocation() const { return m_ArrowLocation; }
          inline const LeaderTerminatorTypeEnum GetType() const { return m_HeadType; }
          inline void SetType( const LeaderTerminatorTypeEnum inTerminatorType ) { m_HeadType = inTerminatorType; }
 
          inline void GetDirections( Dtk_dir& outRefDir, Dtk_dir& outAxisDir ) const
          {
               outRefDir = m_RefDir; outRefDir.Normalize();
               outAxisDir = m_AxisDir; outAxisDir.Normalize();
          }
          inline void GetWidthHeight( Dtk_Double64& outWidth, Dtk_Double64& outHeight ) const
          {
               outWidth = m_RefDir.norm();
               outHeight = 2. * m_AxisDir.norm();
          }
          inline void SetWidthHeight( const Dtk_Double64 inWidth, const Dtk_Double64 inHeight )
          {
               m_RefDir.Normalize();
               m_AxisDir.Normalize();
               m_RefDir *= inWidth;
               m_AxisDir *= 0.5 * inHeight;
          }
          void CreateGeometries( Dtk_tab< Dtk_CurvePtr >& outRes ) const;
          inline Dtk_ErrorStatus Translate( const Dtk_dir &inTranslateDir )
          {
               Dtk_transfo TmpMatrix;
               TmpMatrix.addTranslate( inTranslateDir );
               return Transform( TmpMatrix );
          }
          inline Dtk_ErrorStatus Transform( const Dtk_transfo &inTransfo )
          {
               m_RefDir = inTransfo * m_RefDir;
               m_AxisDir = inTransfo * m_AxisDir;
               m_ArrowLocation = inTransfo * m_ArrowLocation;
               return dtkNoError;
          }
 
          ArrowHead& operator=( const ArrowHead &in )
          {
               if( &in == this )
               {
                    return *this;
               }
               _Reset();
               _Copy( in );
               return *this;
          }
 
 
     };
public:
     enum LeaderTypeEnum
     {
          TypeUnknown = 0,
          TypeLinear,
          TypeAngular
     };
 
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_LEADER
     };
     Dtk_Leader();
 
     Dtk_Leader(const Dtk_Leader& in );
     Dtk_Leader( Dtk_Leader&& in ) DTK_NOEXCEPT;
 
     void _CommonAngularCtor(
          const Dtk_Double64 &inWidth,
          const Dtk_Double64 &inHeight,
          const Dtk_pnt &inArrowLocation,
          const Dtk_Double64 &inRadius,
          const LeaderTerminatorTypeEnum &inTerminatorType,
          const Dtk_pnt &inEndingPnt,
          const Dtk_pnt &inCenterPnt,
          const Dtk_bool &IsCounterClockwise );
     void _CommonLinearCtor(
          const Dtk_Double64 &inWidth,
          const Dtk_Double64 &inHeight,
          const Dtk_pnt &inArrowLocation,
          const LeaderTerminatorTypeEnum &inTerminatorType,
          const Dtk_tab<Dtk_pnt> &inPntsArray );
    Dtk_Leader(
        const Dtk_Double64 &inWidth,
        const Dtk_Double64 &inHeight,
        const Dtk_pnt &inArrowLocation,
        const Dtk_Double64 &inRadius,
        const LeaderTerminatorTypeEnum &inTerminatorType,
        const Dtk_pnt &inEndingPnt,
        const Dtk_pnt &inCenterPnt,
        const Dtk_bool &IsCounterClockwise);
     Dtk_Leader(
          const Dtk_Double64 &inWidth,
          const Dtk_Double64 &inHeight,
          const Dtk_pnt &inArrowLocation,
          const LeaderTerminatorTypeEnum &inTerminatorType,
          const Dtk_tab<Dtk_pnt> &inPntsArray );
 
     virtual ~Dtk_Leader();
     inline virtual Dtk_Object* Clone() { return new Dtk_Leader( *this ); }
private:
     void _Init();
     void _Reset();
     void _Copy(const Dtk_Leader &s);
 
     friend class Dtk_SmartPtr<Dtk_Leader>;
public:
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_Leader* DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_LeaderPtr Create();
 
     static Dtk_LeaderPtr Create(const Dtk_Leader &s);
     static Dtk_LeaderPtr Create( Dtk_Leader &&s );
 
    static Dtk_LeaderPtr Create(const Dtk_Double64 &inWidth,
        const Dtk_Double64 &inHeight, const Dtk_pnt &inArrowLocation,
        const Dtk_Double64 &inRadius,
        const LeaderTerminatorTypeEnum &inTerminatorType,
        const Dtk_pnt &inEndingPnt, const Dtk_pnt &inCenterPnt,
        const Dtk_bool &IsCounterClockwise);
 
    static Dtk_LeaderPtr Create(const Dtk_Double64 &inWidth,
        const Dtk_Double64& inHeight, const Dtk_pnt &inArrowLocation,
        const LeaderTerminatorTypeEnum &inTerminatorType,
        const Dtk_tab<Dtk_pnt> &inPntsArray);
 
 
     Dtk_ErrorStatus RetrieveLeader_terminator_infos(Dtk_Double64 &outWidth,
          Dtk_Double64 &outHeight, Dtk_pnt &outArrowLocation,
          LeaderTerminatorTypeEnum &outTerminatorType) const;
 
     Dtk_Leader& operator = (const Dtk_Leader &in);
     Dtk_Leader& operator = ( Dtk_Leader&& in ) DTK_NOEXCEPT;
 
     Dtk_CurvePtr GetLeaderCurve() const;
 
     void SetLeaderCurveColor( const Dtk_RGB& inColor );
 
     void SetLeaderCurveThicknessInMM( const Dtk_Double64 inCurveThicknessinMM );
 
     void SetLeaderCurveLineType(const Dtk_FontLineType inCurveLineType);
 
     LeaderTypeEnum GetLeaderType() const;
 
     Dtk_PolylinePtr GetExtensionLine() const;
 
     void SetExtensionLine( const Dtk_PolylinePtr& inExtLine );
 
    void SetLeaderTerminatorType(const LeaderTerminatorTypeEnum &inTerminatorType);
 
    void SetLeaderWidthHeight(const Dtk_Double64& inWidth, const Dtk_Double64& inHeight);
 
     void SetArrowHead( const ArrowHead& inArroWHead );
     const ArrowHead& GetArrowHead() const;
     ArrowHead& GetArrowHead();
 
     void ConvertToGeom(Dtk_tab<Dtk_CurvePtr> &outGeomsArray, const IncludeOptions inConvertToGeomFilter = IncludeAll ) const;
 
     Dtk_InfoPtr& GetInfo();
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    void SetApplicationZoneType( const Dtk_Leader::ApplicationZone::ApplicationZoneEnum& inApplicationZoneType, const Dtk_tab< Dtk_CurvePtr >& inRelatedGeomElements);
 
    void GetApplicationZone(Dtk_Leader::ApplicationZone& outApplicationZone) const;
 
    Dtk_Leader::ApplicationZone::ApplicationZoneEnum GetApplicationZoneType() const;
 
 
     Dtk_bool GetAllAroundSet() const;
 
    const Dtk_pnt& GetArrowLocation() const;
 
     void SetAllAroundSet(const Dtk_bool & inAllAroundSetValue);
 
     double GetStubDelta() const;
 
     void SetStubDelta(const double & inStubDelta);
 
};
 
class Dtk_Annotation : public Dtk_2dEntity
{
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_ANNOTATION
     };
     virtual ~Dtk_Annotation();
 
     Dtk_Annotation();
 
     Dtk_Annotation(const Dtk_Annotation &in);
     Dtk_Annotation( Dtk_Annotation&& in) DTK_NOEXCEPT;
 
     Dtk_Annotation(const Dtk_pnt &inLocationPnt, const Dtk_InfoPtr &inInfos,
          Dtk_tab<Dtk_LeaderPtr> inLeadersArray = Dtk_tab<Dtk_LeaderPtr>(),
          const Dtk_Double64 &inAngle = 0.0, const Dtk_Double64 &inOffSet = 0.0,
          const Dtk_anchor_type &inAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_justication_type &inJustificationType = DTK_JUSTIFY_LEFT);
    virtual Dtk_Object* Clone() = 0;
 
private:
     void _Init();
     void _Reset();
     void _Copy(const Dtk_Annotation &s);
     friend class Dtk_SmartPtr<Dtk_Annotation>;
public:
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_Annotation *DtkDynamicCast(Dtk_Object *s);
 
     Dtk_Annotation& operator=(const Dtk_Annotation &in);
     Dtk_Annotation& operator=( Dtk_Annotation&& in ) DTK_NOEXCEPT;
 
     Dtk_Size_t GetNumLeaders() const;
 
     Dtk_LeaderPtr GetLeader(const Dtk_Size_t &inPos) const;
 
     Dtk_ErrorStatus AddLeader(const Dtk_LeaderPtr &leader);
 
     SetAsDeprecated("Undefined", "Use Dtk_TextStyle::Justification()")
     Dtk_justication_type GetJustification() const;
 
     Dtk_Double64 GetRotationAngle(
          const Dtk_dir &inXAxis = Dtk_dir(1,0,0),
          const Dtk_dir& inYAxis = Dtk_dir(0,1,0)) const;
 
     Dtk_Double64 GetOffset() const;
 
     Dtk_dir GetXAxis() const;
 
     Dtk_dir GetYAxis() const;
 
     const Dtk_anchor_type& GetLocationAnchorType() const;
 
     virtual Dtk_pnt GetLocation() const;
 
     virtual Dtk_ErrorStatus Reverse();
 
     // The interface functions
     virtual type_detk get_type_detk() const = 0;
 
     virtual Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const = 0;
 
     virtual Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType) = 0;
 
     virtual Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation) = 0;
 
 
    Dtk_ErrorStatus SetLocation(const Dtk_pnt& location, const Dtk_anchor_type& inAnchorType);
 
     virtual Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset) = 0;
 
     virtual Dtk_ErrorStatus SetRotationAngle(
          const Dtk_Double64 &inRotationAngle);
 
     virtual Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo) = 0;
};
 
class Dtk_Roughness : public Dtk_Annotation
{
public :
     enum ObtentionTypeEnum{
          ObtentionTypeNotDefined = 0,
          ObtentionTypeMachiningMandatory,
          ObtentionTypeMachiningForbidden
     };
 
     enum ApplyToEnum{
          ApplyToSpecifiedSurface = 0,
          ApplyToSurroundingSurfaces,
          ApplyToBasicSurface,
          ApplyToAllSurfaces
     };
 
     enum RoughModeEnum{
          ModeNone = 0,
          ModeMultiDirectional,
          ModeCircular,
          ModeRadial,
          ModeParticular,
          ModeWithAngles,
          ModeParallel,
          ModePerpendicular
     };
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum
     {
          _typeID = DTK_TYPE_ROUGHNESS
     };
 
     Dtk_Roughness();
 
     Dtk_Roughness(
          const Dtk_pnt &inLocationPnt,
          Dtk_Text inTopLeftText = Dtk_Text(),
          Dtk_Text inMiddleLeftText = Dtk_Text(),
          Dtk_Text inBottomLeftText = Dtk_Text(),
          Dtk_Text inTopRightText = Dtk_Text(),
          Dtk_Text inMiddleRightText = Dtk_Text(),
          Dtk_Text inBottomRightText = Dtk_Text(),
          const ObtentionTypeEnum &inObtentionType = ObtentionTypeNotDefined,
          const ApplyToEnum &inApplyToType = ApplyToSpecifiedSurface,
          const Dtk_InfoPtr &inInfos = NULL,
          Dtk_tab<Dtk_LeaderPtr> inLeadersArray = Dtk_tab<Dtk_LeaderPtr>(),
          const Dtk_Double64 &inAngle = 0.0,
          const Dtk_Double64 &inOffSet = 0.0,
          const Dtk_anchor_type &inAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_justication_type &inJustificationType = DTK_JUSTIFY_LEFT);
 
     Dtk_Roughness(
          const Dtk_pnt &inLocationPnt,
          const Dtk_InfoPtr &inInfos,
          Dtk_tab<Dtk_LeaderPtr> inLeadersArray = Dtk_tab<Dtk_LeaderPtr>(),
          const Dtk_Double64 &inAngle = 0.0,
          const Dtk_Double64 &inOffSet = 0.0,
          const Dtk_anchor_type &inAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_justication_type &inJustificationType = DTK_JUSTIFY_LEFT);
 
     Dtk_Roughness(const Dtk_Roughness &s);
     Dtk_Roughness( Dtk_Roughness&& s ) DTK_NOEXCEPT;
 
     ~Dtk_Roughness();
 
     Dtk_Double64 _ProcessSideLength();
     Dtk_pnt _GetStartPoint() const;
 
    inline virtual Dtk_Object* Clone() { return new Dtk_Roughness(*this); }
 
private:
     void _Init();
     void _Copy(const Dtk_Roughness &s);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_Roughness>;
     friend class Dtk_Symbol;
public:
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_Roughness * DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_RoughnessPtr Create();
 
     static Dtk_RoughnessPtr Create(const Dtk_pnt &inLocationPnt,
          Dtk_Text inTopLeftText = Dtk_Text(),
          Dtk_Text inMiddleLeftText = Dtk_Text(),
          Dtk_Text inBottomLeftText = Dtk_Text(),
          Dtk_Text inTopRightText = Dtk_Text(),
          Dtk_Text inMiddleRightText = Dtk_Text(),
          Dtk_Text inBottomRightText = Dtk_Text(),
          const ObtentionTypeEnum &inObtentionType = ObtentionTypeNotDefined,
          const ApplyToEnum &inApplyToType = ApplyToSpecifiedSurface,
          const Dtk_InfoPtr &inInfos = NULL,
          Dtk_tab<Dtk_LeaderPtr> inLeadersArray = Dtk_tab<Dtk_LeaderPtr>(),
          const Dtk_Double64 &inAngle = 0.0,
          const Dtk_Double64 &inOffSet = 0.0,
          const Dtk_anchor_type &inAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_justication_type &inJustificationType = DTK_JUSTIFY_LEFT);
 
     static Dtk_RoughnessPtr Create(const Dtk_pnt &inLocationPnt,
          const Dtk_InfoPtr &inInfos,
          Dtk_tab<Dtk_LeaderPtr> inLeadersArray = Dtk_tab<Dtk_LeaderPtr>(),
          const Dtk_Double64 &inAngle = 0.0, const Dtk_Double64 &inOffSet = 0.0,
          const Dtk_anchor_type &inAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_justication_type &inJustificationType = DTK_JUSTIFY_LEFT);
 
     static Dtk_RoughnessPtr Create(const Dtk_Roughness &in);
     static Dtk_RoughnessPtr Create( Dtk_Roughness&& in );
 
     Dtk_Roughness& operator=(const Dtk_Roughness &in);
 
     Dtk_Text rough_mode_to_Dtk_Text() const;
 
    Dtk_Oriented2dBBox GetOuterBoundingBox(const Dtk_bool inIncludeSymbolGeometry) const;
     Dtk_ErrorStatus SetTopLeftText( Dtk_Text inText);
 
     Dtk_ErrorStatus SetMiddleLeftText( Dtk_Text inText);
 
     Dtk_ErrorStatus SetBottomLeftText( Dtk_Text inText);
 
     Dtk_ErrorStatus SetTopRightText( Dtk_Text inText);
 
     Dtk_ErrorStatus SetMiddleRightText( Dtk_Text inText);
 
     Dtk_ErrorStatus SetBottomRightText( Dtk_Text inText);
 
    Dtk_ErrorStatus SetCutOff( Dtk_Text inText);
 
    Dtk_ErrorStatus SetOtherRequirement( Dtk_Text inText);
 
    Dtk_ErrorStatus SetRoughMode( Dtk_Text inRoughModeText);
 
     Dtk_ErrorStatus SetRoughnessType(const ObtentionTypeEnum &inObtentionType);
 
     Dtk_ErrorStatus SetRoughnessApplyTo(const ApplyToEnum &inApplyTo);
 
     void SetInvertText( Dtk_Int32 inValue=DTK_FALSE );
 
     Dtk_Text GetTopLeftText() const;
 
     Dtk_Text GetMiddleLeftText() const;
 
     Dtk_Text GetBottomLeftText() const;
 
     Dtk_Text GetTopRightText() const;
 
     Dtk_Text GetMiddleRightText() const;
 
     Dtk_Text GetBottomRightText() const;
 
    Dtk_Text GetCutOff() const;
 
    Dtk_Text GetOtherRequirement() const;
 
     ObtentionTypeEnum GetRoughnessType() const;
 
     ApplyToEnum GetRoughnessApplyTo() const;
 
     RoughModeEnum GetRoughMode() const;
 
     Dtk_Int32 GetInvertText( ) const;
 
     Dtk_ErrorStatus GetAnchorPoints( Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     Dtk_ErrorStatus GetAnchorPoints( Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]);
 
     type_detk get_type_detk() const { return DTK_TYPE_ROUGHNESS; }
 
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
     Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &angle);
 
     Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
    void Translate(const Dtk_dir &inTranslationDir);
 
    void ProcessSymbolInfos(Dtk_tab< Dtk_pnt >& outPnts, Dtk_Double64& outCircleRadius) const;
 
    void SetSymbolColor(Dtk_Int32 inColorId) const;
 
    void GetSymbolColor(Dtk_Int32& outColorId) const;
 
 
     void AddAssociatedGeometries( Dtk_tab< Dtk_EntityPtr > inAssociatedGeometries );
 
     Dtk_tab< Dtk_EntityPtr > GetGeometries() const;
};
 
class Dtk_Welding : public Dtk_Annotation
{
public :
    enum WeldingSymbolEnum{
        SymbolNone = 0,
        SymbolSquareButtWeld,
        SymbolSingeVButtWeld,
        SymbolSingleBevelButtWeld,
        SymbolFlareVButtWeld,
        SymbolFlareBevelButtWeld,
        SymbolSingleUButtWeld,
        SymbolSingleJButtWeld,
        SymbolFilletWeld,
        SymbolSpotWeld,
        SymbolBackWeld,
        SymbolSteepFlankedSingleBevelButtWeld,
        SymbolSteepFlankedSingleVWeld,
        SymbolPlugWeld,
        SymbolRemovableBackingStripUsed,
        SymbolPermanentBackingStripUsed,
        SymbolSurfacingWeld,
        SymbolSeamWeld,
        SymbolFlangeEdge,
        SymbolStickWeld,
        SymbolFlangeCorner,
        SymbolVFlareWeld,
        SymbolFlareBevelWeld,
        SymbolScarfWeld,
        SymbolStudWeld,
        SymbolANSIEdgeWeld,
        SymbolISOEdgeWeld,
        SymbolSurfaceJointWeld,
        SymbolInclinedJointWeld,
        SymbolMeltThroughWeld,
          SymbolSolderedJointWeld,
          SymbolFoldJointWeld,
          SymbolKGrooveWeld,
          SymbolStakeWeld
    };
    static inline Dtk_string WeldingSymbolEnumToString(const WeldingSymbolEnum& inEnum)
    {
        switch( inEnum )
        {
        case SymbolNone :                               return L"SymbolNone";
        case SymbolSquareButtWeld :                     return L"SymbolSquareButtWeld";
        case SymbolSingeVButtWeld :                     return L"SymbolSingeVButtWeld";
        case SymbolSingleBevelButtWeld :                return L"SymbolSingleBevelButtWeld";
        case SymbolFlareVButtWeld :                     return L"SymbolFlareVButtWeld";
        case SymbolFlareBevelButtWeld :                 return L"SymbolFlareBevelButtWeld";
        case SymbolSingleUButtWeld :                    return L"SymbolSingleUButtWeld";
        case SymbolSingleJButtWeld :                    return L"SymbolSingleJButtWeld";
        case SymbolFilletWeld :                         return L"SymbolFilletWeld";
        case SymbolSpotWeld :                           return L"SymbolSpotWeld";
        case SymbolBackWeld :                           return L"SymbolBackWeld";
        case SymbolSteepFlankedSingleBevelButtWeld :    return L"SymbolSteepFlankedSingleBevelButtWeld";
        case SymbolSteepFlankedSingleVWeld :            return L"SymbolSteepFlankedSingleVWeld";
        case SymbolPlugWeld :                           return L"SymbolPlugWeld";
        case SymbolRemovableBackingStripUsed :          return L"SymbolRemovableBackingStripUsed";
        case SymbolPermanentBackingStripUsed :          return L"SymbolPermanentBackingStripUsed";
        case SymbolSurfacingWeld :                      return L"SymbolSurfacingWeld";
        case SymbolSeamWeld :                           return L"SymbolSeamWeld";
        case SymbolFlangeEdge :                         return L"SymbolFlangeEdge";
        case SymbolStickWeld :                          return L"SymbolStickWeld";
        case SymbolFlangeCorner :                       return L"SymbolFlangeCorner";
        case SymbolVFlareWeld :                         return L"SymbolVFlareWeld";
        case SymbolFlareBevelWeld :                     return L"SymbolFlareBevelWeld";
        case SymbolScarfWeld :                          return L"SymbolScarfWeld";
        case SymbolStudWeld :                           return L"SymbolStudWeld";
        case SymbolANSIEdgeWeld :                       return L"SymbolANSIEdgeWeld";
        case SymbolISOEdgeWeld :                        return L"SymbolISOEdgeWeld";
        case SymbolSurfaceJointWeld :                   return L"SymbolSurfaceJointWeld";
        case SymbolInclinedJointWeld :                  return L"SymbolInclinedJointWeld";
          case SymbolMeltThroughWeld:                     return L"SymbolMeltThroughWeld";
          case SymbolSolderedJointWeld:                   return L"SymbolSolderedJointWeld";
          case SymbolFoldJointWeld:                       return L"SymbolFoldJointWeld";
          case SymbolKGrooveWeld:                         return L"SymbolKGrooveWeld";
          case SymbolStakeWeld:                           return L"SymbolFoldJointWeldSymbolStakeWeld";
        default :                                       return L"Unknown";
        }
    }
 
    enum ComplementarySymbolEnum{
        ComplementarySymbolNone = 0,
        ComplementarySymbolWeldWithFlatFace,
        ComplementarySymbolWeldWithConvexFace,
        ComplementarySymbolWeldWithConcaveFace,
        ComplementarySymbolFlushFinishedWeld,
        ComplementarySymbolFilletWeldWithSmoothBlendedFace
    };
 
     enum WeldTextType
     {
          WeldTextUndefinedType = 0,
          WeldTextFinishSymbol,
          WeldTextAngle,
          WeldTextNum,
          WeldTextLength,
          WeldTextSize,
          WeldTextDepth,
          WeldTextClearance,
          WeldTextSecondFilletSize,
          WeldTextSecondFilletLength,
          WeldTextOpening,
          WeldTextWeldSymbol
     };
 
    static inline Dtk_string ComplementarySymbolEnumToString(const ComplementarySymbolEnum& inEnum)
    {
        switch( inEnum )
        {
        case ComplementarySymbolNone :                               return L"ComplementarySymbolNone";
        case ComplementarySymbolWeldWithFlatFace :                   return L"ComplementarySymbolWeldWithFlatFace";
        case ComplementarySymbolWeldWithConvexFace :                 return L"ComplementarySymbolWeldWithConvexFace";
        case ComplementarySymbolWeldWithConcaveFace :                return L"ComplementarySymbolWeldWithConcaveFace";
        case ComplementarySymbolFlushFinishedWeld :                  return L"ComplementarySymbolFlushFinishedWeld";
        case ComplementarySymbolFilletWeldWithSmoothBlendedFace :    return L"ComplementarySymbolFilletWeldWithSmoothBlendedFace";
        default :                                                    return L"Unknown";
        }
    }
 
    enum FinishSymbolEnum{
        FinishSymbolNone = 0,
        FinishSymbolChip,
        FinishSymbolFlush,
        FinishSymbolGrind,
        FinishSymbolHammer,
        FinishSymbolMachine,
        FinishSymbolRoll,
          FinishSymbolPeening,
        FinishSymbolUnspecified
    };
    static inline Dtk_string FinishSymbolEnumToString(const FinishSymbolEnum& inEnum)
    {
        switch( inEnum )
        {
        case FinishSymbolNone :                                     return L"FinishSymbolNone";
        case FinishSymbolChip :                                     return L"FinishSymbolChip";
        case FinishSymbolFlush :                                    return L"FinishSymbolFlush";
        case FinishSymbolGrind :                                    return L"FinishSymbolGrind";
        case FinishSymbolHammer :                                   return L"FinishSymbolHammer";
        case FinishSymbolMachine :                                  return L"FinishSymbolMachine";
          case FinishSymbolRoll :                                     return L"FinishSymbolRoll";
          case FinishSymbolPeening :                                  return L"FinishSymbolPeening";
        case FinishSymbolUnspecified :                              return L"FinishSymbolUnspecified";
        default :                                                   return L"Unknown";
        }
    }
 
protected:
    // Weld Symbol Terminology :
    //
    // OTHER SIDE
    // ------------
    // ARROW SIDE  \
    //             _\|
    //
    struct Dtk_Handle; // Not defined here
    Dtk_Handle *_Private; // Handle
    enum { _typeID = DTK_TYPE_WELDING };
 
    Dtk_Welding();
 
    Dtk_Welding(const Dtk_pnt &inLocation,
        Dtk_CompositeText inMiddleRightText,
        const Dtk_bool inFieldWeldActivated,
        const Dtk_Char8 inIndentLineFlag,
        const Dtk_bool inTailActivated,
        const Dtk_bool inReverseTailAndField,
        const Dtk_InfoPtr &inInfos,
        Dtk_tab<Dtk_LeaderPtr> inLeaders,
        const Dtk_Double64 inAngle,
        const Dtk_Double64 inOffset,
        const Dtk_anchor_type inAnchorType,
        const Dtk_justication_type inJustification);
 
    Dtk_Welding(const Dtk_pnt &inLocation,
        const Dtk_InfoPtr &inInfos,
        Dtk_tab<Dtk_LeaderPtr> inLeaders = Dtk_tab<Dtk_LeaderPtr>(),
        const Dtk_Double64 inAngle = 0.0,
        const Dtk_Double64 inOffset = 0.0,
        const Dtk_anchor_type inAnchor_type = DTK_ANCHOR_BOTTOM_LEFT,
        const Dtk_justication_type inJustification = DTK_JUSTIFY_LEFT);
 
    Dtk_Welding(const Dtk_Welding &s);
     Dtk_Welding( Dtk_Welding&& s ) DTK_NOEXCEPT;
 
    ~Dtk_Welding();
    inline virtual Dtk_Object* Clone() { return new Dtk_Welding(*this); }
private:
    void _Init();
    void _Copy(const Dtk_Welding& s);
    void _Reset();
    friend class Dtk_SmartPtr<Dtk_Welding>;
    friend class Dtk_Symbol;
public:
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    static Dtk_Welding * DtkDynamicCast(Dtk_Object *s);
public:
    static Dtk_WeldingPtr Create();
 
    static Dtk_WeldingPtr Create(const Dtk_pnt &inLocation,
        Dtk_CompositeText inTailText,
        const Dtk_bool inFieldWeldActivated,
        const Dtk_Char8 inIndentLineFlag,
        const Dtk_bool inTailActivated,
        const Dtk_bool inReverseTailAndField,
        const Dtk_InfoPtr &inInfos,
        Dtk_tab<Dtk_LeaderPtr> inLeaders,
        const Dtk_Double64 inAngle,
        const Dtk_Double64 inOffset,
        const Dtk_anchor_type inAnchorType,
        const Dtk_justication_type inJustification);
 
    static Dtk_WeldingPtr Create(const Dtk_pnt &inLocation,
        const Dtk_InfoPtr &inInfos,
        Dtk_tab<Dtk_LeaderPtr> inLeaders = Dtk_tab<Dtk_LeaderPtr>(),
        const Dtk_Double64 inAngle = 0.0,
        const Dtk_Double64 inOffset = 0.0,
        const Dtk_anchor_type inAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
        const Dtk_justication_type inJustification = DTK_JUSTIFY_LEFT);
 
    static Dtk_WeldingPtr Create(const Dtk_Welding &in);
     static Dtk_WeldingPtr Create( Dtk_Welding &&in );
 
    Dtk_Welding& operator = (const Dtk_Welding &in);
 
    //Dtk_Annotation interface
    Dtk_ErrorStatus GetAnchorPoints(
        Dtk_pnt (&inTabPoints)[DTK_NB_ANCHOR_TYPES]) const;
    Dtk_ErrorStatus GetAnchorPoints(
        Dtk_pnt (&inTabPoints)[DTK_NB_ANCHOR_TYPES]);
 
    type_detk get_type_detk() const { return DTK_TYPE_WELDING; }
 
    void AddAssociatedGeometries( Dtk_tab< Dtk_EntityPtr > inAssociatedGeometries);
 
     void AddAssociatedGeometry( Dtk_EntityPtr inAssociatedGeometry );
 
     void SetOtherSideTexts( std::unordered_map <Dtk_UInt8, Dtk_CompositeText>& inTexts );
 
     void AddOtherSideText( WeldTextType inType, Dtk_CompositeText inText );
 
     void AddOtherSideUndefinedText( Dtk_CompositeText inText );
 
     void SetArrowSideTexts( std::unordered_map <Dtk_UInt8, Dtk_CompositeText>& inTexts );
 
     void AddArrowSideText( WeldTextType inType, Dtk_CompositeText inText );
 
     void AddArrowSideUndefinedText( Dtk_CompositeText inText );
 
     void SetArrowSideWeldingSymbol( WeldingSymbolEnum inWeldingSymbol );
 
     void SetArrowSideContourSymbol( ComplementarySymbolEnum inContourSymbol );
 
     void SetArrowSideAssociatedGeometries( Dtk_tab< Dtk_EntityPtr > inAssociatedGeometries );
 
     void AddArrowSideAssociatedGeometry( Dtk_EntityPtr inAssociatedGeometry );
 
     void SetOtherSideWeldingSymbol( WeldingSymbolEnum inWeldingSymbol );
 
     void SetOtherSideContourSymbol( ComplementarySymbolEnum inContourSymbol );
 
     void SetOtherSideAssociatedGeometries( Dtk_tab< Dtk_EntityPtr > inAssociatedGeometries );
 
     void AddOtherSideAssociatedGeometry( Dtk_EntityPtr inAssociatedGeometry );
 
     std::unordered_map <Dtk_UInt8, Dtk_CompositeText> GetArrowSideAllTexts() const;
 
     std::unordered_map <Dtk_UInt8, Dtk_CompositeText> GetOtherSideAllTexts() const;
 
    void SetOtherSideData(
        const WeldingSymbolEnum inWeldingSymbol,
        Dtk_Text inNumWeldsText,
        Dtk_Text inAngleText,
        const ComplementarySymbolEnum inContourSymbol,
        Dtk_Text inFinishSymbolText,
        Dtk_Text inSizeText,
        Dtk_Text inLengthText,
        Dtk_tab< Dtk_EntityPtr > inAssociatedGeometries);
 
    void SetArrowSideData(
        const WeldingSymbolEnum inWeldingSymbol,
        Dtk_Text inNumWeldsText,
        Dtk_Text inAngleText,
        const ComplementarySymbolEnum inContourSymbol,
        Dtk_Text inFinishSymbolText,
        Dtk_Text inSizeText,
        Dtk_Text inLengthText,
        Dtk_tab< Dtk_EntityPtr > inAssociatedGeometries);
 
    void SetTailText( Dtk_CompositeText inTailText);
 
    void SetArrowSideSizeText( Dtk_CompositeText inArrowSideSizeText);
 
    void SetOtherSideSizeText( Dtk_CompositeText inOtherSideSizeText);
 
    void SetFieldWeldFlag(const Dtk_bool inFieldWeldFlag);
 
    void SetIndentLineFlag(const Dtk_Char8 inIndentLineFlag = -1);
 
    void SetWeldTailActivated(const Dtk_bool inTailActivated = DTK_FALSE);
 
    void SetReverseTailAndFieldFlag(const Dtk_bool  inReverseTailAndField = DTK_TRUE);
 
    Dtk_bool GetFieldWeldActivated() const;
 
    Dtk_Char8 GetIndentLineFlag() const;
 
    Dtk_bool GetWeldTailActivated() const;
 
    Dtk_bool GetReverseTailAndFieldFlag() const;
 
    //ArrowSide - BottomLine - Accessors
 
    Dtk_Text GetFinishSymbolTextArrowSide() const;
 
    Dtk_Text GetAngleTextArrowSide() const;
 
    Dtk_Text GetNumWeldsTextArrowSide() const;
 
    Dtk_Text GetSizeTextArrowSide() const;
 
    Dtk_Text GetLengthTextArrowSide() const;
 
    WeldingSymbolEnum GetWeldingSymbolArrowSide() const;
 
    ComplementarySymbolEnum GetComplementarySymbolArrowSide() const;
 
    FinishSymbolEnum GetFinishSymbolArrowSide() const;
 
    Dtk_Text GetFinishSymbolArrowSideAsText() const;
 
    //OtherSide - _TopLine - Accessors
    Dtk_Text GetFinishSymbolTextOtherSide() const;
 
    Dtk_Text GetAngleTextOtherSide() const;
 
    Dtk_Text GetNumWeldsTextOtherSide() const;
 
    Dtk_Text GetSizeTextOtherSide() const;
 
    Dtk_Text GetLengthTextOtherSide() const;
 
    WeldingSymbolEnum GetWeldingSymbolOtherSide() const;
 
    ComplementarySymbolEnum GetComplementarySymbolOtherSide() const;
 
    FinishSymbolEnum GetFinishSymbolOtherSide() const;
 
    Dtk_Text GetFinishSymbolOtherSideAsText() const;
 
     Dtk_bool GetBrazingOtherSide() const;
 
     void SetBrazingOtherSide( const Dtk_bool inBrazing = DTK_TRUE );
 
     Dtk_bool GetBrazingArrowSide() const;
 
     void SetBrazingArrowSide( const Dtk_bool inBrazing = DTK_TRUE );
 
    Dtk_CompositeText GetTailText() const;
 
    Dtk_CompositeText GetOtherSideSizeText() const;
 
    Dtk_CompositeText GetArrowSideSizeText() const;
 
    Dtk_tab< Dtk_EntityPtr > GetGeometries(
        const Dtk_bool inIncludeWeldBodyGeometries = DTK_TRUE,
        const Dtk_bool inIncludeOtherSideGeometries = DTK_TRUE,
        const Dtk_bool inIncludeArrowSideGeometries = DTK_TRUE) const;
 
    Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
        const Dtk_anchor_type &inLocationAnchorType);
 
    Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
    Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &inAngle);
 
    Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
    Dtk_Char8 FinishSymbolToDtk_Text( const FinishSymbolEnum inFinishSymbol) const;
 
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    void ProcessSymbolInfos(Dtk_tab< Dtk_pnt >& outPnts) const;
 
     void SetSymbolInfos( Dtk_tab< Dtk_pnt >& inPnts );
 
 
     void SetArrowSideDepthText( Dtk_CompositeText inArrowSideDepthText );
 
     Dtk_CompositeText GetArrowSideDepthText() const;
 
     void SetArrowSideClearanceText( Dtk_CompositeText inArrowSideClearanceText );
 
     Dtk_CompositeText GetArrowSideClearanceText() const;
 
     void SetArrowSideSecondFilletSizeText( Dtk_CompositeText inArrowSideSecondFilletSizeText );
 
     Dtk_CompositeText GetArrowSideSecondFilletSizeText() const;
 
     void SetArrowSideSecondFilletLengthText( Dtk_CompositeText inArrowSideSecondFilletLengthText );
 
     Dtk_CompositeText GetArrowSideSecondFilletLengthText() const;
 
     void SetArrowSideOpeningText( Dtk_CompositeText inArrowSideOpeningText );
 
     Dtk_CompositeText GetArrowSideOpeningText() const;
 
     void SetArrowSideWeldSymbolText( Dtk_CompositeText inArrowSideWeldSymbolText );
 
     Dtk_CompositeText GetArrowSideWeldSymbolText() const;
 
     Dtk_CompositeText GetArrowSideUndefinedText() const;
 
 
     void SetOtherSideDepthText( Dtk_CompositeText inOtherSideDepthText );
 
     Dtk_CompositeText GetOtherSideDepthText() const;
 
     void SetOtherSideClearanceText( Dtk_CompositeText inOtherSideClearanceText );
 
     Dtk_CompositeText GetOtherSideClearanceText() const;
 
     void SetOtherSideSecondFilletSizeText( Dtk_CompositeText inOtherSideSecondFilletSizeText );
 
     Dtk_CompositeText GetOtherSideSecondFilletSizeText() const;
 
     void SetOtherSideSecondFilletLengthText( Dtk_CompositeText inOtherSideSecondFilletLengthText );
 
     Dtk_CompositeText GetOtherSideSecondFilletLengthText() const;
 
     void SetOtherSideOpeningText( Dtk_CompositeText inOtherSideOpeningText );
 
     Dtk_CompositeText GetOtherSideOpeningText() const;
 
     void SetOtherSideWeldSymbolText( Dtk_CompositeText inOtherSideWeldSymbolText );
 
     Dtk_CompositeText GetOtherSideWeldSymbolText() const;
 
     Dtk_CompositeText GetOtherSideUndefinedText() const;
};
 
class Dtk_DatumTarget : public Dtk_Annotation
{
public:
    enum DatumTargetTypeEnum
    {
        Unknown     = 0,
        Point       = 1,
        Linear      = 2,
        Rectangular = 3,
        Circular    = 4,
        Annular     = 5,
        Spherical   = 6,
        Cylindrical = 7,
        Arbitrary   = 8,
 
        NumTypes
 
    };
    static inline Dtk_string DatumTargetTypeEnumToString(const DatumTargetTypeEnum& inEnum)
    {
        switch( inEnum )
        {
        default:
        case Unknown:       return L"Unknown";
        case Point:         return L"Point";
        case Linear:        return L"Linear";
        case Rectangular:   return L"Rectangular";
        case Circular:      return L"Circular";
        case Annular:       return L"Annular";
        case Spherical:     return L"Spherical";
        case Cylindrical:   return L"Cylindrical";
        case Arbitrary:     return L"Arbitrary";
        }
    }
 
     enum DatumTargetMovableStatusEnum
     {
          NonMovable = 0,
          Movable = 1
     };
     static inline Dtk_string DatumTargetMovableStatusEnumToString( const DatumTargetMovableStatusEnum& inEnum )
     {
          switch( inEnum )
          {
               default:
               case NonMovable:    return L"NonMovable";
               case Movable:       return L"Movable";
          }
     }
 
     enum DatumTargetValueEnum
     {
          DiameterValue      = 0,
          InnerDiameterValue = 1,
          OuterDiameterValue = 2,
          WidthValue         = 3,
          HeightValue        = 4,
          StartPointValue    = 5,
          EndPointValue      = 6,
          AreaValue          = 7,
          NumValues
     };
 
     static inline Dtk_string DatumTargetValueEnumToString(const DatumTargetValueEnum& inEnum)
     {
          switch (inEnum)
          {
          default:
          case DiameterValue:       return L"DiameterValue";
          case InnerDiameterValue:  return L"InnerDiameterValue";
          case OuterDiameterValue:  return L"OuterDiameterValue";
          case WidthValue:          return L"WidthValue";
          case HeightValue:         return L"HeightValue";
          case StartPointValue:     return L"StartPointValue";
          case EndPointValue:       return L"EndPointValue";
          case AreaValue:           return L"AreaValue";
          }
     }
 
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum
     {
          _typeID = DTK_TYPE_DATUM_TARGET
     };
 
     Dtk_DatumTarget();
 
     Dtk_DatumTarget(const Dtk_DatumTarget& inToBeCopied);
     Dtk_DatumTarget( Dtk_DatumTarget&& inToBeMoved ) DTK_NOEXCEPT;
 
     Dtk_DatumTarget( Dtk_CompositeText inTopText,
           Dtk_CompositeText inBottomText, const Dtk_pnt& inLocationPnt,
          const Dtk_InfoPtr& inInfos,
           Dtk_tab<Dtk_LeaderPtr> inLeadersArray = Dtk_tab<Dtk_LeaderPtr>(),
          const Dtk_Double64& inAngle = 0.0, const Dtk_Double64& inOffSet = 0.0,
          const Dtk_bool& inHasFrame = DTK_TRUE,
          const Dtk_anchor_type& inAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_justication_type& inJustificationType = DTK_JUSTIFY_LEFT);
    inline virtual Dtk_Object* Clone() { return new Dtk_DatumTarget(*this); }
 
     ~Dtk_DatumTarget();
private:
     void _Init();
     void _Copy(const Dtk_DatumTarget& s);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_DatumTarget>;
public:
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_DatumTarget* DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_DatumTargetPtr Create();
 
     static Dtk_DatumTargetPtr Create(const Dtk_DatumTarget &in);
     static Dtk_DatumTargetPtr Create( Dtk_DatumTarget&& in );
 
     static Dtk_DatumTargetPtr Create( Dtk_CompositeText inTopText,
           Dtk_CompositeText inBottomText, const Dtk_pnt &inLocationPnt,
          const Dtk_InfoPtr &inInfos,
           Dtk_tab<Dtk_LeaderPtr> inLeadersArray = Dtk_tab<Dtk_LeaderPtr>(),
          const Dtk_Double64 &inAngle = 0.0, const Dtk_Double64 &inOffSet = 0.0,
          const Dtk_bool &inHasFrame = DTK_TRUE,
          const Dtk_anchor_type &inAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_justication_type &inJustificationType = DTK_JUSTIFY_LEFT);
 
     Dtk_DatumTarget& operator =(const Dtk_DatumTarget &in);
     Dtk_DatumTarget& operator =( Dtk_DatumTarget&& in ) DTK_NOEXCEPT;
 
     Dtk_Double64 ProcessRadius() const ;
 
    void SetDatumTargetType( const DatumTargetTypeEnum inType );
 
    Dtk_DatumTarget::DatumTargetTypeEnum GetDatumTargetType() const;
 
     void SetDatumTargetMovable( const DatumTargetMovableStatusEnum inMovableStatus,
                                         Dtk_tab<Dtk_CurvePtr> inMovableGeom );
 
     Dtk_DatumTarget::DatumTargetMovableStatusEnum GetDatumTargetMovableStatus() const;
 
     Dtk_tab<Dtk_CurvePtr> & GetDatumTargetMovableStatusRelatedGeom() const;
 
     Dtk_CompositeText &TopText();
 
     void SetOptionnalTopTextLeader( const Dtk_LeaderPtr & inLeader );
 
     const Dtk_LeaderPtr &GetOptionnalTopTextLeader() const;
 
     Dtk_CompositeText &BottomText();
 
     void SetOptionnalBottomTextLeader( const Dtk_LeaderPtr & inLeader );
 
     const Dtk_LeaderPtr &GetOptionnalBottomTextLeader() const;
 
     const Dtk_CompositeText &TopText() const;
 
     const Dtk_CompositeText &BottomText() const;
 
     const Dtk_bool& HasFrame() const;
 
     void EnableFrame();
 
     void DisableFrame();
 
     void SetFrame( Dtk_Frame inFrame );
 
     const Dtk_Frame &GetFrame() const;
 
     Dtk_pnt ProcessCenterPoint() const;
 
    Dtk_Oriented2dBBox ProcessBoundingBox() const;
 
     //Dtk_Annotation interface
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]);
 
     Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     type_detk get_type_detk() const
     {
          return DTK_TYPE_DATUM_TARGET;
     }
 
     Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
     Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
     Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &inRotationAngle);
 
     Dtk_ErrorStatus SwapTexts();
 
    Dtk_tab< Dtk_EntityPtr > GetGeometries() const;
 
     Dtk_ErrorStatus Reverse();
    void Translate(const Dtk_dir &inTranslationDir);
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     Dtk_ErrorStatus SetParameterValue(const DatumTargetValueEnum &inValueEnum, Dtk_Val inValue);
 
     Dtk_ErrorStatus GetParameterValue(const DatumTargetValueEnum &inValueEnum, Dtk_Val& outValue);
};
 
class Dtk_OneCell
{
protected:
     Dtk_Double64 _Height;
     Dtk_Double64 _Width;
     Dtk_Double64 min_Height;
     Dtk_Double64 min_Width;
    Dtk_bool        _HasText;
     Dtk_CompositeText _text;
     Dtk_Size_t anchor;
     Dtk_Int32 nbCells_Left_Right;
     Dtk_Int32 nbCells_Top_Bottom;
     Dtk_justication_type justification;
 
    // Color of Border Top
    Dtk_RGB _BorderTopColor;
    // Color of Border Bottom
    Dtk_RGB _BorderBottomColor;
    // Color of Border Left
    Dtk_RGB _BorderLeftColor;
    // Color of Border Right
    Dtk_RGB _BorderRightColor;
    // Blanked Status of Border Top
    Dtk_Int32 _BorderTopBlanked;
    // Blanked Status of Border Bottom
    Dtk_Int32 _BorderBottomBlanked;
    // Blanked Status of Border Left
    Dtk_Int32 _BorderLeftBlanked;
    // Blanked Status of Border Right
    Dtk_Int32 _BorderRightBlanked;
    Dtk_tab<Dtk_EntityPtr>  _AdditionnalGeometries;
 
     enum
     {
          _typeID = DTK_TYPE_CELL
     };
 
    void _InitC();
    void _ResetC();
    void _CopyC(const Dtk_OneCell &cell);
public:
     Dtk_OneCell();
     //Dtk_OneCell(const double &h, const double &w);
 
     Dtk_OneCell(const Dtk_OneCell&in);
     Dtk_OneCell( Dtk_OneCell&& in ) DTK_NOEXCEPT;
 
     ~Dtk_OneCell();
    Dtk_bool HasText() const {return _HasText;}
 
     Dtk_Int32 DtkDynamicType(const int& inId);
 
     static Dtk_OneCell* DtkDynamicCast(Dtk_Object * s);
 
     Dtk_OneCell& operator=(const Dtk_OneCell &in);
     Dtk_OneCell& operator =( Dtk_OneCell&& in );
 
     Dtk_Size_t& getAnchor();
 
     void setAnchor(const Dtk_Size_t& inNumberOfAnchor);
 
     Dtk_justication_type & getJustification();
 
     void setJustification(const Dtk_justication_type & inNewJustification);
 
     Dtk_Int32 getnbCells_Left_Right() const;
 
     void setnbCells_Left_Right(const Dtk_Size_t &inNewVal);
 
     Dtk_Int32 getnbCells_Top_Bottom() const;
 
     void setnbCells_Top_Bottom(const Dtk_Size_t& inNewVal);
 
     void SetText( Dtk_CompositeText text);
 
     Dtk_CompositeText& GetText();
     const Dtk_CompositeText& GetText() const;
 
     Dtk_Double64   getHeight() const;
 
     void setHeight(const double &inHeight);
 
     Dtk_Double64  getWidth() const;
 
     void setWidth(const double &inWidth);
 
     Dtk_Double64 get_min_Height();
 
     void set_min_Height(const double &inHeight);
 
     Dtk_Double64  get_min_Width();
 
     void set_min_Width(const double &min_Width);
 
     void Delete_Text();
 
     bool Merged_Cell_Horizontally();
 
     bool Merged_Cell_Vertically();
 
 
    void SetBorderTopColor(const Dtk_Int32 & inBorderTopColor);
    void SetBorderTopColor(const Dtk_RGB & inBorderTopColor);
 
    const Dtk_RGB& GetBorderTopColor();
 
    void SetBorderBottomColor(const Dtk_Int32 & inBorderBottomColor);
    void SetBorderBottomColor(const Dtk_RGB & inBorderBottomColor);
 
    const Dtk_RGB& GetBorderBottomColor();
 
    void SetBorderLeftColor(const Dtk_Int32 & inBorderLeftColor);
    void SetBorderLeftColor(const Dtk_RGB & inBorderLeftColor);
 
    const Dtk_RGB& GetBorderLeftColor();
 
    void SetBorderRightColor(const Dtk_Int32 & inBorderRightColor);
    void SetBorderRightColor(const Dtk_RGB & inBorderRightColor);
 
    const Dtk_RGB& GetBorderRightColor();
 
 
    void SetBorderTopBlanked(const Dtk_Int32 & inBorderTopBlanked);
 
    Dtk_Int32 GetBorderTopBlanked();
 
    void SetBorderBottomBlanked(const Dtk_Int32 & inBorderBottomBlanked);
 
    Dtk_Int32 GetBorderBottomBlanked();
 
    void SetBorderLeftBlanked(const Dtk_Int32 & inBorderLeftBlanked);
 
    Dtk_Int32 GetBorderLeftBlanked();
 
    void SetBorderRightBlanked(const Dtk_Int32 & inBorderRightBlanked);
 
    Dtk_Int32 GetBorderRightBlanked();
 
    void AddAdditionnalGeometries( Dtk_tab<Dtk_EntityPtr> inAdditionnalGeometries);
 
    const Dtk_tab< Dtk_EntityPtr >& GetAdditionnalGeometries() const;
 
};
 
class Dtk_Table:public Dtk_Annotation
{
protected:
     Dtk_OneCell ** tableOfCell;
     Dtk_Size_t nbRows;
     Dtk_Size_t nbCol;
     Dtk_tab< Dtk_Size_t > nbCells_Line;
     Dtk_tab< Dtk_Size_t > nbCells_Col;//
     enum
     {
          _typeID = DTK_TYPE_TABLE
     };
    Dtk_Table();
 
    Dtk_Table(const Dtk_Table &tab);
 
    Dtk_Table(const Dtk_Int32 &inNumRows,
        const Dtk_Int32 &inNumCols,
        const Dtk_pnt &inLocationPnt = Dtk_pnt(0,0,0),
        const Dtk_Double64 &inAngle = 0.0,
        const Dtk_InfoPtr &infos = NULL,
        Dtk_tab<Dtk_LeaderPtr> inLeadersArray = Dtk_tab<Dtk_LeaderPtr>(),
        const Dtk_Double64 &inOffSet = 0.0,
        const Dtk_anchor_type &inAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
        const Dtk_justication_type &inJustificationType = DTK_JUSTIFY_LEFT);
 
    ~Dtk_Table();
 
    inline virtual Dtk_Object* Clone() { return new Dtk_Table(*this); }
    const Dtk_OneCell * operator[](const Dtk_Size_t &inPos) const;
    Dtk_OneCell * operator[](const Dtk_Size_t &inPos);
     void _CheckRowCol(const Dtk_Size_t inRow, const Dtk_Size_t inCol) const;
private:
     void _InitT();
     void _Copy(const Dtk_Table &tab);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_Table>;
public:
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_Table* DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_TablePtr Create(const Dtk_Table& in);
 
     static Dtk_TablePtr Create(const Dtk_Int32 &inNumRows,
          const Dtk_Int32 &inNumCols,
          const Dtk_pnt &inLocationPnt = Dtk_pnt(0,0,0),
          const Dtk_Double64 &inAngle = 0.0,
          const Dtk_InfoPtr &infos = NULL,
          Dtk_tab<Dtk_LeaderPtr> inLeadersArray = Dtk_tab<Dtk_LeaderPtr>(),
          const Dtk_Double64 &inOffSet = 0.0,
          const Dtk_anchor_type &inAnchorType = DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_justication_type &inJustificationType = DTK_JUSTIFY_LEFT);
 
     Dtk_Size_t getNbrows();
 
     Dtk_Size_t getNbcols();
 
    inline Dtk_OneCell& getCell( const Dtk_Size_t &inRow, const Dtk_Size_t &inCol)
    {
#ifdef _DEBUG_DTK
        _CheckRowCol( inRow, inCol);
#endif
        return operator[](inRow)[inCol];
    }
    inline const Dtk_OneCell& getCell( const Dtk_Size_t &inRow, const Dtk_Size_t &inCol) const
    {
#ifdef _DEBUG_DTK
        _CheckRowCol( inRow, inCol);
#endif
        return operator[](inRow)[inCol];
    }
 
 
 
 
 
     void Set_Texts(const Dtk_Size_t &inRowIdx, const Dtk_Size_t &inColIdx,
          Dtk_CompositeText inText);
 
    const Dtk_Size_t& Cell_Line(const Dtk_Size_t inPos) const;
 
    Dtk_Size_t& Cell_Line(const Dtk_Size_t inPos);
 
    const Dtk_Size_t& Cell_Col(const Dtk_Size_t inPos) const;
 
    Dtk_Size_t& Cell_Col(const Dtk_Size_t inPos);
 
 
     Dtk_Size_t GetNumRows() const;
 
     Dtk_Size_t GetNumCols() const;
 
     type_detk get_type_detk() const { return DTK_TYPE_TABLE; }
 
     const Dtk_CompositeText& Text(const Dtk_Size_t &inRow,
          const Dtk_Size_t &inCol) const;
 
     Dtk_CompositeText& Text(const Dtk_Size_t &inRow, const Dtk_Size_t &inCol);
 
     Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const ;
 
     Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
     Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
     Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &inRotationAngle);
 
     Dtk_ErrorStatus ProcessTextsPlacement() ;
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo) ;
};
 
class Dtk_Grid : public Dtk_Annotation //Dtk_2dEntity
{
protected:
    struct Dtk_Handle; // Not defined here
    Dtk_Handle *_Private; // Handle
    enum
    {
        _typeID = DTK_TYPE_GRID
    };
 
public:
    enum ShowLabelOption
    {
        None,
        ParallelToView,
        Always
    };
 
    enum OriginReferenceOption
    {
        Absolute,
        WCS,
        Local
    };
 
protected:
     Dtk_Grid() :
          _Private( nullptr )
     {
     };
 
    Dtk_Grid(const Dtk_Grid &grid);
 
    Dtk_Grid(const  Dtk_Oriented2dBBox      &inUVBBox,
             const Dtk_Double64             &inUSpacing,
             const Dtk_Double64             &inVSpacing,
             const Dtk_Int32                &inUMinorPerMajor,
             const Dtk_Int32                &inVMinorPerMajor,
             //style
             const Dtk_RGB                  &inLineColor,
             const Dtk_FontLineType         &inMajorLineStyle,
             const Dtk_FontLineType         &inMinorLineStyle,
             const Dtk_Double64             &inMajorLineWidth,
             const Dtk_Double64             &inMinorLineWidth,
             const Dtk_bool                 &inDisplayGridOpt,
             const Dtk_bool                 &inDisplayOnTopOpt,
             const Dtk_bool                 &inDisplayMajorLinesOpt,
             const ShowLabelOption          &inShowLabelOpt,
             const OriginReferenceOption    &inOriginReferenceOpt,
             const Dtk_Double64             &inConceptionUnit);
 
    ~Dtk_Grid();
 
    inline virtual Dtk_Object* Clone() { return new Dtk_Grid(*this); }
 
private:
    void _Init();
    void _Copy(const Dtk_Grid &grid);
    void _Reset();
    friend class Dtk_SmartPtr<Dtk_Grid>;
 
 
    Dtk_Double64 GetConceptionUnit() const;
    Dtk_bool GetDrawLabelsInOriginUnitOption() const;
public:
 
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    static Dtk_Grid* DtkDynamicCast(Dtk_Object *s);
 
    static Dtk_GridPtr Create(const Dtk_Grid& in);
 
    static Dtk_GridPtr Create(const Dtk_Oriented2dBBox      &inUVBBox,
                              const Dtk_Double64            &inUSpacing,
                              const Dtk_Double64            &inVSpacing,
                              const Dtk_Int32               &inUMinorPerMajor = 1,
                              const Dtk_Int32               &inVMinorPerMajor = 1,
                              //style
                              const Dtk_RGB                 &inLineColor = Dtk_RGB(),
                              const Dtk_FontLineType        &inMajorLineStyle = DTK_NO_PATTERN,
                              const Dtk_FontLineType        &inMinorLineStyle = DTK_NO_PATTERN,
                              const Dtk_Double64            &inMajorLineWidth = 1.0,
                              const Dtk_Double64            &inMinorLineWidth = 1.0,
                              const Dtk_bool                &inDisplayGridOpt = DTK_TRUE,
                              const Dtk_bool                &inDisplayOnTopOpt = DTK_TRUE,
                              const Dtk_bool                &inDisplayMajorLinesOpt = DTK_FALSE,
                              const ShowLabelOption         &inShowLabelOpt = Dtk_Grid::Always,
                              const OriginReferenceOption   &inOriginReferenceOpt = Dtk_Grid::Local,
                              const Dtk_Double64            &inConceptionUnit = 1.0);
 
    Dtk_Oriented2dBBox &GetBoundingBox() const;
 
    Dtk_Double64 GetUSpacing() const;
 
    Dtk_Double64 GetVSpacing() const;
 
    Dtk_Int32 GetUMinorPerMajor() const;
 
    Dtk_Int32 GetVMinorPerMajor() const;
 
    Dtk_FontLineType GetMajorLineStyle() const;
 
    Dtk_FontLineType GetMinorLineStyle() const;
 
    Dtk_Double64 GetMajorLineWidth() const;
 
    Dtk_Double64 GetMinorLineWidth() const;
 
     Dtk_bool GetDisplayGridOption() const;
 
     Dtk_bool GetDisplayOnTopOption() const;
 
     Dtk_bool GetDisplayMajorLinesOption() const;
 
    ShowLabelOption GetDisplayShowLabelOption() const;
 
    OriginReferenceOption GetDisplayOriginReferenceOption() const;
 
 
    type_detk get_type_detk() const { return DTK_TYPE_GRID; }
 
    void DrawLabelsInOriginUnit(const Dtk_bool&inVal);
 
    Dtk_ErrorStatus GetAnchorPoints(
        Dtk_pnt(&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
    Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
                                   const Dtk_anchor_type &inLocationAnchorType);
 
    Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
    Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
    //Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &inRotationAngle);
 
    //Dtk_ErrorStatus ProcessTextsPlacement();
 
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    Dtk_tab< Dtk_EntityPtr > GetGeometries() const;
 
    Dtk_CompositeText GetLabelsAsCompositeTexts() const;
};
 
 
 
class Dtk_Dimension : public Dtk_2dEntity
{
public:
     enum DimensionTypeEnum {
          LinearDimension = 0,
          AngularDimension,
          CurvilinearDimension,
          DiameterDimension,
          LinearDiameterDimension,
          RadiusDimension,
          LinearRadiusDimension,
          CumulatedDimension,
          ChamferDimension,
          DistanceDimension,
          LengthDimension
     };
     enum BasicDimensionTypeEnum {
          BasicTypeNone = 0,
          BasicTypeRectangle,
          BasicTypeCircle,
          BasicTypeFlagRight,
          BasicTypeOblong
     };
 
     enum ShowDualValueTypeEnum {
          ShowDualValueNone = 0,
          ShowDualValueBelow,
          ShowDualValueFractional,
          ShowDualValueSydeBySide
     };
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_DIMENSION
     };
     ~Dtk_Dimension();
 
     Dtk_Dimension();
 
     Dtk_Dimension(const Dtk_Dimension &in);
     Dtk_Dimension( Dtk_Dimension&& in ) DTK_NOEXCEPT;
 
     Dtk_Dimension(const DimensionTypeEnum &inDimensionType,
          Dtk_CompositeText inTexts);
    Dtk_ErrorStatus _GetExtensionLineIdx(const Dtk_Size_t& pos, Dtk_Size_t& outIdx) const;
 
    inline virtual Dtk_Object* Clone() { return new Dtk_Dimension(*this); }
 
private:
     void _Init();
     void _Copy(const Dtk_Dimension &s);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_Dimension>;
public:
     // Downcasting
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_Dimension* DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_DimensionPtr Create();
 
     static Dtk_DimensionPtr Create(const Dtk_Dimension &in);
     static Dtk_DimensionPtr Create( Dtk_Dimension && in );
 
     static Dtk_DimensionPtr Create(const DimensionTypeEnum &inDimensionType,
          Dtk_CompositeText inTexts);
 
     SetAsDeprecated( "2025.4", "Use Dtk_ErrorStatus Dtk_Leader::SetExtensionLine(const Dtk_PolylinePtr &) and Dtk_ErrorStatus AddLeader( const Dtk_LeaderPtr& leader ) instead" )
     Dtk_ErrorStatus AddLeaderWithExtensionLine(
          const Dtk_LeaderPtr &inLeader,
          Polyline_detk* const &inExtensionLine);
 
     SetAsDeprecated( "2025.4", "Use Dtk_ErrorStatus Dtk_Leader::SetExtensionLine(const Dtk_PolylinePtr &) and Dtk_ErrorStatus AddLeader( const Dtk_LeaderPtr& leader ) instead" )
     Dtk_ErrorStatus AddLeaderWithExtensionLine(const Dtk_LeaderPtr &inLeader,
          const Dtk_tab<Dtk_pnt> &inExtensionLinePnts);
     
     Dtk_ErrorStatus AddLeader( const Dtk_LeaderPtr& leader );
 
     type_detk get_type_detk() const
     {
          return DTK_TYPE_DIMENSION;
     }
 
     Dtk_ErrorStatus AddText( Dtk_Text inText);
 
     const Dtk_CompositeText& GetTexts() const;
 
     Dtk_Size_t GetNumLeaders() const;
 
     SetAsDeprecated( "2025.4", "Use Dtk_LeaderPtr GetNumLeaders() and Dtk_ErrorStatus Dtk_Leader::GetExtensionLine() instead" )
     Dtk_Size_t GetNumExtensionLines() const;
 
     Dtk_LeaderPtr GetLeader(const Dtk_Size_t &inPos) const;
 
     SetAsDeprecated( "2025.4", "Use Dtk_LeaderPtr GetLeader(const Dtk_Size_t &inPos) and Dtk_ErrorStatus Dtk_Leader::GetExtensionLine() instead" )
     Dtk_CurvePtr GetExtensionLineAsCurve(const Dtk_Size_t &inPos) const;
 
     DimensionTypeEnum GetDimensionType() const;
 
     SetAsDeprecated( "2025.4", "Use Dtk_LeaderPtr GetLeader(const Dtk_Size_t &inPos) and Dtk_ErrorStatus Dtk_Leader::GetExtensionLine() instead" )
     Dtk_ErrorStatus ConvertExtensionLineToGeometries(
          const Dtk_Size_t &inExtLinePos,
          Dtk_tab<Dtk_CurvePtr> &outGeomsArray) const;
 
     Dtk_Size_t GetNumExtraGeometries() const;
 
     Dtk_CurvePtr GetExtraGeometryAsCurve(const Dtk_Size_t &inPos) const;
 
    void SetBasicDimensionType(const BasicDimensionTypeEnum& inBasicDimensionTypeEnum) const;
 
    BasicDimensionTypeEnum& GetBasicDimensionType() const ;
 
    void SetBasicDimensionType(const BasicDimensionTypeEnum& inBasicDimensionTypeEnum, Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements) const;
 
    BasicDimensionTypeEnum& GetBasicDimensionType(Dtk_tab< Dtk_CurvePtr >& inRelatedGeomElements) const ;
 
     const BasicDimensionTypeEnum& BasicDimensionType() const;
 
     BasicDimensionTypeEnum& BasicDimensionType();
 
     const ShowDualValueTypeEnum& ShowDualValueType() const;
 
     ShowDualValueTypeEnum& ShowDualValueType();
 
     Dtk_ErrorStatus GetTextVerticalOffSet(double& outOffSet);
     Dtk_ErrorStatus GetTextRefPoint(Dtk_pnt& outRefPnt);
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    Dtk_bool IsFakeDimension() const;
 
    void SetFakeDimensionStatus(const Dtk_bool inIsFakeDimension);
 
     void SetFrameType( const Dtk_frame_type& inFrameType, Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements);
 
     void GetFrame(Dtk_Frame& outFrame) const;
 
 
     void ClearLeader();
 
};
 
class Dtk_ReferenceBlock : public Dtk_Object
{
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_REFERENCE
     };
    Dtk_ReferenceBlock(const Dtk_Oriented2dBBox& inInnerBBox,
        const Dtk_Oriented2dBBox& inOuterBBox);
 
     Dtk_ReferenceBlock(const Dtk_ReferenceBlock &in);
     Dtk_ReferenceBlock( Dtk_ReferenceBlock&& in ) DTK_NOEXCEPT;
 
     ~Dtk_ReferenceBlock();
 
     void _ConcatenateMaterialModifierToText(const Dtk_Size_t &inReferencePos,
          const DTK_FDT_MODIFIER &inMaterialModifier);
 
     void _ReplaceFirstMaterialModifer(const Dtk_Size_t &inReferencePos,
          const DTK_FDT_MODIFIER &inMaterialModifier);
    inline virtual Dtk_Object* Clone() { return new Dtk_ReferenceBlock(*this); }
 
private:
     void _Init();
     void _Copy(const Dtk_ReferenceBlock &s);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_ReferenceBlock>;
public:
 
     Dtk_ErrorStatus AddReference( Dtk_string inReferenceLabel,
          const DTK_FDT_MODIFIER &inMaterialModifier = DTK_FDT_MODIFIER_NONE,
          const Dtk_FdtPtr &inLinkedFdt = NULL);
 
     Dtk_ErrorStatus AddReference( Dtk_string inFullTextWithMaterialCondition,
        const Dtk_FdtPtr &inLinkedFdt);
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_ReferenceBlock* DtkDynamicCast(Dtk_Object *s);
 
//   //! \DtkInternal
//   void _PropagateOrientation(const Dtk_dir &inXAxis, const Dtk_dir &inYAxis);
 
     static Dtk_ReferenceBlockPtr Create(
        const Dtk_Oriented2dBBox& inInnerBBox,
        const Dtk_Oriented2dBBox& inOuterBBox);
 
     static Dtk_ReferenceBlockPtr Create(const Dtk_ReferenceBlock &in);
     static Dtk_ReferenceBlockPtr Create( Dtk_ReferenceBlock&& in );
 
     //static Dtk_ReferenceBlockPtr Create(
     //   const Dtk_Text &inFullTextWithMaterialCondition,
     //   const Dtk_FdtPtr &fdt);
     //
     //static Dtk_ReferenceBlockPtr Create(const Dtk_Text &inLabel,
     //   const DTK_FDT_MODIFIER &inMaterialModifier = DTK_FDT_MODIFIER_NONE,
     //   const Dtk_FdtPtr &inLinkedFdt = Dtk_FdtPtr(NULL));
 
     Dtk_ReferenceBlock& operator=(const Dtk_ReferenceBlock& in);
     Dtk_ReferenceBlock& operator=( Dtk_ReferenceBlock&& in ) DTK_NOEXCEPT;
 
     const Dtk_string& GetReferenceLabel(const Dtk_Size_t &inReferencePos) const;
 
     Dtk_ErrorStatus SetXAxis(const Dtk_dir &ref_dir);
 
     Dtk_ErrorStatus SetYAxis(const Dtk_dir &axis_dir);
 
     DTK_FDT_MODIFIER GetMaterialModifier(const Dtk_Size_t &inReferencePos) const;
 
     Dtk_FdtPtr GetLinkedtFdt(const Dtk_Size_t &inReferencePos) const;
 
     Dtk_string ConvertToDtk_String() const;
 
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType=DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_Double64 &inOffSet = 0.0);
 
     Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPoints)[DTK_NB_ANCHOR_TYPES],
          const Dtk_Double64 &inOffSet = 0.0) const;
 
     Dtk_Size_t GetNumReferences() const;
 
     void Translate(const Dtk_dir &inTranslationDir);
 
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    Dtk_Oriented2dBBox GetOuterBoundingBox() const;
 
    void SetOuterBoundingBox(const Dtk_Oriented2dBBox& inOuterBBox) const;
 
 
    void SetInnerBoundingBox(const Dtk_Oriented2dBBox& inInnerBBox);
 
    Dtk_Oriented2dBBox GetInnerBoundingBox() const;
 
};
 
class Dtk_ReferenceFrame : public Dtk_Object
{
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_REFERENCE_FRAME
     };
 
     Dtk_ReferenceFrame();
 
     Dtk_ReferenceFrame(const Dtk_ReferenceFrame &s);
     Dtk_ReferenceFrame( Dtk_ReferenceFrame&& s ) DTK_NOEXCEPT;
 
     Dtk_ReferenceFrame(const Dtk_ReferenceBlockPtr &ref);
    inline virtual Dtk_Object* Clone() { return new Dtk_ReferenceFrame(*this); }
 
     ~Dtk_ReferenceFrame();
private:
     void _Init();
     void _Reset();
     void _Copy(const Dtk_ReferenceFrame &s);
     friend class Dtk_SmartPtr<Dtk_ReferenceFrame>;
 
public:
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_ReferenceFrame* DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_ReferenceFramePtr Create();
 
     static Dtk_ReferenceFramePtr Create(const Dtk_ReferenceFrame &in);
     static Dtk_ReferenceFramePtr Create( Dtk_ReferenceFrame&& in );
 
     static Dtk_ReferenceFramePtr Create(
          const Dtk_ReferenceBlockPtr & inFirstReferenceBlock);
 
     Dtk_ReferenceFrame& operator=(const Dtk_ReferenceFrame &in);
     Dtk_ReferenceFrame& operator=( Dtk_ReferenceFrame&& in ) DTK_NOEXCEPT;
 
     Dtk_ErrorStatus AddReferenceBlock(
          const Dtk_ReferenceBlockPtr & inReferenceBlock);
 
//   //! \DtkInternal
//   void _PropagateOrientation(const Dtk_dir &inXAxis, const Dtk_dir &inYAxis);
 
     Dtk_Size_t GetNumReferences() const;
 
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_Double64& inOffSet = 0.0) const;
 
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType,
          const Dtk_Double64 &inOffSet = 0.0);
 
     Dtk_ReferenceBlockPtr& Reference(const Dtk_Size_t &inReferencePos);
 
     const Dtk_ReferenceBlockPtr& Reference(
          const Dtk_Size_t &inReferencePos) const;
 
     Dtk_ReferenceBlockPtr& FirstReference();
 
     const Dtk_ReferenceBlockPtr& FirstReference() const;
 
     Dtk_ReferenceBlockPtr& SecondReference();
 
     const Dtk_ReferenceBlockPtr& SecondReference() const;
 
     Dtk_ReferenceBlockPtr& ThirdReference();
 
     const Dtk_ReferenceBlockPtr& ThirdReference() const;
 
    void Translate(const Dtk_dir& inTranslationDir);
 
    Dtk_ErrorStatus GetOuterBoundingBox(Dtk_Oriented2dBBox& outOuterBBox) const;
};
 
class Dtk_ToleranceSpecification : public Dtk_Object
{
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_TOL_SPEC
     };
     Dtk_ToleranceSpecification();
 
     Dtk_ToleranceSpecification( Dtk_Text inFullTextWithMaterialCondition,
          const Dtk_ReferenceFramePtr
          &inReferenceFrame = Dtk_ReferenceFrame::Create());
 
     Dtk_ToleranceSpecification(const Dtk_ToleranceSpecification &in);
     Dtk_ToleranceSpecification( Dtk_ToleranceSpecification&& in ) DTK_NOEXCEPT;
 
     ~Dtk_ToleranceSpecification();
    inline virtual Dtk_Object* Clone() { return new Dtk_ToleranceSpecification(*this); }
 
private:
     void _Init();
     void _Copy(const Dtk_ToleranceSpecification &s);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_ToleranceSpecification>;
public:
     // Downcasting
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_ToleranceSpecification* DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_ToleranceSpecificationPtr Create();
 
     static Dtk_ToleranceSpecificationPtr Create(
          Dtk_Text inFullTextWithMaterialCondition,
          const Dtk_ReferenceFramePtr &inReferenceFrame = Dtk_ReferenceFrame::Create());
 
     static Dtk_ToleranceSpecificationPtr Create( const Dtk_ToleranceSpecification &in );
     static Dtk_ToleranceSpecificationPtr Create( Dtk_ToleranceSpecification&& in );
 
     Dtk_ToleranceSpecification& operator=( const Dtk_ToleranceSpecification &in );
     Dtk_ToleranceSpecification& operator=( Dtk_ToleranceSpecification&& in ) DTK_NOEXCEPT;
 
     Dtk_Size_t GetNumReferences() const;
 
     Dtk_ReferenceBlockPtr& Reference( const Dtk_Size_t &inReferencePos );
 
     const Dtk_ReferenceBlockPtr& Reference( const Dtk_Size_t &inReferencePos ) const;
 
     Dtk_ReferenceBlockPtr &FirstReference();
 
     const Dtk_ReferenceBlockPtr& FirstReference() const;
 
     Dtk_ReferenceBlockPtr& SecondReference();
 
     const Dtk_ReferenceBlockPtr& SecondReference() const;
 
     Dtk_ReferenceBlockPtr& ThirdReference();
 
     const Dtk_ReferenceBlockPtr& ThirdReference() const;
 
     Dtk_Double64 ProcessWidth() const;
 
     Dtk_Double64 ProcessHeight() const;
 
 
     Dtk_ErrorStatus Explode(Dtk_CompositeText &outCompositeText,
          Dtk_tab<Dtk_CurvePtr> &outGeoms);
 
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_Int32& ignoreadd = 0) const;
 
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_Int32& ignoreadd=0);
 
 
     Dtk_ErrorStatus GetOuterBoundingBox( Dtk_Oriented2dBBox& outOuterBBox,
                                                   const Dtk_bool inIncludeReferenceFrame = DTK_TRUE,
                                                   const Dtk_bool InIncludeIndicators = DTK_TRUE ) const;
 
     SetAsDeprecated( "2021.1", "Use SetMainValue mehod to alter MainValue instead." )
     Dtk_ErrorStatus SetOuterBoundingBox(const Dtk_Oriented2dBBox& inOuterBBox);
 
    Dtk_ErrorStatus GetInnerBoundingBox(Dtk_Oriented2dBBox& outInnerBBox) const;
     SetAsDeprecated( "2021.1", "Use SetMainValue mehod to alter MainValue instead." )
     Dtk_ErrorStatus SetInnerBoundingBox(const Dtk_Oriented2dBBox& inInnerBBox);
 
    Dtk_ErrorStatus GetOuterBoundingBoxWithOutRefFrame(Dtk_Oriented2dBBox& outOuterBBox) const;
 
     SetAsDeprecated( "2021.1", "Use SetMainValue mehod to alter MainValue instead." )
     Dtk_ErrorStatus SetOuterBoundingBoxWithOutRefFrame(const Dtk_Oriented2dBBox& inOuterBBox) ;
 
     Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     Dtk_ErrorStatus SetXAxis(const Dtk_dir &dir);
 
     Dtk_ErrorStatus SetYAxis(const Dtk_dir &dir);
 
     const Dtk_CompositeText& GetMainValue() const;
 
     void SetMainValue( Dtk_CompositeText inNewMainValue );
 
     const Dtk_ReferenceFramePtr& ReferenceFrame() const;
 
     Dtk_ReferenceFramePtr& ReferenceFrame();
 
     void AddIndicator( const Dtk_FCFFeatureIndicatorPtr& inIndicator );
 
     Dtk_Size_t GetNumIndicators() const;
 
     const Dtk_FCFFeatureIndicatorPtr& GetIndicator( const Dtk_Size_t inIndicatorIndex ) const;
 
     Dtk_FCFFeatureIndicatorPtr& GetIndicator( const Dtk_Size_t inIndicatorIndex );
 
     DTK_FDT_MODIFIER GetMaterialModifier() const;
 
    Dtk_bool HasFreeStateModifier() const;
 
     Dtk_dir GetXAxis() const;
 
     Dtk_dir GetYAxis() const;
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     void Translate(const Dtk_dir &inTranslationDir);
};
 
class Dtk_GeometricalTolerance : public Dtk_Annotation
{
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_GEOM_TOL
     };
 
     Dtk_GeometricalTolerance();
 
     Dtk_GeometricalTolerance(const Dtk_GeometricalTolerance &s);
     Dtk_GeometricalTolerance( Dtk_GeometricalTolerance&& s ) DTK_NOEXCEPT;
    inline virtual Dtk_Object* Clone() { return new Dtk_GeometricalTolerance(*this); }
     ~Dtk_GeometricalTolerance();
private:
     void _Init();
     void _Reset();
     void _Copy(const Dtk_GeometricalTolerance &s);
     friend class Dtk_SmartPtr<Dtk_GeometricalTolerance>;
public:
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_GeometricalTolerance* DtkDynamicCast(Dtk_Object *s);
 
     type_detk get_type_detk() const { return DTK_TYPE_GEOM_TOL; }
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     static Dtk_GeometricalTolerancePtr Create();
 
     static Dtk_GeometricalTolerancePtr Create(
          const Dtk_GeometricalTolerance &in);
     static Dtk_GeometricalTolerancePtr Create(
          Dtk_GeometricalTolerance&& in );
 
     Dtk_GeometricalTolerance& operator=(
          const Dtk_GeometricalTolerance &in);
     Dtk_GeometricalTolerance& operator=(
          Dtk_GeometricalTolerance&& in ) DTK_NOEXCEPT;
 
     Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_bool& inProcessAddtionnalTexts) const;
 
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type& inLocationAnchorType);
 
     Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType,
          const Dtk_bool &inProcessAddtionnalTexts);
 
     Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
     Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
     Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &inRotationAngle);
 
     Dtk_ToleranceSpecificationContainerPtr &at(const Dtk_Size_t &inPos);
 
     Dtk_ToleranceSpecificationContainerPtr &operator[](const Dtk_Size_t &inPos);
 
     const Dtk_ToleranceSpecificationContainerPtr &at(
          const Dtk_Size_t &inPos) const;
 
     const Dtk_ToleranceSpecificationContainerPtr& operator[](
          const Dtk_Size_t &inPos) const;
 
     Dtk_ToleranceSpecificationContainerPtr& GetToleranceSpecificationContainer(
          const Dtk_Size_t& inPos);
 
     const Dtk_ToleranceSpecificationContainerPtr&
          GetToleranceSpecificationContainer(const Dtk_Size_t &inPos) const;
 
     Dtk_Size_t GetToleranceSpecificationContainerNb() const;
 
     Dtk_ErrorStatus AddToleranceSpecificationContainer(
          const Dtk_ToleranceSpecificationContainerPtr &inTolSpecCont);
 
//   //! \DtkInternal
//   void IPropagateOrientation();
 
     Dtk_ErrorStatus GetOuterBoundingBox(
          const Dtk_bool& inProcessAddtionnalTexts,
          Dtk_Oriented2dBBox& outOuterBBox) const;
 
     void Translate(const Dtk_dir& inTranslationDir);
 
    void SetLetteringColor(const Dtk_RGB &inLetteringColor);
 
    const Dtk_RGB& GetLetteringColor() const ;
 
    void SetFrameColor(const Dtk_RGB &inFrameColor);
 
    const Dtk_RGB& GetFrameColor() const ;
 
};
 
class Dtk_FCFFeatureIndicatorType
{
public:
     enum Dtk_FCFFeatureIndicatorTypeEnum
     {
          Unknown = 0,
          DirectionFeature,
          CollectionPlane,
          IntersectionPlane,
          OrientationPlane,
     };
protected:
     Dtk_FCFFeatureIndicatorTypeEnum                   m_Type;
     Dtk_tab< Dtk_CurvePtr >                           m_RelatedGeomElements;
     Dtk_Oriented2dBBox                                m_OuterBBox;
     void _Init();
     void _Copy( const Dtk_FCFFeatureIndicatorType &s );
     void _Reset();
public:
 
     inline Dtk_FCFFeatureIndicatorType( const Dtk_FCFFeatureIndicatorTypeEnum& inIndicatorType,
                                         const Dtk_Oriented2dBBox& inOuterBoundingBox,
                                         Dtk_tab< Dtk_CurvePtr > inRelatedGeometricalElts )
     {
          SetIndicatorTypeData( inIndicatorType,
                                     inOuterBoundingBox,
                                     std::move( inRelatedGeometricalElts ) );
     }
 
     inline Dtk_FCFFeatureIndicatorType()
     {
          _Init();
     }
     Dtk_FCFFeatureIndicatorType( const Dtk_FCFFeatureIndicatorType & in ) : m_Type( in.m_Type ), m_RelatedGeomElements( in.m_RelatedGeomElements ), m_OuterBBox( in.m_OuterBBox )
     {
     }
     Dtk_FCFFeatureIndicatorType( Dtk_FCFFeatureIndicatorType&& in ) DTK_NOEXCEPT : m_Type( in.m_Type ), m_RelatedGeomElements( std::move( in.m_RelatedGeomElements ) ), m_OuterBBox( in.m_OuterBBox )
     {
     }
 
     inline ~Dtk_FCFFeatureIndicatorType()
     {
          _Reset();
     }
 
     inline void Clear()
     {
          _Reset();
     }
 
 
     inline void SetIndicatorTypeData(
          const Dtk_FCFFeatureIndicatorTypeEnum& inIndicatorType,
          const Dtk_Oriented2dBBox& inOuterBoundingBox,
          Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements )
     {
          m_Type = inIndicatorType;
          m_OuterBBox = inOuterBoundingBox;
          m_RelatedGeomElements = std::move( inRelatedGeomElements );
     }
     inline const Dtk_FCFFeatureIndicatorTypeEnum& GetIndicatorType() const
     {
          return m_Type;
     }
 
     Dtk_ErrorStatus CreateGeometries( Dtk_tab< Dtk_CurvePtr >& outGeoms ) const;
 
     inline const Dtk_Oriented2dBBox& GetOuterBoundingBox() const
     {
          return m_OuterBBox;
     }
     Dtk_ErrorStatus Translate( const Dtk_dir &inTranslateDir );
 
     Dtk_ErrorStatus Transform( const Dtk_transfo &inTransfo );
 
     inline Dtk_FCFFeatureIndicatorType& operator=( const Dtk_FCFFeatureIndicatorType &in )
     {
          if( &in == this )
          {
               return *this;
          }
          _Reset();
          _Copy( in );
          return *this;
     }
     inline Dtk_FCFFeatureIndicatorType& operator=( Dtk_FCFFeatureIndicatorType&& in ) DTK_NOEXCEPT
     {
          if( &in == this )
          {
               return *this;
          }
          m_Type = in.m_Type;
          m_RelatedGeomElements = std::move( in.m_RelatedGeomElements );
          m_OuterBBox = in.m_OuterBBox;
 
          return *this;
     }
};
 
class Dtk_FCFFeatureIndicator : public Dtk_Object
{
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *m_Private; // Handle
     enum
     {
          _typeID = DTK_TYPE_SPECIFICATION_INDICATOR
     };
 
     inline Dtk_FCFFeatureIndicator()
     {
          _Init();
     }
 
     Dtk_FCFFeatureIndicator( const Dtk_FCFFeatureIndicator &in ) : Dtk_Object ( in )
     {
          _Init();
          _Copy( in );
     }
 
     Dtk_FCFFeatureIndicator( Dtk_FCFFeatureIndicator&& in ) DTK_NOEXCEPT : Dtk_Object( std::move( in ) ), m_Private( in.m_Private )
     {
          in.m_Private = nullptr;
     }
 
     Dtk_FCFFeatureIndicator( Dtk_FCFFeatureIndicatorType inFeatureIndicatorType,
                                    Dtk_Text inSymbol,
                                    Dtk_Text inDatumFeatureIdentifier );
     inline virtual Dtk_Object* Clone()
     {
          return new Dtk_FCFFeatureIndicator( *this );
     }
 
     inline ~Dtk_FCFFeatureIndicator()
     {
          _Reset();
     }
private:
     void _Init();
     void _Reset();
     void _Copy( const Dtk_FCFFeatureIndicator &s );
     friend class Dtk_SmartPtr<Dtk_FCFFeatureIndicator>;
 
public:
     inline Dtk_Int32 DtkDynamicType( const Dtk_Int32 &inId )
     {
          if( inId == _typeID )
               return 1;
          return Dtk_Object::DtkDynamicType( inId );
     }
     inline static Dtk_FCFFeatureIndicator* DtkDynamicCast( Dtk_Object *s )
     {
          if( s->DtkDynamicType( _typeID ) )
               return static_cast< Dtk_FCFFeatureIndicator* >( s );
          return NULL;
     }
     inline void Clear()
     {
          _Reset();
          _Init();
     }
 
     inline static Dtk_FCFFeatureIndicatorPtr Create()
     {
          return new Dtk_FCFFeatureIndicator();
     }
 
     inline static Dtk_FCFFeatureIndicatorPtr Create( const Dtk_FCFFeatureIndicator &in )
     {
          return new Dtk_FCFFeatureIndicator( in );
     }
     inline static Dtk_FCFFeatureIndicatorPtr Create( Dtk_FCFFeatureIndicator&& in )
     {
          return new Dtk_FCFFeatureIndicator( std::move( in ) );
     }
 
     inline static Dtk_FCFFeatureIndicatorPtr Create( Dtk_FCFFeatureIndicatorType inFeatureIndicatorType,
                                                         Dtk_Text inSymbol,
                                                         Dtk_Text inDatumFeatureIdentifier )
     {
          return new Dtk_FCFFeatureIndicator( std::move( inFeatureIndicatorType ), std::move( inSymbol ), std::move( inDatumFeatureIdentifier ) );
     }
 
     Dtk_FCFFeatureIndicator& operator=( const Dtk_FCFFeatureIndicator &in );
     Dtk_FCFFeatureIndicator& operator=( Dtk_FCFFeatureIndicator&& in ) DTK_NOEXCEPT;
 
     Dtk_ErrorStatus GetAnchorPoints( Dtk_pnt( &outTabPnts )[ DTK_NB_ANCHOR_TYPES ] ) const;
 
 
     const Dtk_Text& GetDatumFeatureIdentifier() const;
 
     const Dtk_Text& GetSymbol() const;
 
     const Dtk_FCFFeatureIndicatorType& GetFeatureIndicatorType() const;
 
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType );
 
     Dtk_ErrorStatus Translate( const Dtk_dir& inTranslationDir );
 
     Dtk_ErrorStatus Transform( const Dtk_transfo &inTransfo );
 
     Dtk_Oriented2dBBox GetOuterBoundingBox() const;
 
     Dtk_ErrorStatus Explode( Dtk_CompositeText & outText, Dtk_tab<Dtk_CurvePtr >& outGeomsArray ) const;
 
 
};
 
class Dtk_ToleranceSpecificationContainer : public Dtk_Object
{
public:
     enum TypeEnum {
          Typeunknown = 0,
          TypeStraightness,
          TypeFlatness,
          TypeCircularity,
          TypeCylindricity,
          TypeLineProfile,
          TypeSurfaceProfile,
          TypeAngularity,
          TypePerpendicularity,
          TypeParallelism,
          TypePosition,
          TypeConcentricity,
          TypeSymmetry,
          TypeCircularRunout,
          TypeTotalRunout,
          TypeAxisIntersection
     };
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_GEOM_TOL
     };
     Dtk_ToleranceSpecificationContainer(
          const Dtk_ToleranceSpecificationContainer &s);
     Dtk_ToleranceSpecificationContainer(
          Dtk_ToleranceSpecificationContainer&& s ) DTK_NOEXCEPT;
     Dtk_ToleranceSpecificationContainer(
        const TypeEnum &inTolSpecContType,
        const Dtk_Oriented2dBBox& inInnerTolTypeBBox,
        const Dtk_Oriented2dBBox& inOuterTolTypeBBox);
 
     ~Dtk_ToleranceSpecificationContainer();
    inline virtual Dtk_Object* Clone() { return new Dtk_ToleranceSpecificationContainer(*this); }
 
private:
     void _Init();
     void _Reset();
     void _Copy(const Dtk_ToleranceSpecificationContainer &s);
     friend class Dtk_SmartPtr<Dtk_ToleranceSpecificationContainer>;
public:
 
 
     static Dtk_string TolSpecContTypeToDtk_string( const TypeEnum inValue );
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_ToleranceSpecificationContainer* DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_ToleranceSpecificationContainerPtr Create(
          const Dtk_ToleranceSpecificationContainer &in );
     static Dtk_ToleranceSpecificationContainerPtr Create(
          Dtk_ToleranceSpecificationContainer&& in );
 
     static Dtk_ToleranceSpecificationContainerPtr Create(
          const TypeEnum &inTolSpecContType,
        const Dtk_Oriented2dBBox& inInnerTolTypeBBox,
        const Dtk_Oriented2dBBox& inOuterTolTypeBBox );
 
 
    void GetToleranceTypeOuterBoundingBox( Dtk_Oriented2dBBox& outOuterBBox ) const;
 
 
    void SetToleranceTypeOuterBoundingBox(const Dtk_Oriented2dBBox& inOuterBBox ) const;
 
    void GetToleranceTypeInnerBoundingBox( Dtk_Oriented2dBBox& outInnerBBox ) const;
 
     void SetToleranceTypeInnerBoundingBox( const Dtk_Oriented2dBBox& inInnerBBox ) const;
 
     Dtk_ErrorStatus GetToleranceSpecificationBoundingBox(
          const Dtk_Size_t &inTolSpecPos,
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     Dtk_ErrorStatus GetToleranceSpecificationsBoundingBox(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
    Dtk_ErrorStatus GetToleranceSpecificationOuterBoundingBox(
        const Dtk_Size_t& inTolSpecPos,
        Dtk_Oriented2dBBox& outOuterBBox) const;
 
//   //! \DtkInternal
//   void _PropagateOrientation();
 
     Dtk_Size_t GetNumToleranceSpecifications() const;
 
     Dtk_ToleranceSpecificationContainer& operator=(
          const Dtk_ToleranceSpecificationContainer & in );
     Dtk_ToleranceSpecificationContainer& operator=(
          Dtk_ToleranceSpecificationContainer&& in ) DTK_NOEXCEPT;
 
     Dtk_ErrorStatus AddToleranceSpecification(
          const Dtk_ToleranceSpecificationPtr &inTolSpec);
 
     Dtk_ToleranceSpecificationPtr GetToleranceSpecification(
          const Dtk_Size_t &inPos) const;
 
     Dtk_ErrorStatus SetToleranceSpecification(
          const Dtk_Size_t &inPos,
          const Dtk_ToleranceSpecificationPtr &inNewTolSpec);
 
     Dtk_ErrorStatus GetAnchorPointsByTolSpec(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_Int32 &ref_tol_spec_ind = -1) const;
 
     Dtk_ErrorStatus SetTopText( Dtk_CompositeText inText);
 
     Dtk_ErrorStatus SetBottomText( Dtk_CompositeText text);
 
     Dtk_ErrorStatus SetLeftText( Dtk_CompositeText inText);
 
     Dtk_ErrorStatus SetRightText( Dtk_CompositeText inText);
 
     const Dtk_Text& TopText() const;
 
     const Dtk_Text& BottomText() const;
 
     const Dtk_Text& GetRightText() const;
 
     const Dtk_Text& GetLeftText() const;
 
    const Dtk_CompositeText& TopTextAsCompositeText() const;
 
    const Dtk_CompositeText& BottomTextAsCompositeText() const;
 
    const Dtk_CompositeText& RightTextAsCompositeText() const;
 
    const Dtk_CompositeText& LeftTextAsCompositeText() const;
 
 
     Dtk_string GetTopTextLabel() const;
 
     Dtk_string GetBottomTextLabel() const;
 
     Dtk_string GetRightTextLabel() const;
 
     Dtk_string GetLeftTextLabel() const;
 
     Dtk_ErrorStatus Explode(
          Dtk_CompositeText &outCompositeText,
          Dtk_tab<Dtk_CurvePtr> &outGeoms);
 
     const TypeEnum& ToleranceSpecificationContainerType() const;
 
     TypeEnum& ToleranceSpecificationContainerType();
 
//   //! \DtkInternal
//   void _PropagateOrientation(const Dtk_dir &inXAxis, const Dtk_dir &inYAxis);
 
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_bool& ProcessAddtionnalTexts) const;
 
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType,
          const Dtk_bool &inProcessAdditionnalTexts);
 
     Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     void Translate(const Dtk_dir &inTranslationDir);
 
    Dtk_ErrorStatus GetOuterBoundingBox(
        const Dtk_bool& inProcessAddtionnalTexts,
        Dtk_Oriented2dBBox& outOuterBBox) const;
};
 
class Dtk_Symbol : public Dtk_Annotation
{
public:
     enum TypeEnum {
        TypeUnknown = -1,
          TypeNote = 0,
          TypeDatum,
          TypeBalloon,
          TypeDatumTarget,
          TypeRoughness,
          TypeDimension,
          TypeFlagNote,
          TypeGeometricalTolerance,
          TypeAnnotationTable,
          TypeCell,
          TypeTable,
          TypeCallout,
        TypeWelding,
        TypeCoordinateDimension,
        TypeGeom,
          TypeAxis,
          TypeAxisSystem,
          TypeCenterLine,
          TypeCenterMark,
        TypeGrid,
        TypeRegion,
        TypeHatching,
          TypeFullBoltCircle,
          TypeCustomSymbol,
          TypeHoleNote,
          TypeUrl,
          TypeArrow
     };
    static inline const Dtk_string TypeEnumToString(const TypeEnum& inEnum)
    {
        switch( inEnum )
        {
        case TypeNote:                  return L"TypeNote";
        case TypeDatum:                 return L"TypeDatum";
        case TypeBalloon:               return L"TypeBalloon";
        case TypeDatumTarget:           return L"TypeDatumTarget";
        case TypeRoughness:             return L"TypeRoughness";
        case TypeDimension:             return L"TypeDimension";
        case TypeFlagNote:              return L"TypeFlagNote";
        case TypeGeometricalTolerance:  return L"TypeGeometricalTolerance";
        case TypeAnnotationTable:       return L"TypeAnnotationTable";
        case TypeCell:                  return L"TypeCell";
        case TypeTable:                 return L"TypeTable";
        case TypeCallout:               return L"TypeCallout";
        case TypeWelding:               return L"TypeWelding";
        case TypeCoordinateDimension:   return L"TypeCoordinateDimension";
          case TypeGeom:                  return L"TypeGeom";
          case TypeAxis:                  return L"TypeAxis";
          case TypeAxisSystem:            return L"TypeAxisSystem";
        case TypeCenterLine:            return L"TypeCenterLine";
        case TypeCenterMark:            return L"TypeCenterMark";
        case TypeGrid:                  return L"TypeGrid";
          case TypeHatching:              return L"TypeHatching";
          case TypeFullBoltCircle:        return L"TypeFullBoltCircle";
          case TypeCustomSymbol:          return L"TypeCustomSymbol";
          case TypeHoleNote:              return L"TypeHoleNote";
          case TypeUrl:                   return L"TypeUrl";
          case TypeArrow:                 return L"TypeArrow";
        default:                        return L"Unknown";
        }
    }
 
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum { _typeID = DTK_TYPE_SYMBOL };
protected:
 
     Dtk_Symbol(const Dtk_Dimension &inToBeConverted,const Dtk_bool &inKeepLeaderAsLeader);
 
     Dtk_Symbol(Dtk_Table& inToBeConverted, const Dtk_bool& inTextAutoFlip = DTK_FALSE);
 
     Dtk_Symbol(
          const Dtk_GeometricalTolerance& inToBeConverteds,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     Dtk_Symbol(
          const Dtk_Roughness &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     Dtk_Symbol(
          const Dtk_DatumTarget &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     Dtk_Symbol(
          const Dtk_Welding &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
    Dtk_Symbol(
        const Dtk_CompositeEntity &inToBeConverted,
        const Dtk_bool &inTextAutoFlip = DTK_FALSE);
    Dtk_Symbol(
        const Dtk_Grid &inGrid,
        const Dtk_bool &text_auto_flip = DTK_FALSE);
 
    Dtk_Symbol(const Dtk_Region &inRegion,
                           const Dtk_bool &text_auto_flip);
 
     Dtk_Symbol();
 
     Dtk_Symbol(const Dtk_Symbol &s);
     Dtk_Symbol( Dtk_Symbol&& s ) DTK_NOEXCEPT;
 
     ~Dtk_Symbol();
    inline virtual Dtk_Object* Clone() { return new Dtk_Symbol(*this); }
 
     Dtk_ErrorStatus _CreateDatumFeatureFrameAsGeometries( Dtk_pnt (&inTabPoints)[DTK_NB_ANCHOR_TYPES] );
 
private:
     void _Init();
     void _Reset();
     void _Copy(const Dtk_Symbol &s);
     friend class Dtk_SmartPtr<Dtk_Symbol>;
public:
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_Symbol * DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_SymbolPtr Create();
 
     static Dtk_SymbolPtr Create( const Dtk_Symbol &in );
     static Dtk_SymbolPtr Create( Dtk_Symbol&& in );
 
     static Dtk_SymbolPtr Create(
          const Dtk_pnt &inLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     static Dtk_SymbolPtr Create( const Dtk_DimensionPtr &inToBeConverted ,
        const Dtk_bool &inKeepLeaderAsLeader = DTK_FALSE );
 
     static Dtk_SymbolPtr Create(
          const Dtk_DatumTargetPtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     static Dtk_SymbolPtr Create(
          const Dtk_GeometricalTolerancePtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     static Dtk_SymbolPtr Create(
          const Dtk_TablePtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     static Dtk_SymbolPtr Create(
          const Dtk_RoughnessPtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
    static Dtk_SymbolPtr Create(
        const Dtk_GridPtr &inToBeConverted,
        const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
    static Dtk_SymbolPtr Create(
        const Dtk_RegionPtr &inToBeConverted,
        const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     static Dtk_SymbolPtr Create(
          const Dtk_AnnotationPtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     static Dtk_SymbolPtr Create(
          const Dtk_2dEntityPtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE,
        const Dtk_bool &inKeepLeaderAsLeader = DTK_FALSE );
 
     static Dtk_SymbolPtr Create(
          const Dtk_WeldingPtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip);
 
    static Dtk_SymbolPtr Create(
        const Dtk_CompositeEntityPtr &inToBeConverted,
        const Dtk_bool &inTextAutoFlip);
 
     Dtk_Symbol& operator=(const Dtk_Symbol & in );
     Dtk_Symbol& operator=( Dtk_Symbol&& in ) DTK_NOEXCEPT;
 
    Dtk_ErrorStatus AddGeometricalElement( const Dtk_EntityPtr &inGeomElt );
 
     Dtk_Size_t GetNumGeometricalElements() const;
 
     Dtk_EntityPtr GetGeomElement( const Dtk_Size_t &inPos ) const;
 
    void ConvertLeadersToGeometrie();
 
     const Dtk_CompositeText& Texts()const;
 
     Dtk_CompositeText& Texts();
 
    Dtk_frame_type FrameType() const;
 
    void SetFrameType( const Dtk_frame_type& inFrameType, Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements);
 
    void GetFrame(Dtk_Frame& outFrame) const;
 
     const TypeEnum& SymbolType()const;
 
     TypeEnum& SymbolType();
 
     Dtk_ErrorStatus GetAnchorPoints( Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES] ) const;
 
     type_detk get_type_detk() const { return DTK_TYPE_SYMBOL; }
 
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     Dtk_ErrorStatus SetLocation( const Dtk_pnt &inLocation );
 
     Dtk_ErrorStatus SetOffset( const Dtk_Double64 &inOffset );
 
     Dtk_ErrorStatus SetRotationAngle( const Dtk_Double64 &inRotationAngle );
 
     Dtk_ErrorStatus CreateFrameAsGeometries();
 
    void MergeWithOtherSymbol(const Dtk_SymbolPtr &inSymbolToBeMerged);
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
};
 
class Dtk_Drawing : public Dtk_Entity
{
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_DRAWING
     };
 
private:
     
     Dtk_Drawing(const Dtk_Drawing & in);
     Dtk_Drawing( Dtk_Drawing&& in ) DTK_NOEXCEPT;
 
     Dtk_Drawing();
 
     ~Dtk_Drawing();
    inline virtual Dtk_Object* Clone() { return new Dtk_Drawing(*this); }
 
private:
     void _Init();
     void _Copy(const Dtk_Drawing &s);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_Drawing>;
 
public:
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_Drawing* DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_DrawingPtr Create();
 
     static Dtk_DrawingPtr Create(const Dtk_Drawing &in);
     static Dtk_DrawingPtr Create( Dtk_Drawing&& in );
 
     type_detk get_type_detk() const
     {
          return DTK_TYPE_DRAWING;
     }
 
     Dtk_ErrorStatus AddView(const Dtk_ViewPtr &inViewtoBeAdded);
 
     Dtk_ErrorStatus AddOrigin(const Dtk_pnt &origin);
 
    Dtk_ErrorStatus AddView(const Dtk_ViewPtr& inView, const Dtk_pnt& inOrigin);
 
     Dtk_ViewPtr& GetView(const Dtk_Size_t &inPos);
 
     const Dtk_ViewPtr& GetView(const Dtk_Size_t &inPos)const;
 
     Dtk_Double64 &Width();
 
     const Dtk_Double64 &Width() const;
 
     Dtk_Double64 &Height();
 
     const Dtk_Double64 &Height() const;
 
     Dtk_Size_t GetNumViews() const;
 
     SetAsDeprecated( "2025.4", "Please remove calls to this function, it will always return 0." )
     Dtk_Size_t GetNum2dEntities() const;
 
     Dtk_Size_t GetNumOrigins() const;
 
     Dtk_pnt& GetOrigin(const Dtk_Size_t &inPos);
 
     const Dtk_pnt& GetOrigin(const Dtk_Size_t &inPos) const;
 
     SetAsDeprecated( "2025.4", "Please remove calls to this function, it will always return a null object." )
     Dtk_2dEntityPtr& Get2dEntity(const Dtk_Size_t &inPos);
 
     SetAsDeprecated( "2025.4", "Please remove calls to this function, it will always return a null object." )
     const Dtk_2dEntityPtr& Get2dEntity(const Dtk_Size_t &inPos) const ;
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
};
 
class Dtk_ViewDisplay : public Dtk_Object
{
public:
     enum DisplayMode3DEnum
     {
          DefaultDisplay = 0,
          WireframeDisplay = 1, 
          WithHiddenDisplay = 2,  
          NoHiddenDisplay = 3,  
          ShadingDisplay = 4,
          ShadingWithEdgeDisplay = 5
     };
 
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum
     {
          _typeID = DTK_TYPE_VIEW_DISPLAY
     };
 
     Dtk_ViewDisplay();
     Dtk_ViewDisplay( const Dtk_ViewDisplay &s );
     Dtk_ViewDisplay( Dtk_ViewDisplay &&s ) DTK_NOEXCEPT;
     Dtk_ViewDisplay( DisplayMode3DEnum  inDisplayMode );
     inline virtual Dtk_Object* Clone()
     {
          return new Dtk_ViewDisplay( *this );
     }
     ~Dtk_ViewDisplay();
private:
     void _Init();
     void _Copy( const Dtk_ViewDisplay &s );
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_ViewDisplay>;
public:
     Dtk_Int32 DtkDynamicType( const Dtk_Int32 &inId );
 
     static Dtk_ViewDisplay * DtkDynamicCast( Dtk_Object *s );
 
     type_detk get_type_detk() const
     {
          return DTK_TYPE_VIEW_DISPLAY;
     }
 
     static Dtk_ViewDisplayPtr Create( DisplayMode3DEnum  inDisplayMode);
 
     static Dtk_ViewDisplayPtr Create( const Dtk_ViewDisplay & in );
     static Dtk_ViewDisplayPtr Create( Dtk_ViewDisplay&& in );
 
 
     DisplayMode3DEnum GetDisplayMode();
 
     Dtk_ErrorStatus GetVisibleEdgesLineStyle( Dtk_FontLineType &outLineFont, Dtk_Double64 &outLineWidth, Dtk_RGB &outLineColor ) const;
 
     void SetVisibleEdgesLineStyle( Dtk_FontLineType inLineFont, Dtk_Double64 inLineWidth, Dtk_RGB inLineColor );
 
     Dtk_ErrorStatus GetHiddenEdgesLineStyle( Dtk_FontLineType &outLineFont, Dtk_Double64 &outLineWidth, Dtk_RGB &outLineColor ) const;
 
     void SetHiddenEdgesLineStyle( Dtk_FontLineType inLineFont, Dtk_Double64 inLineWidth, Dtk_RGB inLineColor );
 
     Dtk_ErrorStatus GetTangentEdgesLineStyle( Dtk_FontLineType &outLineFont, Dtk_Double64 &outLineWidth, Dtk_RGB &outLineColor ) const;
 
     void SetTangentEdgesLineStyle( Dtk_FontLineType inLineFont, Dtk_Double64 inLineWidth, Dtk_RGB inLineColor );
 
 
};
 
 
class Dtk_View : public Dtk_Entity
{
public:
     enum ViewType
     {
          NoTypeView = 0,
          DetailView = 1,
          SectionView = 2,
          BrokenView = 4,
     };
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_VIEW
     };
 
     Dtk_View();
 
     Dtk_View(const Dtk_View &s);
     Dtk_View( Dtk_View&& s ) DTK_NOEXCEPT;
    inline virtual Dtk_Object* Clone() { return new Dtk_View(*this); }
     ~Dtk_View();
private:
     void _Init();
     void _Copy(const Dtk_View &s);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_View>;
public:
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_View * DtkDynamicCast(Dtk_Object *s);
 
     type_detk get_type_detk() const
     {
          return DTK_TYPE_VIEW;
     }
 
     static Dtk_ViewPtr Create();
 
     static Dtk_ViewPtr Create(const Dtk_View &in);
     static Dtk_ViewPtr Create( Dtk_View&& in );
 
     Dtk_ErrorStatus Add2dEntity(const Dtk_2dEntityPtr &in2DEntity);
 
     Dtk_ErrorStatus Add2dEntities(
          const Dtk_tab<Dtk_2dEntityPtr> &in2DEntitiesArray);
 
    Dtk_ErrorStatus AddEntity(const Dtk_EntityPtr& inEnt);
 
    Dtk_ErrorStatus AddEntities(const Dtk_tab<Dtk_EntityPtr>& inEntitiesArray);
 
     Dtk_Size_t GetNum2dEntities() const;
 
     Dtk_2dEntityPtr Get2dEntity(const Dtk_Size_t &inPos) const;
 
     Dtk_2dEntityPtr operator [](const Dtk_Size_t &inPos) const;
 
     Dtk_PlaneSurfacePtr GetClipping(const Dtk_Size_t &inPos) const;
 
     const Dtk_CompositeEntityPtr & GetClippingBoundary() const;
 
     Dtk_ErrorStatus Add2dGeometricalEntity(const Dtk_EntityPtr  &inGeomElt) const;
 
     Dtk_Size_t GetNum2dGeometricalEntity() const;
 
     Dtk_EntityPtr Get2dGeometricalEntity( const Dtk_Size_t& inPos ) const;
 
     Dtk_ErrorStatus AddBody( const Dtk_BodyPtr &inBody );
     
    Dtk_ErrorStatus AddBodies(
        Dtk_tab<Dtk_BodyPtr> inBodyArray);
 
    Dtk_Size_t GetNumBodies() const;
 
     Dtk_BodyPtr GetBody(const Dtk_Size_t &inPos) const;
 
     
     void SetViewDisplay( Dtk_ViewDisplayPtr inDisplay );
 
     Dtk_ViewDisplayPtr GetViewDisplay();
 
     Dtk_ErrorStatus AddPicture( const Dtk_picturePtr &inPicture );
 
     Dtk_ErrorStatus AddPictures(
          const Dtk_tab<Dtk_picturePtr> &inPicturesArray );
 
     Dtk_Size_t GetNumPictures() const;
 
     Dtk_picturePtr GetPicture( const Dtk_Size_t &inPos ) const;
 
     Dtk_ErrorStatus AddOLEObject( const Dtk_OLEObjectPtr & inOLEObject );
     Dtk_ErrorStatus AddOLEObjects( const Dtk_tab<Dtk_OLEObjectPtr> & inOleObjects );
     Dtk_Size_t GetNumOLEObjects() const;
     Dtk_OLEObjectPtr GetOLEObject( const Dtk_Size_t & inIndex ) const;
 
 
     const Dtk_Double64& Scale() const;
 
     Dtk_Double64& Scale();
 
     const Dtk_Double64& Angle() const;
 
     Dtk_Double64& Angle();
 
     const Dtk_transfo& TransformationMatrix() const;
 
     Dtk_transfo& TransformationMatrix();
 
     Dtk_ErrorStatus SetClippingPlane(const Dtk_Size_t &inPos,
          const Dtk_pnt &inLocation,const Dtk_dir &inRefAxis,
          const Dtk_dir &inNormalAxis);
 
 
     void SetClippingBoundary(const Dtk_CompositeEntityPtr &inBoundary) const;
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     bool IsView( ViewType typeView );
     void AddView( ViewType typeView );
     
};
 
 
//FDT Classes
class Dtk_Fdt : public Dtk_Entity
{
public:
    enum ScreenDisplayEnum
    { 
        Default             = 0, 
        ParallelToScreen    = 1,
        PinToScreen         = 2  
    };
    static inline Dtk_string ScreenDisplayEnumToString(const ScreenDisplayEnum& inEnum)
    {
        switch( inEnum )
        {
        default:
        case Default:           return L"Default";
        case ParallelToScreen:  return L"ParallelToScreen";
        case PinToScreen:       return L"PinToScreen";
        }
    }
protected:
    struct Dtk_Handle; // Not defined here
    Dtk_Handle *_Private; // Handle
    enum
    {
        _typeID = DTK_TYPE_FDT
    };
 
    Dtk_Fdt();
 
    Dtk_Fdt(const Dtk_Fdt &inToBeCopied );
     Dtk_Fdt( Dtk_Fdt&& inToBeMoved ) DTK_NOEXCEPT;
 
    Dtk_Fdt(const Dtk_transfo &inTransforansform,
        const Dtk_2dEntityPtr &entity2D);
    inline virtual Dtk_Object* Clone() { return new Dtk_Fdt(*this); }
 
    virtual ~Dtk_Fdt();
 
private:
    void _Init();
    void _Reset();
    void _Copy(const Dtk_Fdt &s);
    friend class Dtk_SmartPtr<Dtk_Fdt>;
public:
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    static Dtk_Fdt* DtkDynamicCast(Dtk_Object *s);
 
    static Dtk_FdtPtr Create();
 
    static Dtk_FdtPtr Create(const Dtk_Fdt &s);
     static Dtk_FdtPtr Create( Dtk_Fdt&& inToBeMoved );
 
    static Dtk_FdtPtr Create(const Dtk_transfo &inTransformationMatrix,
        const Dtk_2dEntityPtr &inSub2DEntity);
 
    type_detk get_type_detk() const
    {
        return DTK_TYPE_FDT;
    }
 
    void SetScreenDisplayAttribute( const ScreenDisplayEnum inType );
 
    Dtk_Fdt::ScreenDisplayEnum GetScreenDisplayAttribute() const;
 
     void SetDisplayBackgroundColorId(Dtk_Int32 inData);
 
     Dtk_ErrorStatus GetDisplayBackgroundColorId(Dtk_Int32& outColorIdData);
 
 
     void SetIsZoomableAttribute( const bool &inBool );
 
     bool GetIsZoomableAttribute( ) const;
 
    const Dtk_transfo& TransformationMatrix() const;
 
    Dtk_transfo& TransformationMatrix();
 
    const Dtk_2dEntityPtr& Sub2DEntity() const;
 
    Dtk_2dEntityPtr& Sub2DEntity();
 
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
};
 
 
class Dtk_Camera : public Dtk_Entity
{
public:
     enum ProjectionTypeEnum{
          ProjectionTypeUnknown = 0,
          ProjectionTypeParallel,
          ProjectionTypePerspective
     };
    enum ZoomFitModeEnum
    {
        NoZoomFit = 0,      //The camera doesn't need to be zoom fitted.
        ZoomFitAllScene,    //The camera needs to be zoom fitted to the entire scene.
    };
    protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum { _typeID = DTK_TYPE_CAMERA };
     Dtk_Camera();
 
     Dtk_Camera(const Dtk_Camera &s);
    inline virtual Dtk_Object* Clone() { return new Dtk_Camera(*this); }
 
     ~Dtk_Camera();
private:
     void _Init();
     void _Copy(const Dtk_Camera &s);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_Camera>;
public:
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_Camera * DtkDynamicCast(Dtk_Object *s);
 
     type_detk get_type_detk() const { return DTK_TYPE_CAMERA; }
 
     static Dtk_CameraPtr Create();
 
     static Dtk_CameraPtr Create(
          const Dtk_pnt& inOriginPoint,
          const Dtk_pnt& inTarget,
          const Dtk_dir& inUpVector,
          const double& inAngle,
          const double& inFocus,
          const double& inZoomFactor = 1.0,
          const ProjectionTypeEnum inProjectionType = ProjectionTypeParallel,
        const ZoomFitModeEnum inZoomFitMode = NoZoomFit );
 
    static Dtk_CameraPtr Create(
        const Dtk_pnt& inOriginPoint,
        const Dtk_pnt& inTarget,
        const Dtk_Double64 inSemiWidth,
        const Dtk_Double64 inSemiHeight,
        const Dtk_dir& inUpVector,
        const ProjectionTypeEnum inProjectionType = ProjectionTypeParallel,
        const ZoomFitModeEnum inZoomFitMode = NoZoomFit );
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     const Dtk_pnt& OriginPoint() const;
 
    const Dtk_pnt& TargetPoint() const;
 
     const Dtk_dir& UpVector() const;
 
    Dtk_Double64 GetFocusDistance() const;
 
    Dtk_Double64 GetSemiWidth() const;
 
    Dtk_Double64 GetSemiHeight() const;
 
     const Dtk_Camera::ProjectionTypeEnum& ProjectionType() const;
 
    const Dtk_Camera::ZoomFitModeEnum& GetZoomFitMode() const;
 
    Dtk_Double64 ProcessXZoomFactor() const { return IsValid() ? ( 1. / GetSemiWidth() ) : 0.; }
 
    Dtk_Double64 ProcessYZoomFactor() const { return IsValid() ? ( 1. / GetSemiHeight() ) : 0.; }
 
    inline Dtk_Double64 ProcessXSemiAngle() const { return IsValid() ? ( atan( GetSemiWidth() / GetFocusDistance() ) ) : 0.; }
 
    inline Dtk_Double64 ProcessYSemiAngle() const { return IsValid() ? ( atan( GetSemiHeight() / GetFocusDistance() ) ) : 0.; }
 
    Dtk_dir TargetVector() const;
 
    inline Dtk_Double64 Angle() const { return ProcessXSemiAngle() * 180. / DTK_PI; }
 
    inline Dtk_Double64 ZoomFactor() const { return ProcessXZoomFactor(); }
 
    inline Dtk_Double64 Focus() const { return GetFocusDistance(); }
 
    inline Dtk_bool IsValid() const
    {
        if( GetFocusDistance() < DTK_TOLERANCE ||
            GetSemiWidth() < DTK_TOLERANCE ||
            GetSemiHeight() < DTK_TOLERANCE )
        {
            return DTK_FALSE;
        }
        else
        {
            return DTK_TRUE;
        }
    }
 
     void SetClippingDistance(const Dtk_Double64& inFrontDistance ,const Dtk_Double64& inBackDistance ) const;
 
     void GetClippingDistance( Dtk_Double64& outFrontDistance, Dtk_Double64& outBackDistance ) const;
 
};
 
 
 
typedef enum
{
     Dtk_HatchingStyle_Unknown,
     Dtk_HatchingStyle_Hatching,
     Dtk_HatchingStyle_Coloring,
     Dtk_HatchingStyle_Dotting
} Dtk_HatchingStyle;
 
 
class Dtk_HatchingPattern
{
public :
 
     Dtk_HatchingStyle _style;
     Dtk_Double64 _offset;
     Dtk_Double64 _angle;
     Dtk_Double64 _pitch;
     Dtk_RGB         _color;
     Dtk_Int32    _line_style;
     Dtk_Double64    _line_width;
 
     Dtk_HatchingPattern ()
     {
          this->_angle = 0.0;
          this->_line_style = 0;
          this->_line_width = 0.0;
          this->_offset = 0.0;
          this->_style = (Dtk_HatchingStyle) 0;
          this->_pitch = 0.0;
 
     }
 
     Dtk_HatchingPattern (const Dtk_HatchingPattern& in)
     {
          this->_angle = in._angle;
          this->_color = in._color;
          this->_line_style = in._line_style;
          this->_line_width = in._line_width;
          this->_offset = in._offset;
          this->_style = in._style;
          this->_pitch = in._pitch;
     }
 
     Dtk_HatchingPattern& operator=(const Dtk_HatchingPattern& in)
     {
          if (&in!=this)
          {
               this->_angle = in._angle;
               this->_color = in._color;
               this->_line_style = in._line_style;
               this->_line_width = in._line_width;
               this->_offset = in._offset;
               this->_pitch = in._pitch;
               this->_style = in._style;
          }
          return *this;
     }
 
 
 
     Dtk_HatchingStyle & HatchingStyle ();
     Dtk_Double64 & Offset ();
     Dtk_Double64 & Pitch ();
     Dtk_Double64 & Angle ();
     Dtk_RGB & Color ();
     Dtk_Int32 & LineType ();
     Dtk_Double64 & LineWidth ();
 
    const Dtk_HatchingStyle & HatchingStyle () const;
 
    const Dtk_Double64 & Offset () const;
    const Dtk_Double64 & Pitch () const;
    const Dtk_Double64 & Angle () const;
     const Dtk_RGB & Color () const;
    const Dtk_Int32 & LineType () const;
     const Dtk_Double64 & LineWidth () const;
 
};
 
 
 
class Dtk_Hatching : public Dtk_Entity
{
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_HATCHING
     };
     Dtk_Hatching();
 
     Dtk_Hatching(const Dtk_Hatching &s);
 
     ~Dtk_Hatching();
 
    inline virtual Dtk_Object* Clone() { return new Dtk_Hatching(*this); }
 
private:
     void _Init();
     void _Copy(const Dtk_Hatching &s);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_Hatching>;
    void __GeneratePatternGeometries( const Dtk_HatchingPattern& inHatchingPattern, const Dtk_Oriented2dBBox& BoundariesBBox, Dtk_tab< Dtk_EntityPtr >& inoutResultEntities );
public:
 
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_Hatching* DtkDynamicCast(Dtk_Object *s);
 
     static Dtk_HatchingPtr Create();
 
     type_detk get_type_detk() const;
 
     Dtk_Hatching& operator=(const Dtk_Hatching& in);
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     Dtk_tab<Dtk_PolylinePtr> &Boundaries ();
 
     Dtk_tab<Dtk_HatchingPattern> & Patterns ();
 
     void SetApplyScaleOnPattern( bool inApply = true );
 
    Dtk_tab< Dtk_EntityPtr > GeneratePatternGeometries(const Dtk_dir& inXRefDir = Dtk_dir(1., 0., 0.), const Dtk_dir& inNormalDir = Dtk_dir(0., 0., 1.) );
};
 
 
class Dtk_CompositeEntity : public Dtk_2dEntity
{
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_COMPOSITE_ENTITY
     };
 
     Dtk_CompositeEntity();
 
     Dtk_CompositeEntity(const Dtk_CompositeEntity &s);
     Dtk_CompositeEntity( Dtk_CompositeEntity&& s ) DTK_NOEXCEPT;
 
     inline virtual Dtk_Object* Clone() { return new Dtk_CompositeEntity(*this); }
     ~Dtk_CompositeEntity();
private:
     void _Init();
     void _Copy(const Dtk_CompositeEntity &s);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_CompositeEntity>;
public:
     void Clear();
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_CompositeEntity * DtkDynamicCast(Dtk_Object *s);
 
     type_detk get_type_detk() const
     {
          return DTK_TYPE_COMPOSITE_ENTITY;
     }
 
     static Dtk_CompositeEntityPtr Create();
 
     static Dtk_CompositeEntityPtr Create(const Dtk_CompositeEntity &in);
     static Dtk_CompositeEntityPtr Create( Dtk_CompositeEntity&& in );
 
    Dtk_ErrorStatus AddEntity(const Dtk_EntityPtr &inElt );
 
    void AddEntities(const Dtk_tab<Dtk_EntityPtr>& inEltArray);
 
    Dtk_ErrorStatus AddPicture( const Dtk_picturePtr &inElt );
 
    void AddPictures( const Dtk_tab<Dtk_picturePtr>& inEltArray );
 
    Dtk_Size_t GetNumEntities() const;
 
    Dtk_EntityPtr GetEntity( const Dtk_Size_t& inPos ) const;
 
    Dtk_Size_t GetNumPictures() const;
 
    Dtk_picturePtr GetPicture( const Dtk_Size_t& inPos ) const;
 
    void GetAllEntitiesByType(
        Dtk_tab< Dtk_2dEntityPtr >& out2dEntities,
        Dtk_tab< Dtk_EntityPtr >& outGeometricalEntities,
        Dtk_tab< Dtk_picturePtr >& outPictures ) const;
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
};
 
 
class Dtk_Region : public Dtk_Annotation
{
public:
    enum RegionType
    {
        RectangularType,
        CircularType,
        AnnularType,
        CylindricalType,
        ArbitraryType,
        UnknownType
    };
protected:
    struct Dtk_Handle; // Not defined here
    Dtk_Handle *_Private; // Handle
    enum
    {
        _typeID = DTK_TYPE_REGION
    };
    Dtk_Region(RegionType inType,
               Dtk_HatchingPattern &inHatchingPattern,
               Dtk_tab< Dtk_EntityPtr > inGeometries);
 
    Dtk_Region(const Dtk_Region &s);
 
    ~Dtk_Region();
 
    inline virtual Dtk_Object* Clone() { return new Dtk_Region(*this); }
 
private:
    void _Init();
    void _Copy(const Dtk_Region &s);
    void _Reset();
    friend class Dtk_SmartPtr<Dtk_Region>;
public:
 
 
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    static Dtk_Region* DtkDynamicCast(Dtk_Object *s);
 
    static Dtk_RegionPtr Create(RegionType inType,
                                Dtk_HatchingPattern &inHatchingPattern,
                                Dtk_tab< Dtk_EntityPtr > inGeometries);
 
    type_detk get_type_detk() const { return DTK_TYPE_REGION; }
 
    Dtk_Region& operator=(const Dtk_Region& in);
 
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    Dtk_tab< Dtk_EntityPtr > GetGeometries() const;
 
    Dtk_ErrorStatus GetAnchorPoints(
        Dtk_pnt(&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
    Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
                                   const Dtk_anchor_type &inLocationAnchorType);
 
    Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
    Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
    RegionType GetType();
 
    Dtk_ErrorStatus SetRectangularWidth(Dtk_Double64 inWidth);
 
    Dtk_ErrorStatus GetRectangularWidth(Dtk_Double64 &outWidth);
 
    Dtk_ErrorStatus SetRectangularHeight(Dtk_Double64 inHeight);
 
    Dtk_ErrorStatus GetRectangularHeight(Dtk_Double64 &outHeight);
 
    Dtk_ErrorStatus SetCircularDiameter(Dtk_Double64 inDiameter);
 
    Dtk_ErrorStatus GetCircularDiameter(Dtk_Double64 &outDiameter);
 
    Dtk_ErrorStatus SetAnnularOuterDiameter(Dtk_Double64 inDiameter);
 
    Dtk_ErrorStatus GetAnnularOuterDiameter(Dtk_Double64 &outDiameter);
 
    Dtk_ErrorStatus SetAnnularInnerDiameter(Dtk_Double64 inDiameter);
 
    Dtk_ErrorStatus GetAnnularInnerDiameter(Dtk_Double64 &outDiameter);
 
    Dtk_HatchingPattern GetHatchingPattern();
 
 
};
 
 
#endif