util_ent_dtk.hpp

Go to the documentation of this file.

#ifndef _UTIL_ENT_DTK_HPP_
#define _UTIL_ENT_DTK_HPP_
 
#include "util/BaseTypes/dtk_metadata.hpp"
#include "util/BaseTypes/dtk_object.hpp"
#include "util/BaseTypes/dtk_transfo.hpp"
#include "util/BaseTypes/dtk_rgb.hpp"
#include "util/dtk_maindoc_ptr.hpp"
#include "util/error_dtk.hpp"
#include "util/util_draw_ptr_dtk.hpp"
#include "util/util_ptr_dtk.hpp"
#include "util_stl_dtk.hpp"
#include "def/define.h"
#include "dtk/config.hpp"
#include <iosfwd>
#include "util/dtk_val.hpp"
 
class Dtk_Entity;
class Dtk_material;
class Dtk_MetaData;
 
template <class T> class Dtk_SmartPtr;
 
typedef Dtk_SmartPtr<Dtk_material>              Dtk_MaterialPtr;
 
enum Dtk_PointType {
    DTK_PT_UNSPECIFIED = 0,
    DTK_PT_CROSS,           // a cross which looks like a "X"
    DTK_PT_PLUS,              // a cross which looks like a "+"
    DTK_PT_CONCENTRIC,      // an unfilled circle
    DTK_PT_COINCIDENT,      // two unfilled concentric circles
    DTK_PT_FULLCIRCLE,      // a filled circle
    DTK_PT_FULLSQUARE,      // a filled square
    DTK_PT_STAR,            // a star which is the union of a 2D marker CROSS, a 2D marker PLUS and a 2D marker DOT
    DTK_PT_DOT,             // a dot
    DTK_PT_SMALLDOT,        // a small dot whose size is one pixel
    DTK_PT_BIGFULLCIRCLE,   // a big filled circle
    DTK_PT_BIGFULLSQUARE,   // a big filled square
     DTK_PT_SQUARE,          // an unfilled square
     DTK_PT_UP_TRIANGLE,     // a triangle pointing up
     DTK_PT_DIAMOND          // a square rotated by 90 degrees
};
 
enum Dtk_FontLineType {
    DTK_NO_PATTERN = 0,
    // ________________________________
    DTK_SOLIDLINE,
    // _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
    DTK_DASHED,
    // ________ _ _ _________ _ _ _____
    DTK_PHANTOM,
    // ________ _ _________ _ _________
    DTK_CENTERLINE,
    // ................................
    DTK_DOTTED,
    // ___ ___ ___ ___ ___ ___ ___ ___
    DTK_LONG_DASHED,
    // ___ . ___ . ___ . ___ . ___ . __
    DTK_DOTTED_DASHED,
    // --'\,-----'\,-----'\,-----'\,---
    DTK_BREAKLINE,
    DTK_NUM_FONT_LINE_TYPES
};
 
extern   int dtk_AddColorInTable(const Dtk_RGB&);
 
class Dtk_Object;
template <class T>
class Dtk_SmartPtr;
class Dtk_Val;
struct Dtk_string_compare;
class Dtk_Info;
 
//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;
 
class Dtk_UUID;
class Dtk_pnt;
class Dtk_dir;
class Dtk_RGB;
class Dtk_string;
 
 
 
 
 
 
struct Dtk_string_compare
{
  bool operator()(const Dtk_string& s1, const Dtk_string& s2) const
  {
    return s1.cmp(s2) < 0;
  }
};
 
struct Dtk_string_compare_case_insensitive
{
     bool operator()(const Dtk_string& s1, const Dtk_string& s2) const
     {
          return s1.icmp(s2) < 0;
     }
};
class Dtk_Info : public Dtk_Object
{
 
protected:
    enum { _typeID = DTK_TYPE_INFO };
    struct Dtk_Handle;       // Not defined here
    Dtk_Handle *_Private;   // Handle
    Dtk_MaterialPtr _Material;
    void _init();
    void _copy(const Dtk_Info& s);
    void _reset();
    Dtk_Info();
    Dtk_Info(const Dtk_Info& s);
    Dtk_Info( Dtk_Info&& s) DTK_NOEXCEPT;
    friend class Dtk_SmartPtr<Dtk_Info>;
    virtual Dtk_Object* Clone() { return new Dtk_Info(*this); }
public:
     enum MandatoryFlag
     {
          NotMandatory = 0,
          XYPlane,
          YZPlane,
          ZXPlane,
          OriginPoint
     };
 
    //downcasting
    int DtkDynamicType(const Dtk_Int32& inId);
    static Dtk_Info* DtkDynamicCast(Dtk_Object * s);
 
