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/dtk_oleobject.hpp"
#include "util/util_ptr_dtk.hpp"
#include "util/util_stl_dtk.hpp"
#include "util/util_topology_ptr_dtk.hpp"
#include "util/dtk/span.hpp"
#include <cmath>
#include "def/define.h"
#include "dtk/config.hpp"
#include <iosfwd>
#include <memory>
#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
 
/// @cond NO_DOXYGEN_DOC
//Forward declarations
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;
/// @endcond
 
////////////////////////////////////////////////////////////////////////////////////////////////
//! \enum DTK_FDT_MODIFIER
//! \brief This is the several tolerances modifiers list
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
//! \brief This is the several references composing rules
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,
     //! \image html TextAlignmentLeft.png
     DTK_ALIGN_LEFT,
     //! \image html TextAlignmentRight.png
     DTK_ALIGN_RIGHT,
     //! \image html TextAlignmentCenter.png
     DTK_ALIGN_CENTER,
     //! \image html TextAlignmentJustifed.png
     DTK_ALIGN_JUSTIFIED
};
 
enum Dtk_justication_type {
     //! \image html TextAlignmentLeft.png
     DTK_JUSTIFY_LEFT = 0,
     //! \image html TextAlignmentCenter.png
     DTK_JUSTIFY_CENTER,
     //! \image html TextAlignmentRight.png
     DTK_JUSTIFY_RIGHT
};
 
enum Dtk_frame_type {
     DTK_FRAME_TYPE_NONE = 0,
     //! \image html FrameTypeRectangle.png
     DTK_FRAME_TYPE_RECTANGLE = 1,
     //! \image html FrameTypeSquare.png
     DTK_FRAME_TYPE_SQUARE = 2,
     //! \image html FrameTypeCircle.png
     DTK_FRAME_TYPE_CIRCLE = 3,
     //! \image html FrameTypeScoredCircle.png
     DTK_FRAME_TYPE_SCORED_CIRCLE = 4,
     //! \image html FrameTypeDiamond.png
     DTK_FRAME_TYPE_DIAMOND = 5,
     //! \image html FrameTypeTriangle.png
     DTK_FRAME_TYPE_TRIANGLE = 6,
     //! \image html FrameTypeFlagRight.png
     DTK_FRAME_TYPE_FLAG_RIGHT = 7,
     //! \image html FrameTypeFlagLeft.png
     DTK_FRAME_TYPE_FLAG_LEFT = 8,
     //! \image html FrameTypeFlagBoth.png
     DTK_FRAME_TYPE_FLAG_BOTH = 9,
     //! \image html FrameTypeOblong.png
     DTK_FRAME_TYPE_OBLONG = 10,
     //! \image html FrameTypeOblongRight.png
     DTK_FRAME_TYPE_OBLONG_RIGHT = 11,
     //! \image html FrameTypeOblongLeft.png
     DTK_FRAME_TYPE_OBLONG_LEFT = 12,
     //! \image html FrameTypeEllipse.png
     DTK_FRAME_TYPE_ELLIPSE = 13,
     DTK_FRAME_TYPE_STICKING = 14,
     //! \image html FrameTypeSet.png
     DTK_FRAME_TYPE_SET = 15,
     //! \image html FrameTypeFixedSupport.png
     DTK_FRAME_TYPE_FIXED_SUPPORT = 16,
     //! \image html FrameTypeNota.png
     DTK_FRAME_TYPE_NOTA = 17,
     //! \image html FrameTypeSymmetricalPart.png
     DTK_FRAME_TYPE_SYMMETRICAL_PART = 18,
     //! \image html FrameTypeSymmetricalSet.png
     DTK_FRAME_TYPE_SYMMETRICAL_SET = 19,
     //! \image html FrameTypeScoredRectangle.png
     DTK_FRAME_TYPE_SCORED_RECTANGLE = 20,
     //! \image html FrameTypeParallelogram.png
    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
};
 
//! \ingroup draw
//! \class Dtk_Font
//! \brief This is the font class
//! This class lets you access to font information (name, type ...)
class Dtk_Font
{
public:
     enum FontTypeEnum {
          FontUnknown = 0,
          FontTruescript,
          FontPostscript,
          FontOpentype
     };
protected:     
     //! \brief Font name
     Dtk_string _name;
     //! \brief Font type (Postcript, TrueType)
     FontTypeEnum _font_type;
     //! \brief Font ID
     Dtk_Size_t _ID;
public:
     //! \BaseDestructor
     ~Dtk_Font();
     //! \BaseConstructor
     Dtk_Font();
 
     //! \brief Retrieves the font name - get/set -
     //! \return The font name
     //! \sa Name() const
     Dtk_string& Name();
 
     //! \brief Retrieves the font name - read only -
     //! \return The font name
     //! \sa Name()
     const Dtk_string& Name() const;
 
     //! \brief Retrieves the font type - get/set -
     //! \return The font type (FontTruescript, FontPostscript, etc...)
     //! \sa FontTypeEnum() const
     FontTypeEnum& FontType();
 
     //! \brief Retrieves the font type - read only -
     //! \return The font type (FontTruescript, FontPostscript, etc...)
     //! \sa FontTypeEnum()
     const FontTypeEnum& FontType() const;
 
     //! \brief Retrieves the font Id - get/set -
     //! \return The font Id
     //! \sa ID() const
     Dtk_Size_t& ID();
 
     //! \brief Retrieves the font Id - read only -
     //! \return The font Id
     //! \sa ID()
     const Dtk_Size_t& ID() const;
 
     //! \internal
};
 
//! \ingroup draw
//! \class Dtk_TextStyle
//! \brief This is the text_style.
//! This class gathers information about text style.
class Dtk_TextStyle
{
public:
     enum FontStyleEnum {
          //! \image html FontStyleRegular.png
          StyleRegular = 0,
          //! \image html FontStyleBold.png
          StyleBold,
          //! \image html FontStyleItalic.png
          StyleItalic,
          //! \image html FontStyleBoldItalic.png
          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 {
          //! \image html TextAttributeNone.png
          AttributeNone = 0,
          //! \image html TextAttributeUnderline.png
          AttributeUnderline = 1,
          //! \image html TextAttributeStrikethrough.png
          AttributeStrikethrough = 2,
          //! \image html TextAttributeOverline.png
          AttributeOverline = 4,
          //! \image html TextAttributeSuperscript.png
          AttributeSuperscript = 8,
          //! \image html TextAttributeSubscript.png
          AttributeSubscript = 16
     };
     enum TextJustificationEnum {
          //! \image html TextJustificationLeft.png
          JustificationLeft = 0,
          //! \image html TextJustificationCenter.png
          JustificationCenter,
          //! \image html TextJustificationRight.png
          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:
 
     //! \brief Font informations
     Dtk_Font _font;
     //! \brief Font Style type (Regular, Italic, etc...)
     FontStyleEnum _font_style;
     //! \brief Text Attribute (Underline, etc...)
     TextAttributeEnum _attributes;
     //! \brief Text Justification (Left, etc...)
     TextJustificationEnum _justification;
     //! \brief Height of each char in the text
     Dtk_Double64 _char_height;
     //! \brief Spacing between two chars
     Dtk_Double64 _char_spacing;
     //! \brief Width of each char in the text
     Dtk_Double64 _char_width;
     //! \brief Spacing between two lines in the text - for multiline texts for example -
     Dtk_Double64 _line_spacing;
     //! \brief Char Slant (PI/2 by default)
     Dtk_Double64 _slant;
     //! \brief Char Ratio. It represents the stretch of the width of the text. Default value is 1.
     Dtk_Double64 _ratio;
     //! \brief Char Pitch
     Dtk_Double64 _pitch;
public:
     //! \BaseDestructor
     ~Dtk_TextStyle();
 
     //! \BaseConstructor
     Dtk_TextStyle();
 
     //! \brief Retrieves the font - get/set -
     //! \return The font
     //! \sa Font() const
     Dtk_Font& Font();
 
     //! \brief Retrieves the font - read only -
     //! \return The font
     //! \sa Font()
     const Dtk_Font& Font() const;
 
     //! \brief Retrieves the font style - get/set -
     //! \return The font style
     //! \sa FontStyle() const
     FontStyleEnum& FontStyle();
 
     //! \brief Retrieves the font style - read only -
     //! \return The font style
     //! \sa FontStyle()
     const FontStyleEnum& FontStyle() const;
 
     //! \brief Retrieves the text attribute - get/set -
     //! \return The text attribute
     //! \sa Attributes() const
     TextAttributeEnum& Attributes();
 
     //! \brief Retrieves the text attribute - read only -
     //! \return The text attribute
     //! \sa Attributes()
     const TextAttributeEnum& Attributes() const;
 
     //! \brief Retrieves the text justification - get/set -
     //! \return The text justification
     //! \sa Justification()
     TextJustificationEnum& Justification();
 
     //! \brief Retrieves the text justification - read only -
     //! \return The text justification
     //! \sa Justification() const
     const TextJustificationEnum& Justification() const;
 
     //! \brief Retrieves the char height - get/set -
     //! \return The char height
     //! \sa CharHeight() const
     Dtk_Double64& CharHeight();
 
     //! \brief Retrieves the char height - Read Only -
     //! \return The char height
     //! \sa CharHeight()
     const Dtk_Double64& CharHeight() const;
 
     //! \brief Retrieves the char spacing - get/set -
     //! \return The char spacing
     //! \sa CharSpacing() const
     Dtk_Double64& CharSpacing();
 
     //! \brief Retrieves the char spacing - read only -
     //! \return The char spacing
     //! \sa CharSpacing()
     const Dtk_Double64& CharSpacing() const;
 
     //! \brief Retrieves the char width - get/set -
     //! \return The char width
     //! \sa CharWidth() const
     Dtk_Double64& CharWidth();
 
     //! \brief Retrieves the char width - read only -
     //! \return The char width
     //! \sa CharWidth()
     const Dtk_Double64& CharWidth() const;
 
     //! \brief Retrieves the line spacing - get/set -
     //! \return The line spacing
     //! \sa LineSpacing() const
     Dtk_Double64& LineSpacing();
 
     //! \brief Retrieves the line spacing - read only -
     //! \return The line spacing
     //! \sa LineSpacing()
     const Dtk_Double64& LineSpacing() const;
 
     //! \brief Retrieves the text slant - get/set -
     //! \return The text slant
     //! \sa Slant() const
     Dtk_Double64& Slant();
 
     //! \brief Retrieves the text slant - read only -
     //! \return The text slant
     //! \sa Slant()
     const Dtk_Double64& Slant() const;
 
     //! \brief Retrieves the text ratio - get/set -
     //! \return The text ratio
     //! \sa Ratio() const
     Dtk_Double64& Ratio();
 
     //! \brief Retrieves the text ratio - Read Only -
     //! \return The text ratio
     //! \sa Ratio()
     const Dtk_Double64& Ratio() const;
 
     //! \brief Retrieves the text pitch - get/set -
     //! \return The text pitch
     //! \sa Pitch() const
     Dtk_Double64& Pitch();
 
     //! \brief Retrieves the text pitch - read only -
     //! \return The text pitch
     //! \sa Pitch()
     const Dtk_Double64& Pitch() const;
 
};
 
//! \ingroup draw
//! \class Dtk_Oriented2dBBox
//! \brief This is the base bounding box class.\n
//! It's used into a lot of 2D Entities\n
//! This class represents the base bounding box used in the texts entities.\n
//! \n The Dtk_Oriented2dBBox uses an anchor point notion. Here the 9 anchor point types:\n\n
//! \image html Dtk_Oriented2dBBox.png "Anchor Type Samples"
class Dtk_Oriented2dBBox
{
protected:
     Dtk_pnt _BottomLeftPnt;
     Dtk_dir _XLocalVector;
     Dtk_dir _YLocalVector;
     Dtk_Double64 _XLength;
     Dtk_Double64 _YLength;
public:
     //! \BaseConstructor
     Dtk_Oriented2dBBox();
 
     //! \brief Full featured constructor
     //! \param inBottomLeft Bottom left point
     //! \param inXLength X length
     //! \param inYLenght Y length
     //! \param inRefAxis Ref axis
     //! \param inNormalAxis Normal axis
     Dtk_Oriented2dBBox(const Dtk_pnt &inBottomLeft,
          const Dtk_Double64 &inXLength,
          const Dtk_Double64 inYLength,
          const Dtk_dir &inRefAxis = Dtk_dir(1,0,0),
          const Dtk_dir &inNormalAxis = Dtk_dir(0,0,1));
 
     //! \brief Clear elements
    inline void Clear()
    {
          _BottomLeftPnt = Dtk_pnt( 0.0, 0.0, 0.0 );
          _XLocalVector = Dtk_dir( 1.0, 0.0, 0.0 );
          _YLocalVector = Dtk_dir( 0.0, 1.0, 0.0 );
          _XLength = 0.0;
          _YLength = 0.0;
    }
 
     //! \brief Processes all the anchor points
     //! \param outTabPnts the resulting anchor point array
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     //! \brief Retrieves the bottom left point - Read Only -
     //! \return The bottom left point
     inline Dtk_pnt BottomLeftPoint() const
     {
          return _BottomLeftPnt;
     }
 
     //! \brief Retrieves the bottom left point - Read Only -
     //! \return The bottom left point
     //! \sa BottomLeftPoint()
     inline Dtk_pnt GetBottomLeftPoint() const
     {
          return BottomLeftPoint();
     }
 
     //! \brief Retrieves the middle left point - Read Only -
     //! \return The middle left point
     inline Dtk_pnt GetMiddleLeftPoint() const
     {
          return _BottomLeftPnt + 0.5*_YLength*_YLocalVector;
     }
 
     //! \brief Retrieves the top left point - Read Only -
     //! \return The top left point
     inline Dtk_pnt GetTopLeftPoint() const
     {
          return _BottomLeftPnt + _YLength*_YLocalVector;
     }
 
     //! \brief Retrieves the bottom center point - Read Only -
     //! \return The bottom center point
     inline Dtk_pnt GetBottomCenterPoint() const
     {
          return _BottomLeftPnt + 0.5*_XLength*_XLocalVector;
     }
 
     //! \brief Retrieves the middle center point - Read Only -
     //! \return The middle center point
     inline Dtk_pnt GetMiddleCenterPoint() const
     {
          return _BottomLeftPnt + 0.5*_YLength*_YLocalVector
               + 0.5*_XLength*_XLocalVector;
     }
 
     //! \brief Retrieves the top center point - Read Only -
     //! \return The top center point
     inline Dtk_pnt GetTopCenterPoint() const
     {
          return _BottomLeftPnt + _YLength*_YLocalVector
               + 0.5*_XLength*_XLocalVector;
     }
 
     //! \brief Retrieves the bottom right point - Read Only -
     //! \return The bottom right point
     inline Dtk_pnt GetBottomRightPoint() const
     {
          return _BottomLeftPnt + _XLength*_XLocalVector;
     }
 
     //! \brief Retrieves the middle right point - Read Only -
     //! \return The middle right point
     inline Dtk_pnt GetMiddleRightPoint() const
     {
          return _BottomLeftPnt + 0.5*_YLength*_YLocalVector
               + _XLength*_XLocalVector;
     }
 
     //! \brief Retrieves the top right point - Read Only -
     //! \return The top right point
     inline Dtk_pnt GetTopRightPoint() const
     {
          return _BottomLeftPnt + _YLength*_YLocalVector + _XLength*_XLocalVector;
     }
 
     //! \brief Retrieves the X length - Read Only -
     //! \return The X length
     inline Dtk_Double64 GetXLength() const
     {
          return _XLength;
     }
 
     //! \brief Retrieves the Y length - Read Only -
     //! \return The Y length
     inline Dtk_Double64 GetYLength() const
     {
          return _YLength;
     }
 
     //! \brief Retrieves the X local vector - Read Only -
     //! \return The X local vector
     inline Dtk_dir XLocalVector() const
     {
          return _XLocalVector;
     }
 
     //! \brief Retrieves the Y local vector - Read Only -
     //! \return The Y local vector
     inline Dtk_dir YLocalVector() const
     {
          return _YLocalVector;
     }
 
     //! \brief Sets the X local vector
     //! \param inNewXVector The new X local vector
     inline void SetXLocalVector(const Dtk_dir& inNewXVector)
     {
          _XLocalVector = inNewXVector;
          _XLocalVector.normalize();
     }
 
     //! \brief Sets the Y local vector
     //! \param inNewYVector The new Y local vector
     inline void SetYLocalVector(const Dtk_dir& inNewYVector)
     {
          _YLocalVector = inNewYVector;
          _YLocalVector.normalize();
     }
 
     //! \brief Sets the X and Y local vectors
     //! \param inNewXVector The new X local vector
     //! \param inNewYVector The new Y local vector
     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;
     }
 
     //! \brief Test if a point is inside Dtk_Oriented2dBBox class
     //! \param inPoint The point
     //! \brief  return true if the point is inside Dtk_Oriented2dBBox class
     Dtk_bool IsInside(const Dtk_pnt &inPoint) const;
 
     //! \brief Merges the Dtk_Oriented2dBBox to an additional point
     //! \param inPoint The inPoint to be merged
     //! \sa Merge
     void Merge(const Dtk_pnt &inPoint);
 
     //! \brief Merges the Dtk_Oriented2dBBox to another one
     //! \param inOriented2dBBox The Dtk_Oriented2dBBox to be merged
     //! \sa Merge
     void Merge(const Dtk_Oriented2dBBox &inOriented2dBBox);
 
     //! \brief Translates the text giving a translation vector
     //! \param inTranslateDir the translation vector
     //! \return dtkNoError if OK
     void Translate(const Dtk_dir &inTranslation);
 
     //! \brief Rotates the bounding box
     //! \param inAngleInRadian The angle in radian
     //! \return dtkNoError if OK
     void Rotate(const Dtk_Double64 &inAngleInRadian);
 
     //! \brief Applies a transformation matrix to the bounding box
     //! \param inTransfo The transformation matrix
     //! \return dtkNoError if OK
     void Transform(const Dtk_transfo &inTransfo);
 
     //! \brief Reverses the bounding box
     //! X local vector and Y local vector orientation are reversed
     //! \return dtkNoError if OK
     void Reverse();
 
     //! \brief Extend the bounding box
     //! \param inXExtend Extend the bounding box horizontally
     //! \param inYExtend Extend the bounding box vertically
     //! \return dtkNoError if OK
     void Extend(const Dtk_Double64 &inXExtend, const Dtk_Double64 &inYExtend);
 
     //! \brief Extend the bounding box
     //! \param inTopExtend Extend the top of the bounding box
     //! \param inBottomExtend Extend the bottom of the bounding box
     //! \param inLeftExtend Extend the left of the bounding box
     //! \param inRightExtend Extend the right of the bounding box
     //! \return dtkNoError if OK
     void Extend(const Dtk_Double64 &inTopExtend,
          const Dtk_Double64 &inBottomExtend,
          const Dtk_Double64 &inLeftExtend,
          const Dtk_Double64 &inRightExtend);
 
     //! \brief Retrieves the bottom left point
     //! \return The bottom left point
     inline Dtk_pnt& BottomLeftPoint()
     {
          return _BottomLeftPnt;
     }
 
     //! \brief Retrieves the X local vector
     //! \return The X local vector
     inline Dtk_dir& XLocalVector()
     {
          return _XLocalVector;
     }
 
     //! \brief Retrieves the Y local vector
     //! \return The Y local vector
     inline Dtk_dir& YLocalVector()
     {
          return _YLocalVector;
     }
 
     //! \brief Retrieves the X length
     //! \param inNewXlength Extend the new X length of the bounding box
     //! \return The X length
     void SetXLength(const Dtk_Double64 &inNewXlength);
 
     //! \brief Retrieves the Y length
     //! \param inNewXlength Extend the new Y length of the bounding box
     //! \return The Y length
     void SetYLength(const Dtk_Double64 &inNewXlength);
 
     //! \brief Sets the bottom left point
     //! \param inNewPoint The new bottom left point
     void SetBottomLeftPoint(const Dtk_pnt &inNewPoint);
 
     //! \brief Sets the middle left point
     //! \param inNewPoint The new middle left point
     void SetMiddleLeftPoint(const Dtk_pnt &inNewPoint);
 
     //! \brief Sets the top left point
     //! \param inNewPoint The new top left point
     void SetTopLeftPoint(const Dtk_pnt &inNewPoint);
 
     //! \brief Sets the bottom center point
     //! \param inNewPoint The new bottom center point
     void SetBottomCenterPoint(const Dtk_pnt &inNewPoint);
 
     //! \brief Sets the middle center point
     //! \param inNewPoint The new middle center point
     void SetMiddleCenterPoint(const Dtk_pnt &inNewPoint);
 
     //! \brief Sets the top center point
     //! \param inNewPoint The new top center point
     void SetTopCenterPoint(const Dtk_pnt &inNewPoint);
 
     //! \brief Sets the bottom right point
     //! \param inNewPoint The new bottom right point
     void SetBottomRightPoint(const Dtk_pnt &inNewPoint);
 
     //! \brief Sets the middle right point
     //! \param inNewPoint The new middle right point
     void SetMiddleRightPoint(const Dtk_pnt &inNewPoint);
 
     //! \brief Sets the top right point
     //! \param inNewPoint The new top right point
     void SetTopRightPoint(const Dtk_pnt &inNewPoint);
 
     //! \brief Retrieves the point with inAnchorType type
     //! \param inAnchorType The point anchor type
     //! \return The point
     Dtk_pnt GetPoint(const enum Dtk_anchor_type& inAnchorType) const;
 
     //! \brief Sets the point with inAnchorType type
     //! \param inNewPoint The new point
     //! \param inAnchorType The point anchor type
     void SetPoint(const Dtk_pnt &inNewPoint,
          const enum Dtk_anchor_type& inAnchorType);
 
     //! \brief Process distance - Read Only -
     //! \param inReferenceBBox The reference bounding box
     //! \param outTopOffSet The result top offset
     //! \param outBottomOffSet The result bottom offset
     //! \param outRightOffSet The result right offset
     //! \param outLeftOffSet The result left offset
     Dtk_ErrorStatus ProcessDistance(const Dtk_Oriented2dBBox& inReferenceBBox,
          Dtk_Double64& outTopOffSet, Dtk_Double64& outBottomOffSet,
          Dtk_Double64& outRightOffSet, Dtk_Double64& outLeftOffSet) const;
 
     //! \brief Processes intersection points with a line.
     //! \param inLine : the line to process
     //! \param outIntersectionPnt1 The 1st intersection point - if exists -
     //! \param outIntersectionPnt2 The 2nd intersection point - if exists -
     //! \param outIntersectionParam1 The 1st intersection parameter - if exists -
     //! \param outIntersectionParam2 The 2nd intersection parameter - if exists -
     //! \param inTestComplanarity If DTK_TRUE the method will test if inPntA and inPntB are on the same plane than the Bounding Box.
     //! \return 0 If No intersection.
     //! \return 1 If 1 intersection.
     //! \return 2 If 2 intersections.
     //! \return 3 If an infinity of intersections.
     //! \return -1 if inPntA and inPntB are not on the same plane than the Bounding Box.
     //! \warning  For internal use only
     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;
 
    //! \brief Processes intersection points with a line giving two points on the line.
    //! \param inPntA The 1st point of the line
    //! \param inPntB The 2nd point of the line
    //! \param outIntersectionPnt1 The 1st intersection point - if exists -
    //! \param outIntersectionPnt2 The 2nd intersection point - if exists -
    //! \param inTestComplanarity If DTK_TRUE the method will test if inPntA and inPntB are on the same plane than the Bounding Box.
    //! \return 0 If No intersection.
    //! \return 1 If 1 intersection.
    //! \return 2 If 2 intersections.
    //! \return 3 If an infinity of intersections.
    //! \return -1 if inPntA and inPntB are not on the same plane than the Bounding Box.
    //! \warning  For internal use only
    Dtk_Int32 ProcessIntersectionWithLine(
        const Dtk_pnt& inPntA,
        const Dtk_pnt& inPntB,
        Dtk_pnt& outIntersectionPnt1,
        Dtk_pnt& outIntersectionPnt2,
        const Dtk_bool& inTestComplanarity = DTK_FALSE ) const;
 
    //! \brief Processes intersection points with a segment giving its ends.
    //! \param inPntA The 1st end of the segment.
    //! \param inPntB The 2nd end of the segment.
    //! \param outIntersectionPnt1 The 1st intersection point - if exists -
    //! \param outIntersectionPnt2 The 2nd intersection point - if exists -
    //! \param inTestComplanarity If DTK_TRUE the method will test if inPntA and inPntB are on the same plane than the Bounding Box.
    //! \return 0 If No intersection.
    //! \return 1 If 1 intersection.
    //! \return 2 If 2 intersections.
    //! \return 3 If an infinity of intersections.
    //! \return -1 if inPntA and inPntB are not on the same plane than the Bounding Box.
    //! \warning  For internal use only
    Dtk_Int32 ProcessIntersectionWithSegment(
        const Dtk_pnt& inPntA,
        const Dtk_pnt& inPntB,
        Dtk_pnt& outIntersectionPnt1,
        Dtk_pnt& outIntersectionPnt2,
        const Dtk_bool& inTestComplanarity = DTK_FALSE ) const;
 
     //! \brief Processes intersection points with a segment giving its ends.
     //! \param inPntA The 1st end of the segment.
     //! \param inPntB The 2nd end of the segment.
     //! \param outIntersectionPnts The list of intersection points
     //! \param inTestComplanarity If DTK_TRUE the method will test if inPntA and inPntB are on the same plane than the Bounding Box.
     //! \return 0 If No intersection.
     //! \return 1 If 1 intersection.
     //! \return 2 If 2 intersections.
     //! \return 3 If an infinity of intersections.
     //! \return -1 if inPntA and inPntB are not on the same plane than the Bounding Box.
     //! \warning  For internal use only
     Dtk_Int32 ProcessIntersectionWithSegment(
          const Dtk_pnt& inPntA,
          const Dtk_pnt& inPntB,
          Dtk_tab<Dtk_pnt>& outIntersectionPnts,
          const Dtk_bool& inTestComplanarity = DTK_FALSE) const;
 
    //! \brief Processes intersection points with a circle on the same plane as the boundingbox, giving its center and its radius.
    //! \param inCenter The center of the circle.
    //! \param inRadius The radius of the circle.
    //! \param outIntersectionPnts The tab of intersection points
    //! \return Number of intersections
    //! \warning  For internal use only
 
    Dtk_Int32 ProcessIntersectionWithCircle(
        const Dtk_pnt& inCenter,
        const Dtk_Double64& inRadius,
        Dtk_tab<Dtk_pnt>& outIntersectionPnts) const;
};
 
//! \ingroup draw
//! \class Dtk_Frame
//! \brief This is the frame class.\n
//! It's used to gather all frame information.
class Dtk_Frame
{
protected:
    Dtk_frame_type              _FrameType;
    Dtk_tab< Dtk_CurvePtr >     _RelatedGeomElements;
public:
 
    //! \brief Full featured constructor
    //! \param inFrameType Frame Type.
    //! \param inRelatedGeometricalElts Geometries representing the frame.
     Dtk_Frame( const Dtk_frame_type& inFrameType, Dtk_tab< Dtk_CurvePtr > inRelatedGeometricalElts )
          : _FrameType( inFrameType ), _RelatedGeomElements( std::move( inRelatedGeometricalElts ) ) { }
 
     //! \CopyConstructor{in}
     Dtk_Frame( const Dtk_Frame &in );
     //! \MoveConstructor{s}
     Dtk_Frame( Dtk_Frame &&in ) DTK_NOEXCEPT;
 
    //! \BaseConstructor
     inline Dtk_Frame() : _FrameType( DTK_FRAME_TYPE_NONE ) {}
 
    //! \BaseDestructor
     inline ~Dtk_Frame(){}
 
    //! \brief Clear elements
    inline void Clear()
    {
        _FrameType = DTK_FRAME_TYPE_NONE;
        _RelatedGeomElements.clear();
    }
 
 
    //! \brief Set Frame informations.
    //! \param inFrameType Frame Type.
    //! \param inRelatedGeometricalElts Geometries representing the frame.
    inline void SetFrameData(
        const Dtk_frame_type& inFrameType,
        Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements )
    {
        this->_FrameType = inFrameType;
        this->_RelatedGeomElements = std::move( inRelatedGeomElements );
    }
    //! \brief Retrieves the Frame Type - Read Only -
    //! \return The Frame Type
    inline const Dtk_frame_type& GetFrameType() const {return _FrameType;}
 
    //! \brief Process Related geometries.
    //! \return Always dtkNoError as success.
    Dtk_ErrorStatus CreateGeometries(Dtk_tab< Dtk_CurvePtr >& outGeoms) const;
 
    //! \brief Translates the frame giving a translation vector
    //! \param inTranslateDir the translation vector
    //! \return dtkNoError if OK
    Dtk_ErrorStatus Translate(const Dtk_dir &inTranslateDir);
 
    //! \brief Applies a transformation matrix to the frame
    //! \param inTransfo The transformation matrix
    //! \return dtkNoError if OK
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    //! \AssignmentOp{in}
    Dtk_Frame& operator=(const Dtk_Frame & in);
     //! \MoveOp{in}
    Dtk_Frame& operator=( Dtk_Frame && in ) DTK_NOEXCEPT;
};
class Dtk_CompositeText;
 
//! \ingroup draw
//! \class DTK_Text_subtype
//! \brief This is the DTK_Text_subtype class.\n
//! It's used to provide semantic data about Dtk_Text type.\n
//! See the \ref howtodtk_subtypes link to know how to handle it.
class DTK_Text_subtype
{
private:
     int p;
public:
     DTK_Text_subtype(int in=0);
     //! \brief Appends a new subtype
     void Append(int in);
    Dtk_bool IsNotDefined() const;
    //! \brief Tell if the associated Dtk_text is part of dual group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsDual() const;
    //! \brief Tell if the associated Dtk_text is part of left group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsLeftText() const;
    //! \brief Tell if the associated Dtk_text is part of right group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsRightText() const;
    //! \brief Tell if the associated Dtk_text is part of Up group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsUpText() const;
    //! \brief Tell if the associated Dtk_text is part of Down group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsDownText() const;
    //! \brief Tell if the associated Dtk_text is part of Prefix group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsPrefix() const;
    //! \brief Tell if the associated Dtk_text is part of Suffix group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsSuffix() const;
    //! \brief Tell if the associated Dtk_text is part of Chamfer Sign group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsChamfersign() const;
    //! \brief Tell if the associated Dtk_text is part of Chamfer Right group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsChamferright() const;
    //! \brief Tell if the associated Dtk_text is part of Main Value Part group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsMainvalpart() const;
    //! \brief Tell if the associated Dtk_text is part of Basis group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsBasisval() const;
    //! \brief Tell if the associated Dtk_text is part of Pow group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsPow() const;
    //! \brief Tell if the associated Dtk_text is part of Upper Fraction group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsUpperFrac() const;
    //! \brief Tell if the associated Dtk_text is part of Lower Fraction group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsLowerFrac() const;
    //! \brief Tell if the associated Dtk_text is part of Value Split Part 1 - for Degrees/Minutes/Seconds form - group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsValSplitPart1() const;
    //! \brief Tell if the associated Dtk_text is part of Value Split Part 2 - for Degrees/Minutes/Seconds form - group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsValSplitPart2() const;
    //! \brief Tell if the associated Dtk_text is part of Value Split Part 3 - for Degrees/Minutes/Seconds form - group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsValSplitPart3() const;
    //! \brief Tell if the associated Dtk_text is part of Tolerance Block group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsTolBloc() const;
    //! \brief Tell if the associated Dtk_text is part of Tolerance Value group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsTolValPart() const;
    //! \brief Tell if the associated Dtk_text is part of Tolerance Upper Value group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsTolUpperTol() const;
    //! \brief Tell if the associated Dtk_text is part of Tolerance Lower Value group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsTolLowerTol() const;
    //! \brief Tell if the associated Dtk_text is part of Tolerance Symetrical Value group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsTolSymetricalTol() const;
    //! \brief Tell if the associated Dtk_text is part of Tolerance Sign group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsTolSign() const;
    //! \brief Tell if the associated Dtk_text is part of Tolerance Prefix group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsTolPrefix() const;
    //! \brief Tell if the associated Dtk_text is part of Tolerance Left Parenthesis group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
     Dtk_bool IsTolLeftParenthesis() const;
    //! \brief Tell if the associated Dtk_text is part of Tolerance Right Parenthesis group - into \DtkLinkToPtr{Dtk_Dimension} -
    //! \return DTK_TRUE or DTK_FALSE
    Dtk_bool IsTolRightParenthesis() const;
     //! \brief Tell if the associated Dtk_text is an url group - into \DtkLinkToPtr{Dtk_Dimension} -
     //! \return DTK_TRUE or DTK_FALSE
     Dtk_bool IsUrl() const;
     //! \brief Tell if the associated Dtk_text is a fraction bar group - into \DtkLinkToPtr{Dtk_Dimension} -
     //! \return DTK_TRUE or DTK_FALSE
     Dtk_bool IsFractionBar() const;
     //! \brief Tell if the associated Dtk_text is a separator - into \DtkLinkToPtr{Dtk_Dimension} -
     //! \return DTK_TRUE or DTK_FALSE
     Dtk_bool IsSeparator() const;
     //! \brief Return all subtypes as a Dtk_string.
     //! \return The processes Dtk_string.
    Dtk_string Dump() const;
};
 
 
 
 
//! \ingroup draw
//! \class Dtk_Text
//! \brief This is the base text class. It's part of Dtk_CompositeText.\n
//! This class represents the texts and values used in the annotations entities (Dtk_Annotation and Dtk_Dimension). \n
//! You can learn how to browse their semantic data following this page : \ref howtodtk_subtypes \n
//! It also contains an inner Dtk_Oriented2dBBox and a outer Dtk_Oriented2dBBox that allows you to place the text in 2D space.\n
//! The Dtk_Text uses a lot of informations. The most important ones, coming from its Dtk_Oriented2dBBox, are shown in the picture below:\n
//! \image html Dtk_Text.png Dtk_Text Most Important Information : inner and outer Dtk_Oriented2dBBox
//! \n The Dtk_Text also uses an anchor point notion ( Dtk_anchor_type ). Here are the 9 anchor point types:\n\n
//! \image html AnchorTypes.png Anchor Type Samples
class Dtk_Text
{
public:
     enum MirroringTypeEnum {
          NoMirroring = 0,
          HorizontalMirroring,
          VerticalMirroring
     };
 
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
 
public:
     //! \BaseDestructor
     ~Dtk_Text();
     //! \BaseConstructor
     Dtk_Text();
     //! \CopyConstructor{s}
     Dtk_Text( const Dtk_Text & s );
     //! \MoveConstructor{s}
     Dtk_Text( Dtk_Text && s) DTK_NOEXCEPT;
     //! \AssignmentOp{in}
     Dtk_Text& operator=( const Dtk_Text& in );
     //! \MoveOp{in}
     Dtk_Text& operator=( Dtk_Text&& in ) DTK_NOEXCEPT;
     //! \brief Full featured constructor
     //! \param inTextString The text string
     //! \param inInnerBox The inner bounding box
     //! \param inOuterBox The outer bounding box
     //! \param inAnchorType The anchor type
     //! \param inTextType The text type
     //! \param inHorizontalVerticalType The horizontal/vertical text orientation
     //! \param inInfos The text infos
     //! \param inTextStyle The text style
     //! \param inSlant The text slant - PI / 2.0 for normal text -
     //! \param inFontIndex The font index
     //! \param inMirroringType The mirroring type
     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);
 
     //! \brief Constructor
     //! \param inTextString The text string
     //! \param inInnerBox The inner bounding box
     //! \param inOuterBox The outer bounding box
     //! \param inSlant The text slant - PI / 2.0 for normal text -
     //! \param inHorizontalVerticalType The horizontal/vertical text orientation
     //! \param inTextType The text type
     //! \param inInfos The text infos
     //! \param inTextStyle The text style
     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);
 
    //! \brief Tells if the Dtk_Text is empty or not - read only -
    //! \return DTK_TRUE if the Dtk_text is empty or DTK_FALSE else.
    //! \remark This method internally checks the string of the Dtk_text.
    //! If the string length is == 0 so the Dtk_text is empty.
    Dtk_bool IsEmpty() const;
 
    //! \brief Set the text frame information - get/set -
    //! \return The text frame type
    //! \sa FrameType() const
    void SetFrameType( const Dtk_frame_type& inFrameType, Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements);
 
    //! \brief Retrieves the Frame - read only -
    //! \param outFrame The frame
    //! \sa FrameType() const
    void GetFrame(Dtk_Frame& outFrame) const;
 
    //! \brief Retrieves the text frame type - read only -
     //! \return The text frame type
     //! \sa FrameType()
     Dtk_frame_type FrameType() const;
 
     //! \brief Retrieves the text type - get/set -
     //! \return The text type
     //! \sa TextType() const
     DTK_Text_type& TextType();
 
     //! \brief Retrieves the text type - read only -
     //! \return The text type
     //! \sa TextType()
     const DTK_Text_type& TextType() const;
 
     //! \brief Retrieves the text subtype - get/set -
     //! \return The text subtype
     //! \sa TextType() const
     DTK_Text_subtype& TextSubType();
 
     //! \brief Retrieves the text subtype - read only -
     //! \return The text subtype
     //! \sa TextType()
     const DTK_Text_subtype& TextSubType() const;
 
 
     //! \brief Retrieves the inner bounding box XAxis - read only -
     //! \return The inner bounding box XAxis
     //! \sa InnerXAxis()
     const Dtk_dir& InnerXAxis() const;
 
     //! \brief Retrieves the outer bounding box XAxis - read only -
     //! \return The outer bounding box XAxis
     //! \sa OuterXAxis()
     const Dtk_dir& OuterXAxis() const;
 
     //! \brief Retrieves the inner bounding box XAxis - get/set -
     //! \return The inner bounding box XAxis
     //! \sa InnerXAxis() const
     Dtk_dir& InnerXAxis();
 
     //! \brief Retrieves the outer bounding box XAxis - get/set -
     //! \return The outer bounding box XAxis
     //! \sa OuterXAxis() const
     Dtk_dir& OuterXAxis();
 
     //! \brief Retrieves the inner bounding box YAxis - read only -
     //! \return The inner bounding box YAxis
     //! \sa InnerYAxis()
     const Dtk_dir& InnerYAxis() const;
 
     //! \brief Retrieves the outer bounding box YAxis - read only -
     //! \return The outer bounding box YAxis
     //! \sa OuterYAxis()
     const Dtk_dir& OuterYAxis() const;
 
     //! \brief Retrieves the inner bounding box YAxis - get/set -
     //! \return The inner bounding box YAxis
     //! \sa InnerYAxis() const
     Dtk_dir& InnerYAxis();
 
     //! \brief Retrieves the outer bounding box YAxis - get/set -
     //! \return The outer bounding box YAxis
     //! \sa OuterYAxis() const
     Dtk_dir& OuterYAxis();
 
     //! \brief Retrieves the inner bounding box location - read only -
     //! \return The inner bounding box location
     //! \sa InnerLocation()
     const Dtk_pnt& InnerLocation() const;
 
     //! \brief Retrieves the outer bounding box location - read only -
     //! \return The outer bounding box location
     //! \sa OuterLocation()
     const Dtk_pnt& OuterLocation() const;
 
     //! \brief Retrieves the inner bounding box location - get/set -
     //! \return The inner bounding box location
     //! \sa InnerLocation() const
     Dtk_pnt& InnerLocation();
 
     //! \brief Retrieves the outer bounding box location - get/set -
     //! \return The outer bounding box location
     //! \sa OuterLocation() const
     Dtk_pnt& OuterLocation();
 
     //! \brief Retrieves the text string - get/set -
     //! \return The text string
     //! \sa Text() const
     Dtk_string& Text();
 
     //! \brief Retrieves the text string - read only -
     //! \return The text string
     //! \sa Text()
     const Dtk_string& Text() const;
 
     //! \brief Retrieves the text text style - get/set -
     //! \return The text text style
     //! \sa TextStyle() const
     Dtk_TextStyle& TextStyle();
 
     //! \brief Retrieves the text text style - read only -
     //! \return The text text style
     //! \sa TextStyle()
     const Dtk_TextStyle& TextStyle() const;
 
     //! \brief Retrieves the text vertically oriented Status - read only -
     //! \return The text vertically oriented status - DTK_TRUE for vertically oriented text -
     //! \sa VerticallyOrientedStatus()
     const Dtk_bool& VerticallyOrientedStatus() const;
 
     //! \brief Sets the text vertically oriented status
     //! \return The text vertically oriented status - DTK_TRUE for vertically oriented text -
     //! \sa VerticallyOrientedStatus() const
     Dtk_ErrorStatus SetVerticallyOrientedStatus(
          const Dtk_bool &inVerticallyOrientedStatus);
 
     //! \brief Retrieves the text anchor type - get/set -
     //! \return The text anchor type
     //! \sa AnchorType() const
     Dtk_anchor_type& AnchorType();
 
     //! \brief Retrieves the text anchor type - read only -
     //! \return The text anchor type
     //! \sa AnchorType()
     const Dtk_anchor_type& AnchorType() const;
 
     //! \brief Retrieves the text infos - read only -
     //! \return The text infos
     const Dtk_InfoPtr& GetInfo() const;
 
     //! \brief Retrieves the text infos
     //! \return The text infos
     Dtk_InfoPtr& GetInfo();
 
     //! \brief Sets the inner bounding box rotation angle giving a reference base
     //! \param inRotationAngle The rotation angle to be set
     //! \param inXAxis The reference X Axis - default value = (1,0,0)
     //! \param inYAxis The reference Y Axis - default value = (0,1,0)
     //! \return dtkNoError if OK
     //! \sa GetRotationAngle
     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));
 
     //! \brief Sets the outer bounding box rotation angle giving a reference base
     //! \param inRotationAngle The rotation angle to be set
     //! \param inXAxis The reference X Axis - default value = (1,0,0)
     //! \param inYAxis The reference Y Axis - default value = (0,1,0)
     //! \return dtkNoError if OK
     //! \sa GetRotationAngle
     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));
 
     //! \brief Gets the inner bounding box rotation angle giving a reference base
     //! \param inXAxis The reference X Axis - default value = (1,0,0)
     //! \param inYAxis The reference Y Axis - default value = (0,1,0)
     //! \return The rotation angle
     //! \sa SetRotationAngle
     Dtk_Double64 GetInnerRotationAngle(const Dtk_dir &inXAxis = Dtk_dir(1,0,0),
          const Dtk_dir &inYAxis = Dtk_dir(0,1,0));
 
     //! \brief Gets the outer bounding box rotation angle giving a reference base
     //! \param inXAxis The reference X Axis - default value = (1,0,0)
     //! \param inYAxis The reference Y Axis - default value = (0,1,0)
     //! \return The rotation angle
     //! \sa SetRotationAngle
     Dtk_Double64 GetOuterRotationAngle(const Dtk_dir &inXAxis = Dtk_dir(1,0,0),
          const Dtk_dir &inYAxis = Dtk_dir(0,1,0));
 
     //! \brief Translates the inner bounding box giving a translation vector
     //! \param inTranslateDir the translation vector
     //! \return dtkNoError if OK
     Dtk_ErrorStatus InnerTranslate(const Dtk_dir &inTranslateDir);
 
     //! \brief Translates the outer bounding box giving a translation vector
     //! \param inTranslateDir the translation vector
     //! \return dtkNoError if OK
     Dtk_ErrorStatus OuterTranslate(const Dtk_dir &inTranslateDir);
 
     //! \brief Translates the text giving a translation vector
     //! \param inTranslateDir the translation vector
     //! \return dtkNoError if OK
     Dtk_ErrorStatus Translate(const Dtk_dir &inTranslateDir);
 
     //! \brief Applies a transformation matrix to the text
     //! \param inTransfo The transformation matrix
     //! \return dtkNoError if OK
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     //! \brief Reverses the text
     //! The text anchor type is replaced by the opposed one
     //! and the text orientation is reversed.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus Reverse();
 
     //! \brief Sets the inner bounding box orientation
     //! \param inXAxis The new inner bounding box X Axis
     //! \param inYAxis The new inner bounding box Y Axis
     //! \sa GetInnerXYAxis
     void SetInnerXYAxis(const Dtk_dir &inXAxis, const Dtk_dir &inYAxis);
 
     //! \brief Sets the outer bounding box orientation
     //! \param inXAxis The new outer bounding box X Axis
     //! \param inYAxis The new outer bounding box Y Axis
     //! \sa GetOuterXYAxis
     void SetOuterXYAxis(const Dtk_dir &inXAxis, const Dtk_dir &inYAxis);
 
     //! \brief Gets the inner bounding box orientation
     //! \param outXAxis The inner bounding box X Axis
     //! \param outYAxis The inner bounding box Y Axis
     //! \sa SetInnerXYAxis
     void GetInnerXYAxis(Dtk_dir &outXAxis, Dtk_dir &outYAxis) const;
 
     //! \brief Gets the outer bounding box orientation
     //! \param outXAxis The outer bounding box X Axis
     //! \param outYAxis The outer bounding box Y Axis
     //! \sa SetOuterXYAxis
     void GetOuterXYAxis(Dtk_dir &outXAxis, Dtk_dir &outYAxis) const;
 
     //! \brief Sets the inner bounding box X length
     //! \param inXLength The new inner bounding box X length
     //! \sa GetInnerBoundingBox
     void SetInnerXLength(const Dtk_Double64 &inXLength);
 
     //! \brief Sets the inner bounding box Y length
     //! \param inXLength The new inner bounding box Y length
     //! \sa GetInnerBoundingBox
     void SetInnerYLength(const Dtk_Double64 &inYLength);
 
     //! \brief Sets the outer bounding box X length
     //! \param inXLength The new outer bounding box X length
     //! \sa GetOuterBoundingBox
     void SetOuterXLength(const Dtk_Double64 &inXLength);
 
     //! \brief Sets the outer bounding box Y length
     //! \param inXLength The new outer bounding box Y length
     //! \sa GetOuterBoundingBox
     void SetOuterYLength(const Dtk_Double64 &inYLength);
 
     //! \brief Processes the mirroring type giving the reference Z Axis.
     //! \param inZAxis the reference Z Axis
     //! \return The mirroring type
     MirroringTypeEnum ProcessMirroringType(
          const Dtk_dir &inZAxis = Dtk_dir(0,0,1)) const;
 
     //! \brief Processes the inner bounding box rotation angle giving the reference Z Axis.
     //! \param inZAxis the reference Z Axis
     //! \return The rotation angle
     Dtk_Double64 ProcessRotationAngle(
          const Dtk_dir &inZAxis = Dtk_dir(0,0,1)) const;
 
     //! \brief Processes the line feed number.
     //! \return The line feed number
     Dtk_Int32 ProcessTextNumLines() const;
 
     //! \brief Processes the bottom-left inner anchor point.
     //! \return The bottom-left inner anchor point
     Dtk_pnt ProcessBottomLeftAnchorPoint() const;
 
     //! \brief Processes the inner bounding box.
     //! \return The inner bounding box
    const Dtk_Oriented2dBBox& GetInnerBoundingBox() const;
    Dtk_Oriented2dBBox& GetInnerBoundingBox();
 
     //! \brief Processes the outer bounding box.
     //! \return The outer bounding box
    const Dtk_Oriented2dBBox& GetOuterBoundingBox() const;
    Dtk_Oriented2dBBox& GetOuterBoundingBox();
 
     //! \brief Sets the inner bounding box.
     Dtk_ErrorStatus SetInnerBoundingBox(const Dtk_Oriented2dBBox& innerBoundingBox);
 
     //! \brief Sets the outer bounding box.
      Dtk_ErrorStatus SetOuterBoundingBox(const Dtk_Oriented2dBBox& outerBoundingBox);
 
     //! \deprecated Use SetInnerBoundingBox() const function instead.
     //! \brief Set the text inner anchor point
     //! \param inNewOrigin the new location point
     //! \param inLocationAnchorType the new location anchor type
     //! \return dtkNoError if OK
     //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);
 
     //! \brief Set the text outer anchor point
     //! \param inNewOrigin the new location point
     //! \param inLocationAnchorType the new location anchor type
     //! \return dtkNoError if OK
     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);
 
     //! \brief Creates geometries corresponding to the text frame type
     //! \param outGeoms the resulting geometries
     //! \return dtkNoError if OK
     Dtk_ErrorStatus CreateFrameAsGeometry(
          Dtk_tab<Dtk_CurvePtr> &outGeoms) const;
 
     //! \brief Explodes the Dtk_Text to other Dtk_Text according the IGES font number
     //! \param outNumFontArray Font numbers array - size = outNumTexts -
     //! \param outNumTexts Number of resulting texts
     //! \return the Exploded resulting Dtk_Text array - size = outNumTexts -.
     Dtk_Text *ExplodeText(Dtk_Int32 **outNumFontArray,
          Dtk_Int32 &outNumTexts) const;
 
     friend Dtk_CompositeText operator+( Dtk_Text s1, Dtk_Text s2);
};
 
//! \ingroup draw
//! \class Dtk_CompositeText
//! \brief This is the composite text class.\n
//! It's basically a Dtk_Text Container.\n
//! This class represents a group of several base_texts.\n
//! It contains an inner Dtk_Oriented2dBBox and a outer Dtk_Oriented2dBBox.\n
//! The Dtk_CompositeText uses a lot of informations. The most important ones are shown in the picture below:\n
//! \image html Dtk_CompositeText.png Dtk_CompositeText Most Important Informations
class Dtk_CompositeText
{
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
 
public:
     //! \BaseDestructor
     ~Dtk_CompositeText();
 
     //! \BaseConstructor
     Dtk_CompositeText();
 
     //! \CopyConstructor{t}
     Dtk_CompositeText(const Dtk_CompositeText& t);
 
     //! \MoveConstructor{t}
     Dtk_CompositeText( Dtk_CompositeText&& t) DTK_NOEXCEPT;
 
     //! \brief Pre allocator constructor
     //! \param inNumTexts Number of text to be reserved 
     Dtk_CompositeText(const Dtk_Size_t& inNumTexts);
 
     //! \brief Constructor from one Dtk_Text
     //! \param inText Dtk_Text to be included into
     Dtk_CompositeText( Dtk_Text inText );
 
     //! \brief Constructor from several Dtk_Text
     //! \param inTexts Dtk_Text to be included into
     Dtk_CompositeText( Dtk_tab<Dtk_Text> inTexts);
 
     //! \AssignmentOp{in}
     Dtk_CompositeText& operator=(const Dtk_CompositeText& in);
     //! \MoveOp{in}
     Dtk_CompositeText& operator=( Dtk_CompositeText&& in ) DTK_NOEXCEPT;
 
    void Clear();
 
     //! \brief Access operator - get/set -
     //! \param inPos The position of the element to be retrieved
     //! \return the inPos'th Dtk_Text
     Dtk_Text& operator[](Dtk_Size_t inPos);
 
     //! \brief Access operator - read only -
     //! \param inPos The position of the element to be retrieved
     //! \return the inPos'th Dtk_Text
     const Dtk_Text& operator[](Dtk_Size_t inPos) const;
 
     //! \brief Retrieves the texts number
     //! \return the texts number
     Dtk_Size_t GetNumTexts() const;
 
     //! \brief Add all the Dtk_Text from the two Dtk_CompositeText
     //! \param s1 the first composite text
     //! \param s2 the second composite text
     //! \return the resulting Dtk_CompositeText
     friend Dtk_CompositeText operator+(
          Dtk_CompositeText s1, Dtk_CompositeText s2);
 
     //! \brief Merges the Dtk_CompositeText to another one
    //! \param s2 The first Dtk_CompositeText to merge to this
    Dtk_CompositeText& operator+=( Dtk_CompositeText s2);
 
     //! \deprecated Use GetOuterBoundingBox() const function instead.
     //! \brief Processes all the Dtk_CompositeText outer anchor points
     //! \param outTabPnts the resulting anchor point array
     //! \return dtkNoError if OK
     SetAsDeprecated("Undefined", "Use GetOuterBoundingBox")
     Dtk_ErrorStatus GetOuterAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     //! \brief Processes the inner bounding box.
     //! \return The inner bounding box
     const Dtk_Oriented2dBBox GetInnerBoundingBox() const;
 
     //! \brief Processes the outer bounding box.
     //! \param inIncludeInvisible : If DTK_TRUE - default value - invisible texts are processed    . Else They are not.
     //! \return The outer bounding box
     const Dtk_Oriented2dBBox GetOuterBoundingBox( Dtk_bool inIncludeInvisible = DTK_TRUE ) const;
 
     //! \brief Processes the inner bounding box.
     //! \param outError Return dtkNoError if OK
     //! \return The inner bounding box
     const Dtk_Oriented2dBBox GetInnerBoundingBox(Dtk_ErrorStatus &outError)
          const;
 
     //! \brief Processes the outer bounding box.
     //! \param outError Return dtkNoError if OK
     //! \param inIncludeInvisible : If DTK_TRUE - default value - invisible texts are processed    . Else They are not.
     //! \return The outer bounding box
     const Dtk_Oriented2dBBox GetOuterBoundingBox(Dtk_ErrorStatus &outError,
          Dtk_bool inIncludeInvisible = DTK_TRUE )
          const;
 
     //! \brief Retrieves the wrapping width
     //! \return The wrapping width
     const Dtk_Double64& GetWrappingWidth() const;
 
     //! \brief Sets the wrapping width
     //! \param inWrappingWidth The new wrapping width
     void SetWrappingWidth(const Dtk_Double64 &inWrappingWidth);
 
     //! \brief Set the Dtk_CompositeText inner anchor point
     //! \param inNewLocationPnt The new anchor point
     //! \param inNewAnchorType The new anchor type
     //! \param inStartingGetText The starting text - -1 to process from the 1st text - for the old anchor points process
     //! \param inNumGetTexts The number of processed texts - -1 to process all texts from starting text - for the old anchor points process
     //! \param inStartingSetText The starting text - -1 to process from the 1st text -  for the new anchor points process
     //! \param inNumSetTexts The number of processed texts - -1 to process all texts from starting text - for the new anchor points process
     //! \return dtkNoError if OK
     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);
 
     //! \brief Set the Dtk_CompositeText outer anchor point
     //! \param inNewLocationPnt The new anchor point
     //! \param inNewAnchorType The new anchor type
     //! \param inStartingGetText The starting text - -1 to process from the 1st text - for the old anchor points process
     //! \param inNumGetTexts The number of processed texts - -1 to process all texts from starting text - for the old anchor points process
     //! \param inStartingSetText The starting text - -1 to process from the 1st text -  for the new anchor points process
     //! \param inNumSetTexts The number of processed texts - -1 to process all texts from starting text - for the new anchor points process
     //! \param inOffSet For internal use only
     //! \param inBoundingType The bounding type
     //! \return dtkNoError if OK
     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;
 
     //! \brief Sets the inner bounding box X Axis for the Dtk_CompositeText and included Dtk_Texts
     //! \param inXAxis The new inner bounding box X Axis
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetInnerXAxis(const Dtk_dir &inXAxis);
 
     //! \brief Sets the outer bounding box X Axis for the Dtk_CompositeText and included Dtk_Texts
     //! \param inXAxis The new outer bounding box X Axis
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetOuterXAxis(const Dtk_dir &inXAxis);
 
     //! \brief Sets the inner bounding box Y Axis for the Dtk_CompositeText and included Dtk_Texts
     //! \param inYAxis The new inner bounding box Y Axis
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetInnerYAxis(const Dtk_dir &axis_dir);
 
     //! \brief Sets the outer bounding box Y Axis for the Dtk_CompositeText and included Dtk_Texts
     //! \param inYAxis The new outer bounding box Y Axis
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetOuterYAxis(const Dtk_dir &axis_dir);
 
     //! \brief Sets the inner bounding box X and Y axes for the Dtk_CompositeText and included Dtk_Texts
     //! \param inXAxis The new inner bounding box X Axis
     //! \param inYAxis The new inner bounding box Y Axis
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetInnerXYAxis(const Dtk_dir &inXaxis,
          const Dtk_dir &inYaxis);
 
     //! \brief Sets the outer bounding box X and Y axes for the Dtk_CompositeText and included Dtk_Texts
     //! \param inXAxis The new outer bounding box X Axis
     //! \param inYAxis The new outer bounding box Y Axis
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetOuterXYAxis(const Dtk_dir &inXaxis,
          const Dtk_dir &inYaxis);
 
     //! \brief Retrieves the infos
     //! \return The infos
     const Dtk_InfoPtr& GetInfo() const;
 
     //! \brief Retrieves the infos
     //! \return The infos
     Dtk_InfoPtr& GetInfo();
 
     //! \brief Reverses the Dtk_CompositeText and included Dtk_Texts
     //! \sa Dtk_Text::Reverse
     //! \return dtkNoError if OK
     Dtk_ErrorStatus Reverse();
 
     //! \brief Adds a Dtk_Text to the Dtk_CompositeText
     //! \param inText The Dtk_Text to be added
     void AddText( Dtk_Text inText);
 
     //! \brief Replaces all the included Dtk_Texts by the given ones
     //! \param inTexts The Dtk_Texts to add
     void ReplaceTexts(const Dtk_tab<Dtk_Text> &inTexts);
 
     //! \brief Merges the Dtk_CompositeText to Dtk_string
     //! \return The merged Dtk_string
     Dtk_string ConvertToDtk_string() const;
 
     //! \brief Applies a transformation matrix to the Dtk_CompositeText and included Dtk_Texts
     //! \param inTransfo The transformation matrix to apply
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     //! \brief Translates the Dtk_CompositeText giving a translation vector
     //! \param inTranslateDir the translation vector
     //! \return dtkNoError if OK
     Dtk_ErrorStatus Translate(const Dtk_dir &inTranslateDir);
};
 
//! \ingroup draw
//! \class Dtk_2dEntity
//! \brief This is the abstract Dtk_2dEntity class.\n
//! Gathers Dtk_Annotation and Dtk_Dimension.
//! \SmartPtr{Dtk_2dEntityPtr}
class Dtk_2dEntity : public Dtk_Entity
{
protected:
    struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_2D_ENTITY
     };
     //! \BaseDestructor
     virtual ~Dtk_2dEntity();
 
     //! \BaseConstructor
     Dtk_2dEntity();
 
     Dtk_2dEntity(const Dtk_2dEntity&);
     Dtk_2dEntity( Dtk_2dEntity&& ) DTK_NOEXCEPT;
    virtual Dtk_Object* Clone() = 0;
 
protected:
     friend class Dtk_SmartPtr<Dtk_2dEntity>;
public:
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_2dEntity* DtkDynamicCast(Dtk_Object *s);
 
     virtual type_detk get_type_detk() const = 0;
 
    //! \AssignmentOp{in}
    Dtk_2dEntity& operator=(const Dtk_2dEntity & in);
     //! \MoveOp{in}
     Dtk_2dEntity& operator=( Dtk_2dEntity && in) DTK_NOEXCEPT;
 
     //! \Transform{inTransfo}
     virtual Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo)=0;
 
    //! \brief Adds an additionnal geometry to the Dtk_2dEntity
    //! \param inAdditionnalGeometry The geometry to be added
    void AddAdditionnalGeometry( const Dtk_EntityPtr& inAdditionnalGeometry);
 
    //! \brief Adds some additionnal geometries to the Dtk_2dEntity
    //! \param inAdditionnalGeometries The geometries to be added
    void AddAdditionnalGeometries(const Dtk_tab<Dtk_EntityPtr>& inAdditionnalGeometries);
 
    //! \brief Adds some additionnal texts to the Dtk_2dEntity
    //! \param inAddtionnalTexts The texts to be added
    void AddAdditionnalTexts( Dtk_CompositeText inAddtionnalTexts);
 
    //! \brief Retrieves the additionnal geometries of the Dtk_2dEntity
    //! \return The additionnal geometries array - read only -.
    const Dtk_tab< Dtk_EntityPtr >& GetAdditionnalGeometries() const;
 
    //! \brief Retrieves the additionnal texts of the Dtk_2dEntity
    //! \return The additionnal texts - read only -.
    const Dtk_CompositeText& GetAdditionnalTexts() const;
};
 
//! \ingroup draw
//! \class Dtk_Leader
//! \brief This class graphically represents leader of annotations.\n It is part of Dtk_Annotation and Dtk_Dimension.
//! \details Its main curve (also called LeaderCurve), is represented using a Dtk_Polyline. The following schema indicated the points order to expect.
//! \image html PolylineLeader.png
//! The first point of the Dtk_Polyline indicates the location of the ArrowHead / leader terminator. See the following schema for a simple representation of an ArrowHead, with a head of type Dtk_Leader::TerminatorTypeOpenArrow.
//! \image html LeaderTeminator.png width=800cm
//! In Datakit representation, a leader can also have an extension line, that usually points from the annotation to the model geometry.
//! \image html Dtk_LeaderExtensionLine.png
//! Dtk_Dimension is the most common annotation having leaders with an extension line, but it is also possible for a Dtk_Roughness or any other kind of Dtk_Annotation.
//! \warning To represent a stand-alone extension line, it is possible to encounter a leader with an extension line, and no main curve.
//! \SmartPtr{Dtk_LeaderPtr}
class Dtk_Leader:public Dtk_Object
{
public:
 
    //! \class ApplicationZone
    //! \brief This is the application zone class.\n
    //! It is used to gather all application zone information.
    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;
    public:
 
        //! \brief Full featured constructor
        //! \param inApplicationZoneType ApplicationZone Type.
        //! \param inRelatedGeometricalElts Geometries representing the frame.
        ApplicationZone(const ApplicationZoneEnum& inApplicationZoneType,
            const Dtk_tab< Dtk_CurvePtr >& inRelatedGeometricalElts);
 
        //! \BaseConstructor
          inline ApplicationZone() : _ApplicationZoneType( Default ) {}
          ApplicationZone( const ApplicationZone& in ) : _ApplicationZoneType( in._ApplicationZoneType )
          {
               _RelatedGeomElements.reserve( in._RelatedGeomElements.size() );
               for( Dtk_Size_t i = 0; i < in._RelatedGeomElements.size(); i++ )
               {
                    Dtk_CurvePtr tmp;
                    in._RelatedGeomElements[ i ].Clone( tmp );
                    _RelatedGeomElements.push_back( tmp );
               }
          };
          ApplicationZone( ApplicationZone && in ) DTK_NOEXCEPT = default;
 
        //! \BaseDestructor
          inline ~ApplicationZone(){}
 
        //! \brief Clear elements
        inline void Clear()
        {
            _ApplicationZoneType = Default;
            _RelatedGeomElements.clear();
        }
 
        //! \brief Set ApplicationZone informations.
        //! \param inApplicationZoneType The ApplicationZone Type.
        //! \param inRelatedGeometricalElts Geometries representing the Application Zone Symbol.
        inline void SetApplicationData(
            const ApplicationZoneEnum& inApplicationZoneType,
            Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements )
        {
            this->_ApplicationZoneType = inApplicationZoneType;
            this->_RelatedGeomElements = std::move( inRelatedGeomElements );
        }
        //! \brief Retrieves the ApplicationZone Type - Read Only -
        //! \return The ApplicationZone Type.
        inline ApplicationZoneEnum GetApplicationZoneType() const {return _ApplicationZoneType;}
 
        //! \brief Process Related geometries.
        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]);
        }
 
        //! \brief Translates the ApplicationZone giving a translation vector
        //! \param inTranslateDir the translation vector
        //! \return dtkNoError if OK
        inline Dtk_ErrorStatus Translate(const Dtk_dir &inTranslateDir)
        {
            Dtk_transfo TmpMatrix;
            TmpMatrix.addTranslate( inTranslateDir );
            return Transform( TmpMatrix );
        }
        //! \brief Applies a transformation matrix to the ApplicationZone
        //! \param inTransfo The transformation matrix
        //! \return dtkNoError if OK
        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;
        }
 //! \AssignmentOp{in}
        inline ApplicationZone& operator=(const ApplicationZone & in)
        {
            if (&in == this)
            {
                return *this;
            }
               _ApplicationZoneType = in._ApplicationZoneType;
               _RelatedGeomElements.reserve( in._RelatedGeomElements.size() );
               for (Dtk_Size_t i = 0; i < in._RelatedGeomElements.size(); i++)
               {
                    Dtk_CurvePtr tmp;
                    in._RelatedGeomElements[i].Clone(tmp);
                    _RelatedGeomElements.push_back(tmp);
               }
               return *this;
          }
          //! \MoveOp{in}
          inline ApplicationZone& operator=( ApplicationZone&& in ) DTK_NOEXCEPT = default;
    };
 
     //! \brief Internal leader terminator type
     enum LeaderTerminatorTypeEnum {
          //! \image html TerminatorTypeNone.png
          TerminatorTypeNone = 0,
          //! \image html TerminatorTypeOpenArrow.png
          TerminatorTypeOpenArrow,
          //! \image html TerminatorTypeClosedArrow.png
          TerminatorTypeClosedArrow,
          //! \image html TerminatorTypeFillArrow.png
          TerminatorTypeFillArrow,
          //! \image html TerminatorTypeCrossArrow.png
          TerminatorTypeCrossArrow,
          //! \image html TerminatorTypeCircle.png
          TerminatorTypeCircle,
          //! \image html TerminatorTypeFilledCircle.png
          TerminatorTypeFilledCircle,
          //! \image html TerminatorTypeSquare.png
          TerminatorTypeSquare,
          //! \image html TerminatorTypeFilledSquare.png
          TerminatorTypeFilledSquare,
          //! \image html TerminatorTypeSlash.png
          TerminatorTypeSlash,
          //! \image html TerminatorTypeCrossedCircle.png
          TerminatorTypeCrossedCircle,
          //! \image html TerminatorTypeXCircle.png
          TerminatorTypeXCircle,
          //! \image html TerminatorTypeTriangle.png
          TerminatorTypeTriangle,
          //! \image html TerminatorTypeFilledTriangle.png
          TerminatorTypeFilledTriangle,
          //! \image html TerminatorTypePlus.png
          TerminatorTypePlus,
          //! \image html TerminatorTypeXCross.png
          TerminatorTypeXCross,
          //! \image html TerminatorTypeIntegral.png
          TerminatorTypeIntegral,
          //! \image html TerminatorTypeCircleCenter.png
          TerminatorTypeCircleCenter,
          //! \image html TerminatorTypeDoubleOpenArrow.png
          TerminatorTypeDoubleOpenArrow,
          //! \image html TerminatorTypeDoubleCloseArrow.png
          TerminatorTypeDoubleCloseArrow,
          //! \image html TerminatorTypeDoubleFillArrow.png
          TerminatorTypeDoubleFillArrow,
          //! \image html TerminatorTypeDoubleTriangle.png
          TerminatorTypeDoubleTriangle,
          //! \image html TerminatorTypeTopOpenArrow.png
          TerminatorTypeTopOpenArrow,
          //! \image html TerminatorTypeBottomOpenArrow.png
          TerminatorTypeBottomOpenArrow,
          //! \image html TerminatorTypeTopFillArrow.png
          TerminatorTypeTopFillArrow,
          //! \image html TerminatorTypeBottomFillArrow.png
          TerminatorTypeBottomFillArrow,
          //! \image html TerminatorTypeDoubleCrossArrow.png
          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,
     };
     
     //! \brief This class graphically represents a leader head.
     class ArrowHead
     {
     protected:
          Dtk_InfoPtr                        m_Infos;
          LeaderTerminatorTypeEnum m_HeadType;
          Dtk_pnt                            m_ArrowLocation;
          Dtk_dir                            m_RefDir;
          Dtk_dir                            m_AxisDir;
     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 );
          }
          //! \BaseConstructor
          inline ArrowHead()
               : m_Infos( Dtk_Info::Create() )
               , m_HeadType( TerminatorTypeOpenArrow )
          {}
          //! \BaseDestructor
          inline ~ArrowHead() {}
          
          ArrowHead( const ArrowHead& in )
               : m_HeadType( in.m_HeadType )
               , m_ArrowLocation( in.m_ArrowLocation )
               , m_RefDir( in.m_RefDir )
               , m_AxisDir( in.m_AxisDir )
          {
               in.m_Infos.Clone( m_Infos );
          }
          ArrowHead( ArrowHead&& in ) DTK_NOEXCEPT : m_HeadType( in.m_HeadType ), m_ArrowLocation( std::move(in.m_ArrowLocation) ), m_RefDir( std::move(in.m_RefDir) ), m_AxisDir( std::move(in.m_AxisDir) ), m_Infos( std::move(in.m_Infos) ) {}
          ArrowHead& operator=( ArrowHead&& in ) DTK_NOEXCEPT
          {
               if( &in == this )
               {
                    return *this;
               }
               m_HeadType = in.m_HeadType;
               m_ArrowLocation = std::move( in.m_ArrowLocation );
               m_RefDir = std::move( in.m_RefDir );
               m_AxisDir = std::move( in.m_AxisDir );
               m_Infos = std::move( in.m_Infos );
          };
          //! \AssignmentOp{in}
          ArrowHead& operator=( const ArrowHead& in )
          {
               if( &in == this )
               {
                    return *this;
               }
               in.m_Infos.Clone( m_Infos );
               m_HeadType = in.m_HeadType;
               m_ArrowLocation = in.m_ArrowLocation;
               m_RefDir = in.m_RefDir;
               m_AxisDir = in.m_AxisDir;
               return *this;
          }
          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 , Dtk_Int32 inByPolygon=DTK_FALSE ) const;
          //! \brief Translates the ApplicationZone giving a translation vector
          //! \param inTranslateDir the translation vector 
          //! \return dtkNoError if OK
          inline Dtk_ErrorStatus Translate( const Dtk_dir &inTranslateDir )
          {
               Dtk_transfo TmpMatrix;
               TmpMatrix.addTranslate( inTranslateDir );
               return Transform( TmpMatrix );
          }
          //! \brief Applies a transformation matrix to the ApplicationZone
          //! \param inTransfo The transformation matrix 
          //! \return dtkNoError if OK
          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;
          }
     };