    static Dtk_SmartPtr<Dtk_Info> create(const Dtk_Info& s);
    static Dtk_SmartPtr<Dtk_Info> create( Dtk_Info&& s );
    static Dtk_SmartPtr<Dtk_Info> create();
    ~Dtk_Info();
 
    Dtk_ErrorStatus AddAttribute( Dtk_string name, Dtk_Val val); 
 
    Dtk_ErrorStatus FindAttribute(const Dtk_string& name, Dtk_Val& val) const;
    Dtk_Val const * FindAttribute(const Dtk_string& name) const; // If not found, returns nullptr.
    Dtk_ErrorStatus ListAttributes(const Dtk_string& substring, Dtk_tab<Dtk_string>& tab_keys) const;
    Dtk_ErrorStatus ListAllAttributes(Dtk_tab<Dtk_string>& tab_keys) const;
     Dtk_ErrorStatus ListAllAttributesWithVal(Dtk_tab<Dtk_pair<Dtk_string,Dtk_Val> >& tab) const;
     Dtk_ErrorStatus RemoveAttribute(const Dtk_string& name);
 
     Dtk_ErrorStatus SetAdditionnalGeometryFlag(const Dtk_Int32& inAdditionnalGeom);
     Dtk_ErrorStatus SetUse(const Dtk_Int32& inUse);
     Dtk_ErrorStatus SetActivationFlag(const Dtk_Int32& inActivation);
     Dtk_ErrorStatus SetFlexibleFlag(const Dtk_Int32& inIsFlexible);
     Dtk_ErrorStatus SetActiveChildren(const Dtk_tab<Dtk_Int32> &inIndices);
     Dtk_ErrorStatus SetDefaultChildIndex(const Dtk_Int32& inIndex);
     Dtk_ErrorStatus SetHierarchy(const Dtk_Int32& inHierarchy);
     Dtk_ErrorStatus SetHierarchyColorFlag(const Dtk_Int32& inHierarchy);
    Dtk_ErrorStatus SetFontId(const Dtk_Int32& inFontId);
    Dtk_ErrorStatus SetFormFlag(const Dtk_Int32& inFormFlag);
    Dtk_ErrorStatus SetMatId(const Dtk_Int32& inMatId);
    Dtk_ErrorStatus SetSubordFlag(const Dtk_Int32& inSubordFlag);
    Dtk_ErrorStatus SetId(const Dtk_Int32& inId);
    Dtk_ErrorStatus SetViewId(const Dtk_Int32& inViewId);
     Dtk_ErrorStatus SetColor( const int&R, const int&G, const int&B );// {return SetColorId( dtk_AddColorInTable( Dtk_RGB( R, G, B ) ) ); }
     Dtk_ErrorStatus SetColor( const Dtk_RGB & inColor );// {return SetColorId( dtk_AddColorInTable( inColor ) ); }
 
 
    Dtk_ErrorStatus SetColorId(const Dtk_Int32& inColorId);
     Dtk_ErrorStatus SetName( Dtk_string inName);
     Dtk_ErrorStatus SetPersistentName( Dtk_string inName);
    Dtk_ErrorStatus SetLayer(const Dtk_Int32 & inLayer);
    Dtk_ErrorStatus SetBlankedStatus(const Dtk_Int32 &inBlankedStatus);
    Dtk_ErrorStatus SetCurveThickNess(const Dtk_Int32 &inCurveThickNess);
     Dtk_ErrorStatus AddCurveLineTypeDefinition( const Dtk_LineTypeDefinitionPtr & inLineTypeDefinition );
     Dtk_ErrorStatus SetCurveLineTypeDefinitionId( const Dtk_ID & inLineTypeDefinitionId );
     Dtk_ErrorStatus SetCurveLineType(const Dtk_Int32 &inCurveLineType);
    Dtk_ErrorStatus SetCurveThickNessInMM(const Dtk_Double64 inCurveThickNessInMM);
    Dtk_ErrorStatus SetPointSymbolType(const Dtk_PointType inPointSymbolType);
     Dtk_ErrorStatus SetInfiniteGeometryFlag(const Dtk_Int32 &inInfiniteGeometryFlag);
     Dtk_ErrorStatus SetRefEntityFlag( const Dtk_Int32 &inRefEntityFlag );
     Dtk_ErrorStatus SetMandatoryFlag(const enum MandatoryFlag &inMandatoryFlag);
     Dtk_ErrorStatus SetUuid(const Dtk_UUID &inUuid);
     Dtk_ErrorStatus SetAddedItemFlag(const Dtk_Int32 &inAddedItem);
     Dtk_ErrorStatus SetMetaData(Dtk_tab<Dtk_MetaDataPtr>& inArray) ;
     Dtk_ErrorStatus AddLayer(const Dtk_Int32 & inLayer);
     //Deprecated use AddRenderInfos and AddMaterialInfos methods instead
     Dtk_ErrorStatus  AddMaterial( const Dtk_MaterialPtr &inMaterial );
     Dtk_ErrorStatus AddPhysicalMaterialInfos( const Dtk_PhysicalMaterialInfosPtr &inMaterial );
     Dtk_ErrorStatus SetPhysicalMaterialInfosId( const Dtk_ID &inMaterialId );
     Dtk_ErrorStatus AddRenderInfos( const Dtk_RenderInfosPtr &inRender );
     Dtk_ErrorStatus SetRenderInfosId( const Dtk_ID &inRenderId );
 
 
     int         GetActivationFlag() const;
     int            GetFlexibleFlag() const;
     Dtk_tab<Dtk_Int32> GetActiveChildren() const;
     int         GetDefaultChildIndex() const;
     int         GetAdditionnalGeometryFlag() const;
     int         GetUse() const;
     int         GetAddedItemFlag() const;
     int         GetHierarchy() const;
     int         GetHierarchyColorFlag() const;
    int         GetFontId() const;
    int         GetFormFlag() const;
    int         GetMatId() const;
    int         GetSubordFlag() const;
    int         GetId() const;
    int         GetViewId() const;
     Dtk_tab<Dtk_Int32> GetlayerList() const;
 