public:
     //! \brief Internal leader type - linear or angular -
     enum LeaderTypeEnum
     {
          TypeUnknown = 0,
          TypeLinear,
          TypeAngular
     };
 
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_LEADER
     };
 
     //! \sa Create()
     Dtk_Leader();
     //! \sa Create(const 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 );
    //! \sa Create(const Dtk_Double64 &,const Dtk_Double64 &, const Dtk_pnt &, const Dtk_Double64 &, const LeaderTerminatorTypeEnum &, const Dtk_pnt &, const Dtk_pnt &, const Dtk_bool &)
    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);
     //! \sa Create(const Dtk_Double64 &, const Dtk_Double64 &, const Dtk_pnt &, const LeaderTerminatorTypeEnum &, const Dtk_tab<Dtk_pnt> &)
     Dtk_Leader(
          const Dtk_Double64 &inWidth,
          const Dtk_Double64 &inHeight,
          const Dtk_pnt &inArrowLocation,
          const LeaderTerminatorTypeEnum &inTerminatorType,
          const Dtk_tab<Dtk_pnt> &inPntsArray );
 
     //! \BaseDestructor
     virtual ~Dtk_Leader();
     inline virtual Dtk_Object* Clone() { return new Dtk_Leader( *this ); }
private:
 
     friend class Dtk_SmartPtr<Dtk_Leader>;
public:
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_Leader* DtkDynamicCast(Dtk_Object *s);
 
     //! \CreateBase
     static Dtk_LeaderPtr Create();
 
     //! \CreateCopy{in}
     static Dtk_LeaderPtr Create(const Dtk_Leader &in);
 
    //! \brief Angular leader constructor.
    //! \param inWidth Arrow width
    //! \param inHeight Arrow height
    //! \param inArrowLocation Arrow location point
    //! \param inRadius Leader radius
    //! \param inTerminatorType Terminator type
    //! \param inEndingPnt Leader ending point
    //! \param inCenterPnt Center point
    //! \param IsCounterClockwise DTK_TRUE if the leader angle is counter-clockwise
    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);
 
    //! \brief Linear leader constructor.
    //! \param inWidth Arrow width
    //! \param inHeight Arrow height
    //! \param inArrowLocation Arrow location point
    //! \param inTerminatorType Terminator type
    //! \param inPntsArray Points array representing the leader body - in polyline form -
    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);
 
 
     //! \brief Retrieves the leader terminator informations.
     //! \param outWidth Arrow width
     //! \param outHeight Arrow height
     //! \param outArrowLocation Arrow location point
     //! \param outTerminatorType Terminator type
     //! \return dtkNoError if OK
     Dtk_ErrorStatus RetrieveLeader_terminator_infos(Dtk_Double64 &outWidth,
          Dtk_Double64 &outHeight, Dtk_pnt &outArrowLocation,
          LeaderTerminatorTypeEnum &outTerminatorType) const;
 
 
     //! \brief Returns the leader curve
     //! \return Dtk_CurvePtr or NULL.
     Dtk_CurvePtr GetLeaderCurve() const;
 
     //! \brief Set the leader curve Color.
     //! \param inColor The curve Color.
     void SetLeaderCurveColor( const Dtk_RGB& inColor );
 
     //! \brief Set the leader curve Thickness in Millimeters.
     //! \param inCurveThicknessinMM The curve Thickness in Millimeters.
     void SetLeaderCurveThicknessInMM( const Dtk_Double64 inCurveThicknessinMM );
 
     //! \brief Set the leader curve FontLineType .
     //! \param inCurveLineType The curve FontLineType .
     void SetLeaderCurveLineType(const Dtk_FontLineType inCurveLineType);
 
     //! \brief Gets the leader type - read only -
     //! \return The leader type
     LeaderTypeEnum GetLeaderType() const;
 
    //! \brief Get the leader Extension Line.
     //! \return The Dtk_PolylinePtr defining the Extension Line.
     Dtk_PolylinePtr GetExtensionLine() const;
 
    //! \brief Set the leader Extendion Line.
    //! \param inExtLine The Dtk_PolylinePtr defining the Extension Line.
     void SetExtensionLine( const Dtk_PolylinePtr& inExtLine );
 
    //! \brief Set the Leader Terminator Type
    //! \param inTerminatorType The Leader Terminator Type
    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();
 
     //! \brief Converts the Dtk_Leader to geometrical elements
     //! \param outGeomsArray Geometrical elements array
     void ConvertToGeom(Dtk_tab<Dtk_CurvePtr> &outGeomsArray, const IncludeOptions inConvertToGeomFilter = IncludeAll, Dtk_Int32 inByPolygon=DTK_FALSE) const;
 
     //! \brief Retrieves the info
     //! \return The info
     Dtk_InfoPtr& GetInfo();  
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    //! \brief Set the text frame information - get/set -
    //! \return The text frame type
    //! \sa FrameType() const
    void SetApplicationZoneType( const Dtk_Leader::ApplicationZone::ApplicationZoneEnum& inApplicationZoneType, const Dtk_tab< Dtk_CurvePtr >& inRelatedGeomElements);
 
    //! \brief Retrieves the Frame - read only -
    //! \param outFrame The frame
    //! \sa FrameType() const
    void GetApplicationZone(Dtk_Leader::ApplicationZone& outApplicationZone) const;
 
    //! \brief Retrieves the Frame - read only -
    //! \param outFrame The frame
    //! \sa FrameType() const
    Dtk_Leader::ApplicationZone::ApplicationZoneEnum GetApplicationZoneType() const;
 
 
    //! \brief OBSOLETE Retrieves the status of the all around property for the current drawing leader
     //! \return DTK_TRUE or DTK_FALSE
    //! \deprecated Use GetApplicationZoneType() const or GetApplicationZone()::GetApplicationZoneType() methods instead.
     Dtk_bool GetAllAroundSet() const;
 
    //! \brief Retrieves The ArrowHead Location point - Get Only -.
    //! \return The ArrowHead Location point.
    const Dtk_pnt& GetArrowLocation() const;
 
    //! \brief Set the status of the all around property for the current drawing leader
     //! \param inAllAroundSetValue as boolean value
     void SetAllAroundSet(const Dtk_bool & inAllAroundSetValue);
 
     //! \brief Retrieves the value of the leader stub.
     //! \return double.
    //! \remark If the Stub Delta is positive, the last leader segment represents the stub.
     double GetStubDelta() const;
 
     //! \brief Set the value of the leader stub.
     //! \param inStubDelta as double value.
    //! \remark If the Stub Delta is positive, the last leader segment represents the stub.
     void SetStubDelta(const double & inStubDelta);
 
};
 
//! \ingroup draw
//! \class Dtk_Annotation
//! \brief This is abstract Dtk_Annotation class.
//! \SmartPtr{Dtk_AnnotationPtr}
class Dtk_Annotation : public Dtk_2dEntity
{
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_ANNOTATION
     };
     virtual ~Dtk_Annotation();
     Dtk_Annotation();
     Dtk_Annotation(const Dtk_Annotation &);
     Dtk_Annotation( Dtk_Annotation&& ) DTK_NOEXCEPT;
 
     //! \brief Full featured constructor
     //! \param inLocationPnt Location of the Dtk_Annotation
     //! \param inInfos Infos
     //! \param inLeadersArray Addittional leaders array
     //! \param inAngle Angle
     //! \param inOffSet Offset
     //! \param inAnchorType Annotation anchor type
     //! \param inJustificationType Annotation justification type
     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:
     friend class Dtk_SmartPtr<Dtk_Annotation>;
public:
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_Annotation *DtkDynamicCast(Dtk_Object *s);
 
     //! \brief Retrieves the number of leaders
     //! \return The number of leaders
     Dtk_Size_t GetNumLeaders() const;
 
     //! \brief Gets the i'th leader
     //! \param inPos The leader position - 0 indexed -
     //! \return The inPos'th leader
     Dtk_LeaderPtr GetLeader(const Dtk_Size_t &inPos) const;
 
     //! \brief Adds a leader to the Dtk_Annotation
     //! \param leader The leader to be added
     //! \return dtkNoError is OK
     //! \remarks If Added leader is NULL, so no leader is added.
     Dtk_ErrorStatus AddLeader(const Dtk_LeaderPtr &leader);
 
     //! \brief Get the justification type - read only -
     //! \return The justification type
     //! \deprecated use the Dtk_TextStyle::Justification() instead
     SetAsDeprecated("Undefined", "Use Dtk_TextStyle::Justification()")
     Dtk_justication_type GetJustification() const;
 
     //! \brief Gets the text rotation angle giving a reference base.
     //! \param inXAxis The reference X Axis - default value = (1,0,0) -
     //! \param inYAxis The reference Y Axis - default value = (0,1,0) -
     //! \return The rotation angle.
     Dtk_Double64 GetRotationAngle(
          const Dtk_dir &inXAxis = Dtk_dir(1,0,0),
          const Dtk_dir& inYAxis = Dtk_dir(0,1,0)) const;
 
     //! \brief Gets the annotation offset - read only -
     //! \return The annotation offset.
     //! \warning  For internal use only
     Dtk_Double64 GetOffset() const;
 
     //! \brief Get the X Axis - read only -
     //! \return The X Axis.
     Dtk_dir GetXAxis() const;
 
     //! \brief Get the Y Axis - read only -
     //! \return The Y Axis.
     Dtk_dir GetYAxis() const;
 
     //! \brief Gets the location anchor type - read only -
     //! \return The location anchor type.
     const Dtk_anchor_type& GetLocationAnchorType() const;
 
     //! \brief Get the annoation location point
     //! \return The location point
     virtual Dtk_pnt GetLocation() const;
 
     //! \brief Reverses the Dtk_Annotation.
     virtual Dtk_ErrorStatus Reverse();
 
     // The interface functions
     virtual type_detk get_type_detk() const = 0;
 
     //! \brief Processes all the Dtk_Annotation anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     virtual Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const = 0;
 
     //! \brief Sets the Dtk_Annotation anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \return dtkNoError if OK
     virtual Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType) = 0;
 
     //! \brief Sets the location point of the Dtk_Annotation
     //! \brief The location point is related to the anchor type
     //! \param inLocation the location point
     //! \return dtkNoError if OK
     virtual Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation) = 0;
 
     //! \brief Sets the location point of the Dtk_Annotation
     //! \brief The location point is related to the anchor type
     //! \param location the location point
    //! \param inAnchorType The anchor type related to the new location.
     //! \return dtkNoError if OK
    Dtk_ErrorStatus SetLocation(const Dtk_pnt& location, const Dtk_anchor_type& inAnchorType);
 
     //! \brief Sets the offset of the Dtk_Annotation
     //! \brief The Offset is used to process bounding frames.
     //! \param inOffset The offset
     //! \return dtkNoError if OK
     //! \warning  For internal use only
     virtual Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset) = 0;
 
     //! \brief Sets the annotation angle using the annotation base.
     //! \param inRotationAngle  The rotation angle to be set
     //! \return dtkNoError if OK
     virtual Dtk_ErrorStatus SetRotationAngle(
          const Dtk_Double64 &inRotationAngle);
 
     //! \Transform{inTransfo}
     virtual Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo) = 0;
};
 
//! \ingroup draw
//! \class Dtk_Roughness
//! \brief This is the Roughness class
//! \SmartPtr{Dtk_RoughnessPtr}
//! \image html RoughNessDescription.png
class Dtk_Roughness : public Dtk_Annotation
{
public :
     enum ObtentionTypeEnum{
          //! \image html ObtentionTypeNotDefined.png
          ObtentionTypeNotDefined = 0,
          //! \image html ObtentionTypeMachiningMandatory.png
          ObtentionTypeMachiningMandatory,
          //! \image html ObtentionTypeMachiningForbidden.png
          ObtentionTypeMachiningForbidden
     };
 
     enum ApplyToEnum{
          //! \image html ApplyToSpecifiedSurface.png
          ApplyToSpecifiedSurface = 0,
          //! \image html ApplyToSurroundingSurfaces.png
          ApplyToSurroundingSurfaces,
          //! \image html ApplyToBasicSurface.png
          ApplyToBasicSurface,
          //! \image html ApplyToAllSurfaces.png
          ApplyToAllSurfaces
     };
 
     enum RoughModeEnum{
          ModeNone = 0,
          //! \image html ModeMultiDirectional.png
          ModeMultiDirectional,
          //! \image html ModeCircular.png
          ModeCircular,
          //! \image html ModeRadial.png
          ModeRadial,
          //! \image html ModeParticular.png
          ModeParticular,
          //! \image html ModeWithAngles.png
          ModeWithAngles,
          //! \image html ModeParallel.png
          ModeParallel,
          //! \image html ModePerpendicular.png
          ModePerpendicular
     };
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum
     {
          _typeID = DTK_TYPE_ROUGHNESS
     };
 
     //! \sa Create()
     Dtk_Roughness();
 
    //! \sa Create(const Dtk_pnt &, const Dtk_Text &, const Dtk_Text &, const Dtk_Text &, const Dtk_Text &, const Dtk_Text &, const Dtk_Text &, const ObtentionTypeEnum &, const ApplyToEnum &, const Dtk_InfoPtr &, const Dtk_tab<Dtk_LeaderPtr> &, const Dtk_Double64 &, const Dtk_Double64 &,const Dtk_anchor_type &,const Dtk_justication_type &)
    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);
 
     //! \sa Create(const Dtk_pnt &,const Dtk_InfoPtr &,const Dtk_tab<Dtk_LeaderPtr> &, const Dtk_Double64 &,const Dtk_Double64 &,const Dtk_anchor_type &,const Dtk_justication_type &)
     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);
 
     //! \sa Create(const Dtk_Roughness &)
     Dtk_Roughness(const Dtk_Roughness &s);
     Dtk_Roughness( Dtk_Roughness&& in ) DTK_NOEXCEPT;
     ~Dtk_Roughness();
 
     Dtk_Double64 _ProcessSideLength();
     Dtk_pnt _GetStartPoint() const;
 
    inline virtual Dtk_Object* Clone() { return new Dtk_Roughness(*this); }
 
private:
     friend class Dtk_SmartPtr<Dtk_Roughness>;
     friend class Dtk_Symbol;
public:
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_Roughness * DtkDynamicCast(Dtk_Object *s);
 
     //! \CreateBase
     static Dtk_RoughnessPtr Create();
 
     //! \brief Full featured constructor
     //! \param inLocationPnt Location point
     //! \param inTopLeftText Top left text
     //! \param inMiddleLeftText Middle left text
     //! \param inBottomLeftText Bottom left text
     //! \param inTopRightText Top right text
     //! \param inMiddleRightText Middle right text
     //! \param inBottomRightText Bottom right text
     //! \param inObtentionType Obtention type
     //! \param inApplyToType ApplyTo type
     //! \param inInfos Roughness infos
     //! \param inLeadersArray Leaders array
     //! \param inAngle Angle
     //! \param inOffSet Offset
     //! \param inAnchorType Roughness anchor type
     //! \param inJustificationType Justification type
     //! \return The created Dtk_RoughnessPtr
     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);
 
     //! \brief Full featured constructor
     //! \param inLocationPnt Location point
     //! \param inInfos Roughness infos
     //! \param inLeadersArray Leaders array
     //! \param inAngle Angle
     //! \param inOffSet Offset
     //! \param inAnchorType Roughness anchor type
     //! \param inJustificationType Justification type
     //! \return The created Dtk_RoughnessPtr
     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);
 
     //! \CreateCopy{in}
     static Dtk_RoughnessPtr Create(const Dtk_Roughness &in);
 
     //! \brief Converts the rough mode into a Dtk_Text - used to Dtk_Symbol conversion -
     Dtk_Text rough_mode_to_Dtk_Text() const;
 
    Dtk_Oriented2dBBox GetOuterBoundingBox(const Dtk_bool inIncludeSymbolGeometry) const;
     //! \brief Sets the top-left text
     //! \param inText The new text.
     //! \return dtkNoError if OK
     //! \sa GetTopLeftText
     Dtk_ErrorStatus SetTopLeftText( Dtk_Text inText);
 
     //! \brief Sets the middle-left text
     //! \param inText The new text.
     //! \return dtkNoError if OK
     //! \sa GetMiddleLeftText
     Dtk_ErrorStatus SetMiddleLeftText( Dtk_Text inText);
 
     //! \brief Sets the bottom-left text
     //! \param inText The new text.
     //! \return dtkNoError if OK
     //! \sa GetBottomLeftText
     Dtk_ErrorStatus SetBottomLeftText( Dtk_Text inText);
 
     //! \brief Sets the top-right text
     //! \param inText The new text.
     //! \return dtkNoError if OK
     //! \sa GetTopRightText
     Dtk_ErrorStatus SetTopRightText( Dtk_Text inText);
 
     //! \brief Sets the middle-right text
     //! \param inText The new text.
     //! \return dtkNoError if OK
     //! \sa GetMiddleRightText
     Dtk_ErrorStatus SetMiddleRightText( Dtk_Text inText);
 
     //! \brief Sets the bottom-right text
     //! \param inText The new text.
     //! \return dtkNoError if OK
     //! \sa GetBottomRightText
     Dtk_ErrorStatus SetBottomRightText( Dtk_Text inText);
 
     //! \brief Sets the CutOff text
     //! \param inText The new CutOff text.
     //! \return dtkNoError if OK
     //! \sa GetCutOff
    Dtk_ErrorStatus SetCutOff( Dtk_Text inText);
 
     //! \brief Sets the OtherRequirement text
     //! \param inText The new OtherRequirement text.
     //! \return dtkNoError if OK
     //! \sa GetOtherRequirement
    Dtk_ErrorStatus SetOtherRequirement( Dtk_Text inText);
 
     //! \brief Sets the rough mode.
     //! \param inRoughMode The new rough mode - in Text form -.
     //! \return dtkNoError if OK
     //! \sa GetRoughMode
    Dtk_ErrorStatus SetRoughMode( Dtk_Text inRoughModeText);
 
     //! \brief Sets the obtention type.
     //! \param inObtentionType The obtention type.
     //! \return dtkNoError if OK
     //! \sa GetRoughnessType
     Dtk_ErrorStatus SetRoughnessType(const ObtentionTypeEnum &inObtentionType);
 
     //! \brief Sets the apply-to type.
     //! \param inApplyTo The new apply-to type.
     //! \return dtkNoError if OK
     //! \sa GetTopLeftText
     Dtk_ErrorStatus SetRoughnessApplyTo(const ApplyToEnum &inApplyTo);
 
     //! \brief Sets text are invert.
     //! \param inValue DTK_TRUE all text are invert
     //! \sa GetInvertText
     void SetInvertText( Dtk_Int32 inValue=DTK_FALSE );
 
     //! \brief Gets the top-left text - read only -.
     //! \return The top-left text
     //! \sa SetTopLeftText
     Dtk_Text GetTopLeftText() const;
 
     //! \brief Gets the middle-left text - read only -.
     //! \return The middle-left text
     //! \sa SetMiddleLeftText
     Dtk_Text GetMiddleLeftText() const;
 
     //! \brief Gets the bottom-left text - read only -.
     //! \return The bottom-left text
     //! \sa SetBottomLeftText
     Dtk_Text GetBottomLeftText() const;
 
     //! \brief Gets the top-right text - read only -.
     //! \return The top-right text
     //! \sa SetTopRightText
     Dtk_Text GetTopRightText() const;
 
     //! \brief Gets the middle-right text - read only -.
     //! \return The middle-right text
     //! \sa SetMiddleRightText
     Dtk_Text GetMiddleRightText() const;
 
     //! \brief Gets the bottom-right text - read only -.
     //! \return The bottom-right text
     //! \sa SetBottomRightText
     Dtk_Text GetBottomRightText() const;
 
     //! \brief Gets the CutOff text - read only -.
     //! \return The CutOff text
     //! \sa SetCutOff
    Dtk_Text GetCutOff() const;
 
     //! \brief Gets the OtherRequirement text - read only -.
     //! \return The OtherRequirement text
     //! \sa SetOtherRequirement
    Dtk_Text GetOtherRequirement() const;
 
     //! \brief Gets the obtention type - read only -.
     //! \return The obtention type
     //! \sa SetRoughnessType
     ObtentionTypeEnum GetRoughnessType() const;
 
     //! \brief Gets the apply-to type - read only -.
     //! \return The apply-to type
     //! \sa SetRoughnessApplyTo
     ApplyToEnum GetRoughnessApplyTo() const;
 
     //! \brief Gets the rough mode - read only -.
     //! \return The rough mode
     //! \sa SetRoughMode
     RoughModeEnum GetRoughMode() const;
 
     //! \brief Gets text is invert or not.
     //! \return DTK_TRUE if all text are invert , DTK_FALSE otherwise
     //! \sa SetInvertText
     Dtk_Int32 GetInvertText( ) const;
 
     //! \brief Processes all the Dtk_Annotation anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints( Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     //! \brief Processes all the Dtk_Annotation anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints( Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]);
 
     //! \return The type of the entity type - DTK_TYPE_ROUGHNESS -
     type_detk get_type_detk() const { return DTK_TYPE_ROUGHNESS; }
 
     //! \brief Sets the Dtk_Roughness anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     //! \brief Sets the location point of the Dtk_Annotation
     //! \brief The location point is related to the anchor type
     //! \param inLocation the location point
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
     //! \brief Sets the annotation angle using the annotation base.
     //! \param inRotationAngle  The rotation angle to be set
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &angle);
 
     //! \brief Sets the offset of the Dtk_Annotation
     //! \brief The Offset is used to process bounding frames.
     //! \param inOffset The offset
     //! \return dtkNoError if OK
     //! \warning  For internal use only
     Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
    //! \brief Translates the  Dtk_ReferenceBlock - internal use only -.
    //! \param inTranslationDir the translation vector.
    void Translate(const Dtk_dir &inTranslationDir);
 
    //! \brief Process the Roughness Symbol Informations as shown in the picture below.
    //! \image html RoughNessSymbolInfos.png
    //! \param outPnts The reference points processed.
    //! \param outCircleRadius The circle radius processed.
    void ProcessSymbolInfos(Dtk_tab< Dtk_pnt >& outPnts, Dtk_Double64& outCircleRadius) const;
 
    //! \brief set the color of the Symbol
    //! \param inColor : the color of the symbol.
    void SetSymbolColor(Dtk_Int32 inColorId) const;
 
    //! \brief get the color of the Symbol
    //! \param outColor : the color of the symbol.
    void GetSymbolColor(Dtk_Int32& outColorId) const;
 
 
     //! \brief Add Geometries associated to whole Dtk_Roughness.
     //! \remark Used to Dtk_Symbol convertion.
     //! \param inAssociatedGeometries The Geometries associated to the Dtk_Roughness.
     void AddAssociatedGeometries( Dtk_tab< Dtk_EntityPtr > inAssociatedGeometries );
 
     //! \brief Retrieves the Dtk_Roughness geometries.
     //! \return All the associated geometries asked.
     Dtk_tab< Dtk_EntityPtr > GetGeometries() const;
};
 
//! \ingroup draw
//! \class Dtk_Welding
//! \brief This is the Welding Symbol class
//! \SmartPtr{Dtk_WeldingPtr}
//! \n
//! \image html WeldSymbolDescription.png
//! \n\n
class Dtk_Welding : public Dtk_Annotation
{
public :
    enum WeldingSymbolEnum{
        SymbolNone = 0,
        //! \image html SymbolSquareButtWeld.png
        SymbolSquareButtWeld,
        //! \image html SymbolSingeVButtWeld.png
        SymbolSingeVButtWeld,
        //! \image html SymbolSingleBevelButtWeld.png
        SymbolSingleBevelButtWeld,
        //! \image html SymbolFlareVButtWeld.png
        SymbolFlareVButtWeld,
        //! \image html SymbolFlareBevelButtWeld.png
        SymbolFlareBevelButtWeld,
        //! \image html SymbolSingleUButtWeld.png
        SymbolSingleUButtWeld,
        //! \image html SymbolSingleJButtWeld.png
        SymbolSingleJButtWeld,
        //! \image html SymbolFilletWeld.png
        SymbolFilletWeld,
        //! \image html SymbolSpotWeld.png
        SymbolSpotWeld,
        //! \image html SymbolBackWeld.png
        SymbolBackWeld,
        //! \image html SymbolSteepFlankedSingleBevelButtWeld.png
        SymbolSteepFlankedSingleBevelButtWeld,
        //! \image html SymbolSteepFlankedSingleVWeld.png
        SymbolSteepFlankedSingleVWeld,
        //! \image html SymbolPlugWeld.png
        SymbolPlugWeld,
        //! \image html SymbolRemovableBackingStripUsed.png
        SymbolRemovableBackingStripUsed,
        //! \image html SymbolPermanentBackingStripUsed.png
        SymbolPermanentBackingStripUsed,
        //! \image html SymbolSurfacingWeld.png
        SymbolSurfacingWeld,
        //! \image html SymbolSeamWeld.png
        SymbolSeamWeld,
        //! \image html SymbolFlangeEdge.png
        SymbolFlangeEdge,
        //! \image html SymbolStickWeld.png
        SymbolStickWeld,
        //! \image html SymbolFlangeCorner.png
        SymbolFlangeCorner,
        //! \image html SymbolVFlareWeld.png
        SymbolVFlareWeld,
        //! \image html SymbolFlareBevelWeld.png
        SymbolFlareBevelWeld,
        //! \image html SymbolScarfWeld.png
        SymbolScarfWeld,
        //! \image html SymbolStudWeld.png
        SymbolStudWeld,
        //! \image html SymbolANSIEdgeWeld.png
        SymbolANSIEdgeWeld,
        //! \image html SymbolISOEdgeWeld.png
        SymbolISOEdgeWeld,
        //! \image html SymbolSurfaceJointWeld.png
        SymbolSurfaceJointWeld,
        //! \image html SymbolInclinedJointWeld.png
        SymbolInclinedJointWeld,
        //! \image html SymbolMeltThroughWeld.png
        SymbolMeltThroughWeld,
          //! \image html SymbolSolderedJointWeld.png
          SymbolSolderedJointWeld,
          //! \image html SymbolFoldJointWeld.png
          SymbolFoldJointWeld,
          //! \image html SymbolKGrooveWeld.png
          SymbolKGrooveWeld,
          //! \image html SymbolStakeWeld.png
          SymbolStakeWeld
    };
    static 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,
        //! \image html ComplementarySymbolWeldWithFlatFace.png
        ComplementarySymbolWeldWithFlatFace,
        //! \image html ComplementarySymbolWeldWithConvexFace.png
        ComplementarySymbolWeldWithConvexFace,
        //! \image html ComplementarySymbolWeldWithConcaveFace.png
        ComplementarySymbolWeldWithConcaveFace,
        //! \image html ComplementarySymbolFlushFinishedWeld.png
        ComplementarySymbolFlushFinishedWeld,
        //! \image html ComplementarySymbolFilletWeldWithSmoothBlendedFace.png
        ComplementarySymbolFilletWeldWithSmoothBlendedFace
    };
 
     enum WeldTextType
     {
          WeldTextUndefinedType = 0,
          WeldTextFinishSymbol,
          WeldTextAngle,
          WeldTextNum,
          WeldTextLength,
          WeldTextSize,
          WeldTextDepth,
          WeldTextClearance,
          WeldTextSecondFilletSize,
          WeldTextSecondFilletLength,
          WeldTextOpening,
          WeldTextWeldSymbol
     };
 
    static 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,
        //! \image html WeldFinishSymbolChip.png
        FinishSymbolChip,
        //! \image html WeldFinishSymbolFlush.png
        FinishSymbolFlush,
        //! \image html WeldFinishSymbolGrind.png
        FinishSymbolGrind,
        //! \image html WeldFinishSymbolHammer.png
        FinishSymbolHammer,
        //! \image html WeldFinishSymbolMachine.png
        FinishSymbolMachine,
        //! \image html WeldFinishSymbolRoll.png
        FinishSymbolRoll,
          //! \image html WeldFinishSymbolPeening.png
          FinishSymbolPeening,
        //! \image html WeldFinishSymbolUnspecified.png
        FinishSymbolUnspecified
    };
    static 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
    std::unique_ptr< Dtk_Handle > _Private; // Handle
    enum { _typeID = DTK_TYPE_WELDING };
 
    //! \sa Create()
    Dtk_Welding();
 
    //! \sa Create(const Dtk_pnt&, const Dtk_CompositeText&, const Dtk_bool, const Dtk_Char8, const Dtk_bool, const Dtk_bool, const Dtk_InfoPtr&, const Dtk_tab<Dtk_LeaderPtr>&, const Dtk_Double64, const Dtk_Double64, const Dtk_anchor_type, const Dtk_justication_type)
    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);
 
    //! \sa Create(const Dtk_pnt&, const Dtk_InfoPtr&, const Dtk_tab<Dtk_LeaderPtr>&, const Dtk_Double64, const Dtk_Double64, const Dtk_anchor_type, const Dtk_justication_type)
    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);
    //! \sa Create(const Dtk_Welding &)
    Dtk_Welding( const Dtk_Welding & );
    Dtk_Welding( Dtk_Welding&& in ) DTK_NOEXCEPT;
    ~Dtk_Welding();
    inline virtual Dtk_Object* Clone() { return new Dtk_Welding(*this); }
 
private:
    friend class Dtk_SmartPtr<Dtk_Welding>;
    friend class Dtk_Symbol;
public:
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    //! \DtkDynamicCast
    static Dtk_Welding * DtkDynamicCast(Dtk_Object *s);
public:
    //! \CreateBase
    static Dtk_WeldingPtr Create();
 
    //! \brief Calls full featured constructor to allocate a new object.
    //! \param inLocationPnt The Dtk_Welding location
    //! \param inTailText Tail Dtk_CompositeText.
    //! \param inFieldWeldActivated DTK_TRUE if Field is activated. DTK_FALSE else.
    //! \param inIndentLineFlag The IndentLineSideDown Flag:\n
    //! - -1 To disable Indent Line - default -.\n
    //! -  0 To set Indent Line to OtherSide - Up -.\n
    //! -  1 To set Indent Line to ArrowSide - Down -.
    //! \param inTailActivated The Tail Flag Activation status. DTK_TRUE if activated DTK_FALSE else.
    //! \param inReverseTailAndField The Tail/Field Reverse Flag:\n
    //! - If DTK_TRUE the Field is at the left of the Dtk_Welding and the Tail is at Right.
    //! - If DTK_FALSE the Field and Tail are reversed - Field => Right and Tail => Left -.
    //! \param inInfos Dtk_Welding infos
    //! \param inLeaders Leaders array.
    //! \param inAngle Angle.
    //! \param inOffSet Offset.
    //! \param inAnchorType Dtk_Welding anchor type.
    //! \param inJustificationType Justification type.
    //! \return The created Dtk_WeldingPtr
    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);
 
    //! \brief Calls full featured constructor to allocate a new object.
    //! \param inLocationPnt The Dtk_Welding location
    //! \param inInfos Dtk_Welding infos
    //! \param inLeaders Leaders array.
    //! \param inAngle Angle.
    //! \param inOffSet Offset.
    //! \param inAnchorType Dtk_Welding anchor type.
    //! \param inJustificationType Justification type.
    //! \return The created Dtk_WeldingPtr
    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);
 
    //! \CreateCopy{in}
    static Dtk_WeldingPtr Create(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]);
 
    //! \return The type of the entity type - DTK_TYPE_WELDING -
    type_detk get_type_detk() const { return DTK_TYPE_WELDING; }
 
    //! \brief Add Geometries associated to whole Dtk_Welding (Weld body and tail).
    //! \remark Used to Dtk_symbol convertion.
    //! \param inAssociatedGeometries The Geometries associated to the Dtk_Welding.
    void AddAssociatedGeometries( Dtk_tab< Dtk_EntityPtr > inAssociatedGeometries);
 
     //! \brief Add a Geometry associated to whole Dtk_Welding (Weld body and tail).
     //! \remark Used to Dtk_symbol convertion.
     //! \param inAssociatedGeometry The Geometry associated to the Dtk_Welding.
     void AddAssociatedGeometry( Dtk_EntityPtr inAssociatedGeometry );
 
     //! \brief Set the Dtk_Welding OtherSide Texts and their types.
    //! \param inTexts Map of texts with their corresponding WeldTextType
     void SetOtherSideTexts( std::unordered_map <Dtk_UInt8, Dtk_CompositeText>& inTexts );
 
     //! \brief Add a Text and its type to the OtherSide
     //! \param inType The WeldTextType
     //! \param inTexts The text 
     void AddOtherSideText( WeldTextType inType, Dtk_CompositeText inText );
 
     //! \brief Add an undefined Text to the OtherSide
     //! \param inTexts The text
     void AddOtherSideUndefinedText( Dtk_CompositeText inText );
 
     //! \brief Set the Dtk_Welding ArrowSide Texts and their types.
     //! \param inTexts Map of texts with their corresponding WeldTextType
     void SetArrowSideTexts( std::unordered_map <Dtk_UInt8, Dtk_CompositeText>& inTexts );
 
     //! \brief Add a Text and its type to the ArrowSide
     //! \param inType The WeldTextType
     //! \param inTexts The text 
     void AddArrowSideText( WeldTextType inType, Dtk_CompositeText inText );
 
     //! \brief Add an undefined Text to the ArrowSide
     //! \param inTexts The text
     void AddArrowSideUndefinedText( Dtk_CompositeText inText );
 
     //! \brief Set the WeldingSymbol of the ArrowSide
     //! \param inWeldingSymbol The Welding Symbol.
     void SetArrowSideWeldingSymbol( WeldingSymbolEnum inWeldingSymbol );
 
     //! \brief Set the ContourSymbol of the ArrowSide
     //! \param inContourSymbol The Contour Symbol.
     void SetArrowSideContourSymbol( ComplementarySymbolEnum inContourSymbol );
 
     //! \brief Set the AssociatedGeometries of the ArrowSide
     //! \param inAssociatedGeometries The Geometries associated to the ArrowSide.
     void SetArrowSideAssociatedGeometries( Dtk_tab< Dtk_EntityPtr > inAssociatedGeometries );
 
     //! \brief Add an AssociatedGeometry of the ArrowSide
     //! \param inAssociatedGeometry The Geometry associated to the ArrowSide.
     void AddArrowSideAssociatedGeometry( Dtk_EntityPtr inAssociatedGeometry );
 
     //! \brief Set the WeldingSymbol of the OtherSide
     //! \param inWeldingSymbol The Welding Symbol.
     void SetOtherSideWeldingSymbol( WeldingSymbolEnum inWeldingSymbol );
 
     //! \brief Set the ContourSymbol of the OtherSide
     //! \param inContourSymbol The Contour Symbol.
     void SetOtherSideContourSymbol( ComplementarySymbolEnum inContourSymbol );
 
     //! \brief Set the AssociatedGeometries of the OtherSide
     //! \param inAssociatedGeometries The Geometries associated to the OtherSide.
     void SetOtherSideAssociatedGeometries( Dtk_tab< Dtk_EntityPtr > inAssociatedGeometries );
 
     //! \brief Add an AssociatedGeometry of the OtherSide
     //! \param inAssociatedGeometry The Geometry associated to the OtherSide.
     void AddOtherSideAssociatedGeometry( Dtk_EntityPtr inAssociatedGeometry );
 
     //! \brief Return all the texts of the ArrowSide
     //! \return A map with WeldTextType keys and Dtk_CompositeText
     std::unordered_map <Dtk_UInt8, Dtk_CompositeText> GetArrowSideAllTexts() const;
 
     //! \brief Return all the texts of the OtherSide
     //! \return A map with WeldTextType keys and Dtk_CompositeText
     std::unordered_map <Dtk_UInt8, Dtk_CompositeText> GetOtherSideAllTexts() const;
 
    //! \brief Sets the Dtk_Welding OtherSide Data.
    //! \param inWeldingSymbol The Welding Symbol.
    //! \param inNumWeldsText The NumWelds Dtk_Text.
    //! \param inAngleText The Angle Dtk_Text.
    //! \param inContourSymbol The Contour Symbol.
    //! \param inFinishSymbolText The Finish Symbol Dtk_Text.
    //! \param inSizeText The Size Dtk_Text.
    //! \param inLengthText The Length Dtk_Text.
    //! \param inAssociatedGeometries The Geometries associated to the OtherSide - used to Dtk_Symbol convertion -.
    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);
 
    //! \brief Sets the Dtk_Welding ArrowSide Data.
    //! \param inWeldingSymbol The Welding Symbol.
    //! \param inNumWeldsText The NumWelds Dtk_Text.
    //! \param inAngleText The Angle Dtk_Text.
    //! \param inContourSymbol The Contour Symbol.
    //! \param inFinishSymbolText The Finish Symbol Dtk_Text.
    //! \param inSizeText The Size Dtk_Text.
    //! \param inLengthText The Length Dtk_Text.
    //! \param inAssociatedGeometries The Geometries associated to the ArrowSide - used to Dtk_Symbol convertion -.
    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);
 
    //! \brief Sets the Tail Dtk_CompositeText.
    //! \param inTailText The Tail Dtk_CompositeText.
    void SetTailText( Dtk_CompositeText inTailText);
 
    //! \brief Sets the ArrowSideSizeText Dtk_CompositeText.
    //! \param inArrowSideSizeText The Tail Dtk_CompositeText.
    void SetArrowSideSizeText( Dtk_CompositeText inArrowSideSizeText);
 
    //! \brief Sets the OtherSideSizeText Dtk_CompositeText.
    //! \param inOtherSideSizeText The Tail Dtk_CompositeText.
    void SetOtherSideSizeText( Dtk_CompositeText inOtherSideSizeText);
 
    //! \brief Sets the Field Weld Flag.
    //! \param inFieldWeldFlag The Field Weld Flag. DTK_TRUE if Field Weld is activated. DTK_TRUE else.
    void SetFieldWeldFlag(const Dtk_bool inFieldWeldFlag);
 
    //! \brief Sets the IndentLine Flag.
    //! \param inIndentLineFlag The IndentLine Flag:\n
    //! - -1 To disable Indent Line - default -.\n
    //! -  0 To set Indent Line to OtherSide - Up -.\n
    //! -  1 To set Indent Line to ArrowSide - Down -.
    void SetIndentLineFlag(const Dtk_Char8 inIndentLineFlag = -1);
 
    //! \brief Sets the Tail Activation Flag.
    //! \param inTailActivated The Tail Flag. If DTK_FALSE - default value - the Tail is not activated. Else it's activated.
    void SetWeldTailActivated(const Dtk_bool inTailActivated = DTK_FALSE);
 
    //! \brief Sets the Field/Tail Reverse Flag.
    //! \param inReverseTailAndField The Tail/Field Reverse Flag:\n
    //! - If DTK_TRUE the Field is at the left of the Dtk_Welding and the Tail is at Right - default value -.
    //! - If DTK_FALSE the Field and Tail are reversed - Field => Right and Tail => Left -.
    void SetReverseTailAndFieldFlag(const Dtk_bool  inReverseTailAndField = DTK_TRUE);
 
    //! \brief Tells if the Field Weld Symbol is activated.
    //! \return DTK_TRUE if Field Weld Symbol is activated. DTK_FALSE else.
    Dtk_bool GetFieldWeldActivated() const;
 
    //! \brief Retrieves the IndentLine Flag.
    //! \return -1 if no Indent Line.
    //! \return  0 if Indent Line set at the OtherSide - Up -.
    //! \return  1 if Indent Line set at the ArrowSide - Down -.
    Dtk_Char8 GetIndentLineFlag() const;
 
    //! \brief Tells if the Weld Tail is activated.
    //! \return DTK_FALSE if no Tail.
    //! \return DTK_TRUE  if Tail is activated.
    Dtk_bool GetWeldTailActivated() const;
 
    //! \brief Tells if the Field/Tail are reversed.
    //! \return  DTK_FALSE if Field/Tail not reversed - Filed to the Left and Tail to the Right -.
    //! \return  DTK_TRUE  if Field/Tail reversed.
    Dtk_bool GetReverseTailAndFieldFlag() const;
 
    //ArrowSide - BottomLine - Accessors
 
    //! \brief Retrieves the ArrowSide Finish Symbol Dtk_Text.
    //! \return The ArrowSide Finish Symbol Dtk_Text.
    Dtk_Text GetFinishSymbolTextArrowSide() const;
 
    //! \brief Retrieves the ArrowSide Angle Dtk_Text.
    //! \return The ArrowSide Angle Dtk_Text.
    Dtk_Text GetAngleTextArrowSide() const;
 
    //! \brief Retrieves the ArrowSide NumWelds Dtk_Text.
    //! \return The ArrowSide NumWelds Dtk_Text.
    Dtk_Text GetNumWeldsTextArrowSide() const;
 
    //! \brief Retrieves the ArrowSide Size Dtk_Text.
    //! \return The ArrowSide Size Dtk_Text.
    Dtk_Text GetSizeTextArrowSide() const;
 
    //! \brief Retrieves the ArrowSide Length Dtk_Text.
    //! \return The ArrowSide Length Dtk_Text.
    Dtk_Text GetLengthTextArrowSide() const;
 
    //! \brief Retrieves the ArrowSide WeldingSymboEnum.
    //! \return The ArrowSide WeldingSymboEnum.
    WeldingSymbolEnum GetWeldingSymbolArrowSide() const;
 
    //! \brief Retrieves the ArrowSide WeldingSymboEnum.
    //! \return The ArrowSide WeldingSymboEnum.
    ComplementarySymbolEnum GetComplementarySymbolArrowSide() const;
 
    //! \brief Retrieves the ArrowSide FinishSymbol as FinishSymbolEnum.
    //! \return The ArrowSide FinishSymbol as FinishSymbolEnum.
    FinishSymbolEnum GetFinishSymbolArrowSide() const;
 
    //! \sa GetFinishSymbolTextArrowSide() const
    Dtk_Text GetFinishSymbolArrowSideAsText() const;
 
    //OtherSide - _TopLine - Accessors
    //! \brief Retrieves the OtherSide Finish Symbol Dtk_Text.
    //! \return The OtherSide Finish Symbol Dtk_Text.
    Dtk_Text GetFinishSymbolTextOtherSide() const;
 
    //! \brief Retrieves the OtherSide Angle Dtk_Text.
    //! \return The OtherSide Angle Dtk_Text.
    Dtk_Text GetAngleTextOtherSide() const;
 
    //! \brief Retrieves the OtherSide NumWelds Dtk_Text.
    //! \return The OtherSide NumWelds Dtk_Text.
    Dtk_Text GetNumWeldsTextOtherSide() const;
 
    //! \brief Retrieves the OtherSide Size Dtk_Text.
    //! \return The OtherSide Size Dtk_Text.
    Dtk_Text GetSizeTextOtherSide() const;
 
    //! \brief Retrieves the OtherSide Length Dtk_Text.
    //! \return The OtherSide Length Dtk_Text.
    Dtk_Text GetLengthTextOtherSide() const;
 
    //! \brief Retrieves the OtherSide WeldingSymboEnum.
    //! \return The OtherSide WeldingSymboEnum.
    WeldingSymbolEnum GetWeldingSymbolOtherSide() const;
 
    //! \brief Retrieves the OtherSide WeldingSymboEnum.
    //! \return The OtherSide WeldingSymboEnum.
    ComplementarySymbolEnum GetComplementarySymbolOtherSide() const;
 
    //! \brief Retrieves the OtherSide FinishSymbol as FinishSymbolEnum.
    //! \return The OtherSide FinishSymbol as FinishSymbolEnum.
    FinishSymbolEnum GetFinishSymbolOtherSide() const;
 
    //! \sa GetFinishSymbolTextOtherSide() const
    Dtk_Text GetFinishSymbolOtherSideAsText() const;
 
     //! \brief Tells if the Brazing is activated for the OtherSide
     //! \return DTK_TRUE if the Brazing is activated, and the corresponding geometry should be in the _AssociatedGeometries, DTK_FALSE otherwise
     Dtk_bool GetBrazingOtherSide() const;
 
     //! \brief Sets the Brazing flag for the OtherSide.
     //! \param inBrazing The Brazing Flag.
     void SetBrazingOtherSide( const Dtk_bool inBrazing = DTK_TRUE );
 
     //! \brief Tells if the Brazing is activated for the ArrowSide
     //! \return DTK_TRUE if the Brazing is activated, and the corresponding geometry should be in the _AssociatedGeometries, DTK_FALSE otherwise
     Dtk_bool GetBrazingArrowSide() const;
 
     //! \brief Sets the Brazing flag for the ArrowSide.
     //! \param inBrazing The Brazing Flag.
     void SetBrazingArrowSide( const Dtk_bool inBrazing = DTK_TRUE );
 
    //! \brief Retrieves the Tail Dtk_CompositeText.
    //! \return The Tail Dtk_CompositeText.
    Dtk_CompositeText GetTailText() const;
 
    //! \brief Retrieves the OtherSideSizeText Dtk_CompositeText.
    //! \return The OtherSideSizeText Dtk_CompositeText.
    Dtk_CompositeText GetOtherSideSizeText() const;
 
    //! \brief Retrieves the ArrowSideSizeText Dtk_CompositeText.
    //! \return The ArrowSideSizeText Dtk_CompositeText.
    Dtk_CompositeText GetArrowSideSizeText() const;
 
    //! \brief Retrieves the Dtk_Welding geometries.
    //! \param inIncludeWeldBodyGeometries If DTK_TRUE includes WeldBody geometries - DTK_TRUE by default -.
    //! \param inIncludeOtherSideGeometries If DTK_TRUE includes OtherSide geometries - DTK_TRUE by default -.
    //! \param inIncludeArrowSideGeometries If DTK_TRUE includes ArrowSide geometries - DTK_TRUE by default -.
    //! \return All the associated geometries asked.
    Dtk_tab< Dtk_EntityPtr > GetGeometries(
        const Dtk_bool inIncludeWeldBodyGeometries = DTK_TRUE,
        const Dtk_bool inIncludeOtherSideGeometries = DTK_TRUE,
        const Dtk_bool inIncludeArrowSideGeometries = DTK_TRUE) const;
 
    //! \brief Sets the Dtk_Welding anchor point.
    //! \param inNewLocation The new location point.
    //! \param inLocationAnchorType The anchor type related to the new location.
    //! \return dtkNoError if OK
    Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
        const Dtk_anchor_type &inLocationAnchorType);
 
    //! \brief Sets the location point of the Dtk_Annotation
    //! \brief The location point is related to the anchor type
    //! \param inLocation the location point
    //! \return dtkNoError if OK
    Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
    //! \brief Sets the annotation angle using the annotation base.
    //! \param inRotationAngle  The rotation angle to be set
    //! \return dtkNoError if OK
    Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &inAngle);
 
    //! \brief Sets the offset of the Dtk_Welding
    //! \brief The Offset is used to process bounding frames.
    //! \param inOffset The offset
    //! \return dtkNoError if OK
    //! \warning  For internal use only
    Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
    //! \brief Convert FinishSymbolEnum to Dtk_Char8.
    //! \param inFinishSymbol FinishSymbolEnum to be converted.
    //! \return Dtk_Char8 related to inFinishSymbol value.
    Dtk_Char8 FinishSymbolToDtk_Text( const FinishSymbolEnum inFinishSymbol) const;
 
    //! \Transform{inTransfo}
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    //! \brief Process the Welding Symbol Informations as shown in the picture below.
    //! \image html WeldingSymbolInfos.png
    //! \param outPnts The reference points processed.
    //! \remark The 1st point is the Field point.
    //! \remark The 2nd point is the Tail point.
    void ProcessSymbolInfos(Dtk_tab< Dtk_pnt >& outPnts) const;
 
     //! \brief Process the Welding Symbol Informations.
     //! \param inPnts The reference points.
     //! \remark The 1st point is the Field point.
     //! \remark The 2nd point is the Tail point.
     void SetSymbolInfos( Dtk_tab< Dtk_pnt >& inPnts );
 
     ///////////////////////Arrow Side New Texts
 
     //! \brief Sets the ArrowSideDepthText Dtk_CompositeText.
     //! \param inArrowSideDepthText The Tail Dtk_CompositeText.
     void SetArrowSideDepthText( Dtk_CompositeText inArrowSideDepthText );
 
     //! \brief Retrieves the ArrowSideDepthText Dtk_CompositeText.
     //! \return The ArrowSideDepthText Dtk_CompositeText.
     Dtk_CompositeText GetArrowSideDepthText() const;
 
     //! \brief Sets the ArrowSideClearanceText Dtk_CompositeText.
     //! \param inArrowSideClearanceText The Tail Dtk_CompositeText.
     void SetArrowSideClearanceText( Dtk_CompositeText inArrowSideClearanceText );
 
     //! \brief Retrieves the ArrowSideClearanceText Dtk_CompositeText.
     //! \return The ArrowSideClearanceText Dtk_CompositeText.
     Dtk_CompositeText GetArrowSideClearanceText() const;
 
     //! \brief Sets the ArrowSideSecondFilletSizeText Dtk_CompositeText.
     //! \param inArrowSideSecondFilletSizeText The Tail Dtk_CompositeText.
     void SetArrowSideSecondFilletSizeText( Dtk_CompositeText inArrowSideSecondFilletSizeText );
 
     //! \brief Retrieves the ArrowSideSecondFilletSizeText Dtk_CompositeText.
     //! \return The ArrowSideSecondFilletSizeText Dtk_CompositeText.
     Dtk_CompositeText GetArrowSideSecondFilletSizeText() const;
 
     //! \brief Sets the ArrowSideSecondFilletLengthText Dtk_CompositeText.
     //! \param inArrowSideSecondFilletLengthText The Tail Dtk_CompositeText.
     void SetArrowSideSecondFilletLengthText( Dtk_CompositeText inArrowSideSecondFilletLengthText );
 
     //! \brief Retrieves the ArrowSideSecondFilletLengthText Dtk_CompositeText.
     //! \return The ArrowSideSecondFilletLengthText Dtk_CompositeText.
     Dtk_CompositeText GetArrowSideSecondFilletLengthText() const;
 
     //! \brief Sets the ArrowSideOpeningText Dtk_CompositeText.
     //! \param inArrowSideOpeningText The Tail Dtk_CompositeText.
     void SetArrowSideOpeningText( Dtk_CompositeText inArrowSideOpeningText );
 
     //! \brief Retrieves the ArrowSideOpeningText Dtk_CompositeText.
     //! \return The ArrowSideOpeningText Dtk_CompositeText.
     Dtk_CompositeText GetArrowSideOpeningText() const;
 
     //! \brief Sets the ArrowSideWeldSymbolText Dtk_CompositeText.
     //! \param inArrowSideWeldSymbolText The Tail Dtk_CompositeText.
     void SetArrowSideWeldSymbolText( Dtk_CompositeText inArrowSideWeldSymbolText );
 
     //! \brief Retrieves the ArrowSideWeldSymbolText Dtk_CompositeText.
     //! \return The ArrowSideWeldSymbolText Dtk_CompositeText.
     Dtk_CompositeText GetArrowSideWeldSymbolText() const;
 
     //! \brief Retrieves the ArrowSideUndefinedText Dtk_CompositeText.
     //! \return The ArrowSideUndefinedText Dtk_CompositeText.
     Dtk_CompositeText GetArrowSideUndefinedText() const;
 
     ///////////////////////Other Side New Texts
 
     //! \brief Sets the OtherSideDepthText Dtk_CompositeText.
     //! \param inOtherSideDepthText The Tail Dtk_CompositeText.
     void SetOtherSideDepthText( Dtk_CompositeText inOtherSideDepthText );
 
     //! \brief Retrieves the OtherSideDepthText Dtk_CompositeText.
     //! \return The OtherSideDepthText Dtk_CompositeText.
     Dtk_CompositeText GetOtherSideDepthText() const;
 
     //! \brief Sets the OtherSideClearanceText Dtk_CompositeText.
     //! \param inOtherSideClearanceText The Tail Dtk_CompositeText.
     void SetOtherSideClearanceText( Dtk_CompositeText inOtherSideClearanceText );
 
     //! \brief Retrieves the OtherSideClearanceText Dtk_CompositeText.
     //! \return The OtherSideClearanceText Dtk_CompositeText.
     Dtk_CompositeText GetOtherSideClearanceText() const;
 
     //! \brief Sets the OtherSideSecondFilletSizeText Dtk_CompositeText.
     //! \param inOtherSideSecondFilletSizeText The Tail Dtk_CompositeText.
     void SetOtherSideSecondFilletSizeText( Dtk_CompositeText inOtherSideSecondFilletSizeText );
 
     //! \brief Retrieves the OtherSideSecondFilletSizeText Dtk_CompositeText.
     //! \return The OtherSideSecondFilletSizeText Dtk_CompositeText.
     Dtk_CompositeText GetOtherSideSecondFilletSizeText() const;
 
     //! \brief Sets the OtherSideSecondFilletLengthText Dtk_CompositeText.
     //! \param inOtherSideSecondFilletLengthText The Tail Dtk_CompositeText.
     void SetOtherSideSecondFilletLengthText( Dtk_CompositeText inOtherSideSecondFilletLengthText );
 
     //! \brief Retrieves the OtherSideSecondFilletLengthText Dtk_CompositeText.
     //! \return The OtherSideSecondFilletLengthText Dtk_CompositeText.
     Dtk_CompositeText GetOtherSideSecondFilletLengthText() const;
 
     //! \brief Sets the OtherSideOpeningText Dtk_CompositeText.
     //! \param inOtherSideOpeningText The Tail Dtk_CompositeText.
     void SetOtherSideOpeningText( Dtk_CompositeText inOtherSideOpeningText );
 
     //! \brief Retrieves the OtherSideOpeningText Dtk_CompositeText.
     //! \return The OtherSideOpeningText Dtk_CompositeText.
     Dtk_CompositeText GetOtherSideOpeningText() const;
 
     //! \brief Sets the OtherSideWeldSymbolText Dtk_CompositeText.
     //! \param inOtherSideWeldSymbolText The Tail Dtk_CompositeText.
     void SetOtherSideWeldSymbolText( Dtk_CompositeText inOtherSideWeldSymbolText );
 
     //! \brief Retrieves the OtherSideWeldSymbolText Dtk_CompositeText.
     //! \return The OtherSideWeldSymbolText Dtk_CompositeText.
     Dtk_CompositeText GetOtherSideWeldSymbolText() const;
 
     //! \brief Retrieves the OtherSideUndefinedText Dtk_CompositeText.
     //! \return The OtherSideUndefinedText Dtk_CompositeText.
     Dtk_CompositeText GetOtherSideUndefinedText() const;
};
 
//! \ingroup draw
//! \class Dtk_DatumTarget
//! \image html DatumTarget1.png
//! \image html DatumTarget2.png
//! \brief This is the Datum Target
//! \SmartPtr{Dtk_DatumTargetPtr}
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 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 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 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
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum
     {
          _typeID = DTK_TYPE_DATUM_TARGET
     };
 
     //! \sa Create()
     Dtk_DatumTarget();
     //! \sa Create(const Dtk_DatumTarget &)
     Dtk_DatumTarget(const Dtk_DatumTarget& );
     Dtk_DatumTarget( Dtk_DatumTarget&& ) DTK_NOEXCEPT;
     //! \sa Create(const Dtk_CompositeText&, const Dtk_CompositeText&, const Dtk_pnt &, const Dtk_InfoPtr &,const Dtk_tab<Dtk_LeaderPtr> &,const Dtk_Double64 &,const Dtk_Double64 &,const Dtk_bool&, const Dtk_anchor_type &,const Dtk_justication_type &)
     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:
     friend class Dtk_SmartPtr<Dtk_DatumTarget>;
public:
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_DatumTarget* DtkDynamicCast(Dtk_Object *s);
 
     //! \CreateBase
     static Dtk_DatumTargetPtr Create();
 
     //! \CreateCopy{in}
     static Dtk_DatumTargetPtr Create(const Dtk_DatumTarget &in);
 
     //! \brief Calls full featured constructor to allocate a new object.
     //! \param inTopText Top text
     //! \param inBottomText Bottom text
     //! \param inLocationPnt The Dtk_DatumTarget location
     //! \param inInfos Dtk_DatumTarget infos
     //! \param inLeadersArray Leaders array
     //! \param inAngle Angle
     //! \param inOffSet Offset
     //! \param inHasFrame DTK_TRUE if the Dtk_DatumTarget has frame
     //! \param inAnchorType Dtk_DatumTarget anchor type
     //! \param inJustificationType Justification type
     //! \return The created Dtk_DatumTargetPtr
     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);
 
     //! \brief Processes the Dtk_DatumTarget radius
     //! \return the processed radius.
     Dtk_Double64 ProcessRadius() const ;
 
    //! \brief Sets the type of the Dtk_DatumTarget.
    //! \param inType The Dtk_DatumTarget type
    //! \sa GetDatumTargetType() const
    void SetDatumTargetType( const DatumTargetTypeEnum inType );
 
    //! \brief Gets the type of the Dtk_DatumTarget.
    //! \return The Dtk_DatumTarget type
    //! \sa GetDatumTargetType() const
    Dtk_DatumTarget::DatumTargetTypeEnum GetDatumTargetType() const;
 
     //! \brief Sets the Movable status of the Dtk_DatumTarget.
     //! \param inMovableStatus The Dtk_DatumTarget Movable status
     //! \param inMovableGeom The geometry related to the Movable status
     //! \sa GetDatumTargetMovableStatus() const
     //! \sa GetDatumTargetMovableStatusRelatedGeom() const
     void SetDatumTargetMovable( const DatumTargetMovableStatusEnum inMovableStatus,
                                         Dtk_tab<Dtk_CurvePtr> inMovableGeom );
 
     //! \brief Gets the Movable status of the Dtk_DatumTarget.
     //! \return The Dtk_DatumTarget Movable status
     //! \sa SetDatumTargetMovable() const
     Dtk_DatumTarget::DatumTargetMovableStatusEnum GetDatumTargetMovableStatus() const;
 
     //! \brief Gets the geometry related to the Movable status of the Dtk_DatumTarget.
     //! \return The tab of Dtk_CurvePtr composing the geometry related to the Movable status
     //! \sa SetDatumTargetMovable() const
     Dtk_tab<Dtk_CurvePtr> & GetDatumTargetMovableStatusRelatedGeom() const;
 
    //! \brief Retrieves the top text - get/set -
     //! \return The top text
     //! \sa TopText() const
     Dtk_CompositeText &TopText();
 
     //! \brief Sets the optionnal Leader of the Top Text
     //! \param inLeader The Dtk_LeaderPtr 
     //! \sa GetOptionnalTopTextLeader() const
     void SetOptionnalTopTextLeader( const Dtk_LeaderPtr & inLeader );
 
     //! \brief Retrieves optionnal Leader of the Top Text
     //! \return The Dtk_LeaderPtr
     //! \sa SetOptionnalTopTextLeader()
     const Dtk_LeaderPtr &GetOptionnalTopTextLeader() const;
 
     //! \brief Retrieves the bottom text - get/set -
     //! \return The bottom text
     //! \sa BottomText() const
     Dtk_CompositeText &BottomText();
 
     //! \brief Sets the optionnal Leader of the Bottom Text
     //! \param inLeader The Dtk_LeaderPtr 
     //! \sa GetOptionnalBottomTextLeader() const
     void SetOptionnalBottomTextLeader( const Dtk_LeaderPtr & inLeader );
 
     //! \brief Retrieves optionnal Leader of the Bottom Text
     //! \return The Dtk_LeaderPtr
     //! \sa SetOptionnalBottomTextLeader()
     const Dtk_LeaderPtr &GetOptionnalBottomTextLeader() const;
 
     //! \brief Retrieves the top text - read only -
     //! \return The top text
     //! \sa TopText()
     const Dtk_CompositeText &TopText() const;
 
     //! \brief Retrieves the bottom text - read only -
     //! \return The bottom text
     //! \sa BottomText()
     const Dtk_CompositeText &BottomText() const;
 
     //! \brief Retrieves the frame status - read only -
     //! \return The text frame status
     //! \sa EnableFrame()
     //! \sa DisableFrame()
     const Dtk_bool& HasFrame() const;
 
     //! \brief Enables the frame status
     //! \sa HasFrame() const
     //! \sa DisableFrame()
     void EnableFrame();
 
     //! \brief Disables the frame status
     //! \sa HasFrame() const
     //! \sa DisableFrame()
     void DisableFrame();
 
     //! \brief Sets the frame of the Datum Target
     //! \param inFrame The Dtk_Frame 
     //! \sa GetFrame() const
     void SetFrame( Dtk_Frame inFrame );
 
     //! \brief Retrieves the frame of the Datum Target
     //! \return The Dtk_Frame
     //! \sa SetFrame()
     const Dtk_Frame &GetFrame() const;
 
     //! \brief Retrieves the center point - read only -
     //! \return The center point
     //! \sa CenterPoint()
     Dtk_pnt ProcessCenterPoint() const;
 
    Dtk_Oriented2dBBox ProcessBoundingBox() const;
 
     //Dtk_Annotation interface
     //! \brief Processes all the Dtk_DatumTarget anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]);
 
     //! \brief Processes all the Dtk_DatumTarget anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     //! \return The type of the entity type - DTK_TYPE_DATUM_TARGET -
     type_detk get_type_detk() const
     {
          return DTK_TYPE_DATUM_TARGET;
     }
 
     //! \brief Sets the Dtk_DatumTarget anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     //! \brief Sets the location point of the Dtk_DatumTarget
     //! \brief The location point is related to the anchor type
     //! \param inLocation the location point
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
     //! \brief Sets the offset of the Dtk_DatumTarget
     //! \brief The Offset is used to process bounding frames.
     //! \param inOffset The offset
     //! \return dtkNoError if OK
     //! \warning  For internal use only
     Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
     //! \brief Sets the annotation angle using the annotation base.
     //! \param inRotationAngle  The rotation angle to be set
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &inRotationAngle);
 
     //! \brief Swaps the Dtk_DatumTarget texts
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SwapTexts();
 
    //! \brief Retrieves the Dtk_DatumTarget geometries - frame -.
    //! \return All the geometries asked.
    Dtk_tab< Dtk_EntityPtr > GetGeometries() const;
 
     //! \brief Reverses the text
     //! The text anchor type is replaced by the opposed one
     //! and the text orientation is reversed.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus Reverse();
    //! \brief Translates the  Dtk_ReferenceBlock - internal use only -.
    //! \param inTranslationDir the translation vector.
    void Translate(const Dtk_dir &inTranslationDir);
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     //! \brief Sets the value associated to DatumTargetValueEnum .
     //! \param inValue  Set the inValue associated to the inValueEnum
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetParameterValue(const DatumTargetValueEnum &inValueEnum, Dtk_Val inValue);
 
     //! \brief Gets the value associated to DatumTargetValueEnum .
     //! \param outValue  Get the value associated to inValueEnum
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetParameterValue(const DatumTargetValueEnum &inValueEnum, Dtk_Val& outValue);
};
 
//! \ingroup draw
//! \class Dtk_OneCell
//! \brief Allows the representation of cell.
//!  <P> <B> min_Height: </B> The original height before mergers.</P>
//!  <P> <B> min_Width: </B> The original width before mergers.</P>
//!  <P> <B> nbCells_Left_Right: </B> Number of adjacent cells to the left or right. </P>
//!  <P> <B> nbCells_Top_Bottom: </B> Number of adjacent cells at the top or bottom. </P>
//! \image html OneCell.png
class Dtk_OneCell
{
protected:
     //! The real height (before and after mergers).
     Dtk_Double64 _Height;
     //! The real width (before and after mergers).
     Dtk_Double64 _Width;
     //! The original height before mergers.
     Dtk_Double64 min_Height;
     //! The original width before mergers.
     Dtk_Double64 min_Width;
    Dtk_bool        _HasText;
     Dtk_CompositeText _text;
     //! Defines the anchor texts.
     Dtk_Size_t anchor;
     //! Number of adjacent cells to the left or right
     Dtk_Int32 nbCells_Left_Right;
     //! Number of adjacent cells at the top or bottom
     Dtk_Int32 nbCells_Top_Bottom;
     //! Text justification
     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;
    //! \brief Added geometries for Dtk_OneCell
    Dtk_tab<Dtk_EntityPtr>  _AdditionnalGeometries;
 
     enum
     {
          _typeID = DTK_TYPE_CELL
     };
public:
     //! Base constructor
     Dtk_OneCell();
     //Dtk_OneCell(const double &h, const double &w);
 
     //! \CopyConstructor{in}
     Dtk_OneCell(const Dtk_OneCell&in);
     //! \MoveConstructor{in}
     Dtk_OneCell( Dtk_OneCell&& in ) DTK_NOEXCEPT;
     //! \AssignmentOp{in}
     Dtk_OneCell& operator=( const Dtk_OneCell& in );
     //! \MoveOp{in}
     Dtk_OneCell& operator =( Dtk_OneCell&& in ) DTK_NOEXCEPT;
 
     //! \BaseDestructor
     ~Dtk_OneCell();
    Dtk_bool HasText() const {return _HasText;}
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const int& inId);
 
     //! \DtkDynamicCast
     static Dtk_OneCell* DtkDynamicCast(Dtk_Object * s);
 
 
     //! \brief Gets the Dtk_OneCell anchor
     //! \return anchor;
     Dtk_Size_t& getAnchor();
 
     //! \brief Set anchor of text
     //! \param inNumberOfAnchor The new number of anchor
     void setAnchor(const Dtk_Size_t& inNumberOfAnchor);
 
     //! \brief Gets the Dtk_OneCell justification
     //! \return text justification
     Dtk_justication_type & getJustification();
 
     //! \brief Sets justification
     //! \param inNewJustification The new Justification
     void setJustification(const Dtk_justication_type & inNewJustification);
 
     //! \brief Gets the Dtk_OneCell nbCells_Left_Right
     //! \return nbCells_Left_Right
     Dtk_Int32 getnbCells_Left_Right() const;
 
     //! \brief Sets nbCells_Left_Right
     //! \param inNewVal The new int used to set nbCells_Left_Right
     void setnbCells_Left_Right(const Dtk_Size_t &inNewVal);
 
     //! \brief Gets the number of cells at the bottom or left of the Dtk_OneCell
     //! \return nbCells_Top_Bottom
     Dtk_Int32 getnbCells_Top_Bottom() const;
 
     //! \brief Sets nbCells_Top_Bottom
     //! \param inNewVal The new int used to set nbCells_Top_Bottom
     void setnbCells_Top_Bottom(const Dtk_Size_t& inNewVal);
 
     //! \brief Sets the text in the Dtk_OneCell
     //! \param text The new text used to set _text
     void SetText( Dtk_CompositeText text);
 
     //! \brief Gets the text witch is in the Dtk_OneCell
     //! \return _text
     Dtk_CompositeText& GetText();
     const Dtk_CompositeText& GetText() const;
 
     //! \brief Gets the height of the Dtk_OneCell
     //! \return _Height
     Dtk_Double64   getHeight() const;
 
     //! \brief Sets the Dtk_OneCell height
     //! \param inHeight The new height used to set _Height
     void setHeight(const Dtk_Double64&inHeight);
 
     //! \brief Gets the width of the Dtk_OneCell
     //! \return _Width
     Dtk_Double64  getWidth() const;
 
     //! \brief Sets the Dtk_OneCell Width
     //! \param inWidth The new width used to set _Width
     void setWidth(const Dtk_Double64&inWidth);
 
     //! \brief Gets the original height
     //! \return min_Height
     Dtk_Double64 get_min_Height();
 
     //! \brief Sets the Dtk_OneCell min_Height
     //! \param inHeight The new height used to set min_Height
     void set_min_Height(const Dtk_Double64&inHeight);
 
     //! \brief Gets the original width of the Dtk_Onecell
     //! \return min_Width
     Dtk_Double64  get_min_Width();
 
     //! \brief Sets the Dtk_OneCell min_Width
     //! \param inWidth The new width used to set min_Width
     void set_min_Width(const Dtk_Double64 &min_Width);
 
     //! \brief Affects _text to null in order not to read the text which is inside.
     void Delete_Text();
 
     //! \brief Tests if the cell is composed of cells merged horizontally.
     //! \return true or false
     bool Merged_Cell_Horizontally();
 
     //! \brief tests if the cell is composed of cells merged vertically.
     //! \return true or false
     bool Merged_Cell_Vertically();
 
 
    //! \brief Sets BorderTopColor of Top border
    //! \param inBorderTopColor : color of the Top border
    void SetBorderTopColor(const Dtk_Int32 & inBorderTopColor);
    void SetBorderTopColor(const Dtk_RGB & inBorderTopColor);
 
    //! \brief Gets BorderTopColor of Top border
    //! \return BorderTopColor
    const Dtk_RGB& GetBorderTopColor() const;
 
    //! \brief Sets BorderBottomColor of Bottom border
    //! \param inBorderBottomColor : color of the Bottom border
    void SetBorderBottomColor(const Dtk_Int32 & inBorderBottomColor);
    void SetBorderBottomColor(const Dtk_RGB & inBorderBottomColor);
 
    //! \brief Gets BorderBottomColor of Bottom border
    //! \return BorderBottomColor
    const Dtk_RGB& GetBorderBottomColor() const;
 
    //! \brief Sets BorderLeftColor of Left border
    //! \param inBorderLeftColor : color of the Left border
    void SetBorderLeftColor(const Dtk_Int32 & inBorderLeftColor);
    void SetBorderLeftColor(const Dtk_RGB & inBorderLeftColor);
 
    //! \brief Gets BorderLeftColor of Left border
    //! \return BorderLeftColor
    const Dtk_RGB& GetBorderLeftColor() const;
 
    //! \brief Sets BorderRightColor of Right border
    //! \param inBorderRightColor : color of the Right border
    void SetBorderRightColor(const Dtk_Int32 & inBorderRightColor);
    void SetBorderRightColor(const Dtk_RGB & inBorderRightColor);
 
    //! \brief Gets BorderRightColor of Right border
    //! \return BorderRightColor
    const Dtk_RGB& GetBorderRightColor() const;
 
 
    //! \brief Sets BorderTopBlanked of Top border
    //! \param inBorderTopBlanked : Blanked Status of the Top border
    void SetBorderTopBlanked(const Dtk_Int32 & inBorderTopBlanked);
 
    //! \brief Gets BorderTopBlanked of Top border
    //! \return BorderTopBlanked DTK_TRUE is blanked
    Dtk_Int32 GetBorderTopBlanked() const;
 
    //! \brief Sets BorderBottomBlanked of Bottom border
    //! \param inBorderBottomBlanked : Blanked Status of the Bottom border
    void SetBorderBottomBlanked(const Dtk_Int32 & inBorderBottomBlanked);
 
    //! \brief Gets BorderBottomBlanked of Bottom border
    //! \return BorderBottomBlanked DTK_TRUE is blanked
    Dtk_Int32 GetBorderBottomBlanked() const;
 
    //! \brief Sets BorderLeftBlanked of Left border
    //! \param inBorderLeftBlanked : Blanked Status of the Left border
    void SetBorderLeftBlanked(const Dtk_Int32 & inBorderLeftBlanked);
 
    //! \brief Gets BorderLeftBlanked of Left border
    //! \return BorderLeftBlanked DTK_TRUE is blanked
    Dtk_Int32 GetBorderLeftBlanked() const;
 
    //! \brief Sets BorderRightBlanked of Right border
    //! \param inBorderRightBlanked : Blanked Status of the Right border
    void SetBorderRightBlanked(const Dtk_Int32 & inBorderRightBlanked);
 
    //! \brief Gets BorderRightBlanked of Right border
    //! \return BorderRightBlanked DTK_TRUE is blanked
    Dtk_Int32 GetBorderRightBlanked() const;
 
    //! \brief Adds some additionnal geometries to the Dtk_OneCell
    //! \param inAdditionnalGeometries The geometries to be added
    void AddAdditionnalGeometries( Dtk_tab<Dtk_EntityPtr> inAdditionnalGeometries);
 
    //! \brief Retrieves the additionnal geometries of the Dtk_OneCell
    //! \return The additionnal geometries array - read only -.
    const Dtk_tab< Dtk_EntityPtr >& GetAdditionnalGeometries() const;
 
};
 