    Dtk_RGB     GetColor() const;
    int         GetColorId() const;
 
     Dtk_string  GetName() const;
     Dtk_string  GetPersistentName() const;
 
    int         GetLayer() const;
 
    int         GetBlankedStatus() const;
 
     int         GetCurveThickNess() const;
 
     Dtk_Double64  GetCurveThickNessInMM() const;
 
     Dtk_FontLineType      GetCurveLineType() const;
 
     Dtk_LineTypeDefinitionPtr GetCurveLineTypeDefinition() const;
 
     Dtk_ID GetCurveLineTypeDefinitionId() const;
 
     Dtk_PointType         GetPointSymbolType() const;
 
     enum MandatoryFlag GetMandatoryFlag() const;
 
 
     int         GetInfiniteGeometryFlag() const;
     int         GetRefEntityFlag() const;
     Dtk_UUID    GetUuid() const;
     Dtk_ErrorStatus GetMetaData(Dtk_tab<Dtk_MetaDataPtr>& outArray) const;
 
     //Deprecated use GetRenderInfos() and GetPhysicalMaterialInfos() methods instead.
     Dtk_MaterialPtr GetMaterial() const;
 
     Dtk_RenderInfosPtr GetRenderInfos() const;
 
     Dtk_ID GetRenderInfosId() const;
 
     Dtk_PhysicalMaterialInfosPtr GetPhysicalMaterialInfos() const;
 
     Dtk_ID GetPhysicalMaterialInfosId() const;
 
     Dtk_ErrorStatus SetBuildingInfosIds(const Dtk_tab<Dtk_Int32> inBuildingInfos);
     Dtk_tab<Dtk_Int32> GetBuildingInfosIds() const;
 
 
     Dtk_ErrorStatus GetProperties(Dtk_tab<Dtk_PropertiesPtr>& outArray) const;
     Dtk_ErrorStatus GetReferenceSet(Dtk_tab<Dtk_string>& outArray, Dtk_Int32 inRemovePrefix=DTK_FALSE ) const;
     Dtk_string      GetConfigurationName() const;
     Dtk_ErrorStatus SetConfigurationName( const Dtk_string &inName );
 
     Dtk_bool GetIsUpToDate() const;
     void SetIsUpToDate( const Dtk_bool isUpToDate );
 
 
    friend std::ostream& operator<<(std::ostream& o,const Dtk_Info& d);
     virtual Dtk_Size_t GetSize() const;
     virtual Dtk_ErrorStatus _Store(void*);
};
 
 
class Dtk_Entity : public Dtk_Object
{
protected:
    struct Dtk_Handle;       // Not defined here
    Dtk_Handle *_Private;   // Handle
    enum { _typeID = DTK_TYPE_ENTITY };
    void _init();
    void _copy(const Dtk_Entity& s);
    void _reset();
 
    virtual Dtk_Object* Clone() = 0;
    friend class Dtk_SmartPtr<Dtk_Entity>;
public:
    Dtk_Entity();
     Dtk_Entity(const Dtk_Entity& s);
     Dtk_Entity( Dtk_Entity&& s) DTK_NOEXCEPT;
     Dtk_Entity& operator=( const Dtk_Entity& s );
     Dtk_Entity& operator=( Dtk_Entity&& s ) DTK_NOEXCEPT;
 