//! \ingroup draw
//! \class Dtk_Table
//! \brief Represents the tables
//!  <P> <B> nbCells_Line : </B>  number of cells on each line (if we consider mergers).</P>
//!  <P> <B> nbCells_Col : </B> number of cells on each column (if we consider mergers).</P>
//!  <P> <B> Example: </B>  </P>
//! \image html TableOfCell.png
//! \sa Dtk_OneCell
//! \SmartPtr{Dtk_TablePtr}
class Dtk_Table:public Dtk_Annotation
{
protected:
     //! \brief A table of cells
     Dtk_OneCell ** tableOfCell;
     //! \brief Number of lines
     Dtk_Size_t nbRows;
     //! \brief Number of columns
     Dtk_Size_t nbCol;
     //! \brief number of cells on each line (if we consider mergers)
     Dtk_tab< Dtk_Size_t > nbCells_Line;
     //! \brief number of cells on each column (if we consider mergers)
     Dtk_tab< Dtk_Size_t > nbCells_Col;//
     enum
     {
          _typeID = DTK_TYPE_TABLE
     };
 
    Dtk_Table();
    //! \sa Create(const Dtk_Table &)
    Dtk_Table(const Dtk_Table &tab);
    Dtk_Table( Dtk_Table &&tab);
    //! \sa Create(const Dtk_Int32&, const Dtk_Int32&, const Dtk_pnt &,const Dtk_Double64 &, const Dtk_InfoPtr &,const Dtk_tab<Dtk_LeaderPtr> &,const Dtk_Double64 &, const Dtk_anchor_type &,const Dtk_justication_type &)    Dtk_Annotation();
    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:
     friend class Dtk_SmartPtr<Dtk_Table>;
public:
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_Table* DtkDynamicCast(Dtk_Object *s);
 
     //! \brief CreateCopy{in}
     static Dtk_TablePtr Create(const Dtk_Table& in);
 
     //! \brief Calls full featured constructor to allocate a new object.
     //! \param inNumRows Rows number in the Dtk_Table
     //! \param inNumCols Columns number in the Dtk_Table
     //! \param inLocationPnt The Dtk_Table location
     //! \param inAngle Angle
     //! \param inInfos Dtk_Table infos
     //! \param inLeadersArray Leaders array
     //! \param inOffSet Offset
     //! \param inAnchorType Dtk_Table anchor type
     //! \param inJustificationType Justification type
     //! \return The created Dtk_TablePtr
     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);
 
     //! \brief Gets the number of rows in Dtk_Table
     //! \return the number of rows
     Dtk_Size_t getNbrows();
 
     //! \brief Gets the number of colums in Dtk_Table
     //! \return the number of columns
     Dtk_Size_t getNbcols();
 
     //! \param inRow Line number
     //! \param inCol Column number
     //! \return tableOfCell[i][j]
    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];
    }
 
     //! \brief Sets the (inRowIdx,inColIdx)th text.
     //! \param inRowIdx Line index - 0 based -
     //! \param inColIdx column index - 0 based -
     //! \param inText Text be put.
     void Set_Texts(const Dtk_Size_t &inRowIdx, const Dtk_Size_t &inColIdx,
          Dtk_CompositeText inText);
 
     //! \brief Gets the number of cells in each line
     //! \return the number of cells in each line
    const Dtk_Size_t& Cell_Line(const Dtk_Size_t inPos) const;
 
     //! \brief Sets the number of cells of the (i)th line
     //! \param i Line number
     //! \param inNewVal The new number witch represents the number of cell of the ith row
    Dtk_Size_t& Cell_Line(const Dtk_Size_t inPos);
 
     //! \brief Gets the number of cells in each column
     //! \return the number of cells in each column
    const Dtk_Size_t& Cell_Col(const Dtk_Size_t inPos) const;
 
     //! \brief Sets the number of cells of the ith columns
     //! \param i Column number
     //! \param inNewVal The new number witch represents the number of cell of the ith Column
    Dtk_Size_t& Cell_Col(const Dtk_Size_t inPos);
 
 
    //! \brief Gets the Dtk_Table rows number.
     //! \return The rows number.
     Dtk_Size_t GetNumRows() const;
 
     //! \brief Gets the Dtk_Table columns number.
     //! \return The columns number.
     Dtk_Size_t GetNumCols() const;
 
     //! \return The type of the entity type - DTK_TYPE_TABLE-
     type_detk get_type_detk() const { return DTK_TYPE_TABLE; }
 
     //! \brief Gets the (i,j)th text - get/set -.
     //! \param inRow Text row index - 0 based -
     //! \param inCol Text column index - 0 based -
     //! \return The (inRow, inCol)th text.
     //! \sa Text(const Dtk_Size_t &, const Dtk_Size_t &) const
     //! \sa SetText(const Dtk_Size_t &, const Dtk_Size_t &, const Dtk_CompositeText &)
     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);
 
     //! \brief Processes all the Dtk_Annotation anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const ;
 
     //! \brief Sets the Dtk_Annotation anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     //! \brief Sets the location point of the Dtk_Annotation
     //! \brief The location point is related to the anchor type
     //! \param inLocation the location point
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
     //! \brief Sets the offset of the Dtk_Annotation
     //! \brief The Offset is used to process bounding frames.
     //! \param inOffset The offset
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
     //! \brief Sets the annotation angle using the annotation base.
     //! \param inRotationAngle  The rotation angle to be set
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &inRotationAngle);
 
     //! \brief Processes internal annotation placement - internal use only -
     //! \return dtkNoError if OK
     Dtk_ErrorStatus ProcessTextsPlacement() ;
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo) ;
};
 
//! \ingroup draw
//! \class Dtk_Grid
//! \brief Represents the grids
//!  <P> <B> Example: </B>  </P>
//!  <P> Here is a grid with 3 minor lines per major in U and V directions </P>
//! \image html Dtk_Grid.png
//! \SmartPtr{Dtk_GridPtr}
class Dtk_Grid : public Dtk_Annotation //Dtk_2dEntity
{
protected:
    struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
    enum
    {
        _typeID = DTK_TYPE_GRID
    };
 
public:
    enum ShowLabelOption
    {
        None,
        ParallelToView,
        Always
    };
 
    enum OriginReferenceOption
    {
        Absolute,
        WCS,
        Local
    };
 
protected:
    //! \BaseConstructor
     Dtk_Grid();
 
    //! \sa Create(const Dtk_Grid &)
    Dtk_Grid( const Dtk_Grid &grid );    
    Dtk_Grid( Dtk_Grid &&grid ) DTK_NOEXCEPT;    
    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:
    friend class Dtk_SmartPtr<Dtk_Grid>;
 
 
    Dtk_Double64 GetConceptionUnit() const;
    Dtk_bool GetDrawLabelsInOriginUnitOption() const;
public:
 
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    //! \DtkDynamicCast
    static Dtk_Grid* DtkDynamicCast(Dtk_Object *s);
    //! \brief CreateCopy{in}
    static Dtk_GridPtr Create( const Dtk_Grid& in );
 
    //! \brief Calls full featured constructor to allocate a new object.
    //! \param inUVBBox Bounding box of the grid
    //! \param inUSpacing U spacing between lines
    //! \param inVSpacing v spacing between lines
    //! \param inUMinorPerMajor U number of minor lines per major lines
    //! \param inVMinorPerMajor V number of minor lines per major lines
    //! \param inLineColor Grid Color
    //! \param inMajorLineStyle Major lines style
    //! \param inMinorLineStyle Minor lines style
    //! \param inMajorLineWidth Major lines width
    //! \param inMinorLineWidth Minor lines width
    //! \return The created Dtk_GridPtr
    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);
 
    //! \brief Gets the 2d bbox of the grid
    //! \return the bbox
    Dtk_Oriented2dBBox &GetBoundingBox() const;
 
    //! \brief Gets U spacing between lines
    //! \return U spacing
    Dtk_Double64 GetUSpacing() const;
 
    //! \brief Gets V spacing between lines
    //! \return V spacing
    Dtk_Double64 GetVSpacing() const;
 
    //! \brief Gets U minor lines per major
    //! \return U number of minor lines per major
    Dtk_Int32 GetUMinorPerMajor() const;
 
    //! \brief Gets V minor lines per major
    //! \return V number of minor lines per major
    Dtk_Int32 GetVMinorPerMajor() const;
 
    //! \brief Gets the major line font line type
    //! \return the major line font line type
    Dtk_FontLineType GetMajorLineStyle() const;
 
    //! \brief Gets the minor line font line type
    //! \return the minor line font line type
    Dtk_FontLineType GetMinorLineStyle() const;
 
    //! \brief Gets the major line width
    //! \return the major line width
    Dtk_Double64 GetMajorLineWidth() const;
 
    //! \brief Gets the minor line width
    //! \return the minor line width
    Dtk_Double64 GetMinorLineWidth() const;
 
    //! \brief Gets the display grid option
    //! \return the display grid option
     //! \return DTK_TRUE if grid is visible
     //! \return DTK_FALSE if grid is invisible
     Dtk_bool GetDisplayGridOption() const;
 
    //! \brief Gets the display on top option
    //! \return the display on top option
     //! \return DTK_TRUE if grid stays on top of other entities,
     //! \return DTK_FALSE if it is hidden by other entities displayed in front of it
     Dtk_bool GetDisplayOnTopOption() const;
 
    //! \brief Gets the display major lines option
    //! \return the display major lines option
     //! \return DTK_TRUE if displays major lines with style
     //! \return DTK_FALSE if all major and minor have same style
     Dtk_bool GetDisplayMajorLinesOption() const;
 
    //! \brief Gets the display show labels option
    //! \return the display show labels option
    //! \returns an enum indicating wether labels are hidden(None),
    //! \stays parallel to screen(ParallelToView) or displayed in grid plane(Always)
    ShowLabelOption GetDisplayShowLabelOption() const;
 
    //! \brief Gets the display origin reference option
    //! \return the display origin reference option
    //! \returns an enum indicating wether the origin of the grid is given in Absolute coordinates (Absolute),
    //! \in World Coordinate System (WCS) coordinates or in Local coordinates (Local)
    OriginReferenceOption GetDisplayOriginReferenceOption() const;
 
 
    //! \return The type of the entity type - DTK_TYPE_GRID-
    type_detk get_type_detk() const { return DTK_TYPE_GRID; }
 
    //! \brief Draws Labels in millimeters or in origin unit
    //! \param inVal : Draws Labels in millimeters (DTK_FALSE) or in origin unit (DTK_TRUE)
    //! \remark : by default labels will be drawn in millimeters
    void DrawLabelsInOriginUnit(const Dtk_bool&inVal);
 
    //! \brief Processes all the Dtk_Annotation anchor points.
    //! \param outTabPnts The resulting anchor point array.
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetAnchorPoints(
        Dtk_pnt(&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
    //! \brief Sets the Dtk_Annotation anchor point.
    //! \param inNewLocation The new location point.
    //! \param inLocationAnchorType The anchor type related to the new location.
    //! \return dtkNoError if OK
    Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
                                   const Dtk_anchor_type &inLocationAnchorType);
 
    //! \brief Sets the location point of the Dtk_Annotation
    //! \brief The location point is related to the anchor type
    //! \param inLocation the location point
    //! \return dtkNoError if OK
    Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
    //! \brief Sets the offset of the Dtk_Annotation
    //! \brief The Offset is used to process bounding frames.
    //! \param inOffset The offset
    //! \return dtkNoError if OK
    Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
    ////! \brief Sets the annotation angle using the annotation base.
    ////! \param inRotationAngle  The rotation angle to be set
    ////! \return dtkNoError if OK
    //Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &inRotationAngle);
 
    ////! \brief Processes internal annotation placement - internal use only -
    ////! \return dtkNoError if OK
    //Dtk_ErrorStatus ProcessTextsPlacement();
 
    //! \Transform{inTransfo}
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    //! \brief Retrieves the Dtk_Grid geometries.
    //! \return All the associated geometries asked.
    Dtk_tab< Dtk_EntityPtr > GetGeometries() const;
 
    //! \brief Retrieves the Dtk_Grid labels.
    //! \return All the labels as composite texts.
    Dtk_CompositeText GetLabelsAsCompositeTexts() const;
};
 
 
 
//! \ingroup draw
//! \class Dtk_Dimension
//! \brief This is the general dimension
//! \SmartPtr{Dtk_DimensionPtr}
class Dtk_Dimension : public Dtk_2dEntity
{
public:
     enum DimensionTypeEnum {
          //! \image html LinearDimension.png
          LinearDimension = 0,
          //! \image html AngularDimension.png
          AngularDimension,
          //! \image html CurvilinearDimension.png
          CurvilinearDimension,
          //! \image html DiameterDimension.png
          DiameterDimension,
          //! \image html LinearDiameterDimension.png
          LinearDiameterDimension,
          //! \image html RadiusDimension.png
          RadiusDimension,
          //! \image html LinearRadiusDimension.png
          LinearRadiusDimension,
          //! \image html CumulatedDimension.png
          CumulatedDimension,
          //! \image html ChamferDimension.png
          ChamferDimension,
          //! \image html LinearDimension.png
          DistanceDimension,
          //! \image html LinearDimension.png
          LengthDimension
     };
     enum BasicDimensionTypeEnum {
          BasicTypeNone = 0,
          BasicTypeRectangle,
          BasicTypeCircle,
          BasicTypeFlagRight,
          BasicTypeOblong
     };
 
     enum ShowDualValueTypeEnum {
          ShowDualValueNone = 0,
          ShowDualValueBelow,
          ShowDualValueFractional,
          ShowDualValueSydeBySide
     };
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_DIMENSION
     };
     ~Dtk_Dimension();
     //! \sa Create()
     Dtk_Dimension();
     //! \sa Create(const Dtk_Dimension &)
     Dtk_Dimension(const Dtk_Dimension &in);
     Dtk_Dimension( Dtk_Dimension&& in ) DTK_NOEXCEPT;
     Dtk_Dimension(const DimensionTypeEnum &inDimensionType,
          Dtk_CompositeText inTexts);
    inline virtual Dtk_Object* Clone() { return new Dtk_Dimension(*this); }
 
private:
     friend class Dtk_SmartPtr<Dtk_Dimension>;
public:
     // Downcasting
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_Dimension* DtkDynamicCast(Dtk_Object *s);
 
     //! \CreateBase
     static Dtk_DimensionPtr Create();
 
     //! \CreateCopy{in}
     static Dtk_DimensionPtr Create(const Dtk_Dimension &in);
 
     //! \brief Calls full featured constructor to allocate a new object.
     //! \param inDimensionType The Dtk_Dimension type
     //! \param inTexts The Dtk_Dimension texts
     static Dtk_DimensionPtr Create(const DimensionTypeEnum &inDimensionType,
          Dtk_CompositeText inTexts);
 
     //! \brief Adds a leader with an extension line to the Dtk_Dimension
     //! \param inLeader the leader to add
     //! \param inExtensionLine The additional extension line - optional -
     //! \return DtkNoError if OK.
     //! \remark This function is used for backward compatibility only.
     //! \sa AddLeaderWithExtensionLine(const Dtk_LeaderPtr &, const Dtk_tab<Dtk_pnt> &)
     //! \deprecated Use Dtk_ErrorStatus Dtk_Leader::SetExtensionLine(const Dtk_PolylinePtr &) and Dtk_ErrorStatus AddLeader( const Dtk_LeaderPtr& leader ) instead
     SetAsDeprecated( "2025.4", "Use Dtk_ErrorStatus Dtk_Leader::SetExtensionLine(const Dtk_PolylinePtr &) and Dtk_ErrorStatus AddLeader( const Dtk_LeaderPtr& leader ) instead" )
     Dtk_ErrorStatus AddLeaderWithExtensionLine_Deprecated254(
          const Dtk_LeaderPtr &inLeader,
          Polyline_detk* const &inExtensionLine);
 
     //! \brief Adds a leader with an extension line to the Dtk_Dimension.
     //! \param inLeader the leader to add.
     //! \param inExtensionLinePnts The additional extension line - optional - in points array form.
     //! \return DtkNoError if OK.
     //! \deprecated Use Dtk_ErrorStatus Dtk_Leader::SetExtensionLine(const Dtk_PolylinePtr &) and Dtk_ErrorStatus AddLeader( const Dtk_LeaderPtr& leader ) instead
     SetAsDeprecated( "2025.4", "Use Dtk_ErrorStatus Dtk_Leader::SetExtensionLine(const Dtk_PolylinePtr &) and Dtk_ErrorStatus AddLeader( const Dtk_LeaderPtr& leader ) instead" )
     Dtk_ErrorStatus AddLeaderWithExtensionLine_Deprecated254(const Dtk_LeaderPtr &inLeader,
          const Dtk_tab<Dtk_pnt> &inExtensionLinePnts);
     
     //! \brief Adds a leader to the Dtk_Dimension.
     //! \param inLeader The leader to add.
     //! \return DtkNoError if OK.
     Dtk_ErrorStatus AddLeader( const Dtk_LeaderPtr& leader );
 
     //! \return The type of the entity type - DTK_TYPE_DIMENSION -.
     type_detk get_type_detk() const
     {
          return DTK_TYPE_DIMENSION;
     }
 
     //! \brief Adds text to the Dtk_Dimension text.
     //! \param inText Text to be added.
     //! \return DtkNoError if OK.
     Dtk_ErrorStatus AddText( Dtk_Text inText);
 
     //! \brief Retrieves the Dtk_Dimension text - read only -.
     //! \return The Dtk_Dimension text.
     const Dtk_CompositeText& GetTexts() const;
 
     //! \brief Retrieves the leaders number - read only -.
     //! \return The Dtk_Dimension leaders number.
     Dtk_Size_t GetNumLeaders() const;
 
     //! \brief Retrieves the extension lines number - read only -.
     //! \return The number of Dtk_Dimension leaders having an extension line.
     //! \deprecated Use Dtk_LeaderPtr GetNumLeaders() and Dtk_ErrorStatus Dtk_Leader::GetExtensionLine() instead
     SetAsDeprecated( "2025.4", "Use Dtk_LeaderPtr GetNumLeaders() and Dtk_ErrorStatus Dtk_Leader::GetExtensionLine() instead" )
     Dtk_Size_t GetNumExtensionLines_Deprecated254() const;
 
     //! \brief Retrieves the ith leader - read only -.
     //! \param inPos The leader index.
     //! \return The ith leader.
     Dtk_LeaderPtr GetLeader(const Dtk_Size_t &inPos) const;
 
     //! \brief Retrieves the ith extension line found in the leaders - read only -.
     //! \param inPos The extension line index.
     //! \return The ith extension line as a Dtk_CurvePtr.
     //! \deprecated Use Dtk_LeaderPtr GetLeader(const Dtk_Size_t &inPos) and Dtk_ErrorStatus Dtk_Leader::GetExtensionLine() instead
     SetAsDeprecated( "2025.4", "Use Dtk_LeaderPtr GetLeader(const Dtk_Size_t &inPos) and Dtk_ErrorStatus Dtk_Leader::GetExtensionLine() instead" )
     Dtk_CurvePtr GetExtensionLineAsCurve_Deprecated254(const Dtk_Size_t &inPos) const;
 
     //! \brief Retrieves the Dtk_Dimension type - read only -.
     //! \return The Dtk_Dimension type.
     DimensionTypeEnum GetDimensionType() const;
 
     //! \brief Converts the ith extension line found in the leaders into geometrical elements.
     //! \param inExtLinePos The extension line index.
     //! \param outGeomsArray The geometrical elements array to populate.
     //! \return dtkErrorNullPointer if there is less than [inExtLinePos + 1] extension lines, dtkNoError otherwise.
     //! \deprecated Use Dtk_LeaderPtr GetLeader(const Dtk_Size_t &inPos) and Dtk_ErrorStatus Dtk_Leader::GetExtensionLine() instead
     SetAsDeprecated( "2025.4", "Use Dtk_LeaderPtr GetLeader(const Dtk_Size_t &inPos) and Dtk_ErrorStatus Dtk_Leader::GetExtensionLine() instead" )
     Dtk_ErrorStatus ConvertExtensionLineToGeometries_Deprecated254(
          const Dtk_Size_t &inExtLinePos,
          Dtk_tab<Dtk_CurvePtr> &outGeomsArray) const;
 
     //! \brief Gets the extra geometrical elements number - read only -.
     //! \return The extra geometrical elements number.
     Dtk_Size_t GetNumExtraGeometries() const;
 
     //! \brief Gets the ith extra geometrical element - read only -
     //! \param inPos The extra geometrical element index.
     //! \return The extra geometrical element.
     Dtk_CurvePtr GetExtraGeometryAsCurve(const Dtk_Size_t &inPos) const;
 
    //! \brief Set the Dtk_Dimension Basic status type - set only -.
    //! \sa SetBasicDimensionType()
    void SetBasicDimensionType(const BasicDimensionTypeEnum& inBasicDimensionTypeEnum) const;
 
    //! \brief Get the Dtk_Dimension Basic status type with its Geometries definition- get only -.
    //! \return The Dtk_Dimension basic status type.
    //! \sa GetBasicDimensionType()
    BasicDimensionTypeEnum& GetBasicDimensionType() const ;
 
    //! \brief Set the Dtk_Dimension Basic status type with its Geometries definition- set only -.
    //! \sa SetBasicDimensionType()
    void SetBasicDimensionType(const BasicDimensionTypeEnum& inBasicDimensionTypeEnum, Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements) const;
 
    //! \brief Get the Dtk_Dimension Basic status type - get only -.
    //! \return The Dtk_Dimension basic status type.
    //! \sa GetBasicDimensionType()
    BasicDimensionTypeEnum& GetBasicDimensionType(Dtk_tab< Dtk_CurvePtr >& inRelatedGeomElements) const ;
 
     //! \brief Retrieves the Dtk_Dimension Basic status type - read only -.
     //! \return The Dtk_Dimension basic status type.
     //! \sa BasicDimensionType()
     const BasicDimensionTypeEnum& BasicDimensionType() const;
 
     //! \brief Retrieves the Dtk_Dimension Basic status type - get/set -.
     //! \return The Dtk_Dimension basic status type.
     //! \sa BasicDimensionType() const
     BasicDimensionTypeEnum& BasicDimensionType();
 
     //! \brief Retrieves the Dtk_Dimension show dual value type - read only -.
     //! \return The Dtk_Dimension show dual type such as Below, Fractional, or Side-by-Side.
     //! \sa ShowDualValueType() const
     const ShowDualValueTypeEnum& ShowDualValueType() const;
 
     //! \brief Retrieves the Dtk_Dimension show dual value type - get/set -.
     //! \return The Dtk_Dimension show dual type such as Below, Fractional, or Side-by-Side.
     //! \sa ShowDualValueType()
     ShowDualValueTypeEnum& ShowDualValueType();
 
     Dtk_ErrorStatus GetTextVerticalOffSet(double& outOffSet);
     Dtk_ErrorStatus GetTextRefPoint(Dtk_pnt& outRefPnt);
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    //! \brief Tells if the Dtk_Dimension is a Fake one or not.
    //! \return DTK_TRUE if it's a fake Dimension, DTK_FALSE else.
    //! \sa SetFakeDimensionStatus()
    Dtk_bool IsFakeDimension() const;
 
    //! \brief Sets the Fake Dimension Status.
    //! \param inIsFakeDimension DTK_TRUE if it's a fake Dimension, DTK_FALSE else.
    //! \sa IsFakeDimension()
    void SetFakeDimensionStatus(const Dtk_bool inIsFakeDimension);
 
     //! \brief Set the Dtk_Dimension frame information - get/set -
     //! \return The Dtk_Dimension frame type
     //! \sa FrameType() const
     void SetFrameType( const Dtk_frame_type& inFrameType, Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements);
 
     //! \brief Retrieves the Frame - read only -
     //! \param outFrame The frame
     //! \sa FrameType() const
     void GetFrame(Dtk_Frame& outFrame) const;
 
 
     //! \brief Remove leader-
     void ClearLeader();
 
};
 
//! \ingroup draw
//! \class Dtk_ReferenceBlock
//! \image html Dtk_ReferenceBlock.png
//! \brief This is the Dtk_ReferenceBlock Class.\n
//! It is part of the Dtk_ReferenceFrame entity.
//! \SmartPtr{Dtk_ReferenceBlockPtr}
class Dtk_ReferenceBlock : public Dtk_Object
{
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_REFERENCE
     };
     //! \sa Create( const Dtk_Oriented2dBBox& , const Dtk_Oriented2dBBox& )
    Dtk_ReferenceBlock(const Dtk_Oriented2dBBox& inInnerBBox,
        const Dtk_Oriented2dBBox& inOuterBBox);
 
     //! \sa Create( const Dtk_ReferenceBlock & )
     Dtk_ReferenceBlock(const Dtk_ReferenceBlock &in);
     Dtk_ReferenceBlock( Dtk_ReferenceBlock&& in ) DTK_NOEXCEPT;
     ~Dtk_ReferenceBlock();
 
     //! \DtkInternal
     void _ConcatenateMaterialModifierToText(const Dtk_Size_t &inReferencePos,
          const DTK_FDT_MODIFIER &inMaterialModifier);
     //! \DtkInternal
     void _ReplaceFirstMaterialModifer(const Dtk_Size_t &inReferencePos,
          const DTK_FDT_MODIFIER &inMaterialModifier);
    inline virtual Dtk_Object* Clone() { return new Dtk_ReferenceBlock(*this); }
 
private:
     friend class Dtk_SmartPtr<Dtk_ReferenceBlock>;
public:
 
     //! \brief Add a reference to the Dtk_ReferenceBlock.
     //! \param inReferenceLabel The reference label.
     //! \param inMaterialModifier The reference material modifier.
     //! \param inLinkedFdt The FDT to be linked - NULL by default -.
     //! \return DtkNoError if OK.
     Dtk_ErrorStatus AddReference( Dtk_string inReferenceLabel,
          const DTK_FDT_MODIFIER &inMaterialModifier = DTK_FDT_MODIFIER_NONE,
          const Dtk_FdtPtr &inLinkedFdt = NULL);
 
     //! \brief Add a reference to the Dtk_ReferenceBlock.
     //! \param inFullTextWithMaterialCondition The reference label.\n May contain also material modifier.
     //! \param inLinkedFdt The FDT to be linked - NULL by default -.
     //! \return DtkNoError if OK.
     Dtk_ErrorStatus AddReference( Dtk_string inFullTextWithMaterialCondition,
        const Dtk_FdtPtr &inLinkedFdt);
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_ReferenceBlock* DtkDynamicCast(Dtk_Object *s);
 
//   //! \DtkInternal
//   void _PropagateOrientation(const Dtk_dir &inXAxis, const Dtk_dir &inYAxis);
 
     //! \brief Calls full featured constructor to allocate a new object.
     static Dtk_ReferenceBlockPtr Create(
        const Dtk_Oriented2dBBox& inInnerBBox,
        const Dtk_Oriented2dBBox& inOuterBBox);
 
     //! \CreateCopy{in}
     static Dtk_ReferenceBlockPtr Create(const Dtk_ReferenceBlock &in);
 
     //! \brief Full featured constructor.
     //! \param inFullTextWithMaterialCondition The Transformation Matrix
     //! \param inLinkedFdt The FDT to be linked.
     //! \return the created Dtk_ReferenceBlockPtr
     //static Dtk_ReferenceBlockPtr Create(
     //   const Dtk_Text &inFullTextWithMaterialCondition,
     //   const Dtk_FdtPtr &fdt);
     //
     ////! \brief Full featured constructor with one first reference.
     ////! \param inLabel The first reference label
     ////! \param inMaterialModifier The first reference material modifier.
     ////! \param inLinkedFdt The FDT to be linked.
     ////! \return the created Dtk_ReferenceBlockPtr
     //static Dtk_ReferenceBlockPtr Create(const Dtk_Text &inLabel,
     //   const DTK_FDT_MODIFIER &inMaterialModifier = DTK_FDT_MODIFIER_NONE,
     //   const Dtk_FdtPtr &inLinkedFdt = Dtk_FdtPtr(NULL));
 
     //! \brief Retrieves the ith reference label - read only -.
     //! \param inReferencePos The reference index
     //! \return the ith reference label
     //! \sa GetReferenceLabel(const Dtk_Size_t &)
     const Dtk_string& GetReferenceLabel(const Dtk_Size_t &inReferencePos) const;
 
     //! \brief Retrieves the material modifier related to the ith reference.
     //! \param inReferencePos The reference index.
     //! \return the related material modifier.
     DTK_FDT_MODIFIER GetMaterialModifier(const Dtk_Size_t &inReferencePos) const;
 
     //! \brief Retrieves the Linked Fdt
     //! \return The linked Fdt
     Dtk_FdtPtr GetLinkedtFdt(const Dtk_Size_t &inReferencePos) const;
 
     //! \brief Converts the Dtk_ReferenceBlock into a Dtk_string - used for Dtk_Symbol conversion -
     //! \return The converted Dtk_string
     Dtk_string ConvertToDtk_String() const;
 
     //! \brief Sets the Dtk_ReferenceBlock anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \param inOffSet For internal use only.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType=DTK_ANCHOR_BOTTOM_LEFT,
          const Dtk_Double64 &inOffSet = 0.0);
 
     //! \brief Processes all the Dtk_ReferenceBlock anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \param inOffSet - internal use only -.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPoints)[DTK_NB_ANCHOR_TYPES],
          const Dtk_Double64 &inOffSet = 0.0) const;
 
     //! \brief Retrieves the references number.
     //! \return The number of references included into the Dtk_ReferenceBlock.
     Dtk_Size_t GetNumReferences() const;
 
     //! \brief Translates the  Dtk_ReferenceBlock - internal use only -.
     //! \param inTranslationDir the translation vector.
     void Translate(const Dtk_dir &inTranslationDir);
 
    //! \Transform{inTransfo}
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    Dtk_Oriented2dBBox GetOuterBoundingBox() const;
 
     //! \brief Set the outer Bounding Box.
    //! \param inOuterBBox The outer Bounding Box.
    void SetOuterBoundingBox(const Dtk_Oriented2dBBox& inOuterBBox) const;
 
 
    //! \brief Set the inner Bounding Box.
    //! \param inInnerBBox The inner Bounding Box.
    void SetInnerBoundingBox(const Dtk_Oriented2dBBox& inInnerBBox);
 
    Dtk_Oriented2dBBox GetInnerBoundingBox() const;
 
};
 
//! \ingroup draw
//! \class Dtk_ReferenceFrame
//! \image html Dtk_ReferenceFrame.png
//! \brief This is the Reference Frame Class.\n
//! It is part of the Dtk_ToleranceSpecification entity.\n
//! It's basically composed by one - or more - Dtk_ReferenceBlock.
//! \SmartPtr{Dtk_ReferenceFramePtr}
class Dtk_ReferenceFrame : public Dtk_Object
{
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_REFERENCE_FRAME
     };
 
 
     //! \sa Create()
     Dtk_ReferenceFrame();
 
     //! \sa Create(const Dtk_ReferenceFrame &)
     Dtk_ReferenceFrame(const Dtk_ReferenceFrame &s);
     Dtk_ReferenceFrame( Dtk_ReferenceFrame&& in ) DTK_NOEXCEPT;
 
     //! \sa Create(const Dtk_ReferenceBlockPtr &)
     Dtk_ReferenceFrame(const Dtk_ReferenceBlockPtr &ref);
     ~Dtk_ReferenceFrame();
    inline virtual Dtk_Object* Clone() { return new Dtk_ReferenceFrame(*this); }
private:
     friend class Dtk_SmartPtr<Dtk_ReferenceFrame>;
 
public:
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_ReferenceFrame* DtkDynamicCast(Dtk_Object *s);
 
     //! \CreateBase
     static Dtk_ReferenceFramePtr Create();
 
     //! \CreateCopy{in}
     static Dtk_ReferenceFramePtr Create(const Dtk_ReferenceFrame &in);
 
     //! \brief Full featured constructor with one first reference block.
     //! \param inFirstReferenceBlock The first reference block
     //! \return the created Dtk_ReferenceFramePtr
     static Dtk_ReferenceFramePtr Create(
          const Dtk_ReferenceBlockPtr & inFirstReferenceBlock);
 
     //! \brief Add a reference block to the Dtk_ReferenceFrame.
     //! \param inReferenceBlock The reference block to add
     //! \return DtkNoError if OK.
     Dtk_ErrorStatus AddReferenceBlock(
          const Dtk_ReferenceBlockPtr & inReferenceBlock);
 
//   //! \DtkInternal
//   void _PropagateOrientation(const Dtk_dir &inXAxis, const Dtk_dir &inYAxis);
 
     //! \brief Retrieves the number of reference blocks - read only -.
     //! \return The number of reference blocks.
     Dtk_Size_t GetNumReferences() const;
 
     //! \brief Processes all the Dtk_ReferenceFrame anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \param inOffSet - internal use only -.
     //! \return DtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_Double64& inOffSet = 0.0) const;
 
     //! \brief Sets the Dtk_ReferenceFrame anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \param inOffSet For internal use only.
     //! \return DtkNoError if OK
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType,
          const Dtk_Double64 &inOffSet = 0.0);
 
     //! \brief Retrieves the ith reference block - get/set -.
     //! \param inReferencePos The reference block index
     //! \return The inReferencePos'th reference block.
     //! \exception Dtk_OutOfRangeType Dtk_Exception is raised if
     //! the inReferencePos parameter is invalid
     Dtk_ReferenceBlockPtr& Reference(const Dtk_Size_t &inReferencePos);
 
     //! \brief Retrieves the ith reference blocks - read only -.
     //! \param inReferencePos The reference block index
     //! \return The inReferencePos'th reference block.
     //! \exception Dtk_OutOfRangeType Dtk_Exception is raised if
     //! the inReferencePos parameter is invalid
     const Dtk_ReferenceBlockPtr& Reference(
          const Dtk_Size_t &inReferencePos) const;
 
     //! \brief Retrieves the first reference block - get/set -.
     //! \return The first reference block.
     //! \sa FirstReference() const
     Dtk_ReferenceBlockPtr& FirstReference();
 
     //! \brief Retrieves the first reference block - read only -.
     //! \return The first reference block.
     //! \sa FirstReference()
     const Dtk_ReferenceBlockPtr& FirstReference() const;
 
     //! \brief Retrieves the second reference block - get/set -.
     //! \return The second reference block.
     //! \sa FirstReference() const
     Dtk_ReferenceBlockPtr& SecondReference();
 
     //! \brief Retrieves the second reference block - read only -.
     //! \return The second reference block.
     //! \sa FirstReference()
     const Dtk_ReferenceBlockPtr& SecondReference() const;
 
     //! \brief Retrieves the third reference block - get/set -.
     //! \return The third reference block.
     //! \sa FirstReference() const
     Dtk_ReferenceBlockPtr& ThirdReference();
 
     //! \brief Retrieves the third reference block - read only -.
     //! \return The third reference block.
     //! \sa FirstReference()
     const Dtk_ReferenceBlockPtr& ThirdReference() const;
 
    void Translate(const Dtk_dir& inTranslationDir);
 
    Dtk_ErrorStatus GetOuterBoundingBox(Dtk_Oriented2dBBox& outOuterBBox) const;
};
 
//! \ingroup draw
//! \class Dtk_ToleranceSpecification
//! \image html Dtk_ToleranceSpecification.png
//! \brief This is the geometrical tolerance specification.\n
//! It is part of the Dtk_ToleranceSpecificationContainer.\n
//! It may contain a Dtk_ReferenceFrame and/or Dtk_FCFFeatureIndicator.
//! \SmartPtr{Dtk_ToleranceSpecificationPtr}
class Dtk_ToleranceSpecification : public Dtk_Object
{
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_TOL_SPEC
     };
     //! \sa Create()
     Dtk_ToleranceSpecification();
     //! \sa Create( Dtk_Text, const Dtk_ReferenceFramePtr &)
     Dtk_ToleranceSpecification( Dtk_Text inFullTextWithMaterialCondition,
          const Dtk_ReferenceFramePtr
          &inReferenceFrame = Dtk_ReferenceFrame::Create());
 
     //! \sa Create( const Dtk_ToleranceSpecification & )
     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:
     friend class Dtk_SmartPtr<Dtk_ToleranceSpecification>;
public:
     // Downcasting
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_ToleranceSpecification* DtkDynamicCast(Dtk_Object *s);
 
     //! \CreateBase
     static Dtk_ToleranceSpecificationPtr Create();
 
     //! \brief Calls full featured constructor to allocate a new object.
     //! \param inFullTextWithMaterialCondition A full text string containing the main value AND the optional material modifier.
     //! \param inReferenceFrame The optional reference frame.
     //! \return the created Dtk_ReferenceFramePtr
     static Dtk_ToleranceSpecificationPtr Create(
          Dtk_Text inFullTextWithMaterialCondition,
          const Dtk_ReferenceFramePtr &inReferenceFrame = Dtk_ReferenceFrame::Create());
 
     //! \CreateCopy{in}
     static Dtk_ToleranceSpecificationPtr Create( const Dtk_ToleranceSpecification &in );
 
     //! \brief Retrieves the reference blocks number - read only -.\n
     //! This is a shortcut without using Dtk_ReferenceFrame object.
     //! \return The reference blocks number.
     //! \sa Dtk_ReferenceFrame::GetNumReferences()
     Dtk_Size_t GetNumReferences() const;
 
     //! \brief Retrieves the ith reference block - get/set -.\n
     //! This is a shortcut without using Dtk_ReferenceFrame object.
     //! \param inReferencePos the reference block index.
     //! \return The ith reference block.
     //! \exception Dtk_NullPointerType Dtk_Exception is raised if
     //! there isn't any Dtk_ReferenceFrame into the Dtk_ToleranceSpecification object
     //! \sa Reference() const
     //! \sa Dtk_ReferenceFrame::Reference()
     Dtk_ReferenceBlockPtr& Reference( const Dtk_Size_t &inReferencePos );
 
     //! \brief Retrieves the ith reference block - get/set -.\n
     //! This is a shortcut without using Dtk_ReferenceFrame object.
     //! \param inReferencePos the reference block index.
     //! \return The ith reference block.
     //! \exception Dtk_NullPointerType Dtk_Exception is raised if
     //! there isn't any Dtk_ReferenceFrame into the Dtk_ToleranceSpecification object
     //! \sa Reference()
     //! \sa Dtk_ReferenceFrame::Reference() const
     const Dtk_ReferenceBlockPtr& Reference( const Dtk_Size_t &inReferencePos ) const;
 
     //! \brief Retrieves the first reference block - get/set -.\n
     //! This is a shortcut without using Dtk_ReferenceFrame object.
     //! \return The first reference block.
     //! \exception Dtk_NullPointerType Dtk_Exception is raised if
     //! there isn't any Dtk_ReferenceFrame into the Dtk_ToleranceSpecification object
     //! \sa FirstReference() const
     //! \sa Dtk_ReferenceFrame::FirstReference()
     Dtk_ReferenceBlockPtr &FirstReference();
 
     //! \brief Retrieves the first reference block - read only -.\n
     //! This is a shortcut without using Dtk_ReferenceFrame object.
     //! \return The first reference block.
     //! \exception Dtk_NullPointerType Dtk_Exception is raised if
     //! there isn't any Dtk_ReferenceFrame into the Dtk_ToleranceSpecification object
     //! \sa FirstReference()
     //! \sa Dtk_ReferenceFrame::FirstReference() const
     const Dtk_ReferenceBlockPtr& FirstReference() const;
 
     //! \brief Retrieves the second reference block - get/set -.\n
     //! This is a shortcut without using Dtk_ReferenceFrame object.
     //! \return The second reference block.
     //! \exception Dtk_NullPointerType Dtk_Exception is raised if
     //! there isn't any Dtk_ReferenceFrame into the Dtk_ToleranceSpecification object
     //! \sa SecondReference() const
     //! \sa Dtk_ReferenceFrame::SecondReference()
     Dtk_ReferenceBlockPtr& SecondReference();
 
     //! \brief Retrieves the second reference block - read only -.\n
     //! This is a shortcut without using Dtk_ReferenceFrame object.
     //! \return The second reference block.
     //! \exception Dtk_NullPointerType Dtk_Exception is raised if
     //! there isn't any Dtk_ReferenceFrame into the Dtk_ToleranceSpecification object
     //! \sa SecondReference()
     //! \sa Dtk_ReferenceFrame::SecondReference() const
     const Dtk_ReferenceBlockPtr& SecondReference() const;
 
     //! \brief Retrieves the third reference block - get/set -.\n
     //! This is a shortcut without using Dtk_ReferenceFrame object.
     //! \return The third reference block.
     //! \exception Dtk_NullPointerType Dtk_Exception is raised if
     //! there isn't any Dtk_ReferenceFrame into the Dtk_ToleranceSpecification object
     //! \sa ThirdReference() const
     //! \sa Dtk_ReferenceFrame::ThirdReference()
     Dtk_ReferenceBlockPtr& ThirdReference();
 
     //! \brief Retrieves the third reference block - read only -.\n
     //! This is a shortcut without using Dtk_ReferenceFrame object.
     //! \return The third reference block.
     //! \exception Dtk_NullPointerType Dtk_Exception is raised if
     //! there isn't any Dtk_ReferenceFrame into the Dtk_ToleranceSpecification object
     //! \sa ThirdReference()
     //! \sa Dtk_ReferenceFrame::ThirdReference() const
     const Dtk_ReferenceBlockPtr& ThirdReference() const;
 
     //! \DtkInternal
     Dtk_Double64 ProcessWidth() const;
 
     //! \DtkInternal
     Dtk_Double64 ProcessHeight() const;
 
 
     //! \brief Explodes the Dtk_ToleranceSpecification into Dtk_CompositeText and
     //! geometrical elements - used for Dtk_Symbol conversion only -
     //! \param outCompositeText Resulting composite text
     //! \param outGeoms Resulting geometrical elements
     //! \return DtkNoError if OK
     Dtk_ErrorStatus Explode(Dtk_CompositeText &outCompositeText,
          Dtk_tab<Dtk_CurvePtr> &outGeoms);
 
     //! \brief Processes all the Dtk_ToleranceSpecification anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \param ignoreadd - internal use only -.
     //! \return DtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_Int32& ignoreadd = 0) const;
 
     //! \brief Processes all the Dtk_ToleranceSpecification anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \param ignoreadd - internal use only -.
     //! \return DtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_Int32& ignoreadd=0);
 
 
     //! \brief Retrieve the Dtk_ToleranceSpecification Outer Bounding Box.
     //! \param outOuterBBox The resulting Outer Bounding Box.
     //! \param inIncludeReferenceFrame DTK_TRUE to include the reference frame Bounding box - DTK_TRUE by default -.
     //! \param InIncludeIndicators DTK_TRUE to include the indicatorBounding boxes - DTK_TRUE by default -.
     //! \return DtkNoError if OK
     Dtk_ErrorStatus GetOuterBoundingBox( Dtk_Oriented2dBBox& outOuterBBox,
                                                   const Dtk_bool inIncludeReferenceFrame = DTK_TRUE,
                                                   const Dtk_bool InIncludeIndicators = DTK_TRUE ) const;
 
     //! \deprecated Use SetMainValue mehod to alter MainValue instead.
    Dtk_ErrorStatus GetInnerBoundingBox(Dtk_Oriented2dBBox& outInnerBBox) const;
 
    Dtk_ErrorStatus GetOuterBoundingBoxWithOutRefFrame(Dtk_Oriented2dBBox& outOuterBBox) const;
 
     //! \brief Sets the Dtk_ToleranceSpecification anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     //! \brief Retrieves the Dtk_ToleranceSpecification text including all modifiers as Dtk_CompositeText - material modifier, etc... - - read only -
     //! \return Dtk_ToleranceSpecification Dtk_CompositeText.
     const Dtk_CompositeText& GetMainValue() const;
 
     //! \brief Sets the Dtk_ToleranceSpecification text including all modifiers - material modifier, etc... -
     void SetMainValue( Dtk_CompositeText inNewMainValue );
 
     //! \brief Retrieves the reference frame- read only -
     //! \return The reference frame
     //! \sa ReferenceFrame()
     const Dtk_ReferenceFramePtr& ReferenceFrame() const;
 
     //! \brief Retrieves the reference frame- get/set -
     //! \return The reference frame
     //! \sa ReferenceFrame() const
     Dtk_ReferenceFramePtr& ReferenceFrame();
 
     //! \brief Adds a feature indicator to the Dtk_ToleranceSpecification.
     //! \param inIndicator the feature indicator to be added.
     void AddIndicator( const Dtk_FCFFeatureIndicatorPtr& inIndicator );
 
     //! \brief Retrieves indicator number - read only -.\n
     //! \return The indicator number.
     Dtk_Size_t GetNumIndicators() const;
 
     //! \brief Retrieves the ith indicator - get only -.\n
     //! \param inIndicatorIndex the indicator index.
     //! \return The ith indicator.
     //! \sa GetIndicator()
     const Dtk_FCFFeatureIndicatorPtr& GetIndicator( const Dtk_Size_t inIndicatorIndex ) const;
 
     //! \brief Retrieves the ith indicator - get/set -.\n
     //! \param inIndicatorIndex the indicator index.
     //! \return The ith indicator.
     //! \sa GetIndicator() const
     Dtk_FCFFeatureIndicatorPtr& GetIndicator( const Dtk_Size_t inIndicatorIndex );
 
     //! \brief Retrieves the Dtk_ToleranceSpecification material modifier - read only -
     //! \return The material modifier
     DTK_FDT_MODIFIER GetMaterialModifier() const;
 
    //! \brief Tells if the Dtk_ToleranceSpecification has a FreeState Modifier or not - read only -
    //! \return DTK_TRUE if a FreeState modifier is present. DTK_FALSE else
    Dtk_bool HasFreeStateModifier() const;
 
     //! \brief Retrieves the X Axis for the Dtk_ToleranceSpecification - read only -
     //! \return The X Axis
     Dtk_dir GetXAxis() const;
 
     //! \brief Retrieves the Y Axis for the Dtk_ToleranceSpecification - read only -
     //! \return The Y Axis
     Dtk_dir GetYAxis() const;
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     //! \brief Translates the text giving a translation vector
     //! \param inTranslateDir the translation vector
     //! \return dtkNoError if OK
     void Translate(const Dtk_dir &inTranslationDir);
};
 
//! \ingroup draw
//! \class Dtk_GeometricalTolerance
//! \image html Dtk_GeometricalTolerance.png
//! \brief This is the geometrical tolerance.\n
//!  It's basically composed by one - or more - Dtk_ToleranceSpecificationContainer.
//! \SmartPtr{Dtk_GeometricalTolerancePtr} \n
//! \ref geom_tol
class Dtk_GeometricalTolerance : public Dtk_Annotation
{
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_GEOM_TOL
     };
 
     //! \sa Create()
     Dtk_GeometricalTolerance();
     //! \sa Create(const Dtk_GeometricalTolerance &)
     Dtk_GeometricalTolerance(const Dtk_GeometricalTolerance &s);
     Dtk_GeometricalTolerance( Dtk_GeometricalTolerance&& in ) DTK_NOEXCEPT;
    inline virtual Dtk_Object* Clone() { return new Dtk_GeometricalTolerance(*this); }
     ~Dtk_GeometricalTolerance();
private:
     friend class Dtk_SmartPtr<Dtk_GeometricalTolerance>;
public:
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_GeometricalTolerance* DtkDynamicCast(Dtk_Object *s);
 
     //! \return The type of the entity type - DTK_TYPE_GEOM_TOL -
     type_detk get_type_detk() const { return DTK_TYPE_GEOM_TOL; }
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     //! \CreateBase
     static Dtk_GeometricalTolerancePtr Create();
     //! \CreateCopy{in}
     static Dtk_GeometricalTolerancePtr Create( const Dtk_GeometricalTolerance& in );
 
     //! \brief Processes all the Dtk_GeometricalTolerance anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     //! \brief Processes all the Dtk_GeometricalTolerance anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \param inProcessAddtionnalTexts DTK_TRUE if additional texts are included in the bounding box.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_bool& inProcessAddtionnalTexts) const;
 
     //! \brief Sets the Dtk_GeometricalTolerance anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type& inLocationAnchorType);
 
     //! \brief Sets the Dtk_GeometricalTolerance anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \param inProcessAddtionnalTexts DTK_TRUE if additional texts are included in the bounding box.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType,
          const Dtk_bool &inProcessAddtionnalTexts);
 
     //! \brief Sets the location point of the Dtk_GeometricalTolerance
     //! \brief The location point is related to the anchor type
     //! \param inLocation the location point
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
     //! \brief Sets the offset of the Dtk_GeometricalTolerance
     //! \brief The Offset is used to process bounding frames.
     //! \param inOffset The offset
     //! \return dtkNoError if OK
     //! \warning  For internal use only
     Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
     //! \brief Sets the annotation angle using the annotation base.
     //! \param inRotationAngle  The rotation angle to be set
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetRotationAngle(const Dtk_Double64 &inRotationAngle);
 
     //! \brief Retrieves the ith Dtk_ToleranceSpecificationContainer - get/set -
     //! \param inPos tolerance specification container index.
     //! \return the inPos'th Dtk_ToleranceSpecificationContainer
     //! \sa at(const Dtk_Size_t&) const
     Dtk_ToleranceSpecificationContainerPtr &at(const Dtk_Size_t &inPos);
 
     //! \brief Retrieves the ith Dtk_ToleranceSpecificationContainer - get/set -
     //! \param inPos tolerance specification container index.
     //! \return the inPos'th Dtk_ToleranceSpecificationContainer
     //! \sa at(const Dtk_Size_t&)
     Dtk_ToleranceSpecificationContainerPtr &operator[](const Dtk_Size_t &inPos);
 
     //! \brief Retrieves the ith Dtk_ToleranceSpecificationContainer - read only -
     //! \param inPos tolerance specification container index.
     //! \return the inPos'th Dtk_ToleranceSpecificationContainer
     //! \sa at(const Dtk_Size_t&)
     const Dtk_ToleranceSpecificationContainerPtr &at(
          const Dtk_Size_t &inPos) const;
 
     //! \brief Retrieves the ith Dtk_ToleranceSpecificationContainer - read only -
     //! \param inPos tolerance specification container index.
     //! \return the inPos'th Dtk_ToleranceSpecificationContainer
     //! \sa at(const Dtk_Size_t&) const
     const Dtk_ToleranceSpecificationContainerPtr& operator[](
          const Dtk_Size_t &inPos) const;
 
     //! \brief Retrieves the ith Dtk_ToleranceSpecificationContainer - get/set -
     //! \param inPos tolerance specification container index.
     //! \return the inPos'th Dtk_ToleranceSpecificationContainer
     //! \sa at(const Dtk_Size_t&)
     //! \sa GetToleranceSpecificationContainer(const Dtk_Size_t&) const
     Dtk_ToleranceSpecificationContainerPtr& GetToleranceSpecificationContainer(
          const Dtk_Size_t& inPos);
 
     //! \brief Retrieves the ith Dtk_ToleranceSpecificationContainer - read only -
     //! \param inPos tolerance specification container index.
     //! \return the inPos'th Dtk_ToleranceSpecificationContainer
     //! \sa at(const Dtk_Size_t&) const
     //! \sa GetToleranceSpecificationContainer(const Dtk_Size_t&)
     const Dtk_ToleranceSpecificationContainerPtr&
          GetToleranceSpecificationContainer(const Dtk_Size_t &inPos) const;
 
     //! \brief Retrieves the Dtk_ToleranceSpecificationContainer number - read only -
     //! \return The Dtk_ToleranceSpecificationContainer number
     Dtk_Size_t GetToleranceSpecificationContainerNb() const;
 
     //! \brief Adds a Dtk_ToleranceSpecificationContainer to the Dtk_GeometricalTolerance.
     //! \param inTolSpecCont The Dtk_ToleranceSpecificationContainer to be Added.
     //! \return DtkNoError if OK
     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);
 
    //! \brief Sets the lettering color for symbol and references.
    //! \param inLetteringColor  The color to be set
    void SetLetteringColor(const Dtk_RGB &inLetteringColor);
 
    //! \brief Gets the lettering color for symbol and references.
    //! \return the lettering color
    const Dtk_RGB& GetLetteringColor() const ;
 
    //! \brief Sets the frame color .
    //! \param inFrameColor  The color to be set
    void SetFrameColor(const Dtk_RGB &inFrameColor);
 
    //! \brief Gets the frame color .
    //! \return the frame color
    const Dtk_RGB& GetFrameColor() const ;
};
 
//! \ingroup draw
//! \class Dtk_FCFFeatureIndicatorType
//! \brief This is the Feature Indicator.\n
//!  It is part of the Dtk_FCFFeatureIndicator.\n
class Dtk_FCFFeatureIndicatorType
{
public:
     enum Dtk_FCFFeatureIndicatorTypeEnum
     {
          Unknown = 0,
          //! \image html IndicatorTypeDirectionFeature.png
          DirectionFeature,
          //! \image html IndicatorTypeCollectionPlane.png
          CollectionPlane,
          //! \image html IndicatorTypeIntersectionPlane.png
          IntersectionPlane,
          //! \image html IndicatorTypeOrientationPlane.png
          OrientationPlane,
     };
protected:
     Dtk_FCFFeatureIndicatorTypeEnum                   m_Type;
     Dtk_tab< Dtk_CurvePtr >                           m_RelatedGeomElements;
     Dtk_Oriented2dBBox                                m_OuterBBox;
public:
 
     //! \brief Full featured constructor
     //! \param inIndicatorType Feature indicator Type.
     //! \param inOuterBoundingBox Outer Bounding Box.
     //! \param inRelatedGeometricalElts Geometries representing the frame.
     inline Dtk_FCFFeatureIndicatorType( const Dtk_FCFFeatureIndicatorTypeEnum& inIndicatorType,
                                         const Dtk_Oriented2dBBox& inOuterBoundingBox,
                                         Dtk_tab< Dtk_CurvePtr > inRelatedGeometricalElts )
     {
          SetIndicatorTypeData( inIndicatorType,
                                     inOuterBoundingBox,
                                     std::move( inRelatedGeometricalElts ) );
     }
 
     //! \BaseConstructor
     inline Dtk_FCFFeatureIndicatorType()
          : m_Type( Unknown )
     {}
     //! \CopyConstructor{in}
     Dtk_FCFFeatureIndicatorType( const Dtk_FCFFeatureIndicatorType & in );
     //! \MoveConstructor{in}
     Dtk_FCFFeatureIndicatorType( Dtk_FCFFeatureIndicatorType&& in ) DTK_NOEXCEPT;
 
     //! \AssignmentOp{in}
     Dtk_FCFFeatureIndicatorType& operator=( const Dtk_FCFFeatureIndicatorType& in );
     //! \MoveOp{in}
     Dtk_FCFFeatureIndicatorType& operator=( Dtk_FCFFeatureIndicatorType&& in ) DTK_NOEXCEPT;
 
     //! \BaseDestructor
     inline ~Dtk_FCFFeatureIndicatorType(){}
 
     //! \brief Clear elements
     inline void Clear()
     {
          m_Type = Unknown;
          m_RelatedGeomElements.clear();
          m_OuterBBox.Clear();
     }
 
 
     //! \brief Set IndicatorType data.
     //! \param inIndicatorType Feature indicator Type.
     //! \param inOuterBoundingBox Outer Bounding Box.
     //! \param inRelatedGeometricalElts Geometries representing the frame.
     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 );
     }
     //! \brief Retrieves the IndicatorType semantic Type - Read Only -
     //! \return The IndicatorType Type
     inline const Dtk_FCFFeatureIndicatorTypeEnum& GetIndicatorType() const
     {
          return m_Type;
     }
 
     //! \brief Process IndicatorType Related geometries.
     //! \return Always dtkNoError as success.
     Dtk_ErrorStatus CreateGeometries( Dtk_tab< Dtk_CurvePtr >& outGeoms ) const;
 
     //! \brief Retrieves the IndicatorType Outer Bounding Box - basically the related geometries BBox - - Read Only -
     //! \return The IndicatorType Outer Bounding Box
     inline const Dtk_Oriented2dBBox& GetOuterBoundingBox() const
     {
          return m_OuterBBox;
     }
     //! \brief Translates the IndicatorType giving a translation vector
     //! \param inTranslateDir the translation vector
     //! \return dtkNoError if OK
     Dtk_ErrorStatus Translate( const Dtk_dir &inTranslateDir );
 
     //! \brief Applies a transformation matrix to the IndicatorType
     //! \param inTransfo The transformation matrix
     //! \return dtkNoError if OK
     Dtk_ErrorStatus Transform( const Dtk_transfo &inTransfo );
};
 
//! \ingroup draw
//! \class Dtk_FCFFeatureIndicator
//! \image html Dtk_FCFFeatureIndicator.png
//! \brief This is the Feature Indicator.\n
//!  It is part of the Dtk_ToleranceSpecification.\n
//!  It's basically composed of a type, a symbol and a Datum feature identifier.
//! \SmartPtr{Dtk_FCFFeatureIndicator}
class Dtk_FCFFeatureIndicator : public Dtk_Object
{
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> m_Private; // Handle
     enum
     {
          _typeID = DTK_TYPE_SPECIFICATION_INDICATOR
     };
 
     //! \sa Create()
     Dtk_FCFFeatureIndicator();
     //! \sa Create(const Dtk_FCFFeatureIndicator &)
     Dtk_FCFFeatureIndicator( const Dtk_FCFFeatureIndicator &in );
     Dtk_FCFFeatureIndicator( Dtk_FCFFeatureIndicator&& in ) DTK_NOEXCEPT;
 
     //! \sa  Create( Dtk_FCFFeatureIndicatorType, Dtk_Text, Dtk_Text )
     Dtk_FCFFeatureIndicator( Dtk_FCFFeatureIndicatorType inFeatureIndicatorType,
                                    Dtk_Text inSymbol,
                                    Dtk_Text inDatumFeatureIdentifier );
     inline virtual Dtk_Object* Clone()
     {
          return new Dtk_FCFFeatureIndicator( *this );
     }
     ~Dtk_FCFFeatureIndicator();
private:
     friend class Dtk_SmartPtr<Dtk_FCFFeatureIndicator>;
 
public:
     //! \DtkDynamicType
     inline Dtk_Int32 DtkDynamicType( const Dtk_Int32 &inId )
     {
          if( inId == _typeID )
               return 1;
          return Dtk_Object::DtkDynamicType( inId );
     }
     //! \DtkDynamicCast
     static Dtk_FCFFeatureIndicator* DtkDynamicCast( Dtk_Object *s )
     {
          if( s->DtkDynamicType( _typeID ) )
               return static_cast< Dtk_FCFFeatureIndicator* >( s );
          return NULL;
     }
     void Clear();
 
     //! \CreateBase
     static Dtk_FCFFeatureIndicatorPtr Create()
     {
          return new Dtk_FCFFeatureIndicator();
     }
 
     //! \CreateCopy{in}
     static Dtk_FCFFeatureIndicatorPtr Create( const Dtk_FCFFeatureIndicator &in )
     {
          return new Dtk_FCFFeatureIndicator( in );
     }
 
     //! \brief Calls full featured constructor to allocate a new object.
     //! \param inFeatureIndicatorType The FeatureIndicator Type.
     //! \param inSymbol The FeatureIndicator symbol.
     //! \param inDatumFeatureIdentifier The FeatureIndicator Datum feature identifier.
     //! \return the created Dtk_FCFFeatureIndicatorPtr
     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 ) );
     }
 
     //! \brief Processes all the Dtk_FCFFeatureIndicator anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \param inOffSet - internal use only -.
     //! \return DtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints( Dtk_pnt( &outTabPnts )[ DTK_NB_ANCHOR_TYPES ] ) const;
 
     //! \brief Retrieves the DatumFeature Identifier of the Dtk_FCFFeatureIndicator - Read Only -
     //! \return The Dtk_FCFFeatureIndicator DatumFeature Identifier.
     const Dtk_Text& GetDatumFeatureIdentifier() const;
 
     //! \brief Retrieves the Symbol of the Dtk_FCFFeatureIndicator - Read Only -
     //! \return The Dtk_FCFFeatureIndicator Symbol.
     const Dtk_Text& GetSymbol() const;
 
     //! \brief Retrieves the Full Type of the Dtk_FCFFeatureIndicator - Read Only -.
     //! \return The Dtk_FCFFeatureIndicator Dtk_FCFFeatureIndicatorType.
     const Dtk_FCFFeatureIndicatorType& GetFeatureIndicatorType() const;
 
     //! \brief Sets the Dtk_FCFFeatureIndicator anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \return DtkNoError if OK
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType );
 
     //! \brief Translates the Dtk_FCFFeatureIndicator giving a translation vector.
     //! \param inTranslationDir The translation vector.
     //! \return DtkNoError if OK
     Dtk_ErrorStatus Translate( const Dtk_dir& inTranslationDir );
 
     //! \brief Transforms the Dtk_FCFFeatureIndicator giving a transformation matrix.
     //! \param inTranslationDir The transformation matrix.
     //! \return DtkNoError if OK
     Dtk_ErrorStatus Transform( const Dtk_transfo &inTransfo );
 
     //! \brief Retrieves the Dtk_FCFFeatureIndicator Outer Bounding Box.
     //! \return The Dtk_FCFFeatureIndicator Outer Bounding Box.
     Dtk_Oriented2dBBox GetOuterBoundingBox() const;
 
     //! \brief Explodes the Dtk_FCFFeatureIndicator into Dtk_CompositeText and
     //! geometrical elements - used for Dtk_Symbol conversion only -
     //! \param outText Resulting composite text
     //! \param outGeomsArray Resulting geometrical elements
     //! \return DtkNoError if OK
     Dtk_ErrorStatus Explode( Dtk_CompositeText & outText, Dtk_tab<Dtk_CurvePtr >& outGeomsArray ) const;
};
 
//! \ingroup draw
//! \class Dtk_ToleranceSpecificationContainer
//! \image html Dtk_ToleranceSpecificationContainer.png
//! \brief This is the tolerance specification container.\n
//!  It is part of the Dtk_GeometricalTolerance.\n
//!  It's basically composed by one - or more - Dtk_ToleranceSpecification.
//! \SmartPtr{Dtk_ToleranceSpecificationContainerPtr}
class Dtk_ToleranceSpecificationContainer : public Dtk_Object
{
public:
     enum TypeEnum {
          Typeunknown = 0,
          //! \image html Straightness.png
          TypeStraightness,
          //! \image html Flatness.png
          TypeFlatness,
          //! \image html Circularity.png
          TypeCircularity,
          //! \image html Cylindricity.png
          TypeCylindricity,
          //! \image html LineProfile.png
          TypeLineProfile,
          //! \image html SurfaceProfile.png
          TypeSurfaceProfile,
          //! \image html Angularity.png
          TypeAngularity,
          //! \image html Perpendicularity.png
          TypePerpendicularity,
          //! \image html Parallelism.png
          TypeParallelism,
          //! \image html Position.png
          TypePosition,
          //! \image html Concentricity.png
          TypeConcentricity,
          //! \image html Symmetry.png
          TypeSymmetry,
          //! \image html CircularRunout.png
          TypeCircularRunout,
          //! \image html TotalRunout.png
          TypeTotalRunout,
          //! \image html AxisIntersection.png
          TypeAxisIntersection
     };
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_GEOM_TOL
     };
     //! \sa Create(const Dtk_ToleranceSpecificationContainer &)
     Dtk_ToleranceSpecificationContainer( const Dtk_ToleranceSpecificationContainer &s);
     Dtk_ToleranceSpecificationContainer( Dtk_ToleranceSpecificationContainer&& in ) DTK_NOEXCEPT;
 
     //! \sa Create(const TypeEnum &)
     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:
     friend class Dtk_SmartPtr<Dtk_ToleranceSpecificationContainer>;