     virtual ~Dtk_Entity();
     const Dtk_ID& GetID() const;
 
    virtual enum type_detk get_type_detk() const=0;
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Entity* DtkDynamicCast(Dtk_Object * s);
 
    Dtk_InfoPtr get_info() const;
    Dtk_InfoPtr& info();
     //virtual Dtk_status Transform(const Dtk_transfo& inTransfo)=0;
     virtual Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo)=0;
    friend std::ostream& operator<<(std::ostream& o,const Dtk_Entity& d);
 
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
 
     virtual void PrepareTransfo ();
};
 
 
class Dtk_LayerInfosSet;
class Dtk_ColorInfosSet;
class Dtk_LayerFilterInfos;
class Dtk_AxisSystem;
class Dtk_ModelDisplay;
class Dtk_Constraint;
class Dtk_ConstraintReference;
typedef Dtk_SmartPtr<Dtk_LayerInfosSet> Dtk_LayerInfosSetPtr;
typedef Dtk_SmartPtr<Dtk_ColorInfosSet> Dtk_ColorInfosSetPtr;
typedef Dtk_SmartPtr<Dtk_LayerFilterInfos> Dtk_LayerFilterInfosPtr;
typedef Dtk_SmartPtr<Dtk_AxisSystem> Dtk_AxisSystemPtr;
typedef Dtk_SmartPtr<Dtk_ModelDisplay> Dtk_ModelDisplayPtr;
typedef Dtk_SmartPtr<Dtk_Constraint> Dtk_ConstraintPtr;
typedef Dtk_SmartPtr<Dtk_ConstraintReference> Dtk_ConstraintReferencePtr;
 
 
 
 
class Dtk_LayerFilterInfos: public Dtk_Object
{
protected:
    struct Dtk_Handle; // Not defined here
    Dtk_Handle *_Private; // Handle
    enum { _typeID = DTK_TYPE_LAYER_FILTER_INFOS };
 
    Dtk_LayerFilterInfos(const Dtk_Size_t inNumLayers, Dtk_string inName = L"", Dtk_string inDescription = L"", const Dtk_bool inAreLayersActivatedByDefault = DTK_FALSE);
    Dtk_LayerFilterInfos(const Dtk_LayerFilterInfos& s);
    ~Dtk_LayerFilterInfos();
    void _Init(const Dtk_Size_t inNumLayers);
    void _Copy(const Dtk_LayerFilterInfos &s);
    void _Reset();
    friend class Dtk_SmartPtr< Dtk_LayerFilterInfos >;
    friend class Dtk_LayerInfosSet;
public:
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    static Dtk_LayerFilterInfos * DtkDynamicCast(Dtk_Object *s);
 
    type_detk get_type_detk() const { return DTK_TYPE_LAYER_FILTER_INFOS; }
 
    void SelectLayer(const Dtk_Size_t inNumLayer);
 
    void SelectLayers(const Dtk_tab< Dtk_Size_t >& inNumLayers);
 
    void UnselectLayer(const Dtk_Size_t inLayerPos);
 
    void UnselectLayers(const Dtk_tab< Dtk_Size_t >& inNumLayers);
 
 
    Dtk_bool IsLayerSelected(const Dtk_Size_t inLayerPos) const;
 
    void GetSelectedLayers(Dtk_tab< Dtk_Size_t >& outSelectedLayers) const;
 
    void GetName(Dtk_string& outLayerFilterName) const;
 
    void GetDescription(Dtk_string& outLayerFilterDescription) const;
};
 
class Dtk_LayerInfosSet : public Dtk_Object
{
public:
protected:
    struct Dtk_Handle; // Not defined here
    Dtk_Handle *_Private; // Handle
    enum { _typeID = DTK_TYPE_LAYER_INFOS_SET };
    Dtk_LayerInfosSet(const Dtk_Size_t inNumLayers);
 
    Dtk_LayerInfosSet(const Dtk_LayerInfosSet &s);
    virtual Dtk_Object* Clone() { return new Dtk_LayerInfosSet(*this); }
 
    ~Dtk_LayerInfosSet();
private:
    void _Init(const Dtk_Size_t inNumLayers);
    void _Copy(const Dtk_LayerInfosSet &s);
    void _Reset();
    friend class Dtk_SmartPtr<Dtk_LayerInfosSet>;
public:
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    static Dtk_LayerInfosSet * DtkDynamicCast(Dtk_Object *s);
 
    type_detk get_type_detk() const { return DTK_TYPE_LAYER_INFOS_SET; }
 
    static Dtk_LayerInfosSetPtr Create(const Dtk_Size_t inNumLayers);
 