public:
 
 
     static Dtk_string TolSpecContTypeToDtk_string( const TypeEnum inValue );
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_ToleranceSpecificationContainer* DtkDynamicCast(Dtk_Object *s);
 
     //! \CreateCopy{in}
     static Dtk_ToleranceSpecificationContainerPtr Create( const Dtk_ToleranceSpecificationContainer &in );
 
     //! \brief Calls full featured constructor to allocate a new object.
     //! \param inTolSpecContType The tolerance specification container type
     //! \return the created Dtk_ToleranceSpecificationContainerPtr
     static Dtk_ToleranceSpecificationContainerPtr Create(
          const TypeEnum &inTolSpecContType,
        const Dtk_Oriented2dBBox& inInnerTolTypeBBox,
        const Dtk_Oriented2dBBox& inOuterTolTypeBBox );
 
 
    //! \brief Retrieves the Tolerance Specification Container Type outer Bounding Box.
    //! \param outOuterBBox The resulting Tolerance Specification Container Type outer Bounding Box.
    void GetToleranceTypeOuterBoundingBox( Dtk_Oriented2dBBox& outOuterBBox ) const;
 
 
     //! \brief Set the Tolerance Specification Container Type outer Bounding Box.
    //! \param inOuterBBox The Tolerance Specification Container Type outer Bounding Box.
    void SetToleranceTypeOuterBoundingBox(const Dtk_Oriented2dBBox& inOuterBBox ) const;
 
    //! \brief Retrieves the Tolerance Specification Container Type inner Bounding Box.
    //! \param outOuterBBox The resulting Tolerance Specification Container Type inner Bounding Box.
    void GetToleranceTypeInnerBoundingBox( Dtk_Oriented2dBBox& outInnerBBox ) const;
 
     //! \brief Set the Tolerance Specification Container Type inner Bounding Box.
     //! \param inInnerBBox The Tolerance Specification Container Type inner Bounding Box.
     void SetToleranceTypeInnerBoundingBox( const Dtk_Oriented2dBBox& inInnerBBox ) const;
 
    //! \brief Processes all the ith Dtk_ToleranceSpecification anchor points.
     //! \param inTolSpecPos the Dtk_ToleranceSpecification index.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetToleranceSpecificationBoundingBox(
          const Dtk_Size_t &inTolSpecPos,
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
     //! \brief Processes all the Dtk_ToleranceSpecificationContainer anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     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();
 
     //! \brief Retrieves the tolerance specification number - read only -.
     //! \return The tolerance specification number.
     Dtk_Size_t GetNumToleranceSpecifications() const;
 
     //! \brief Adds a tolerance specification to the Dtk_ToleranceSpecificationContainer.
     //! \param inTolSpec the tolerance specification to be added.
     //! \return dtkNoError if OK.
     Dtk_ErrorStatus AddToleranceSpecification(
          const Dtk_ToleranceSpecificationPtr &inTolSpec);
 
     //! \brief Retrieves the ith tolerance specification - read only -.
     //! \param inPos the tolerance specification index.
     //! \return The inPos'th tolerance specification.
     Dtk_ToleranceSpecificationPtr GetToleranceSpecification(
          const Dtk_Size_t &inPos) const;
 
     //! \brief Replaces the ith tolerance specification .
     //! \param inPos the tolerance specification index.
     //! \param inNewTolSpec the new tolerance specification index.
     //! \return dtkNoError if OK.
     Dtk_ErrorStatus SetToleranceSpecification(
          const Dtk_Size_t &inPos,
          const Dtk_ToleranceSpecificationPtr &inNewTolSpec);
 
     //! \brief Processes all the Dtk_Symbol anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPointsByTolSpec(
          Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_Int32 &ref_tol_spec_ind = -1) const;
 
     //! \brief Sets the Dtk_ToleranceSpecificationContainer top-text.
     //! \param inText The new text.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetTopText( Dtk_CompositeText inText);
 
     //! \brief Sets the Dtk_ToleranceSpecificationContainer bottom-text.
     //! \param inText The new text.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetBottomText( Dtk_CompositeText inText);
 
     //! \brief Sets the Dtk_ToleranceSpecificationContainer left-text.
     //! \param inText The new text.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetLeftText( Dtk_CompositeText inText);
 
     //! \brief Sets the Dtk_ToleranceSpecificationContainer right-text.
     //! \param inText The new text.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetRightText( Dtk_CompositeText inText);
 
     //! \brief OBSOLETE Retrieves the Dtk_ToleranceSpecificationContainer top-text as Dtk_Text - read only -.
    //! \remark Only the first text - if exists - is retrieved.
    //! \return the text if there is one. an empty Dtk_Text else.
    //! \deprecated Use TopTextAsCompositeText() const method instead.
     const Dtk_Text& TopText() const;
 
     //! \brief OBSOLETE Retrieves the Dtk_ToleranceSpecificationContainer bottom-text as Dtk_Text - read only -.
    //! \remark Only the first text - if exists - is retrieved.
    //! \return the text if there is one. an empty Dtk_Text else.
    //! \deprecated Use BottomTextAsCompositeText() const method instead.
     const Dtk_Text& BottomText() const;
 
     //! \brief OBSOLETE Retrieves the Dtk_ToleranceSpecificationContainer right-text as Dtk_Text - read only -.
    //! \remark Only the first text - if exists - is retrieved.
    //! \return the text if there is one. an empty Dtk_Text else.
    //! \deprecated Use RightTextAsCompositeText() const method instead.
     const Dtk_Text& GetRightText() const;
 
     //! \brief OBSOLETE Retrieves the Dtk_ToleranceSpecificationContainer left-text as Dtk_Text - read only -.
    //! \remark Only the first text - if exists - is retrieved.
    //! \return the text if there is one. an empty Dtk_Text else.
    //! \deprecated Use LeftTextAsCompositeText() const method instead.
     const Dtk_Text& GetLeftText() const;
 
    //! \brief Retrieves the Dtk_ToleranceSpecificationContainer top-text as Dtk_CompositeText - read only -.
    //! \return the text.
    const Dtk_CompositeText& TopTextAsCompositeText() const;
 
    //! \brief Retrieves the Dtk_ToleranceSpecificationContainer bottom-text as Dtk_CompositeText - read only -.
    //! \return the text.
    const Dtk_CompositeText& BottomTextAsCompositeText() const;
 
    //! \brief Retrieves the Dtk_ToleranceSpecificationContainer right-text as Dtk_CompositeText - read only -.
    //! \return the text.
    const Dtk_CompositeText& RightTextAsCompositeText() const;
 
    //! \brief Retrieves the Dtk_ToleranceSpecificationContainer left-text as Dtk_CompositeText - read only -.
    //! \return the text.
    const Dtk_CompositeText& LeftTextAsCompositeText() const;
 
 
     //! \brief Retrieves the Dtk_ToleranceSpecificationContainer top-text - read only -.
     //! \return the text - Dtk_string form -.
     Dtk_string GetTopTextLabel() const;
 
     //! \brief Retrieves the Dtk_ToleranceSpecificationContainer bottom-text - read only -.
     //! \return the text - Dtk_string form -.
     Dtk_string GetBottomTextLabel() const;
 
     //! \brief Retrieves the Dtk_ToleranceSpecificationContainer right-text - read only -.
     //! \return the text - Dtk_string form -.
     Dtk_string GetRightTextLabel() const;
 
     //! \brief Retrieves the Dtk_ToleranceSpecificationContainer left-text - read only -.
     //! \return the text - Dtk_string form -.
     Dtk_string GetLeftTextLabel() const;
 
     //! \brief Explodes the Dtk_ToleranceSpecificationContainer into Dtk_CompositeText and
     //! geometrical elements - used for Dtk_Symbol conversion only -
     //! \param outCompositeText Resulting composite text
     //! \param outGeoms Resulting geometrical elements
     //! \return DtkNoError if OK
     Dtk_ErrorStatus Explode(
          Dtk_CompositeText &outCompositeText,
          Dtk_tab<Dtk_CurvePtr> &outGeoms);
 
     //! \brief Retrieves the Dtk_ToleranceSpecificationContainer type - read only -
     //! \return The Dtk_ToleranceSpecificationContainer type.
     //! \sa ToleranceSpecificationContainerType()
     const TypeEnum& ToleranceSpecificationContainerType() const;
 
     //! \brief Retrieves the Dtk_ToleranceSpecificationContainer type - get/set -
     //! \return The Dtk_ToleranceSpecificationContainer type.
     //! \sa ToleranceSpecificationContainerType() const
     TypeEnum& ToleranceSpecificationContainerType();
 
//   //! \DtkInternal
//   void _PropagateOrientation(const Dtk_dir &inXAxis, const Dtk_dir &inYAxis);
 
     //! \brief Processes all the Dtk_Symbol anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints(Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES],
          const Dtk_bool& ProcessAddtionnalTexts) const;
 
     //! \brief Sets the Dtk_ToleranceSpecificationContainer anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \param inProcessAdditionnalTexts For internal use only.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType,
          const Dtk_bool &inProcessAdditionnalTexts);
 
     //! \brief Sets the location point of the Dtk_ToleranceSpecificationContainer
     //! \brief The location point is related to the anchor type
     //! \param inLocation the location point
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     //! \brief Translates the text giving a translation vector
     //! \param inTranslateDir the translation vector
     //! \return dtkNoError if OK
     void Translate(const Dtk_dir &inTranslationDir);
 
    Dtk_ErrorStatus GetOuterBoundingBox(
        const Dtk_bool& inProcessAddtionnalTexts,
        Dtk_Oriented2dBBox& outOuterBBox) const;
};
 