    Dtk_LayerFilterInfosPtr CreateLayerFilterInfos( Dtk_string inName = L"",  Dtk_string inDescription = L"", const Dtk_bool inAreLayersActivatedByDefault = DTK_FALSE, const Dtk_bool IsDefaultLayerFilter = DTK_FALSE);
 
    Dtk_Size_t GetNumLayers() const;
 
    Dtk_Size_t GetNumLayerFilters() const;
 
    Dtk_ErrorStatus SetLayerName(const Dtk_Size_t inLayerPos, const Dtk_string& inLayerName);
 
     Dtk_ErrorStatus GetLayerName( const Dtk_Size_t inLayerPos, Dtk_string& outLayerName ) const;
 
     Dtk_ErrorStatus GetLayerNameById( const Dtk_ID inLayerID, Dtk_string& outLayerName ) const;
 
    Dtk_ErrorStatus SetDefaultLayer(const Dtk_Size_t inDefaultLayer);
 
    Dtk_ErrorStatus GetDefaultLayer(Dtk_Size_t& outDefaultLayer) const;
 
    Dtk_ErrorStatus GetDefaultLayerFilter(Dtk_Size_t& outDefaultLayerFilter) const;
 
    Dtk_LayerFilterInfosPtr GetLayerFilterByPos(const Dtk_Size_t inLayerFilterPos) const;
 
     Dtk_ErrorStatus SetLayerID(const Dtk_Size_t inLayerPos, const Dtk_ID& inLayerID);
 
     Dtk_ErrorStatus GetLayerID(const Dtk_Size_t inLayerPos, Dtk_ID& outLayerID) const;
 
};
 
 
class Dtk_ColorInfosSet : public Dtk_Object
{
public:
protected:
     struct Dtk_Handle; // Not defined here
     Dtk_Handle *_Private; // Handle
     enum { _typeID = DTK_TYPE_COLOR_INFOS_SET};
     Dtk_ColorInfosSet(const Dtk_Size_t inNumColors);
 
     Dtk_ColorInfosSet(const Dtk_ColorInfosSet &s);
     virtual Dtk_Object* Clone() { return new Dtk_ColorInfosSet(*this); }
 
     ~Dtk_ColorInfosSet();
private:
     void _Init(const Dtk_Size_t inNumColors);
     void _Copy(const Dtk_ColorInfosSet &s);
     void _Reset();
     friend class Dtk_SmartPtr<Dtk_ColorInfosSet>;
public:
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     static Dtk_ColorInfosSet * DtkDynamicCast(Dtk_Object *s);
 
     type_detk get_type_detk() const { return DTK_TYPE_COLOR_INFOS_SET; }
 
     static Dtk_ColorInfosSetPtr Create(const Dtk_Size_t inNumColors);
 
     Dtk_Size_t GetNumColors() const;
 
     Dtk_Size_t AddColor(const Dtk_ID inColorReadId, const Dtk_string& inColorName,const Dtk_RGB& inColorDef);
 
 
     Dtk_ErrorStatus SetColorName(const Dtk_Size_t inColorPos, const Dtk_string& inColorName);
 
     Dtk_ErrorStatus GetColorName(const Dtk_Size_t inColorPos, Dtk_string& outColorName) const;
 
     Dtk_ErrorStatus GetColorNameById(const Dtk_ID inColorReadId, Dtk_string& outColorName) const;
 
     Dtk_ErrorStatus SetDefaultColor(const Dtk_Int32 inDefaultColor);
 
     Dtk_ErrorStatus GetDefaultColor(Dtk_Int32& outDefaultColor) const;
 
     Dtk_ErrorStatus SetColorID(const Dtk_Size_t inColorPos, const Dtk_ID& inColorReadID);
 
     Dtk_ErrorStatus GetColorID(const Dtk_Size_t inColorPos, Dtk_ID& outColorReadID) const;
 
     Dtk_ErrorStatus GetColorDefinition(const Dtk_Size_t inColorPos, Dtk_RGB& outColorDef) const;
 
};
 
class Dtk_Preview;
typedef Dtk_SmartPtr<Dtk_Preview> Dtk_PreviewPtr;
 
 
class Dtk_Preview: public Dtk_Object
{
public:
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Preview * DtkDynamicCast(Dtk_Object * s);
 
    //constructors
    static Dtk_PreviewPtr Create(const Dtk_Preview& s);
    static Dtk_PreviewPtr Create(const char* inStream,const Dtk_Int32 inSizeStream);
    char *GetStream();
    Dtk_Int32 GetStreamSize();
    preview_type_detk GetType();
    void SetType(preview_type_detk inPreviewType);
 
protected:
    Dtk_Preview();
    Dtk_Preview(const char* inStream,const Dtk_Int32 inSizeStream);
    virtual ~Dtk_Preview();
    struct Dtk_Handle;
    Dtk_Handle *_Private;
    void _Init();
    void _Copy(const Dtk_Preview& s);
    void _Reset();
    friend class Dtk_SmartPtr<Dtk_Preview>;
};
 
 
class Dtk_AxisSystem : public Dtk_Entity
{
public:
 
    Dtk_AxisSystem(const Dtk_AxisSystem& p);
    Dtk_AxisSystem& operator=(const Dtk_AxisSystem& p);
 
 
    Dtk_string GetName() const;
    void SetName(const Dtk_string& in) ;
 
    const Dtk_transfo& GetMatrix() const;
 
    void SetMatrix(const Dtk_transfo& in) ;
 
    int GetIsVisible() const;
    void SetIsVisible() ;
 
    int GetIsHidden() const;
    void SetIsHidden() ;
 
    Dtk_bool IsDefault() const;
    void SetDefaultStatus(Dtk_bool inDefaultStatus) ;
 
 
 
    type_detk get_type_detk() const { return DTK_TYPE_AXIS_SYSTEM; }
 
    static Dtk_SmartPtr<Dtk_AxisSystem> create();
    virtual void conv_ptr(Dtk_AxisSystem ** s){*s = this;}
    int DtkDynamicType(const int& inId);
    static Dtk_AxisSystem* DtkDynamicCast(Dtk_Object * inObject);
 
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
protected:
    Dtk_AxisSystem();
    virtual ~Dtk_AxisSystem();
    struct Dtk_Handle;
    Dtk_Handle *_Private;
    void _Init();
    void _copy(const Dtk_AxisSystem& s);
    void _reset();
    inline virtual Dtk_Object* Clone() { return new Dtk_AxisSystem(*this); }
    friend class Dtk_SmartPtr<Dtk_AxisSystem>;
 
};
class Dtk_ModelDisplay : public Dtk_Entity
{
protected:
    struct Dtk_Handle; // Not defined here
    Dtk_Handle *_Private; // Handle
    enum { _typeID = DTK_TYPE_MODEL_DISPLAY };
 
    Dtk_ModelDisplay();
 
    Dtk_ModelDisplay(const Dtk_ModelDisplay &s);
 
    Dtk_ModelDisplay(
        const Dtk_CameraPtr& inCamera,
        const Dtk_EntityPtr& inClippingEntity,
        const Dtk_bool inIsActivated);
 
    inline virtual Dtk_Object* Clone() { return new Dtk_ModelDisplay(*this); }
 
    ~Dtk_ModelDisplay();
private:
    void _Init();
    void _Copy(const Dtk_ModelDisplay &s);
    void _Reset();
    friend class Dtk_SmartPtr<Dtk_ModelDisplay>;
 
public:
     enum RenderingModeEnum
     {
          rendering_mode_shaded_only=0,
          rendering_mode_shaded_with_visible_edges,
          rendering_mode_wireframe_with_all_edges,
          rendering_mode_wireframe_with_only_visible_edges,
          rendering_mode_static_wireframe,
          rendering_mode_wireframe_face_analysis,
          rendering_mode_wireframe_partially_shade,
          rendering_mode_studio,
          rendering_mode_unknown
     };
     enum SectionTypeEnum {
          SectionPlane = 0,
          SectionPlaneList,
          SectionParallelePlane,
          SectionBox,
          SectionBody,
          SectionUndefined
     };
 
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
    static Dtk_ModelDisplay * DtkDynamicCast(Dtk_Object *s);
 
    type_detk get_type_detk() const { return DTK_TYPE_MODEL_DISPLAY; }
 
    static Dtk_ModelDisplayPtr Create(
        const Dtk_CameraPtr& inCamera,
        const Dtk_EntityPtr& inClippingEntity,
        const Dtk_bool inIsActivated);
 
    const Dtk_CameraPtr& GetCamera() const;
 
    Dtk_EntityPtr GetClippingEntity() const;
 
    Dtk_bool IsActivated() const;
 
     void SetRenderingMode(RenderingModeEnum inMode) const;
 
     RenderingModeEnum GetRenderingMode() const;
 
     void SetIsStandardView() const;
 
     Dtk_bool GetIsStandardView() const;
 
     void SetSectionInformation(const SectionTypeEnum& inSectionType, const Dtk_Int32& inIsLocked = DTK_FALSE, const Dtk_Double64& inThickness=0.0) const;
 
     void GetSectionInformation(SectionTypeEnum& outSectionType, Dtk_Int32& outIsLocked, Dtk_Double64& outThickness) const;
 
    Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
     void GetVisibleLayers( Dtk_tab<Dtk_Int32> &outVisibleLayers )const;
     void SetVisibleLayers( const Dtk_tab<Dtk_Int32> & inVisibleLayers );
 
};
 
 
class Dtk_ConstraintReference : public Dtk_Entity
{
public:
 