//! \ingroup draw
//! \class Dtk_Symbol
//! \brief This is the general symbol class.\n
//! It's basically composed of Dtk_CompositeText and geometrical elements.
//! \SmartPtr{Dtk_SymbolPtr}
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 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
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum { _typeID = DTK_TYPE_SYMBOL };
protected:
 
     //! \sa Create(const Dtk_Dimension &)
     Dtk_Symbol(const Dtk_Dimension &inToBeConverted,const Dtk_bool &inKeepLeaderAsLeader);
     //! \sa Create(const Dtk_Table &, const Dtk_bool &)
     Dtk_Symbol(Dtk_Table& inToBeConverted, const Dtk_bool& inTextAutoFlip = DTK_FALSE);
     //! \sa Create(const Dtk_GeometricalTolerance &, const Dtk_bool &)
     Dtk_Symbol(
          const Dtk_GeometricalTolerance& inToBeConverteds,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
     //! \sa Create(const Dtk_Roughness &, const Dtk_bool &)
     Dtk_Symbol(
          const Dtk_Roughness &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
     //! \sa Create(const Dtk_DatumTarget &, const Dtk_bool &)
     Dtk_Symbol(
          const Dtk_DatumTarget &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
     //! \sa Create(const Dtk_Welding &, const Dtk_bool &)
     Dtk_Symbol(
          const Dtk_Welding &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
     //! \sa  Create( const Dtk_CompositeEntityPtr&, const Dtk_bool& inTextAutoFlip)
    Dtk_Symbol(
        const Dtk_CompositeEntity &inToBeConverted,
        const Dtk_bool &inTextAutoFlip = DTK_FALSE);
     //! \sa Create( const Dtk_GridPtr&, const Dtk_bool& )
    Dtk_Symbol(
        const Dtk_Grid &inGrid,
        const Dtk_bool &text_auto_flip = DTK_FALSE);
     //! \sa Create( const Dtk_Region&, const Dtk_bool& )
    Dtk_Symbol(const Dtk_Region &inRegion,
                           const Dtk_bool &text_auto_flip);
     //! \sa Create()
     Dtk_Symbol();
     //! \sa Create(const Dtk_Symbol &)
     Dtk_Symbol(const Dtk_Symbol &s);
     Dtk_Symbol( Dtk_Symbol&& in ) DTK_NOEXCEPT;
 
     ~Dtk_Symbol();
    inline virtual Dtk_Object* Clone() { return new Dtk_Symbol(*this); }
 
     //! \DtkInternal
     Dtk_ErrorStatus _CreateDatumFeatureFrameAsGeometries( Dtk_pnt (&inTabPoints)[DTK_NB_ANCHOR_TYPES] );
 
private:
     friend class Dtk_SmartPtr<Dtk_Symbol>;
public:
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_Symbol * DtkDynamicCast(Dtk_Object *s);
 
     //! \CreateBase
     static Dtk_SymbolPtr Create();
 
     //! \CreateCopy{in}
     static Dtk_SymbolPtr Create( const Dtk_Symbol &in );
 
     //! \brief Calls full featured constructor to allocate a new object.
     //! \param inLocation The symbol location point
     //! \param inLocationAnchorType The anchor type related to the location.
     //! \return the created Dtk_SymbolPtr
     static Dtk_SymbolPtr Create(
          const Dtk_pnt &inLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     //! \brief Create from Dtk_DimensionPtr
    //! \param inToBeConverted Entity to be converted.
    //! \param inKeepLeaderAsLeader to keep the leader definition put the value DTK_TRUE.
     //! \return the created Dtk_SymbolPtr
     static Dtk_SymbolPtr Create( const Dtk_DimensionPtr &inToBeConverted ,
        const Dtk_bool &inKeepLeaderAsLeader = DTK_FALSE );
 
     //! \brief Create from Dtk_DatumTargetPtr
     //! \param inToBeConverted Entity to be converted.
     //! \param inTextAutoFlip For internal use only.
     //! \return the created Dtk_SymbolPtr
     static Dtk_SymbolPtr Create(
          const Dtk_DatumTargetPtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     //! \brief Create from Dtk_GeometricalTolerancePtr
     //! \param inToBeConverted Entity to be converted.
     //! \param inTextAutoFlip For internal use only.
     //! \return the created Dtk_SymbolPtr
     static Dtk_SymbolPtr Create(
          const Dtk_GeometricalTolerancePtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     //! \brief Create from Dtk_TablePtr
     //! \param inToBeConverted Entity to be converted.
     //! \param inTextAutoFlip For internal use only.
     //! \return the created Dtk_SymbolPtr
     static Dtk_SymbolPtr Create(
          const Dtk_TablePtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     //! \brief Create from Dtk_RoughnessPtr
     //! \param inToBeConverted Entity to be converted.
     //! \param inTextAutoFlip For internal use only.
     //! \return the created Dtk_SymbolPtr
     static Dtk_SymbolPtr Create(
          const Dtk_RoughnessPtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
    //! \brief Create from Dtk_GridPtr
    //! \param inToBeConverted Entity to be converted.
    //! \param inTextAutoFlip For internal use only.
    //! \return the created Dtk_SymbolPtr
    static Dtk_SymbolPtr Create(
        const Dtk_GridPtr &inToBeConverted,
        const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
    //! \brief Create from Dtk_RegionPtr
    //! \param inToBeConverted Entity to be converted.
    //! \param inTextAutoFlip For internal use only.
    //! \return the created Dtk_SymbolPtr
    static Dtk_SymbolPtr Create(
        const Dtk_RegionPtr &inToBeConverted,
        const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     //! \brief Create from Dtk_AnnotationPtr
     //! \param inToBeConverted Entity to be converted.
     //! \param inTextAutoFlip For internal use only.
     //! \return the created Dtk_SymbolPtr
     static Dtk_SymbolPtr Create(
          const Dtk_AnnotationPtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE);
 
     //! \brief Create from Dtk_2dEntityPtr
     //! \param inToBeConverted Entity to be converted.
     //! \param inTextAutoFlip For internal use only - except for Dtk_Dimension -.
    //! \param inKeepLeaderAsLeader to keep the leader definition put the value DTK_TRUE - only for Dtk_Dimension -.
    //! \return the created Dtk_SymbolPtr
     static Dtk_SymbolPtr Create(
          const Dtk_2dEntityPtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip = DTK_FALSE,
        const Dtk_bool &inKeepLeaderAsLeader = DTK_FALSE );
 
     //! \brief Create from Dtk_WeldingPtr
     //! \param inToBeConverted Entity to be converted.
     //! \param inTextAutoFlip For internal use only.
     //! \return the created Dtk_SymbolPtr
     static Dtk_SymbolPtr Create(
          const Dtk_WeldingPtr &inToBeConverted,
          const Dtk_bool &inTextAutoFlip);
 
     //! \brief Create from Dtk_CompositeEntityPtr
     //! \param inToBeConverted Entity to be converted.
     //! \param inTextAutoFlip For internal use only.
     //! \return the created Dtk_SymbolPtr
    static Dtk_SymbolPtr Create(
        const Dtk_CompositeEntityPtr &inToBeConverted,
        const Dtk_bool &inTextAutoFlip);
 
    //! \brief Adds a geometrical element to the Dtk_Symbol.
    //! \param inGeomElt The geometrical element to be added.
    //! \return DtkNoError if OK.
    Dtk_ErrorStatus AddGeometricalElement( const Dtk_EntityPtr &inGeomElt );
 
     //! \brief Retrieves the geometrical elements number - read only -.
     //! \return The geometrical elements number.
     Dtk_Size_t GetNumGeometricalElements() const;
 
     //! \brief Retrieves the ith geometrical element
     //! \param inPos The geoemtrical element index
     //! \return The inPos'th geometrical element.
     Dtk_EntityPtr GetGeomElement( const Dtk_Size_t &inPos ) const;
 
    //! \brief Converts all leaders into Dtk_Symbol into geometrical elements
    void ConvertLeadersToGeometrie();
 
     //! \brief Retrieves the Dtk_CompositeText included into the Dtk_Symbol - read only -.
     //! \return The Dtk_CompositeText.
     //! \sa Texts()
     const Dtk_CompositeText& Texts()const;
 
     //! \brief Retrieves the Dtk_CompositeText included into the Dtk_Symbol - get/set -.
     //! \return The Dtk_CompositeText.
     //! \sa Texts() const
     Dtk_CompositeText& Texts();
 
     //! \brief Retrieves the Dtk_Symbol frame type - read only -.
     //! \return The frame type.
     //! \sa FrameType()
    Dtk_frame_type FrameType() const;
 
    //! \brief Set the Dtk_Symbol frame information - get/set -
    //! \return The Dtk_Symbol frame type
    //! \sa FrameType() const
    void SetFrameType( const Dtk_frame_type& inFrameType, Dtk_tab< Dtk_CurvePtr > inRelatedGeomElements);
 
    //! \brief Retrieves the Frame - read only -
    //! \param outFrame The frame
    //! \sa FrameType() const
    void GetFrame(Dtk_Frame& outFrame) const;
 
     //! \brief Retrieves the Dtk_Symbol type - read only -.
     //! \return The Dtk_Symbol type.
     //! \sa SymbolType()
     const TypeEnum& SymbolType()const;
 
     //! \brief Retrieves the Dtk_Symbol type - get/set -.
     //! \return The Dtk_Symbol type.
     //! \sa SymbolType() const
     TypeEnum& SymbolType();
 
     //! \brief Processes all the Dtk_Symbol anchor points.
     //! \param outTabPnts The resulting anchor point array.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus GetAnchorPoints( Dtk_pnt (&outTabPnts)[DTK_NB_ANCHOR_TYPES] ) const;
 
     //! \return The type of the entity type - DTK_TYPE_SYMBOL -
     type_detk get_type_detk() const { return DTK_TYPE_SYMBOL; }
 
     //! \brief Sets the Dtk_Symbol anchor point.
     //! \param inNewLocation The new location point.
     //! \param inLocationAnchorType The anchor type related to the new location.
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetAnchorPoint(
          const Dtk_pnt &inNewLocation,
          const Dtk_anchor_type &inLocationAnchorType);
 
     //! \brief Sets the location point of the Dtk_Symbol
     //! \brief The location point is related to the anchor type
     //! \param inLocation the location point
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetLocation( const Dtk_pnt &inLocation );
 
     //! \brief Sets the offset of the Dtk_Symbol
     //! \brief The Offset is used to process bounding frames.
     //! \param inOffset The offset
     //! \return dtkNoError if OK
     //! \warning  For internal use only
     Dtk_ErrorStatus SetOffset( const Dtk_Double64 &inOffset );
 
     //! \brief Sets the annotation angle using the annotation base.
     //! \param inRotationAngle  The rotation angle to be set
     //! \return dtkNoError if OK
     Dtk_ErrorStatus SetRotationAngle( const Dtk_Double64 &inRotationAngle );
 
     //! \brief Processes Dtk_Symbol frame as geometrical elements/
     //! \return dtkNoError if OK
     Dtk_ErrorStatus CreateFrameAsGeometries();
 
     //! \brief Merges texts and geometrical element of the given Dtk_Symbol into this Dtk_Symbol
    //! \param inSymbolToBeMerged Dtk_Symbol to be merged into.
    void MergeWithOtherSymbol(const Dtk_SymbolPtr &inSymbolToBeMerged);
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
};
 
//! \ingroup draw
//! \class Dtk_Drawing
//! \brief This is the drawing class.\n
//! It basically contains a Dtk_View array
//! \SmartPtr{Dtk_DrawingPtr}
class Dtk_Drawing : public Dtk_Entity
{
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_DRAWING
     };
 
private:
     
     Dtk_Drawing(const Dtk_Drawing & );
     Dtk_Drawing( Dtk_Drawing&&  ) DTK_NOEXCEPT;
     //! \sa Create()
     Dtk_Drawing();
     ~Dtk_Drawing();
    inline virtual Dtk_Object* Clone() { return new Dtk_Drawing(*this); }
 
private:
     friend class Dtk_SmartPtr<Dtk_Drawing>;
 
public:
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_Drawing* DtkDynamicCast(Dtk_Object *s);
 
     //! \CreateBase
     static Dtk_DrawingPtr Create();
 
     //! \CreateCopy{in}
     static Dtk_DrawingPtr Create(const Dtk_Drawing &in);
 
     //! \return The type of the entity type - DTK_TYPE_DRAWING -
     type_detk get_type_detk() const
     {
          return DTK_TYPE_DRAWING;
     }
 
     //! \brief Adds a view into the drawing
     //! \param inViewtoBeAdded Dtk_View to be added.
     //! \return DtkNoError if OK
     Dtk_ErrorStatus AddView(const Dtk_ViewPtr &inViewtoBeAdded);
 
     //! \DtkInternal
     Dtk_ErrorStatus AddOrigin(const Dtk_pnt &origin);
 
    //! \brief Adds a view into the drawing
    //! \param inView Dtk_View to be added.
    //! \param inOrigin Origin of the view in the Dtk_Drawing.
    //! \return DtkNoError if OK
    Dtk_ErrorStatus AddView(const Dtk_ViewPtr& inView, const Dtk_pnt& inOrigin);
 
     //! \brief Retrieves the ith Dtk_View - get/set -.
     //! \param inPos View index.
     //! \return the inPos'th Dtk_View.
     //! \sa GetView(const Dtk_Size_t&) const
     Dtk_ViewPtr& GetView(const Dtk_Size_t &inPos);
 
     //! \brief Retrieves the ith Dtk_View - read only -.
     //! \param inPos View index.
     //! \return the inPos'th Dtk_View.
     //! \sa GetView(const Dtk_Size_t&)
     const Dtk_ViewPtr& GetView(const Dtk_Size_t &inPos)const;
 
     //! \brief Retrieves the drawing width - get/set -.
     //! \return the drawing width.
     //! \sa Width() const
     Dtk_Double64 &Width();
 
     //! \brief Retrieves the drawing width - read only -.
     //! \return the drawing width.
     //! \sa Width()
     const Dtk_Double64 &Width() const;
 
     //! \brief Retrieves the drawing height - get/set -.
     //! \return the drawing height.
     //! \sa Height() const
     Dtk_Double64 &Height();
 
     //! \brief Retrieves the drawing height - read only -.
     //! \return the drawing height.
     //! \sa Height()
     const Dtk_Double64 &Height() const;
 
     //! \brief Retrieves the views number - read only -.
     //! \return The views number.
     Dtk_Size_t GetNumViews() const;
 
     //! \brief Retrieves the 2D entities number - read only -.
     //! \return The 2D entities number.
     SetAsDeprecated( "2025.4", "Please remove calls to this function, it will always return 0." )
     Dtk_Size_t GetNum2dEntities_Deprecated254() const;
 
     //! \brief Retrieves the origin points number - read only -.
     //! \return The origin points number.
     Dtk_Size_t GetNumOrigins() const;
 
     //! \brief Retrieves the origin Dtk_pnt - get/set -.
     //! \param inPos origin Dtk_pnt index.
     //! \return the inPos'th origin Dtk_pnt.
     //! \sa GetOrigin(const Dtk_Size_t&) const
     Dtk_pnt& GetOrigin(const Dtk_Size_t &inPos);
 
     //! \brief Retrieves the ith origin Dtk_pnt - read only -.
     //! \param inPos origin Dtk_pnt index.
     //! \return the inPos'th origin Dtk_pnt.
     //! \sa GetOrigin(const Dtk_Size_t&)
     const Dtk_pnt& GetOrigin(const Dtk_Size_t &inPos) const;
 
     //! \brief Retrieves the 2D entity - get/set -.
     //! \param inPos 2D entity index.
     //! \return the inPos'th 2D entity.
     //! \sa Get2dEntity(const Dtk_Size_t&) const
     SetAsDeprecated( "2025.4", "Please remove calls to this function, it will always return a null object." )
     Dtk_2dEntityPtr& Get2dEntity_Deprecated254(const Dtk_Size_t &inPos);
 
     //! \brief Retrieves the ith 2D entity - read only -.
     //! \param inPos 2D entity index.
     //! \return the inPos'th 2D entity.
     //! \sa Get2dEntity(const Dtk_Size_t&)
     SetAsDeprecated( "2025.4", "Please remove calls to this function, it will always return a null object." )
     const Dtk_2dEntityPtr& Get2dEntity_Deprecated254(const Dtk_Size_t &inPos) const ;
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
};
 
//! \ingroup draw
//! \class Dtk_ViewDisplay
//! \brief This is the Dtk_ViewDisplay class to set the Display mode for the bodies stored in a view.
//! \SmartPtr{Dtk_ViewDisplayPtr}
class Dtk_ViewDisplay : public Dtk_Object
{
public:
     enum DisplayMode3DEnum
     {
          DefaultDisplay = 0,
          //! \image html WireframeDisplay.png
          WireframeDisplay = 1, 
          //! \image html WithHiddenDisplay.png
          WithHiddenDisplay = 2,  
          //! \image html NoHiddenDisplay.png
          NoHiddenDisplay = 3,  
          //! \image html ShadingDisplay.png
          ShadingDisplay = 4,
          //! \image html ShadingWithEdgeDisplay.png
          ShadingWithEdgeDisplay = 5
     };
 
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum
     {
          _typeID = DTK_TYPE_VIEW_DISPLAY
     };
 
     //! \sa Create()
     Dtk_ViewDisplay();
     //! \sa Create( const Dtk_View& )
     Dtk_ViewDisplay( const Dtk_ViewDisplay &s );
     Dtk_ViewDisplay( Dtk_ViewDisplay&& in ) DTK_NOEXCEPT;
     //! \sa Create( DisplayMode3DEnum )
     Dtk_ViewDisplay( DisplayMode3DEnum  inDisplayMode );
     inline virtual Dtk_Object* Clone(){ return new Dtk_ViewDisplay( *this ); }
     //! \BaseDestructor
     ~Dtk_ViewDisplay();
private:
     friend class Dtk_SmartPtr<Dtk_ViewDisplay>;
public:
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType( const Dtk_Int32 &inId );
 
     //! \DtkDynamicCast
     static Dtk_ViewDisplay * DtkDynamicCast( Dtk_Object *s );
 
     //! \return The type of the entity type - DTK_TYPE_VIEW_DISPLAY -
     type_detk get_type_detk() const
     {
          return DTK_TYPE_VIEW_DISPLAY;
     }
 
     //! \CreateBase
     static Dtk_ViewDisplayPtr Create( DisplayMode3DEnum  inDisplayMode);
 
     //! \CreateCopy{in}
     static Dtk_ViewDisplayPtr Create( const Dtk_ViewDisplay & in );
 
 
     //! \brief Return the Display Mode
     DisplayMode3DEnum GetDisplayMode() const;
 
     //! \brief Retrieves Line style for Visible Edges
     //! \param outLineFont Line Font - Solid, Dimmed, ...-
     //! \param outLineWidth Line Width in MM
     //! \param outLineColor Line Color 
     //! \return dtkNoError if Success.
     Dtk_ErrorStatus GetVisibleEdgesLineStyle( Dtk_FontLineType &outLineFont, Dtk_Double64 &outLineWidth, Dtk_RGB &outLineColor ) const;
 
     //! \brief Set Line style for Visible Edges
     //! \param inLineFont Line Font - Solid, Dimmed, ...-
     //! \param inLineWidth Line Width in MM
     //! \param inLineColor Line Color 
     void SetVisibleEdgesLineStyle( Dtk_FontLineType inLineFont, Dtk_Double64 inLineWidth, Dtk_RGB inLineColor );
 
     //! \brief Retrieves Line style for Hidden Edges
     //! \param outLineFont Line Font - Solid, Dimmed, ...-
     //! \param outLineWidth Line Width in MM
     //! \param outLineColor Line Color 
     //! \return dtkNoError if Success.
     Dtk_ErrorStatus GetHiddenEdgesLineStyle( Dtk_FontLineType &outLineFont, Dtk_Double64 &outLineWidth, Dtk_RGB &outLineColor ) const;
 
     //! \brief Set Line style for Hidden Edges
     //! \param inLineFont Line Font - Solid, Dimmed, ...-
     //! \param inLineWidth Line Width in MM
     //! \param inLineColor Line Color 
     void SetHiddenEdgesLineStyle( Dtk_FontLineType inLineFont, Dtk_Double64 inLineWidth, Dtk_RGB inLineColor );
 
     //! \brief Retrieves Line style for Tangent Edges
     //! \param outLineFont Line Font - Solid, Dimmed, ...-
     //! \param outLineWidth Line Width in MM
     //! \param outLineColor Line Color 
     //! \return dtkNoError if Success.
     Dtk_ErrorStatus GetTangentEdgesLineStyle( Dtk_FontLineType &outLineFont, Dtk_Double64 &outLineWidth, Dtk_RGB &outLineColor ) const;
 
     //! \brief Set Line style for Tangent Edges
     //! \param inLineFont Line Font - Solid, Dimmed, ...-
     //! \param inLineWidth Line Width in MM
     //! \param inLineColor Line Color 
     void SetTangentEdgesLineStyle( Dtk_FontLineType inLineFont, Dtk_Double64 inLineWidth, Dtk_RGB inLineColor );
 
 
};
 
 
//! \ingroup draw
//! \class Dtk_View
//! \brief This class is used to represent a drawing view of a 3D model.
//! It can also be used to represent parts of the drawing that are not a view of a 3D model, such as a title block.
//! \SmartPtr{Dtk_ViewPtr}
class Dtk_View : public Dtk_Entity
{
public:
     enum ViewType
     {
          // Unspecified view type.
          NoTypeView = 0,
          // View focused on a specific area of a model.
          DetailView = 1,
          // View representing a section of a model.
          SectionView = 2,
          // View showing a model with a portion removed to save space on the drawing.
          BrokenView = 4,
          // Dtk_View containing the title block area of a sheet.
          TitleBlockView = 8,
          // Dtk_View containing entities on sheet that are not related to any view of a 3D model.
          SheetView = 16
     };
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_VIEW
     };
 
     //! \sa Create()
     Dtk_View();
     //! \sa Create(const Dtk_View&)
     Dtk_View(const Dtk_View &s);
     Dtk_View( Dtk_View&& in ) DTK_NOEXCEPT;
    inline virtual Dtk_Object* Clone() { return new Dtk_View(*this); }
     ~Dtk_View();
private:
     friend class Dtk_SmartPtr<Dtk_View>;
public:
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_View * DtkDynamicCast(Dtk_Object *s);
 
     //! \return The type of the entity type - DTK_TYPE_VIEW -
     type_detk get_type_detk() const
     {
          return DTK_TYPE_VIEW;
     }
 
     //! \CreateBase
     static Dtk_ViewPtr Create();
 
     //! \CreateCopy{in}
     static Dtk_ViewPtr Create(const Dtk_View &in);
 
     //! \brief Adds a 2D entity to the view
     //! \param in2DEntity 2D entity to be added.
     //! \return DtkNoError if OK.
     Dtk_ErrorStatus Add2dEntity(const Dtk_2dEntityPtr &in2DEntity);
 
     //! \brief Adds an array of 2D entities to the view
     //! \param in2DEntitiesArray Array of 2D entities to be added.
     //! \return DtkNoError if OK.
     Dtk_ErrorStatus Add2dEntities(
          const Dtk_tab<Dtk_2dEntityPtr> &in2DEntitiesArray);
 
    //! \brief Adds an entity, Dtk_Hatching, curve and point to the view ( other type are not supported )
    //! \param inEnt Entity to be added.
    //! \return DtkNoError if OK.
    Dtk_ErrorStatus AddEntity(const Dtk_EntityPtr& inEnt);
 
    //! \brief Adds an array of 2D entities, Dtk_Hatching, curve and point to the view ( other type are not supported )
    //! \param inEntitiesArray Array of entities to be added.
    //! \return DtkNoError if OK.
    Dtk_ErrorStatus AddEntities(const Dtk_tab<Dtk_EntityPtr>& inEntitiesArray);
 
     //! \brief Retrieves the 2D entities number - read only -
     //! \returns The 2D entities number.
     Dtk_Size_t GetNum2dEntities() const;
 
     //! \brief Retrieves the ith 2D entity.
     //! \param inPos 2D entity index.
     //! \return the inPos'th 2D entity.
     Dtk_2dEntityPtr Get2dEntity(const Dtk_Size_t &inPos) const;
 
     //! \brief Retrieves the ith 2D entity.
     //! \param inPos 2D entity index.
     //! \return the inPos'th 2D entity.
     //! \sa Get2dEntity(const Dtk_Size_t &)
     Dtk_2dEntityPtr operator [](const Dtk_Size_t &inPos) const;
 
    //! \return The ith clipping
     //! \param inPos clipping plane index.
     //! \return the inPos'th clipping plane.
     Dtk_PlaneSurfacePtr GetClipping(const Dtk_Size_t &inPos) const;
 
     //! \return The clipping boundary
     //! \return the Dtk_CompositeEntityPtr which defines the boundary.
     const Dtk_CompositeEntityPtr & GetClippingBoundary() const;
 
     //! \brief Adds a drawing geometrical entity to the view
     //! \param inGeomElt geometrical entity to be added.
     //!   only Dtk_pnt and Dtk_Curve are allowed
     //! \return DtkNoError if OK.
     //!         dtkErrorTypeNotsupported if entity isn't a Curve or a point
     Dtk_ErrorStatus Add2dGeometricalEntity(const Dtk_EntityPtr  &inGeomElt) const;
 
     //! \brief Retrieves the number of geometrical entity to the view
     //! \return size of the array
     Dtk_Size_t GetNum2dGeometricalEntity() const;
 
     //! \brief Retrieves the ith geometrical entity.
     //! \param inPos geometrical entity index.
     //! \return the inPos'th geometrical entity.
     Dtk_EntityPtr Get2dGeometricalEntity( const Dtk_Size_t& inPos ) const;
 
     //! \brief Adds a Body displayed in the view
     //! \param inBody Body to be displayed.
     //! \return DtkNoError if OK.
     Dtk_ErrorStatus AddBody( const Dtk_BodyPtr &inBody );
     
     //! \brief Adds an array of bodies displayed in the view
    //! \param inBodyArray Array of bodies to be displayed.
    //! \return DtkNoError if OK.
    Dtk_ErrorStatus AddBodies(Dtk_tab<Dtk_BodyPtr> inBodyArray);
 
    //! \brief Retrieves the bodies number to be displayed
    //! \returns The bodies number.
    Dtk_Size_t GetNumBodies() const;
 
    //! \brief Retrieves the ith Body.
    //! \param inPos Body index.
    //! \return the inPos'th Body.
     Dtk_BodyPtr GetBody(const Dtk_Size_t &inPos) const;
     
     //! \brief Retrieves the bodies needed to be displayed 
     //! \returns The bodies to be displayed.
     const Dtk_tab<Dtk_BodyPtr> & GetBodies() const;
 
     //! \brief Retrieves the camera used for projection in the view - read only -.
     Dtk_CameraPtr GetCameraforProjection() const;
     //! \brief Set the camera used for 3D entities projection in the view.
     Dtk_ErrorStatus SetCameraforProjection( const Dtk_CameraPtr& inCamera );
 
     //! \brief SetDisplayMode for 3D entity to be displayed
     //! \param inDisplay Body index.
     void SetViewDisplay( Dtk_ViewDisplayPtr inDisplay );
 
     //! \brief GetDisplayMode for 3D entity
     //! \returns The Display View.
     Dtk_ViewDisplayPtr GetViewDisplay() const;
 
     //! \brief Adds a picture to the view
     //! \param inPicture Picture to be added.
     //! \return dtkNoError if OK.
     Dtk_ErrorStatus AddPicture( const Dtk_picturePtr &inPicture );
 
     //! \brief Adds an array of pictures to the view
     //! \param inPicturesArray Array of pictures to be added.
     //! \return dtkNoError if OK.
     Dtk_ErrorStatus AddPictures(
          const Dtk_tab<Dtk_picturePtr> &inPicturesArray );
 
     //! \brief Retrieves the pictures number - read only -
     //! \returns The pictures number.
     Dtk_Size_t GetNumPictures() const;
 
     //! \brief Retrieves the ith Picture.
     //! \param inPos Picture index.
     //! \return the inPos'th Picture.
     Dtk_picturePtr GetPicture( const Dtk_Size_t &inPos ) const;
 
     //! \brief Adds a Dtk_OLEObjectPtr to the view
     //! \param inOLEObject Dtk_OLEObjectPtr to be added.
     //! \return dtkNoError if OK.
     Dtk_ErrorStatus AddOLEObject( const Dtk_OLEObjectPtr & inOLEObject );
     //! \brief Adds an array of Dtk_OLEObjectPtr to the view
     //! \param inOleObjects Array of Dtk_OLEObjectPtr to be added.
     //! \return dtkNoError if OK.
     Dtk_ErrorStatus AddOLEObjects( const Dtk_tab<Dtk_OLEObjectPtr> & inOleObjects );
     //! \brief Retrieves the number of OLE Objects in the Dtk_View.
     Dtk_Size_t GetNumOLEObjects() const;
     //! \brief Retrieves the OLE Object at index.
     Dtk_OLEObjectPtr GetOLEObject( const Dtk_Size_t & inIndex ) const;
 
 
     //! \brief Retrieves the Dtk_View scale - read only -.
     //! \returns The Dtk_View scale.
     //! \sa Scale()
     const Dtk_Double64& Scale() const;
 
     //! \brief Retrieves the Dtk_View scale - get/set-.
     //! \returns The Dtk_View scale.
     //! \sa Scale() const
     Dtk_Double64& Scale();
 
     //! \brief Retrieves the Dtk_View angle - read only -.
     //! \returns The Dtk_View angle.
     //! \sa Angle()
     const Dtk_Double64& Angle() const;
 
     //! \brief Retrieves the Dtk_View angle - get/set-.
     //! \returns The Dtk_View angle.
     //! \sa Angle() const
     Dtk_Double64& Angle();
 
     //! \brief Retrieves the Dtk_View transformation matrix - read only -.
     //! \returns The Dtk_View transformation matrix.
     //! \sa TransformationMatrix()
     const Dtk_transfo& TransformationMatrix() const;
 
     //! \brief Retrieves the Dtk_View transformation matrix - get/set-.
     //! \returns The Dtk_View transformation matrix.
     //! \sa TransformationMatrix() const
     Dtk_transfo& TransformationMatrix();
 
     //! \brief Sets the ith clipping plane informations.
     //! \param inPos The clipping plane index.
     //! \param inLocation The clipping plane location.
     //! \param inRefAxis The clipping plane reference axis.
     //! \param inNormalAxis The clipping plane normal axis.
     //! \return DtkNoError if OK.
     Dtk_ErrorStatus SetClippingPlane(const Dtk_Size_t &inPos,
          const Dtk_pnt &inLocation,const Dtk_dir &inRefAxis,
          const Dtk_dir &inNormalAxis);
 
 
     //! \brief Sets the clipping boundary informations.
     void SetClippingBoundary(const Dtk_CompositeEntityPtr &inBoundary) const;
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     //! \brief Checks if the view is of a given type.
     bool IsView( ViewType typeView );
 
     //! \brief Set the view as being of a given type.
     void AddView( ViewType typeView );
};
 
 
//////////////////////////////////////////////////////////////////////////////////////////
//FDT Classes
//! \class Dtk_Fdt
//! \brief This is the FD&T class.\n
//! The base PMI Class contains a \DtkLinkToPtr{Dtk_2dEntity} and Transformation Matrix
//! to locate the FDT into 3D Space.\n
//! \SmartPtr{Dtk_FdtPtr}
class Dtk_Fdt : public Dtk_Entity
{
public:
    enum ScreenDisplayEnum
    { //! The annotation display isn't bound to the viewport.
        Default             = 0, 
          //! Keep the annotation facing the viewport - Rotate won't have effect on annotation display -. Pan/Zoom WILL have effect on annotation display.
        ParallelToScreen    = 1,
          //! Keep the annotation facing the viewport - Rotate won't have effect on annotation display -. Pan and zoom also WON'T have effect on annotation display. Coordinates are screen ratio between 0.0 and 1.0, Origin at bottom left.
        PinToScreen         = 2  
    };
    static 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
     std::unique_ptr<Dtk_Handle> _Private; // Handle
    enum
    {
        _typeID = DTK_TYPE_FDT
    };
 
    //! \sa Create()
    Dtk_Fdt();
     //! \sa Create(const Dtk_Fdt &)
    Dtk_Fdt(const Dtk_Fdt & );
    Dtk_Fdt( Dtk_Fdt&& in ) DTK_NOEXCEPT;
    //! \sa Create(const Dtk_transfo &, const Dtk_2dEntityPtr &)
    Dtk_Fdt(const Dtk_transfo &inTransforansform,
        const Dtk_2dEntityPtr &entity2D);
    inline virtual Dtk_Object* Clone() { return new Dtk_Fdt(*this); }
 
    //! \BaseDestructor
    virtual ~Dtk_Fdt();
 
private:
    friend class Dtk_SmartPtr<Dtk_Fdt>;
public:
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    //! \DtkDynamicCast
    static Dtk_Fdt* DtkDynamicCast(Dtk_Object *s);
 
    //! \CreateBase
    static Dtk_FdtPtr Create();
 
    //! \CreateCopy{s}
    static Dtk_FdtPtr Create(const Dtk_Fdt &s);
 
    //! \brief Calls full featured constructor to allocate a new object.
    //! \param inTransformationMatrix The Transformation Matrix
    //! \param inSub2DEntity The sub 2D entity
    static Dtk_FdtPtr Create(const Dtk_transfo &inTransformationMatrix,
        const Dtk_2dEntityPtr &inSub2DEntity);
 
    //! \return The type of the entity type - DTK_TYPE_FDT -
    type_detk get_type_detk() const
    {
        return DTK_TYPE_FDT;
    }
 
    //! \brief Sets the ScreenDisplay attribute of the Dtk_Fdt.
    //! \param inType The Dtk_Fdt ScreenDisplay attribute
    //! \sa SetScreenDisplayAttribute()
    void SetScreenDisplayAttribute( const ScreenDisplayEnum inType );
 
    //! \brief Gets the ScreenDisplay attribute of the Dtk_Fdt.
    //! \return The Dtk_Fdt ScreenDisplay attribute
    //! \sa GetScreenDisplayAttribute() const
    Dtk_Fdt::ScreenDisplayEnum GetScreenDisplayAttribute() const;
 
     //! \brief Sets the DisplayBackground color id of the Dtk_Fdt.
     //! \param inData the color id
     //! \sa SetDisplayBackgroundColorId()
     void SetDisplayBackgroundColorId(Dtk_Int32 inData);
 
     //! \brief Gets the DisplayBackground color id of the Dtk_Fdt.
     //! \param outColorIdData : if present the color id >=0
     //! \return if present dtkNoError otherwise dtkErrorUnspecified
     //! \sa GetDisplayBackgroundColorId()
     Dtk_ErrorStatus GetDisplayBackgroundColorId(Dtk_Int32& outColorIdData) const;
 
 
     //! \brief Sets the Zoomable attribute of the Dtk_Fdt.
     //! \param inBool The Dtk_Fdt zoomable attribute
     //! \sa SetIsZoomableAttribute() const
     //! \remark : by default fdt will be zoomable
     void SetIsZoomableAttribute( const bool &inBool );
 
     //! \brief Gets the Zoomable attribute of the Dtk_Fdt.
     //! \return The Dtk_Fdt Zoomable attribute
     //! \sa GetIsZoomableAttribute() const
     bool GetIsZoomableAttribute( ) const;
 
    //! \brief Retrieves the transformation matrix - read only -.
    //! \return The transformation matrix.
    //! \sa TransformationMatrix()
    const Dtk_transfo& TransformationMatrix() const;
 
    //! \brief Retrieves the transformation matrix - get/set -.
    //! \return The transformation matrix.
    //! \sa TransformationMatrix() const
    Dtk_transfo& TransformationMatrix();
 
    //! \brief Retrieves the sub 2D entity - read only -.
    //! \return The sub 2D entity.
    //! \sa Sub2DEntity()
    const Dtk_2dEntityPtr& Sub2DEntity() const;
 
    //! \brief Retrieves the sub 2D entity - get/set -.
    //! \return The sub 2D entity.
    //! \sa Sub2DEntity() const
    Dtk_2dEntityPtr& Sub2DEntity();
 
    //! \Transform{inTransfo}
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
};
 
 
//////////////////////////////////////////////////////////////////////////////////////////
//! \class Dtk_Camera
//! \brief This is the Camera class.\n This class lets you define elements to create frustum.\n
//! \SmartPtr{Dtk_CameraPtr}
//! \brief The camera can be parallel:
//! \image html CameraParallelGlobal.png
//! \brief ...or perspective:
//! \image html CameraPerspectiveGlobal.png
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
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum { _typeID = DTK_TYPE_CAMERA };
     //! \sa Create()
     Dtk_Camera();
     //! \sa Create(const Dtk_Camera&)
     Dtk_Camera(const Dtk_Camera &s);
     Dtk_Camera( Dtk_Camera&& in ) DTK_NOEXCEPT;
    inline virtual Dtk_Object* Clone() { return new Dtk_Camera(*this); }
     ~Dtk_Camera();
private:
     friend class Dtk_SmartPtr<Dtk_Camera>;
public:
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_Camera * DtkDynamicCast(Dtk_Object *s);
 
     //! \return The type of the entity type - DTK_TYPE_CAMERA -
     type_detk get_type_detk() const { return DTK_TYPE_CAMERA; }
 
     //! \CreateBase
     static Dtk_CameraPtr Create();
     //! \CopyConstructor{in}
     static Dtk_CameraPtr Create( Dtk_Camera const& in );
 
    //! \deprecated Use Create(        const Dtk_pnt& inOriginPoint,
    //! const Dtk_pnt& inTarget,
    //! const Dtk_dir& inUpVector,
    //! const Dtk_Double64 inSemiWidth,
    //! const Dtk_Double64 inSemiHeight,
    //! const ProjectionTypeEnum& inProjectionType,
    //! const ZoomFitModeEnum inZoomFitMode) method instead.
    //! \brief Calls full featured constructor to allocate a new object.
     //! \param inOriginPoint The Dtk_Camera location point
     //! \param inTarget The Target vector
     //! \param inUpVector The Up vector
     //! \param inAngle The angle - in Degrees - - will be used to process Semi-Width/Semi-Height -
     //! \param inFocus The focus - This value will be ignored -
     //! \param inZoomFactor The zoom factor - 1.0 by default - - This value will be ignored -
    //! \param inProjectionType The projection type - ProjectionTypeParallel by default -
    //! \param inZoomFitMode The Zoom Fit Mode - NoZoomFit by default -
    //! \return The created Dtk_CameraPtr
     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 );
 
     //! \brief Calls full featured constructor to allocate a new object.
    //! \param inOriginPoint The Dtk_Camera location point
    //! \param inTarget The Target vector
    //! \param inSemiWidth Semi-Width of the Pyramid/Block Camera Frustum - in mm -
    //! \param inSemiHeight Semi-Height of the Pyramid/Block Camera Frustum - in mm -
    //! \param inUpVector The Up vector
    //! \param inProjectionType The projection type - ProjectionTypeParallel by default -
    //! \param inZoomFitMode The Zoom Fit Mode - NoZoomFit by default -
    //! \return The created Dtk_CameraPtr
    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 );
 
    //! \Transform{inTransfo}
    //! \return dtkErrorUnspecified if the resulting Dtk_Camera is not valid, DtkNoError otherwise.
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     //! \brief Retrieves the origin point - read only -
     //! \return The origin point
     const Dtk_pnt& OriginPoint() const;
 
    //! \brief Retrieves the target point - read only -
    //! \return The target point
    const Dtk_pnt& TargetPoint() const;
 
     //! \brief Retrieves the up vector - read only -
     //! \return The up vector
     const Dtk_dir& UpVector() const;
 
    //! \brief Processes the Focus Distance ie the Distance between the Origin and the Target points - read only -
    //! \return The Focus Distance in mm.
    Dtk_Double64 GetFocusDistance() const;
 
    //! \brief Retrieves the Camera Base Semi Width - read only -
    //! \return The Base Width in mm.
    Dtk_Double64 GetSemiWidth() const;
 
    //! \brief Retrieves the Camera Base Semi Height - read only -
    //! \return The Base Height in mm.
    Dtk_Double64 GetSemiHeight() const;
 
     //! \brief Retrieves the projection type - read only -
     //! \return The projection type
     const Dtk_Camera::ProjectionTypeEnum& ProjectionType() const;
 
    //! \brief Retrieves the zoom fit mode - read only -
    //! \return The zoom fit mode
    const Dtk_Camera::ZoomFitModeEnum& GetZoomFitMode() const;
 
    //! \brief Processes the X - along width - zoom factor - read only -
    //! \return The X zoom factor, 0.0 if Dtk_Camera is not valid.
    //! \remark The X Zoom Factor is equal to 1. / GetSemiWidth()
    //! \remark The X Zoom Factor is relevant for Parallel Camera.
    Dtk_Double64 ProcessXZoomFactor() const { return IsValid() ? ( 1. / GetSemiWidth() ) : 0.; }
 
    //! \brief Processes the Y - along height - zoom factor - read only -
    //! \return The Y zoom factor, 0.0 if Dtk_Camera is not valid.
    //! \remark The Y Zoom Factor is equal to 1. / GetSemiHeight()
    //! \remark The Y Zoom Factor is relevant for Parallel Camera.
    Dtk_Double64 ProcessYZoomFactor() const { return IsValid() ? ( 1. / GetSemiHeight() ) : 0.; }
 
    //! \brief Processes the X - along width - Semi Angle - read only -
    //! \image html CameraXSemiAngle.png
    //! \return The X Semi-Angle in Radians, 0.0 if Dtk_Camera is not valid.
    //! \remark The X Semi-Angle is equal to atan( GetSemiWidth() / GetFocusDistance() )
    //! \remark The X Semi-Angle is relevant for Perspective Camera.
    inline Dtk_Double64 ProcessXSemiAngle() const { return IsValid() ? ( atan( GetSemiWidth() / GetFocusDistance() ) ) : 0.; }
 
    //! \brief Processes the Y - along height - Semi Angle - read only -
    //! \image html CameraYSemiAngle.png
    //! \return The Y Semi-Angle in Radians, 0.0 if Dtk_Camera is not valid.
    //! \remark The Y Semi-Angle is equal to atan( GetSemiHeight() / GetFocusDistance() )
    //! \remark The Y Semi-Angle is relevant for Perspective Camera.
    inline Dtk_Double64 ProcessYSemiAngle() const { return IsValid() ? ( atan( GetSemiHeight() / GetFocusDistance() ) ) : 0.; }
 
    //! \deprecated Use TargetPoint() const method instead.
    //! \brief Retrieves the target vector - read only -
    //! \return The target vector
    Dtk_dir TargetVector() const;
 
    //! \deprecated Use ProcessXSemiAngle() const or ProcessYSemiAngle() const methods instead.
    //! \sa ProcessXSemiAngle() const
    //! \return The X Semi angle in Degrees, 0.0 if Dtk_Camera is not valid.
    //! \return The angle
    inline Dtk_Double64 Angle() const { return ProcessXSemiAngle() * 180. / DTK_PI; }
 
    //! \deprecated Use ProcessXZoomFactor() const or ProcessYZoomFactor() const methods instead.
    //! \sa ProcessXZoomFactor() const, 0.0 if Dtk_Camera is not valid.
    //! \brief Processes the X - width - zoom factor - read only -
    //! \return The X zoom factor
    inline Dtk_Double64 ZoomFactor() const { return ProcessXZoomFactor(); }
 
    //! \deprecated This method has been superseed by GetFocusDistance() const method.
    //! \sa GetFocusDistance() const
    inline Dtk_Double64 Focus() const { return GetFocusDistance(); }
 
    //! \brief Checks if the Dtk_Camera is valid. For this:
    //! - The Focus Distance must be >= DTK_TOLERANCE.
    //! - The Semi-Width must be >= DTK_TOLERANCE.
    //! - The Semi-Height must be >= DTK_TOLERANCE.
    //! \return DTK_TRUE if the Dtk_Camera is valid, DTK_FALSE otherwise.
    inline Dtk_bool IsValid() const
    {
        if( GetFocusDistance() < DTK_TOLERANCE ||
            GetSemiWidth() < DTK_TOLERANCE ||
            GetSemiHeight() < DTK_TOLERANCE )
        {
            return DTK_FALSE;
        }
        else
        {
            return DTK_TRUE;
        }
    }
 
     //! \brief set the Front Clipping Distance  et Back Clipping Distance
     void SetClippingDistance(const Dtk_Double64& inFrontDistance ,const Dtk_Double64& inBackDistance ) const;
 
     //! \brief get the Front Clipping Distance  et Back Clipping Distance
     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
//! \brief This is the Hatching Pattern class. This describes a repetition of lines/dots or coloring. It includes line style and colors as well.
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;
 
     //! \BaseConstructor
     Dtk_HatchingPattern() :_angle( 0.0 ), _line_style( 0 ), _line_width( 0.0 ), _offset( 0.0 ), _style( Dtk_HatchingStyle_Unknown ), _pitch( 0.0 ){}
 
     Dtk_HatchingStyle & HatchingStyle ();
     Dtk_Double64 & Offset ();
     Dtk_Double64 & Pitch ();
     Dtk_Double64 & Angle ();
     Dtk_RGB & Color ();
     Dtk_Int32 & LineType ();
     Dtk_Double64 & LineWidth ();
 
    //! \brief Retrieves the hatching style, one of the following : hatching, coloring or dotting.
     //! \return The hatching style : Dtk_HatchingStyle_Hatching, Dtk_HatchingStyle_Coloring or Dtk_HatchingStyle_Dotting
     //! \image html DtkHatchingStyles.png
    const Dtk_HatchingStyle & HatchingStyle () const;
 
     //! \brief Retrieves the position start offset along the hatch line. Applies for hatching and dotting.
     //! \return The first position offset along the hatch line
    const Dtk_Double64 & Offset () const;
     //! \brief Retrieves the position offset perpendicular to the hatch line (or dot). Applies for hatching and dotting.
     //! \return The position offset perpendicular to the hatch line
     //! \image html DtkHatchingPitch.png
    const Dtk_Double64 & Pitch () const;
     //! \brief Retrieves the angle between horizontal line and hatch line (or dot). Applies for hatching and dotting.
     //! \return The angle between horizontal line and hatch line
     //! \image html DtkHatchingAngle.png
    const Dtk_Double64 & Angle () const;
     //! \brief Retrieves the color of the pattern element.
     //! \return The color of the pattern element.
     const Dtk_RGB & Color () const;
     //! \brief Retrieves the hatch line type. Applies for hatching. The value can be casted to enum ::Dtk_FontLineType
     //! Returns one of the following values :
     //! \sa 0 : No Pattern
     //! \sa 1 : ________________________________ Solid
     //! \sa 2 : _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _       Dash
     //! \sa 3 : ________ _ _ _________ _ _ _____ Phantom
     //! \sa 4 : ________ _ _________ _ _________ Center Line
     //! \sa 5 : ................................ Dotted
     //! \sa 6 : ___ ___ ___ ___ ___ ___ ___ ___       Long Dashed
     //! \sa 7 : ___ . ___ . ___ . ___ . ___ . __ Dotted Dashed
     //! \sa 8 : --'\,-----'\,-----'\,-----'\,--- Breakline
    const Dtk_Int32 & LineType () const;
     //! \brief Retrieves the hatch line width. Applies for hatching.
     //! \return The hatch line width
     const Dtk_Double64 & LineWidth () const;
 
};
 
//! \class Dtk_Boundary
//! \brief This is the Boundary class.
//! The boundary defines the curves that delimit a closed area.
class Dtk_Boundary : public Dtk_Object
{
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum
     {
          _typeID = DTK_TYPE_BOUNDARY
     };
 
public:
 
     //! \brief Construct a boundary provided both its exact representation as curves, as well as a simplified representation as a polyline.
     //! \details It is expected that both definitions match, that is to say they represent the same geometry.
     //! In case the simplified representation isn't provided, it will be computed based on the exact representation by calling Dtk_Curve::ToPolyline.
     //! \param[in] exactRepresentation : a contiguous sequence of curves representing the exact definition of the boundary.
     //! \param[in] simplifiedRepresentation : a single polyline representing the boundary.
     Dtk_Boundary( dtk::Span<Dtk_CurvePtr const> exactRepresentation,
                      Dtk_PolylinePtr simplifiedRepresentation );
 
     //! \CopyConstructor{in}
     Dtk_Boundary( const Dtk_Boundary & in );
     //! \MoveConstructor{in}
     Dtk_Boundary( Dtk_Boundary && in ) DTK_NOEXCEPT;
 
     //! \BaseDestructor
     ~Dtk_Boundary();
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType( const Dtk_Int32 &inId );
 
     //! \DtkDynamicCast
     static Dtk_Boundary* DtkDynamicCast( Dtk_Object * );
 
     type_detk get_type_detk() const;
 
     //! \AssignmentOp{in}
     Dtk_Boundary& operator=( const Dtk_Boundary& in );
     //! \MoveOp{in}
     Dtk_Boundary& operator=( Dtk_Boundary && in) DTK_NOEXCEPT;
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform( const Dtk_transfo &inTransfo );
 
     //! \brief Retrieves all curves linked together that makes a boundary.
     //! \return An array of curves, all linked together with ordering.
     dtk::Span<Dtk_CurvePtr> GetExactRepresentation() const;
     //! \brief Retrieves a simplified representation of the boundary as a polyline.
     //! Useful for simple display.
     //! \return The simplified polyline representation of the boundary.
     const Dtk_PolylinePtr& GetSimplifiedRepresentation() const;
};
 
//! \class Dtk_Hatching
//! \brief This is the Hatching class.
//! The hatching fills a closed area delimited by boundaries.
//! The first boundary is the outer bounday, following boundaries are inner boundaries.
//! A hatching area can include several ::Dtk_HatchingPattern patterns (repetition of decorated/styled lines, dots or simple solid coloring).
//! \image html DtkHatching.png
//! \SmartPtr{Dtk_HatchingPtr}
class Dtk_Hatching : public Dtk_Entity
{
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_HATCHING
     };
     //! \sa Create()
     Dtk_Hatching();
 
     //! \sa Create(const Dtk_Hatching&)
     Dtk_Hatching(const Dtk_Hatching &);
     Dtk_Hatching( Dtk_Hatching&& in ) DTK_NOEXCEPT;
 
     //! \BaseDestructor
     ~Dtk_Hatching();
 
    inline virtual Dtk_Object* Clone() { return new Dtk_Hatching(*this); }
 
private:
     friend class Dtk_SmartPtr<Dtk_Hatching>;
    void __GeneratePatternGeometries( const Dtk_HatchingPattern& inHatchingPattern, const Dtk_Oriented2dBBox& BoundariesBBox, Dtk_tab< Dtk_EntityPtr >& inoutResultEntities );
public:
 
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_Hatching* DtkDynamicCast(Dtk_Object *s);
 
     //! \CreateBase
     static Dtk_HatchingPtr Create();
     //! \CreateCopy{in}
     static Dtk_HatchingPtr Create( const Dtk_Hatching& in );
 
     type_detk get_type_detk() const;
 
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     //! \brief Retrieves the hatching area boundaries as a span. The first boundary is the outer boundary.
     //! \warning If returned span is empty, please use Dtk_tab<Dtk_PolylinePtr> &Boundaries() to retrieve boundaries.
     //! \return The boundaries
     //! \see dtk::Span
     dtk::Span<Dtk_Boundary> GetBoundaries() const;
 
     //! \brief Adds a boundary to the hatching area.
     //! \param boundary The boundary to add.
     void AddBoundary( Dtk_Boundary boundary );
 
     //! \brief Retrieves the hatching area boundaries as an array (of ordered polylines). The first boundary (this->Boundaries[0]) is the outer boundary.
     //! \return The boundaries
     Dtk_tab<Dtk_PolylinePtr> &Boundaries();
 
     //! \brief Retrieves the hatching area patterns. Patterns describes hatch line presentations (angle, pitch etc...)
     //! \return The patterns as Dtk_HatchingPattern objects
     Dtk_tab<Dtk_HatchingPattern> & Patterns();
 
     //! \brief Specify if applying transform also scales pattern data. Not active by default.
     //! \param inApply Boolean denoting if scale shall be applied on pattern data - true by default -.
     void SetApplyScaleOnPattern( bool inApply = true );
 
    //! \brief Generate Pattern geometries from Dtk_Hatching.
    //! \param inXRefDir X reference vector - (1,0,0) by default -.
    //! \param inNormalDir Normal vector - (0,0,1) by default -.
    //! \return The generated geometries as Dtk_tab< Dtk_EntityPtr >
    //! \remark At this moment, we only handle hatching patterns - no point/fill pattern -.
    Dtk_tab< Dtk_EntityPtr > GeneratePatternGeometries(const Dtk_dir& inXRefDir = Dtk_dir(1., 0., 0.), const Dtk_dir& inNormalDir = Dtk_dir(0., 0., 1.) );
};
 
 
//! \ingroup draw
//! \class Dtk_CompositeEntity
//! \brief This is the Dtk_CompositeEntity class.
//! \SmartPtr{Dtk_CompositeEntityPtr}
class Dtk_CompositeEntity : public Dtk_2dEntity
{
protected:
     struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
     enum {
          _typeID = DTK_TYPE_COMPOSITE_ENTITY
     };
 
     //! \sa Create()
     Dtk_CompositeEntity();
     //! \sa Create(const Dtk_CompositeEntity&)
     Dtk_CompositeEntity(const Dtk_CompositeEntity &s);
     Dtk_CompositeEntity( Dtk_CompositeEntity&& in ) DTK_NOEXCEPT;
 
     inline virtual Dtk_Object* Clone() { return new Dtk_CompositeEntity(*this); }
     //! \BaseDestructor
     ~Dtk_CompositeEntity();
private:
     friend class Dtk_SmartPtr<Dtk_CompositeEntity>;
public:
     //! Resets all sub entities
     void Clear();
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_CompositeEntity * DtkDynamicCast(Dtk_Object *s);
 
     //! \return The type of the entity type - DTK_TYPE_VIEW -
     type_detk get_type_detk() const
     {
          return DTK_TYPE_COMPOSITE_ENTITY;
     }
 
     //! \CreateBase
     static Dtk_CompositeEntityPtr Create();
 
     //! \CreateCopy{in}
     static Dtk_CompositeEntityPtr Create(const Dtk_CompositeEntity &in);
 
     //! \brief Adds a Dtk_EntityPtr to the Dtk_CompositeEntity
    //! For that, it will check if the Dtk_EntityPtr is not NULL and if it has a handled type.\n
    //! The handled types are  Dtk_CurvePtr / Dtk_PointPtr / Dtk_2dEntityPtr / Dtk_HatchingPtr.
     //! \param inElt The Dtk_EntityPtr to be added.
    //! \return DtkNoError if OK.
    //! \return dtkErrorNullPointer if inElt.IsNULL().
    //! \return dtkErrorTypeNotsupported if the entity type is not supported.
    Dtk_ErrorStatus AddEntity(const Dtk_EntityPtr &inElt );
 
     //! \brief Adds an array of Dtk_EntityPtr.
    //! Calls Dtk_CompositeEntity::AddEntity for each elements.
     //! \param inEltArray Array of Dtk_EntityPtr to be added.
     //! \return DtkNoError if OK.
    void AddEntities(const Dtk_tab<Dtk_EntityPtr>& inEltArray);
 
    //! \brief Adds a Dtk_picturePtr to the Dtk_CompositeEntity
    //! For that, it will check if the Dtk_picturePtr is not NULL.
    //! \param inElt The Dtk_picturePtr to be added.
    //! \return DtkNoError if OK.
    //! \return dtkErrorNullPointer if inElt.IsNULL().
    Dtk_ErrorStatus AddPicture( const Dtk_picturePtr &inElt );
 
    //! \brief Adds an array of Dtk_EntityPtr.
    //! Calls Dtk_CompositeEntity::AddPicture for each elements.
    //! \param inEltArray Array of Dtk_picturePtr to be added.
    //! \return DtkNoError if OK.
    void AddPictures( const Dtk_tab<Dtk_picturePtr>& inEltArray );
 
    //! \brief Retrieves the number of Dtk_EntityPtr in Dtk_CompositeEntity
    //! \return size of the array
    Dtk_Size_t GetNumEntities() const;
 
    //! \brief Retrieves the ith Dtk_EntityPtr.
    //! \param inPos Dtk_EntityPtr index.
    //! \return the inPos'th Dtk_EntityPtr.
    Dtk_EntityPtr GetEntity( const Dtk_Size_t& inPos ) const;
 
    //! \brief Retrieves the number of Dtk_picturePtr in Dtk_CompositeEntity
    //! \return size of the array
    Dtk_Size_t GetNumPictures() const;
 
    //! \brief Retrieves the ith Dtk_picturePtr.
    //! \param inPos Dtk_picturePtr index.
    //! \return the inPos'th Dtk_picturePtr.
    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;
     //! \Transform{inTransfo}
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
};
 
 
//! \class Dtk_Region
//! \brief This is the Region class.
//! The region that designates areas of your model for special purposes, such as an area affected by a datum target.
//! The region can contain a hatching pattern and boundaries that are stored as geometries.
//!  <P> <B> Types of regions: </B>  </P>
//!  <P> Here are different region types with their specificities </P>
//! \image html Dtk_Region.png
//! \SmartPtr{Dtk_RegionPtr}
class Dtk_Region : public Dtk_Annotation
{
public:
    enum RegionType
    {
        RectangularType,
        CircularType,
        AnnularType,
        CylindricalType,
        ArbitraryType,
        UnknownType
    };
protected:
    struct Dtk_Handle; // Not defined here
     std::unique_ptr<Dtk_Handle> _Private; // Handle
    enum
    {
        _typeID = DTK_TYPE_REGION
    };
    //! \sa Create(RegionType, Dtk_HatchingPattern&, Dtk_tab< Dtk_EntityPtr > )
    Dtk_Region(RegionType inType,
               Dtk_HatchingPattern &inHatchingPattern,
               Dtk_tab< Dtk_EntityPtr > inGeometries);
 
    Dtk_Region(const Dtk_Region &s);
    Dtk_Region( Dtk_Region && s) DTK_NOEXCEPT;
    ~Dtk_Region();
 
    inline virtual Dtk_Object* Clone() { return new Dtk_Region(*this); }
 
private:
    friend class Dtk_SmartPtr<Dtk_Region>;
public:
 
 
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    //! \DtkDynamicCast
    static Dtk_Region* DtkDynamicCast(Dtk_Object *s);
 
     //! \brief Calls full featured constructor to allocate a new object.
    static Dtk_RegionPtr Create(RegionType inType,
                                Dtk_HatchingPattern &inHatchingPattern,
                                Dtk_tab< Dtk_EntityPtr > inGeometries);
     static Dtk_RegionPtr Create( Dtk_Region const& in );
 
    type_detk get_type_detk() const { return DTK_TYPE_REGION; }
 
    //! \Transform{inTransfo}
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
    //! \brief Retrieves the Dtk_Region boundaries as geometries.
    //! \return Dtk_Region boundaries as geometries.
    Dtk_tab< Dtk_EntityPtr > GetGeometries() const;
 
    //! \brief Processes all the Dtk_Annotation anchor points.
    //! \param outTabPnts The resulting anchor point array.
    //! \return dtkNoError if OK
    Dtk_ErrorStatus GetAnchorPoints(
        Dtk_pnt(&outTabPnts)[DTK_NB_ANCHOR_TYPES]) const;
 
    //! \brief Sets the Dtk_Annotation anchor point.
    //! \param inNewLocation The new location point.
    //! \param inLocationAnchorType The anchor type related to the new location.
    //! \return dtkNoError if OK
    Dtk_ErrorStatus SetAnchorPoint(const Dtk_pnt &inNewLocation,
                                   const Dtk_anchor_type &inLocationAnchorType);
 
    //! \brief Sets the location point of the Dtk_Annotation
    //! \brief The location point is related to the anchor type
    //! \param inLocation the location point
    //! \return dtkNoError if OK
    Dtk_ErrorStatus SetLocation(const Dtk_pnt &inLocation);
 
    //! \brief Sets the offset of the Dtk_Annotation
    //! \brief The Offset is used to process bounding frames.
    //! \param inOffset The offset
    //! \return dtkNoError if OK
    Dtk_ErrorStatus SetOffset(const Dtk_Double64 &inOffset);
 
    //! \brief Gets the type of the region
    //! \return the type of region
    RegionType GetType() const;
 
    //! \brief Sets the width of the rectangular Dtk_Region
    //! \brief This is a semantic information (will not modify geometries)
    //! \param inWidth The width
    //! \return dtkNoError if OK, dtkErrorAttributeNotFound if it is not a rectangular region
    Dtk_ErrorStatus SetRectangularWidth(Dtk_Double64 inWidth);
 
    //! \brief Gets the width of the rectangular Dtk_Region
    //! \brief This is a semantic information (will not modify geometries)
    //! \param outWidth The width
    //! \return dtkNoError if OK, dtkErrorAttributeNotFound if it is not a rectangular region
    Dtk_ErrorStatus GetRectangularWidth(Dtk_Double64 &outWidth) const;
 
    //! \brief Sets the height of the rectangular Dtk_Region
    //! \brief This is a semantic information (will not modify geometries)
    //! \param inWidth The height
    //! \return dtkNoError if OK, dtkErrorAttributeNotFound if it is not a rectangular region
    Dtk_ErrorStatus SetRectangularHeight(Dtk_Double64 inHeight);
 
    //! \brief Gets the height of the rectangular Dtk_Region
    //! \brief This is a semantic information (will not modify geometries)
    //! \param outWidth The height
    //! \return dtkNoError if OK, dtkErrorAttributeNotFound if it is not a rectangular region
    Dtk_ErrorStatus GetRectangularHeight(Dtk_Double64 &outHeight) const;
 
    //! \brief Sets the diameter of the circular Dtk_Region
    //! \brief This is a semantic information (will not modify geometries)
    //! \param inDiameter The diameter
    //! \return dtkNoError if OK, dtkErrorAttributeNotFound if it is not a circular region
    Dtk_ErrorStatus SetCircularDiameter(Dtk_Double64 inDiameter);
 
    //! \brief Gets the diameter of the circular Dtk_Region
    //! \brief This is a semantic information (will not modify geometries)
    //! \param outDiameter The diameter
    //! \return dtkNoError if OK, dtkErrorAttributeNotFound if it is not a circular region
    Dtk_ErrorStatus GetCircularDiameter(Dtk_Double64 &outDiameter) const;
 
    //! \brief Sets the outer diameter of the annular Dtk_Region
    //! \brief This is a semantic information (will not modify geometries)
    //! \param inDiameter The outer diameter
    //! \return dtkNoError if OK, dtkErrorAttributeNotFound if it is not a annular region
    Dtk_ErrorStatus SetAnnularOuterDiameter(Dtk_Double64 inDiameter);
 
    //! \brief Gets the outer diameter of the annular Dtk_Region
    //! \brief This is a semantic information (will not modify geometries)
    //! \param outDiameter The outer diameter
    //! \return dtkNoError if OK, dtkErrorAttributeNotFound if it is not a annular region
    Dtk_ErrorStatus GetAnnularOuterDiameter(Dtk_Double64 &outDiameter) const;
 
    //! \brief Sets the inner diameter of the annular Dtk_Region
    //! \brief This is a semantic information (will not modify geometries)
    //! \param inDiameter The inner diameter
    //! \return dtkNoError if OK, dtkErrorAttributeNotFound if it is not a annular region
    Dtk_ErrorStatus SetAnnularInnerDiameter(Dtk_Double64 inDiameter);
 
    //! \brief Gets the inner diameter of the annular Dtk_Region
    //! \brief This is a semantic information (will not modify geometries)
    //! \param outDiameter The inner diameter
    //! \return dtkNoError if OK, dtkErrorAttributeNotFound if it is not a annular region
    Dtk_ErrorStatus GetAnnularInnerDiameter(Dtk_Double64 &outDiameter) const;
 
    //! \brief Gets Hatching Pattern of the region Dtk_Region
    //! \brief This is a semantic information (will not modify geometries)
    //! \return the hatching patter if available
    Dtk_HatchingPattern const& GetHatchingPattern() const;
 
 
};
 
 
#endif