     Dtk_ConstraintReference(const Dtk_ConstraintReference& p);
     Dtk_ConstraintReference& operator=(const Dtk_ConstraintReference& p);
 
 
     const Dtk_NodeConnectorPtr& GetNodeConnector() const;
     void SetNodeConnector(const Dtk_NodeConnectorPtr& in);
 
 
     const Dtk_pnt& GetPosition(Dtk_bool & outHasPosition) const;
     void SetPosition(const Dtk_pnt& in);
 
 
     type_detk get_type_detk() const { return DTK_TYPE_CONSTRAINT_REFERENCE; }
 
     static Dtk_SmartPtr<Dtk_ConstraintReference> Create();
     virtual void conv_ptr(Dtk_ConstraintReference ** s) { *s = this; }
     int DtkDynamicType(const int& inId);
     static Dtk_ConstraintReference* DtkDynamicCast(Dtk_Object * inObject);
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
protected:
     Dtk_ConstraintReference();
     virtual ~Dtk_ConstraintReference();
     struct Dtk_Handle;
     Dtk_Handle *_Private;
     void _Init();
     void _Copy(const Dtk_ConstraintReference& s);
     void _Reset();
     inline virtual Dtk_Object* Clone() { return new Dtk_ConstraintReference(*this); }
     friend class Dtk_SmartPtr<Dtk_ConstraintReference>;
 
};
 
 
class Dtk_Constraint : public Dtk_Entity
{
public:
     enum ConstraintOrientationTypeEnum
     {
          ValueTypeUndefined = 0,
          ValueTypeSame,
          ValueTypeOpposite,
          ValueTypeInternal,
          ValueTypeExternal,
     };
     static Dtk_string ConstraintOrientationTypeEnumToString( const ConstraintOrientationTypeEnum &inEnum )
     {
          switch( inEnum )
          {
               case ValueTypeSame:      return L"TypeSame";
               case ValueTypeOpposite:  return L"TypeOpposite";
               case ValueTypeInternal:  return L"TypeInternal";
               case ValueTypeExternal:  return L"TypeExternal";
               default:
               case ValueTypeUndefined: return L"TypeUndefined";
          }
     }
 
     enum ConstraintValueTypeEnum
     {
          ValueTypeUnknown = 0,
          ValueTypeAngle,
          ValueTypeDistance,
          ValueTypePosition,
          ValueTypeRotation,
          ValueTypeOrientation,
     };
     static Dtk_string ConstraintValueTypeEnumToString( const ConstraintValueTypeEnum &inEnum )
     {
          switch( inEnum )
          {
               case ValueTypeAngle:                    return L"Angle";
               case ValueTypeDistance:                 return L"Distance";
               case ValueTypePosition:                 return L"Position";
               case ValueTypeRotation:                 return L"Rotation";
               case ValueTypeOrientation:              return L"Orientation";
               default:
               case ValueTypeUnknown: return L"TypeUnknown";
          }
     }
 
     class _ConstraintValue
     {
     public:
          _ConstraintValue();
          ~_ConstraintValue();
 
          _ConstraintValue(const ConstraintValueTypeEnum& inValueType, Dtk_Val& inValue, const Dtk_Int32& inEnableLowerLimit, const Dtk_Double64& inLowerLimit, const Dtk_Int32& inEnableUpperLimit, const Dtk_Double64& inUpperLimit);
          _ConstraintValue(const ConstraintValueTypeEnum& inValueType, Dtk_Val& inValue);
 
          ConstraintValueTypeEnum _ValueType;
          Dtk_Val _Value;
          Dtk_Int32 _EnableLower;
          Dtk_Int32 _EnableUpper;
          Dtk_Double64 _ValueLower;
          Dtk_Double64 _ValueUpper;
     private:
 
     };
 
     enum ConstraintTypeEnum
     {
          TypeUnknown = 0,
          TypeAlign,
          TypeAngle,
          TypeBond,
          TypeCam,
          TypeCenter,
          TypeConcentric,
          TypeCoincidence,
          TypeDistance,
          TypeFit,
          TypeFix,
          TypeGear,
          TypeHinge,
          TypeLimit,
          TypeLinear,
          TypeLinearCoupler,
          TypeLock,
          TypeOrientAngle,
          TypeParallel,
          TypePathMate,
          TypePerpendicular,
          TypeProfileCenter,
          TypeRackPinion,
          TypeScrew,
          TypeSlot,
          TypeSymmetric,
          TypeTangent,
          TypeTouch,
          TypeUniversalJoint,
          TypeWidth
     };
     static inline Dtk_string ConstraintTypeEnumToString(const ConstraintTypeEnum& inEnum)
     {
          switch (inEnum)
          {
          case TypeAlign:                return L"TypeAlign";
          case TypeAngle:                return L"TypeAngle";
          case TypeBond:                 return L"TypeBond";
          case TypeCam:                  return L"TypeCam";
          case TypeCenter:               return L"TypeCenter";
          case TypeConcentric:           return L"TypeConcentric";
          case TypeCoincidence:          return L"TypeCoincidence";
          case TypeDistance:             return L"TypeDistance";
          case TypeFit:                  return L"TypeFit";
          case TypeFix:                  return L"TypeFix";
          case TypeGear:                 return L"TypeGear";
          case TypeHinge:                return L"TypeHinge";
          case TypeLimit:                return L"TypeLimit";
          case TypeLinear:               return L"TypeLinear";
          case TypeLinearCoupler:        return L"TypeLinearCoupler";
          case TypeLock:                 return L"TypeLock";
          case TypeOrientAngle:          return L"TypeOrientAngle";
          case TypeParallel:             return L"TypeParallel";
          case TypePathMate:             return L"TypePathMate";
          case TypePerpendicular:        return L"TypePerpendicular";
          case TypeProfileCenter:        return L"TypeProfileCenter";
          case TypeRackPinion:           return L"TypeRackPinion";
          case TypeScrew:                return L"TypeScrew";
          case TypeSlot:                 return L"TypeSlot";
          case TypeSymmetric:            return L"TypeSymmetric";
          case TypeTangent:              return L"TypeTangent";
          case TypeTouch:                return L"TypeTouch";
          case TypeUniversalJoint:       return L"TypeUniversalJoint";
          case TypeWidth:                return L"TypeWidth";
          default:
          case TypeUnknown:              return L"Unknown";
          }
     }
 
     Dtk_Constraint(const Dtk_Constraint& p);
     Dtk_Constraint& operator=(const Dtk_Constraint& p);
 
 
     Dtk_Constraint(const ConstraintTypeEnum& inType);
 
     const ConstraintTypeEnum& GetConstraintType() const;
     void SetConstraintType(const ConstraintTypeEnum& in);
 
     Dtk_Size_t GetNumberOfConstraintValues();
 
     const _ConstraintValue& GetConstraintValue( const Dtk_Size_t &index ) const;
 
     Dtk_ErrorStatus GetValue( const ConstraintValueTypeEnum& inValue, Dtk_Val& outValue, Dtk_Int32& outEnableLowerLimit, Dtk_Double64& outLowerLimit, Dtk_Int32& outEnableUpperLimit, Dtk_Double64& outUpperLimit ) const;
     Dtk_ErrorStatus GetValue( const ConstraintValueTypeEnum& inValue, Dtk_Val& outValue ) const;
 
     Dtk_tab< ConstraintValueTypeEnum > GetValuesTypes() const;
 
     void SetValue( const ConstraintValueTypeEnum& inValueType, Dtk_Val& inValue, const Dtk_Int32& inEnableLowerLimit, const Dtk_Double64& inLowerLimit, const Dtk_Int32& inEnableUpperLimit, const Dtk_Double64& inUpperLimit );
     void SetValue( const ConstraintValueTypeEnum& inValueType, Dtk_Val& inValue );
 
     Dtk_Size_t GetNumberOfConstraintReferences() const;
     const Dtk_ConstraintReferencePtr& GetConstraintReference( const Dtk_Size_t &index ) const;
     const Dtk_tab<Dtk_ConstraintReferencePtr>& GetConstraintReference() const;
     void AddConstraintReference( const Dtk_ConstraintReferencePtr& in );
 
 
     type_detk get_type_detk() const { return DTK_TYPE_CONSTRAINT; }
 
     static Dtk_SmartPtr<Dtk_Constraint> Create();
     virtual void conv_ptr(Dtk_Constraint ** s) { *s = this; }
     int DtkDynamicType(const int& inId);
     static Dtk_Constraint* DtkDynamicCast(Dtk_Object * inObject);
 
     Dtk_ErrorStatus Transform(const Dtk_transfo &inTransfo);
 
protected:
     Dtk_Constraint();
     virtual ~Dtk_Constraint();
     struct Dtk_Handle;
     Dtk_Handle *_Private;
     void _Init();
     void _Copy(const Dtk_Constraint& s);
     void _Reset();
     inline virtual Dtk_Object* Clone() { return new Dtk_Constraint(*this); }
     friend class Dtk_SmartPtr<Dtk_Constraint>;
 
};
 
#endif