DATAKIT SDK  V2026.4
Namespaces | Macros | Functions | Variables
util_xml_dtk.cpp File Reference

Namespaces

 Dtk_StandardTools
 

Macros

#define XmlFormat(inOldFormat)   "%z" inOldFormat
 

Functions

Dtk_string Dtk_ConvertFontLineTypeEnumToString (const Dtk_FontLineType &inEnum)
 
void Dtk_DumpXml_Body (FILE *inDump, const Dtk_BodyPtr &inBody)
 
Dtk_ErrorStatus Dtk_DumpXml_bounding_box (FILE *F, Dtk_pnt tab[])
 
Dtk_ErrorStatus Dtk_DumpXml_ColorInfosTable (FILE *F)
 
void Dtk_DumpXml_ComplementarySymbolEnum (FILE *F, const Dtk_Welding::ComplementarySymbolEnum &inEnum, const Dtk_string &inPropertyName)
 
void Dtk_DumpXml_ComponentTypeEnum (FILE *F, const Dtk_Component::ComponentTypeEnum &inEnum, const Dtk_string &inPropertyName)
 
void Dtk_DumpXml_ConstraintOrientationEnum (FILE *F, const Dtk_Constraint::ConstraintOrientationTypeEnum &inEnum)
 
void Dtk_DumpXml_ConstraintTypeEnum (FILE *F, const Dtk_Constraint::ConstraintTypeEnum &inEnum, const Dtk_string &inPropertyName)
 
void Dtk_DumpXml_ConstraintValueEnum (FILE *F, const Dtk_Constraint::ConstraintValueTypeEnum &inEnum, const Dtk_string &inPropertyName)
 
Dtk_ErrorStatus Dtk_DumpXml_Drawing (const Dtk_DrawingPtr &d)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_2dEntityPtr (FILE *F, const Dtk_2dEntityPtr &D, const int &compact)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_anchor_type (FILE *F, const Dtk_anchor_type &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_AnnotationPtr (FILE *F, const Dtk_AnnotationPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_AxisSystemPtr (FILE *F, const Dtk_AxisSystemPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_BodyPtr (FILE *F, const Dtk_BodyPtr &inBody)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_bool (FILE *F, const Dtk_bool &B)
 
static Dtk_ErrorStatus Dtk_DumpXml_Dtk_BoundaryPtr (FILE *F, const Dtk_Boundary &boundary)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraProjectionTypeEnum (FILE *F, const Dtk_Camera::ProjectionTypeEnum &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraPtr (FILE *F, const Dtk_CameraPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CoedgePtr (FILE *F, const Dtk_CoedgePtr &inCoedge)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ColorInfosSetPtr (FILE *F, const Dtk_ColorInfosSetPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentAvailability (FILE *F, const Dtk_ComponentPtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr (FILE *F, const Dtk_ComponentPtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_End (FILE *F)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_Init (FILE *F, const Dtk_ComponentPtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CompositeEntityPtr (FILE *F, const Dtk_CompositeEntityPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CompositeText (FILE *F, const Dtk_CompositeText &T)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConicalSurfacePtr (FILE *F, const Dtk_ConicalSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Constraint_ConstraintValue (FILE *F, const Dtk_Constraint::_ConstraintValue &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConstraintPtr (FILE *F, const Dtk_ConstraintPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConstraintReferencePtr (FILE *F, const Dtk_ConstraintReferencePtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CurvePtr (FILE *F, const Dtk_CurvePtr &inCurve)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CylindricalSurfacePtr (FILE *F, const Dtk_CylindricalSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_DTK_DATUM_COMPOSING_RULE (FILE *F, const DTK_DATUM_COMPOSING_RULE &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DatumTargetPtr (FILE *F, const Dtk_DatumTargetPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Dimension_BasicDimensionType (FILE *F, const Dtk_Dimension::BasicDimensionTypeEnum &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Dimension_DimensionType (FILE *F, const Dtk_Dimension::DimensionTypeEnum &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Dimension_ShowDualValueType (FILE *F, const Dtk_Dimension::ShowDualValueTypeEnum &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DimensionPtr (FILE *F, const Dtk_DimensionPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_dir (FILE *F, const Dtk_dir &D, const char *b)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DrawingPtr (FILE *F, const Dtk_DrawingPtr &D, const int &compact)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EdgePtr (FILE *F, const Dtk_EdgePtr &inEdge)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EllipsePtr (FILE *F, const Dtk_EllipsePtr &inCurve)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EntityPtr (FILE *inDumpFile, const Dtk_EntityPtr &inEntity)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FacePtr (FILE *F, const Dtk_FacePtr &inFace)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr (FILE *F, const Dtk_FCFFeatureIndicatorPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FCFFeatureIndicatorType (FILE *F, const Dtk_FCFFeatureIndicatorType &D)
 
Dtk_ErrorStatus Dtk_DumpXml_DTK_FDT_MODIFIER (FILE *F, const DTK_FDT_MODIFIER &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtPtr (FILE *F, const Dtk_FdtPtr &D, const int &compact)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FeaturePtr (FILE *f, const Dtk_FeaturePtr &inToWrite)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FilletSurfacePtr (FILE *F, const Dtk_FilletSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Font (FILE *F, const Dtk_Font &T)
 
void Dtk_DumpXml_Dtk_FontLineTypeEnum (FILE *F, const Dtk_FontLineType &inEnum, const Dtk_string &inPropertyName)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Frame (FILE *F, const Dtk_Frame &T)
 
void Dtk_DumpXml_Dtk_frame_type (FILE *F, const Dtk_frame_type &inEnum, const Dtk_string &inPropertyName)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GeometricalTolerancePtr (FILE *F, const Dtk_GeometricalTolerancePtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GraphicalDataPtr (FILE *F, const Dtk_GraphicalDataPtr &inGraphicalData)
 
void Dtk_DumpXml_Dtk_Grid_OriginReferenceOptionEnum (FILE *F, const Dtk_Grid::OriginReferenceOption &inEnum, const Dtk_string &inPropertyName)
 
void Dtk_DumpXml_Dtk_Grid_ShowLabelOptionEnum (FILE *F, const Dtk_Grid::ShowLabelOption &inEnum, const Dtk_string &inPropertyName)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GridPtr (FILE *F, const Dtk_GridPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_HatchingPattern (FILE *F, const Dtk_HatchingPattern &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_HatchingPtr (FILE *F, const Dtk_HatchingPtr &D)
 
void Dtk_DumpXml_Dtk_HatchingStyleEnum (FILE *F, const Dtk_HatchingStyle &inEnum, const Dtk_string &inPropertyName)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_HyperbolaPtr (FILE *F, const Dtk_HyperbolaPtr &inCurve)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_info (FILE *F, const Dtk_InfoPtr &I)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCommand (FILE *inFile, const Dtk_KinCommandPtr &inCommand, Dtk_bool simplified)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsConstraint (FILE *inFile, const Dtk_KinConstraintPtr &inConstraint, Dtk_bool simplified)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCurve (FILE *inFile, const Dtk_KinCurvePtr &inCurve)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFixPart (FILE *inFile, const Dtk_KinFixPartPtr &inFixPart)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFormula (FILE *inFile, const Dtk_KinFormulaPtr &inFormula)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsJoint (FILE *inFile, const Dtk_KinJointPtr &inJoint, Dtk_bool simplified)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsLaw (FILE *inFile, const Dtk_KinLawPtr &inLaw)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsMechanism (FILE *inFile, const Dtk_KinMechanismPtr &inKinMechanism)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsNamedValue (FILE *inFile, const Dtk_KinNamedValuePtr &inNamedValue)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsParameter (FILE *inFile, const Dtk_KinParameterPtr &inParameter, Dtk_bool simplified)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsProduct (FILE *inFile, const Dtk_KinProductPtr &inKinProduct, int &inKinProductIndex)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsPtr (FILE *inFile, const Dtk_KinematicPtr &inKinematic)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration (FILE *inFile, const Dtk_KinSpeedAccelerationPtr &inSpeedAcceleration)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LayerInfosSetPtr (FILE *F, const Dtk_LayerInfosSetPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LayerInfosSetPtr_Deprecated (FILE *F, const Dtk_LayerInfosSetPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LeaderPtr (FILE *F, const Dtk_LeaderPtr &L)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Light (FILE *F, const Dtk_LightMapPtr &inLight)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LinearExtrusionSurfacePtr (FILE *F, const Dtk_LinearExtrusionSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LinePtr (FILE *F, const Dtk_LinePtr &inCurve)
 
void Dtk_DumpXml_Dtk_LineTypeDefinitionPtr (FILE *F, const Dtk_LineTypeDefinitionPtr &inLineTypeDefinition)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LoopPtr (FILE *F, const Dtk_LoopPtr &inLoop)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LumpPtr (FILE *F, const Dtk_LumpPtr &inLump)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr (FILE *F, const Dtk_MainDocPtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr_End (FILE *F, const Dtk_MainDocPtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr_Init (FILE *F, const Dtk_MainDocPtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_material (FILE *F, const Dtk_MaterialPtr &inMaterial)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshLightPtr (FILE *F, const Dtk_MeshPtr &inMesh)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshPtr (FILE *F, const Dtk_MeshPtr &inMesh)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshSurfacePtr (FILE *F, const Dtk_MeshSurfacePtr &inMeshSurface)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetaDataGroup (const Dtk_MetaDataGroupPtr &m)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataGroupPtr (FILE *F, const Dtk_MetaDataGroupPtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataPtr (FILE *F, const Dtk_MetaDataPtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ModelDisplayPtr (FILE *F, const Dtk_ModelDisplayPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodeConnector (FILE *inFile, const Dtk_NodeConnectorPtr &inNodeConnector)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr (FILE *F, const Dtk_NodePtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr_End (FILE *F)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr_Init (FILE *F, const Dtk_NodePtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NurbsCurvePtr (FILE *F, const Dtk_NurbsCurvePtr &inCurve)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NurbsSurfacePtr (FILE *F, const Dtk_NurbsSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OffsetSurfacePtr (FILE *F, const Dtk_OffsetSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OLEObjectPtr (FILE *F, const Dtk_OLEObjectPtr &O)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OneCell (FILE *F, Dtk_OneCell &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Oriented2dBBox (FILE *F, const Dtk_Oriented2dBBox &BBox, const Dtk_string &inLabel=L"")
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OverrideInfo (FILE *F, const Dtk_OverrideInfoPtr &inOverrideInfo)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OverrideSet (FILE *F, const Dtk_OverrideSetPtr &inOverrideSet)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ParabolaPtr (FILE *F, const Dtk_ParabolaPtr &inCurve)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PhysicalMaterialInfos (FILE *F, const Dtk_PhysicalMaterialInfosPtr &inMaterial)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Picture (FILE *F, Dtk_picture *inPicture)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PlaneSurfacePtr (FILE *F, const Dtk_PlaneSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_pnt (FILE *F, const Dtk_pnt &P, const char *b)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PointPtr (FILE *F, const Dtk_PointPtr &inPoint)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PolylinePtr (FILE *F, const Dtk_PolylinePtr &inCurve)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PropertiesPtr (FILE *F, const Dtk_PropertiesPtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceBlockPtr (FILE *F, const Dtk_ReferenceBlockPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceFramePtr (FILE *F, const Dtk_ReferenceFramePtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RegionPtr (FILE *F, const Dtk_RegionPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RenderInfos (FILE *F, const Dtk_RenderInfosPtr &inRender)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RevolutionSurfacePtr (FILE *F, const Dtk_RevolutionSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RGB (FILE *F, const Dtk_RGB &RGB)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_roughness_obtention_type (FILE *F, const Dtk_Roughness::ObtentionTypeEnum &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_roughness_rough_mode (FILE *F, const Dtk_Roughness::RoughModeEnum &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_roughness_roughness_applyto (FILE *F, const Dtk_Roughness::ApplyToEnum &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RoughnessPtr (FILE *F, const Dtk_RoughnessPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RuledSurfacePtr (FILE *F, const Dtk_RuledSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SelectionDataSet (FILE *F, const Dtk_GlobalDataSetPtr &ptrGlobalDataSet)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SelectionSet (FILE *F, const Dtk_SelectionSetPtr &inSelectionSet)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ShellPtr (FILE *F, const Dtk_ShellPtr &inShell)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SphericalSurfacePtr (FILE *F, const Dtk_SphericalSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_StandardRevolutionSurfacePtr (FILE *F, const Dtk_StandardRevolutionSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_StreamPtr (FILE *F, const Dtk_StreamPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SurfacePtr (FILE *F, const Dtk_SurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SymbolPtr (FILE *F, const Dtk_SymbolPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_TablePtr (FILE *F, const Dtk_TablePtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Text (FILE *F, const Dtk_Text &T)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Text_DTK_Text_subtype (FILE *F, const DTK_Text_subtype &subType)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Text_DTK_Text_type (FILE *F, const DTK_Text_type &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_TextStyle (FILE *F, const Dtk_TextStyle &T)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Texture (FILE *F, const Dtk_TextureInfosPtr &inTexture)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr (FILE *F, const Dtk_ToleranceSpecificationContainerPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType (FILE *F, const Dtk_ToleranceSpecificationContainer::TypeEnum &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationPtr (FILE *F, const Dtk_ToleranceSpecificationPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToroidalSurfacePtr (FILE *F, const Dtk_ToroidalSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_transfo (FILE *F, const Dtk_transfo &T)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_TransformedSurfacePtr (FILE *F, const Dtk_TransformedSurfacePtr &inSurf)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_val (FILE *F, const Dtk_Val &V)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_VertexPtr (FILE *F, const Dtk_VertexPtr &inVertex)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewDisplayDisplayMode3DEnum (FILE *F, const Dtk_ViewDisplay::DisplayMode3DEnum &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewDisplayPtr (FILE *F, const Dtk_ViewDisplayPtr &V)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewPtr (FILE *F, const Dtk_ViewPtr &V, const int &compact)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_VolumePtr (FILE *F, const Dtk_VolumePtr &inVol)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_complementary_symbol (FILE *F, const Dtk_Welding::ComplementarySymbolEnum &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_finish_symbol (FILE *F, const Dtk_Welding::FinishSymbolEnum &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_symbol (FILE *F, const Dtk_Welding::WeldingSymbolEnum &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_WeldingPtr (FILE *F, const Dtk_WeldingPtr &D)
 
void Dtk_DumpXml_DtkReaderType (FILE *F, const DtkReaderType &inEnum, const Dtk_string &inPropertyName)
 
Dtk_ErrorStatus Dtk_DumpXml_End ()
 
Dtk_ErrorStatus Dtk_DumpXml_End (FILE *F)
 
Dtk_ErrorStatus Dtk_DumpXml_Fdt (const Dtk_FdtPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_FeatAxis (FILE *f, const Dtk_feat_axis *inToWrite)
 
Dtk_ErrorStatus Dtk_DumpXml_FeatGeometry (FILE *f, const Dtk_feat_geometry *inToWrite, const char *inName)
 
Dtk_ErrorStatus Dtk_DumpXml_FeatHole (FILE *f, const Dtk_feat_hole *inToWrite)
 
Dtk_ErrorStatus Dtk_DumpXml_FeatLimit (FILE *f, const Dtk_feat_limit *inToWrite)
 
Dtk_ErrorStatus Dtk_DumpXml_FeatPattern (FILE *f, const Dtk_feat_pattern *inToWrite)
 
Dtk_ErrorStatus Dtk_DumpXml_FeatThread (FILE *f, const Dtk_feat_thread *inToWrite)
 
void Dtk_DumpXml_FinishSymbolEnum (FILE *F, const Dtk_Welding::FinishSymbolEnum &inEnum, const Dtk_string &inPropertyName)
 
Dtk_string Dtk_DumpXml_FormatDtk_string (const Dtk_string &inString, const XML_StringType inXmlStringType)
 
FILE * Dtk_DumpXml_GetFeaturesDumpFile ()
 
FILE * Dtk_DumpXml_GetFile ()
 
Dtk_ErrorStatus Dtk_DumpXml_Init (const Dtk_string &xml_file)
 
void Dtk_DumpXml_LeaderTerminatorTypeEnum (FILE *F, const Dtk_Leader::LeaderTerminatorTypeEnum &inEnum, const Dtk_string &inPropertyName)
 
Dtk_ErrorStatus Dtk_DumpXml_LineTypeDefinitionTable (FILE *F)
 
Dtk_ErrorStatus Dtk_DumpXml_Metadata (const Dtk_MetaDataPtr &m)
 
void Dtk_DumpXml_MetaDataTypeEnum (FILE *F, const Dtk_MetaData::MetaDataTypeEnum &inEnum, const Dtk_string &inPropertyName)
 
void Dtk_DumpXml_NodeFullType (FILE *F, const Dtk_Node::FullType &inNodeFullType, const Dtk_string &inPropertyName)
 
void Dtk_DumpXml_NodeTypeEnum (FILE *F, const Dtk_Node::NodeDataTypeEnum &inEnum, const Dtk_string &inPropertyName)
 
Dtk_ErrorStatus Dtk_DumpXml_PhysicalMaterialInfosTable (FILE *F)
 
Dtk_ErrorStatus Dtk_DumpXml_RenderInfosTable (FILE *F)
 
void Dtk_DumpXml_TextAttributeEnum (FILE *F, const Dtk_TextStyle::TextAttributeEnum &inEnum, const Dtk_string &inPropertyName)
 
void Dtk_DumpXml_TextJustificationEnum (FILE *F, const Dtk_TextStyle::TextJustificationEnum &inEnum, const Dtk_string &inPropertyName)
 
Dtk_ErrorStatus Dtk_DumpXml_Value (FILE *inFile, const Dtk_string &inLabel, const char *inFormat,...)
 
Dtk_ErrorStatus Dtk_DumpXml_Value (FILE *inFile, const Dtk_string &inLabel, const Dtk_bool &inValue)
 
Dtk_ErrorStatus Dtk_DumpXml_Value (FILE *inFile, const Dtk_string &inLabel, const Dtk_Double64 &inValue, const char *inFormat)
 
Dtk_ErrorStatus Dtk_DumpXml_Value (FILE *inFile, const Dtk_string &inLabel, const Dtk_Int64 &inValue)
 
Dtk_ErrorStatus Dtk_DumpXml_Value (FILE *inFile, const Dtk_string &inLabel, const Dtk_string &inValue)
 
Dtk_ErrorStatus Dtk_DumpXml_Value (FILE *inFile, const Dtk_string &inLabel, const Dtk_UInt64 &inValue)
 
void Dtk_DumpXml_WeldingSymbolEnum (FILE *F, const Dtk_Welding::WeldingSymbolEnum &inEnum, const Dtk_string &inPropertyName)
 
Dtk_ErrorStatus Dtk_End_Dump_Files (const Dtk_string &inComponentFullName)
 
Dtk_string Dtk_FCFFeatureIndicatorTypeEnumToString (const Dtk_FCFFeatureIndicatorType::Dtk_FCFFeatureIndicatorTypeEnum &inEnum)
 
Dtk_ErrorStatus Dtk_Init_Dump_Files (const Dtk_string &inDumpFileName, Dtk_bool dumpFeatures)
 
Dtk_string DtkPictureTypeEnumToString (const Dtk_PictureType &inEnum)
 
Dtk_string DtkReaderTypeEnumToString (const DtkReaderType &inReaderTypeEnum)
 
void dump_dtk_feat (Dtk_feat *feature, FILE *f, int vers=0)
 
int Dtk_StandardTools::sprintf_dtk (char *Buffer, size_t BufferCount, const char *Format,...)
 
Dtk_string typedetkToDtk_string (const type_detk &inVal)
 
Dtk_status validate_xml_string (Dtk_string &inputString)
 
int Dtk_StandardTools::vsprintf_dtk (char *Buffer, size_t BufferCount, const char *Format, va_list inArgList)
 

Variables

FILE * dump_file = NULL
 
FILE * FeaturesDumpFile = NULL
 
FILE * inDumpFile
 

Macro Definition Documentation

◆ XmlFormat

#define XmlFormat (   inOldFormat)    "%z" inOldFormat

Function Documentation

◆ Dtk_ConvertFontLineTypeEnumToString()

Dtk_string Dtk_ConvertFontLineTypeEnumToString ( const Dtk_FontLineType &  inEnum)
2328  {
2329  Dtk_string EnumToStr;
2330 
2331  switch( inEnum )
2332  {
2333  default:
2334  case DTK_NO_PATTERN: EnumToStr = L"DTK_NO_PATTERN"; break;
2335  case DTK_SOLIDLINE: EnumToStr = L"DTK_SOLIDLINE"; break;
2336  case DTK_DASHED: EnumToStr = L"DTK_DASHED"; break;
2337  case DTK_PHANTOM: EnumToStr = L"DTK_PHANTOM"; break;
2338  case DTK_CENTERLINE: EnumToStr = L"DTK_CENTERLINE"; break;
2339  case DTK_DOTTED: EnumToStr = L"DTK_DOTTED"; break;
2340  case DTK_LONG_DASHED: EnumToStr = L"DTK_LONG_DASHED"; break;
2341  case DTK_DOTTED_DASHED: EnumToStr = L"DTK_DOTTED_DASHED"; break;
2342  case DTK_BREAKLINE: EnumToStr = L"DTK_BREAKLINE"; break;
2343  }
2344 
2345  return EnumToStr;
2346  }

◆ Dtk_DumpXml_Body()

void Dtk_DumpXml_Body ( FILE *  inDump,
const Dtk_BodyPtr &  inBody 
)

◆ Dtk_DumpXml_bounding_box()

Dtk_ErrorStatus Dtk_DumpXml_bounding_box ( FILE *  F,
Dtk_pnt  tab[] 
)
896  {
897  // from a bouding box, you can find back height and width (example : width = norm of vector (DTK_ANCHOR_BOTTOM_RIGHT - DTK_ANCHOR_BOTTOM_LEFT)
898  // you can also find back the orientation.
899  // note that methods already exist for that.
900 
901  fprintf( F, "<Bounding_box>\n" );
902  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, tab[ DTK_ANCHOR_TOP_LEFT ], "top_left" );
903  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, tab[ DTK_ANCHOR_TOP_CENTER ], "top_center" );
904  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, tab[ DTK_ANCHOR_TOP_RIGHT ], "top_right" );
905  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, tab[ DTK_ANCHOR_MIDDLE_LEFT ], "middle_left" );
906  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, tab[ DTK_ANCHOR_MIDDLE_CENTER ], "middle_center" );
907  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, tab[ DTK_ANCHOR_MIDDLE_RIGHT ], "middle_right" );
908  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, tab[ DTK_ANCHOR_BOTTOM_LEFT ], "bottom_left" );
909  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, tab[ DTK_ANCHOR_BOTTOM_CENTER ], "bottom_center" );
910  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, tab[ DTK_ANCHOR_BOTTOM_RIGHT ], "bottom_right" );
911  fprintf( F, "</Bounding_box>\n" );
912  return dtkNoError;
913  }

◆ Dtk_DumpXml_ColorInfosTable()

Dtk_ErrorStatus Dtk_DumpXml_ColorInfosTable ( FILE *  F)
3990  {
3991  Dtk_API *api = Dtk_API::GetAPI();
3992  Dtk_ID i, nb = ( Dtk_ID )api->GetNumColorInTable();
3993  if( nb )
3994  fprintf( F, "<ColorInfosTable>\n" );
3995  for( i = 0; i < nb; i++ )
3996  {
3997  Dtk_RGB col;
3998  api->GetColorInTable( i, col );
3999  fprintf( F, "<Dtk_Color><id>%d</id><R>%d</R><G>%d</G><B>%d</B><A>%d</A></Dtk_Color>\n",
4000  i, col[ 0 ], col[ 1 ], col[ 2 ], col[ 3 ] );
4001  }
4002  if( nb )
4003  fprintf( F, "</ColorInfosTable>\n" );
4004 
4005  return dtkNoError;
4006  }

◆ Dtk_DumpXml_ComplementarySymbolEnum()

void Dtk_DumpXml_ComplementarySymbolEnum ( FILE *  F,
const Dtk_Welding::ComplementarySymbolEnum &  inEnum,
const Dtk_string &  inPropertyName 
)
854  {
855  Dtk_string EnumToStr = Dtk_Welding::ComplementarySymbolEnumToString( inEnum );
856  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
857  }

◆ Dtk_DumpXml_ComponentTypeEnum()

void Dtk_DumpXml_ComponentTypeEnum ( FILE *  F,
const Dtk_Component::ComponentTypeEnum &  inEnum,
const Dtk_string &  inPropertyName 
)
685  {
686  Dtk_string EnumToStr = Dtk_Component::ComponentTypeEnumToString( inEnum );
687  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
688  }

◆ Dtk_DumpXml_ConstraintOrientationEnum()

void Dtk_DumpXml_ConstraintOrientationEnum ( FILE *  F,
const Dtk_Constraint::ConstraintOrientationTypeEnum &  inEnum 
)
8564  {
8565  const Dtk_string enumAsString = Dtk_Constraint::ConstraintOrientationTypeEnumToString( inEnum );
8566  fprintf( F, "%s\n", enumAsString.c_str() );
8567  }

◆ Dtk_DumpXml_ConstraintTypeEnum()

void Dtk_DumpXml_ConstraintTypeEnum ( FILE *  F,
const Dtk_Constraint::ConstraintTypeEnum &  inEnum,
const Dtk_string &  inPropertyName 
)
8557  {
8558  const Dtk_string EnumToStr = Dtk_Constraint::ConstraintTypeEnumToString( inEnum );
8559  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
8560  }

◆ Dtk_DumpXml_ConstraintValueEnum()

void Dtk_DumpXml_ConstraintValueEnum ( FILE *  F,
const Dtk_Constraint::ConstraintValueTypeEnum &  inEnum,
const Dtk_string &  inPropertyName 
)
8572  {
8573  const Dtk_string enumAsString = Dtk_Constraint::ConstraintValueTypeEnumToString( inEnum );
8574  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, enumAsString );
8575  }

◆ Dtk_DumpXml_Drawing()

Dtk_ErrorStatus Dtk_DumpXml_Drawing ( const Dtk_DrawingPtr &  d)
5189  {
5190  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_DrawingPtr( dump_file, d, 0 );
5191  }

◆ Dtk_DumpXml_Dtk_2dEntityPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_2dEntityPtr ( FILE *  F,
const Dtk_2dEntityPtr &  D,
const int &  compact 
)
2803  {
2804  if( !D )
2805  return dtkErrorNullPointer;
2806 
2807  int unused;
2808  unused = compact;
2809  fprintf( F, "\n<Dtk_2dEntityPtr>\n" );
2810  enum type_detk type = D->get_type_detk();
2811  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, D->info() );
2812 #ifdef Convert2dEntitiesToSymbol
2813  {
2814  Dtk_SymbolPtr Converted = Dtk_Symbol::Create( D );
2815  if( Converted.IsNotNULL() )
2816  {
2817  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_SymbolPtr( F, Dtk_SymbolPtr::DtkDynamicCast( Converted ) ); // downcasting
2818  }
2819  else
2820  {
2821  fprintf( F, "Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_2dEntityPtr : Unknow type (%d)\n", type );
2822  }
2823  }
2824 #else //#ifdef Convert2dEntitiesToSymbol
2825  switch( type )
2826  {
2827  case DTK_TYPE_TABLE:
2828  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_TablePtr( F, Dtk_TablePtr::DtkDynamicCast( D ) ); // downcasting
2829  break;
2830  case DTK_TYPE_SYMBOL:
2831  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_SymbolPtr( F, Dtk_SymbolPtr::DtkDynamicCast( D ) ); // downcasting
2832  break;
2833  case DTK_TYPE_DIMENSION:
2834  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_DimensionPtr( F, Dtk_DimensionPtr::DtkDynamicCast( D ) ); // downcasting
2835  break;
2836  case DTK_TYPE_GEOM_TOL:
2837  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_GeometricalTolerancePtr( F, Dtk_GeometricalTolerancePtr::DtkDynamicCast( D ) ); // downcasting
2838  break;
2839  case DTK_TYPE_ROUGHNESS:
2840  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RoughnessPtr( F, Dtk_RoughnessPtr::DtkDynamicCast( D ) ); // downcasting
2841  break;
2842  case DTK_TYPE_WELDING:
2843  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_WeldingPtr( F, Dtk_WeldingPtr::DtkDynamicCast( D ) ); // downcasting
2844  break;
2845  case DTK_TYPE_DATUM_TARGET:
2846  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_DatumTargetPtr( F, Dtk_DatumTargetPtr::DtkDynamicCast( D ) ); // downcasting
2847  break;
2848  case DTK_TYPE_GRID:
2849  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_GridPtr( F, Dtk_GridPtr::DtkDynamicCast( D ) ); // downcasting
2850  break;
2851  case DTK_TYPE_REGION:
2852  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RegionPtr( F, Dtk_RegionPtr::DtkDynamicCast( D ) ); // downcasting
2853  break;
2854  case DTK_TYPE_COMPOSITE_ENTITY:
2855  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeEntityPtr( F, Dtk_CompositeEntityPtr::DtkDynamicCast( D ) ); // downcasting
2856  break;
2857  default:
2858  fprintf( F, "Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_2dEntityPtr : Unknow type (%d)\n", type );
2859  }
2860 #endif //#ifdef Convert2dEntitiesToSymbol
2861  const Dtk_CompositeText &CompoText = D->GetAdditionnalTexts();
2862  if( CompoText.GetNumTexts() > 0 )
2863  {
2864  fprintf( F, "<AdditionnalTexts>\n" );
2865  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, CompoText );
2866  fprintf( F, "</AdditionnalTexts>\n" );
2867  }
2868 
2869  const Dtk_tab< Dtk_EntityPtr > &AdditionnalGeometries = D->GetAdditionnalGeometries();
2870  Dtk_Size_t nbgeoms = AdditionnalGeometries.size();
2871  if( nbgeoms > 0 )
2872  {
2873  Dtk_Size_t i;
2874  fprintf( F, "<AdditionnalGeometries size=\"" XmlFormat( "u" )"\">\n", nbgeoms );
2875  for( i = 0; i < nbgeoms; i++ )
2876  {
2877  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EntityPtr( F, AdditionnalGeometries[ i ] );
2878  }
2879  fprintf( F, "</AdditionnalGeometries>\n" );
2880  }
2881 
2882  fprintf( F, "</Dtk_2dEntityPtr>\n" );
2883  return dtkNoError;
2884  }

◆ Dtk_DumpXml_Dtk_anchor_type()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_anchor_type ( FILE *  F,
const Dtk_anchor_type &  D 
)
1181  {
1182  fprintf( F, "<Dtk_anchor_type>" );
1183  switch( D )
1184  {
1185  case DTK_ANCHOR_TOP_LEFT: fprintf( F, "DTK_ANCHOR_TOP_LEFT" ); break;
1186  case DTK_ANCHOR_TOP_CENTER: fprintf( F, "DTK_ANCHOR_TOP_CENTER" ); break;
1187  case DTK_ANCHOR_TOP_RIGHT: fprintf( F, "DTK_ANCHOR_TOP_RIGHT" ); break;
1188  case DTK_ANCHOR_MIDDLE_LEFT: fprintf( F, "DTK_ANCHOR_MIDDLE_LEFT" ); break;
1189  case DTK_ANCHOR_MIDDLE_CENTER: fprintf( F, "DTK_ANCHOR_MIDDLE_CENTER" ); break;
1190  case DTK_ANCHOR_MIDDLE_RIGHT: fprintf( F, "DTK_ANCHOR_MIDDLE_RIGHT" ); break;
1191  case DTK_ANCHOR_BOTTOM_LEFT: fprintf( F, "DTK_ANCHOR_BOTTOM_LEFT" ); break;
1192  case DTK_ANCHOR_BOTTOM_CENTER: fprintf( F, "DTK_ANCHOR_BOTTOM_CENTER" ); break;
1193  case DTK_ANCHOR_BOTTOM_RIGHT: fprintf( F, "DTK_ANCHOR_BOTTOM_RIGHT" ); break;
1194  default: fprintf( F, "Undefined" ); break;
1195  }
1196  fprintf( F, "</Dtk_anchor_type>\n" );
1197  return dtkNoError;
1198  }

◆ Dtk_DumpXml_Dtk_AnnotationPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_AnnotationPtr ( FILE *  F,
const Dtk_AnnotationPtr &  D 
)
878  {
879  fprintf( F, "<Dtk_AnnotationPtr>\n" );
880  Dtk_Size_t i, nbleads;
881  nbleads = D->GetNumLeaders();
882  fprintf( F, "<Leaders>\n" );
883  fprintf( F, "<num_leaders>" XmlFormat( "u" )"</num_leaders>\n", nbleads );
884  for( i = 0; i < nbleads; i++ )
885  {
886  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LeaderPtr( F, D->GetLeader( i ) );
887  }
888  fprintf( F, "</Leaders>\n" );
889  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, D->GetLocation(), "Location" );
890  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_anchor_type( F, D->GetLocationAnchorType() );
891  fprintf( F, "</Dtk_AnnotationPtr>\n" );
892  return dtkNoError;
893  }

◆ Dtk_DumpXml_Dtk_AxisSystemPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_AxisSystemPtr ( FILE *  F,
const Dtk_AxisSystemPtr &  inVal 
)
3295  {
3296  fprintf( F, "<Dtk_AxisSystemPtr>\n" );
3297  if( inVal.IsNotNULL() )
3298  {
3299  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->get_info() );
3300 
3301 
3302  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"AxisName", inVal->GetName() );
3303  fprintf( F, "<IsDefault> %s </IsDefault>\n", inVal->IsDefault() ? "True" : "False" );
3304  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inVal->GetMatrix() );
3305  }
3306  else
3307  {
3308  fprintf( F, "Null" );
3309  }
3310  fprintf( F, "</Dtk_AxisSystemPtr>\n" );
3311 
3312  return dtkNoError;
3313  }

◆ Dtk_DumpXml_Dtk_BodyPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_BodyPtr ( FILE *  F,
const Dtk_BodyPtr &  inBody 
)
6715  {
6716  Dtk_Size_t numLump, i, j;
6717 
6718  fprintf( F, "<Dtk_BodyPtr>" );
6719  fprintf( F, "<Status>%d</Status>", inBody->GetBodyStatus() );
6720  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inBody->get_info() );
6721  // fprintf(F,"<Id>%d</Id>",inBody->GetID());
6722  numLump = inBody->GetNumLumps();
6723  for( i = 0; i < numLump; i++ )
6724  {
6725  Dtk_LumpPtr lump;
6726  inBody->GetLump( i, lump );
6727  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LumpPtr( F, lump );
6728 
6729  }
6730  Dtk_ShellPtr myshell;
6731  Dtk_Size_t m, NumOpenshell = inBody->GetNumOpenShells();
6732 
6733  for( m = 0; m < NumOpenshell; m++ )
6734  {
6735  inBody->GetOpenShell( m, myshell );
6736  if( myshell.IsNotNULL() )
6737  {
6738  fprintf( F, "<Dtk_OpenShellPtr>" );
6739  if( myshell->info().IsNotNULL() )
6740  {
6741  fprintf( F, "<Id>%d</Id>", myshell->info()->GetId() );
6742  }
6743 
6744  Dtk_Size_t NumFaces = myshell->GetNumFaces();
6745  for( i = 0; i < NumFaces; i++ )
6746  {
6747  Dtk_FacePtr FacePtr;
6748  Dtk_bool Orientation;
6749  myshell->GetFace( i, FacePtr, Orientation );
6750  fprintf( F, "<orientation>%d</orientation>", Orientation );
6751  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FacePtr( F, FacePtr );
6752  }
6753  Dtk_Size_t nbWires = myshell->GetNumWireSet();
6754  if( nbWires != 0 )
6755  {
6756  fprintf( F, "<Wireframe>" );
6757  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, myshell->get_info() );
6758  for( i = 0; i < nbWires; i++ )
6759  {
6760  fprintf( F, "<WireSet>" );
6761 
6762  Dtk_tab<Dtk_EntityPtr> wireSet;
6763  Dtk_tab<Dtk_bool> orientation;
6764  Dtk_bool looporientation = -1;
6765  myshell->GetWireSetTopo( i, wireSet , orientation, looporientation);
6766  fprintf(F, "<WireLoopOrientation>%d</WireLoopOrientation>", looporientation);
6767  for( j = 0; j < wireSet.size(); j++ )
6768  {
6769  if( wireSet[ j ]->get_type_detk() != DTK_TYPE_VERTEX )
6770  {
6771  fprintf(F, "<WireEdgeOrientation>%d</WireEdgeOrientation>", orientation[j]);
6772  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EdgePtr( F, Dtk_EdgePtr::DtkDynamicCast( wireSet[ j ] ) );
6773  }
6774  else
6775  {
6776  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_VertexPtr( F, Dtk_VertexPtr::DtkDynamicCast( wireSet[ j ] ) );
6777  }
6778  }
6779  fprintf( F, "</WireSet>" );
6780  }
6781  fprintf( F, "</Wireframe>" );
6782  }
6783  fprintf( F, "</Dtk_OpenShellPtr>" );
6784  }
6785  }
6786  Dtk_Size_t numStream = inBody->GetNumStream();
6787  for( i = 0; i < numStream; i++ )
6788  {
6789  Dtk_StreamPtr stream;
6790  stream = inBody->GetStream( i );
6791  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_StreamPtr( F, stream );
6792 
6793  }
6794 
6795  fprintf( F, "</Dtk_BodyPtr>" );
6796 
6797  return dtkNoError;
6798  }

◆ Dtk_DumpXml_Dtk_bool()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_bool ( FILE *  F,
const Dtk_bool &  B 
)
1273  {
1274  Dtk_string str( "" );
1275 
1276  if( B == DTK_TRUE )
1277  {
1278  str = "DTK_TRUE";
1279  }
1280  else
1281  {
1282  str = "DTK_FALSE";
1283  }
1284  fprintf( F, "%s", str.c_str() );
1285  return dtkNoError;
1286  }

◆ Dtk_DumpXml_Dtk_BoundaryPtr()

static Dtk_ErrorStatus Dtk_DumpXml_Dtk_BoundaryPtr ( FILE *  F,
const Dtk_Boundary &  boundary 
)
static
2142  {
2143  fprintf( F, "<Dtk_BoundaryPtr>\n" );
2144 
2145  // Print exact representation -> an array of curves
2146  const auto& definition = boundary.GetExactRepresentation();
2147  fprintf( F, "<ExactRepresentation Num=\'" XmlFormat( "d" )"\'>\n", definition.size() );
2148  for( auto it = definition.cbegin(); it != definition.cend(); ++it )
2149  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, *it );
2150  fprintf( F, "</ExactRepresentation>\n" );
2151 
2152  // Print simplified representation -> a polyline
2153  fprintf( F, "<SimplifiedRepresentation>\n" );
2154  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_PolylinePtr( F, boundary.GetSimplifiedRepresentation() );
2155  fprintf( F, "</SimplifiedRepresentation>\n" );
2156 
2157  fprintf( F, "</Dtk_BoundaryPtr>\n" );
2158  return dtkNoError;
2159  }

◆ Dtk_DumpXml_Dtk_CameraProjectionTypeEnum()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraProjectionTypeEnum ( FILE *  F,
const Dtk_Camera::ProjectionTypeEnum &  inVal 
)
3113  {
3114  fprintf( F, "<Dtk_CameraProjectionTypeEnum>" );
3115  switch( inVal )
3116  {
3117  default:
3118  case Dtk_Camera::ProjectionTypeUnknown:
3119  {
3120  fprintf( F, "ProjectionTypeUnknown" );
3121  break;
3122  }
3123  case Dtk_Camera::ProjectionTypeParallel:
3124  {
3125  fprintf( F, "ProjectionTypeParallel" );
3126  break;
3127  }
3128  case Dtk_Camera::ProjectionTypePerspective:
3129  {
3130  fprintf( F, "ProjectionTypePerspective" );
3131  break;
3132  }
3133  }
3134  fprintf( F, "</Dtk_CameraProjectionTypeEnum>" );
3135  return dtkNoError;
3136 
3137  }

◆ Dtk_DumpXml_Dtk_CameraPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraPtr ( FILE *  F,
const Dtk_CameraPtr &  inVal 
)
3139  {
3140  fprintf( F, "<Dtk_Camera>\n" );
3141  if( inVal.IsNotNULL() )
3142  {
3143  //info
3144  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->info() );
3145  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inVal->OriginPoint(), "OriginPoint" );
3146  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inVal->TargetPoint(), "TargetPoint" );
3147  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inVal->UpVector(), "UpVector" );
3148  fprintf( F, "<Angle>%f</Angle>\n", inVal->Angle() );
3149  fprintf( F, "<Focus>%f</Focus>\n", inVal->Focus() );
3150  fprintf( F, "<ZoomFactor>%f</ZoomFactor>\n", inVal->ZoomFactor() );
3151  fprintf( F, "<ZoomFitMode>%i</ZoomFitMode>\n", inVal->GetZoomFitMode() );
3152 
3153  Dtk_Double64 front, back;
3154  inVal->GetClippingDistance( front, back );
3155  if( front != 0.0 || back != 0.0 )
3156  {
3157  fprintf( F, "<FrontClippingDistance>%f</FrontClippingDistance>\n", front );
3158  fprintf( F, "<BackClippingDistance>%f</BackClippingDistance>\n", back );
3159  }
3160 
3161 
3162  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CameraProjectionTypeEnum( F, inVal->ProjectionType() );
3163  }
3164  else
3165  {
3166  fprintf( F, "Null" );
3167  }
3168  fprintf( F, "</Dtk_Camera>\n" );
3169  return dtkNoError;
3170  }

◆ Dtk_DumpXml_Dtk_CoedgePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_CoedgePtr ( FILE *  F,
const Dtk_CoedgePtr &  inCoedge 
)
6575  {
6576  Dtk_EdgePtr edge;
6577  Dtk_CurvePtr curveUV;
6578 
6579  fprintf( F, "<Dtk_CoedgePtr>" );
6580  fprintf( F, "<orientation>%d</orientation>", inCoedge->GetOrientation() );
6581  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inCoedge->get_info() );
6582  // fprintf(F,"<Id>%d</Id>",inCoedge->GetID());
6583  curveUV = inCoedge->GetGeom();
6584  if( curveUV.IsNotNULL() )
6585  {
6586  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, curveUV );
6587  }
6588  inCoedge->GetEdge( edge );
6589  if( edge.IsNotNULL() )
6590  {
6591  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EdgePtr( F, edge );
6592  }
6593 
6594  fprintf( F, "</Dtk_CoedgePtr>" );
6595  return dtkNoError;
6596  }

◆ Dtk_DumpXml_Dtk_ColorInfosSetPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ColorInfosSetPtr ( FILE *  F,
const Dtk_ColorInfosSetPtr &  inVal 
)
3316  {
3317  fprintf( F, "<Dtk_ColorInfosSet>\n" );
3318  if( inVal.IsNotNULL() )
3319  {
3320  Dtk_Size_t i;
3321  Dtk_Size_t NumColors = inVal->GetNumColors();
3322  Dtk_Int32 DefaultColor;
3323 
3324  inVal->GetDefaultColor( DefaultColor );
3325  fprintf( F, "<Colors Num=\"" XmlFormat( "u" )"\" DefaultColor=\" %d\">\n", NumColors, DefaultColor );
3326  for( i = 0; i < NumColors; i++ )
3327  {
3328  Dtk_string ColorName;
3329  Dtk_ID ColorReadId;
3330  Dtk_RGB ColorDef;
3331  Dtk_ErrorStatus errd = inVal->GetColorDefinition( i, ColorDef );
3332  Dtk_ErrorStatus errn = inVal->GetColorName( i, ColorName );
3333  Dtk_ErrorStatus erri = inVal->GetColorID( i, ColorReadId );
3334  if( errn == dtkNoError && erri == dtkNoError )
3335  {
3336  ColorName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( ColorName, XMLGenericString );
3337  fprintf( F, "<__%d__ Name=\"%S\"", ColorReadId, ColorName.w_str() );
3338  }
3339  else
3340  {
3341  if( erri == dtkNoError )
3342  fprintf( F, "<__%d__ Name=\"\"", ColorReadId );
3343  else
3344  fprintf( F, "<__" XmlFormat( "u" )"__ Name=\"\"", i );
3345 
3346  }
3347  if( errd == dtkNoError )
3348  {
3349  //Dtk_DumpXml_Dtk_RGB(F, ColorDef);
3350  if( ColorDef.IndexReader() >= 0 )
3351  {
3352  fprintf( F, " RGBA=\"%d %d %d %d %d \" ", ColorDef[ 0 ], ColorDef[ 1 ], ColorDef[ 2 ], ColorDef[ 3 ], ColorDef.IndexReader() );
3353  }
3354  else
3355  {
3356  fprintf( F, " RGBA=\"%d %d %d %d\" ", ColorDef[ 0 ], ColorDef[ 1 ], ColorDef[ 2 ], ColorDef[ 3 ] );
3357  }
3358  }
3359  fprintf( F, "/>\n" );
3360  }
3361  fprintf( F, "</Colors>\n" );
3362  }
3363  else
3364  {
3365  fprintf( F, "Null" );
3366  }
3367  fprintf( F, "</Dtk_ColorInfosSet>\n" );
3368 
3369  return dtkNoError;
3370  }

◆ Dtk_DumpXml_Dtk_ComponentAvailability()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentAvailability ( FILE *  F,
const Dtk_ComponentPtr &  inObject 
)
4897  {
4898  //deprecated
4899 
4900  /* Dtk_string avail = Dtk_Component::ComponentAvailabilityEnumToString( inObject->ComponentAvailability() );
4901  fprintf( F, "<ComponentAvailability>%ls</ComponentAvailability>\n", avail.w_str() );
4902  if( inObject->IsAdditionnalReference() )
4903  fprintf( F, "<IsAdditionnalReference>1</IsAdditionnalReference>\n" );*/
4904 
4905  //new flags
4906 
4907  if( inObject->IsAvailabilityFlaggedAs( Dtk_Component::ComponentFound ) )
4908  fprintf( F, "<ComponentFound>true</ComponentFound>\n" );
4909  if( inObject->IsAvailabilityFlaggedAs( Dtk_Component::ComponentMissing ) )
4910  fprintf( F, "<ComponentMissing>true</ComponentMissing>\n" );
4911  if( inObject->IsAvailabilityFlaggedAs( Dtk_Component::ComponentAdditionnalReference ) )
4912  fprintf( F, "<ComponentAdditionnalReference>true</ComponentAdditionnalReference>\n" );
4913  if( inObject->IsAvailabilityFlaggedAs( Dtk_Component::ComponentInternal ) )
4914  fprintf( F, "<ComponentInternal>true</ComponentInternal>\n" );
4915  if( inObject->IsAvailabilityFlaggedAs( Dtk_Component::ComponentPhantom ) )
4916  fprintf( F, "<ComponentPhantom>true</ComponentPhantom>\n" );
4917  if( inObject->IsAvailabilityFlaggedAs( Dtk_Component::ComponentAssemblyGeometry ) )
4918  fprintf( F, "<ComponentAssemblyGeometry>true</ComponentAssemblyGeometry>\n" );
4919  if( inObject->IsAvailabilityFlaggedAs( Dtk_Component::ComponentWithUnavailableReader ) )
4920  fprintf( F, "<ComponentWithUnavailableReader>true</ComponentWithUnavailableReader>\n" );
4921  if( inObject->IsAvailabilityFlaggedAs( Dtk_Component::ComponentNotRequired ) )
4922  fprintf( F, "<ComponentNotRequired>true</ComponentNotRequired>\n" );
4923 
4924  return dtkNoError;
4925 
4926  }

◆ Dtk_DumpXml_Dtk_ComponentPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr ( FILE *  F,
const Dtk_ComponentPtr &  inObject 
)
4845  {
4846  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr_Init( F, inObject );
4847  Dtk_Size_t NumChildren = inObject->GetNumChildren();
4848  for( Dtk_Size_t i = 0; i < NumChildren; i++ )
4849  {
4850  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->GetChild( i ) );
4851  }
4852 
4853  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr_End( F );
4854  /*fprintf( F, "<Dtk_ComponentPtr>\n" );
4855  if( inObject.IsNotNULL() )
4856  {
4857  Dtk_Size_t i, NumChildren, NumFathers = inObject->GetNumFathers();
4858  Dtk_MaterialPtr mat = NULL;
4859  fprintf( F, "<ComponentID>%u</ComponentID>\n", inObject->GetID() );
4860  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4861  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4862  Dtk_ID readid;
4863  inObject->GetReadID( readid );
4864  if( readid > 0 )
4865  fprintf( F, "<ReadID>%d</ReadID>\n", readid );
4866  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FullPathName", inObject->FullPathName() );
4867  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"InstanceName", inObject->InstanceName() );
4868  if( inObject->GetFileVersion().icmp( L"" ) != 0 )
4869  {
4870  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FileVersion", inObject->GetFileVersion() );
4871  }
4872  fprintf( F, "<ComponentUnitScale>%f</ComponentUnitScale>\n", inObject->GetConceptionUnitScale() );
4873  for( i = 0; i < NumFathers; i++ )
4874  fprintf( F, "<FatherID>%u</FatherID>\n", inObject->GetFatherID( i ) );
4875  Dtk_DumpXMLNamespace::Dtk_DumpXml_DtkReaderType( F, inObject->GetAssociatedModuleType(), L"AssociatedModule" );
4876  Dtk_DumpXMLNamespace::Dtk_DumpXml_ComponentTypeEnum( F, inObject->ComponentType(), L"ComponentType" );
4877  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inObject->TransformationMatrix() );
4878  // mat = inObject->GetMaterial();
4879  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_material(F,mat);
4880 
4881 
4882  NumChildren = inObject->GetNumChildren();
4883  for( i = 0; i < NumChildren; i++ )
4884  {
4885  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->GetChild( i ) );
4886  }
4887 
4888  }
4889  else
4890  {
4891  fprintf( F, "'Null'" );
4892  }
4893  fprintf( F, "</Dtk_ComponentPtr>\n" );*/
4894  return dtkNoError;
4895  }

◆ Dtk_DumpXml_Dtk_ComponentPtr_End()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_End ( FILE *  F)
5023  {
5024  if( F == NULL )
5025  {
5026  return dtkErrorNullPointer;
5027  }
5028 
5029  fprintf( F, "</Dtk_ComponentPtr>\n" );
5030  return dtkNoError;
5031  }

◆ Dtk_DumpXml_Dtk_ComponentPtr_Init()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_Init ( FILE *  F,
const Dtk_ComponentPtr &  inObject 
)
4930  {
4931  if( F == NULL )
4932  {
4933  return dtkErrorNullPointer;
4934  }
4935 
4936  fprintf( F, "<Dtk_ComponentPtr>\n" );
4937  if( inObject.IsNotNULL() )
4938  {
4939  Dtk_Size_t i;
4940  Dtk_MaterialPtr mat = NULL;
4941  fprintf( F, "<ComponentID>%u</ComponentID>\n", inObject->GetID() );
4942  fprintf( F, "<IsAssembly>%d</IsAssembly>\n", inObject->IsAssembly() );
4943  if( inObject->ComponentType() == Dtk_Component::PrototypeComponentType )
4944  {
4945  Dtk_DumpXml_Dtk_ComponentAvailability( F, inObject );
4946  }
4947  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4948  if( inObject->Name().len() > 0 )
4949  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4950 
4951  Dtk_ID readid;
4952  inObject->GetReadID( readid );
4953  if( readid > 0 )
4954  fprintf( F, "<ReadID>%d</ReadID>\n", readid );
4955 
4956  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FullPathName", inObject->FullPathName() );
4957  if( inObject->OriginalPathName().len() > 0 )
4958  {
4959  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"OriginalPathName", inObject->OriginalPathName() );
4960  }
4961  if( inObject->InstanceName().len() > 0 )
4962  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"InstanceName", inObject->InstanceName() );
4963  if( inObject->GetFileVersion().len() > 0 )
4964  {
4965  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FileVersion", inObject->GetFileVersion() );
4966  }
4967  Dtk_Double64 UnitScale;
4968  inObject->GetConceptionUnitScale( UnitScale );
4969  fprintf( F, "<ComponentUnitScale>%f</ComponentUnitScale>\n", UnitScale );
4970  Dtk_ID FatherID = inObject->GetFatherID( 0 );
4971  if( FatherID )
4972  fprintf( F, "<FatherID>%u</FatherID>\n", FatherID );
4973  Dtk_DumpXMLNamespace::Dtk_DumpXml_DtkReaderType( F, inObject->GetAssociatedModuleType(), L"AssociatedModule" );
4974  Dtk_DumpXMLNamespace::Dtk_DumpXml_ComponentTypeEnum( F, inObject->ComponentType(), L"ComponentType" );
4975 
4976  Dtk_PreviewPtr preview = inObject->GetPreview();
4977  if( preview.IsNotNULL() )
4978  {
4979  Dtk_Size_t size = preview->GetStreamSize();
4980  fprintf( F, "<PreviewSize>\"" XmlFormat( "u" )"\"</PreviewSize>", size );
4981  }
4982 
4983  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inObject->TransformationMatrix() );
4984  // mat = inObject->GetMaterial();
4985  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_material(F,mat);
4986 
4987  Dtk_Size_t NumMetaData;
4988  NumMetaData = inObject->GetNumMetaData();
4989  if( NumMetaData )
4990  {
4991  fprintf( F, "<Dtk_MetaData Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaData );
4992  for( i = 0; i < NumMetaData; i++ )
4993  {
4994  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr( F, inObject->GetMetaData( i ) );
4995  }
4996  fprintf( F, "</Dtk_MetaData>\n" );
4997  }
4998 
4999 #ifdef XML_GROUP_METADATA
5000  Dtk_Size_t NumMetaDataGroup;
5001  NumMetaDataGroup = inObject->GetNumMetaDataGroup();
5002  if( NumMetaDataGroup )
5003  {
5004  fprintf( F, "<Dtk_MetaDataGroup Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaDataGroup );
5005  for( i = 0; i < NumMetaDataGroup; i++ )
5006  {
5007  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataGroupPtr( F, inObject->GetMetaDataGroup( i ) );
5008  }
5009  fprintf( F, "</Dtk_MetaDataGroup>\n" );
5010  }
5011 #endif
5012  }
5013  else
5014  {
5015  fprintf( F, "'Null'" );
5016  }
5017 
5018  return dtkNoError;
5019  }

◆ Dtk_DumpXml_Dtk_CompositeEntityPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_CompositeEntityPtr ( FILE *  F,
const Dtk_CompositeEntityPtr &  D 
)
2480  {
2481  fprintf( F, "<Dtk_CompositeEntity>\n" );
2482 
2483  Dtk_tab< Dtk_2dEntityPtr > Tmp2dEntities;
2484  Dtk_tab< Dtk_EntityPtr > TmpGeometricalEntities;
2485  Dtk_tab< Dtk_picturePtr > TmpPictures;
2486 
2487  D->GetAllEntitiesByType( Tmp2dEntities, TmpGeometricalEntities, TmpPictures );
2488  Dtk_Size_t i, NumElts;
2489 
2490  ////////////////// 2DEntities ////////////////////////
2491  NumElts = Tmp2dEntities.size();
2492  fprintf( F, "<_2DEntities NumElts=\"" XmlFormat( "u" ) " \">\n", NumElts );
2493  for( i = 0; i < NumElts; ++i )
2494  {
2495  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_2dEntityPtr( F, Tmp2dEntities[ i ] );
2496  }
2497  fprintf( F, "</_2DEntities>\n" );
2498  //////////////////////////////////////////////////////
2499 
2500  //////////////// Geometrical Entities ////////////////
2501  NumElts = TmpGeometricalEntities.size();
2502  fprintf( F, "<GeometricalEntities NumElts=\"" XmlFormat( "u" ) " \">\n", NumElts );
2503  for( i = 0; i < NumElts; ++i )
2504  {
2505  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EntityPtr( F, TmpGeometricalEntities[ i ] );
2506  }
2507  fprintf( F, "</GeometricalEntities>\n" );
2508  //////////////////////////////////////////////////////
2509 
2510  /////////////////// Pictures /////////////////////////
2511  NumElts = TmpPictures.size();
2512  fprintf( F, "<Pictures NumElts=\"" XmlFormat( "u" ) " \">\n", NumElts );
2513  for( i = 0; i < NumElts; ++i )
2514  {
2515  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Picture( F, TmpPictures[ i ].operator ->() );
2516  }
2517  fprintf( F, "</Pictures>\n" );
2518  //////////////////////////////////////////////////////
2519 
2520  fprintf( F, "</Dtk_CompositeEntity>\n" );
2521  return dtkNoError;
2522  }

◆ Dtk_DumpXml_Dtk_CompositeText()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_CompositeText ( FILE *  F,
const Dtk_CompositeText &  T 
)
1246  {
1247  fprintf( F, "<Dtk_CompositeText>\n" );
1248  Dtk_Size_t i, nbtexts;
1249  nbtexts = T.GetNumTexts();
1250 
1251  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, T.GetInfo() );
1252  if( nbtexts )
1253  {
1254  const Dtk_Oriented2dBBox InnerBBox = T.GetInnerBoundingBox();
1255  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, InnerBBox, L"Inner_Bounding_box" );
1256 
1257 
1258  const Dtk_Oriented2dBBox OuterBBox = T.GetOuterBoundingBox();
1259  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, OuterBBox, L"Outer_Bounding_box" );
1260  }
1261 
1262  fprintf( F, "<Num_texts>" XmlFormat( "u" )"</Num_texts>\n", nbtexts );
1263  for( i = 0; i < nbtexts; i++ )
1264  {
1265  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, T[ i ] );
1266  }
1267 
1268  fprintf( F, "</Dtk_CompositeText>\n" );
1269  return dtkNoError;
1270  }

◆ Dtk_DumpXml_Dtk_ConicalSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConicalSurfacePtr ( FILE *  F,
const Dtk_ConicalSurfacePtr &  inSurf 
)
6215  {
6216  fprintf( F, "<Dtk_ConicalSurfacePtr>" );
6217 
6218  fprintf( F, "<AxisPosition>" );
6219  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inSurf->GetAxisPosition() );
6220  fprintf( F, "</AxisPosition>" );
6221  fprintf( F, "<RevolutionAxis>" );
6222  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetRevolutionAxis() );
6223  fprintf( F, "</RevolutionAxis>" );
6224  fprintf( F, "<Radius>%f</Radius>", inSurf->GetRadius() );
6225  fprintf( F, "<SemiAngle>%f</SemiAngle>", inSurf->GetSemiAngle() );
6226 
6227  fprintf( F, "</Dtk_ConicalSurfacePtr>" );
6228  return dtkNoError;
6229 
6230  }

◆ Dtk_DumpXml_Dtk_Constraint_ConstraintValue()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Constraint_ConstraintValue ( FILE *  F,
const Dtk_Constraint::_ConstraintValue &  inVal 
)
8578  {
8579  const Dtk_string typeAsString = Dtk_Constraint::ConstraintValueTypeEnumToString( inVal._ValueType );
8580 
8581  fprintf( F, "<%s>\n", typeAsString.c_str() );
8582 
8583  if( inVal._ValueType == Dtk_Constraint::ValueTypeOrientation )
8584  {
8585  const Dtk_Int32 value = inVal._Value.GetInt();
8586  const Dtk_Constraint::ConstraintOrientationTypeEnum valueAsEnum = ( Dtk_Constraint::ConstraintOrientationTypeEnum )value;
8587  Dtk_DumpXMLNamespace::Dtk_DumpXml_ConstraintOrientationEnum( F, valueAsEnum );
8588  }
8589  else
8590  {
8591  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, inVal._Value );
8592  }
8593 
8594  if( inVal._EnableLower == DTK_TRUE )
8595  fprintf( F, "<LowerLimit>%f</LowerLimit>\n", inVal._ValueLower );
8596  if( inVal._EnableUpper == DTK_TRUE )
8597  fprintf( F, "<UpperLimit>%f</UpperLimit>\n", inVal._ValueUpper );
8598 
8599  fprintf( F, "</%s>\n", typeAsString.c_str() );
8600 
8601  return dtkNoError;
8602  }

◆ Dtk_DumpXml_Dtk_ConstraintPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConstraintPtr ( FILE *  F,
const Dtk_ConstraintPtr &  inVal 
)
8626  {
8627  fprintf( F, "<Dtk_ConstraintPtr>\n" );
8628  if( inVal.IsNULL() == DTK_TRUE )
8629  fprintf( F, "Null" );
8630  else
8631  {
8632  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->get_info() );
8633  Dtk_DumpXMLNamespace::Dtk_DumpXml_ConstraintTypeEnum( F, inVal->GetConstraintType(), L"ConstraintType" );
8634 
8635  const Dtk_Size_t nbConstraintValues = inVal->GetNumberOfConstraintValues();
8636  for( Dtk_Size_t i = 0; i < nbConstraintValues; ++i )
8637  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Constraint_ConstraintValue( F, inVal->GetConstraintValue( i ) );
8638 
8639  const Dtk_Size_t nbConstraintReferences = inVal->GetNumberOfConstraintReferences();
8640  for( Dtk_Size_t i = 0; i < nbConstraintReferences; ++i )
8641  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ConstraintReferencePtr( F, inVal->GetConstraintReference( i ) );
8642  }
8643  fprintf( F, "</Dtk_ConstraintPtr>\n" );
8644  return dtkNoError;
8645  }

◆ Dtk_DumpXml_Dtk_ConstraintReferencePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConstraintReferencePtr ( FILE *  F,
const Dtk_ConstraintReferencePtr &  inVal 
)
8605  {
8606  fprintf( F, "<Dtk_ConstraintReferencePtr>\n" );
8607  if( inVal.IsNULL() )
8608  fprintf( F, "Null" );
8609  else
8610  {
8611  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->info() );
8612 
8613  if( inVal->GetNodeConnector().IsNotNULL() )
8614  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NodeConnector( F, inVal->GetNodeConnector() );
8615 
8616  Dtk_bool hasPosition = DTK_FALSE;
8617  const Dtk_pnt position = inVal->GetPosition( hasPosition );
8618  if( hasPosition == DTK_TRUE )
8619  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, position, "Position" );
8620  }
8621  fprintf( F, "</Dtk_ConstraintReferencePtr>\n" );
8622  return dtkNoError;
8623  }

◆ Dtk_DumpXml_Dtk_CurvePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_CurvePtr ( FILE *  F,
const Dtk_CurvePtr &  inCurve 
)
6016  {
6017  type_detk type;
6018  if( inCurve.IsNULL() )
6019  {
6020  return dtkErrorNullPointer;
6021  }
6022  fprintf( F, "<Dtk_CurvePtr>" );
6023  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inCurve->get_info() );
6024  // fprintf(F,"<Id>%d</Id>",inCurve->GetID());
6025 
6026  if( inCurve->IsTrimmed() )
6027  {
6028  fprintf( F, "<Domain>" );
6029 
6030  fprintf( F, "<UMin>%f</UMin>", inCurve->GetTrimUMin() );
6031  fprintf( F, "<UMax>%f</UMax>", inCurve->GetTrimUMax() );
6032 
6033  fprintf( F, "</Domain>" );
6034  }
6035 
6036 
6037 
6038  type = inCurve->get_type_detk();
6039  switch( type )
6040  {
6041  case DTK_TYPE_LINE:
6042  {
6043  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LinePtr( F, Dtk_LinePtr::DtkDynamicCast( inCurve ) );
6044  break;
6045  }
6046  case DTK_TYPE_POLYLINE:
6047  {
6048  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_PolylinePtr( F, Dtk_PolylinePtr::DtkDynamicCast( inCurve ) );
6049  break;
6050  }
6051  case DTK_TYPE_NURBS_CURVE:
6052  {
6053  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NurbsCurvePtr( F, Dtk_NurbsCurvePtr::DtkDynamicCast( inCurve ) );
6054  break;
6055  }
6056  case DTK_TYPE_HYPERBOLA:
6057  {
6058  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_HyperbolaPtr( F, Dtk_HyperbolaPtr::DtkDynamicCast( inCurve ) );
6059  break;
6060  }
6061  case DTK_TYPE_PARABOLA:
6062  {
6063  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ParabolaPtr( F, Dtk_ParabolaPtr::DtkDynamicCast( inCurve ) );
6064  break;
6065  }
6066  case DTK_TYPE_CIRCLE:
6067  case DTK_TYPE_ELLIPSE:
6068  {
6069  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EllipsePtr( F, Dtk_EllipsePtr::DtkDynamicCast( inCurve ) );
6070  break;
6071  }
6072  case DTK_TYPE_INTERSECTION_CURVE:
6073  case DTK_TYPE_SPCURVE:
6074  {
6075  //Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_IntersectCurvePtr( F, Dtk_IntersectCurvePtr::DtkDynamicCast( inCurve ) );
6076  type = type;
6077  break;
6078  }
6079  default:
6080  {
6081  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NurbsCurvePtr( F, Dtk_NurbsCurvePtr::DtkDynamicCast( inCurve->ToNurbs() ) );
6082  break;
6083  }
6084  }
6085  fprintf( F, "</Dtk_CurvePtr>" );
6086  return dtkNoError;
6087  }

◆ Dtk_DumpXml_Dtk_CylindricalSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_CylindricalSurfacePtr ( FILE *  F,
const Dtk_CylindricalSurfacePtr &  inSurf 
)
6198  {
6199  fprintf( F, "<Dtk_CylindricalSurfacePtr>" );
6200 
6201  fprintf( F, "<AxisPosition>" );
6202  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inSurf->GetAxisPosition() );
6203  fprintf( F, "</AxisPosition>" );
6204  fprintf( F, "<RevolutionAxis>" );
6205  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetRevolutionAxis() );
6206  fprintf( F, "</RevolutionAxis>" );
6207  fprintf( F, "<Radius>%f</Radius>", inSurf->GetRadius() );
6208 
6209  fprintf( F, "</Dtk_CylindricalSurfacePtr>" );
6210  return dtkNoError;
6211 
6212  }

◆ Dtk_DumpXml_DTK_DATUM_COMPOSING_RULE()

Dtk_ErrorStatus Dtk_DumpXml_DTK_DATUM_COMPOSING_RULE ( FILE *  F,
const DTK_DATUM_COMPOSING_RULE &  D 
)
2603  {
2604  fprintf( F, "<DTK_DATUM_COMPOSING_RULE>" );
2605  switch( D )
2606  {
2607  default:
2608  case DTK_UNKNOWN:
2609  fprintf( F, "DTK_UNKNOWN" );
2610  break;
2611  case DTK_WITH_HIERARCHY:
2612  fprintf( F, "DTK_WITH_HIERARCHY" );
2613  break;
2614  case DTK_WITHOUT_HIERARCHY:
2615  fprintf( F, "DTK_WITHOUT_HIERARCHY" );
2616  break;
2617  case DTK_INDIFFERENT_HIERARCHY:
2618  fprintf( F, "DTK_INDIFFERENT_HIERARCHY" );
2619  break;
2620  }
2621  fprintf( F, "</DTK_DATUM_COMPOSING_RULE>\n" );
2622  return dtkNoError;
2623  }

◆ Dtk_DumpXml_Dtk_DatumTargetPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_DatumTargetPtr ( FILE *  F,
const Dtk_DatumTargetPtr &  D 
)
2082  {
2083  Dtk_Val value;
2084  Dtk_Int32 i = 0;
2085 
2086  fprintf( F, "<Dtk_DatumTargetPtr>\n" );
2087  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_AnnotationPtr( F, Dtk_AnnotationPtr::DtkDynamicCast( D ) ); // upcasting
2088 
2089  fprintf( F, "<DatumTargetType>%s</DatumTargetType>\n", Dtk_DatumTarget::DatumTargetTypeEnumToString( D->GetDatumTargetType() ).c_str() );
2090 
2091  for( i = 0; i < Dtk_DatumTarget::NumValues; i++ )
2092  {
2093  if( D->GetParameterValue( ( Dtk_DatumTarget::DatumTargetValueEnum )i, value ) == dtkNoError )
2094  {
2095  fprintf( F, "<%ls>\n", Dtk_DatumTarget::DatumTargetValueEnumToString( ( Dtk_DatumTarget::DatumTargetValueEnum )i ).w_str() );
2096  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, value );
2097  fprintf( F, "</%ls>\n", Dtk_DatumTarget::DatumTargetValueEnumToString( ( Dtk_DatumTarget::DatumTargetValueEnum )i ).w_str() );
2098  }
2099  }
2100 
2101  if( D->GetFrame().GetFrameType() != DTK_FRAME_TYPE_NONE )
2102  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Frame( F, D->GetFrame() );
2103 
2104  if( D->GetDatumTargetMovableStatus() != Dtk_DatumTarget::NonMovable )
2105  {
2106  Dtk_tab<Dtk_CurvePtr> &movable_geom = D->GetDatumTargetMovableStatusRelatedGeom();
2107  Dtk_Size_t size = movable_geom.size();
2108  fprintf( F, "<MovableStatus>%ls</MovableStatus>\n", Dtk_DatumTarget::DatumTargetMovableStatusEnumToString( D->GetDatumTargetMovableStatus() ).w_str() );
2109  fprintf( F, "<MovableRelatedGeom Num=\"" XmlFormat( "u" )"\">\n", size );
2110  for( Dtk_Size_t ii = 0; ii < size; ++ii )
2111  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, movable_geom[ ii ] );
2112  fprintf( F, "</MovableRelatedGeom>\n" );
2113  }
2114 
2115  fprintf( F, "<TopText>\n" );
2116  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->TopText() );
2117  fprintf( F, "</TopText>\n" );
2118 
2119  if( D->GetOptionnalTopTextLeader() )
2120  {
2121  fprintf( F, "<TopTextLeader>\n" );
2122  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LeaderPtr( F, D->GetOptionnalTopTextLeader() );
2123  fprintf( F, "</TopTextLeader>\n" );
2124  }
2125 
2126  fprintf( F, "<BottomText>\n" );
2127  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->BottomText() );
2128  fprintf( F, "</BottomText>\n" );
2129 
2130  if( D->GetOptionnalBottomTextLeader() )
2131  {
2132  fprintf( F, "<BottomTextLeader>\n" );
2133  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LeaderPtr( F, D->GetOptionnalBottomTextLeader() );
2134  fprintf( F, "</BottomTextLeader>\n" );
2135  }
2136 
2137  fprintf( F, "</Dtk_DatumTargetPtr>\n" );
2138  return dtkNoError;
2139  }

◆ Dtk_DumpXml_Dtk_Dimension_BasicDimensionType()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Dimension_BasicDimensionType ( FILE *  F,
const Dtk_Dimension::BasicDimensionTypeEnum &  D 
)
1350  {
1351  fprintf( F, "<Dtk_Dimension_BasicDimensionType>" );
1352  switch( D )
1353  {
1354  default:
1355  case Dtk_Dimension::BasicTypeNone:
1356  fprintf( F, "BasicTypeNone" );
1357  break;
1358  case Dtk_Dimension::BasicTypeRectangle:
1359  fprintf( F, "BasicTypeRectangle" );
1360  break;
1361  case Dtk_Dimension::BasicTypeCircle:
1362  fprintf( F, "BasicTypeCircle" );
1363  break;
1364  case Dtk_Dimension::BasicTypeFlagRight:
1365  fprintf( F, "BasicTypeFlagRight" );
1366  break;
1367  case Dtk_Dimension::BasicTypeOblong:
1368  fprintf( F, "BasicTypeOblong" );
1369  break;
1370  }
1371  fprintf( F, "</Dtk_Dimension_BasicDimensionType>\n" );
1372  return dtkNoError;
1373  }

◆ Dtk_DumpXml_Dtk_Dimension_DimensionType()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Dimension_DimensionType ( FILE *  F,
const Dtk_Dimension::DimensionTypeEnum &  D 
)
1403  {
1404  fprintf( F, "<Dtk_DimensionType>" );
1405  switch( D )
1406  {
1407  default:
1408  case Dtk_Dimension::LinearDimension: fprintf( F, "LinearDimension" ); break;
1409  case Dtk_Dimension::AngularDimension: fprintf( F, "AngularDimension" ); break;
1410  case Dtk_Dimension::CurvilinearDimension: fprintf( F, "CurvilinearDimension" ); break;
1411  case Dtk_Dimension::DiameterDimension: fprintf( F, "DiameterDimension" ); break;
1412  case Dtk_Dimension::LinearDiameterDimension: fprintf( F, "LinearDiameterDimension" ); break;
1413  case Dtk_Dimension::RadiusDimension: fprintf( F, "RadiusDimension" ); break;
1414  case Dtk_Dimension::LinearRadiusDimension: fprintf( F, "LinearRadiusDimension" ); break;
1415  case Dtk_Dimension::CumulatedDimension: fprintf( F, "CumulatedDimension" ); break;
1416  case Dtk_Dimension::ChamferDimension: fprintf( F, "ChamferDimension" ); break;
1417  case Dtk_Dimension::LengthDimension: fprintf( F, "LengthDimension" ); break;
1418  case Dtk_Dimension::DistanceDimension: fprintf( F, "DistanceDimension" ); break;
1419  }
1420  fprintf( F, "</Dtk_DimensionType>\n" );
1421  return dtkNoError;
1422  }

◆ Dtk_DumpXml_Dtk_Dimension_ShowDualValueType()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Dimension_ShowDualValueType ( FILE *  F,
const Dtk_Dimension::ShowDualValueTypeEnum &  D 
)
1376  {
1377  if( D == Dtk_Dimension::ShowDualValueNone )
1378  {
1379  return dtkNoError;
1380  }
1381 
1382  fprintf( F, "<Dtk_Dimension_ShowDualValueType>" );
1383  switch( D )
1384  {
1385  default:
1386  case Dtk_Dimension::ShowDualValueNone:
1387  fprintf( F, "ShowDualValueNone" );
1388  break;
1389  case Dtk_Dimension::ShowDualValueBelow:
1390  fprintf( F, "ShowDualValueBelow" );
1391  break;
1392  case Dtk_Dimension::ShowDualValueFractional:
1393  fprintf( F, "ShowDualValueFractional" );
1394  break;
1395  case Dtk_Dimension::ShowDualValueSydeBySide:
1396  fprintf( F, "ShowDualValueSydeBySide" );
1397  break;
1398  }
1399  fprintf( F, "</Dtk_Dimension_ShowDualValueType>\n" );
1400  return dtkNoError;
1401  }

◆ Dtk_DumpXml_Dtk_DimensionPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_DimensionPtr ( FILE *  F,
const Dtk_DimensionPtr &  D 
)
1426  {
1427  fprintf( F, "<Dtk_DimensionPtr>\n" );
1428  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, D->info() );
1429  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->GetTexts() );
1430  Dtk_Size_t i, nbleads, nbextrdraw;
1431  nbleads = D->GetNumLeaders();
1432  Dtk_tab< Dtk_CurvePtr > RelatedGeomElements;
1433  Dtk_Dimension::BasicDimensionTypeEnum type = D->GetBasicDimensionType( RelatedGeomElements );
1434  type = type;
1435  Dtk_Size_t sizei = RelatedGeomElements.size();
1436 
1437  if( sizei > 0 )
1438  {
1439  fprintf( F, "<RelatedGeomElements>\n" );
1440  }
1441  for( i = 0; i < sizei; i++ )
1442  {
1443  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, RelatedGeomElements[ i ] );
1444  }
1445  if( sizei > 0 )
1446  {
1447  fprintf( F, "</RelatedGeomElements>\n" );
1448  }
1449 
1450  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Dimension_BasicDimensionType( F, D->BasicDimensionType() );
1451  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Dimension_ShowDualValueType( F, D->ShowDualValueType() );
1452  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Dimension_DimensionType( F, D->GetDimensionType() );
1453 
1454  Dtk_Frame DimFrame;
1455  D->GetFrame( DimFrame );
1456  Dtk_tab< Dtk_CurvePtr > AssocGeoms;
1457  if( DimFrame.GetFrameType() != DTK_FRAME_TYPE_NONE )
1458  {
1459  DimFrame.CreateGeometries( AssocGeoms );
1460  }
1461  if( DimFrame.GetFrameType() != DTK_FRAME_TYPE_NONE || AssocGeoms.size() > 0 )
1462  {
1463  fprintf( F, "<DimFrame>\n" );
1464  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Frame( F, DimFrame );
1465  fprintf( F, "</DimFrame>\n" );
1466  }
1467 
1468  fprintf( F, "<Leaders>\n" );
1469  fprintf( F, "<num_leaders>" XmlFormat( "u" )"</num_leaders>\n", nbleads );
1470  for( i = 0; i < nbleads; i++ )
1471  {
1472  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LeaderPtr( F, D->GetLeader( i ) );
1473  }
1474  fprintf( F, "</Leaders>\n" );
1475  /*nbextline = D->GetNumExtensionLines();//Already processed in Dtk_Leader
1476  fprintf( F, "<ext_lines>\n" );
1477  fprintf( F, "<num_ext_lines>" XmlFormat( "u" )"</num_ext_lines>\n", nbextline );
1478  for( i = 0; i < nbextline; i++ )
1479  {
1480  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, D->GetExtensionLineAsCurve( i ) );
1481  }
1482  fprintf( F, "</ext_lines>\n" );*/
1483  nbextrdraw = D->GetNumExtraGeometries();
1484  fprintf( F, "<ext_draw>\n" );
1485  fprintf( F, "<num_ext_draw>" XmlFormat( "u" )"</num_ext_draw>\n", nbextrdraw );
1486  for( i = 0; i < nbextrdraw; i++ )
1487  {
1488  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, D->GetExtraGeometryAsCurve( i ) );
1489  }
1490  fprintf( F, "</ext_draw>\n" );
1491  fprintf( F, "</Dtk_DimensionPtr>\n" );
1492  return dtkNoError;
1493  }

◆ Dtk_DumpXml_Dtk_dir()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_dir ( FILE *  F,
const Dtk_dir &  D,
const char *  b 
)
4357  {
4358  fprintf( F, "<%s>(%f %f %f)</%s>\n", b, D[ 0 ], D[ 1 ], D[ 2 ], b );
4359  return dtkNoError;
4360  }

◆ Dtk_DumpXml_Dtk_DrawingPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_DrawingPtr ( FILE *  F,
const Dtk_DrawingPtr &  D,
const int &  compact 
)
3043  {
3044  if( F == NULL )
3045  {
3046  return dtkErrorNullPointer;
3047  }
3048  Dtk_Size_t i;
3049  fprintf( F, "<Dtk_DrawingPtr>\n" );
3050  Dtk_DumpXml_Dtk_info( F, D->get_info() );
3051  fprintf( F, "<Width>%f</Width><Height>%f</Height>\n", D->Width(), D->Height() );
3052  fprintf( F, "<Views><Number>" XmlFormat( "u" )"</Number>\n", D->GetNumViews() );
3053  for( i = 0; i < D->GetNumViews(); i++ )
3054  {
3055  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, D->GetOrigin( i ), "Origin" );
3056  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ViewPtr( F, D->GetView( i ), compact );
3057  }
3058  fprintf( F, "</Views>\n" );
3059  fprintf( F, "</Dtk_DrawingPtr>\n" );
3060  return dtkNoError;
3061  }

◆ Dtk_DumpXml_Dtk_EdgePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_EdgePtr ( FILE *  F,
const Dtk_EdgePtr &  inEdge 
)
6541  {
6542  Dtk_CurvePtr curve3d;
6543  Dtk_VertexPtr startVertex, endVertex;
6544 
6545  fprintf( F, "<Dtk_EdgePtr>" );
6546  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inEdge->get_info() );
6547 
6548  Dtk_Double64 tolerance = 0.0;
6549  if( inEdge->GetTolerance( tolerance ) == dtkNoError )
6550  {
6551  fprintf( F, "<tolerance>%f</tolerance>", tolerance );
6552  }
6553 
6554  // fprintf(F,"<Id>%d</Id>",inEdge->GetID());
6555  curve3d = inEdge->GetGeom();
6556  if( curve3d.IsNotNULL() )
6557  {
6558  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, curve3d );
6559  }
6560  inEdge->GetStartVertex( startVertex );
6561  if( startVertex.IsNotNULL() )
6562  {
6563  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_VertexPtr( F, startVertex );
6564  }
6565  inEdge->GetEndVertex( endVertex );
6566  if( endVertex.IsNotNULL() )
6567  {
6568  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_VertexPtr( F, endVertex );
6569  }
6570 
6571  fprintf( F, "</Dtk_EdgePtr>" );
6572  return dtkNoError;
6573  }

◆ Dtk_DumpXml_Dtk_EllipsePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_EllipsePtr ( FILE *  F,
const Dtk_EllipsePtr &  inCurve 
)
5326  {
5327  fprintf( F, "<Dtk_EllipsePtr>" );
5328  fprintf( F, "<Center>" );
5329  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inCurve->GetCenterPoint() );
5330  fprintf( F, "</Center>" );
5331  fprintf( F, "<XDir>" );
5332  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inCurve->GetXDirection() );
5333  fprintf( F, "</XDir>" );
5334  fprintf( F, "<YDir>" );
5335  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inCurve->GetYDirection() );
5336  fprintf( F, "</YDir>" );
5337  fprintf( F, "<ZDir>" );
5338  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inCurve->GetZDirection() );
5339  fprintf( F, "</ZDir>" );
5340  fprintf( F, "<MajorRadius>%f</MajorRadius>", inCurve->GetMajorRadius() );
5341  fprintf( F, "<MinorRadius>%f</MinorRadius>", inCurve->GetMinorRadius() );
5342  fprintf( F, "</Dtk_EllipsePtr>" );
5343  return dtkNoError;
5344  }

◆ Dtk_DumpXml_Dtk_EntityPtr()

FILE const Dtk_EntityPtr &inEntity Dtk_ErrorStatus Dtk_DumpXml_Dtk_EntityPtr ( FILE *  inDumpFile,
const Dtk_EntityPtr &  inEntity 
)
5347  {
5348  //if NULL entity => error
5349  if( inEntity.IsNULL() )
5350  {
5351  return dtkErrorNullPointer;
5352  }
5353 
5354  //firstly we test if the entity is a curve
5355  {
5356  Dtk_CurvePtr TmpEnt = Dtk_CurvePtr::DtkDynamicCast( inEntity );
5357  if( TmpEnt.IsNotNULL() )
5358  {
5359  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( inDumpFile, TmpEnt );
5360  }
5361  }
5362  {
5363  Dtk_SurfacePtr TmpEnt = Dtk_SurfacePtr::DtkDynamicCast( inEntity );
5364  if( TmpEnt.IsNotNULL() )
5365  {
5366  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_SurfacePtr( inDumpFile, TmpEnt );
5367  }
5368  }
5369  //We retrieve the entity type...
5370  type_detk type = inEntity->get_type_detk();
5371  switch( type )
5372  {
5373  case DTK_TYPE_BODY:
5374  {
5375  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_BodyPtr( inDumpFile, Dtk_BodyPtr::DtkDynamicCast( inEntity ) );
5376  }
5377 
5378  case DTK_TYPE_LUMP:
5379  {
5380  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LumpPtr( inDumpFile, Dtk_LumpPtr::DtkDynamicCast( inEntity ) );
5381  }
5382 
5383  case DTK_TYPE_VOLUME:
5384  {
5385  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_VolumePtr( inDumpFile, Dtk_VolumePtr::DtkDynamicCast( inEntity ) );
5386  }
5387 
5388  case DTK_TYPE_SHELL:
5389  {
5390  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ShellPtr( inDumpFile, Dtk_ShellPtr::DtkDynamicCast( inEntity ) );
5391  }
5392 
5393  case DTK_TYPE_FACE:
5394  {
5395  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FacePtr( inDumpFile, Dtk_FacePtr::DtkDynamicCast( inEntity ) );
5396  }
5397  case DTK_TYPE_LOOP:
5398  {
5399  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LoopPtr( inDumpFile, Dtk_LoopPtr::DtkDynamicCast( inEntity ) );
5400  }
5401 
5402  case DTK_TYPE_COEDGE:
5403  {
5404  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CoedgePtr( inDumpFile, Dtk_CoedgePtr::DtkDynamicCast( inEntity ) );
5405  }
5406 
5407  case DTK_TYPE_EDGE:
5408  {
5409  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EdgePtr( inDumpFile, Dtk_EdgePtr::DtkDynamicCast( inEntity ) );
5410  }
5411 
5412  case DTK_TYPE_VERTEX:
5413  {
5414  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_VertexPtr( inDumpFile, Dtk_VertexPtr::DtkDynamicCast( inEntity ) );
5415  }
5416  //cases Curves already processed
5417  //cases Surfaces already processed
5418 
5419  case DTK_TYPE_POINT:
5420  {
5421  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_PointPtr( inDumpFile, Dtk_PointPtr::DtkDynamicCast( inEntity ) );
5422  }
5423  case DTK_TYPE_HATCHING:
5424  {
5425  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_HatchingPtr( inDumpFile, Dtk_HatchingPtr::DtkDynamicCast( inEntity ) );
5426  }
5427  case DTK_TYPE_COMPOSITE_ENTITY:
5428  {
5429  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeEntityPtr( inDumpFile, Dtk_CompositeEntityPtr::DtkDynamicCast( inEntity ) );
5430  }
5431  default:
5432  {
5433  //and the type as string
5434  Dtk_string TypeStr = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( typedetkToDtk_string( type ), XMLElement );
5435  fprintf( inDumpFile, "<%s>\n", TypeStr.c_str() );
5436  fprintf( inDumpFile, "dtkErrorNotYetImplemented" );
5437  fprintf( inDumpFile, "</%s>\n", TypeStr.c_str() );
5438  return dtkErrorNotYetImplemented;
5439  }
5440  }
5441  }

◆ Dtk_DumpXml_Dtk_FacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FacePtr ( FILE *  F,
const Dtk_FacePtr &  inFace 
)
6622  {
6623  Dtk_Size_t numLoop, i;
6624  Dtk_SurfacePtr surf;
6625 
6626  fprintf( F, "<Dtk_FacePtr>" );
6627  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inFace->get_info() );
6628  // fprintf(F,"<Id>%d</Id>",inFace->GetID());
6629  surf = inFace->GetGeom();
6630  if( surf.IsNotNULL() )
6631  {
6632  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_SurfacePtr( F, surf );
6633  }
6634  numLoop = inFace->GetNumLoops();
6635  for( i = 0; i < numLoop; i++ )
6636  {
6637  Dtk_LoopPtr loop;
6638  inFace->GetLoop( i, loop );
6639  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LoopPtr( F, loop );
6640 
6641  }
6642  fprintf( F, "</Dtk_FacePtr>" );
6643  return dtkNoError;
6644  }

◆ Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr ( FILE *  F,
const Dtk_FCFFeatureIndicatorPtr &  D 
)
2762  {
2763  fprintf( F, "<Dtk_FCFFeatureIndicatorPtr>\n" );
2764 
2765  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FCFFeatureIndicatorType( F, D->GetFeatureIndicatorType() );
2766 
2767  fprintf( F, "<Symbol>\n" );
2768  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetSymbol() );
2769  fprintf( F, "</Symbol>\n" );
2770 
2771  fprintf( F, "<DatumFeatureIdentifier>\n" );
2772  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetDatumFeatureIdentifier() );
2773  fprintf( F, "</DatumFeatureIdentifier>\n" );
2774 
2775  fprintf( F, "</Dtk_FCFFeatureIndicatorPtr>\n" );
2776  return dtkNoError;
2777  }

◆ Dtk_DumpXml_Dtk_FCFFeatureIndicatorType()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FCFFeatureIndicatorType ( FILE *  F,
const Dtk_FCFFeatureIndicatorType &  D 
)
2745  {
2746  fprintf( F, "<Dtk_FCFFeatureIndicatorType>\n" );
2747 
2748  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Type", Dtk_FCFFeatureIndicatorTypeEnumToString( D.GetIndicatorType() ) );
2749  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, D.GetOuterBoundingBox() );
2750  Dtk_tab< Dtk_CurvePtr > TypeCrvs;
2751  D.CreateGeometries( TypeCrvs );
2752  fprintf( F, "<TypeGeometries Num=\"" XmlFormat( "u" )"\" >\n", TypeCrvs.size() );
2753  for( Dtk_Size_t i = 0; i < TypeCrvs.size(); i++ )
2754  {
2755  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, TypeCrvs[ i ] );
2756  }
2757  fprintf( F, "</TypeGeometries>\n" );
2758  fprintf( F, "</Dtk_FCFFeatureIndicatorType>\n" );
2759  return dtkNoError;
2760  }

◆ Dtk_DumpXml_DTK_FDT_MODIFIER()

Dtk_ErrorStatus Dtk_DumpXml_DTK_FDT_MODIFIER ( FILE *  F,
const DTK_FDT_MODIFIER &  D 
)
2625  {
2626  fprintf( F, "<DTK_FDT_MODIFIER>" );
2627  switch( D )
2628  {
2629  default:
2630  case DTK_FDT_MODIFIER_NOT_SET:
2631  fprintf( F, "DTK_FDT_MODIFIER_NOT_SET" );
2632  break;
2633  case DTK_FDT_MODIFIER_MAX_MATERIAL:
2634  fprintf( F, "DTK_FDT_MODIFIER_MAX_MATERIAL" );
2635  break;
2636  case DTK_FDT_MODIFIER_LEAST_MATERIAL:
2637  fprintf( F, "DTK_FDT_MODIFIER_LEAST_MATERIAL" );
2638  break;
2639  case DTK_FDT_MODIFIER_REGARDLESS_OF_FEATURE_SIZE:
2640  fprintf( F, "DTK_FDT_MODIFIER_REGARDLESS_OF_FEATURE_SIZE" );
2641  break;
2642  case DTK_FDT_MODIFIER_NONE:
2643  fprintf( F, "DTK_FDT_MODIFIER_NONE" );
2644  break;
2645  }
2646  fprintf( F, "</DTK_FDT_MODIFIER>\n" );
2647  return dtkNoError;
2648  }

◆ Dtk_DumpXml_Dtk_FdtPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtPtr ( FILE *  F,
const Dtk_FdtPtr &  D,
const int &  compact 
)
3066  {
3067  fprintf( F, "<Dtk_FdtPtr>\n" );
3068  if( D.IsNotNULL() )
3069  {
3070  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, D->info() );
3071 
3072  if( D->info().IsNotNULL() &&
3073  D->Sub2DEntity() &&
3074  D->Sub2DEntity()->info() )
3075  {
3076  D->Sub2DEntity()->info()->SetBlankedStatus( D->info()->GetBlankedStatus() );
3077  }
3078 
3079 
3080  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, D->TransformationMatrix() );
3081  Dtk_Fdt::ScreenDisplayEnum ScreenDisplayAttribute = D->GetScreenDisplayAttribute();
3082 
3083  if( ScreenDisplayAttribute != Dtk_Fdt::Default )
3084  {
3085  fprintf( F, "<ScreenDisplayAttribute>%s</ScreenDisplayAttribute>\n", Dtk_Fdt::ScreenDisplayEnumToString( ScreenDisplayAttribute ).c_str() );
3086  }
3087  fprintf( F, "<IsZoomable>%s</IsZoomable>\n", D->GetIsZoomableAttribute() == true ? "True" : "False" );
3088 
3089  Dtk_Int32 ColorIdData = -1;
3090  if ( D->GetDisplayBackgroundColorId(ColorIdData) == dtkNoError )
3091  {
3092  fprintf(F, "<DisplayBackgroundColor>\n");
3093  Dtk_RGB rgb;
3094  Dtk_API::GetAPI()->GetColorInTable(ColorIdData, rgb);
3095  Dtk_DumpXml_Dtk_RGB(F, rgb);
3096  fprintf(F, "</DisplayBackgroundColor>\n");
3097  }
3098 
3099  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_2dEntityPtr( F, D->Sub2DEntity(), compact );
3100 
3101  }
3102  else
3103  {
3104  fprintf( F, "Null" );
3105  }
3106  fprintf( F, "</Dtk_FdtPtr>\n" );
3107  return dtkNoError;
3108  }

◆ Dtk_DumpXml_Dtk_FeaturePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FeaturePtr ( FILE *  f,
const Dtk_FeaturePtr &  inToWrite 
)
8445  {
8446  fprintf( f, "<Dtk_FeaturePtr>\n" );
8447  fprintf( f, "<FeatId>%d</FeatId>\n", inToWrite->GetId() );
8448  if( inToWrite->name.len() )
8449  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( f, L"Name", inToWrite->GetName() );
8450  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( f, L"Type", inToWrite->GetTypeAsString() );
8451  fprintf( f, "<IsActive>%d</IsActive>\n", inToWrite->IsActive() );
8452 
8453  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetInputGeometry(), "InputGeometry" );
8454  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetOutputGeometry(), "OutputGeometry" );
8455  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetAssociatedGeometry(), "AssociatedGeometry" );
8456  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetFinalAssociatedGeometry(), "FinalAssociatedGeometry" );
8457 
8458  switch( inToWrite->GetType() )
8459  {
8460  case DTK_FEAT_HOLE:
8461  Dtk_DumpXml_FeatHole( f, inToWrite->GetHole() );
8462  break;
8463  // case DTK_FEAT_HOLE_SERIES :
8464  // Dtk_DumpXml_FeatHoleSeries(f,inToWrite->GetHoleSeries());
8465  // break;
8466  // case DTK_FEAT_UDF :
8467  // Dtk_DumpXml_FeatUDF(f,inToWrite->GetUdf());
8468  // break;
8469  case DTK_FEAT_THREAD:
8470  Dtk_DumpXml_FeatThread( f, inToWrite->GetThread() );
8471  break;
8472  // case DTK_FEAT_PRISM :
8473  // Dtk_DumpXml_FeatPrism(f, inToWrite->GetPrism());
8474  // break;
8475  // case DTK_FEAT_REVOL :
8476  // Dtk_DumpXml_FeatRevol (f, inToWrite->GetRevol());
8477  // break;
8478  // case DTK_FEAT_SHELL:
8479  // Dtk_DumpXml_FeatShell (f, inToWrite->GetRevol());
8480  // break;
8481  // case DTK_FEAT_FILLET:
8482  // Dtk_DumpXml_FeatFillet (f, inToWrite->GetRevol());
8483  // break;
8484  // case DTK_FEAT_SWEEP:
8485  // Dtk_DumpXml_FeatSweep (f, inToWrite->GetRevol());
8486  // break;
8487  // case DTK_FEAT_CHAMFER:
8488  // Dtk_DumpXml_FeatChamfer (f, inToWrite->GetRevol());
8489  // break;
8490  // case DTK_FEAT_SPLIT_SURF:
8491  // Dtk_DumpXml_FeatSplitSurf (f, inToWrite->GetRevol());
8492  // break;
8493  // case DTK_FEAT_THICK_SURF:
8494  // Dtk_DumpXml_FeatThickSurf (f, inToWrite->GetRevol());
8495  // break;
8496  // case DTK_FEAT_SEW_SURF:
8497  // Dtk_DumpXml_FeatSewSurf (f, inToWrite->GetRevol());
8498  // break;
8499  // case DTK_FEAT_CLOSE_SURF:
8500  // Dtk_DumpXml_FeatCloseSurf(f, inToWrite->GetRevol());
8501  // break;
8502  case DTK_FEAT_PATTERN:
8503  Dtk_DumpXml_FeatPattern( f, inToWrite->GetPattern() );
8504  break;
8505  // case DTK_FEAT_USER_PATTERN:
8506  // Dtk_DumpXml_FeatUserPattern (f, inToWrite->GetRevol());
8507  // break;
8508  // case DTK_FEAT_MIRROR:
8509  // Dtk_DumpXml_FeatMirror(f, inToWrite->GetRevol());
8510  // break;
8511  // case DTK_FEAT_DRAFT :
8512  // Dtk_DumpXml_FeatDraft(f, inToWrite->GetRevol());
8513  // break;
8514  // case DTK_FEAT_TRANSLATE:
8515  // break;
8516  // case DTK_FEAT_ROTATE:
8517  // break;
8518  // case DTK_FEAT_REMOVE_FACE :
8519  // break;
8520  // case DTK_FEAT_STIFFENER:
8521  // break;
8522  // case DTK_FEAT_FACE_FILLET:
8523  // break;
8524  // case DTK_FEAT_TRITANGENT_FILLET:
8525  // break;
8526  // case DTK_FEAT_MULTI_PAD:
8527  // break;
8528  // case DTK_FEAT_MULTI_POCKET:
8529  // break;
8530  // case DTK_FEAT_LOFT:
8531  // break;
8532  // case DTK_FEAT_THICKNESS:
8533  // break;
8534  // case DTK_FEAT_SCALING:
8535  // break;
8536  // case DTK_FEAT_USER_DEFINED:
8537  // Dtk_DumpXml_FeatUserDefined (f, inToWrite->GetUserDefined());
8538  // break;
8539  // case DTK_FEAT_PIPE:
8540  // Dtk_DumpXml_FeatPipe (f, inToWrite->GetPipe());
8541  // break;
8542  // case DTK_FEAT_SPOT_POINT:
8543  // Dtk_DumpXml_FeatSpotPoint(f, inToWrite->GetSpotPoint());
8544  // break;
8545 
8546  default:
8547  break;
8548  }
8549  fprintf( f, "</Dtk_FeaturePtr>\n" );
8550  return dtkNoError;
8551  }

◆ Dtk_DumpXml_Dtk_FilletSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FilletSurfacePtr ( FILE *  F,
const Dtk_FilletSurfacePtr &  inSurf 
)
6369  {
6370  fprintf( F, "<Dtk_FilletSurfacePtr>" );
6371  fprintf( F, "<SpineCurve>" );
6372  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, inSurf->GetSpineCurve() );
6373  fprintf( F, "</SpineCurve>" );
6374 
6375  fprintf( F, "<AdjacentCurves>" );
6376  for( Dtk_Size_t i = 0; i < inSurf->GetNumAdjacentCurves(); ++i )
6377  {
6378  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, inSurf->GetAdjacentCurve( i ) );
6379  }
6380  fprintf( F, "</AdjacentCurves>" );
6381 
6382  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NurbsSurfacePtr( F, Dtk_NurbsSurfacePtr::DtkDynamicCast( inSurf->ToNurbs() ) );
6383 
6384  fprintf( F, "</Dtk_FilletSurfacePtr>" );
6385  return dtkNoError;
6386  }

◆ Dtk_DumpXml_Dtk_Font()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Font ( FILE *  F,
const Dtk_Font &  T 
)
932  {
933  Dtk_string str = T.Name();
934  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"font_name", str );
935  return dtkNoError;
936  }

◆ Dtk_DumpXml_Dtk_FontLineTypeEnum()

void Dtk_DumpXml_Dtk_FontLineTypeEnum ( FILE *  F,
const Dtk_FontLineType &  inEnum,
const Dtk_string &  inPropertyName 
)
2352  {
2353  const Dtk_string EnumToStr = Dtk_ConvertFontLineTypeEnumToString( inEnum );
2354  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
2355  }

◆ Dtk_DumpXml_Dtk_Frame()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Frame ( FILE *  F,
const Dtk_Frame &  T 
)
1201  {
1202  fprintf( F, "<Dtk_Frame>\n" );
1203  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_frame_type( F, T.GetFrameType(), L"FrameType" );
1204  fprintf( F, "<Associated_Geometries>\n" );
1205  Dtk_tab< Dtk_CurvePtr > AssocGeoms;
1206  T.CreateGeometries( AssocGeoms );
1207  Dtk_Size_t i, NumGeoms = AssocGeoms.size();
1208  for( i = 0; i < NumGeoms; i++ )
1209  {
1210  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, AssocGeoms[ i ] );
1211  }
1212  fprintf( F, "</Associated_Geometries>\n" );
1213 
1214  fprintf( F, "</Dtk_Frame>\n" );
1215  return dtkNoError;
1216  }

◆ Dtk_DumpXml_Dtk_frame_type()

void Dtk_DumpXml_Dtk_frame_type ( FILE *  F,
const Dtk_frame_type &  inEnum,
const Dtk_string &  inPropertyName 
)
1148  {
1149  Dtk_string EnumToStr = L"Unknown";
1150 
1151  switch( inEnum )
1152  {
1153  case DTK_FRAME_TYPE_NONE: EnumToStr = L"DTK_FRAME_TYPE_NONE"; break;
1154  case DTK_FRAME_TYPE_RECTANGLE: EnumToStr = L"DTK_FRAME_TYPE_RECTANGLE"; break;
1155  case DTK_FRAME_TYPE_SQUARE: EnumToStr = L"DTK_FRAME_TYPE_SQUARE"; break;
1156  case DTK_FRAME_TYPE_CIRCLE: EnumToStr = L"DTK_FRAME_TYPE_CIRCLE"; break;
1157  case DTK_FRAME_TYPE_SCORED_CIRCLE: EnumToStr = L"DTK_FRAME_TYPE_SCORED_CIRCLE"; break;
1158  case DTK_FRAME_TYPE_DIAMOND: EnumToStr = L"DTK_FRAME_TYPE_DIAMOND"; break;
1159  case DTK_FRAME_TYPE_TRIANGLE: EnumToStr = L"DTK_FRAME_TYPE_TRIANGLE"; break;
1160  case DTK_FRAME_TYPE_FLAG_RIGHT: EnumToStr = L"DTK_FRAME_TYPE_FLAG_RIGHT"; break;
1161  case DTK_FRAME_TYPE_FLAG_LEFT: EnumToStr = L"DTK_FRAME_TYPE_FLAG_LEFT"; break;
1162  case DTK_FRAME_TYPE_FLAG_BOTH: EnumToStr = L"DTK_FRAME_TYPE_FLAG_BOTH"; break;
1163  case DTK_FRAME_TYPE_OBLONG: EnumToStr = L"DTK_FRAME_TYPE_OBLONG"; break;
1164  case DTK_FRAME_TYPE_OBLONG_RIGHT: EnumToStr = L"DTK_FRAME_TYPE_OBLONG_RIGHT"; break;
1165  case DTK_FRAME_TYPE_OBLONG_LEFT: EnumToStr = L"DTK_FRAME_TYPE_OBLONG_LEFT"; break;
1166  case DTK_FRAME_TYPE_ELLIPSE: EnumToStr = L"DTK_FRAME_TYPE_ELLIPSE"; break;
1167  case DTK_FRAME_TYPE_STICKING: EnumToStr = L"DTK_FRAME_TYPE_STICKING"; break;
1168  case DTK_FRAME_TYPE_SET: EnumToStr = L"DTK_FRAME_TYPE_SET"; break;
1169  case DTK_FRAME_TYPE_FIXED_SUPPORT: EnumToStr = L"DTK_FRAME_TYPE_FIXED_SUPPORT"; break;
1170  case DTK_FRAME_TYPE_NOTA: EnumToStr = L"DTK_FRAME_TYPE_NOTA"; break;
1171  case DTK_FRAME_TYPE_SYMMETRICAL_PART: EnumToStr = L"DTK_FRAME_TYPE_SYMMETRICAL_PART"; break;
1172  case DTK_FRAME_TYPE_SYMMETRICAL_SET: EnumToStr = L"DTK_FRAME_TYPE_SYMMETRICAL_SET"; break;
1173  case DTK_FRAME_TYPE_SCORED_RECTANGLE: EnumToStr = L"DTK_FRAME_TYPE_SCORED_RECTANGLE"; break;
1174  case DTK_FRAME_TYPE_PARALLELOGRAM: EnumToStr = L"DTK_FRAME_TYPE_PARALLELOGRAM"; break;
1175  case DTK_FRAME_TYPE_OCTANGLE: EnumToStr = L"DTK_FRAME_TYPE_OCTANGLE"; break;
1176  default: break;
1177  }
1178  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
1179  }

◆ Dtk_DumpXml_Dtk_GeometricalTolerancePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_GeometricalTolerancePtr ( FILE *  F,
const Dtk_GeometricalTolerancePtr &  D 
)
2551  {
2552  fprintf( F, "<Dtk_GeometricalTolerancePtr>\n" );
2553  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_AnnotationPtr( F, Dtk_AnnotationPtr::DtkDynamicCast( D ) ); // upcasting
2554 
2555  Dtk_Size_t i, TolSpecContNb;
2556  TolSpecContNb = D->GetToleranceSpecificationContainerNb();
2557  fprintf( F, "<TolSpecConts TolSpecContNb = \"" XmlFormat( "u" )"\">\n", TolSpecContNb );
2558  for( i = 0; i < TolSpecContNb; i++ )
2559  {
2560  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr( F, D->at( i ) );
2561  }
2562  fprintf( F, "</TolSpecConts>\n" );
2563  fprintf( F, "</Dtk_GeometricalTolerancePtr>\n" );
2564  return dtkNoError;
2565  }

◆ Dtk_DumpXml_Dtk_GraphicalDataPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_GraphicalDataPtr ( FILE *  F,
const Dtk_GraphicalDataPtr &  inGraphicalData 
)
8648  {
8649  if( inGraphicalData.IsNULL() )
8650  return dtkErrorNullPointer;
8651  int nbt = 0;
8652  int i, nb = ( int )inGraphicalData->GetNumMeshes();
8653  for( i = 0; i < nb; i++ )
8654  {
8655  Dtk_MeshPtr me = inGraphicalData->GetMesh( i );
8656  Dtk_DumpXml_Dtk_MeshPtr( F, me );
8657  }
8658  nbt = nb;
8659  nb = ( int )inGraphicalData->GetNumDrawings();
8660  nbt += nb;
8661  for( i = 0; i < nb; i++ )
8662  {
8663  Dtk_DrawingPtr dr = inGraphicalData->GetDrawing( i );
8664  Dtk_DumpXml_Dtk_DrawingPtr( F, dr );
8665  }
8666  Dtk_CameraPtr defcam = inGraphicalData->GetDefaultCamera();
8667  if( defcam.IsNotNULL() )
8668  {
8669  Dtk_DumpXml_Dtk_CameraPtr( F, defcam );
8670  }
8671  if( nbt == 0 )
8672  return dtkWarningNoEntitiesWritten;
8673  else
8674  return dtkNoError;
8675  }

◆ Dtk_DumpXml_Dtk_Grid_OriginReferenceOptionEnum()

void Dtk_DumpXml_Dtk_Grid_OriginReferenceOptionEnum ( FILE *  F,
const Dtk_Grid::OriginReferenceOption &  inEnum,
const Dtk_string &  inPropertyName 
)
2378  {
2379  Dtk_string EnumToStr;
2380  switch( inEnum )
2381  {
2382  default:
2383  case Dtk_Grid::Absolute: EnumToStr = L"Absolute"; break;
2384  case Dtk_Grid::WCS: EnumToStr = L"WCS"; break;
2385  case Dtk_Grid::Local: EnumToStr = L"Local"; break;
2386  }
2387 
2388  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
2389  }

◆ Dtk_DumpXml_Dtk_Grid_ShowLabelOptionEnum()

void Dtk_DumpXml_Dtk_Grid_ShowLabelOptionEnum ( FILE *  F,
const Dtk_Grid::ShowLabelOption &  inEnum,
const Dtk_string &  inPropertyName 
)
2361  {
2362  Dtk_string EnumToStr;
2363  switch( inEnum )
2364  {
2365  default:
2366  case Dtk_Grid::None: EnumToStr = L"None"; break;
2367  case Dtk_Grid::ParallelToView: EnumToStr = L"ParallelToView"; break;
2368  case Dtk_Grid::Always: EnumToStr = L"Always"; break;
2369  }
2370 
2371  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
2372  }

◆ Dtk_DumpXml_Dtk_GridPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_GridPtr ( FILE *  F,
const Dtk_GridPtr &  D 
)
2393  {
2394  Dtk_string majorStyle, minorStyle;
2395  fprintf( F, "<Dtk_Grid>\n" );
2396 
2397  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_AnnotationPtr( F, Dtk_AnnotationPtr::DtkDynamicCast( D ) ); // upcasting
2398  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, D->GetBoundingBox() );
2399  fprintf( F, "<uSpacing>%f</uSpacing>\n", D->GetUSpacing() );
2400  fprintf( F, "<vSpacing>%f</vSpacing>\n", D->GetVSpacing() );
2401  fprintf( F, "<uMinorPerMajor>%d</uMinorPerMajor>\n", D->GetUMinorPerMajor() );
2402  fprintf( F, "<vMinorPerMajor>%d</vMinorPerMajor>\n", D->GetVMinorPerMajor() );
2403  Dtk_DumpXml_Dtk_FontLineTypeEnum( F, D->GetMajorLineStyle(), "majorLineStyle" );
2404  Dtk_DumpXml_Dtk_FontLineTypeEnum( F, D->GetMinorLineStyle(), "minorLineStyle" );
2405  fprintf( F, "<majorLineWidth>%f</majorLineWidth>\n", D->GetMajorLineWidth() );
2406  fprintf( F, "<minorLineWidth>%f</minorLineWidth>\n", D->GetMinorLineWidth() );
2407  fprintf( F, "<displayGridOption>%d</displayGridOption>\n", D->GetDisplayGridOption() );
2408  fprintf( F, "<displayOnTopOption>%d</displayOnTopOption>\n", D->GetDisplayOnTopOption() );
2409  fprintf( F, "<displayMajorLinesOption>%d</displayMajorLinesOption>\n", D->GetDisplayMajorLinesOption() );
2410  Dtk_DumpXml_Dtk_Grid_ShowLabelOptionEnum( F, D->GetDisplayShowLabelOption(), "displayShowLabelOption" );
2411  Dtk_DumpXml_Dtk_Grid_OriginReferenceOptionEnum( F, D->GetDisplayOriginReferenceOption(), "displayOriginReferenceOption" );
2412 
2413  fprintf( F, "</Dtk_Grid>\n" );
2414  return dtkNoError;
2415  }

◆ Dtk_DumpXml_Dtk_HatchingPattern()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_HatchingPattern ( FILE *  F,
const Dtk_HatchingPattern &  D 
)
2180  {
2181  fprintf( F, "<Dtk_HatchingPattern>\n" );
2182  Dtk_HatchingStyle HatchingStyle = D.HatchingStyle();
2183  Dtk_DumpXml_Dtk_HatchingStyleEnum( F, HatchingStyle, L"HatchingStyle" );
2184  fprintf( F, "<Offset>%lf</Offset>\n", D.Offset() );
2185  fprintf( F, "<Pitch>%lf</Pitch>\n", D.Pitch() );
2186  fprintf( F, "<Angle>%lf</Angle>\n", D.Angle() );
2187  fprintf( F, "<LineWidth>%lf</LineWidth>\n", D.LineWidth() );
2188  fprintf( F, "<LineType>%d</LineType>\n", D.LineType() );
2189  fprintf( F, "<Color>" );
2190  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RGB( F, D.Color() );
2191  fprintf( F, "</Color>\n" );
2192  fprintf( F, "</Dtk_HatchingPattern>\n" );
2193  return dtkNoError;
2194  }

◆ Dtk_DumpXml_Dtk_HatchingPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_HatchingPtr ( FILE *  F,
const Dtk_HatchingPtr &  D 
)
2197  {
2198  fprintf( F, "<Dtk_HatchingPtr>\n" );
2199  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EntityPtr(F,Dtk_EntityPtr::DtkDynamicCast(D)); // upcasting
2200 
2201  // Historical function for boundaries
2202  {
2203  const Dtk_tab<Dtk_PolylinePtr>& Boundaries = D->Boundaries();
2204  fprintf( F, "<Boundaries Num=\'" XmlFormat( "d" )"\'>\n", Boundaries.size() );
2205  for( Dtk_Size_t i = 0; i < Boundaries.size(); i++ )
2206  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_PolylinePtr( F, Boundaries[ i ] );
2207  fprintf( F, "</Boundaries>\n" );
2208  }
2209 
2210  // New function for boundaries
2211  const auto& dtkBoundaries = D->GetBoundaries();
2212  if( !dtkBoundaries.empty() )
2213  {
2214  fprintf( F, "<DtkBoundaries Num=\'" XmlFormat( "d" )"\'>\n", dtkBoundaries.size() );
2215  for( auto it_boundary = dtkBoundaries.cbegin(); it_boundary != dtkBoundaries.cend(); ++it_boundary )
2216  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_BoundaryPtr( F, *it_boundary );
2217  fprintf( F, "</DtkBoundaries>\n" );
2218  }
2219 
2220  Dtk_tab<Dtk_HatchingPattern> Patterns = D->Patterns();
2221  fprintf( F, "<Patterns Num=\'" XmlFormat( "d" )"\'>\n", Patterns.size() );
2222  for( Dtk_Size_t i = 0; i < Patterns.size(); i++ )
2223  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_HatchingPattern( F, Patterns[ i ] );
2224  fprintf( F, "</Patterns>\n" );
2225 
2226  fprintf( F, "</Dtk_HatchingPtr>\n" );
2227  return dtkNoError;
2228  }

◆ Dtk_DumpXml_Dtk_HatchingStyleEnum()

void Dtk_DumpXml_Dtk_HatchingStyleEnum ( FILE *  F,
const Dtk_HatchingStyle &  inEnum,
const Dtk_string &  inPropertyName 
)
2165  {
2166  Dtk_string EnumToStr;
2167  switch( inEnum )
2168  {
2169  default:
2170  case Dtk_HatchingStyle_Unknown: EnumToStr = L"Dtk_HatchingStyle_Unknown"; break;
2171  case Dtk_HatchingStyle_Hatching: EnumToStr = L"Dtk_HatchingStyle_Hatching"; break;
2172  case Dtk_HatchingStyle_Coloring: EnumToStr = L"Dtk_HatchingStyle_Coloring"; break;
2173  case Dtk_HatchingStyle_Dotting: EnumToStr = L"Dtk_HatchingStyle_Dotting"; break;
2174  }
2175 
2176  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
2177  }

◆ Dtk_DumpXml_Dtk_HyperbolaPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_HyperbolaPtr ( FILE *  F,
const Dtk_HyperbolaPtr &  inCurve 
)
5283  {
5284  fprintf( F, "<Dtk_HyperbolaPtr>" );
5285  fprintf( F, "<Center>" );
5286  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inCurve->GetCenterPoint() );
5287  fprintf( F, "</Center>" );
5288  fprintf( F, "<XDir>" );
5289  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inCurve->GetXDirection() );
5290  fprintf( F, "</XDir>" );
5291  fprintf( F, "<YDir>" );
5292  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inCurve->GetYDirection() );
5293  fprintf( F, "</YDir>" );
5294  fprintf( F, "<ZDir>" );
5295  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inCurve->GetZDirection() );
5296  fprintf( F, "</ZDir>" );
5297  fprintf( F, "<SemiAxis>%f</SemiAxis>", inCurve->GetSemiAxis() );
5298  fprintf( F, "<SemiImageAxis>%f</SemiImageAxis>", inCurve->GetSemiImageAxis() );
5299  fprintf( F, "</Dtk_HyperbolaPtr>" );
5300  return dtkNoError;
5301  }

◆ Dtk_DumpXml_Dtk_info()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_info ( FILE *  F,
const Dtk_InfoPtr &  I 
) 
                else if( lst[ i ] == "Dtk_CurveThickNess" )
                {

int index = I->GetColorId(); fprintf( F, "<Dtk_CurveThickNess>\n<int>%d</int>\n</Dtk_CurveThickNess>\n", I->GetCurveThickNess() ); } /*

4122  {
4123  Dtk_status st;
4124  Dtk_MaterialPtr material = NULL;
4125 
4126  if( I.IsNULL() )
4127  return dtkNoError;
4128 
4129  Dtk_tab<Dtk_string> lst;
4130  I->ListAllAttributes( lst );
4131  Dtk_Size_t i;
4132  const Dtk_Size_t size = lst.size();
4133  {
4134  fprintf( F, "<Dtk_Info>\n" );
4135 
4136  fprintf( F, "<Dtk_ID>%i</Dtk_ID>\n", I->GetId() );
4137 
4138 #if 0 // dump Referenceset : (UG & JT)
4139  Dtk_tab<Dtk_string> array;
4140  I->GetReferenceSet( array, DTK_TRUE );
4141  if( array.size() > 0 )
4142  {
4143  fprintf(F, "<GetReferenceSet>\n");
4144  fprintf(F, "<size>%i</size>\n", array.size());
4145 
4146  for ( i = 0; i < array.size(); i++ )
4147  {
4148  fprintf(F, "%ls,", array[i].w_str());
4149  }
4150  fprintf(F, "</GetReferenceSet>\n");
4151  }
4152 #endif
4153  Dtk_tab<Dtk_MetaDataPtr> array_metadata;
4154  I->GetMetaData(array_metadata);
4155  Dtk_Size_t NumMetaData;
4156  NumMetaData = array_metadata.size();
4157  if ( NumMetaData )
4158  {
4159  fprintf(F, "<Dtk_MetaData Num=\'" XmlFormat("u") "\'>\n", NumMetaData);
4160  for ( i = 0; i < NumMetaData; i++ )
4161  {
4162  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr(F, array_metadata.at(i));
4163  }
4164  fprintf(F, "</Dtk_MetaData>\n");
4165  }
4166 
4167  for( i = 0; i < size; i++ )
4168  {
4169  Dtk_Val v;
4170  if( lst[ i ] == "Dtk_Render" )
4171  {
4172  //int index = I->GetColorId();
4173  Dtk_RenderInfosPtr color = I->GetRenderInfos();
4174  //shader type
4175  Dtk_RenderInfos::RenderMappingShaderTypeEnum shadertype = Dtk_RenderInfos::Unknown;
4176  shadertype = color->GetShaderType();
4177  //
4178  const Dtk_string colorName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( color->GetName() );
4179  if( color->GetLightMap().IsNotNULL() )
4180  {
4181  if( shadertype != Dtk_RenderInfos::Unknown )
4182  {
4183  Dtk_RGB ambient = color->GetLightMap()->GetAmbientColor();
4184  fprintf( F, "<Dtk_Render><id>%d</id><name>%s</name><shadertype>%d</shadertype><ambientR>%d</ambientR><ambientG>%d</ambientG><ambientB>%d</ambientB><ambientA>%d</ambientA></Dtk_Render>\n",
4185  I->GetRenderInfosId(), colorName.c_str(), shadertype, ambient[ 0 ], ambient[ 1 ], ambient[ 2 ], ambient[ 3 ] );
4186 
4187  }
4188  else
4189  {
4190  Dtk_RGB ambient = color->GetLightMap()->GetAmbientColor();
4191  fprintf( F, "<Dtk_Render><id>%d</id><name>%s</name><ambientR>%d</ambientR><ambientG>%d</ambientG><ambientB>%d</ambientB><ambientA>%d</ambientA></Dtk_Render>\n",
4192  I->GetRenderInfosId(), colorName.c_str(), ambient[ 0 ], ambient[ 1 ], ambient[ 2 ], ambient[ 3 ] );
4193  }
4194  }
4195  else
4196  {
4197  if( shadertype != Dtk_RenderInfos::Unknown )
4198  {
4199  fprintf( F, "<Dtk_Render><id>%d</id><name>%s</name><shadertype>%d</shadertype></Dtk_Render>\n",
4200  I->GetRenderInfosId(), colorName.c_str(), shadertype ); // render sans lightmap (texture possible)
4201  }
4202  else
4203  {
4204  fprintf( F, "<Dtk_Render><id>%d</id><name>%s</name></Dtk_Render>\n",
4205  I->GetRenderInfosId(), colorName.c_str() ); // render sans lightmap (texture possible)
4206  }
4207  }
4208  }
4209  else if( lst[ i ] == "Dtk_ColorId" )
4210  {
4211  //int index = I->GetColorId();
4212  Dtk_RGB color = I->GetColor();
4213  fprintf( F, "<Dtk_Color><r>%d</r><g>%d</g><b>%d</b><a>%d</a>", color[ 0 ], color[ 1 ], color[ 2 ], color[ 3 ] );
4214  if( color.IndexReader() >= 0 )
4215  {
4216  fprintf( F, "<IndexReader>%d</IndexReader>", color.IndexReader() );
4217  }
4218  fprintf( F, "</Dtk_Color>\n" );
4219 
4220 
4221 
4222  }
4223  else if( lst[ i ] == "Dtk_CurveThickNessInMM" )
4224  {
4225  double bval = I->GetCurveThickNessInMM();
4226  fprintf( F, "<Dtk_CurveThickNessInMM><double>%f</double></Dtk_CurveThickNessInMM>\n", bval );
4227  }
4228  /**
4229  else if( lst[ i ] == "Dtk_CurveThickNess" )
4230  {
4231  //int index = I->GetColorId();
4232  fprintf( F, "<Dtk_CurveThickNess>\n<int>%d</int>\n</Dtk_CurveThickNess>\n", I->GetCurveThickNess() );
4233  }
4234  /**/
4235  else if( lst[ i ] == "Dtk_Uuid" )
4236  {
4237  Dtk_UUID uuid;
4238  uuid = I->GetUuid();
4239  fprintf(F, "<Dtk_uuid>\n");
4240 
4241 
4242  char data0[33];
4243  std::snprintf(data0, sizeof(data0), "%X%X%X%X", uuid[0], uuid[1], uuid[2], uuid[3]);
4244  char data[39];
4245  int cpt = 0;
4246  for ( size_t j = 0; j < 16; j++ )
4247  {
4248  data[cpt] = data0[2 * j]; cpt++;
4249  data[cpt] = data0[2 * j + 1]; cpt++;
4250  if ( cpt == 8 || cpt == 13 || cpt == 18 || cpt == 23 )
4251  {
4252  data[cpt] = '-'; cpt++;
4253  }
4254  }
4255  data[cpt] = '\0';
4256  Dtk_string string(data);
4257  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val(F, string);
4258 
4259  for ( Dtk_Size_t j = 0; j < 4; j++ )
4260  {
4261 
4262  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val(F, uuid[j]);
4263  }
4264  fprintf(F, "</Dtk_uuid>\n");
4265  }
4266  else if( lst[ i ] == "Dtk_CurveLineTypeDefinition" )
4267  {
4268  bool couldNotSpecialDump = true;
4269 
4270  const Dtk_ID curveLineDefinitionId = I->GetCurveLineTypeDefinitionId();
4271  const Dtk_API *const dtkAPI = Dtk_API::GetAPI();
4272  if( dtkAPI )
4273  {
4274  const Dtk_LineTypeDefinitionPtr &lineTypeDefinition = dtkAPI->GetCurveLineTypeDefinitionInTable( curveLineDefinitionId );
4275  if( lineTypeDefinition.IsNotNULL() )
4276  {
4277  const Dtk_string name = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lineTypeDefinition->GetName(), XMLGenericString );
4278  const Dtk_string dtkFontLineTypeEnum = Dtk_ConvertFontLineTypeEnumToString( lineTypeDefinition->GetClosestAppearanceInFontLineTypeEnumeration() );
4279  const Dtk_Size_t nbPatterns = lineTypeDefinition->GetPatternLength();
4280 
4281  const bool isNameNull = name.is_NULL();
4282 
4283  const Dtk_string xmlTitle = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lst[ i ], XMLElement );
4284  const Dtk_string printFDef = "<int>%d (=> Name: " +
4285  Dtk_string( isNameNull ? "(null)" : "&quot;%s&quot;" ) +
4286  " - ClosestDtk_FontLineType: &quot;%s&quot; - PatternLength: " XmlFormat( "u" ) ")</int> \n";
4287 
4288  fprintf( F, "<%s>\n", xmlTitle.c_str() );
4289  if( isNameNull )
4290  {
4291  fprintf( F,
4292  printFDef.c_str(),
4293  curveLineDefinitionId,
4294  dtkFontLineTypeEnum.c_str(),
4295  nbPatterns );
4296  }
4297  else
4298  {
4299  fprintf( F,
4300  printFDef.c_str(),
4301  curveLineDefinitionId,
4302  name.c_str(),
4303  dtkFontLineTypeEnum.c_str(),
4304  nbPatterns );
4305  }
4306  fprintf( F, "</%s>\n", xmlTitle.c_str() );
4307 
4308  couldNotSpecialDump = false;
4309  }
4310  }
4311 
4312  // If could not dump correctly, use usual dump (Should not happen).
4313  if( couldNotSpecialDump )
4314  {
4315  I->FindAttribute( lst[ i ], v );
4316  Dtk_string title = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lst[ i ], XMLElement );
4317 
4318  fprintf( F, "<%s>\n", title.c_str() );
4319  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, v );
4320  fprintf( F, "</%s>\n", title.c_str() );
4321  }
4322  }
4323  else
4324  {
4325  I->FindAttribute( lst[ i ], v );
4326  Dtk_string title = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lst[ i ], XMLElement );
4327 
4328  fprintf( F, "<%s>\n", title.c_str() );
4329  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, v );
4330  fprintf( F, "</%s>\n", title.c_str() );
4331  }
4332  }
4333 
4334  //Usefull if you want to handle NX referenceSet
4335  /*
4336  Dtk_tab <Dtk_string> refset;
4337  I->GetReferenceSet(refset,DTK_TRUE);
4338  for (i = 0; i < refset.size(); i++)
4339  fprintf(F, "<Dtk_ReferenceSet_%u>%S</Dtk_ReferenceSet_%u>\n", i, refset[i].w_str(), i);
4340  */
4341 
4342  fprintf( F, "</Dtk_Info>\n" );
4343  }
4344 
4345  return dtkNoError;
4346  }

◆ Dtk_DumpXml_Dtk_KinematicsCommand()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCommand ( FILE *  inFile,
const Dtk_KinCommandPtr &  inCommand,
Dtk_bool  simplified 
)
7685  {
7686  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7687  if( inFile == NULL )
7688  return dtkErrorNullPointer;
7689 
7690  fprintf( inFile, "<command name=\"%s\" id=\"%d\">\n", inCommand->getName().c_str(), inCommand->getId() );
7691  if( simplified == DTK_FALSE )
7692  {
7693  fprintf( inFile, "<attributCommand type=\"%d\" value=\"%f\"/>\n", inCommand->getType(), inCommand->getValue() );
7694  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, inCommand->getJoint(), DTK_TRUE );
7695  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inCommand->getParameter() );
7696  }
7697  fprintf( inFile, "</command>\n" );
7698 
7699  return dtkErrorStatus;
7700  }

◆ Dtk_DumpXml_Dtk_KinematicsConstraint()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsConstraint ( FILE *  inFile,
const Dtk_KinConstraintPtr &  inConstraint,
Dtk_bool  simplified 
)
7477  {
7478  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7479  if( inFile == NULL )
7480  return dtkErrorNullPointer;
7481 
7482  Dtk_Size_t i, nbVal;
7483 
7484  const Dtk_string inConstraintName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inConstraint->getName() );
7485  fprintf( inFile, "<constraint name=\"%s\" id=\"%d\">\n", inConstraintName.c_str(), inConstraint->getId() );
7486  if( simplified == DTK_FALSE )
7487  {
7488  if( inConstraint->hasAttribute( inConstraint->_MODE_INTEGER ) ||
7489  inConstraint->hasAttribute( inConstraint->_VALUE ) ||
7490  inConstraint->hasAttribute( inConstraint->_ORIENTATION ) ||
7491  inConstraint->hasAttribute( inConstraint->_REFERENCE ) ||
7492  inConstraint->hasAttribute( inConstraint->_POSITION ) )
7493  {
7494  fprintf( inFile, "<attributConstraint" );
7495  if( inConstraint->hasAttribute( inConstraint->_MODE_INTEGER ) )
7496  {
7497  fprintf( inFile, " modeInteger=\"%d\"", inConstraint->getModeInteger() );
7498  }
7499  if( inConstraint->hasAttribute( inConstraint->_VALUE ) )
7500  {
7501  fprintf( inFile, " value=\"%f\"", inConstraint->getValue()->getNamedValue()->getValue() );
7502  }
7503  if( inConstraint->hasAttribute( inConstraint->_ORIENTATION ) )
7504  {
7505  fprintf( inFile, " orientation=\"%f\"", inConstraint->getOrientation()->getNamedValue()->getValue() );
7506  }
7507  if( inConstraint->hasAttribute( inConstraint->_REFERENCE ) )
7508  {
7509  fprintf( inFile, " fixInSpace=\"%.0f\"", inConstraint->getReference()->getNamedValue()->getValue() );
7510  }
7511  fprintf( inFile, ">\n" );
7512  if( inConstraint->hasAttribute( inConstraint->_POSITION ) )
7513  {
7514  fprintf( inFile, "<matricePosition nbValue=\"12\"" );
7515  DumpTransfo( inFile, inConstraint->getPosition() );
7516  fprintf( inFile, "/>\n" );
7517  }
7518  fprintf( inFile, "</attributConstraint>\n" );
7519  }
7520  nbVal = inConstraint->getConnectorSize();
7521  if( nbVal > 0 )
7522  {
7523  fprintf( inFile, "<connectors>\n" );
7524  for( i = 0; i < nbVal; i++ )
7525  {
7526  Dtk_DumpXml_Dtk_NodeConnector( inFile, inConstraint->getConnector( i ) );
7527  }
7528  fprintf( inFile, "</connectors>\n" );
7529  }
7530  }
7531  fprintf( inFile, "</constraint>\n" );
7532 
7533  return dtkErrorStatus;
7534  }

◆ Dtk_DumpXml_Dtk_KinematicsCurve()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCurve ( FILE *  inFile,
const Dtk_KinCurvePtr &  inCurve 
)
7418  {
7419  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7420  if( inFile == NULL )
7421  return dtkErrorNullPointer;
7422 
7423  fprintf( inFile, "<curve fileName=\"%s\" idBlock=\"%d\"/>\n", inCurve->getFileName().c_str(), inCurve->getIdBlock() );
7424 
7425  return dtkErrorStatus;
7426  }

◆ Dtk_DumpXml_Dtk_KinematicsFixPart()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFixPart ( FILE *  inFile,
const Dtk_KinFixPartPtr &  inFixPart 
)
7703  {
7704  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7705  if( inFile == NULL )
7706  return dtkErrorNullPointer;
7707 
7708  fprintf( inFile, "<fixPart name=\"%s\" id=\"%d\">\n", inFixPart->getName().c_str(), inFixPart->getId() );
7709  if( inFixPart->getConstraint().IsNotNULL() )
7710  {
7711  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, inFixPart->getConstraint(), DTK_TRUE );
7712  }
7713  if( inFixPart->getPart().IsNotNULL() )
7714  {
7715  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inFixPart->getPart() );
7716  }
7717  fprintf( inFile, "</fixPart>\n" );
7718 
7719  return dtkErrorStatus;
7720  }

◆ Dtk_DumpXml_Dtk_KinematicsFormula()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFormula ( FILE *  inFile,
const Dtk_KinFormulaPtr &  inFormula 
)
7429  {
7430  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7431  if( inFile == NULL )
7432  return dtkErrorNullPointer;
7433 
7434  fprintf( inFile, "<formula name=\"%s\" id=\"%d\">\n", inFormula->getName().c_str(), inFormula->getId() );
7435  fprintf( inFile, "<attributFormula" );
7436  fprintf( inFile, " comment=\"%s\"", inFormula->getComment().c_str() );
7437  fprintf( inFile, " formula=\"%s\"", inFormula->getFormula().c_str() );
7438  fprintf( inFile, " parameter=\"%s\"/>\n", inFormula->getParam().c_str() );
7439  fprintf( inFile, "</formula>\n" );
7440 
7441  return dtkErrorStatus;
7442  }

◆ Dtk_DumpXml_Dtk_KinematicsJoint()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsJoint ( FILE *  inFile,
const Dtk_KinJointPtr &  inJoint,
Dtk_bool  simplified 
)
7537  {
7538  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7539  if( inFile == NULL )
7540  return dtkErrorNullPointer;
7541 
7542  Dtk_Size_t i, nb;
7543  Dtk_KinConstraintPtr constraint;
7544 
7545  fprintf( inFile, "<joint name=\"%s\" id=\"%d\">\n", inJoint->getName().c_str(), inJoint->getId() );
7546  if( simplified == DTK_FALSE )
7547  {
7548  fprintf( inFile, "<attributJoint type=\"%d\"", inJoint->getType() );
7549  if( inJoint->hasAttribute( L"_compoundType" ) )
7550  {
7551  fprintf( inFile, " compoundType=\"%d\"", inJoint->getCompoundType() );
7552  }
7553  if( inJoint->hasAttribute( inJoint->_PARAMETER1 ) )
7554  {
7555  fprintf( inFile, " parameter1=\"%f\"", inJoint->getParameter1() );
7556  }
7557  if( inJoint->hasAttribute( inJoint->_PARAMETER2 ) )
7558  {
7559  fprintf( inFile, " parameter2=\"%f\"", inJoint->getParameter2() );
7560  }
7561  if( inJoint->hasAttribute( inJoint->_RATIO ) )
7562  {
7563  fprintf( inFile, " ratio=\"%f\"", inJoint->getRatio() );
7564  }
7565  fprintf( inFile, ">\n" );
7566  if( inJoint->hasAttribute( inJoint->_UPPER_LIMIT1 ) ||
7567  inJoint->hasAttribute( inJoint->_LOWER_LIMIT1 ) ||
7568  inJoint->hasAttribute( inJoint->_UPPER_LIMIT2 ) ||
7569  inJoint->hasAttribute( inJoint->_LOWER_LIMIT2 ) )
7570  {
7571  fprintf( inFile, "<limit" );
7572  if( inJoint->hasAttribute( inJoint->_UPPER_LIMIT1 ) )
7573  {
7574  fprintf( inFile, " upperLimit1=\"%f\"", inJoint->getUpperLimit1() );
7575  }
7576  if( inJoint->hasAttribute( inJoint->_LOWER_LIMIT1 ) )
7577  {
7578  fprintf( inFile, " lowerLimit1=\"%f\"", inJoint->getLowerLimit1() );
7579  }
7580  if( inJoint->hasAttribute( inJoint->_UPPER_LIMIT2 ) )
7581  {
7582  fprintf( inFile, " upperLimit2=\"%f\"", inJoint->getUpperLimit2() );
7583  }
7584  if( inJoint->hasAttribute( inJoint->_LOWER_LIMIT2 ) )
7585  {
7586  fprintf( inFile, " lowerLimit2=\"%f\"", inJoint->getLowerLimit2() );
7587  }
7588  fprintf( inFile, "/>\n" );
7589  }
7590  fprintf( inFile, "<localFrame1 nbValue=\"12\"" );
7591  DumpTransfo( inFile, inJoint->getLocalFrame1() );
7592  fprintf( inFile, "/>\n" );
7593  fprintf( inFile, "<localFrame2 nbValue=\"12\"" );
7594  DumpTransfo( inFile, inJoint->getLocalFrame2() );
7595  fprintf( inFile, "/>\n" );
7596  if( inJoint->hasAttribute( inJoint->_LOCAL_FRAME3 ) )
7597  {
7598  fprintf( inFile, "<localFrame3 nbValue=\"12\"" );
7599  DumpTransfo( inFile, inJoint->getLocalFrame3() );
7600  fprintf( inFile, "/>\n" );
7601  }
7602  if( inJoint->hasAttribute( inJoint->_LOCAL_FRAME4 ) )
7603  {
7604  fprintf( inFile, "<localFrame4 nbValue=\"12\"" );
7605  DumpTransfo( inFile, inJoint->getLocalFrame4() );
7606  fprintf( inFile, "/>\n" );
7607  }
7608  if( inJoint->hasAttribute( inJoint->_ABSOLUT_POS1 ) )
7609  {
7610  fprintf( inFile, "<absolutePos1 nbValue=\"12\"" );
7611  DumpTransfo( inFile, inJoint->getAbsolutPos1() );
7612  fprintf( inFile, "/>\n" );
7613  }
7614  if( inJoint->hasAttribute( inJoint->_ABSOLUT_POS2 ) )
7615  {
7616  fprintf( inFile, "<absolutePos2 nbValue=\"12\"" );
7617  DumpTransfo( inFile, inJoint->getAbsolutPos2() );
7618  fprintf( inFile, "/>\n" );
7619  }
7620  fprintf( inFile, "</attributJoint>\n" );
7621  fprintf( inFile, "<parts>\n" );
7622  if( inJoint->hasAttribute( L"_part1" ) )
7623  {
7624  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inJoint->getPart1() );
7625  }
7626  if( inJoint->hasAttribute( L"_part2" ) )
7627  {
7628  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inJoint->getPart2() );
7629  }
7630  if( inJoint->hasAttribute( inJoint->_PART3 ) )
7631  {
7632  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inJoint->getPart3() );
7633  }
7634  fprintf( inFile, "</parts>\n" );
7635  if( inJoint->hasAttribute( inJoint->_CONSTRAINT ) )
7636  {
7637  fprintf( inFile, "<constraints>\n" );
7638  nb = inJoint->getConstraintSize();
7639  for( i = 0; i < nb; i++ )
7640  {
7641  constraint = inJoint->getConstraint( i );
7642  Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, constraint, DTK_TRUE );
7643  }
7644  fprintf( inFile, "</constraints>\n" );
7645  }
7646  if( inJoint->hasAttribute( inJoint->_CONNECTOR ) )
7647  {
7648  fprintf( inFile, "<connectors>\n" );
7649  nb = inJoint->getConnectorSize();
7650  for( i = 0; i < nb; i++ )
7651  {
7652  Dtk_DumpXml_Dtk_NodeConnector( inFile, inJoint->getConnector( i ) );
7653  }
7654  fprintf( inFile, "</connectors>\n" );
7655  }
7656  if( inJoint->hasAttribute( inJoint->_FIX_TOGETHER ) )
7657  {
7658  fprintf( inFile, "<fixTogether>\n" );
7659  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, inJoint->getFixTogether(), DTK_TRUE );
7660  fprintf( inFile, "</fixTogether>\n" );
7661  }
7662  if( inJoint->hasAttribute( inJoint->_RATIO_PARAMETER ) )
7663  {
7664  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inJoint->getRatioParameter() );
7665  }
7666  if( inJoint->hasAttribute( inJoint->_JOINT1 ) || inJoint->hasAttribute( inJoint->_JOINT2 ) )
7667  {
7668  fprintf( inFile, "<joints>\n" );
7669  if( inJoint->hasAttribute( inJoint->_JOINT1 ) )
7670  {
7671  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, inJoint->getJoint1(), DTK_TRUE );
7672  }
7673  if( inJoint->hasAttribute( inJoint->_JOINT2 ) )
7674  {
7675  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, inJoint->getJoint2(), DTK_TRUE );
7676  }
7677  fprintf( inFile, "</joints>\n" );
7678  }
7679  }
7680  fprintf( inFile, "</joint>\n" );
7681  return dtkNoError;
7682  }

◆ Dtk_DumpXml_Dtk_KinematicsLaw()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsLaw ( FILE *  inFile,
const Dtk_KinLawPtr &  inLaw 
)
7445  {
7446  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7447  if( inFile == NULL )
7448  return dtkErrorNullPointer;
7449 
7450  Dtk_Size_t i, nb;
7451 
7452  fprintf( inFile, "<law name=\"%s\" id=\"%d\">\n", inLaw->getName().c_str(), inLaw->getId() );
7453  fprintf( inFile, "<attributLaw comment=\"%s\" synchrone=\"%d\" active=\"%d\" algo=\"%d\"/>\n", inLaw->getComment().c_str(), inLaw->getSynchrone(), inLaw->getActive(), inLaw->getAlgo() );
7454  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsFormula( inFile, inLaw->getExpression() );
7455 
7456  if( inLaw->getCurveSize() + inLaw->getParameter().size() > 0 )
7457  {
7458  fprintf( inFile, "<parameters>\n" );
7459  nb = inLaw->getCurveSize();
7460  for( i = 0; i < nb; i++ )
7461  {
7462  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsCurve( inFile, inLaw->getCurve( i ) );
7463  }
7464  nb = inLaw->getParameter().size();
7465  for( i = 0; i < nb; i++ )
7466  {
7467  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inLaw->getParameter().at( i ), DTK_TRUE );
7468  }
7469  fprintf( inFile, "</parameters>\n" );
7470  }
7471  fprintf( inFile, "</law>\n" );
7472 
7473  return dtkNoError;
7474  }

◆ Dtk_DumpXml_Dtk_KinematicsMechanism()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsMechanism ( FILE *  inFile,
const Dtk_KinMechanismPtr &  inKinMechanism 
)
7787  {
7788  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7789  if( inFile == NULL )
7790  return dtkErrorNullPointer;
7791 
7792  Dtk_Size_t i, nbElt;
7793  Dtk_KinJointPtr joint;
7794  Dtk_KinCommandPtr cmd;
7795  Dtk_KinFixPartPtr fixPart;
7796 
7797  fprintf( inFile, "<mechanism name=\"%s\" id=\"%d\" version=\"%s\">\n", inKinMechanism->getName().c_str(), inKinMechanism->getId(), inKinMechanism->getVersion().c_str() );
7798 
7799  // Dump Mechanism joints
7800  fprintf( inFile, "<joints>\n" );
7801  nbElt = inKinMechanism->getJointSize();
7802  for( i = 0; i < nbElt; i++ )
7803  {
7804  joint = inKinMechanism->getJoint( i );
7805  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, joint, DTK_TRUE );
7806  }
7807  fprintf( inFile, "</joints>\n" );
7808 
7809  // Dump Mechanism commands
7810  fprintf( inFile, "<commands>\n" );
7811  nbElt = inKinMechanism->getCommandSize();
7812  for( i = 0; i < nbElt; i++ )
7813  {
7814  cmd = inKinMechanism->getCommand( i );
7815  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsCommand( inFile, cmd, DTK_TRUE );
7816  }
7817  fprintf( inFile, "</commands>\n" );
7818 
7819  // Dump Mechanism fix part
7820  fixPart = inKinMechanism->getFixPart();
7821  if( fixPart.IsNotNULL() )
7822  {
7823  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsFixPart( inFile, fixPart );
7824  }
7825 
7826  // Dump Mechanism time parameter
7827  fprintf( inFile, "<paramTime>\n" );
7828  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inKinMechanism->getParamTime() );
7829  fprintf( inFile, "</paramTime>\n" );
7830 
7831  // Dump Mechanism laws
7832  nbElt = inKinMechanism->getLawSize();
7833  if( nbElt > 0 )
7834  {
7835  fprintf( inFile, "<laws>\n" );
7836  for( i = 0; i < nbElt; i++ )
7837  {
7838  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsLaw( inFile, inKinMechanism->getLaw( i ) );
7839  }
7840  fprintf( inFile, "</laws>\n" );
7841  }
7842 
7843  // Dump Mechanism Speed Acceleration
7844  nbElt = inKinMechanism->getSpeedAccelerationSize();
7845  if( nbElt > 0 )
7846  {
7847  fprintf( inFile, "<speedsAccelerations>\n" );
7848  for( i = 0; i < nbElt; i++ )
7849  {
7850  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration( inFile, inKinMechanism->getSpeedAcceleration( i ) );
7851  }
7852  fprintf( inFile, "</speedsAccelerations>\n" );
7853  }
7854  fprintf( inFile, "</mechanism>\n" );
7855 
7856  return dtkErrorStatus;
7857  }

◆ Dtk_DumpXml_Dtk_KinematicsNamedValue()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsNamedValue ( FILE *  inFile,
const Dtk_KinNamedValuePtr &  inNamedValue 
)
7184  {
7185  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7186  if( inFile == NULL )
7187  return dtkErrorNullPointer;
7188 
7189  fprintf( inFile, "<namedValue name=\"%s\" value=\"%f\"/>\n", inNamedValue->getName().c_str(), inNamedValue->getValue() );
7190  return dtkErrorStatus;
7191  }

◆ Dtk_DumpXml_Dtk_KinematicsParameter()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsParameter ( FILE *  inFile,
const Dtk_KinParameterPtr &  inParameter,
Dtk_bool  simplified 
)
7194  {
7195  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7196  if( inFile == NULL )
7197  return dtkErrorNullPointer;
7198 
7199  int i;
7200 
7201  fprintf( inFile, "<parameter name=\"%s\" id=\"%d\"", inParameter->getName().c_str(), inParameter->getId() );
7202  if( simplified == DTK_TRUE )
7203  {
7204  Dtk_string tmp;
7205  switch( inParameter->getParentType() )
7206  {
7207  case DTK_KIN_TYPE_COMMAND:
7208  tmp.convert_from_int( ( ( Dtk_KinCommand * )inParameter->getParentElement() )->getId() );
7209  tmp += L"_COMMAND";
7210  break;
7211  case DTK_KIN_TYPE_JOINT:
7212  tmp.convert_from_int( ( ( Dtk_KinJoint * )inParameter->getParentElement() )->getId() );
7213  tmp += L"_JOINT";
7214  break;
7215  case DTK_KIN_TYPE_MECHANISM:
7216  tmp.convert_from_int( ( ( Dtk_KinMechanism * )inParameter->getParentElement() )->getId() );
7217  tmp += L"_MECHANISM";
7218  break;
7219  case DTK_KIN_TYPE_LAW:
7220  tmp.convert_from_int( ( ( Dtk_KinLaw * )inParameter->getParentElement() )->getId() );
7221  tmp += L"_LAW";
7222  break;
7223  case DTK_KIN_TYPE_SPEED_ACCELERATION:
7224  tmp.convert_from_int( ( ( Dtk_KinSpeedAcceleration * )inParameter->getParentElement() )->getId() );
7225  tmp += L"_SPEED_ACCELERATION";
7226  break;
7227  default:
7228  tmp = L"DTK_UNKNOWN";
7229  break;
7230  }
7231  fprintf( inFile, " parent=\"%s\"", tmp.c_str() );
7232  }
7233  fprintf( inFile, ">\n" );
7234  if( simplified == DTK_FALSE )
7235  {
7236  if( inParameter->hasAttribute( inParameter->_RANGE ) )
7237  {
7238  fprintf( inFile, "<range nbValue=\"4\"" );
7239  for( i = 0; i < 4; i++ )
7240  {
7241  fprintf( inFile, " _%d=\"%f\"", i + 1, inParameter->getRange( i ) );
7242  }
7243  fprintf( inFile, "/>\n" );
7244  }
7245  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsNamedValue( inFile, inParameter->getNamedValue() );
7246  }
7247  fprintf( inFile, "</parameter>\n" );
7248 
7249  return dtkErrorStatus;
7250  }

◆ Dtk_DumpXml_Dtk_KinematicsProduct()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsProduct ( FILE *  inFile,
const Dtk_KinProductPtr &  inKinProduct,
int &  inKinProductIndex 
)
7723  {
7724  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7725  if( inFile == NULL )
7726  return dtkErrorNullPointer;
7727 
7728  Dtk_Size_t i, nb;
7729  Dtk_KinPartPtr part;
7730  Dtk_KinProductPtr prod;
7731  Dtk_string xmlName, productName, instanceName, fileName;
7732  Dtk_status tempDst;
7733 
7734  fprintf( inFile, "<product" );
7735  productName = inKinProduct->name();
7736  if( productName.is_not_NULL() )
7737  {
7738  xmlName = productName;
7739  tempDst = validate_xml_string( xmlName );
7740  fprintf( inFile, " name=\"%s\"", xmlName.c_str() );
7741  }
7742  fprintf( inFile, " id=\"%d\"", inKinProduct->id() );
7743 
7744  instanceName = inKinProduct->instanceName();
7745  if( instanceName.is_not_NULL() )
7746  {
7747  xmlName = instanceName;
7748  tempDst = validate_xml_string( xmlName );
7749  fprintf( inFile, " instanceName=\"%s\"", xmlName.c_str() );
7750  }
7751  fileName = inKinProduct->fileName();
7752  if( fileName.is_not_NULL() )
7753  {
7754  xmlName = fileName;
7755  tempDst = validate_xml_string( xmlName );
7756  fprintf( inFile, " fileName=\"%s\"", xmlName.c_str() );
7757  }
7758 
7759  fprintf( inFile, ">\n<components>\n" );
7760  nb = inKinProduct->getNbPart();
7761  nb += inKinProduct->getNbProduct();
7762  part = NULL;
7763  prod = NULL;
7764  for( i = 0; i < nb; i++ )
7765  {
7766  inKinProductIndex++;
7767  prod = inKinProduct->searchProductByNumChild( inKinProductIndex );
7768  if( part.IsNotNULL() )
7769  {
7770  Dtk_DumpXml_Dtk_ComponentPtr( inFile, part );
7771  part = NULL;
7772  }
7773  if( prod.IsNotNULL() )
7774  {
7775  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsProduct( inFile, prod, inKinProductIndex );
7776  prod = NULL;
7777  }
7778  }
7779 
7780  fprintf( inFile, "</components>\n" );
7781  fprintf( inFile, "</product>\n" );
7782 
7783  return dtkNoError;
7784  }

◆ Dtk_DumpXml_Dtk_KinematicsPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsPtr ( FILE *  inFile,
const Dtk_KinematicPtr &  inKinematic 
)
7860  {
7861  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7862  if( inFile == NULL )
7863  return dtkErrorNullPointer;
7864 
7865  Dtk_Size_t size, i;
7866  Dtk_KinPartPtr part;
7867  Dtk_KinConstraintPtr constraint;
7868  Dtk_KinJointPtr joint;
7869  Dtk_KinCommandPtr command;
7870  Dtk_KinMechanismPtr mechanism;
7871  Dtk_status dstat;
7872 
7873  fprintf( inFile, "<kinematics>\n" );
7874 
7875  // Dump Kinematics Product
7876  if( inKinematic->getProduct().IsNotNULL() )
7877  {
7878  int iProductIndex = 0;
7879  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsProduct( inFile, inKinematic->getProduct(), iProductIndex );
7880  }
7881 
7882  // Dump Kinematics Parts
7883  fprintf( inFile, "<parts>\n" );
7884  size = inKinematic->getPartSize();
7885  for( i = 0; i < size; i++ )
7886  {
7887  part = inKinematic->getPart( i );
7888  Dtk_DumpXml_Dtk_ComponentPtr( inFile, part );
7889  if( dstat.isNotOK() )
7890  {
7891  return dtkErrorUnspecified;
7892  }
7893  }
7894  fprintf( inFile, "</parts>\n" );
7895 
7896  // Dump kinematics Constraints
7897  fprintf( inFile, "<constraints>\n" );
7898  size = inKinematic->getConstraintSize();
7899  for( i = 0; i < size; i++ )
7900  {
7901  constraint = inKinematic->getConstraint( i );
7902  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, constraint, DTK_FALSE );
7903  if( dtkErrorStatus != dtkNoError )
7904  {
7905  return dtkErrorStatus;
7906  }
7907  }
7908  fprintf( inFile, "</constraints>\n" );
7909 
7910  // Dump kinematics Joints
7911  fprintf( inFile, "<joints>\n" );
7912  size = inKinematic->getJointSize();
7913  for( i = 0; i < size; i++ )
7914  {
7915  joint = inKinematic->getJoint( i );
7916  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, joint, DTK_FALSE );
7917  if( dtkErrorStatus != dtkNoError )
7918  {
7919  return dtkErrorStatus;
7920  }
7921  }
7922  fprintf( inFile, "</joints>\n" );
7923 
7924  // Dump kinematics commands
7925  fprintf( inFile, "<commands>\n" );
7926  size = inKinematic->getCommandSize();
7927  for( i = 0; i < size; i++ )
7928  {
7929  command = inKinematic->getCommand( i );
7930  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsCommand( inFile, command, DTK_FALSE );
7931  if( dtkErrorStatus != dtkNoError )
7932  {
7933  return dtkErrorStatus;
7934  }
7935  }
7936  fprintf( inFile, "</commands>\n" );
7937 
7938  // Dump kinematics commands
7939  fprintf( inFile, "<mechanisms>\n" );
7940  size = inKinematic->getMechanismSize();
7941  for( i = 0; i < size; i++ )
7942  {
7943  mechanism = inKinematic->getMechanism( i );
7944  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsMechanism( inFile, mechanism );
7945  if( dtkErrorStatus != dtkNoError )
7946  {
7947  return dtkErrorStatus;
7948  }
7949  }
7950  fprintf( inFile, "</mechanisms>\n" );
7951 
7952  fprintf( inFile, "</kinematics>\n" );
7953  return dtkErrorStatus;
7954  }

◆ Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration ( FILE *  inFile,
const Dtk_KinSpeedAccelerationPtr &  inSpeedAcceleration 
)
7253  {
7254  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7255  if( inFile == NULL )
7256  return dtkErrorNullPointer;
7257 
7258  fprintf( inFile, "<speedAcceleration name=\"%s\" id=\"%d\">\n", inSpeedAcceleration->getName().c_str(), inSpeedAcceleration->getId() );
7259 
7260  if( inSpeedAcceleration->getRefProd().IsNotNULL() )
7261  {
7262  fprintf( inFile, "<refProd>\n" );
7263  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inSpeedAcceleration->getRefProd() );
7264  fprintf( inFile, "</refProd>\n" );
7265  }
7266  if( inSpeedAcceleration->getPoint().IsNotNULL() )
7267  {
7268  fprintf( inFile, "<point>\n" );
7269  Dtk_DumpXml_Dtk_NodeConnector( inFile, inSpeedAcceleration->getPoint() );
7270  fprintf( inFile, "</point>\n" );
7271  }
7272 
7273  if( inSpeedAcceleration->getPtX().IsNotNULL() )
7274  {
7275  fprintf( inFile, "<pointX>\n" );
7276  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getPtX() );
7277  fprintf( inFile, "</pointX>\n" );
7278  }
7279  if( inSpeedAcceleration->getPtY().IsNotNULL() )
7280  {
7281  fprintf( inFile, "<pointY>\n" );
7282  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getPtY() );
7283  fprintf( inFile, "</pointY>\n" );
7284  }
7285  if( inSpeedAcceleration->getPtZ().IsNotNULL() )
7286  {
7287  fprintf( inFile, "<pointZ>\n" );
7288  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getPtZ() );
7289  fprintf( inFile, "</pointZ>\n" );
7290  }
7291 
7292  if( inSpeedAcceleration->getLinearSpeedX().IsNotNULL() )
7293  {
7294  fprintf( inFile, "<linearSpeedX>\n" );
7295  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeedX() );
7296  fprintf( inFile, "</linearSpeedX>\n" );
7297  }
7298  if( inSpeedAcceleration->getLinearSpeedY().IsNotNULL() )
7299  {
7300  fprintf( inFile, "<linearSpeedY>\n" );
7301  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeedY() );
7302  fprintf( inFile, "</linearSpeedY>\n" );
7303  }
7304  if( inSpeedAcceleration->getLinearSpeedZ().IsNotNULL() )
7305  {
7306  fprintf( inFile, "<linearSpeedZ>\n" );
7307  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeedZ() );
7308  fprintf( inFile, "</linearSpeedZ>\n" );
7309  }
7310  if( inSpeedAcceleration->getLinearSpeed().IsNotNULL() )
7311  {
7312  fprintf( inFile, "<linearSpeed>\n" );
7313  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeed() );
7314  fprintf( inFile, "</linearSpeed>\n" );
7315  }
7316 
7317  if( inSpeedAcceleration->getLinearAccelerationX().IsNotNULL() )
7318  {
7319  fprintf( inFile, "<linearAccelerationX>\n" );
7320  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAccelerationX() );
7321  fprintf( inFile, "</linearAccelerationX>\n" );
7322  }
7323  if( inSpeedAcceleration->getLinearAccelerationY().IsNotNULL() )
7324  {
7325  fprintf( inFile, "<linearAccelerationY>\n" );
7326  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAccelerationY() );
7327  fprintf( inFile, "</linearAccelerationY>\n" );
7328  }
7329  if( inSpeedAcceleration->getLinearAccelerationZ().IsNotNULL() )
7330  {
7331  fprintf( inFile, "<linearAccelerationZ>\n" );
7332  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAccelerationZ() );
7333  fprintf( inFile, "</linearAccelerationZ>\n" );
7334  }
7335  if( inSpeedAcceleration->getLinearAcceleration().IsNotNULL() )
7336  {
7337  fprintf( inFile, "<linearAcceleration>\n" );
7338  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAcceleration() );
7339  fprintf( inFile, "</linearAcceleration>\n" );
7340  }
7341 
7342  if( inSpeedAcceleration->getAngularSpeedX().IsNotNULL() )
7343  {
7344  fprintf( inFile, "<angularSpeedX>\n" );
7345  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeedX() );
7346  fprintf( inFile, "</angularSpeedX>\n" );
7347  }
7348  if( inSpeedAcceleration->getAngularSpeedY().IsNotNULL() )
7349  {
7350  fprintf( inFile, "<angularSpeedY>\n" );
7351  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeedY() );
7352  fprintf( inFile, "</angularSpeedY>\n" );
7353  }
7354  if( inSpeedAcceleration->getAngularSpeedZ().IsNotNULL() )
7355  {
7356  fprintf( inFile, "<angularSpeedZ>\n" );
7357  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeedZ() );
7358  fprintf( inFile, "</angularSpeedZ>\n" );
7359  }
7360  if( inSpeedAcceleration->getAngularSpeed().IsNotNULL() )
7361  {
7362  fprintf( inFile, "<angularSpeed>\n" );
7363  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeed() );
7364  fprintf( inFile, "</angularSpeed>\n" );
7365  }
7366 
7367  if( inSpeedAcceleration->getAngularAccelerationX().IsNotNULL() )
7368  {
7369  fprintf( inFile, "<angularAccelerationX>\n" );
7370  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAccelerationX() );
7371  fprintf( inFile, "</angularAccelerationX>\n" );
7372  }
7373  if( inSpeedAcceleration->getAngularAccelerationY().IsNotNULL() )
7374  {
7375  fprintf( inFile, "<angularAccelerationY>\n" );
7376  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAccelerationY() );
7377  fprintf( inFile, "</angularAccelerationY>\n" );
7378  }
7379  if( inSpeedAcceleration->getAngularAccelerationZ().IsNotNULL() )
7380  {
7381  fprintf( inFile, "<angularAccelerationZ>\n" );
7382  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAccelerationZ() );
7383  fprintf( inFile, "</angularAccelerationZ>\n" );
7384  }
7385  if( inSpeedAcceleration->getAngularAcceleration().IsNotNULL() )
7386  {
7387  fprintf( inFile, "<angularAcceleration>\n" );
7388  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAcceleration() );
7389  fprintf( inFile, "</angularAcceleration>\n" );
7390  }
7391 
7392  if( inSpeedAcceleration->getCirX().IsNotNULL() )
7393  {
7394  fprintf( inFile, "<cirX>\n" );
7395  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getCirX() );
7396  fprintf( inFile, "</cirX>\n" );
7397  }
7398  if( inSpeedAcceleration->getCirY().IsNotNULL() )
7399  {
7400  fprintf( inFile, "<cirY>\n" );
7401  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getCirY() );
7402  fprintf( inFile, "</cirY>\n" );
7403  }
7404  if( inSpeedAcceleration->getCirZ().IsNotNULL() )
7405  {
7406  fprintf( inFile, "<cirZ>\n" );
7407  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getCirZ() );
7408  fprintf( inFile, "</cirZ>\n" );
7409  }
7410 
7411  fprintf( inFile, "</speedAcceleration>\n" );
7412 
7413  return dtkNoError;
7414  }

◆ Dtk_DumpXml_Dtk_LayerInfosSetPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_LayerInfosSetPtr ( FILE *  F,
const Dtk_LayerInfosSetPtr &  inVal 
)
3373  {
3374  fprintf( F, "<Dtk_LayerInfosSet>\n" );
3375  if( inVal.IsNotNULL() )
3376  {
3377  Dtk_Size_t LayerIdx = 0;
3378  Dtk_Size_t NumLayers = inVal->GetNumLayers();
3379  Dtk_Size_t CurrentLayer;
3380 
3381  inVal->GetCurrentLayer( CurrentLayer );
3382  fprintf( F, "<Layers Num=\"" XmlFormat( "u" )"\" CurrentLayer=\"" XmlFormat( "d" )"\">\n", NumLayers, CurrentLayer );
3383  auto const& layers = inVal->GetLayers();
3384  for( Dtk_LayerInfosSet::Layer const& layer : layers )
3385  {
3386  if( layer.GetName().len() > 0 )
3387  {
3388  auto LayerName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( layer.GetName(), XMLGenericString);
3389  fprintf( F, "<__" XmlFormat( "u" ) "__ ID= \"%d\" Name=\"%S\" ", LayerIdx, layer.GetID(), LayerName.w_str());
3390  }
3391  else
3392  {
3393  fprintf( F, "<__" XmlFormat( "u" ) "__ ID= \"%d\" Name=\"\" ", LayerIdx, layer.GetID() );
3394 
3395  //fprintf( F, "<__%d__ Name=\"\"", layer.GetID() );
3396  }
3397  if( layer.GetFatherID() != static_cast< Dtk_ID >( -1 ) )
3398  fprintf( F, " FatherID= \"%d\"", layer.GetFatherID() );
3399  if( !layer.IsFlaggedAs( Dtk_LayerInfosSet::Layer::Status::Visible ) )
3400  fprintf( F, " Visible=\"false\"");
3401  if( !layer.IsFlaggedAs( Dtk_LayerInfosSet::Layer::Status::Selectable ) )
3402  fprintf( F, " Selectable=\"false\"" );
3403 
3404  fprintf( F, "/>\n");
3405  LayerIdx++;
3406  }
3407  fprintf( F, "</Layers>\n" );
3408 
3409  Dtk_Size_t LayerFiltersIdx;
3410  Dtk_Size_t NumLayersFilters = inVal->GetNumLayerFilters();
3411  Dtk_Size_t DefaultLayerFilter; inVal->GetDefaultLayerFilter( DefaultLayerFilter );
3412  Dtk_LayerFilterInfosPtr CurrentLayerFilterInfo = inVal->GetLayerFilterByPos( DefaultLayerFilter );
3413  Dtk_string CurrentLayerFilterName = L"None";
3414  if( CurrentLayerFilterInfo.IsNotNULL() )
3415  {
3416  Dtk_string LayerFilterName;
3417  CurrentLayerFilterInfo->GetName( LayerFilterName );
3418  CurrentLayerFilterName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( LayerFilterName, XMLGenericString );
3419  }
3420  fprintf( F, "<LayerFilters Num=\"" XmlFormat( "u" )"\" DefaultLayerFilter=\"%s\">\n", NumLayersFilters, CurrentLayerFilterName.c_str() );
3421  for( LayerFiltersIdx = 0; LayerFiltersIdx < NumLayersFilters; LayerFiltersIdx++ )
3422  {
3423  Dtk_LayerFilterInfosPtr TmpLayerFilterInfo = inVal->GetLayerFilterByPos( LayerFiltersIdx );
3424  if( TmpLayerFilterInfo.IsNotNULL() )
3425  {
3426  Dtk_string LayerFilterName, LayerFilterDescription;
3427  Dtk_tab< Dtk_Size_t > SelectedLayers;
3428  TmpLayerFilterInfo->GetName( LayerFilterName );
3429  LayerFilterName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( LayerFilterName, XMLGenericString );
3430  TmpLayerFilterInfo->GetDescription( LayerFilterDescription );
3431  TmpLayerFilterInfo->GetSelectedLayers( SelectedLayers );
3432  Dtk_Size_t SelectedLayersIdx, NumSelectedLayers = SelectedLayers.size();
3433 
3434  fprintf( F, "<LayerFilterInfo Name=\"%S\">\n", LayerFilterName.w_str() );
3435  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Description", LayerFilterDescription );
3436  fprintf( F, "<SelectedLayers Num=\"" XmlFormat( "u" )"\">\n", NumSelectedLayers );
3437  for( SelectedLayersIdx = 0; SelectedLayersIdx < NumSelectedLayers; SelectedLayersIdx++ )
3438  {
3439  // Dtk_ID layerId, layerIndex;
3440  // layerIndex = SelectedLayers[ SelectedLayersIdx ];
3441  // layerId = layers.subspan( layerIndex ).begin()->GetID();
3442  // fprintf( F, "<__" XmlFormat( "u" ) "__ ID= \"%d\" />\n ", layerIndex, layerId );
3443  fprintf( F, "<__" XmlFormat( "u" )"__/>\n", SelectedLayers[ SelectedLayersIdx ] );
3444  }
3445  fprintf( F, "</SelectedLayers>\n" );
3446  fprintf( F, "</LayerFilterInfo>\n" );
3447  }
3448  }
3449  fprintf( F, "</LayerFilters>\n" );
3450  }
3451  else
3452  {
3453  fprintf( F, "Null" );
3454  }
3455  fprintf( F, "</Dtk_LayerInfosSet>\n" );
3456 
3457  return dtkNoError;
3458  }

◆ Dtk_DumpXml_Dtk_LayerInfosSetPtr_Deprecated()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_LayerInfosSetPtr_Deprecated ( FILE *  F,
const Dtk_LayerInfosSetPtr &  inVal 
)
3461  {
3462  fprintf( F, "<Dtk_LayerInfosSet>\n" );
3463  if( inVal.IsNotNULL() )
3464  {
3465  Dtk_Size_t LayerIdx;
3466  Dtk_Size_t NumLayers = inVal->GetNumLayers();
3467  Dtk_Size_t DefaultLayer;
3468 
3469  inVal->GetDefaultLayer( DefaultLayer );
3470  fprintf( F, "<Layers Num=\"" XmlFormat( "u" )"\" DefaultLayer=\"" XmlFormat( "d" )"\">\n", NumLayers, DefaultLayer );
3471  for( LayerIdx = 0; LayerIdx < NumLayers; LayerIdx++ )
3472  {
3473  Dtk_string LayerName;
3474  Dtk_ID LayerId;
3475  Dtk_ErrorStatus errn = inVal->GetLayerName( LayerIdx, LayerName );
3476  Dtk_ErrorStatus erri = inVal->GetLayerID( LayerIdx, LayerId );
3477  if( errn == dtkNoError && erri == dtkNoError )
3478  {
3479  LayerName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( LayerName, XMLGenericString );
3480  fprintf( F, "<__" XmlFormat( "u" ) "__ ID= \"%d\" Name=\"%S\"/>\n", LayerIdx, LayerId ,LayerName.w_str() );
3481  }
3482  else
3483  {
3484  if( erri == dtkNoError )
3485  fprintf( F, "<__%d__ Name=\"\"/>\n", LayerId );
3486  else
3487  fprintf( F, "<__" XmlFormat( "u" )"__ Name=\"\"/>\n", LayerIdx );
3488 
3489  }
3490  }
3491  fprintf( F, "</Layers>\n" );
3492 
3493  Dtk_Size_t LayerFiltersIdx;
3494  Dtk_Size_t NumLayersFilters = inVal->GetNumLayerFilters();
3495  Dtk_Size_t DefaultLayerFilter; inVal->GetDefaultLayerFilter( DefaultLayerFilter );
3496  Dtk_LayerFilterInfosPtr CurrentLayerFilterInfo = inVal->GetLayerFilterByPos( DefaultLayerFilter );
3497  Dtk_string CurrentLayerFilterName = L"None";
3498  if( CurrentLayerFilterInfo.IsNotNULL() )
3499  {
3500  Dtk_string LayerFilterName;
3501  CurrentLayerFilterInfo->GetName( LayerFilterName );
3502  CurrentLayerFilterName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( LayerFilterName, XMLGenericString );
3503  }
3504  fprintf( F, "<LayerFilters Num=\"" XmlFormat( "u" )"\" DefaultLayerFilter=\"%s\">\n", NumLayersFilters, CurrentLayerFilterName.c_str() );
3505  for( LayerFiltersIdx = 0; LayerFiltersIdx < NumLayersFilters; LayerFiltersIdx++ )
3506  {
3507  Dtk_LayerFilterInfosPtr TmpLayerFilterInfo = inVal->GetLayerFilterByPos( LayerFiltersIdx );
3508  if( TmpLayerFilterInfo.IsNotNULL() )
3509  {
3510  Dtk_string LayerFilterName, LayerFilterDescription;
3511  Dtk_tab< Dtk_Size_t > SelectedLayers;
3512  TmpLayerFilterInfo->GetName( LayerFilterName );
3513  LayerFilterName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( LayerFilterName, XMLGenericString );
3514  TmpLayerFilterInfo->GetDescription( LayerFilterDescription );
3515  TmpLayerFilterInfo->GetSelectedLayers( SelectedLayers );
3516  Dtk_Size_t SelectedLayersIdx, NumSelectedLayers = SelectedLayers.size();
3517 
3518  fprintf( F, "<LayerFilterInfo Name=\"%S\">\n", LayerFilterName.w_str() );
3519  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Description", LayerFilterDescription );
3520  fprintf( F, "<SelectedLayers Num=\"" XmlFormat( "u" )"\">\n", NumSelectedLayers );
3521  for( SelectedLayersIdx = 0; SelectedLayersIdx < NumSelectedLayers; SelectedLayersIdx++ )
3522  {
3523  fprintf( F, "<__" XmlFormat( "u" )"__/>\n", SelectedLayers[ SelectedLayersIdx ] );
3524  }
3525  fprintf( F, "</SelectedLayers>\n" );
3526  fprintf( F, "</LayerFilterInfo>\n" );
3527  }
3528  }
3529  fprintf( F, "</LayerFilters>\n" );
3530  }
3531  else
3532  {
3533  fprintf( F, "Null" );
3534  }
3535  fprintf( F, "</Dtk_LayerInfosSet>\n" );
3536 
3537  return dtkNoError;
3538  }

◆ Dtk_DumpXml_Dtk_LeaderPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_LeaderPtr ( FILE *  F,
const Dtk_LeaderPtr &  L 
)
1289  {
1290  /*char* arrowtype[] = {"DTK_LDT_NONE","DTK_LDT_OPEN_ARROW","DTK_LDT_CLOSE_ARROW","DTK_LDT_FILL_ARROW",
1291  "DTK_LDT_CROSS_ARROW","DTK_LDT_CIRCLE","DTK_LDT_FILL_CIRCLE","DTK_LDT_SQUARE","DTK_LDT_FILL_SQUARE",
1292  "DTK_LDT_SLASH","DTK_LDT_CROSS_CIRCLE","DTK_LDT_X_CIRCLE","DTK_LDT_TRIANGLE","DTK_LDT_FILL_TRIANGLE",
1293  "DTK_LDT_PLUS","DTK_LDT_X_CROSS"};*/
1294  fprintf( F, "<Dtk_LeaderPtr>\n" );
1295  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, L->GetInfo() );
1296 
1297  switch( L->GetLeaderType() )
1298  {
1299  default:
1300  case Dtk_Leader::TypeUnknown: fprintf( F, "<LeaderType>TypeUnknown</LeaderType>\n" ); break;
1301  case Dtk_Leader::TypeLinear: fprintf( F, "<LeaderType>TypeLinear</LeaderType>\n" ); break;
1302  case Dtk_Leader::TypeAngular: fprintf( F, "<LeaderType>TypeAngular</LeaderType>\n" ); break;
1303  }
1304 
1305  //ArrowHead
1306  {
1307  fprintf( F, "<Arrow>\n" );
1308  double width, height;
1309  const Dtk_Leader::ArrowHead &LeaderArrowHead = L->GetArrowHead();
1310  LeaderArrowHead.GetWidthHeight( width, height );
1311  Dtk_dir ArrowHeaderRefDir, ArrowHeaderAxisDir;
1312  LeaderArrowHead.GetDirections( ArrowHeaderRefDir, ArrowHeaderAxisDir );
1313 
1314  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, LeaderArrowHead.GetInfo() );
1315  //L->RetrieveLeader_terminator_infos( width, height, location, type );
1316  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, LeaderArrowHead.GetArrowLocation(), "Location" );
1317  fprintf( F, "<width>%f</width>\n", width );
1318  fprintf( F, "<height>%f</height>\n", height );
1319  Dtk_DumpXMLNamespace::Dtk_DumpXml_LeaderTerminatorTypeEnum( F, LeaderArrowHead.GetType(), L"TerminatorType" );
1320  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, ArrowHeaderRefDir, "RefDir" );
1321  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, ArrowHeaderAxisDir, "AxisDir" );
1322  fprintf( F, "</Arrow>\n" );
1323  }
1324  fprintf( F, "<ApplicationZoneType>%s</ApplicationZoneType>\n", Dtk_Leader::ApplicationZone::ApplicationZoneEnumToString( L->GetApplicationZoneType() ).c_str() );
1325 
1326  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, L->GetLeaderCurve() );
1327 
1328  //ExtensionLine
1329  {
1330  Dtk_PolylinePtr ExtLine = L->GetExtensionLine();
1331  if( ExtLine.IsNotNULL() )
1332  {
1333  fprintf( F, "<ExtensionLine>\n" );
1334  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, ExtLine->get_info() );
1335  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_PolylinePtr( F, ExtLine );
1336  fprintf( F, "</ExtensionLine>\n" );
1337  }
1338  }
1339 
1340  fprintf( F, "<allAroundEnabled>" );
1341  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_bool( F, L->GetAllAroundSet() );
1342  fprintf( F, "</allAroundEnabled>\n" );
1343 
1344  fprintf( F, "<StubDelta>%f</StubDelta>\n", L->GetStubDelta() );
1345  fprintf( F, "</Dtk_LeaderPtr>\n" );
1346  return dtkNoError;
1347  }

◆ Dtk_DumpXml_Dtk_Light()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Light ( FILE *  F,
const Dtk_LightMapPtr &  inLight 
)
3651  {
3652  fprintf( F, "<Dtk_LightMapPtr>\n" );
3653  Dtk_RGB color;
3654 
3655  color = inLight->GetAmbientColor();
3656  fprintf( F, "<AmbientColor><r>%d</r><g>%d</g><b>%d</b></AmbientColor>\n", color[ 0 ], color[ 1 ], color[ 2 ] );
3657  fprintf( F, "<AmbientCoef>%lf</AmbientCoef>\n", inLight->GetAmbientRatio() );
3658 
3659  color = inLight->GetDiffuseColor();
3660  fprintf( F, "<DiffuseColor><r>%d</r><g>%d</g><b>%d</b></DiffuseColor>\n", color[ 0 ], color[ 1 ], color[ 2 ] );
3661  fprintf( F, "<DiffuseCoef>%lf</DiffuseCoef>\n", inLight->GetDiffuseRatio() );
3662 
3663  color = inLight->GetReflectiveColor();
3664  fprintf( F, "<ReflectiveColor><r>%d</r><g>%d</g><b>%d</b></ReflectiveColor>\n", color[ 0 ], color[ 1 ], color[ 2 ] );
3665  fprintf( F, "<ReflectiveCoef>%lf</ReflectiveCoef>\n", inLight->GetReflectiveRatio() );
3666 
3667  color = inLight->GetEmissiveColor();
3668  fprintf( F, "<EmissiveColor><r>%d</r><g>%d</g><b>%d</b></EmissiveColor>\n", color[ 0 ], color[ 1 ], color[ 2 ] );
3669  fprintf( F, "<EmissiveCoef>%lf</EmissiveCoef>\n", inLight->GetEmissiveRatio() );
3670 
3671  color = inLight->GetSpecularColor();
3672  fprintf( F, "<SpecularColor><r>%d</r><g>%d</g><b>%d</b></SpecularColor>\n", color[ 0 ], color[ 1 ], color[ 2 ] );
3673  fprintf( F, "<SpecularCoef>%lf</SpecularCoef>\n", inLight->GetSpecularRatio() );
3674 
3675 
3676  color = inLight->GetTransparentColor();
3677  fprintf( F, "<TransparentColor><r>%d</r><g>%d</g><b>%d</b></TransparentColor>\n", color[ 0 ], color[ 1 ], color[ 2 ] );
3678  fprintf( F, "<TransparentCoef>%lf</TransparentCoef>\n", inLight->GetTransparentRatio() );
3679 
3680  fprintf( F, "<ShininessCoef>%lf</ShininessCoef>\n", inLight->GetShininessRatio() );
3681 
3682 
3683  fprintf( F, "</Dtk_LightMapPtr>\n" );
3684  return dtkNoError;
3685  }

◆ Dtk_DumpXml_Dtk_LinearExtrusionSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_LinearExtrusionSurfacePtr ( FILE *  F,
const Dtk_LinearExtrusionSurfacePtr &  inSurf 
)
6315  {
6316  fprintf( F, "<Dtk_LinearExtrusionSurfacePtr>" );
6317  fprintf( F, "<ExtrusionAxis>" );
6318  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetExtrusionAxis() );
6319  fprintf( F, "</ExtrusionAxis>" );
6320  fprintf( F, "<ExtrudedCurve>" );
6321  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, inSurf->GetExtrudedCurve() );
6322  fprintf( F, "</ExtrudedCurve>" );
6323 
6324  fprintf( F, "</Dtk_LinearExtrusionSurfacePtr>" );
6325  return dtkNoError;
6326  }

◆ Dtk_DumpXml_Dtk_LinePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_LinePtr ( FILE *  F,
const Dtk_LinePtr &  inCurve 
)
5195  {
5196  fprintf( F, "<Dtk_LinePtr>" );
5197  fprintf( F, "<Origin>" );
5198  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inCurve->GetOrigin() );
5199  fprintf( F, "</Origin>" );
5200  fprintf( F, "<Direction>" );
5201  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inCurve->GetDirection() );
5202  fprintf( F, "</Direction>" );
5203  if( inCurve->IsTrimmed() )
5204  {
5205  fprintf( F, "<Points>" );
5206  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inCurve->GetTrimStartPoint() );
5207  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inCurve->GetTrimEndPoint() );
5208  fprintf( F, "</Points>" );
5209  }
5210  fprintf( F, "</Dtk_LinePtr>" );
5211  return dtkNoError;
5212  }

◆ Dtk_DumpXml_Dtk_LineTypeDefinitionPtr()

void Dtk_DumpXml_Dtk_LineTypeDefinitionPtr ( FILE *  F,
const Dtk_LineTypeDefinitionPtr &  inLineTypeDefinition 
)
4027  {
4028  if( inLineTypeDefinition.IsNotNULL() )
4029  {
4030  fprintf( F, "<Dtk_LineTypeDefinitionPtr>\n" );
4031 
4032  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, "Name", inLineTypeDefinition->GetName() );
4033 
4034  Dtk_DumpXml_Dtk_FontLineTypeEnum( F, inLineTypeDefinition->GetClosestAppearanceInFontLineTypeEnumeration(), "ClosestDtk_FontLineType" );
4035 
4036  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, "PatternLength", inLineTypeDefinition->GetPatternLength() );
4037  { // Pattern dump
4038  for( Dtk_Size_t i_pattern = 0; i_pattern < inLineTypeDefinition->GetPatternLength(); ++i_pattern )
4039  {
4040  fprintf( F, "<PatternDescriptor%zd>", i_pattern );
4041 
4042  Dtk_LineTypeDefinition::Dtk_LineTypePatternDescriptorType currentType;
4043  inLineTypeDefinition->GetPatternDescriptorTypeAtIndex( i_pattern, currentType );
4044 
4045  switch( currentType )
4046  {
4047  case Dtk_LineTypeDefinition::DTK_LINE_TYPE_PATTERN_DESCRIPTOR_DASH:
4048  {
4049  fprintf( F, "<PatternType>Dash</PatternType>" );
4050  Dtk_Double64 dashLength = -1;
4051  inLineTypeDefinition->GetPatternDescriptorDashAtIndex( i_pattern, dashLength );
4052  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, "Length", dashLength );
4053  break;
4054  }
4055  case Dtk_LineTypeDefinition::DTK_LINE_TYPE_PATTERN_DESCRIPTOR_DOT:
4056  {
4057  fprintf( F, "<PatternType>Dot</PatternType>" );
4058  break;
4059  }
4060  case Dtk_LineTypeDefinition::DTK_LINE_TYPE_PATTERN_DESCRIPTOR_GAP:
4061  {
4062  fprintf( F, "<PatternType>Gap</PatternType>" );
4063  Dtk_Double64 gapLength = -1;
4064  inLineTypeDefinition->GetPatternDescriptorGapAtIndex( i_pattern, gapLength );
4065  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, "Gap", gapLength );
4066  break;
4067  }
4068  default:
4069  Pdtk_Assert( false ); // Case was not implemented, to do.
4070  break;
4071  }
4072 
4073  fprintf( F, "</PatternDescriptor%zd>", i_pattern );
4074  }
4075  }
4076 
4077  { // Bold segments dump
4078  Dtk_Double64 outBoldSegmentsThickness, outBoldSegmentsLength;
4079  const bool hasBoldSegmentsOnChangeOfDirections = inLineTypeDefinition->GetBoldSegmentsOnChangeOfDirections( outBoldSegmentsThickness, outBoldSegmentsLength );
4080  if( hasBoldSegmentsOnChangeOfDirections )
4081  {
4082  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, "BoldSegmentsOnChangeOfDirectionsThickness", outBoldSegmentsThickness );
4083  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, "BoldSegmentsOnChangeOfDirectionsLength", outBoldSegmentsLength );
4084  }
4085  }
4086 
4087  fprintf( F, "</Dtk_LineTypeDefinitionPtr>\n" );
4088  }
4089  }

◆ Dtk_DumpXml_Dtk_LoopPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_LoopPtr ( FILE *  F,
const Dtk_LoopPtr &  inLoop 
)
6599  {
6600  Dtk_Size_t numCoedge, i;
6601  Dtk_bool orientation;
6602 
6603  fprintf( F, "<Dtk_LoopPtr>" );
6604  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inLoop->get_info() );
6605  // fprintf(F,"<Id>%d</Id>",inLoop->GetID());
6606  fprintf( F, "<loop_sens>%d</loop_sens>", inLoop->GetOrientation() );
6607  fprintf( F, "<loop_is_outer>%d</loop_is_outer>", inLoop->IsOuter() );
6608  numCoedge = inLoop->GetNumCoedges();
6609  for( i = 0; i < numCoedge; i++ )
6610  {
6611  Dtk_CoedgePtr coedge;
6612  inLoop->GetCoedge( i, coedge, orientation );
6613  fprintf( F, "<coedge_orientation_in_loop>%d</coedge_orientation_in_loop>", orientation );
6614  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CoedgePtr( F, coedge );
6615 
6616  }
6617  fprintf( F, "</Dtk_LoopPtr>" );
6618  return dtkNoError;
6619  }

◆ Dtk_DumpXml_Dtk_LumpPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_LumpPtr ( FILE *  F,
const Dtk_LumpPtr &  inLump 
)
6696  {
6697  Dtk_Size_t numVolume, i;
6698 
6699  fprintf( F, "<Dtk_LumpPtr>" );
6700  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inLump->get_info() );
6701  // fprintf(F,"<Id>%d</Id>",inLump->GetID());
6702  numVolume = inLump->GetNumVolumes();
6703  for( i = 0; i < numVolume; i++ )
6704  {
6705  Dtk_VolumePtr volume;
6706  inLump->GetVolume( i, volume );
6707  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_VolumePtr( F, volume );
6708 
6709  }
6710  fprintf( F, "</Dtk_LumpPtr>" );
6711  return dtkNoError;
6712  }

◆ Dtk_DumpXml_Dtk_MainDocPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr ( FILE *  F,
const Dtk_MainDocPtr &  inObject 
)
4625  {
4626  Dtk_DumpXml_Dtk_MainDocPtr_Init( F, inObject );
4627  if( inObject.IsNotNULL() )
4628  {
4629  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->RootComponent() );
4630  }
4631  else
4632  {
4633  fprintf( F, "Null" );
4634  }
4635  Dtk_DumpXml_Dtk_MainDocPtr_End( F, inObject );
4636  return dtkNoError;
4637  }

◆ Dtk_DumpXml_Dtk_MainDocPtr_End()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr_End ( FILE *  F,
const Dtk_MainDocPtr &  inObject 
)
4593  {
4594  if( inObject.IsNotNULL() )
4595  {
4596  if( inObject->IsMultiModel() )
4597  {
4598  fprintf( F, "<IsMultiModel>DTK_TRUE</IsMultiModel>\n" );
4599  }
4600  // List Additional files referenced by the document
4601  Dtk_tab<Dtk_string> additionalFiles;
4602  Dtk_ErrorStatus err = inObject->GetAdditionalReferenceList( additionalFiles );
4603  fprintf( F, "<AdditionnalReferences Num=\'" XmlFormat( "u" ) "\'>\n", additionalFiles.size() );
4604  for( const auto& file : additionalFiles )
4605  {
4606  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"AdditionnalComponentName", file );
4607  }
4608  fprintf( F, "</AdditionnalReferences>\n" );
4609 
4610  // List Missing files while reading the document
4611  Dtk_tab<Dtk_string> missingFiles;
4612  err = inObject->GetMissingComponentList( missingFiles );
4613  fprintf( F, "<MissingComponents Num=\'" XmlFormat( "u" ) "\'>\n", missingFiles.size() );
4614  for( const auto& file : missingFiles )
4615  {
4616  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"MissingComponentName", file );
4617  }
4618  fprintf( F, "</MissingComponents>\n" );
4619  }
4620  fprintf( F, "</Dtk_MainDocPtr>\n" );
4621  return dtkNoError;
4622  }

◆ Dtk_DumpXml_Dtk_MainDocPtr_Init()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr_Init ( FILE *  F,
const Dtk_MainDocPtr &  inObject 
)
4586  {
4587 
4588  fprintf( F, "<Dtk_MainDocPtr>\n" );
4589  return dtkNoError;
4590  }

◆ Dtk_DumpXml_Dtk_material()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_material ( FILE *  F,
const Dtk_MaterialPtr &  inMaterial 
)
3810  {
3811  Dtk_Size_t i, j, ii;
3812  Dtk_string myname_1 = L"";
3813  Dtk_string myname_2 = L"";
3814 
3815  if( inMaterial.IsNULL() )
3816  {
3817  return dtkNoError;
3818  }
3819 
3820  // MATERIAL
3821  fprintf( F, "<Dtk_MaterialPtr>\n" );
3822  myname_1 = inMaterial->label;
3823  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"label", myname_1 );
3824  fprintf( F, "<ambient>%lf</ambient>\n", inMaterial->ambient );
3825  fprintf( F, "<reflectivity>%lf</reflectivity>\n", inMaterial->reflectivity );
3826  fprintf( F, "<refraction>%lf</refraction>\n", inMaterial->refraction );
3827  fprintf( F, "<roughness>%lf</roughness>\n", inMaterial->roughness );
3828  fprintf( F, "<specular>%lf</specular>\n", inMaterial->specular );
3829  fprintf( F, "<diffuse>%lf</diffuse>\n", inMaterial->diffuse );
3830  fprintf( F, "<repeat_u>%d</repeat_u>\n", inMaterial->repeat_u );
3831  fprintf( F, "<repeat_v>%d</repeat_v>\n", inMaterial->repeat_v );
3832  Dtk_string texture = inMaterial->texture.c_str();
3833  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"texture", texture );
3834 
3835  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Picture( F, inMaterial->picture );
3836 
3837  // RENDERING
3838  if( inMaterial->rendering )
3839  {
3840  fprintf( F, "<Dtk_rendering>\n" );
3841  if( inMaterial->rendering->value.size() > 0 )
3842  {
3843  myname_1 = inMaterial->rendering->name;
3844  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_1 );
3845  for( i = 0; i < inMaterial->rendering->value.size(); i++ )
3846  {
3847  myname_2 = inMaterial->rendering->value.at( i ).NameProperties;
3848  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_2 );
3849  for( j = 0; j < inMaterial->rendering->value.at( i ).PropertiesValue.size(); j++ )
3850  {
3851  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, inMaterial->rendering->value.at( i ).PropertiesValue.at( j ) );
3852  }
3853  }
3854  }
3855  fprintf( F, "</Dtk_rendering>\n" );
3856  }
3857 
3858  // DRAFTING
3859  if( inMaterial->drafting )
3860  {
3861  fprintf( F, "<Dtk_drafting>\n" );
3862  myname_1 = inMaterial->drafting->name;
3863  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_1 );
3864  for( i = 0; i < inMaterial->drafting->value.size(); i++ )
3865  {
3866  Dtk_material_value value = inMaterial->drafting->value.at( i );
3867  myname_2 = value.NameProperties;
3868  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_2 );
3869  Dtk_tab<Dtk_Val > tab = value.PropertiesValue;
3870  for( j = 0; j < tab.size(); j++ )
3871  {
3872  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, tab.at( j ) );
3873  }
3874  }
3875 
3876  fprintf( F, "<Dtk_drw>\n" );
3877  for( ii = 0; ii < inMaterial->drafting->drw.size(); ii++ )
3878  {
3879  myname_1 = inMaterial->drafting->drw.at( ii )->name;
3880  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_1 );
3881  for( i = 0; i < inMaterial->drafting->drw.at( ii )->value.size(); i++ )
3882  {
3883  Dtk_material_value value = inMaterial->drafting->drw.at( ii )->value.at( i );
3884  myname_2 = value.NameProperties;
3885  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_2 );
3886  Dtk_tab<Dtk_Val > tab = value.PropertiesValue;
3887  for( j = 0; j < tab.size(); j++ )
3888  {
3889  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, tab.at( j ) );
3890  }
3891  }
3892 
3893  if( inMaterial->drafting->drw.size() > 0 )
3894  {
3895  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Picture( F, inMaterial->drafting->drw.at( ii )->picture );
3896  }
3897  }
3898  fprintf( F, "</Dtk_drw>\n" );
3899  fprintf( F, "</Dtk_drafting>\n" );
3900  }
3901 
3902  // COMPOSITE
3903  if( inMaterial->composites )
3904  {
3905  fprintf( F, "<Dtk_composite>\n" );
3906  myname_1 = inMaterial->composites->name;
3907  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_1 );
3908  for( i = 0; i < inMaterial->composites->value.size(); i++ )
3909  {
3910  myname_2 = inMaterial->composites->value.at( i ).NameProperties;
3911  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_2 );
3912  for( j = 0; j < inMaterial->composites->value.at( i ).PropertiesValue.size(); j++ )
3913  {
3914  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, inMaterial->composites->value.at( i ).PropertiesValue.at( j ) );
3915  }
3916  }
3917  fprintf( F, "</Dtk_composite>\n" );
3918  }
3919 
3920 
3921  // ANALYSIS
3922  if( inMaterial->analysis )
3923  {
3924  fprintf( F, "<Dtk_analysis>\n" );
3925  myname_1 = inMaterial->analysis->name;
3926  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_1 );
3927  for( i = 0; i < inMaterial->analysis->value.size(); i++ )
3928  {
3929  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_2 );
3930  for( j = 0; j < inMaterial->analysis->value.at( i ).PropertiesValue.size(); j++ )
3931  {
3932  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, inMaterial->analysis->value.at( i ).PropertiesValue.at( j ) );
3933  }
3934  }
3935  fprintf( F, "</Dtk_analysis>\n" );
3936  }
3937 
3938  // POSITIONNED
3939  if( inMaterial->positioned )
3940  {
3941  fprintf( F, "<Dtk_positioned>\n" );
3942  Dtk_pnt pnt;
3943  Dtk_dir dir;
3944  myname_1 = inMaterial->positioned->name;
3945  if( myname_1.len() > 0 )
3946  {
3947  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_1 );
3948  }
3949  for( i = 0; i < inMaterial->positioned->value.size(); i++ )
3950  {
3951  myname_2 = inMaterial->positioned->value.at( i ).NameProperties;
3952  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", myname_2 );
3953  for( j = 0; j < inMaterial->positioned->value.at( i ).PropertiesValue.size(); j++ )
3954  {
3955  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, inMaterial->positioned->value.at( i ).PropertiesValue.at( j ) );
3956  }
3957  }
3958 
3959  if( inMaterial->positioned->matrix )
3960  {
3961  fprintf( F, "<Transfo_matrix>\n" );
3962  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, *( inMaterial->positioned->matrix ) );
3963  fprintf( F, "</Transfo_matrix>\n" );
3964  }
3965  fprintf( F, "</Dtk_positioned>\n" );
3966  }
3967  fprintf( F, "</Dtk_MaterialPtr>\n" );
3968 
3969  return dtkNoError;
3970  }

◆ Dtk_DumpXml_Dtk_MeshLightPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshLightPtr ( FILE *  F,
const Dtk_MeshPtr &  inMesh 
)
6801  {
6802 
6803  double MeshArea = 0.0;
6804  Dtk_Size_t NbMeshTriangles = 0;
6805  Dtk_ID id = 0;
6806  if( inMesh->get_info().IsNotNULL() )
6807  id = inMesh->get_info()->GetId();
6808 
6809  fprintf( F, "<Dtk_MeshPtr id = \"%d\">\n", id );
6810  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inMesh->info() );
6811 
6812  Dtk_Size_t NbMeshFaces = inMesh->get_nb_mesh_face();
6813 
6814  for( Dtk_Size_t iMeshFace = 0; iMeshFace < NbMeshFaces; iMeshFace++ )
6815  {
6816  double MeshFaceArea = 0.0;
6817  Dtk_mesh_face *curMeshFace = inMesh->get_mesh_face( iMeshFace );
6818  Dtk_Size_t NbTriangles = curMeshFace->get_nbtriangles();
6819  NbMeshTriangles += NbTriangles;
6820  for( Dtk_Size_t iTriangle = 0; iTriangle < NbTriangles; iTriangle++ )
6821  {
6822  const Dtk_UInt32 *pnt;
6823  pnt = curMeshFace->get_triangle_indices( iTriangle );
6824  Dtk_pnt pt1 = inMesh->get_vertex( pnt[ 0 ] );
6825  Dtk_pnt pt2 = inMesh->get_vertex( pnt[ 1 ] );
6826  Dtk_pnt pt3 = inMesh->get_vertex( pnt[ 2 ] );
6827  double a = sqrt( ( ( pt2[ 0 ] - pt1[ 0 ] ) * ( pt2[ 0 ] - pt1[ 0 ] ) ) +
6828  ( ( pt2[ 1 ] - pt1[ 1 ] ) * ( pt2[ 1 ] - pt1[ 1 ] ) ) +
6829  ( ( pt2[ 2 ] - pt1[ 2 ] ) * ( pt2[ 2 ] - pt1[ 2 ] ) ) );
6830  double b = sqrt( ( ( pt3[ 0 ] - pt2[ 0 ] ) * ( pt3[ 0 ] - pt2[ 0 ] ) ) +
6831  ( ( pt3[ 1 ] - pt2[ 1 ] ) * ( pt3[ 1 ] - pt2[ 1 ] ) ) +
6832  ( ( pt3[ 2 ] - pt2[ 2 ] ) * ( pt3[ 2 ] - pt2[ 2 ] ) ) );
6833  double c = sqrt( ( ( pt1[ 0 ] - pt3[ 0 ] ) * ( pt1[ 0 ] - pt3[ 0 ] ) ) +
6834  ( ( pt1[ 1 ] - pt3[ 1 ] ) * ( pt1[ 1 ] - pt3[ 1 ] ) ) +
6835  ( ( pt1[ 2 ] - pt3[ 2 ] ) * ( pt1[ 2 ] - pt3[ 2 ] ) ) );
6836  double p = a + b + c;
6837  double tmp = ( p * ( p - 2.0 * a ) * ( p - 2.0 * b ) * ( p - 2.0 * c ) ) / 16.0;
6838  if( tmp > 0.0 )
6839  MeshFaceArea += sqrt( tmp );
6840  }
6841  fprintf( F, "<Dtk_mesh_face id = \"%d\" nb_triangles = \"" XmlFormat( "u" )"\" area = \"%f\">\n", curMeshFace->get_id(), NbTriangles, MeshFaceArea );
6842  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, curMeshFace->info() );
6843  fprintf( F, "</Dtk_mesh_face>\n" );
6844  MeshArea += MeshFaceArea;
6845  }
6846 
6847  fprintf( F, "<ValidationProperties nb_triangles = \"" XmlFormat( "u" )"\" area = \"%f\"/>\n", NbMeshTriangles, MeshArea );
6848  fprintf( F, "</Dtk_MeshPtr>\n" );
6849 
6850  return dtkNoError;
6851 
6852  }

◆ Dtk_DumpXml_Dtk_MeshPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshPtr ( FILE *  F,
const Dtk_MeshPtr &  inMesh 
)
6856  {
6857  Dtk_ID id = 0;
6858  if( inMesh->get_info().IsNotNULL() )
6859  id = inMesh->get_info()->GetId();
6860 
6861  fprintf( F, "<Dtk_MeshPtr>\n" );
6862  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inMesh->info() );
6863 
6864  Dtk_Size_t iVert, NbVert = inMesh->get_nb_vertices();
6865 
6866  fprintf( F, "<Vertices nb = \"" XmlFormat( "u" )"\">\n", NbVert );
6867  for( iVert = 0; iVert < NbVert; iVert++ )
6868  {
6869  Dtk_pnt pt = inMesh->get_vertex( iVert );
6870  fprintf( F, "<Vertex id = \"" XmlFormat( "u" )"\" X = \"%lf\" Y = \"%lf\" Z = \"%lf\">", iVert, pt[ 0 ], pt[ 1 ], pt[ 2 ] );
6871  fprintf( F, "</Vertex>\n" );
6872  }
6873  fprintf( F, "</Vertices>\n" );
6874 
6875 
6876  Dtk_Size_t NbMeshFaces = inMesh->get_nb_mesh_face();
6877  fprintf( F, "<MeshFaces nb =\"" XmlFormat( "u" )"\">\n", NbMeshFaces );
6878 
6879  for( Dtk_Size_t iMeshFace = 0; iMeshFace < NbMeshFaces; iMeshFace++ )
6880  {
6881  const Dtk_UInt32 *pnt;
6882  Dtk_mesh_face *curMeshFace = inMesh->get_mesh_face( iMeshFace );
6883  Dtk_Size_t NbTriangles = curMeshFace->get_nbtriangles();
6884  fprintf( F, "<Dtk_mesh_face>\n" );
6885  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, curMeshFace->info() );
6886  if( NbTriangles > 0 )
6887  {
6888  fprintf( F, "<Triangles nb = \"" XmlFormat( "u" )"\">\n", NbTriangles );
6889  for( Dtk_Size_t iTriangle = 0; iTriangle < NbTriangles; iTriangle++ )
6890  {
6891  pnt = curMeshFace->get_triangle_indices( iTriangle );
6892  fprintf( F, "<Triangle id = \"" XmlFormat( "u" )"\" vertices = \"%d , %d , %d\" >", iTriangle, pnt[ 0 ], pnt[ 1 ], pnt[ 2 ] );
6893  fprintf( F, "</Triangle>\n" );
6894  }
6895  fprintf( F, "</Triangles>\n" );
6896  }
6897 
6898  Dtk_Size_t NbTriFan = curMeshFace->get_nbtriangle_fans();
6899  if( NbTriFan > 0 )
6900  {
6901 
6902  fprintf( F, "<TriFans nb = \"" XmlFormat( "u" )"\">\n", NbTriFan );
6903  for( Dtk_Size_t iTriFanIdx = 0; iTriFanIdx < NbTriFan; iTriFanIdx++ )
6904  {
6905  const Dtk_tab<Dtk_ID> *tabIndices;
6906  tabIndices = curMeshFace->get_triangle_fan_indices( iTriFanIdx );
6907  fprintf( F, "<TriFan id = \"" XmlFormat( "u" )"\" indices = \" ", iTriFanIdx );
6908  for( int iIndex = 0; iIndex < tabIndices->size(); iIndex++ )
6909  {
6910  fprintf( F, "%d", ( *tabIndices )[ iIndex ] );
6911  if( iIndex < tabIndices->size() - 1 )
6912  {
6913  fprintf( F, " , " );
6914  }
6915  }
6916  fprintf( F, " \" >" );
6917  fprintf( F, "</TriFan>\n" );
6918  }
6919  fprintf( F, "</TriFans>\n" );
6920  }
6921 
6922  Dtk_Size_t NbTriStrip = curMeshFace->get_nbtriangle_strips();
6923  if( NbTriStrip > 0 )
6924  {
6925 
6926  fprintf( F, "<TriStrips nb = \"" XmlFormat( "u" )"\">\n", NbTriStrip );
6927  for( Dtk_Size_t iTriStripIdx = 0; iTriStripIdx < NbTriStrip; iTriStripIdx++ )
6928  {
6929  const Dtk_tab<Dtk_ID> *tabIndices;
6930  tabIndices = curMeshFace->get_triangle_strip_indices( iTriStripIdx );
6931  fprintf( F, "<TriStrip id = \"" XmlFormat( "u" )"\" indices = \" ", iTriStripIdx );
6932  for( int iIndex = 0; iIndex < tabIndices->size(); iIndex++ )
6933  {
6934  fprintf( F, "%d", ( *tabIndices )[ iIndex ] );
6935  if( iIndex < tabIndices->size() - 1 )
6936  {
6937  fprintf( F, " , " );
6938  }
6939  }
6940  fprintf( F, " \" >" );
6941  fprintf( F, "</TriStrip>\n" );
6942  }
6943  fprintf( F, "</TriStrips>\n" );
6944  }
6945 
6946  Dtk_Size_t NbPoly = curMeshFace->get_nbpolylines();
6947  if( NbPoly > 0 )
6948  {
6949  fprintf( F, "<Polylines nb =\"" XmlFormat( "u" )"\">\n", NbPoly );
6950  for( Dtk_Size_t iPoly = 0; iPoly < NbPoly; iPoly++ )
6951  {
6952  Dtk_Val dtk_val;
6953  int topoid = 0;
6954  if( curMeshFace->get_nbsubinfos() > 0 )
6955  {
6956  Dtk_InfoPtr inf = curMeshFace->get_subinfo( iPoly );
6957  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inf );
6958  if( inf->FindAttribute( "TOPO_ID_EDGE", dtk_val ) == dtkNoError )
6959  topoid = dtk_val.GetInt();
6960  }
6961 
6962  const Dtk_tab<Dtk_UInt32> *pntpol;
6963  pntpol = curMeshFace->get_polyline_indices( iPoly );
6964  Dtk_Size_t nbpnt;
6965  nbpnt = pntpol->size();
6966 
6967  fprintf( F, "<Polyline id = \"" XmlFormat( "u" )"\" idtopo = \"%i\" vertices = \"", iPoly, topoid );
6968  for( Dtk_Size_t j = 0; j < nbpnt; j++ )
6969  {
6970  fprintf( F, " %d , ", ( *pntpol )[ j ] );
6971  }
6972  fprintf( F, "\"></Polyline>\n" );
6973  }
6974  fprintf( F, "</Polylines>\n" );
6975  }
6976 
6977  fprintf( F, "</Dtk_mesh_face>\n" );
6978 
6979  }
6980  fprintf( F, "</MeshFaces>\n" );
6981 
6982  Dtk_StreamPtr stream;
6983  stream = inMesh->GetStream();
6984  if( stream.IsNotNULL() )
6985  {
6986  Dtk_Val val;
6987  if( inMesh->get_info()->FindAttribute( L"Dtk_NxIndexColor", val ) == dtkNoError )
6988  {
6989  Dtk_tab<Dtk_Int32> ArrayColor = val.GetIntArray();
6990 
6991  fprintf( F, "<Dtk_NxIndexColor Num=\'" XmlFormat( "u" ) "\'>\n", ArrayColor.size() );
6992 
6993  for( size_t i = 0; i < ArrayColor.size(); i++ )
6994  {
6995  Dtk_RGB rgb;
6996  Dtk_API::GetAPI()->GetColorInTable( ArrayColor[ i ], rgb );
6997  Dtk_DumpXml_Dtk_RGB( F, rgb );
6998  }
6999  fprintf( F, "</Dtk_NxIndexColor>\n" );
7000 
7001  }
7002  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_StreamPtr( F, stream );
7003  }
7004 
7005  fprintf( F, "</Dtk_MeshPtr>\n" );
7006 
7007  return dtkNoError;
7008 
7009  }

◆ Dtk_DumpXml_Dtk_MeshSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshSurfacePtr ( FILE *  F,
const Dtk_MeshSurfacePtr &  inMeshSurface 
)
6389  {
6390  fprintf( F, "<Dtk_MeshSurfacePtr>\n" );
6391  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MeshPtr( F, inMeshSurface->GetMesh() );
6392  fprintf( F, "</Dtk_MeshSurfacePtr>\n" );
6393  return dtkNoError;
6394  }

◆ Dtk_DumpXml_Dtk_MetaDataGroup()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetaDataGroup ( const Dtk_MetaDataGroupPtr &  m)
5184  {
5185  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataGroupPtr( dump_file, m );
5186  }

◆ Dtk_DumpXml_Dtk_MetadataGroupPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataGroupPtr ( FILE *  F,
const Dtk_MetaDataGroupPtr &  inObject 
)
5099  {
5100  if( F == NULL )
5101  {
5102  return dtkErrorOpenFiles;
5103  }
5104 
5105 
5106  fprintf( F, "<Dtk_MetaDataGroupPtr>\n" );
5107 
5108  if( inObject.IsNULL() )
5109  {
5110  fprintf( F, "'Null'" );
5111  fprintf( F, "</Dtk_MetaDataGroupPtr>\n" );
5112  return dtkNoError;
5113  }
5114 
5115  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"GroupName", inObject->GetGroupName() );
5116 
5117  Dtk_tab<Dtk_MetaDataPtr> list_metadata = inObject->GetListOfMetadatas();
5118 
5119  Dtk_Size_t size = list_metadata.size();
5120 
5121  for( Dtk_Size_t i = 0; i < size; ++i )
5122  {
5123  Dtk_DumpXml_Dtk_MetadataPtr( F, list_metadata[ i ] );
5124  }
5125 
5126  fprintf( F, "</Dtk_MetaDataGroupPtr>\n" );
5127 
5128  return dtkNoError;
5129  }

◆ Dtk_DumpXml_Dtk_MetadataPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataPtr ( FILE *  F,
const Dtk_MetaDataPtr &  inObject 
)
5036  {
5037  if( F == NULL )
5038  {
5039  return dtkErrorOpenFiles;
5040  }
5041 
5042  fprintf( F, "<Dtk_MetaDataPtr>\n" );
5043  if( inObject.IsNotNULL() )
5044  {
5045  Dtk_string outFormula;
5046  Dtk_string outEstimatedValue;
5047  Dtk_string outTitle;
5048  Dtk_string outResultType;
5049 
5050  Dtk_MetaData::MetaDataTypeEnum MetaDataType = inObject->MetaDataType();
5051  Dtk_DumpXMLNamespace::Dtk_DumpXml_MetaDataTypeEnum( F, MetaDataType, L"MetaDataType" );
5052  if( inObject->GetFormula( outFormula, outEstimatedValue, outTitle, outResultType ) == dtkNoError )
5053  {
5054  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Formula", outFormula );
5055  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"EstimatedValue", outEstimatedValue );
5056  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", outTitle );
5057  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"ResultType", outResultType );
5058  }
5059  else
5060  {
5061  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", inObject->GetTitle() );
5062 
5063  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Type", inObject->GetType() );
5064  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Value", inObject->GetValue() );
5065 
5066  Dtk_string unit;
5067  Dtk_ErrorStatus err = inObject->GetUnits( unit );
5068  if( err == dtkNoError )
5069  {
5070  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Units", unit );
5071  }
5072  if( inObject->GetCategory().len() > 0 )
5073  {
5074  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Category", inObject->GetCategory() );
5075  }
5076  //if (inObject->IsTime_t())
5077  //{
5078  // Dtk_string val = inObject->GetValue();
5079  // int timeint = atoi(val.c_str());
5080  // time_t time;
5081  // time = (time_t)timeint;
5082  // char buffer[100];
5083  // memset(buffer, 0, sizeof(buffer));
5084  // ctime_s(buffer, 100, &time);
5085  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Value(F, L"TIME_T", Dtk_string(buffer));
5086 
5087  //}
5088  }
5089  }
5090  else
5091  {
5092  fprintf( F, "'Null'" );
5093  }
5094  fprintf( F, "</Dtk_MetaDataPtr>\n" );
5095  return dtkNoError;
5096  }

◆ Dtk_DumpXml_Dtk_ModelDisplayPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ModelDisplayPtr ( FILE *  F,
const Dtk_ModelDisplayPtr &  inVal 
)
3172  {
3173  fprintf( F, "<Dtk_ModelDisplay>\n" );
3174  if( inVal.IsNotNULL() )
3175  {
3176  fprintf( F, "<IsActivated>%s</IsActivated>\n", inVal->IsActivated() == DTK_TRUE ? "True" : "False" );
3177  if( inVal->GetIsStandardView() )
3178  {
3179  fprintf( F, "<StandardView>True</StandardView>\n" );
3180  } //info
3181  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->info() );
3182  //Camera
3183  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CameraPtr( F, inVal->GetCamera() );
3184  //Clipping Plane
3185  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EntityPtr( F, inVal->GetClippingEntity() );
3186 
3187  Dtk_ModelDisplay::RenderingModeEnum renderingmode = inVal->GetRenderingMode();
3188 
3189  switch( renderingmode )
3190  {
3191  case Dtk_ModelDisplay::rendering_mode_shaded_only:
3192  {
3193  fprintf( F, "<RenderingModeEnum>rendering_mode_shaded_only</RenderingModeEnum>\n" );
3194  break;
3195  }
3196  case Dtk_ModelDisplay::rendering_mode_shaded_with_visible_edges:
3197  {
3198  fprintf( F, "<RenderingModeEnum>rendering_mode_shaded_with_visible_edges</RenderingModeEnum>\n" );
3199  break;
3200  }
3201  case Dtk_ModelDisplay::rendering_mode_studio:
3202  {
3203  fprintf( F, "<RenderingModeEnum>rendering_mode_studio</RenderingModeEnum>\n" );
3204  break;
3205  }
3206  case Dtk_ModelDisplay::rendering_mode_wireframe_with_all_edges:
3207  {
3208  fprintf( F, "<RenderingModeEnum>rendering_mode_wireframe_with_all_edges</RenderingModeEnum>\n" );
3209  break;
3210  }
3211  case Dtk_ModelDisplay::rendering_mode_wireframe_with_only_visible_edges:
3212  {
3213  fprintf( F, "<RenderingModeEnum>rendering_mode_wireframe_with_only_visible_edges</RenderingModeEnum>\n" );
3214  break;
3215  }
3216  case Dtk_ModelDisplay::rendering_mode_static_wireframe:
3217  {
3218  fprintf( F, "<RenderingModeEnum>rendering_mode_static_wireframe</RenderingModeEnum>\n" );
3219  break;
3220  }
3221  case Dtk_ModelDisplay::rendering_mode_wireframe_face_analysis:
3222  {
3223  fprintf( F, "<RenderingModeEnum>rendering_mode_wireframe_face_analysis</RenderingModeEnum>\n" );
3224  break;
3225  }
3226  case Dtk_ModelDisplay::rendering_mode_wireframe_partially_shade:
3227  {
3228  fprintf( F, "<RenderingModeEnum>rendering_mode_wireframe_partially_shade</RenderingModeEnum>\n" );
3229  break;
3230  }
3231  default:
3232  break;
3233  }
3234 
3235 
3236  Dtk_ModelDisplay::SectionTypeEnum SectionType;
3237  Dtk_Int32 IsLocked = DTK_FALSE;
3238  Dtk_Double64 Thickness = 0.0;
3239 
3240  inVal->GetSectionInformation( SectionType, IsLocked, Thickness );
3241  if( SectionType != Dtk_ModelDisplay::SectionPlane )
3242  {
3243  if( SectionType == Dtk_ModelDisplay::SectionParallelePlane )
3244  {
3245  fprintf( F, "<SectionType>SectionParallelePlane</SectionType>\n" );
3246  fprintf( F, "<Thickness>%f</Thickness>\n", Thickness );
3247  }
3248  else
3249  {
3250  if( SectionType == Dtk_ModelDisplay::SectionBox )
3251  {
3252  fprintf( F, "<SectionType>SectionBox</SectionType>\n" );
3253  }
3254  else
3255  {
3256  if( SectionType == Dtk_ModelDisplay::SectionBody )
3257  {
3258  fprintf( F, "<SectionType>SectionBody</SectionType>\n" );
3259  }
3260  else
3261  {
3262  if( SectionType == Dtk_ModelDisplay::SectionPlaneList )
3263  {
3264  fprintf( F, "<SectionType>SectionPlaneList</SectionType>\n" );
3265  }
3266  }
3267  }
3268  }
3269  }
3270  Dtk_tab<Dtk_Int32> VisibleLayers;
3271  inVal->GetVisibleLayers( VisibleLayers );
3272  if( VisibleLayers.size() > 0 )
3273  {
3274  fprintf( F, "<VisibleLayers>\n" );
3275 
3276  for( Dtk_Size_t i = 0; i < VisibleLayers.size(); i++ )
3277  {
3278  if( VisibleLayers[ i ] == 1 )
3279  {
3280  fprintf( F, "\"" XmlFormat( "u" )"\",\n", i );
3281  }
3282  }
3283  fprintf( F, "</VisibleLayers>\n" );
3284  }
3285  }
3286  else
3287  {
3288  fprintf( F, "Null" );
3289  }
3290  fprintf( F, "</Dtk_ModelDisplay>\n" );
3291  return dtkNoError;
3292  }

◆ Dtk_DumpXml_Dtk_NodeConnector()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodeConnector ( FILE *  inFile,
const Dtk_NodeConnectorPtr &  inNodeConnector 
)
7013  {
7014 
7015  Dtk_ErrorStatus dst = dtkNoError;
7016  Dtk_string ConnectorType;
7017 
7018  if( inNodeConnector.IsNULL() )
7019  {
7020  return dtkErrorNullPointer;
7021  }
7022 
7023  Dtk_tab< Dtk_NodeConnector::SubEntity > SubEntities;
7024  Dtk_tab<Dtk_ID> ComponentPathId;
7025  Dtk_ID NodeId = inNodeConnector->GetNodeId();
7026  inNodeConnector->GetSubEntities( SubEntities );
7027  inNodeConnector->GetAssociatedPathComponentID( ComponentPathId );
7028  Dtk_Node::FullType NodeFullType = inNodeConnector->GetPointingEntityType();
7029  Dtk_Size_t NumSubEntities = SubEntities.size();
7030  Dtk_Size_t NumComp = ComponentPathId.size();
7031 
7032 
7033  if( NumComp <= 1 ) //if only 1 component => Local Component or Prototype
7034  {
7035  ConnectorType = L"Prototype";
7036  }
7037  else
7038  {
7039  ConnectorType = L"ComponentPathId";
7040  }
7041  if( NodeId > 0 )
7042  {
7043  ConnectorType += L" + Node";
7044  }
7045  if( NumSubEntities > 0 )
7046  {
7047  ConnectorType += L" + SubEntities";
7048  }
7049 
7050  fprintf( inFile, "<Dtk_NodeConnector Type=\"%s\">\n", ConnectorType.c_str() );
7051 
7052  Dtk_NodeConnector::ReasonCategoryEnum ReasonCategory;
7053  Dtk_NodeConnector::ReasonLinkEnum ReasonLink = inNodeConnector->GetReasonLink( ReasonCategory );
7054  fprintf( inFile, "<ReasonLink>\"%s\"</ReasonLink>\n", Dtk_NodeConnector::ReasonLinkEnumToString( ReasonLink ).c_str() );
7055  // fprintf(inFile, "<ReasonCategory>\"%s\"</ReasonCategory>\n", Dtk_NodeConnector::ReasonCategoryEnumToString( ReasonCategory ).c_str() );
7056 
7057  if( ReasonLink == Dtk_NodeConnector::ForceColor )
7058  {
7059  fprintf( inFile, "<ColorId>%d</ColorId>\n", inNodeConnector->GetColorId() );
7060  }
7061  if( ReasonLink == Dtk_NodeConnector::ForceRender )
7062  {
7063  fprintf( inFile, "<RenderId>%d</RenderId>\n", inNodeConnector->GetRenderId() );
7064  }
7065 
7066  fprintf( inFile, "<PathCompId>" );
7067  if( NumComp > 0 )
7068  {
7069  Dtk_Size_t i;
7070  for( i = 0; i < NumComp; i++ ) fprintf( inFile, "%d ", ComponentPathId[ i ] );
7071  }
7072  else
7073  {
7074  fprintf( inFile, "LocalComponent" );
7075  }
7076  fprintf( inFile, "</PathCompId>\n" );
7077 
7078 
7079  if( NodeId > 0 )
7080  fprintf( inFile, "<NodeID>%d</NodeID>\n", NodeId );
7081  Dtk_DumpXMLNamespace::Dtk_DumpXml_NodeFullType( inFile, NodeFullType, L"PointingEntityType" );
7082  fprintf( inFile, "<PointedEntityType>%s</PointedEntityType>\n", typedetkToDtk_string( inNodeConnector->GetPointedEntityType() ).c_str() );
7083  //SubEntities
7084  if( NumSubEntities )
7085  {
7086  fprintf( inFile, "<SubEntities Num=\"" XmlFormat( "u" )"\">", NumSubEntities );
7087  for( Dtk_Size_t i = 0; i < NumSubEntities; i++ )
7088  {
7089  Dtk_NodeConnector::SubEntity TmpSub = SubEntities[ i ];
7090  fprintf( inFile, "<SubEntity id=\"%d\" type=\"%s\" ></SubEntity>\n",
7091  TmpSub.GetSubEntityId(),
7092  typedetkToDtk_string( TmpSub.GetSubEntityType() ).c_str() );
7093  }
7094  fprintf( inFile, "</SubEntities>\n" );
7095  }
7096  fprintf( inFile, "</Dtk_NodeConnector>\n" );
7097  return dst;
7098  }

◆ Dtk_DumpXml_Dtk_NodePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr ( FILE *  F,
const Dtk_NodePtr &  inObject 
)
4641  {
4642 
4643  fprintf( F, "<Dtk_NodePtr>\n" );
4644  if( inObject.IsNotNULL() )
4645  {
4646  Dtk_Node::NodeDataTypeEnum NodeType = inObject->GetNodeType();
4647  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4648  Dtk_DumpXMLNamespace::Dtk_DumpXml_NodeTypeEnum( F, NodeType, L"NodeType" );
4649  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"NodeSubType", typedetkToDtk_string( inObject->GetNodeSubType() ) );
4650 
4651  fprintf( F, "<NodeID>%u</NodeID>\n", inObject->GetID() );
4652  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4653  Dtk_StoredInfoPtr sti = inObject->GetStoredInfos();
4654  if( sti.IsNotNULL() )
4655  {
4656  fprintf( F, "<StoredInfos>\n" );
4657  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, Dtk_InfoPtr::DtkDynamicCast( sti ) );
4658  fprintf( F, "</StoredInfos>\n" );
4659  }
4660 
4661  Dtk_Size_t i, NumChildren;
4662  NumChildren = inObject->GetNumChildren();
4663 
4664  for( i = 0; i < NumChildren; i++ )
4665  {
4666  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NodePtr( F, inObject->GetChild( i ) );
4667  }
4668  Dtk_Size_t NumMetaData;
4669  NumMetaData = inObject->GetNumMetaData();
4670  if( NumMetaData )
4671  {
4672  fprintf( F, "<Dtk_MetaData Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaData );
4673  for( i = 0; i < NumMetaData; i++ )
4674  {
4675  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr( F, inObject->GetMetaData( i ) );
4676  }
4677  fprintf( F, "</Dtk_MetaData>\n" );
4678 
4679  }
4680 #ifdef XML_GROUP_METADATA
4681  Dtk_Size_t NumMetaDataGroup;
4682  NumMetaDataGroup = inObject->GetNumMetaDataGroup();
4683  if( NumMetaDataGroup )
4684  {
4685  fprintf( F, "<Dtk_MetaDataGroup Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaDataGroup );
4686  for( i = 0; i < NumMetaDataGroup; i++ )
4687  {
4688  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataGroupPtr( F, inObject->GetMetaDataGroup( i ) );
4689  }
4690  fprintf( F, "</Dtk_MetaDataGroup>\n" );
4691  }
4692 #endif
4693  Dtk_tab< Dtk_NodeConnectorPtr > AssociatedEntities;
4694  inObject->GetAssociatedEntities( AssociatedEntities );
4695  Dtk_Size_t NumConnector = AssociatedEntities.size();
4696  if( NumConnector )
4697  {
4698  fprintf( F, "<NodeConnectors Num=\'" XmlFormat( "u" ) "\'>\n", NumConnector );
4699 
4700  for( i = 0; i < NumConnector; i++ )
4701  {
4702  Dtk_DumpXml_Dtk_NodeConnector( F, AssociatedEntities[ i ] );
4703  }
4704  fprintf( F, "</NodeConnectors>\n" );
4705 
4706  }
4707  }
4708  else
4709  {
4710  fprintf( F, "<Null></Null>\n" );
4711  }
4712  fprintf( F, "</Dtk_NodePtr>\n" );
4713  return dtkNoError;
4714  }

◆ Dtk_DumpXml_Dtk_NodePtr_End()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr_End ( FILE *  F)
4816  {
4817  if( F == NULL )
4818  {
4819  return dtkErrorNullPointer;
4820  }
4821  fprintf( F, "</Dtk_NodePtr>\n" );
4822  return dtkNoError;
4823  }

◆ Dtk_DumpXml_Dtk_NodePtr_Init()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr_Init ( FILE *  F,
const Dtk_NodePtr &  inObject 
)
4717  {
4718  if( F == NULL )
4719  {
4720  return dtkErrorNullPointer;
4721  }
4722  Dtk_Size_t i = 0;
4723  fprintf( F, "<Dtk_NodePtr>\n" );
4724  if( inObject.IsNotNULL() )
4725  {
4726  fprintf( F, "<NodeID>%u</NodeID>\n", inObject->GetID() );
4727  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4728  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4729  Dtk_ID FatherID = inObject->GetFatherID( 0 );
4730  if( FatherID )
4731  fprintf( F, "<FatherID>%u</FatherID>\n", FatherID );
4732 
4733  Dtk_Node::NodeDataTypeEnum NodeType = inObject->GetNodeType();
4734  Dtk_DumpXMLNamespace::Dtk_DumpXml_NodeTypeEnum( F, NodeType, L"NodeType" );
4735  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"NodeSubType", typedetkToDtk_string( inObject->GetNodeSubType() ) );
4736  if( inObject->NodeHasAxis() )
4737  fprintf( F, "<HasAxis>1</HasAxis>\n" );
4738  if( inObject->NodeHasPoints() )
4739  fprintf( F, "<HasPoints>1</HasPoints>\n" );
4740  if( inObject->NodeHasCurves() )
4741  fprintf( F, "<HasCurves>1</HasCurves>\n" );
4742  if( inObject->NodeHasSurfaces() )
4743  fprintf( F, "<HasSurfaces>1</HasSurfaces>\n" );
4744  if( inObject->NodeHasSolids() )
4745  fprintf( F, "<HasSolids>1</HasSolids>\n" );
4746  if( inObject->NodeHasMesh() )
4747  fprintf( F, "<HasMesh>1</HasMesh>\n" );
4748  if( inObject->NodeHasMeshSurfaces() )
4749  fprintf( F, "<HasMeshSurfaces>1</HasMeshSurfaces>\n" );
4750 
4751  Dtk_StoredInfoPtr sti = inObject->GetStoredInfos();
4752  if( sti.IsNotNULL() )
4753  {
4754  fprintf( F, "<StoredInfos>\n" );
4755  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, Dtk_InfoPtr::DtkDynamicCast( sti ) );
4756  fprintf( F, "</StoredInfos>\n" );
4757  }
4758 
4759  Dtk_Size_t NumMetaData;
4760  NumMetaData = inObject->GetNumMetaData();
4761  if( NumMetaData )
4762  {
4763  fprintf( F, "<Dtk_MetaData Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaData );
4764  for( i = 0; i < NumMetaData; i++ )
4765  {
4766  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr( F, inObject->GetMetaData( i ) );
4767  }
4768  fprintf( F, "</Dtk_MetaData>\n" );
4769  }
4770 #ifdef XML_GROUP_METADATA
4771  Dtk_Size_t NumMetaDataGroup;
4772  NumMetaDataGroup = inObject->GetNumMetaDataGroup();
4773  if( NumMetaDataGroup )
4774  {
4775  fprintf( F, "<Dtk_MetaDataGroup Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaDataGroup );
4776  for( i = 0; i < NumMetaDataGroup; i++ )
4777  {
4778  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataGroupPtr( F, inObject->GetMetaDataGroup( i ) );
4779  }
4780  fprintf( F, "</Dtk_MetaDataGroup>\n" );
4781  }
4782 #endif
4783  // Dtk_MaterialPtr mat = inObject->GetMaterial();
4784  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_material(F,mat);
4785 
4786  Dtk_tab< Dtk_NodeConnectorPtr > AssociatedEntities;
4787  inObject->GetAssociatedEntities( AssociatedEntities );
4788  Dtk_Size_t NumConnector = AssociatedEntities.size();
4789  if( NumConnector )
4790  {
4791  fprintf( F, "<NodeConnectors Num=\'" XmlFormat( "u" ) "\'>\n", NumConnector );
4792 
4793  for( i = 0; i < NumConnector; i++ )
4794  {
4795  Dtk_DumpXml_Dtk_NodeConnector( F, AssociatedEntities[ i ] );
4796  }
4797  fprintf( F, "</NodeConnectors>\n" );
4798 
4799  }
4800  Dtk_PreviewPtr preview = inObject->GetPreview();
4801  if( preview.IsNotNULL() )
4802  {
4803  Dtk_Size_t size = preview->GetStreamSize();
4804  fprintf( F, "<PreviewSize>\"" XmlFormat( "u" )"\"</PreviewSize>", size );
4805  }
4806  }
4807  else
4808  {
4809  //fprintf(F,"'Null'");
4810  fprintf( F, "<Null></Null>\n" );
4811  }
4812  return dtkNoError;
4813  }

◆ Dtk_DumpXml_Dtk_NurbsCurvePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NurbsCurvePtr ( FILE *  F,
const Dtk_NurbsCurvePtr &  inCurve 
)
5235  {
5236  Dtk_Size_t num, i;
5237  fprintf( F, "<Dtk_NurbsCurvePtr>" );
5238  fprintf( F, "<IsBezier>%d</IsBezier>", inCurve->IsBezier() );
5239  fprintf( F, "<IsRationnal>%d</IsRationnal>", inCurve->IsRationnal() );
5240  fprintf( F, "<IsUniform>%d</IsUniform>", inCurve->IsUniform() );
5241 
5242  fprintf( F, "<Degree>%d</Degree>", inCurve->GetDegree() );
5243 
5244  fprintf( F, "<Knots>" );
5245  num = inCurve->GetNumKnots();
5246  for( i = 0; i < num - 1; i++ )
5247  {
5248  fprintf( F, "%f,", inCurve->GetKnotValue( i ) );
5249  }
5250  fprintf( F, "%f", inCurve->GetKnotValue( i ) );
5251  fprintf( F, "<Mult>" );
5252  for( i = 0; i < num - 1; i++ )
5253  {
5254  fprintf( F, "%d,", inCurve->GetKnotMultiplicity( i ) );
5255  }
5256  fprintf( F, "%d", inCurve->GetKnotMultiplicity( i ) );
5257  fprintf( F, "</Mult>" );
5258  fprintf( F, "</Knots>" );
5259 
5260  fprintf( F, "<Weights>" );
5261  num = inCurve->GetNumPoints();
5262  fprintf( F, "<NumPoints>" XmlFormat( "u" )"</NumPoints>", num );
5263  for( i = 0; i < num - 1; i++ )
5264  {
5265  fprintf( F, "%f,", inCurve->GetWeight( i ) );
5266  }
5267 
5268  fprintf( F, "%f", inCurve->GetWeight( i ) );
5269  fprintf( F, "</Weights>" );
5270 
5271  fprintf( F, "<Points>" );
5272  for( i = 0; i < num; i++ )
5273  {
5274  Dtk_pnt point = inCurve->Point( i );
5275  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, point );
5276 
5277  }
5278  fprintf( F, "</Points>" );
5279  fprintf( F, "</Dtk_NurbsCurvePtr>" );
5280  return dtkNoError;
5281  }

◆ Dtk_DumpXml_Dtk_NurbsSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NurbsSurfacePtr ( FILE *  F,
const Dtk_NurbsSurfacePtr &  inSurf 
)
6090  {
6091  Dtk_Size_t numU, numV, i, j;
6092 
6093  fprintf( F, "<Dtk_NurbsSurfacePtr>" );
6094  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"TypeBeforeConversion",
6095  typedetkToDtk_string( inSurf->GetTypeBeforeConversion() ) );
6096 
6097  fprintf( F, "<IsBezier>%d</IsBezier>", inSurf->IsBezier() );
6098  fprintf( F, "<IsPlane>%d</IsPlane>", inSurf->IsPlane() );
6099  fprintf( F, "<IsRationnal>%d</IsRationnal>", inSurf->IsRationnal() );
6100  fprintf( F, "<IsUniform>%d</IsUniform>", inSurf->IsUniform() );
6101 
6102  fprintf( F, "<UDegree>%d</UDegree>", inSurf->GetUDegree() );
6103  fprintf( F, "<VDegree>%d</VDegree>", inSurf->GetVDegree() );
6104 
6105  fprintf( F, "<Knots>" );
6106  numU = inSurf->GetNumKnotsU();
6107  fprintf( F, "<UKnots>" );
6108  for( i = 0; i < numU - 1; i++ )
6109  {
6110  fprintf( F, "%f,", inSurf->GetUKnotValue( i ) );
6111  }
6112  fprintf( F, "%f", inSurf->GetUKnotValue( i ) );
6113  fprintf( F, "</UKnots>" );
6114  fprintf( F, "<UMult>" );
6115  for( i = 0; i < numU - 1; i++ )
6116  {
6117  fprintf( F, "%d,", inSurf->GetUKnotMultiplicity( i ) );
6118  }
6119  fprintf( F, "%d", inSurf->GetUKnotMultiplicity( i ) );
6120  fprintf( F, "</UMult>" );
6121 
6122  numV = inSurf->GetNumKnotsV();
6123  fprintf( F, "<VKnots>" );
6124  for( i = 0; i < numV - 1; i++ )
6125  {
6126  fprintf( F, "%f,", inSurf->GetVKnotValue( i ) );
6127  }
6128  fprintf( F, "%f", inSurf->GetVKnotValue( i ) );
6129  fprintf( F, "</VKnots>" );
6130  fprintf( F, "<VMult>" );
6131  for( i = 0; i < numV - 1; i++ )
6132  {
6133  fprintf( F, "%d,", inSurf->GetVKnotMultiplicity( i ) );
6134  }
6135  fprintf( F, "%d", inSurf->GetVKnotMultiplicity( i ) );
6136  fprintf( F, "</VMult>" );
6137  fprintf( F, "</Knots>" );
6138 
6139  fprintf( F, "<Weights>" );
6140  numU = inSurf->GetNumPointsU();
6141  numV = inSurf->GetNumPointsV();
6142  for( i = 0; i < numU - 1; i++ )
6143  {
6144  for( j = 0; j < numV - 1; j++ )
6145  {
6146  fprintf( F, "%f,", inSurf->GetWeight( i, j ) );
6147  }
6148  fprintf( F, "%f,", inSurf->GetWeight( i, j ) );
6149  }
6150  for( j = 0; j < numV - 1; j++ )
6151  {
6152  fprintf( F, "%f,", inSurf->GetWeight( i, j ) );
6153  }
6154  fprintf( F, "%f", inSurf->GetWeight( i, j ) );
6155 
6156  fprintf( F, "</Weights>" );
6157 
6158 
6159  fprintf( F, "<NumUPoints>" XmlFormat( "u" )"</NumUPoints>", numU );
6160  fprintf( F, "<NumVPoints>" XmlFormat( "u" )"</NumVPoints>", numV );
6161  fprintf( F, "<Points>" );
6162  for( i = 0; i < numU; i++ )
6163  {
6164  for( j = 0; j < numV; j++ )
6165  {
6166  Dtk_pnt point = inSurf->Point( i, j );
6167  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, point );
6168  }
6169  fprintf( F, "-------" );
6170  }
6171  fprintf( F, "</Points>" );
6172 
6173  fprintf( F, "</Dtk_NurbsSurfacePtr>" );
6174  return dtkNoError;
6175  }

◆ Dtk_DumpXml_Dtk_OffsetSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_OffsetSurfacePtr ( FILE *  F,
const Dtk_OffsetSurfacePtr &  inSurf 
)
6329  {
6330  fprintf( F, "<Dtk_OffsetSurfacePtr>" );
6331  fprintf( F, "<OffsetDistance>%f</OffsetDistance>", inSurf->GetOffset() );
6332  fprintf( F, "<BasisSurface>" );
6333  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_SurfacePtr( F, inSurf->GetSurface() );
6334  fprintf( F, "</BasisSurface>" );
6335 
6336  fprintf( F, "</Dtk_OffsetSurfacePtr>" );
6337  return dtkNoError;
6338  }

◆ Dtk_DumpXml_Dtk_OLEObjectPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_OLEObjectPtr ( FILE *  F,
const Dtk_OLEObjectPtr &  O 
)
8678  {
8679  fprintf( F, "<Dtk_OLEObjectPtr>\n" );
8680  if( O )
8681  {
8682  Dtk_InfoPtr inf = O->get_info();
8683  if( inf.IsNotNULL() )
8684  {
8685  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inf );
8686  }
8687  fprintf( F, "<BinaryContentSize>" XmlFormat( "u" ) "</BinaryContentSize>\n", O->GetBinaryContentSize() );
8688  fprintf( F, "<ViewingAspect>%s</ViewingAspect>\n", Dtk_OLEObject::Dtk_OLEObjectViewingAspectToString( O->GetViewingAspect() ).c_str() );
8689  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, O->GetPlacement() );
8690  fprintf( F, "<Scale>%lf</Scale>\n", O->GetScale() );
8691  }
8692  else
8693  {
8694  fprintf( F, "Empty" );
8695  }
8696  fprintf( F, "</Dtk_OLEObjectPtr>\n" );
8697  return dtkNoError;
8698  }

◆ Dtk_DumpXml_Dtk_OneCell()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_OneCell ( FILE *  F,
Dtk_OneCell &  D 
)
2232  {
2233  fprintf( F, "<Dtk_OneCell>\n" );
2234 
2235  fprintf( F, "<_Height>%f</_Height>\n", D.getHeight() );
2236  fprintf( F, "<_Width>%f</_Width>\n", D.getWidth() );
2237  fprintf( F, "<nbCells_Left_Right>%u</nbCells_Left_Right>\n", D.getnbCells_Left_Right() );
2238  fprintf( F, "<nbCells_Top_Bottom>%u</nbCells_Top_Bottom>\n", D.getnbCells_Top_Bottom() );
2239 
2240  if( D.GetBorderTopColor().IsFilled() || D.GetBorderBottomColor().IsFilled() || D.GetBorderLeftColor().IsFilled() || D.GetBorderRightColor().IsFilled() )
2241  {
2242  fprintf( F, "<BorderColor>\n" );
2243 
2244  fprintf( F, "<Top>" );
2245  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RGB( F, D.GetBorderTopColor() );
2246  fprintf( F, "</Top>\n" );
2247 
2248  fprintf( F, "<Bottom>" );
2249  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RGB( F, D.GetBorderBottomColor() );
2250  fprintf( F, "</Bottom>\n" );
2251 
2252  fprintf( F, "<Left>" );
2253  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RGB( F, D.GetBorderLeftColor() );
2254  fprintf( F, "</Left>\n" );
2255 
2256  fprintf( F, "<Right>" );
2257  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RGB( F, D.GetBorderRightColor() );
2258  fprintf( F, "</Right>\n" );
2259 
2260  fprintf( F, "</BorderColor>\n" );
2261  }
2262 
2263  if( D.GetBorderTopBlanked() != DTK_FALSE || D.GetBorderBottomBlanked() != DTK_FALSE || D.GetBorderLeftBlanked() != DTK_FALSE || D.GetBorderRightBlanked() != DTK_FALSE )
2264  {
2265  fprintf( F, "<BorderBlanked>\n" );
2266  fprintf( F, "<Top>%d</Top>\n", D.GetBorderTopBlanked() );
2267  fprintf( F, "<Bottom>%d</Bottom>\n", D.GetBorderBottomBlanked() );
2268  fprintf( F, "<Lef>%d</Lef>\n", D.GetBorderLeftBlanked() );
2269  fprintf( F, "<Right>%d</Right>\n", D.GetBorderRightBlanked() );
2270  fprintf( F, "</BorderBlanked>\n" );
2271  }
2272 
2273  const Dtk_tab< Dtk_EntityPtr > &additionnalgeometries = D.GetAdditionnalGeometries();
2274  Dtk_Size_t k, sizek = additionnalgeometries.size();
2275  if( sizek > 0 )
2276  {
2277  fprintf( F, "<AdditionnalGeometries>\n" );
2278  for( k = 0; k < sizek; k++ )
2279  {
2280  Dtk_DumpXml_Dtk_EntityPtr( F, additionnalgeometries[ k ] );
2281  }
2282  fprintf( F, "</AdditionnalGeometries>\n" );
2283  }
2284 
2285  fprintf( F, "</Dtk_OneCell>\n" );
2286  return dtkNoError;
2287  }

◆ Dtk_DumpXml_Dtk_Oriented2dBBox()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Oriented2dBBox ( FILE *  F,
const Dtk_Oriented2dBBox &  BBox,
const Dtk_string &  inLabel = L"" 
)
918  {
919  //we check if the label is present - label overload -
920  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_Oriented2dBBox";
921  fprintf( F, "<%s>\n", Title.c_str() );
922  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, BBox.BottomLeftPoint(), "bottom_left" );
923  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, BBox.XLocalVector(), "x_local_vector" );
924  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, BBox.YLocalVector(), "y_local_vector" );
925  fprintf( F, "<x_length>%f</x_length>\n", BBox.GetXLength() );
926  fprintf( F, "<y_length>%f</y_length>\n", BBox.GetYLength() );
927  fprintf( F, "</%s>\n", Title.c_str() );
928  return dtkNoError;
929  }

◆ Dtk_DumpXml_Dtk_OverrideInfo()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_OverrideInfo ( FILE *  F,
const Dtk_OverrideInfoPtr &  inOverrideInfo 
)
8701  {
8702  fprintf( F, "<Dtk_OverrideInfoPtr>\n" );
8703 
8704  Dtk_string name = inOverrideInfo->GetName();
8705  if( name.len() )
8706  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", name );
8707  Dtk_transfoPtr pos = inOverrideInfo->GetPosition();
8708  if( pos.IsNotNULL() )
8709  {
8710  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, *( pos ).operator->() );
8711  }
8712  Dtk_InfoPtr inf = inOverrideInfo->GetInfos();
8713  if( inf.IsNotNULL() )
8714  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inf );
8715  Dtk_FeaturePtr feat = inOverrideInfo->GetAssemblyFeature();
8716  if( feat.IsNotNULL() )
8717  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FeaturePtr( F, feat );
8718 
8719  Dtk_tab<Dtk_NodeConnectorPtr> tabconnector = inOverrideInfo->GetConnectors();
8720  Dtk_Size_t i, NumConnector = tabconnector.size();
8721  if( NumConnector )
8722  {
8723  fprintf( F, "<NodeConnectors Num=\'" XmlFormat( "u" ) "\'>\n", NumConnector );
8724 
8725  for( i = 0; i < NumConnector; i++ )
8726  {
8727  Dtk_DumpXml_Dtk_NodeConnector( F, tabconnector[ i ] );
8728  }
8729  fprintf( F, "</NodeConnectors>\n" );
8730 
8731  }
8732  fprintf( F, "</Dtk_OverrideInfoPtr>\n" );
8733  return dtkNoError;
8734  }

◆ Dtk_DumpXml_Dtk_OverrideSet()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_OverrideSet ( FILE *  F,
const Dtk_OverrideSetPtr &  inOverrideSet 
)
8737  {
8738  fprintf( F, "<Dtk_OverrideSetPtr>\n" );
8739  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value(F, L"Name", inOverrideSet->GetName());
8740  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value(F, L"SemanticType", Dtk_OverrideSet::Dtk_OverrideSetEnumToString( inOverrideSet->GetSemanticType()));
8741  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"TargetName", inOverrideSet->GetTargetName() );
8742  Dtk_string DisplayName = inOverrideSet->GetDisplayName();
8743  if( DisplayName.is_not_NULL())
8744  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"DisplayName", DisplayName );
8745  fprintf( F, "<IsActivated> %s </IsActivated>\n", inOverrideSet->IsActivated() ? "True" : "False" );
8746  Dtk_tab<Dtk_NodeConnectorPtr> tabconnector = inOverrideSet->GetConnectors();
8747  Dtk_Size_t i, NumConnector = tabconnector.size();
8748  if( NumConnector )
8749  {
8750  fprintf( F, "<NodeConnectors Num=\'" XmlFormat( "u" ) "\'>\n", NumConnector );
8751 
8752  for( i = 0; i < NumConnector; i++ )
8753  {
8754  Dtk_DumpXml_Dtk_NodeConnector( F, tabconnector[ i ] );
8755  }
8756  fprintf( F, "</NodeConnectors>\n" );
8757 
8758  }
8759 
8760  Dtk_tab<Dtk_OverrideInfoPtr> tabInfosC = inOverrideSet->GetOverrideInfoListOnComponent();
8761  Dtk_Size_t NumInfosC = tabInfosC.size();
8762  Dtk_tab<Dtk_OverrideInfoPtr> tabInfosN = inOverrideSet->GetOverrideInfoListOnNode();
8763  Dtk_Size_t NumInfosN = tabInfosN.size();
8764  if( NumInfosC + NumInfosN )
8765  {
8766  fprintf( F, "<OverrideInfos Num=\'" XmlFormat( "u" ) "\'>\n", NumInfosC + NumInfosN );
8767 
8768  for( i = 0; i < NumInfosC; i++ )
8769  {
8770  Dtk_DumpXml_Dtk_OverrideInfo( F, tabInfosC[ i ] );
8771  }
8772  for( i = 0; i < NumInfosN; i++ )
8773  {
8774  Dtk_DumpXml_Dtk_OverrideInfo( F, tabInfosN[ i ] );
8775  }
8776  fprintf( F, "</OverrideInfos>\n" );
8777  }
8778  fprintf( F, "</Dtk_OverrideSetPtr>\n" );
8779  return dtkNoError;
8780  }

◆ Dtk_DumpXml_Dtk_ParabolaPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ParabolaPtr ( FILE *  F,
const Dtk_ParabolaPtr &  inCurve 
)
5304  {
5305  fprintf( F, "<Dtk_ParabolaPtr>" );
5306 
5307  fprintf( F, "<Center>" );
5308  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inCurve->GetCenterPoint() );
5309  fprintf( F, "</Center>" );
5310  fprintf( F, "<XDir>" );
5311  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inCurve->GetXDirection() );
5312  fprintf( F, "</XDir>" );
5313  fprintf( F, "<YDir>" );
5314  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inCurve->GetYDirection() );
5315  fprintf( F, "</YDir>" );
5316  fprintf( F, "<ZDir>" );
5317  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inCurve->GetZDirection() );
5318  fprintf( F, "</ZDir>" );
5319  fprintf( F, "<FocalDistance>%f</FocalDistance>", inCurve->GetFocalDistance() );
5320 
5321  fprintf( F, "</Dtk_ParabolaPtr>" );
5322  return dtkNoError;
5323  }

◆ Dtk_DumpXml_Dtk_PhysicalMaterialInfos()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_PhysicalMaterialInfos ( FILE *  F,
const Dtk_PhysicalMaterialInfosPtr &  inMaterial 
)
3740  {
3741  Dtk_string name = L"";
3742  Dtk_string Value;
3743  char buffer[ 512 ] = { 0 };
3744 
3745  if( inMaterial.IsNULL() )
3746  {
3747  return dtkNoError;
3748  }
3749  fprintf( F, "<Dtk_PhysicalMaterialInfosPtr>\n" );
3750  name = inMaterial->GetName();
3751  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"name", name );
3752  Dtk_string Stype = inMaterial->GetTypeAsString();
3753  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"type", Stype );
3754  Dtk_Double64 val;
3755  Dtk_string unit;
3756  inMaterial->GetDensity( val, unit );
3757  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"density", "%.8e %s", val, unit.c_str() );
3758 
3759  inMaterial->GetThermalExpansion( val, unit );
3760 
3761  Dtk_StandardTools::sprintf_dtk( buffer, 512, "%.8e ", val );
3762  Value = buffer + unit;
3763  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"ThermalExpansion", Value );
3764 
3765  inMaterial->GetThermalConductivity( val, unit );
3766 
3767  Dtk_StandardTools::sprintf_dtk( buffer, 512, "%.8e ", val );
3768  Value = buffer + unit;
3769  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"ThermalConductivity", Value );
3770 
3771  inMaterial->GetYieldStrength( val, unit );
3772  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"YieldStrength", "%.8e %s", val, unit.c_str() );
3773 
3774  inMaterial->GetSpecificHeat( val, unit );
3775 
3776  Dtk_StandardTools::sprintf_dtk( buffer, 512, "%.8e ", val );
3777  Value = buffer + unit;
3778  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"SpecificHeat", Value );
3779 
3780  inMaterial->GetTensileStrength( val, unit );
3781  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"TensileStrength", "%.8e %s", val, unit.c_str() );
3782 
3783  Dtk_Double64 value[ 3 ];
3784  inMaterial->GetYoungModulus( value, unit );
3785  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"YoungModulus0", "%.8e %s", value[ 0 ], unit.c_str() );
3786  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"YoungModulus1", "%.8e %s", value[ 1 ], unit.c_str() );
3787  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"YoungModulus2", "%.8e %s", value[ 2 ], unit.c_str() );
3788 
3789  inMaterial->GetPoissonRatio( value );
3790  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"PoissonRatio0", value[ 0 ], "%.8e" );
3791  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"PoissonRatio1", value[ 1 ], "%.8e" );
3792  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"PoissonRatio2", value[ 2 ], "%.8e" );
3793 
3794  inMaterial->GetShearModulus( value, unit );
3795  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"ShearModulus0", "%.8e %s", value[ 0 ], unit.c_str() );
3796  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"ShearModulus1", "%.8e %s", value[ 1 ], unit.c_str() );
3797  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"ShearModulus2", "%.8e %s", value[ 2 ], unit.c_str() );
3798 
3799  inMaterial->GetHardeningRatio( value );
3800  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"HardeningRatio0", value[ 0 ], "%.8e" );
3801  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"HardeningRatio1", value[ 1 ], "%.8e" );
3802  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"HardeningRatio2", value[ 2 ], "%.8e" );
3803 
3804 
3805  fprintf( F, "</Dtk_PhysicalMaterialInfosPtr>\n" );
3806 
3807  return dtkNoError;
3808  }

◆ Dtk_DumpXml_Dtk_Picture()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Picture ( FILE *  F,
Dtk_picture *  inPicture 
)
3628  {
3629  fprintf( F, "<Dtk_Picture>\n" );
3630  if( inPicture )
3631  {
3632  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inPicture->get_info() );
3633  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inPicture->Origin(), "Origin" );
3634  fprintf( F, "<width>" XmlFormat( "u" )"</width>\n", inPicture->PixelWidth() );
3635  fprintf( F, "<height>" XmlFormat( "u" )"</height>\n", inPicture->PixelHeight() );
3636  fprintf( F, "<metric_width>%lf</metric_width>\n", inPicture->MetricWidth() );
3637  fprintf( F, "<metric_height>%lf</metric_height>\n", inPicture->MetricHeight() );
3638  fprintf( F, "<ScaleX>%lf</ScaleX>\n", inPicture->ScaleX() );
3639  fprintf( F, "<ScaleY>%lf</ScaleY>\n", inPicture->ScaleY() );
3640  fprintf( F, "<picture_type>%s</picture_type>\n", DtkPictureTypeEnumToString( inPicture->FileType() ).c_str() );
3641  fprintf( F, "<file_size>" XmlFormat( "u" )"</file_size>\n", inPicture->File().size() );
3642 
3643  //write BMP
3644  Dtk_tab<char > tab = inPicture->File();
3645  }
3646  fprintf( F, "</Dtk_Picture>\n" );
3647  return dtkNoError;
3648  }

◆ Dtk_DumpXml_Dtk_PlaneSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_PlaneSurfacePtr ( FILE *  F,
const Dtk_PlaneSurfacePtr &  inSurf 
)
6178  {
6179  fprintf( F, "<Dtk_PlaneSurfacePtr>" );
6180 
6181  if( inSurf.IsNotNULL() )
6182  {
6183  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inSurf->GetOrigin(), "Origin" );
6184  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetNormal(), "Normal" );
6185  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetUDirection(), "UDir" );
6186  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetVDirection(), "VDir" );
6187  }
6188  else
6189  {
6190  fprintf( F, "Null" );
6191  }
6192 
6193  fprintf( F, "</Dtk_PlaneSurfacePtr>" );
6194  return dtkNoError;
6195  }

◆ Dtk_DumpXml_Dtk_pnt()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_pnt ( FILE *  F,
const Dtk_pnt &  P,
const char *  b 
)
4351  {
4352  fprintf( F, "<%s>(%f %f %f)</%s>\n", b, P[ 0 ], P[ 1 ], P[ 2 ], b );
4353  return dtkNoError;
4354  }

◆ Dtk_DumpXml_Dtk_PointPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_PointPtr ( FILE *  F,
const Dtk_PointPtr &  inPoint 
)
6502  {
6503  Dtk_pnt point;
6504 
6505  fprintf( F, "<Dtk_PointPtr>" );
6506  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inPoint->get_info() );
6507  // fprintf(F,"<Id>%d</Id>",inPoint->GetID());
6508  inPoint->GetCoordinates( point );
6509  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, point );
6510 
6511  fprintf( F, "</Dtk_PointPtr>" );
6512  return dtkNoError;
6513  }

◆ Dtk_DumpXml_Dtk_PolylinePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_PolylinePtr ( FILE *  F,
const Dtk_PolylinePtr &  inCurve 
)
5215  {
5216  Dtk_Size_t num, i;
5217  fprintf( F, "<Dtk_PolylinePtr>" );
5218  fprintf( F, "<Trim>" );
5219  fprintf( F, "<UMin>%f</UMin>", inCurve->GetTrimUMin() );
5220  fprintf( F, "<UMax>%f</UMax>", inCurve->GetTrimUMax() );
5221  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inCurve->GetTrimStartPoint() );
5222  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inCurve->GetTrimEndPoint() );
5223  fprintf( F, "</Trim>" );
5224  num = inCurve->GetNumPoints();
5225  fprintf( F, "<Points>" );
5226  for( i = 0; i < num; i++ )
5227  {
5228  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inCurve->Point( i ) );
5229  }
5230  fprintf( F, "</Points>" );
5231  fprintf( F, "</Dtk_PolylinePtr>" );
5232  return dtkNoError;
5233  }

◆ Dtk_DumpXml_Dtk_PropertiesPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_PropertiesPtr ( FILE *  F,
const Dtk_PropertiesPtr &  inObject 
)
4828  {
4829  fprintf( F, "<Dtk_PropertiesPtr>\n" );
4830  if( inObject.IsNotNULL() )
4831  {
4832  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", inObject->GetTitle() );
4833  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Type", inObject->GetType() );
4834  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Value", inObject->GetValue() );
4835  }
4836  else
4837  {
4838  fprintf( F, "'Null'" );
4839  }
4840  fprintf( F, "</Dtk_PropertiesPtr>\n" );
4841  return dtkNoError;
4842  }

◆ Dtk_DumpXml_Dtk_ReferenceBlockPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceBlockPtr ( FILE *  F,
const Dtk_ReferenceBlockPtr &  D 
)
2567  {
2568  Dtk_Size_t i;
2569  Dtk_Size_t NumReferences = D->GetNumReferences();
2570 
2571  fprintf( F, "<Dtk_ReferenceBlockPtr NumReferences=\"" XmlFormat( "u" )"\">\n", NumReferences );
2572  for( i = 0; i < NumReferences; i++ )
2573  {
2574  fprintf( F, "<Dtk_Reference>\n" );
2575  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"label", D->GetReferenceLabel( i ) );
2576  //Dtk_DumpXMLNamespace::Dtk_DumpXml_DTK_FDT_MODIFIER(F, D->GetMaterialModifier(i));
2577  fprintf( F, "</Dtk_Reference>\n" );
2578 
2579  }
2580  fprintf( F, "</Dtk_ReferenceBlockPtr>\n" );
2581  return dtkNoError;
2582  }

◆ Dtk_DumpXml_Dtk_ReferenceFramePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceFramePtr ( FILE *  F,
const Dtk_ReferenceFramePtr &  D 
)
2585  {
2586  if( D.IsNotNULL() )
2587  {
2588  Dtk_Size_t nb_refs = D->GetNumReferences();
2589  fprintf( F, "<Dtk_ReferenceFramePtr NumReferencesBlocks = \"" XmlFormat( "u" )"\">\n", nb_refs );
2590 
2591  Dtk_ReferenceBlockPtr Ref;
2592  Ref = D->FirstReference();
2593  if( Ref.IsNotNULL() ) Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ReferenceBlockPtr( F, Ref );
2594  Ref = D->SecondReference();
2595  if( Ref.IsNotNULL() ) Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ReferenceBlockPtr( F, Ref );
2596  Ref = D->ThirdReference();
2597  if( Ref.IsNotNULL() ) Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ReferenceBlockPtr( F, Ref );
2598  fprintf( F, "</Dtk_ReferenceFramePtr>\n" );
2599  }
2600  return dtkNoError;
2601  }

◆ Dtk_DumpXml_Dtk_RegionPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_RegionPtr ( FILE *  F,
const Dtk_RegionPtr &  D 
)
2419  {
2420  Dtk_Double64 val;
2421 
2422  fprintf( F, "<Dtk_Region>\n" );
2423 
2424  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_AnnotationPtr( F, Dtk_AnnotationPtr::DtkDynamicCast( D ) ); // upcasting
2425  //Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox(F, D->GetBoundingBox());
2426  switch( D->GetType() )
2427  {
2428  case Dtk_Region::RectangularType:
2429  {
2430  fprintf( F, "<Type>RectangularType</Type>\n" );
2431  D->GetRectangularHeight( val );
2432  fprintf( F, "<Height>%f</Height>\n", val );
2433  D->GetRectangularWidth( val );
2434  fprintf( F, "<Width>%f</Width>\n", val );
2435  break;
2436  }
2437  case Dtk_Region::AnnularType:
2438  fprintf( F, "<Type>AnnularType</Type>\n" );
2439  D->GetAnnularOuterDiameter( val );
2440  fprintf( F, "<OuterDiameter>%f</OuterDiameter>\n", val );
2441  D->GetAnnularInnerDiameter( val );
2442  fprintf( F, "<InnerDiameter>%f</InnerDiameter>\n", val );
2443  break;
2444  case Dtk_Region::ArbitraryType:
2445  fprintf( F, "<Type>ArbitraryType</Type>\n" );
2446  break;
2447  case Dtk_Region::CircularType:
2448  fprintf( F, "<Type>CircularType</Type>\n" );
2449  D->GetCircularDiameter( val );
2450  fprintf( F, "<Diameter>%f</Diameter>\n", val );
2451  break;
2452  case Dtk_Region::CylindricalType:
2453  fprintf( F, "<Type>CylindricalType</Type>\n" );
2454  break;
2455  case Dtk_Region::UnknownType:
2456  fprintf( F, "<Type>Unknown</Type>\n" );
2457  break;
2458  default:
2459  break;
2460  }
2461  Dtk_DumpXml_Dtk_HatchingPattern( F, D->GetHatchingPattern() );
2462 
2463 
2464  fprintf( F, "<Geometry>\n" );
2465  Dtk_Size_t nbgeoms = D->GetGeometries().size();
2466  Dtk_Size_t i;
2467  fprintf( F, "<Num_geometry>" XmlFormat( "u" )"</Num_geometry>\n", nbgeoms );
2468  for( i = 0; i < nbgeoms; i++ )
2469  {
2470  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EntityPtr( F, D->GetGeometries()[ i ] );
2471  }
2472  fprintf( F, "</Geometry>\n" );
2473 
2474  fprintf( F, "</Dtk_Region>\n" );
2475  return dtkNoError;
2476  }

◆ Dtk_DumpXml_Dtk_RenderInfos()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_RenderInfos ( FILE *  F,
const Dtk_RenderInfosPtr &  inRender 
)
3710  {
3711  Dtk_string name = L"";
3712 
3713  if( inRender.IsNULL() )
3714  {
3715  return dtkNoError;
3716  }
3717  fprintf( F, "<Dtk_RenderInfosPtr>\n" );
3718  name = inRender->GetName();
3719  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"label", name );
3720  Dtk_RenderInfos::RenderMappingShaderTypeEnum shadertype = Dtk_RenderInfos::Unknown;
3721  shadertype = inRender->GetShaderType();
3722  if( shadertype != Dtk_RenderInfos::Unknown )
3723  {
3724  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"shadertype", shadertype );
3725  }
3726 
3727  Dtk_LightMapPtr light = inRender->GetLightMap();
3728  if( light.IsNotNULL() )
3729  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Light( F, light );
3730  Dtk_TextureInfosPtr texture = inRender->GetTexture();
3731  if( texture.IsNotNULL() )
3732  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Texture( F, texture );
3733 
3734  fprintf( F, "</Dtk_RenderInfosPtr>\n" );
3735 
3736  return dtkNoError;
3737  }

◆ Dtk_DumpXml_Dtk_RevolutionSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_RevolutionSurfacePtr ( FILE *  F,
const Dtk_RevolutionSurfacePtr &  inSurf 
)
6267  {
6268  fprintf( F, "<Dtk_RevolutionSurfacePtr>" );
6269  fprintf( F, "<AxisPosition>" );
6270  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inSurf->GetAxisPosition() );
6271  fprintf( F, "</AxisPosition>" );
6272  fprintf( F, "<XDir>" );
6273  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetXDirection() );
6274  fprintf( F, "</XDir>" );
6275  fprintf( F, "<YDir>" );
6276  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetYDirection() );
6277  fprintf( F, "</YDir>" );
6278  fprintf( F, "<ZDir>" );
6279  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetZDirection() );
6280  fprintf( F, "</ZDir>" );
6281  fprintf( F, "<RevolvedCurve>" );
6282  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, inSurf->GetRevolvedCurve() );
6283  fprintf( F, "</RevolvedCurve>" );
6284 
6285  fprintf( F, "</Dtk_RevolutionSurfacePtr>" );
6286  return dtkNoError;
6287 
6288  }

◆ Dtk_DumpXml_Dtk_RGB()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_RGB ( FILE *  F,
const Dtk_RGB &  RGB 
)
3544  {
3545  fprintf( F, "<RGBA><r>%d</r><g>%d</g><b>%d</b><a>%d</a>", RGB.R(), RGB.G(), RGB.B(), RGB.A() );
3546  if( RGB.IndexReader() >= 0 )
3547  {
3548  fprintf( F, "<IndexReader>%d</IndexReader>", RGB.IndexReader() );
3549  }
3550  fprintf( F, "</RGBA>\n" );
3551 
3552  return dtkNoError;
3553  }

◆ Dtk_DumpXml_Dtk_roughness_obtention_type()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_roughness_obtention_type ( FILE *  F,
const Dtk_Roughness::ObtentionTypeEnum &  D 
)
1496  {
1497  fprintf( F, "<Dtk_roughness_obtention_type>" );
1498  switch( D )
1499  {
1500  default:
1501  case Dtk_Roughness::ObtentionTypeNotDefined:
1502  fprintf( F, "DTK_ROUGHNESS_NOT_DEFINED" );
1503  break;
1504  case Dtk_Roughness::ObtentionTypeMachiningMandatory:
1505  fprintf( F, "DTK_ROUGHNESS_MACHINING_MANDATORY" );
1506  break;
1507  case Dtk_Roughness::ObtentionTypeMachiningForbidden:
1508  fprintf( F, "DTK_ROUGHNESS_MACHINING_FORBIDEN" );
1509  break;
1510  }
1511  fprintf( F, "</Dtk_roughness_obtention_type>\n" );
1512  return dtkNoError;
1513  }

◆ Dtk_DumpXml_Dtk_roughness_rough_mode()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_roughness_rough_mode ( FILE *  F,
const Dtk_Roughness::RoughModeEnum &  D 
)
1539  {
1540  fprintf( F, "<Dtk_roughness_rough_mode>" );
1541  switch( D )
1542  {
1543  default:
1544  case Dtk_Roughness::ModeNone:
1545  fprintf( F, "DTK_ROUGHNESS_MODE_NONE" );
1546  break;
1547  case Dtk_Roughness::ModeMultiDirectional:
1548  fprintf( F, "DTK_ROUGHNESS_MODE_MULTIDIRECTIONAL" );
1549  break;
1550  case Dtk_Roughness::ModeCircular:
1551  fprintf( F, "DTK_ROUGHNESS_MODE_CIRCULAR" );
1552  break;
1553  case Dtk_Roughness::ModeRadial:
1554  fprintf( F, "DTK_ROUGHNESS_MODE_RADIAL" );
1555  break;
1556  case Dtk_Roughness::ModeParticular:
1557  fprintf( F, "DTK_ROUGHNESS_MODE_PARTICULAR" );
1558  break;
1559  case Dtk_Roughness::ModeWithAngles:
1560  fprintf( F, "DTK_ROUGHNESS_MODE_WITH_ANGLES" );
1561  break;
1562  case Dtk_Roughness::ModeParallel:
1563  fprintf( F, "DTK_ROUGHNESS_MODE_PARALLEL" );
1564  break;
1565  case Dtk_Roughness::ModePerpendicular:
1566  fprintf( F, "DTK_ROUGHNESS_MODE_PERPENDICULAR" );
1567  break;
1568  }
1569  fprintf( F, "</Dtk_roughness_rough_mode>\n" );
1570  return dtkNoError;
1571  }

◆ Dtk_DumpXml_Dtk_roughness_roughness_applyto()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_roughness_roughness_applyto ( FILE *  F,
const Dtk_Roughness::ApplyToEnum &  D 
)
1516  {
1517  fprintf( F, "<Dtk_roughness_roughness_applyto>" );
1518  switch( D )
1519  {
1520  default:
1521  case Dtk_Roughness::ApplyToSpecifiedSurface:
1522  fprintf( F, "DTK_ROUGHNESS_SPECIFIED_SURFACE" );
1523  break;
1524  case Dtk_Roughness::ApplyToSurroundingSurfaces:
1525  fprintf( F, "DTK_ROUGHNESS_SURROUNDING_SURFACES" );
1526  break;
1527  case Dtk_Roughness::ApplyToBasicSurface:
1528  fprintf( F, "DTK_ROUGHNESS_BASIC_SURFACE" );
1529  break;
1530  case Dtk_Roughness::ApplyToAllSurfaces:
1531  fprintf( F, "DTK_ROUGHNESS_ALL_PART_SURFACES" );
1532  break;
1533  }
1534  fprintf( F, "</Dtk_roughness_roughness_applyto>\n" );
1535  return dtkNoError;
1536  }

◆ Dtk_DumpXml_Dtk_RoughnessPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_RoughnessPtr ( FILE *  F,
const Dtk_RoughnessPtr &  D 
)
1574  {
1575  fprintf( F, "<Dtk_RoughnessPtr>\n" );
1576  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_AnnotationPtr( F, Dtk_AnnotationPtr::DtkDynamicCast( D ) ); // upcasting
1577 
1578  //we dump each of 6 texts
1579  fprintf( F, "<TopLeftText>\n" );
1580  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetTopLeftText() );
1581  fprintf( F, "</TopLeftText>\n" );
1582 
1583  fprintf( F, "<MiddleLeftText>\n" );
1584  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetMiddleLeftText() );
1585  fprintf( F, "</MiddleLeftText>\n" );
1586 
1587  fprintf( F, "<BottomLeftText>\n" );
1588  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetBottomLeftText() );
1589  fprintf( F, "</BottomLeftText>\n" );
1590 
1591  fprintf( F, "<TopRightText>\n" );
1592  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetTopRightText() );
1593  fprintf( F, "</TopRightText>\n" );
1594 
1595  fprintf( F, "<MiddleRightText>\n" );
1596  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetMiddleRightText() );
1597  fprintf( F, "</MiddleRightText>\n" );
1598 
1599  fprintf( F, "<BottomRightText>\n" );
1600  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetBottomRightText() );
1601  fprintf( F, "</BottomRightText>\n" );
1602 
1603  fprintf( F, "<OtherRequirement>\n" );
1604  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetOtherRequirement() );
1605  fprintf( F, "</OtherRequirement>\n" );
1606 
1607  fprintf( F, "<CutOff>\n" );
1608  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetCutOff() );
1609  fprintf( F, "</CutOff>\n" );
1610 
1611 
1612  //fprintf(F,"<ObtentionType>");
1613  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_roughness_obtention_type( F, D->GetRoughnessType() );
1614  //fprintf(F,"</ObtentionType>");
1615  //fprintf(F,"<RoughnessMode>");
1616  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_roughness_rough_mode( F, D->GetRoughMode() );
1617  //fprintf(F,"</RoughnessMode>");
1618  //fprintf(F,"<ApplyTo>");
1619  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_roughness_roughness_applyto( F, D->GetRoughnessApplyTo() );
1620  //fprintf(F,"</ApplyTo>");
1621  if( D->GetInvertText() )
1622  {
1623  fprintf( F, "<InvertText>DTK_TRUE</InvertText>\n" );
1624  }
1625 
1626  fprintf( F, "</Dtk_RoughnessPtr>\n" );
1627  return dtkNoError;
1628  }

◆ Dtk_DumpXml_Dtk_RuledSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_RuledSurfacePtr ( FILE *  F,
const Dtk_RuledSurfacePtr &  inSurf 
)
6341  {
6342  fprintf( F, "<Dtk_RuledSurfacePtr>" );
6343  fprintf( F, "<FirstCurve>" );
6344  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, inSurf->GetFirstCurve() );
6345  fprintf( F, "</FirstCurve>" );
6346  fprintf( F, "<SecondCurve>" );
6347  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, inSurf->GetSecondCurve() );
6348  fprintf( F, "</SecondCurve>" );
6349 
6350  fprintf( F, "</Dtk_RuledSurfacePtr>" );
6351  return dtkNoError;
6352  }

◆ Dtk_DumpXml_Dtk_SelectionDataSet()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_SelectionDataSet ( FILE *  F,
const Dtk_GlobalDataSetPtr &  ptrGlobalDataSet 
)
7145  {
7146  if( F == NULL )
7147  {
7148  return dtkErrorNullPointer;
7149  }
7150  Dtk_Size_t i = 0;
7151 
7152  //Dtk_GlobalDataSetPtr ptrGlobalDataSet = inObject->GetGlobalDataSet();
7153  if( ptrGlobalDataSet.IsNotNULL() )
7154  {
7155  Dtk_SelectionDataSetPtr ptrSelectionDataSet = ptrGlobalDataSet->GetSelectionDataSet();
7156  if( ptrSelectionDataSet.IsNULL() )
7157  {
7158  return dtkErrorNullPointer;
7159  }
7160  Dtk_Size_t ptrSelectionDataSetNb = ptrSelectionDataSet->GetNumSelectionSets();
7161  if( ptrSelectionDataSetNb > 0 )
7162  {
7163  fprintf( F, "<Dtk_SelectionDataSet>\n" );
7164  }
7165  for( i = 0; i < ptrSelectionDataSetNb; i++ )
7166  {
7167  Dtk_SelectionSetPtr curSelectionSet = ptrSelectionDataSet->GetSelectionSetByPos( i );
7168  if( curSelectionSet.IsNotNULL() )
7169  Dtk_DumpXml_Dtk_SelectionSet( F, curSelectionSet );
7170  }
7171  if( ptrSelectionDataSetNb > 0 )
7172  {
7173  fprintf( F, "</Dtk_SelectionDataSet>\n" );
7174  }
7175  }
7176 
7177  return dtkNoError;
7178  }

◆ Dtk_DumpXml_Dtk_SelectionSet()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_SelectionSet ( FILE *  F,
const Dtk_SelectionSetPtr &  inSelectionSet 
)
7101  {
7102  Dtk_ErrorStatus dst = dtkNoError;
7103  Dtk_Size_t i = 0;
7104 
7105  Dtk_string selSetName = inSelectionSet->GetName();
7106  Dtk_tab <Dtk_NodeConnectorPtr> connectorTab = inSelectionSet->GetNodeConnectors();
7107  Dtk_Size_t connectorTabSize = connectorTab.size();
7108 
7109  fprintf( F, "<Dtk_SelectionSet name=\"%s\" linksNb=\"" XmlFormat( "u" )"\">\n", selSetName.c_str(), connectorTabSize );
7110  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inSelectionSet->info() );
7111 
7112  for( i = 0; i < connectorTabSize; i++ )
7113  {
7114  Dtk_NodeConnectorPtr curConnector = connectorTab.at( i );
7115  if( curConnector.IsNotNULL() )
7116  {
7117  Dtk_DumpXml_Dtk_NodeConnector( F, curConnector );
7118  }
7119  }
7120 
7121  Dtk_tab <Dtk_SelectionSetPtr> selectionsetTab = inSelectionSet->GetSelectionSet();
7122  Dtk_Size_t selectionsetTabSize = selectionsetTab.size();
7123  if( selectionsetTabSize > 0 )
7124  {
7125  fprintf( F, "<selectionset Nb=\"" XmlFormat( "u" )"\">\n", selectionsetTabSize );
7126 
7127  for( i = 0; i < selectionsetTabSize; i++ )
7128  {
7129  Dtk_SelectionSetPtr curSelectionset = selectionsetTab.at( i );
7130  if( curSelectionset.IsNotNULL() )
7131  {
7132  Dtk_DumpXml_Dtk_SelectionSet( F, curSelectionset );
7133  }
7134  }
7135  fprintf( F, "</selectionset>\n" );
7136  }
7137 
7138  fprintf( F, "</Dtk_SelectionSet>\n" );
7139  dst = dtkNoError;
7140  return dst;
7141  }

◆ Dtk_DumpXml_Dtk_ShellPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ShellPtr ( FILE *  F,
const Dtk_ShellPtr &  inShell 
)
6647  {
6648  Dtk_Size_t numFace, i;
6649  Dtk_bool orientation;
6650 
6651  fprintf( F, "<Dtk_ShellPtr>" );
6652  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inShell->get_info() );
6653 
6654  fprintf( F, "<IsOuter>%d</IsOuter>", inShell->IsOuter() );
6655  fprintf( F, "<IsClosed>%d</IsClosed>", inShell->IsClosed() );
6656 
6657  // fprintf(F,"<Id>%d</Id>",inShell->GetID());
6658  numFace = inShell->GetNumFaces();
6659  if( numFace == 0 )
6660  {
6661  fprintf( F, "</Dtk_ShellPtr>" );
6662  return dtkTopologyShellHasNoFaces;
6663  }
6664  for( i = 0; i < numFace; i++ )
6665  {
6666  Dtk_FacePtr face;
6667  inShell->GetFace( i, face, orientation );
6668  fprintf( F, "<orientation>%d</orientation>", orientation );
6669  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FacePtr( F, face );
6670 
6671  }
6672  fprintf( F, "</Dtk_ShellPtr>" );
6673  return dtkNoError;
6674  }

◆ Dtk_DumpXml_Dtk_SphericalSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_SphericalSurfacePtr ( FILE *  F,
const Dtk_SphericalSurfacePtr &  inSurf 
)
6233  {
6234  fprintf( F, "<Dtk_SphericalSurfacePtr>" );
6235 
6236  fprintf( F, "<AxisPosition>" );
6237  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inSurf->GetAxisPosition() );
6238  fprintf( F, "</AxisPosition>" );
6239  fprintf( F, "<RevolutionAxis>" );
6240  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetRevolutionAxis() );
6241  fprintf( F, "</RevolutionAxis>" );
6242  fprintf( F, "<Radius>%f</Radius>", inSurf->GetRadius() );
6243 
6244  fprintf( F, "</Dtk_SphericalSurfacePtr>" );
6245  return dtkNoError;
6246 
6247  }

◆ Dtk_DumpXml_Dtk_StandardRevolutionSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_StandardRevolutionSurfacePtr ( FILE *  F,
const Dtk_StandardRevolutionSurfacePtr &  inSurf 
)
6290  {
6291  fprintf( F, "<Dtk_RevolutionSurfacePtr>" );
6292  fprintf( F, "<AxisPosition>" );
6293  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inSurf->GetAxisPosition() );
6294  fprintf( F, "</AxisPosition>" );
6295  fprintf( F, "<XDir>" );
6296  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetXDirection() );
6297  fprintf( F, "</XDir>" );
6298  fprintf( F, "<YDir>" );
6299  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetYDirection() );
6300  fprintf( F, "</YDir>" );
6301  fprintf( F, "<ZDir>" );
6302  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetZDirection() );
6303  fprintf( F, "</ZDir>" );
6304  fprintf( F, "<RevolvedCurve>" );
6305  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CurvePtr( F, inSurf->GetRevolvedCurve() );
6306  fprintf( F, "</RevolvedCurve>" );
6307 
6308  fprintf( F, "</Dtk_RevolutionSurfacePtr>" );
6309  return dtkNoError;
6310 
6311  }

◆ Dtk_DumpXml_Dtk_StreamPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_StreamPtr ( FILE *  F,
const Dtk_StreamPtr &  inVal 
)
8783  {
8784  fprintf( F, "<Dtk_StreamPtr>\n" );
8785  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inVal->GetName() );
8786  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"StreamType", inVal->GetStreamType() );
8787  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"StreamSize", inVal->GetBinaryContentSize() );
8788  fprintf( F, "</Dtk_StreamPtr>\n" );
8789  return dtkNoError;
8790  }

◆ Dtk_DumpXml_Dtk_SurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_SurfacePtr ( FILE *  F,
const Dtk_SurfacePtr &  inSurf 
)
6397  {
6398  type_detk type;
6399  Dtk_Double64 domain[ 4 ];
6400 
6401  fprintf( F, "<Dtk_SurfacePtr>" );
6402  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inSurf->get_info() );
6403 
6404  inSurf->GetTrimUVBox( domain );
6405  fprintf( F, "<TrimUV>" );
6406  fprintf( F, "<UTrimMin>%f</UTrimMin>", domain[ 0 ] );
6407  fprintf( F, "<UTrimMax>%f</UTrimMax>", domain[ 1 ] );
6408  fprintf( F, "<VTrimMin>%f</VTrimMin>", domain[ 2 ] );
6409  fprintf( F, "<VTrimMax>%f</VTrimMax>", domain[ 3 ] );
6410  fprintf( F, "</TrimUV>" );
6411 
6412 
6413  fprintf( F, "<Domain>" );
6414  inSurf->GetDomain( domain );
6415  fprintf( F, "<UMin>%f</UMin>", domain[ 0 ] );
6416  fprintf( F, "<UMax>%f</UMax>", domain[ 1 ] );
6417  fprintf( F, "<VMin>%f</VMin>", domain[ 2 ] );
6418  fprintf( F, "<VMax>%f</VMax>", domain[ 3 ] );
6419  fprintf( F, "</Domain>" );
6420 
6421 
6422 
6423  type = inSurf->get_type_detk();
6424  switch( type )
6425  {
6426  case DTK_TYPE_PLANE:
6427  {
6428  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_PlaneSurfacePtr( F, Dtk_PlaneSurfacePtr::DtkDynamicCast( inSurf ) );
6429  break;
6430  }
6431  case DTK_TYPE_NURBS_SURFACE:
6432  {
6433  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NurbsSurfacePtr( F, Dtk_NurbsSurfacePtr::DtkDynamicCast( inSurf ) );
6434  break;
6435  }
6436  case DTK_TYPE_CYLINDRICAL_SURFACE:
6437  {
6438  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CylindricalSurfacePtr( F, Dtk_CylindricalSurfacePtr::DtkDynamicCast( inSurf ) );
6439  break;
6440  }
6441  case DTK_TYPE_CONICAL_SURFACE:
6442  {
6443  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ConicalSurfacePtr( F, Dtk_ConicalSurfacePtr::DtkDynamicCast( inSurf ) );
6444  break;
6445  }
6446  case DTK_TYPE_SPHERICAL_SURFACE:
6447  {
6448  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_SphericalSurfacePtr( F, Dtk_SphericalSurfacePtr::DtkDynamicCast( inSurf ) );
6449  break;
6450  }
6451  case DTK_TYPE_TOROIDAL_SURFACE:
6452  {
6453  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ToroidalSurfacePtr( F, Dtk_ToroidalSurfacePtr::DtkDynamicCast( inSurf ) );
6454  break;
6455  }
6456  // DEPRECATED use DTK_TYPE_STANDARD_REVOLUTION_SURFACE
6457  //case DTK_TYPE_REVOLUTION_SURFACE:
6458  // {
6459  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RevolutionSurfacePtr(F, Dtk_RevolutionSurfacePtr::DtkDynamicCast(inSurf));
6460  // break;
6461  // }
6462  case DTK_TYPE_STANDARD_REVOLUTION_SURFACE:
6463  {
6464  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_StandardRevolutionSurfacePtr( F, Dtk_StandardRevolutionSurfacePtr::DtkDynamicCast( inSurf ) );
6465  break;
6466  }
6467  case DTK_TYPE_LINEAR_EXTRUSION_SURFACE:
6468  {
6469  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LinearExtrusionSurfacePtr( F, Dtk_LinearExtrusionSurfacePtr::DtkDynamicCast( inSurf ) );
6470  break;
6471  }
6472  case DTK_TYPE_OFFSET_SURFACE:
6473  {
6474  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_OffsetSurfacePtr( F, Dtk_OffsetSurfacePtr::DtkDynamicCast( inSurf ) );
6475  break;
6476  }
6477  case DTK_TYPE_RULED_SURFACE:
6478  {
6479  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RuledSurfacePtr( F, Dtk_RuledSurfacePtr::DtkDynamicCast( inSurf ) );
6480  break;
6481  }
6482  case DTK_TYPE_TRANSFORMED_SURFACE:
6483  {
6484  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_TransformedSurfacePtr( F, Dtk_TransformedSurfacePtr::DtkDynamicCast( inSurf ) );
6485  break;
6486  }
6487  case DTK_TYPE_FILLET_SURFACE:
6488  {
6489  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FilletSurfacePtr( F, Dtk_FilletSurfacePtr::DtkDynamicCast( inSurf ) );
6490  break;
6491  }
6492  case DTK_TYPE_MESH_SURFACE:
6493  {
6494  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MeshSurfacePtr( F, Dtk_MeshSurfacePtr::DtkDynamicCast( inSurf ) );
6495  break;
6496  }
6497  }
6498  fprintf( F, "</Dtk_SurfacePtr>" );
6499  return dtkNoError;
6500  }

◆ Dtk_DumpXml_Dtk_SymbolPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_SymbolPtr ( FILE *  F,
const Dtk_SymbolPtr &  D 
)
2780  {
2781  fprintf( F, "<Dtk_SymbolPtr>\n" );
2782  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_AnnotationPtr( F, Dtk_AnnotationPtr::DtkDynamicCast( D ) ); // upcasting
2783  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"SymbolType", Dtk_Symbol::TypeEnumToString( D->SymbolType() ) );
2784  Dtk_Frame TmpFrame;
2785  D->GetFrame( TmpFrame );
2786  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Frame( F, TmpFrame );
2787  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->Texts() );
2788  fprintf( F, "<Geometry>\n" );
2789  Dtk_Size_t nbgeoms = D->GetNumGeometricalElements();
2790  Dtk_Size_t i;
2791  fprintf( F, "<Num_geometry>" XmlFormat( "u" )"</Num_geometry>\n", nbgeoms );
2792  for( i = 0; i < nbgeoms; i++ )
2793  {
2794  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EntityPtr( F, D->GetGeomElement( i ) );
2795  }
2796  fprintf( F, "</Geometry>\n" );
2797 
2798 
2799  fprintf( F, "</Dtk_SymbolPtr>\n" );
2800  return dtkNoError;
2801  }

◆ Dtk_DumpXml_Dtk_TablePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_TablePtr ( FILE *  F,
const Dtk_TablePtr &  D 
)
2291  {
2292  Dtk_Size_t nbLine, nbCol, i, j;
2293  fprintf( F, "<Dtk_Table>\n" );
2294 
2295  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_AnnotationPtr( F, Dtk_AnnotationPtr::DtkDynamicCast( D ) ); // upcasting
2296  fprintf( F, "<nbRows>" XmlFormat( "u" )"</nbRows>\n", D->getNbrows() );
2297  fprintf( F, "<nbCols>" XmlFormat( "u" )"</nbCols>\n", D->getNbcols() );
2298  nbLine = D->getNbrows();
2299  nbCol = D->getNbcols();
2300  for( i = 0; i < nbLine; i++ )
2301  {
2302  fprintf( F, "<nbCells_in_Line" XmlFormat( "u" )">" XmlFormat( "u" )"</nbCells_in_Line" XmlFormat( "u" )">\n", i, D->Cell_Line( i ), i );
2303  }
2304  for( i = 0; i < nbCol; i++ )
2305  {
2306  fprintf( F, "<nbCells_in_Col" XmlFormat( "u" )">" XmlFormat( "u" )"</nbCells_in_Col" XmlFormat( "u" )">\n", i, D->Cell_Col( i ), i );
2307  }
2308  for( i = 0; i < nbLine; i++ )
2309  {
2310  fprintf( F, "<LineNum" XmlFormat( "u" )">\n", i + 1 );
2311 
2312  for( j = 0; j < nbCol; j++ )
2313  {
2314  fprintf( F, "<ColNum" XmlFormat( "u" )">\n", j + 1 );
2315  if( D->getCell( i, j ).HasText() == DTK_TRUE )
2316  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->Text( i, j ) );
2317  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_OneCell( F, D->getCell( i, j ) );
2318  fprintf( F, "</ColNum" XmlFormat( "u" )">\n", j + 1 );
2319  }
2320  fprintf( F, "</LineNum" XmlFormat( "u" )">\n", i + 1 );
2321  }
2322 
2323  fprintf( F, "</Dtk_Table>\n" );
2324  return dtkNoError;
2325  }

◆ Dtk_DumpXml_Dtk_Text()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Text ( FILE *  F,
const Dtk_Text &  T 
)
1219  {
1220  Dtk_string str = T.Text();
1221 
1222  fprintf( F, "<Dtk_Text>\n" );
1223  if( str.len() )
1224  {
1225  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, T.GetInfo() );
1226  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text_DTK_Text_type( F, T.TextType() );
1227  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text_DTK_Text_subtype( F, T.TextSubType() );
1228  Dtk_Frame TmpFrame;
1229  T.GetFrame( TmpFrame );
1230  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Frame( F, TmpFrame );
1231  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_TextStyle( F, T.TextStyle() );
1232  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"text", str );
1233  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, T.GetInnerBoundingBox() );
1234  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, T.GetOuterBoundingBox() );
1235  }
1236  else
1237  {
1238  fprintf( F, "Empty" );
1239  }
1240 
1241  fprintf( F, "</Dtk_Text>\n" );
1242  return dtkNoError;
1243  }

◆ Dtk_DumpXml_Dtk_Text_DTK_Text_subtype()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Text_DTK_Text_subtype ( FILE *  F,
const DTK_Text_subtype &  subType 
)
1019  {
1020  if( subType.IsNotDefined() )
1021  return dtkNoError;
1022 
1023  fprintf( F, "<DTK_Text_subtype>" );
1024 
1025  if( subType.IsDual() )
1026  {
1027  fprintf( F, "DTK_TEXTSUBTYPE_DUAL;" );
1028  }
1029  if( subType.IsLeftText() )
1030  {
1031  fprintf( F, "DTK_TEXTSUBTYPE_LEFT;" );
1032  }
1033  if( subType.IsRightText() )
1034  {
1035  fprintf( F, "DTK_TEXTSUBTYPE_RIGHT;" );
1036  }
1037  if( subType.IsUpText() )
1038  {
1039  fprintf( F, "DTK_TEXTSUBTYPE_UP;" );
1040  }
1041  if( subType.IsDownText() )
1042  {
1043  fprintf( F, "DTK_TEXTSUBTYPE_DOWN;" );
1044  }
1045  if( subType.IsPrefix() )
1046  {
1047  fprintf( F, "DTK_TEXTSUBTYPE_PREFIX;" );
1048  }
1049  if( subType.IsSuffix() )
1050  {
1051  fprintf( F, "DTK_TEXTSUBTYPE_SUFFIX;" );
1052  }
1053  if( subType.IsChamfersign() )
1054  {
1055  fprintf( F, "DTK_TEXTSUBTYPE_CHAMFERSIGN;" );
1056  }
1057  if( subType.IsChamferright() )
1058  {
1059  fprintf( F, "DTK_TEXTSUBTYPE_CHAMFERRIGHT;" );
1060  }
1061  if( subType.IsMainvalpart() )
1062  {
1063  fprintf( F, "DTK_TEXTSUBTYPE_MAINVALPART;" );
1064  }
1065  if( subType.IsBasisval() )
1066  {
1067  fprintf( F, "DTK_TEXTSUBTYPE_BASISVAL;" );
1068  }
1069  if( subType.IsPow() )
1070  {
1071  fprintf( F, "DTK_TEXTSUBTYPE_POW;" );
1072  }
1073  if( subType.IsUpperFrac() )
1074  {
1075  fprintf( F, "DTK_TEXTSUBTYPE_UPPERFRAC;" );
1076  }
1077  if( subType.IsFractionBar() )
1078  {
1079  fprintf( F, "DTK_TEXTSUBTYPE_FRACTION_BAR;" );
1080  }
1081  if( subType.IsLowerFrac() )
1082  {
1083  fprintf( F, "DTK_TEXTSUBTYPE_LOWERFRAC;" );
1084  }
1085  if( subType.IsValSplitPart1() )
1086  {
1087  fprintf( F, "DTK_TEXTSUBTYPE_VALSPLITPART1;" );
1088  }
1089  if( subType.IsValSplitPart2() )
1090  {
1091  fprintf( F, "DTK_TEXTSUBTYPE_VALSPLITPART2;" );
1092  }
1093  if( subType.IsValSplitPart3() )
1094  {
1095  fprintf( F, "DTK_TEXTSUBTYPE_VALSPLITPART3;" );
1096  }
1097  if( subType.IsTolBloc() )
1098  {
1099  fprintf( F, "DTK_TEXTSUBTYPE_TOLBLOC;" );
1100  }
1101  if( subType.IsTolValPart() )
1102  {
1103  fprintf( F, "DTK_TEXTSUBTYPE_TOLVALPART;" );
1104  }
1105  if( subType.IsTolUpperTol() )
1106  {
1107  fprintf( F, "DTK_TEXTSUBTYPE_UPPERTOL;" );
1108  }
1109  if( subType.IsTolLowerTol() )
1110  {
1111  fprintf( F, "DTK_TEXTSUBTYPE_LOWERTOL;" );
1112  }
1113  if( subType.IsTolSymetricalTol() )
1114  {
1115  fprintf( F, "DTK_TEXTSUBTYPE_SYMETRICALTOL;" );
1116  }
1117  if( subType.IsTolSign() )
1118  {
1119  fprintf( F, "DTK_TEXTSUBTYPE_TOLSIGN;" );
1120  }
1121  if( subType.IsTolPrefix() )
1122  {
1123  fprintf( F, "DTK_TEXTSUBTYPE_TOLPREFIX;" );
1124  }
1125  if( subType.IsTolLeftParenthesis() )
1126  {
1127  fprintf( F, "DTK_TEXTSUBTYPE_LEFTPARENTHESIS;" );
1128  }
1129  if( subType.IsTolRightParenthesis() )
1130  {
1131  fprintf( F, "DTK_TEXTSUBTYPE_RIGHTPARENTHESIS;" );
1132  }
1133  if( subType.IsUrl() )
1134  {
1135  fprintf( F, "DTK_TEXTSUBTYPE_URL;" );
1136  }
1137  if( subType.IsSeparator() )
1138  {
1139  fprintf( F, "DTK_TEXTSUBTYPE_SEPARATOR;" );
1140  }
1141  fprintf( F, "</DTK_Text_subtype>\n" );
1142  return dtkNoError;
1143  }

◆ Dtk_DumpXml_Dtk_Text_DTK_Text_type()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Text_DTK_Text_type ( FILE *  F,
const DTK_Text_type &  D 
)
981  {
982  fprintf( F, "<DTK_Text_type>" );
983  switch( D )
984  {
985  default:
986  case dtk_text_type_undefined: fprintf( F, "dtk_text_type_undefined" ); break;
987  case dtk_text_type_prefix: fprintf( F, "dtk_text_type_prefix" ); break;
988  case dtk_text_type_symbol: fprintf( F, "dtk_text_type_symbol" ); break;
989  case dtk_text_type_value: fprintf( F, "dtk_text_type_value" ); break;
990  case dtk_text_type_valueaff: fprintf( F, "dtk_text_type_valueaff" ); break;
991  case dtk_text_type_fakevalue: fprintf( F, "dtk_text_type_fakevalue" ); break;
992  case dtk_text_type_unit: fprintf( F, "dtk_text_type_unit" ); break;
993  case dtk_text_type_tolerance: fprintf( F, "dtk_text_type_tolerance" ); break;
994  case dtk_text_type_suffix: fprintf( F, "dtk_text_type_suffix" ); break;
995  case dtk_text_type_text_add: fprintf( F, "dtk_text_type_text_add" ); break;
996  case dtk_text_type_modifier: fprintf( F, "dtk_text_type_modifier" ); break;
997  case dtk_text_type_reference: fprintf( F, "dtk_text_type_reference" ); break;
998  case dtk_text_type_upper_text: fprintf( F, "dtk_text_type_upper_text" ); break;
999  case dtk_text_type_lower_text: fprintf( F, "dtk_text_type_lower_text" ); break;
1000  case dtk_text_type_roughness_text1: fprintf( F, "dtk_text_type_roughness_text1" ); break;
1001  case dtk_text_type_roughness_text2: fprintf( F, "dtk_text_type_roughness_text2" ); break;
1002  case dtk_text_type_roughness_text3: fprintf( F, "dtk_text_type_roughness_text3" ); break;
1003  case dtk_text_type_roughness_text4: fprintf( F, "dtk_text_type_roughness_text4" ); break;
1004  case dtk_text_type_roughness_text5: fprintf( F, "dtk_text_type_roughness_text5" ); break;
1005  case dtk_text_type_roughness_text6: fprintf( F, "dtk_text_type_roughness_text6" ); break;
1006  case dtk_text_type_roughness_mode: fprintf( F, "dtk_text_type_roughness_mode" ); break;
1007  case dtk_text_type_roughness_type: fprintf( F, "dtk_text_type_roughness_type" ); break;
1008  case dtk_text_type_roughness_contact_area: fprintf( F, "dtk_text_type_roughness_contact_area" ); break;
1009  case dtk_text_type_text_add_left: fprintf( F, "dtk_text_type_text_add_left" ); break;
1010  case dtk_text_type_text_add_right: fprintf( F, "dtk_text_type_text_add_right" ); break;
1011  case dtk_text_type_text_add_top: fprintf( F, "dtk_text_type_text_add_top" ); break;
1012  case dtk_text_type_text_add_bottom: fprintf( F, "dtk_text_type_text_add_bottom" ); break;
1013  }
1014  fprintf( F, "</DTK_Text_type>\n" );
1015  return dtkNoError;
1016  }

◆ Dtk_DumpXml_Dtk_TextStyle()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_TextStyle ( FILE *  F,
const Dtk_TextStyle &  T 
)
958  {
959  fprintf( F, "<Dtk_TextStyle>\n" );
960  fprintf( F, "<char_height>%f</char_height>\n", T.CharHeight() ); // height of the bounding box : use offset to compute pure char height
961  fprintf( F, "<char_width>%f</char_width>\n", T.CharWidth() ); // same for width
962  fprintf( F, "<char_spacing>%f</char_spacing>\n", T.CharSpacing() ); // space between 2 characters.
963  fprintf( F, "<line_spacing>%f</line_spacing>\n", T.LineSpacing() ); // line spacing
964  fprintf( F, "<slant>%f</slant>\n", T.Slant() ); // line spacing
965  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FontStyle", Dtk_TextStyle::FontStyleEnumToString( T.FontStyle() ) );
966  Dtk_DumpXml_TextAttributeEnum( F, T.Attributes(), L"Attributes" );
967 
968  if( T.Justification() != Dtk_TextStyle::JustificationNone )
969  {
970  Dtk_DumpXml_TextJustificationEnum( F, T.Justification(), L"Justification" );
971  }
972 
973  fprintf( F, "<ratio>%f</ratio>\n", T.Ratio() ); // ratio
974  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Font( F, T.Font() );
975  fprintf( F, "</Dtk_TextStyle>\n" );
976  return dtkNoError;
977  }

◆ Dtk_DumpXml_Dtk_Texture()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_Texture ( FILE *  F,
const Dtk_TextureInfosPtr &  inTexture 
)
3688  {
3689  fprintf( F, "<Dtk_TextureInfosPtr>\n" );
3690  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"ImagePath", inTexture->GetImagePath() );
3691  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"ImageSize", inTexture->GetImageSize() );
3692  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"MappingType", inTexture->GetMappingType() );
3693  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"RotateAngle", inTexture->GetRotateAngle(), "%g" );
3694  fprintf( F, "<UOffset>%g</UOffset>\n", inTexture->GetUOffset() );
3695  fprintf( F, "<VOffset>%g</VOffset>\n", inTexture->GetVOffset() );
3696  fprintf( F, "<UScale>%g</UScale>\n", inTexture->GetUScale() );
3697  fprintf( F, "<VScale>%g</VScale>\n", inTexture->GetVScale() );
3698  fprintf( F, "<UFlipped>%d</UFlipped>\n", inTexture->IsUFlipped() );
3699  fprintf( F, "<VFlipped>%d</VFlipped>\n", inTexture->IsVFlipped() );
3700  Dtk_transfoPtr transf = inTexture->GetTransfo();
3701  if( transf.IsNotNULL() )
3702  {
3703  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, *( transf ).operator->() );
3704  }
3705  fprintf( F, "</Dtk_TextureInfosPtr>\n" );
3706  return dtkNoError;
3707  }

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr ( FILE *  F,
const Dtk_ToleranceSpecificationContainerPtr &  D 
)
2525  {
2526  fprintf( F, "<Dtk_ToleranceSpecificationContainerPtr>\n" );
2527  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType( F, D->ToleranceSpecificationContainerType() );
2528  //We retrieve the TolType BBoxes
2529  Dtk_Oriented2dBBox TmpBBox;
2530  D->GetToleranceTypeOuterBoundingBox( TmpBBox );
2531  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, TmpBBox, L"TopSpecContTypeOuterBBox" );
2532  D->GetToleranceTypeInnerBoundingBox( TmpBBox );
2533  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, TmpBBox, L"TopSpecContTypeInnerBBox" );
2534  fprintf( F, "<TopText>\n" ); Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->TopTextAsCompositeText() ); fprintf( F, "</TopText>\n" );
2535  fprintf( F, "<BottomText>\n" ); Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->BottomTextAsCompositeText() ); fprintf( F, "</BottomText>\n" );
2536  fprintf( F, "<RightText>\n" ); Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->RightTextAsCompositeText() ); fprintf( F, "</RightText>\n" );
2537  fprintf( F, "<LeftText>\n" ); Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->LeftTextAsCompositeText() ); fprintf( F, "</LeftText>\n" );
2538 
2539  Dtk_Size_t i, nbtolspecs;
2540  nbtolspecs = D->GetNumToleranceSpecifications();
2541  fprintf( F, "<tol_specs num_tol_specs = \"" XmlFormat( "u" )"\">\n", nbtolspecs );
2542  for( i = 0; i < nbtolspecs; i++ )
2543  {
2544  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ToleranceSpecificationPtr( F, D->GetToleranceSpecification( i ) );
2545  }
2546  fprintf( F, "</tol_specs>\n" );
2547  fprintf( F, "</Dtk_ToleranceSpecificationContainerPtr>\n" );
2548  return dtkNoError;
2549  }

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType ( FILE *  F,
const Dtk_ToleranceSpecificationContainer::TypeEnum &  D 
)
2651  {
2652  fprintf( F, "<ToleranceSpecificationContainerType>" );
2653  switch( D )
2654  {
2655  default:
2656  case Dtk_ToleranceSpecificationContainer::Typeunknown:
2657  fprintf( F, "TypeUnknown" );
2658  break;
2659  case Dtk_ToleranceSpecificationContainer::TypeStraightness:
2660  fprintf( F, "TypeStraightness" );
2661  break;
2662  case Dtk_ToleranceSpecificationContainer::TypeFlatness:
2663  fprintf( F, "TypeFlatness" );
2664  break;
2665  case Dtk_ToleranceSpecificationContainer::TypeCircularity:
2666  fprintf( F, "TypeCircularity" );
2667  break;
2668  case Dtk_ToleranceSpecificationContainer::TypeCylindricity:
2669  fprintf( F, "TypeCylindricity" );
2670  break;
2671  case Dtk_ToleranceSpecificationContainer::TypeLineProfile:
2672  fprintf( F, "TypeLineProfile" );
2673  break;
2674  case Dtk_ToleranceSpecificationContainer::TypeSurfaceProfile:
2675  fprintf( F, "TypeSurfaceProfile" );
2676  break;
2677  case Dtk_ToleranceSpecificationContainer::TypeAngularity:
2678  fprintf( F, "TypeAngularity" );
2679  break;
2680  case Dtk_ToleranceSpecificationContainer::TypePerpendicularity:
2681  fprintf( F, "TypePerpendicularity" );
2682  break;
2683  case Dtk_ToleranceSpecificationContainer::TypeParallelism:
2684  fprintf( F, "TypeParallelism" );
2685  break;
2686  case Dtk_ToleranceSpecificationContainer::TypePosition:
2687  fprintf( F, "TypePosition" );
2688  break;
2689  case Dtk_ToleranceSpecificationContainer::TypeConcentricity:
2690  fprintf( F, "TypeConcentricity" );
2691  break;
2692  case Dtk_ToleranceSpecificationContainer::TypeSymmetry:
2693  fprintf( F, "TypeSymmetry" );
2694  break;
2695  case Dtk_ToleranceSpecificationContainer::TypeCircularRunout:
2696  fprintf( F, "TypeCircularRunout" );
2697  break;
2698  case Dtk_ToleranceSpecificationContainer::TypeTotalRunout:
2699  fprintf( F, "TypeTotalRunout" );
2700  break;
2701  case Dtk_ToleranceSpecificationContainer::TypeAxisIntersection:
2702  fprintf( F, "TypeAxisIntersection" );
2703  break;
2704  }
2705  fprintf( F, "</ToleranceSpecificationContainerType>\n" );
2706  return dtkNoError;
2707  }

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationPtr ( FILE *  F,
const Dtk_ToleranceSpecificationPtr &  D 
)
2709  {
2710  fprintf( F, "<Dtk_ToleranceSpecificationPtr>\n" );
2711 
2712  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ReferenceFramePtr( F, D->ReferenceFrame() );
2713 
2714  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->GetMainValue() );
2715  //Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir(F, D->GetXAxis(), "X_axis");
2716  //Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir(F, D->GetYAxis(), "Y_axis");
2717  Dtk_DumpXMLNamespace::Dtk_DumpXml_DTK_FDT_MODIFIER( F, D->GetMaterialModifier() );
2718  fprintf( F, "<FreeStateModifier>" );
2719  if( D->HasFreeStateModifier() == DTK_TRUE )
2720  fprintf( F, "Present" );
2721  else
2722  fprintf( F, "Not Present" );
2723  fprintf( F, "</FreeStateModifier>" );
2724  for( Dtk_Size_t i = 0; i < D->GetNumIndicators(); ++i )
2725  {
2726  Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr( F, D->GetIndicator( i ) );
2727  }
2728  fprintf( F, "</Dtk_ToleranceSpecificationPtr>\n" );
2729  return dtkNoError;
2730  }

◆ Dtk_DumpXml_Dtk_ToroidalSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToroidalSurfacePtr ( FILE *  F,
const Dtk_ToroidalSurfacePtr &  inSurf 
)
6250  {
6251  fprintf( F, "<Dtk_ToroidalSurfacePtr>" );
6252 
6253  fprintf( F, "<AxisPosition>" );
6254  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inSurf->GetAxisPosition() );
6255  fprintf( F, "</AxisPosition>" );
6256  fprintf( F, "<RevolutionAxis>" );
6257  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetRevolutionAxis() );
6258  fprintf( F, "</RevolutionAxis>" );
6259  fprintf( F, "<MinorRadius>%f</MinorRadius>", inSurf->GetMinorRadius() );
6260  fprintf( F, "<MajorRadius>%f</MajorRadius>", inSurf->GetMajorRadius() );
6261 
6262  fprintf( F, "</Dtk_ToroidalSurfacePtr>" );
6263  return dtkNoError;
6264 
6265  }

◆ Dtk_DumpXml_Dtk_transfo()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_transfo ( FILE *  F,
const Dtk_transfo &  T 
)
4363  {
4364  fprintf( F, "<Transfo_matrix>\n" );
4365  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getXdir(), "X" );
4366  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getYdir(), "Y" );
4367  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getZdir(), "Z" );
4368  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, T.getOrigin(), "Origin" );
4369  fprintf( F, "<Scale>%f</Scale>\n", T.getScale() );
4370  fprintf( F, "</Transfo_matrix>\n" );
4371  return dtkNoError;
4372  }

◆ Dtk_DumpXml_Dtk_TransformedSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_TransformedSurfacePtr ( FILE *  F,
const Dtk_TransformedSurfacePtr &  inSurf 
)
6355  {
6356  fprintf( F, "<Dtk_TransformedSurfacePtr>" );
6357  fprintf( F, "<Transformation>" );
6358  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inSurf->GetTransformation() );
6359  fprintf( F, "</Transformation>" );
6360  fprintf( F, "<BasisSurface>" );
6361  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_SurfacePtr( F, inSurf->GetSurface() );
6362  fprintf( F, "</BasisSurface>" );
6363 
6364  fprintf( F, "</Dtk_TransformedSurfacePtr>" );
6365  return dtkNoError;
6366  }

◆ Dtk_DumpXml_Dtk_val()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_val ( FILE *  F,
const Dtk_Val &  V 
)
3556  {
3557  switch( V.GetValType() )
3558  {
3559  case DTK_VAL_TYPE_INT:
3560  fprintf( F, "<int>%d</int>\n", V.GetInt() );
3561  break;
3562  case DTK_VAL_TYPE_CHAR:
3563  fprintf( F, "<char>%d</char>\n", V.GetChar() );
3564  break;
3565  case DTK_VAL_TYPE_DOUBLE:
3566  fprintf( F, "<double>%f</double>\n", V.GetDouble() );
3567  break;
3568  case DTK_VAL_TYPE_STRING:
3569  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"string", V.GetString() );
3570  break;
3571  case DTK_VAL_TYPE_RGB:
3572  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RGB( F, V.GetRgb() );
3573  break;
3574  case DTK_VAL_TYPE_PNT:
3575  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, V.GetPnt() );
3576  break;
3577  case DTK_VAL_TYPE_DIR:
3578  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, V.GetDir() );
3579  break;
3580  case DTK_VAL_TYPE_UUID:
3581  {
3582  Dtk_UUID TmpUUid = V.GetUuid();
3583  int i;
3584  unsigned char tmpCharTab[ 16 ] = { 0 };
3585 
3586  for( i = 0; i < 4; i++ )
3587  {
3588  Dtk_Int32 tmp_val = TmpUUid[ i ];
3589  tmpCharTab[ i * 4 + 3 ] = static_cast< unsigned char >( tmp_val & 0x000000FF );
3590  tmp_val = tmp_val >> 8;
3591  tmpCharTab[ i * 4 + 2 ] = static_cast< unsigned char >( tmp_val & 0x000000FF );
3592  tmp_val = tmp_val >> 8;
3593  tmpCharTab[ i * 4 + 1 ] = static_cast< unsigned char >( tmp_val & 0x000000FF );
3594  tmp_val = tmp_val >> 8;
3595  tmpCharTab[ i * 4 ] = static_cast< unsigned char >( tmp_val & 0x000000FF );
3596  }
3597 
3598  fprintf( F, "<UUID>\"" );
3599  for( i = 0; i < 16; i++ )
3600  {
3601  fprintf( F, " %3u", tmpCharTab[ i ] );
3602  }
3603  fprintf( F, "\"</UUID>\n" );
3604  break;
3605  }
3606  case DTK_VAL_TYPE_INTARRAY:
3607  {
3608  fprintf( F, "<int>" );
3609  Dtk_tab< Dtk_Int32> Int_arr = V.GetIntArray();
3610  Dtk_Int32 nb_int = ( Dtk_Int32 )Int_arr.size();
3611  for( Dtk_Int32 i = 0; i < nb_int - 1; i++ )
3612  {
3613  fprintf( F, "%d,", Int_arr[ i ] );
3614  }
3615  if( nb_int )fprintf( F, "%d", Int_arr[ nb_int - 1 ] );
3616  fprintf( F, "</int>\n" );
3617 
3618  break;
3619  }
3620  case DTK_VAL_TYPE_UNKNOWN:
3621  default:
3622  fprintf( F, "Unknown Dtk_Val type" );
3623  }
3624  return dtkNoError;
3625  }

◆ Dtk_DumpXml_Dtk_VertexPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_VertexPtr ( FILE *  F,
const Dtk_VertexPtr &  inVertex 
)
6518  {
6519  Dtk_PointPtr point;
6520  fprintf( F, "<Dtk_VertexPtr>" );
6521  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVertex->get_info() );
6522 
6523  Dtk_Double64 tolerance = 0.0;
6524  if( inVertex->GetTolerance( tolerance ) == dtkNoError )
6525  {
6526  fprintf( F, "<tolerance>%f</tolerance>", tolerance );
6527  }
6528 
6529  // fprintf(F,"<Id>%d</Id>",inVertex->GetID());
6530  point = inVertex->GetGeom();
6531  if( point.IsNotNULL() )
6532  {
6533  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_PointPtr( F, point );
6534  }
6535 
6536  fprintf( F, "</Dtk_VertexPtr>" );
6537  return dtkNoError;
6538  }

◆ Dtk_DumpXml_Dtk_ViewDisplayDisplayMode3DEnum()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewDisplayDisplayMode3DEnum ( FILE *  F,
const Dtk_ViewDisplay::DisplayMode3DEnum &  inVal 
)
2887  {
2888  fprintf( F, "<DisplayMode3DEnum>" );
2889  switch( inVal )
2890  {
2891  case Dtk_ViewDisplay::DefaultDisplay:
2892  fprintf( F, "DefaultDisplay" );
2893  break;
2894 
2895  case Dtk_ViewDisplay::WireframeDisplay:
2896  fprintf( F, "WireframeDisplay" );
2897  break;
2898 
2899  case Dtk_ViewDisplay::WithHiddenDisplay:
2900  fprintf( F, "WithHiddenDisplay" );
2901  break;
2902 
2903  case Dtk_ViewDisplay::NoHiddenDisplay:
2904  fprintf( F, "NoHiddenDisplay" );
2905  break;
2906 
2907  case Dtk_ViewDisplay::ShadingDisplay:
2908  fprintf( F, "ShadingDisplay" );
2909  break;
2910 
2911  case Dtk_ViewDisplay::ShadingWithEdgeDisplay:
2912  fprintf( F, "ShadingWithEdgeDisplay" );
2913  break;
2914  }
2915  fprintf( F, "</DisplayMode3DEnum>" );
2916  return dtkNoError;
2917 
2918  }

◆ Dtk_DumpXml_Dtk_ViewDisplayPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewDisplayPtr ( FILE *  F,
const Dtk_ViewDisplayPtr &  V 
)
2921  {
2922  fprintf( F, "<Dtk_ViewDisplayPtr>\n" );
2923 
2924  fprintf( F, "<DisplayMode>" );
2925  Dtk_DumpXml_Dtk_ViewDisplayDisplayMode3DEnum( F, V->GetDisplayMode() );
2926  fprintf( F, "</DisplayMode>" );
2927 
2928  Dtk_FontLineType lineFont;
2929  Dtk_Double64 lineWidth;
2930  Dtk_RGB lineColor;
2931 
2932  V->GetTangentEdgesLineStyle( lineFont, lineWidth, lineColor );
2933 
2934  fprintf( F, "<TangentEdgesLineStyle>" );
2935  Dtk_DumpXml_Dtk_FontLineTypeEnum( F, lineFont, "tangentLineType" );
2936  fprintf( F, "<Width>%f</Width>\n", lineWidth );
2937  Dtk_DumpXml_Dtk_RGB( F, lineColor );
2938  fprintf( F, "</TangentEdgesLineStyle>" );
2939 
2940  V->GetVisibleEdgesLineStyle( lineFont, lineWidth, lineColor );
2941 
2942  fprintf( F, "<VisibleEdgesLineStyle>" );
2943  Dtk_DumpXml_Dtk_FontLineTypeEnum( F, lineFont, "visibleLineType" );
2944  fprintf( F, "<Width>%f</Width>\n", lineWidth );
2945  Dtk_DumpXml_Dtk_RGB( F, lineColor );
2946  fprintf( F, "</VisibleEdgesLineStyle>" );
2947 
2948  V->GetHiddenEdgesLineStyle( lineFont, lineWidth, lineColor );
2949 
2950  fprintf( F, "<HiddenEdgesLineStyle>" );
2951  Dtk_DumpXml_Dtk_FontLineTypeEnum( F, lineFont, "hiddenLineType" );
2952  fprintf( F, "<Width>%f</Width>\n", lineWidth );
2953  Dtk_DumpXml_Dtk_RGB( F, lineColor );
2954  fprintf( F, "</HiddenEdgesLineStyle>" );
2955 
2956  fprintf( F, "</Dtk_ViewDisplayPtr>\n" );
2957  return dtkNoError;
2958  }

◆ Dtk_DumpXml_Dtk_ViewPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewPtr ( FILE *  F,
const Dtk_ViewPtr &  V,
const int &  compact 
)
2961  {
2962  Dtk_Size_t i;
2963  fprintf( F, "<Dtk_ViewPtr>\n" );
2964  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, V->info() );
2965  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, V->TransformationMatrix() );
2966  fprintf( F, "<Scale>%f</Scale>\n", V->Scale() );
2967  fprintf( F, "<Angle>%f</Angle>\n", V->Angle() );
2968  if( !V->IsView( Dtk_View::NoTypeView ) )
2969  {
2970  fprintf( F, "<ViewTypes>\n" );
2971  if( V->IsView( Dtk_View::SectionView ) )
2972  fprintf( F, "<ViewType>SectionView</ViewType>\n" );
2973  if( V->IsView( Dtk_View::BrokenView ) )
2974  fprintf( F, "<ViewType>BrokenView</ViewType>\n" );
2975  if( V->IsView( Dtk_View::DetailView ) )
2976  fprintf( F, "<ViewType>DetailView</ViewType>\n" );
2977  if( V->IsView( Dtk_View::TitleBlockView ) )
2978  fprintf( F, "<ViewType>TitleBlockView</ViewType>\n" );
2979  if( V->IsView( Dtk_View::SheetView ) )
2980  fprintf( F, "<ViewType>SheetView</ViewType>\n" );
2981  fprintf( F, "</ViewTypes>\n" );
2982  }
2983  else
2984  {
2985  fprintf( F, "<ViewType>NoViewType</ViewType>\n" );
2986  }
2987  Dtk_ViewDisplayPtr viewDisplay = V->GetViewDisplay();
2988  if( viewDisplay )
2989  {
2990  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ViewDisplayPtr( F, V->GetViewDisplay() );
2991  }
2992 
2993  fprintf( F, "<ClippingPlanes>\n" );
2994  for( i = 0; i < 6; i++ )
2995  {
2996  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EntityPtr( F, Dtk_EntityPtr::DtkDynamicCast( V->GetClipping( i ) ) );
2997  }
2998  fprintf( F, "</ClippingPlanes>\n" );
2999 
3000  if( V->GetClippingBoundary().IsNotNULL() )
3001  {
3002  fprintf( F, "<ClippingBoundary>\n" );
3003  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EntityPtr( F, Dtk_EntityPtr::DtkDynamicCast( V->GetClippingBoundary() ) );
3004  fprintf( F, "</ClippingBoundary>\n" );
3005  }
3006 
3007  fprintf( F, "<Geometry><Number>" XmlFormat( "u" )"</Number>\n", V->GetNum2dGeometricalEntity() );
3008  for( i = 0; i < V->GetNum2dGeometricalEntity(); i++ )
3009  {
3010  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EntityPtr( F, V->Get2dGeometricalEntity( i ) );
3011  fprintf( F, "\n" );
3012  }
3013  fprintf( F, "</Geometry>\n" );
3014  fprintf( F, "<Annotations><Number>" XmlFormat( "u" )"</Number>\n", V->GetNum2dEntities() );
3015  for( i = 0; i < V->GetNum2dEntities(); i++ )
3016  {
3017  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_2dEntityPtr( F, V->Get2dEntity( i ), compact );
3018  fprintf( F, "\n" );
3019  }
3020  fprintf( F, "</Annotations>\n" );
3021 
3022  fprintf( F, "<Pictures><Number>" XmlFormat( "u" )"</Number>\n", V->GetNumPictures() );
3023  for( i = 0; i < V->GetNumPictures(); i++ )
3024  {
3025  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Picture( F, V->GetPicture( i ).operator ->() );
3026  fprintf( F, "\n" );
3027  }
3028  fprintf( F, "</Pictures>\n" );
3029 
3030  fprintf( F, "<OleObjects><Number>" XmlFormat( "u" )"</Number>\n", V->GetNumOLEObjects() );
3031  for( i = 0; i < V->GetNumOLEObjects(); i++ )
3032  {
3033  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_OLEObjectPtr( F, V->GetOLEObject( i ).operator ->() );
3034  fprintf( F, "\n" );
3035  }
3036  fprintf( F, "</OleObjects>\n" );
3037 
3038  fprintf( F, "</Dtk_ViewPtr>\n" );
3039  return dtkNoError;
3040  }

◆ Dtk_DumpXml_Dtk_VolumePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_VolumePtr ( FILE *  F,
const Dtk_VolumePtr &  inVol 
)
6677  {
6678  Dtk_Size_t numShell, i;
6679 
6680  fprintf( F, "<Dtk_VolumePtr>" );
6681  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVol->get_info() );
6682  // fprintf(F,"<Id>%d</Id>",inVol->GetID());
6683  numShell = inVol->GetNumShells();
6684  for( i = 0; i < numShell; i++ )
6685  {
6686  Dtk_ShellPtr shell;
6687  inVol->GetShell( i, shell );
6688  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ShellPtr( F, shell );
6689 
6690  }
6691  fprintf( F, "</Dtk_VolumePtr>" );
6692  return dtkNoError;
6693  }

◆ Dtk_DumpXml_Dtk_welding_complementary_symbol()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_complementary_symbol ( FILE *  F,
const Dtk_Welding::ComplementarySymbolEnum &  D 
)
1733  {
1734  switch( D )
1735  {
1736  default:
1737  case Dtk_Welding::ComplementarySymbolNone:
1738  fprintf( F, "DTK_WELDING_COMPEMENTARY_SYMBOL_NONE" );
1739  break;
1740  case Dtk_Welding::ComplementarySymbolWeldWithFlatFace:
1741  fprintf( F, "DTK_WELDING_COMPEMENTARY_SYMBOL_WELD_WITH_FLAT_FACE" );
1742  break;
1743  case Dtk_Welding::ComplementarySymbolWeldWithConvexFace:
1744  fprintf( F, "DTK_WELDING_COMPEMENTARY_SYMBOL_WELD_WITH_CONVEX_FACE" );
1745  break;
1746  case Dtk_Welding::ComplementarySymbolWeldWithConcaveFace:
1747  fprintf( F, "DTK_WELDING_COMPEMENTARY_SYMBOL_WELD_WITH_CONCAVE_FACE" );
1748  break;
1749  case Dtk_Welding::ComplementarySymbolFlushFinishedWeld:
1750  fprintf( F, "DTK_WELDING_COMPEMENTARY_SYMBOL_FLUSH_FINISHED_WELD" );
1751  break;
1752  case Dtk_Welding::ComplementarySymbolFilletWeldWithSmoothBlendedFace:
1753  fprintf( F, "DTK_WELDING_COMPEMENTARY_SYMBOL_FILLET_WELD_WITH_SMOOTH_BLENDED_FACE" );
1754  break;
1755  }
1756  return dtkNoError;
1757  }

◆ Dtk_DumpXml_Dtk_welding_finish_symbol()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_finish_symbol ( FILE *  F,
const Dtk_Welding::FinishSymbolEnum &  D 
)
1761  {
1762  switch( D )
1763  {
1764  case Dtk_Welding::FinishSymbolChip:
1765  fprintf( F, "DTK_WELDING_FINISH_SYMBOL_CHIP" );
1766  break;
1767  case Dtk_Welding::FinishSymbolFlush:
1768  fprintf( F, "DTK_WELDING_FINISH_SYMBOL_FLUSH" );
1769  break;
1770  case Dtk_Welding::FinishSymbolGrind:
1771  fprintf( F, "DTK_WELDING_FINISH_SYMBOL_GRIND" );
1772  break;
1773  case Dtk_Welding::FinishSymbolHammer:
1774  fprintf( F, "DTK_WELDING_FINISH_SYMBOL_HAMMER" );
1775  break;
1776  case Dtk_Welding::FinishSymbolMachine:
1777  fprintf( F, "DTK_WELDING_FINISH_SYMBOL_MACHINE" );
1778  break;
1779  case Dtk_Welding::FinishSymbolRoll:
1780  fprintf( F, "DTK_WELDING_FINISH_SYMBOL_ROLL" );
1781  break;
1782  case Dtk_Welding::FinishSymbolUnspecified:
1783  fprintf( F, "DTK_WELDING_FINISH_SYMBOL_UNSPECIFIED" );
1784  break;
1785  default:
1786  case Dtk_Welding::FinishSymbolNone:
1787  fprintf( F, "DTK_WELDING_FINISH_SYMBOL_NONE" );
1788  break;
1789  };
1790  return dtkNoError;
1791  }

◆ Dtk_DumpXml_Dtk_welding_symbol()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_symbol ( FILE *  F,
const Dtk_Welding::WeldingSymbolEnum &  D 
)
1633  {
1634  switch( D )
1635  {
1636  default:
1637  case Dtk_Welding::SymbolNone:
1638  fprintf( F, "DTK_WELDING_SYMBOL_NONE" );
1639  break;
1640  case Dtk_Welding::SymbolSquareButtWeld:
1641  fprintf( F, "DTK_WELDING_SYMBOL_SQUARE_BUTT_WELD" );
1642  break;
1643  case Dtk_Welding::SymbolSingeVButtWeld:
1644  fprintf( F, "DTK_WELDING_SYMBOL_SINGLE_V_BUTT_WELD" );
1645  break;
1646  case Dtk_Welding::SymbolSingleBevelButtWeld:
1647  fprintf( F, "DTK_WELDING_SYMBOL_SINGLE_BEVEL_BUTT_WELD" );
1648  break;
1649  case Dtk_Welding::SymbolFlareVButtWeld:
1650  fprintf( F, "DTK_WELDING_SYMBOL_FLARE_V_BUTT_WELD" );
1651  break;
1652  case Dtk_Welding::SymbolFlareBevelButtWeld:
1653  fprintf( F, "DTK_WELDING_SYMBOL_FLARE_BEVEL_BUTT_WELD" );
1654  break;
1655  case Dtk_Welding::SymbolSingleUButtWeld:
1656  fprintf( F, "DTK_WELDING_SYMBOL_SINGLE_U_BUTT_WELD" );
1657  break;
1658  case Dtk_Welding::SymbolSingleJButtWeld:
1659  fprintf( F, "DTK_WELDING_SYMBOL_SINGLE_J_BUTT_WELD" );
1660  break;
1661  case Dtk_Welding::SymbolFilletWeld:
1662  fprintf( F, "DTK_WELDING_SYMBOL_FILLET_WELD" );
1663  break;
1664  case Dtk_Welding::SymbolSpotWeld:
1665  fprintf( F, "DTK_WELDING_SYMBOL_SPOT_WELD" );
1666  break;
1667  case Dtk_Welding::SymbolBackWeld:
1668  fprintf( F, "DTK_WELDING_SYMBOL_BACK_WELD" );
1669  break;
1670  case Dtk_Welding::SymbolSteepFlankedSingleBevelButtWeld:
1671  fprintf( F, "DTK_WELDING_SYMBOL_STEEP_FLANKED_SINGLE_BEVEL_BUTT_WELD" );
1672  break;
1673  case Dtk_Welding::SymbolSteepFlankedSingleVWeld:
1674  fprintf( F, "DTK_WELDING_SYMBOL_STEEP_FLANKED_SINGLE_V_WELD" );
1675  break;
1676  case Dtk_Welding::SymbolPlugWeld:
1677  fprintf( F, "DTK_WELDING_SYMBOL_PLUG_WELD" );
1678  break;
1679  case Dtk_Welding::SymbolRemovableBackingStripUsed:
1680  fprintf( F, "DTK_WELDING_SYMBOL_REMOVABLE_BACKING_STRIP_USED" );
1681  break;
1682  case Dtk_Welding::SymbolPermanentBackingStripUsed:
1683  fprintf( F, "DTK_WELDING_SYMBOL_PERMANENT_BACKING_STRIP_USED" );
1684  break;
1685  case Dtk_Welding::SymbolSurfacingWeld:
1686  fprintf( F, "DTK_WELDING_SYMBOL_SURFACING_WELD" );
1687  break;
1688  case Dtk_Welding::SymbolSeamWeld:
1689  fprintf( F, "DTK_WELDING_SYMBOL_SEAM_WELD" );
1690  break;
1691  case Dtk_Welding::SymbolVFlareWeld:
1692  fprintf( F, "DTK_WELDING_SYMBOL_V_FLARE_WELD" );
1693  break;
1694  case Dtk_Welding::SymbolStickWeld:
1695  fprintf( F, "DTK_WELDING_SYMBOL_STICK_WELD" );
1696  break;
1697  case Dtk_Welding::SymbolFlangeEdge:
1698  fprintf( F, "DTK_WELDING_SYMBOL_FLANGE_EDGE" );
1699  break;
1700  case Dtk_Welding::SymbolFlareBevelWeld:
1701  fprintf( F, "DTK_WELDING_SYMBOL_FLARE_BEVEL_WELD" );
1702  break;
1703  case Dtk_Welding::SymbolISOEdgeWeld:
1704  fprintf( F, "DTK_WELDING_SYMBOL_ISOEDGE_WELD" );
1705  break;
1706  case Dtk_Welding::SymbolSurfaceJointWeld:
1707  fprintf( F, "DTK_WELDING_SYMBOL_SURFACE_JOINT_WELD" );
1708  break;
1709  case Dtk_Welding::SymbolSolderedJointWeld:
1710  fprintf( F, "DTK_WELDING_SYMBOL_SOLDERED_JOINT_WELD" );
1711  break;
1712  case Dtk_Welding::SymbolScarfWeld:
1713  fprintf( F, "DTK_WELDING_SYMBOL_SCARF_WELD" );
1714  break;
1715  case Dtk_Welding::SymbolFoldJointWeld:
1716  fprintf( F, "DTK_WELDING_SYMBOL_FOLD_JOINT_WELD" );
1717  break;
1718  case Dtk_Welding::SymbolStudWeld:
1719  fprintf( F, "DTK_WELDING_SYMBOL_STUD_WELD" );
1720  break;
1721  case Dtk_Welding::SymbolKGrooveWeld:
1722  fprintf( F, "DTK_WELDING_SYMBOL_KGROOVE_WELD" );
1723  break;
1724  case Dtk_Welding::SymbolStakeWeld:
1725  fprintf( F, "DTK_WELDING_SYMBOL_STAKE_WELD" );
1726  break;
1727  }
1728  return dtkNoError;
1729  }

◆ Dtk_DumpXml_Dtk_WeldingPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_WeldingPtr ( FILE *  F,
const Dtk_WeldingPtr &  D 
)
1794  {
1795  fprintf( F, "<Dtk_WeldingPtr>\n" );
1796  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_AnnotationPtr( F, Dtk_AnnotationPtr::DtkDynamicCast( D ) ); // Upcasting
1797 
1798  // We dump all texts
1799  fprintf( F, "<SizeTextOtherSide>\n" );
1800  if( D->GetOtherSideSizeText().GetNumTexts() > 1 )
1801  {
1802  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->GetOtherSideSizeText() );
1803  }
1804  else
1805  {
1806  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetSizeTextOtherSide() );
1807  }
1808  fprintf( F, "</SizeTextOtherSide>\n" );
1809 
1810  fprintf( F, "<AngleTextOtherSide>\n" );
1811  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetAngleTextOtherSide() );
1812  fprintf( F, "</AngleTextOtherSide>\n" );
1813 
1814  fprintf( F, "<NumWeldsTextOtherSide>\n" );
1815  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetNumWeldsTextOtherSide() );
1816  fprintf( F, "</NumWeldsTextOtherSide>\n" );
1817 
1818  fprintf( F, "<LengthTextOtherSide>\n" );
1819  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetLengthTextOtherSide() );
1820  fprintf( F, "</LengthTextOtherSide>\n" );
1821 
1822  Dtk_CompositeText tmpText;
1823  tmpText = D->GetOtherSideDepthText();
1824 
1825  if( tmpText.GetNumTexts() > 0 )
1826  {
1827  fprintf( F, "<DepthTextOtherSide>\n" );
1828  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1829  fprintf( F, "</DepthTextOtherSide>\n" );
1830  }
1831 
1832  tmpText = D->GetOtherSideClearanceText();
1833 
1834  if( tmpText.GetNumTexts() > 0 )
1835  {
1836  fprintf( F, "<ClearanceTextOtherSide>\n" );
1837  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1838  fprintf( F, "</ClearanceTextOtherSide>\n" );
1839  }
1840 
1841  tmpText = D->GetOtherSideSecondFilletSizeText();
1842 
1843  if( tmpText.GetNumTexts() > 0 )
1844  {
1845  fprintf( F, "<SecondFiletSizeTextOtherSide>\n" );
1846  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1847  fprintf( F, "</SecondFiletSizeTextOtherSide>\n" );
1848  }
1849 
1850  tmpText = D->GetOtherSideSecondFilletLengthText();
1851 
1852  if( tmpText.GetNumTexts() > 0 )
1853  {
1854  fprintf( F, "<SecondFiletLengthTextOtherSide>\n" );
1855  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1856  fprintf( F, "</SecondFiletLengthTextOtherSide>\n" );
1857  }
1858 
1859  tmpText = D->GetOtherSideOpeningText();
1860 
1861  if( tmpText.GetNumTexts() > 0 )
1862  {
1863  fprintf( F, "<OpeningTextOtherSide>\n" );
1864  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1865  fprintf( F, "</OpeningTextOtherSide>\n" );
1866  }
1867 
1868  tmpText = D->GetOtherSideWeldSymbolText();
1869 
1870  if( tmpText.GetNumTexts() > 0 )
1871  {
1872  fprintf( F, "<WeldSymbolTextOtherSide>\n" );
1873  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1874  fprintf( F, "</WeldSymbolTextOtherSide>\n" );
1875  }
1876 
1877  tmpText = D->GetOtherSideUndefinedText();
1878 
1879  if( tmpText.GetNumTexts() > 0 )
1880  {
1881  fprintf( F, "<UndefinedTextOtherSide>\n" );
1882  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1883  fprintf( F, "</UndefinedTextOtherSide>\n" );
1884  }
1885 
1886  if( D->GetBrazingOtherSide() )
1887  {
1888  fprintf( F, "<WeldBrazingOtherSideActivated>" );
1889  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_bool( F, D->GetBrazingOtherSide() );
1890  fprintf( F, "</WeldBrazingOtherSideActivated>\n" );
1891  }
1892 
1893  fprintf( F, "<TailText>\n" );
1894  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->GetTailText() );
1895  fprintf( F, "</TailText>\n" );
1896 
1897  fprintf( F, "<SizeTextArrowSide>\n" );
1898  if( D->GetArrowSideSizeText().GetNumTexts() > 1 )
1899  {
1900  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->GetArrowSideSizeText() );
1901  }
1902  else
1903  {
1904  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetSizeTextArrowSide() );
1905  }
1906 
1907  fprintf( F, "</SizeTextArrowSide>\n" );
1908 
1909  fprintf( F, "<AngleTextArrowSide>\n" );
1910  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetAngleTextArrowSide() );
1911  fprintf( F, "</AngleTextArrowSide>\n" );
1912 
1913  fprintf( F, "<NumWeldsTextArrowSide>\n" );
1914  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetNumWeldsTextArrowSide() );
1915  fprintf( F, "</NumWeldsTextArrowSide>\n" );
1916 
1917  fprintf( F, "<LengthTextArrowSide>\n" );
1918  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Text( F, D->GetLengthTextArrowSide() );
1919  fprintf( F, "</LengthTextArrowSide>\n" );
1920 
1921  tmpText = D->GetArrowSideDepthText();
1922 
1923  if( tmpText.GetNumTexts() > 0 )
1924  {
1925  fprintf( F, "<DepthTextArrowSide>\n" );
1926  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1927  fprintf( F, "</DepthTextArrowSide>\n" );
1928  }
1929 
1930  tmpText = D->GetArrowSideClearanceText();
1931 
1932  if( tmpText.GetNumTexts() > 0 )
1933  {
1934  fprintf( F, "<ClearanceTextArrowSide>\n" );
1935  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1936  fprintf( F, "</ClearanceTextArrowSide>\n" );
1937  }
1938 
1939  tmpText = D->GetArrowSideSecondFilletSizeText();
1940 
1941  if( tmpText.GetNumTexts() > 0 )
1942  {
1943  fprintf( F, "<SecondFiletSizeTextArrowSide>\n" );
1944  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1945  fprintf( F, "</SecondFiletSizeTextArrowSide>\n" );
1946  }
1947 
1948  tmpText = D->GetArrowSideSecondFilletLengthText();
1949 
1950  if( tmpText.GetNumTexts() > 0 )
1951  {
1952  fprintf( F, "<SecondFiletLengthTextArrowSide>\n" );
1953  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1954  fprintf( F, "</SecondFiletLengthTextArrowSide>\n" );
1955  }
1956 
1957  tmpText = D->GetArrowSideOpeningText();
1958 
1959  if( tmpText.GetNumTexts() > 0 )
1960  {
1961  fprintf( F, "<OpeningTextArrowSide>\n" );
1962  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1963  fprintf( F, "</OpeningTextArrowSide>\n" );
1964  }
1965 
1966  tmpText = D->GetArrowSideWeldSymbolText();
1967 
1968  if( tmpText.GetNumTexts() > 0 )
1969  {
1970  fprintf( F, "<WeldSymbolTextArrowSide>\n" );
1971  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1972  fprintf( F, "</WeldSymbolTextArrowSide>\n" );
1973  }
1974 
1975  tmpText = D->GetArrowSideUndefinedText();
1976 
1977  if( tmpText.GetNumTexts() > 0 )
1978  {
1979  fprintf( F, "<UndefinedTextArrowSide>\n" );
1980  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, tmpText );
1981  fprintf( F, "</UndefinedTextArrowSide>\n" );
1982  }
1983 
1984  if( D->GetBrazingArrowSide() )
1985  {
1986  fprintf( F, "<WeldBrazingArrowSideActivated>" );
1987  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_bool( F, D->GetBrazingArrowSide() );
1988  fprintf( F, "</WeldBrazingArrowSideActivated>\n" );
1989  }
1990 
1991  fprintf( F, "<Dtk_welding_symbol_other_side>" );
1992  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_welding_symbol( F, D->GetWeldingSymbolOtherSide() );
1993  fprintf( F, "</Dtk_welding_symbol_other_side>\n" );
1994 
1995  fprintf( F, "<Dtk_welding_complementary_symbol_other_side>" );
1996  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_welding_complementary_symbol( F,
1997  D->GetComplementarySymbolOtherSide() );
1998  fprintf( F, "</Dtk_welding_complementary_symbol_other_side>\n" );
1999 
2000  fprintf( F, "<Dtk_welding_finish_symbol_other_side>" );
2001  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_welding_finish_symbol( F, D->GetFinishSymbolOtherSide() );
2002  fprintf( F, "</Dtk_welding_finish_symbol_other_side>\n" );
2003 
2004  fprintf( F, "<Dtk_welding_symbol_arrow_side>" );
2005  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_welding_symbol( F, D->GetWeldingSymbolArrowSide() );
2006  fprintf( F, "</Dtk_welding_symbol_arrow_side>\n" );
2007 
2008  fprintf( F, "<Dtk_welding_complementary_symbol_arrow_side>" );
2009  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_welding_complementary_symbol( F,
2010  D->GetComplementarySymbolArrowSide() );
2011  fprintf( F, "</Dtk_welding_complementary_symbol_arrow_side>\n" );
2012 
2013  fprintf( F, "<Dtk_welding_finish_symbol_arrow_side>" );
2014  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_welding_finish_symbol( F, D->GetFinishSymbolArrowSide() );
2015  fprintf( F, "</Dtk_welding_finish_symbol_arrow_side>\n" );
2016 
2017  fprintf( F, "<Dtk_welding_field_weld_activated>" );
2018  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_bool( F, D->GetFieldWeldActivated() );
2019  fprintf( F, "</Dtk_welding_field_weld_activated>\n" );
2020 
2021  // fprintf(F,"<Dtk_welding_weld_all_around_activated>");
2022  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_bool(F,D->GetWeldAllAroundActivated());
2023  // fprintf(F,"</Dtk_welding_weld_all_around_activated>\n");
2024 
2025  // fprintf(F,"<Dtk_welding_weld_text_side_down>");
2026  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_bool(F,D->GetWeldTextSideDown());
2027  // fprintf(F,"</Dtk_welding_weld_text_side_down>\n");
2028 
2029  fprintf( F, "<Dtk_welding_indent_line_side_down>" );
2030  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_bool( F, D->GetIndentLineFlag() );
2031  fprintf( F, "</Dtk_welding_indent_line_side_down>\n" );
2032 
2033  fprintf( F, "<Dtk_welding_weld_tail_activated>" );
2034  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_bool( F, D->GetWeldTailActivated() );
2035  fprintf( F, "</Dtk_welding_weld_tail_activated>\n" );
2036 
2037  // fprintf(F,"<Dtk_welding_reference>");
2038  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_bool(F,D->GetReference());
2039  // fprintf(F,"</Dtk_welding_reference>\n");
2040 
2041  Dtk_tab<Dtk_EntityPtr> array = D->GetGeometries( DTK_TRUE, DTK_FALSE, DTK_FALSE );
2042  Dtk_Size_t k, sizek = array.size();
2043  if( sizek > 0 )
2044  {
2045  fprintf( F, "<BodyGeometries>\n" );
2046  for( k = 0; k < sizek; k++ )
2047  {
2048  Dtk_DumpXml_Dtk_EntityPtr( F, array[ k ] );
2049  }
2050  fprintf( F, "</BodyGeometries>\n" );
2051  }
2052 
2053  array = D->GetGeometries( DTK_FALSE, DTK_TRUE, DTK_FALSE );
2054  sizek = array.size();
2055  if( sizek > 0 )
2056  {
2057  fprintf( F, "<OtherGeometries>\n" );
2058  for( k = 0; k < sizek; k++ )
2059  {
2060  Dtk_DumpXml_Dtk_EntityPtr( F, array[ k ] );
2061  }
2062  fprintf( F, "</OtherGeometries>\n" );
2063  }
2064 
2065  array = D->GetGeometries( DTK_FALSE, DTK_FALSE, DTK_TRUE );
2066  sizek = array.size();
2067  if( sizek > 0 )
2068  {
2069  fprintf( F, "<ArrowGeometries>\n" );
2070  for( k = 0; k < sizek; k++ )
2071  {
2072  Dtk_DumpXml_Dtk_EntityPtr( F, array[ k ] );
2073  }
2074  fprintf( F, "</ArrowGeometries>\n" );
2075  }
2076 
2077  fprintf( F, "</Dtk_WeldingPtr>\n" );
2078  return dtkNoError;
2079  }

◆ Dtk_DumpXml_DtkReaderType()

void Dtk_DumpXml_DtkReaderType ( FILE *  F,
const DtkReaderType &  inEnum,
const Dtk_string &  inPropertyName 
)
802  {
803  Dtk_string EnumToStr = L"Unknown";
804 
805 
806  EnumToStr = DtkReaderTypeEnumToString( inEnum );
807  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
808  }

◆ Dtk_DumpXml_End() [1/2]

Dtk_ErrorStatus Dtk_DumpXml_End ( )
5153  {
5154  if( dump_file == NULL )
5155  return dtkErrorUnspecified;
5156  fprintf( dump_file, "</root>\n" );
5157  fclose( dump_file );
5158  return dtkNoError;
5159  }

◆ Dtk_DumpXml_End() [2/2]

Dtk_ErrorStatus Dtk_DumpXml_End ( FILE *  F)
5161  {
5162  if( F == NULL )
5163  return dtkErrorUnspecified;
5164  fprintf( F, "</root>\n" );
5165  fclose( F );
5166  return dtkNoError;
5167  }

◆ Dtk_DumpXml_Fdt()

Dtk_ErrorStatus Dtk_DumpXml_Fdt ( const Dtk_FdtPtr &  D)
5135  {
5136  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FdtPtr( dump_file, D, 0 );
5137  }

◆ Dtk_DumpXml_FeatAxis()

Dtk_ErrorStatus Dtk_DumpXml_FeatAxis ( FILE *  f,
const Dtk_feat_axis *  inToWrite 
)
8030  {
8031  if( inToWrite == NULL )
8032  return dtkErrorNullPointer;
8033  Dtk_pnt origin = inToWrite->GetOrigin();
8034  Dtk_pnt direction = inToWrite->GetDirection();
8035 
8036  fprintf( f, "<Origin>%f %f %f</Origin>", origin[ 0 ], origin[ 1 ], origin[ 2 ] );
8037  fprintf( f, "<Direction>%f %f %f</Direction>", direction[ 0 ], direction[ 1 ], direction[ 2 ] );
8038  fprintf( f, "<IsReversed>%d</IsReversed>\n", inToWrite->IsReversed() );
8039  return dtkNoError;
8040  }

◆ Dtk_DumpXml_FeatGeometry()

Dtk_ErrorStatus Dtk_DumpXml_FeatGeometry ( FILE *  f,
const Dtk_feat_geometry *  inToWrite,
const char *  inName 
)
7989  {
7990  Dtk_Size_t nb_ids = 0, i = 0;
7991 
7992  if( inToWrite != NULL )
7993  {
7994  //Dtk_tab<Dtk_Int32> ids = inToWrite->GetAllGeomIds();
7995  //nb_ids = ids.size();
7996  //if( nb_ids == 0 )
7997  // return dtkErrorCorruptedEntity;
7998 
7999 
8000  //if( inName )
8001  // fprintf( f, "\t<%s nb_ids=\"" XmlFormat( "u" )"\">", inName, nb_ids );
8002 
8003  //fprintf( f, "<Ids>" );
8004  //for( i = 0; i < nb_ids; i++ )
8005  //{
8006  // fprintf( f, "%d ", ids[ i ] );
8007  //}
8008  //fprintf( f, "</Ids>" );
8009 
8010 
8011  Dtk_tab<Dtk_NodeConnectorPtr> connect;
8012  inToWrite->GetNodeConnectors( connect );
8013  nb_ids = connect.size();
8014  if( inName )
8015  fprintf( f, "\t<%s nb_ids=\"" XmlFormat( "u" )"\">", inName, nb_ids );
8016 
8017  for( i = 0; i < nb_ids; i++ )
8018  Dtk_DumpXml_Dtk_NodeConnector( f, connect[ i ] );
8019 
8020  if( inName )
8021  fprintf( f, "</%s>\n", inName );
8022 
8023 
8024  return dtkNoError;
8025  }
8026  return dtkErrorNullPointer;
8027  }

◆ Dtk_DumpXml_FeatHole()

Dtk_ErrorStatus Dtk_DumpXml_FeatHole ( FILE *  f,
const Dtk_feat_hole *  inToWrite 
)
8134  {
8135  if( inToWrite == NULL )
8136  return dtkErrorNullPointer;
8137 
8138  fprintf( f, "<Hole>" );
8139  fprintf( f, "<Type>%ls</Type>", inToWrite->GetTypeAsString().w_str() );
8140 
8141  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetSketch(), "Sketch" );
8142  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetSupport(), "FaceSupport" );
8143 
8144  fprintf( f, "<BottomAngle>" );
8145  fprintf( f, "<Value>%f</Value>", inToWrite->GetBottomAngle() );
8146  if( inToWrite->HasBottomAngleTolerance() )
8147  {
8148  fprintf( f, "<ToleranceInferior>%f</ToleranceInferior>", inToWrite->GetBottomAngleTolerance()->GetInferiorTolerance() );
8149  fprintf( f, "<ToleranceSuperior>%f</ToleranceSuperior>", inToWrite->GetBottomAngleTolerance()->GetSuperiorTolerance() );
8150  }
8151  fprintf( f, "</BottomAngle>" );
8152 
8153 
8154  fprintf( f, "<Diameter>" );
8155  fprintf( f, "<Value>%f</Value>", inToWrite->hole_params[ IND_DIAMETER ] );
8156  if( inToWrite->HasDiameterTolerance() )
8157  {
8158  fprintf( f, "<ToleranceInferior>%f</ToleranceInferior>", inToWrite->GetDiameterTolerance()->GetInferiorTolerance() );
8159  fprintf( f, "<ToleranceSuperior>%f</ToleranceSuperior>", inToWrite->GetDiameterTolerance()->GetSuperiorTolerance() );
8160  }
8161  fprintf( f, "</Diameter>" );
8162 
8163 
8164  fprintf( f, "<Depth>" );
8165  fprintf( f, "<Value>%f</Value>", inToWrite->hole_params[ IND_DEPTH ] );
8166  if( inToWrite->HasDepthTolerance() )
8167  {
8168  fprintf( f, "<InferiorTolerance>%f</InferiorTolerance>", inToWrite->GetDepthTolerance()->GetInferiorTolerance() );
8169  fprintf( f, "<SuperiorTolerance>%f</SuperiorTolerance>", inToWrite->GetDepthTolerance()->GetSuperiorTolerance() );
8170  }
8171  fprintf( f, "</Depth>" );
8172 
8173 
8174  fprintf( f, "<Axis>" );
8175  Dtk_DumpXml_FeatAxis( f, inToWrite->GetAxis() );
8176  fprintf( f, "</Axis>" );
8177 
8178  fprintf( f, "<HoleLimit>" );
8179  Dtk_DumpXml_FeatLimit( f, inToWrite->GetLimit() );
8180  fprintf( f, "</HoleLimit>" );
8181 
8182  /* H? */
8183  if ( inToWrite->dimension_tolerance )
8184  {
8185  fprintf(f, "<dimension_tolerance>%s</dimension_tolerance>", inToWrite->dimension_tolerance);
8186  }
8187 
8188  switch( inToWrite->GetType() )
8189  {
8190  case SIMPLE: break;
8191  case TAPERED:
8192  fprintf( f, "<TaperedAngle>%f</TaperedAngle>", inToWrite->GetCounterAngle() );
8193  break;
8194  case COUNTER_BORED:
8195  fprintf( f, "<CounterBored>" );
8196  fprintf( f, "<Diameter>%f</Diameter>", inToWrite->GetCounterDiameter() );
8197  fprintf( f, "<Depth>%f</Depth>", inToWrite->GetCounterDepth() );
8198  fprintf( f, "<Anchor>%s</Anchor>", inToWrite->GetAnchorTypeAsString().c_str() );
8199  fprintf( f, "</CounterBored>" );
8200  break;
8201  case COUNTER_SUNK:
8202  fprintf( f, "<CounterSunk>" );
8203  fprintf( f, "<Diameter>%f</Diameter>", inToWrite->GetCounterDiameter() );
8204  fprintf( f, "<Depth>%f</Depth>", inToWrite->GetCounterDepth() );
8205  fprintf( f, "<Angle>%f</Angle>", inToWrite->GetCounterAngle() );
8206  fprintf( f, "</CounterSunk>" );
8207  break;
8208  case COUNTER_DRILLED:
8209  fprintf( f, "<CounterDrilled>" );
8210  fprintf( f, "<Diameter>%f</Diameter>", inToWrite->GetCounterDiameter() );
8211  fprintf( f, "<Depth>%f</Depth>", inToWrite->GetCounterDepth() );
8212  fprintf( f, "<Angle>%f</Angle>", inToWrite->GetCounterAngle() );
8213  fprintf( f, "</CounterDrilled>" );
8214  break;
8215  default: break;
8216  }
8217 
8218 
8219 
8220  if( inToWrite->IsThreaded() == DTK_TRUE )
8221  {
8222  Dtk_feat_inner_thread *thread = inToWrite->GetInnerThread();
8223  fprintf( f, "<HoleThread>" );
8224  fprintf( f, "<LimitType>%ls</LimitType>", thread->GetLimitTypeAsString().w_str() );
8225  /* display thread properties */
8226  switch( inToWrite->GetLimit()->GetType() )
8227  {
8228  case Dtk_feat_limit::BLIND:
8229  case Dtk_feat_limit::DEFAULT:
8230  case Dtk_feat_limit::UP_TO_NEXT:
8231  case Dtk_feat_limit::UP_TO_LAST:
8232  case Dtk_feat_limit::UP_TO_PLANE:
8233  case Dtk_feat_limit::UP_TO_SURFACE:
8234  case Dtk_feat_limit::UP_THRU_NEXT_LIMIT:
8235  switch( inToWrite->GetType() )
8236  {
8237  case SIMPLE:
8238  case COUNTER_BORED:
8239  case COUNTER_SUNK:
8240  case COUNTER_DRILLED:
8241  {
8242  fprintf( f, "<ThreadingPitch>%f</ThreadingPitch>", thread->GetPitch() );
8243  fprintf( f, "<ThreadingDepth>%f</ThreadingDepth>", thread->GetDepth() );
8244  fprintf( f, "<ThreadingDiameter>%f</ThreadingDiameter>", thread->GetDiameter() );
8245 
8246  fprintf( f, "<RightThreaded>%d</RightThreaded>", thread->IsRightThreaded() );
8247  fprintf( f, "<NoStandardTable>%d</NoStandardTable>", thread->IsNoStandardTable() );
8248  if( inToWrite->thread->no_standard_table == DTK_FALSE )
8249  {
8250  fprintf( f, "<DefinitionType>%s</DefinitionType>", thread->GetDefinitionType().c_str() );
8251  fprintf( f, "<DefinitionValue>%s</DefinitionValue>", thread->GetDefinitionValue().c_str() );
8252  }
8253  }
8254  break;
8255  default: break;
8256  }
8257  break;
8258  default: break;
8259  }
8260 
8261  if( thread->thread_limit_type == DTK_THREAD_UP_TO_PLANE )
8262  {
8263  Dtk_DumpXml_FeatGeometry( f, thread->GetLimitReference(), "ThreadLimitReference" );
8264  }
8265  fprintf( f, "</HoleThread>" );
8266 
8267  }
8268 
8269  if( inToWrite->IsStartActived() != -1 )
8270  {
8271  if( inToWrite->IsStartActived() == DTK_FALSE )
8272  {
8273  fprintf( f, "<StartChamfer>disabled</StartChamfer>" );
8274  }
8275  else
8276  {
8277  fprintf( f, "<StartChamfer>enabled</StartChamfer>" );
8278  }
8279 
8280  fprintf( f, "<Diameter>%f</Diameter>", inToWrite->GetStartDiameter() );
8281  fprintf( f, "<Angle>%f</Angle>", inToWrite->GetStartAngle() );
8282 
8283  }
8284 
8285  if( inToWrite->IsReliefActived() != -1 )
8286  {
8287  if( inToWrite->IsReliefActived() == DTK_FALSE )
8288  {
8289  fprintf( f, "<ReliefChamfer>disabled</ReliefChamfer>" );
8290  }
8291  else
8292  {
8293  fprintf( f, "<ReliefChamfer>enabled</ReliefChamfer>" );
8294  }
8295  fprintf( f, "<Diameter>%f</Diameter>", inToWrite->GetReliefDiameter() );
8296  fprintf( f, "<Depth>%f</Depth>", inToWrite->GetReliefDepth() );
8297  fprintf( f, "<Angle>%f</Angle>", inToWrite->GetReliefAngle() );
8298  }
8299 
8300  if( inToWrite->IsNeckActived() != -1 )
8301  {
8302  if( inToWrite->IsNeckActived() == DTK_FALSE )
8303  {
8304  fprintf( f, "<NeckChamfer>disabled</NeckChamfer>" );
8305  }
8306  else
8307  {
8308  fprintf( f, "<NeckChamfer>enabled</NeckChamfer>" );
8309  }
8310  fprintf( f, "<Diameter>%f</Diameter>", inToWrite->GetNeckDiameter() );
8311  fprintf( f, "<Angle>%f</Angle>", inToWrite->GetNeckAngle() );
8312 
8313  }
8314 
8315  if( inToWrite->IsEndActived() != -1 )
8316  {
8317  if( inToWrite->IsEndActived() == DTK_FALSE )
8318  {
8319  fprintf( f, "<EndChamfer>disabled</EndChamfer>" );
8320  }
8321  else
8322  {
8323  fprintf( f, "<EndChamfer>enabled</EndChamfer>" );
8324  }
8325  fprintf( f, "<Diameter>%f</Diameter>", inToWrite->GetEndDiameter() );
8326  fprintf( f, "<Angle>%f</Angle>", inToWrite->GetEndAngle() );
8327  }
8328 
8329  fprintf( f, "</Hole>" );
8330  return dtkNoError;
8331  }

◆ Dtk_DumpXml_FeatLimit()

Dtk_ErrorStatus Dtk_DumpXml_FeatLimit ( FILE *  f,
const Dtk_feat_limit *  inToWrite 
)
8043  {
8044  if( inToWrite == NULL )
8045  return dtkErrorNullPointer;
8046 
8047  fprintf( f, "<Type>%ls</Type>", inToWrite->GetTypeAsString().w_str() );
8048  switch( inToWrite->type )
8049  {
8050  case Dtk_feat_limit::LENGTH:
8051  fprintf( f, "<Length>%f</Length>", inToWrite->GetVal() );
8052  case Dtk_feat_limit::DEFAULT:
8053  break;
8054  case Dtk_feat_limit::UP_TO_LAST:
8055  case Dtk_feat_limit::UP_TO_NEXT:
8056  case Dtk_feat_limit::UP_THRU_NEXT_LIMIT:
8057  fprintf( f, "<OffsetFromSurface>%f</OffsetFromSurface>", inToWrite->GetVal() );
8058  break;
8059  case Dtk_feat_limit::UP_TO_PLANE:
8060  fprintf( f, "<OffsetFromSurface>%f</OffsetFromSurface>", inToWrite->GetVal() );
8061  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetRefenceObject(), "ReferencePlane" );
8062  break;
8063  case Dtk_feat_limit::UP_TO_SURFACE:
8064  fprintf( f, "<OffsetFromSurface>%f</OffsetFromSurface>", inToWrite->GetVal() );
8065  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetRefenceObject(), "ReferenceSurface" );
8066  break;
8067  default:
8068  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetRefenceObject(), "ReferenceGeometry" );
8069  break;
8070  }
8071  return dtkNoError;
8072  }

◆ Dtk_DumpXml_FeatPattern()

Dtk_ErrorStatus Dtk_DumpXml_FeatPattern ( FILE *  f,
const Dtk_feat_pattern *  inToWrite 
)
8335  {
8336  fprintf( f, "<Pattern>" );
8337 
8338  const char *type_symbols[ 3 ] = { "RECTANGULAR", "CIRCULAR", "UNKNOWN" };
8339  const char *type_objects[] = { "DTK_FEATURE_SELECT", "DTK_BODY_SELECT", "DTK_FACE_SELECT", "NO_DTK_OBJECT_TYPE" };
8340  int i;
8341  Dtk_Size_t ui;
8342 
8343  fprintf( f, "<Type>%s</Type>", type_symbols[ inToWrite->type ] );
8344  fprintf( f, "<ObjectType>%s</ObjectType>", type_objects[ inToWrite->type ] );
8345 
8346  fprintf( f, "<ObjectsToPattern>" );
8347 
8348  if( inToWrite->input_ids.size() == 0 )
8349  {
8350 
8351  if( inToWrite->object_type == DTK_BODY_SELECT )
8352  {
8353 
8354  for( ui = 0; ui < inToWrite->objects_to_pattern.size(); ui++ )
8355  {
8356  Dtk_feat_geometry *curGeom = inToWrite->objects_to_pattern[ ui ];
8357  if( curGeom != NULL )
8358  {
8359  Dtk_DumpXml_FeatGeometry( f, curGeom, "BodySelect" );
8360  }
8361  }
8362  }
8363 
8364  }
8365 
8366  fprintf( f, "<Ids>" );
8367  int nb_ids = ( int )inToWrite->input_ids.size();
8368  for( i = 0; i < nb_ids; i++ )
8369  {
8370  fprintf( f, "%ld ", inToWrite->input_ids[ i ] );
8371  }
8372  fprintf( f, "</Ids>" );
8373  fprintf( f, "</ObjectsToPattern>" );
8374 
8375  fprintf( f, "<Row1>%d</Row1>", inToWrite->row1 );
8376  fprintf( f, "<Row2>%d</Row2>", inToWrite->row2 );
8377  fprintf( f, "<Angle>%f</Angle>", inToWrite->angle );
8378 
8379  //TODO
8380  //////////switch (p->type) {
8381  //////////case DTK_RECT_PATTERN:
8382  ////////// dump_dtk_feat_rect_pattern(p->entity.rect, f);
8383  ////////// break;
8384  //////////case DTK_CIRC_PATTERN:
8385  ////////// dump_dtk_feat_circ_pattern(p->entity.circ, f);
8386  ////////// break;
8387  //////////default:
8388  ////////// break;
8389  //////////}
8390 
8391  //////////int nb = 0;
8392  //////////int x = 0, y = 0;
8393 
8394  //////////Dtk_bool isSimpleRepresentation;
8395  //////////p->get_simple_rep(&isSimpleRepresentation);
8396  //////////fprintf(f, "Simple Representation\t: %d\n", isSimpleRepresentation);
8397 
8398  //////////for (i = 0; i < p->nb_instances; i++)
8399  //////////{
8400  ////////// if (p->active_instances[i] == false)
8401  ////////// {
8402  ////////// nb++;
8403  ////////// }
8404  //////////}
8405  //////////fprintf(f, "Nb Inactive Instances\t:\t%d\n", nb);
8406  //////////fprintf(f, "Inactive Instances\t: ");
8407  //////////for (i = 0; i < p->nb_instances; i++)
8408  //////////{
8409  ////////// if (p->active_instances[i] == false)
8410  ////////// {
8411  ////////// if (p->type == DTK_RECT_PATTERN)
8412  ////////// {
8413  ////////// y = (i) / p->entity.rect->first_dir->nb_instances;
8414  ////////// x = (i) % p->entity.rect->first_dir->nb_instances;
8415  ////////// }
8416  ////////// else if (p->type == DTK_CIRC_PATTERN)
8417  ////////// {
8418  ////////// y = i / p->entity.circ->nb_circles;
8419  ////////// x = i%p->entity.circ->nb_circles;
8420  ////////// }
8421  ////////// fprintf(f, "[%d,%d] ", x, y);
8422  ////////// //fprintf (f, "%d ", i+1);
8423  ////////// }
8424  //////////}
8425 
8426  //////////int nbfeature = 0;
8427  //////////p->get_nb_features(&nbfeature);
8428 
8429  //////////if (nbfeature>0)
8430  //////////{
8431  ////////// fprintf(f, "\nNb Feature\t:\t%d\n", nbfeature);
8432 
8433  ////////// Dtk_tab<Dtk_FeaturePtr> ArrayFeature;
8434  ////////// p->get_features(ArrayFeature);
8435  ////////// for (i = 0; i<nbfeature; i++)
8436  ////////// {
8437  ////////// dump_dtk_feat(ArrayFeature[i].operator ->(), f);
8438  ////////// }
8439  //////////}
8440  fprintf( f, "</Pattern>" );
8441  return dtkNoError;
8442 
8443  }

◆ Dtk_DumpXml_FeatThread()

Dtk_ErrorStatus Dtk_DumpXml_FeatThread ( FILE *  f,
const Dtk_feat_thread *  inToWrite 
)
8075  {
8076  fprintf( f, "<Thread>" );
8077  fprintf( f, "<Type>%ls</Type>", inToWrite->GetInnerThread()->GetTypeAsString().w_str() );
8078  fprintf( f, "<ThreadingDiameter>" );
8079  fprintf( f, "<Value>%f</Value>", inToWrite->GetInnerThread()->GetDiameter() );
8080  if( inToWrite->GetInnerThread()->HasDiameterTolerance() )
8081  {
8082  fprintf( f, "<ToleranceInferior>%f</ToleranceInferior>", inToWrite->GetInnerThread()->GetDiameterTolerance()->GetInferiorTolerance() );
8083  fprintf( f, "<ToleranceSuperior>%f</ToleranceSuperior>", inToWrite->GetInnerThread()->GetDiameterTolerance()->GetSuperiorTolerance() );
8084  }
8085  fprintf( f, "</ThreadingDiameter>" );
8086  fprintf( f, "<SupportDiameter>" );
8087  fprintf( f, "<Value>%f</Value>", inToWrite->GetSupportDiameter() );
8088  if( inToWrite->HasSupportDiameterTolerance() )
8089  {
8090  fprintf( f, "<ToleranceInferior>%f</ToleranceInferior>", inToWrite->GetSupportDiameterTolerance()->GetInferiorTolerance() );
8091  fprintf( f, "<ToleranceSuperior>%f</ToleranceSuperior>", inToWrite->GetSupportDiameterTolerance()->GetSuperiorTolerance() );
8092  }
8093  fprintf( f, "</SupportDiameter>" );
8094 
8095 
8096  fprintf( f, "<ThreadingDepth>" );
8097  fprintf( f, "<Value>%f</Value>", inToWrite->GetInnerThread()->GetDepth() );
8098  if( inToWrite->GetInnerThread()->HasDepthTolerance() )
8099  {
8100  fprintf( f, "<InferiorTolerance>%f</InferiorTolerance>", inToWrite->GetInnerThread()->GetDepthTolerance()->GetInferiorTolerance() );
8101  fprintf( f, "<SuperiorTolerance>%f</SuperiorTolerance>", inToWrite->GetInnerThread()->GetDepthTolerance()->GetSuperiorTolerance() );
8102  }
8103  fprintf( f, "</ThreadingDepth>" );
8104 
8105  fprintf( f, "<SupportDepth>" );
8106  fprintf( f, "<Value>%f</Value>", inToWrite->GetSupportDepth() );
8107  if( inToWrite->HasSupportDepthTolerance() )
8108  {
8109  fprintf( f, "<InferiorTolerance>%f</InferiorTolerance>", inToWrite->GetSupportDepthTolerance()->GetInferiorTolerance() );
8110  fprintf( f, "<SuperiorTolerance>%f</SuperiorTolerance>", inToWrite->GetSupportDepthTolerance()->GetSuperiorTolerance() );
8111  }
8112  fprintf( f, "</SupportDepth>" );
8113 
8114  fprintf( f, "<ThreadingPitch>%f</ThreadingPitch>", inToWrite->GetInnerThread()->GetPitch() );
8115  fprintf( f, "<RightThreaded>%d</RightThreaded>", inToWrite->GetInnerThread()->IsRightThreaded() );
8116  fprintf( f, "<NoStandardTable>%d</NoStandardTable>", inToWrite->GetInnerThread()->IsNoStandardTable() );
8117  if( inToWrite->GetInnerThread()->no_standard_table == DTK_FALSE )
8118  {
8119  fprintf( f, "<DefinitionType>%ls</DefinitionType>", inToWrite->GetInnerThread()->GetDefinitionType().w_str() );
8120  fprintf( f, "<DefinitionValue>%ls</DefinitionValue>", inToWrite->GetInnerThread()->GetDefinitionValue().w_str() );
8121  }
8122 
8123 
8124  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetSupport(), "FaceSupport" );
8125  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetLimit(), "FaceLimit" );
8126  fprintf( f, "</Thread>" );
8127  return dtkNoError;
8128  }

◆ Dtk_DumpXml_FinishSymbolEnum()

void Dtk_DumpXml_FinishSymbolEnum ( FILE *  F,
const Dtk_Welding::FinishSymbolEnum &  inEnum,
const Dtk_string &  inPropertyName 
)
863  {
864  Dtk_string EnumToStr = Dtk_Welding::FinishSymbolEnumToString( inEnum );
865  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
866  }

◆ Dtk_DumpXml_FormatDtk_string()

Dtk_string Dtk_DumpXml_FormatDtk_string ( const Dtk_string &  inString,
const XML_StringType  inXmlStringType 
)
4473  {
4474  //if( inString.c_str() != NULL )
4475  {
4476  int StrLen = inString.len();
4477  if( StrLen > 0 )
4478  {
4479  int Idx = 0;
4480  Dtk_string Res;
4481  switch( inXmlStringType )
4482  {
4483  case XMLAttribute:
4484  case XMLElement:
4485  {
4486  //XMLElement
4487  if( isascii( inString[ 0 ] ) == 0 || isdigit( inString[ 0 ] ) )
4488  {
4489  //we add an additional underscore char because an anchor can't start with a digit
4490  Res = L"_" + inString;
4491  Idx++; //we increment the index
4492  }
4493  else
4494  {
4495  Res = inString;
4496  }
4497 
4498  for( int i = 0; i < StrLen; i++, Idx++ )
4499  {
4500  unsigned int Val = ( unsigned int )inString[ i ];
4501  if( Val > 0x007F || Val < 0x002C )
4502  {
4503  Res[ Idx ] = '_';
4504  }
4505  else
4506  {
4507  switch( Val )
4508  {
4509  case 0x002F: //'/'
4510  case 0x003A: //':'
4511  case 0x003B: //';'
4512  case 0x003C: //'<'
4513  case 0x003D: //'='
4514  case 0x003E: //'>'
4515  case 0x003F: //'?'
4516  case 0x0040: //'@'
4517  case 0x005B: //'['
4518  case 0x005C: //'\\'
4519  case 0x005D: //']'
4520  case 0x005E: //'^'
4521  case 0x0060: //'`'
4522  case 0x007B: //'{'
4523  case 0x007C: //'|'
4524  case 0x007D: //'}'
4525  case 0x007E: //'~'
4526  {
4527  Res[ Idx ] = '_';
4528  break;
4529  }
4530  default:
4531  {
4532  break;
4533  }
4534  }
4535 
4536  }
4537  }
4538  break;
4539  }
4540  case XMLGenericString:
4541  {
4542  //XMLGenericString
4543  std::string fast;
4544  fast.reserve( StrLen );
4545  for( int i = 0; i < StrLen; i++ )
4546  {
4547  char buf[ 10 ] = { 0 };
4548  unsigned int Val = ( unsigned int )inString[ i ];
4549  if( Val > 127
4550  || Val == 0x0022 //'"' => this char is valid but could be ugly if we encapsulate with quotes
4551  || Val == 0x0026 //'&'
4552  || Val == 0x003C //'<'
4553  || Val == 0x003E //'>'
4554  || Val == 0x000A //'line feed'
4555  || Val == 0x000D //'carriage return'
4556  )
4557  {
4558  Dtk_StandardTools::sprintf_dtk( buf, 10, "&#x%X;", Val );
4559  }
4560  else if( Val >= 0x0020 ) //we remove ascii character prior 'space'
4561  {
4562  Dtk_StandardTools::sprintf_dtk( buf, 10, "%c", ( char )Val );
4563  }
4564  else
4565  {
4566  Dtk_StandardTools::sprintf_dtk( buf, 10, "_" ); //if control char => underscore
4567  }
4568  fast += buf;
4569  }
4570  Res += fast.c_str();
4571  break;
4572  }
4573  default:
4574  {
4575  break;
4576  }
4577  }
4578  return Res;
4579  }
4580  }
4581  return inString; //same string by default - error -
4582  }

◆ Dtk_DumpXml_GetFeaturesDumpFile()

FILE* Dtk_DumpXml_GetFeaturesDumpFile ( )
5174  {
5175  return FeaturesDumpFile;
5176  }

◆ Dtk_DumpXml_GetFile()

FILE* Dtk_DumpXml_GetFile ( )
5169  {
5170  return dump_file;
5171  }

◆ Dtk_DumpXml_Init()

Dtk_ErrorStatus Dtk_DumpXml_Init ( const Dtk_string &  xml_file)
5140  {
5141  Dtk_string xmlFileOut;
5142 
5143  xmlFileOut = xml_file;
5144 
5145  dump_file = xmlFileOut.OpenFile( DTK_W );
5146  if( dump_file == NULL )
5147  return dtkErrorUnspecified;
5148  // dump_file = fopen(xml_file.c_str(),"w");
5149  fprintf( dump_file, "<root>\n" );
5150  return dtkNoError;
5151  }

◆ Dtk_DumpXml_LeaderTerminatorTypeEnum()

void Dtk_DumpXml_LeaderTerminatorTypeEnum ( FILE *  F,
const Dtk_Leader::LeaderTerminatorTypeEnum &  inEnum,
const Dtk_string &  inPropertyName 
)
836  {
837  Dtk_string EnumToStr = Dtk_Leader::LeaderTerminatorTypeEnumToString( inEnum );
838  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
839  }

◆ Dtk_DumpXml_LineTypeDefinitionTable()

Dtk_ErrorStatus Dtk_DumpXml_LineTypeDefinitionTable ( FILE *  F)
4092  {
4093  Dtk_ErrorStatus outDtkStatus = dtkNoError;
4094 
4095  const Dtk_API *const api = Dtk_API::GetAPI();
4096  if( api )
4097  {
4098  const Dtk_Size_t nbDefinitions = api->GetNumCurveLineTypeDefinitionsInTable();
4099 
4100  if( nbDefinitions > 0 )
4101  {
4102  fprintf( F, "<LineTypeDefinitionTable>\n" );
4103 
4104  for( Dtk_Size_t i_def = 1; i_def <= nbDefinitions; ++i_def )
4105  {
4106  Dtk_DumpXml_Dtk_LineTypeDefinitionPtr( F,
4107  api->GetCurveLineTypeDefinitionInTable( ( Dtk_ID )i_def ) );
4108  }
4109 
4110  fprintf( F, "</LineTypeDefinitionTable>\n" );
4111  }
4112  }
4113  else
4114  {
4115  outDtkStatus = dtkErrorNullPointer;
4116  }
4117 
4118  return outDtkStatus;
4119  }

◆ Dtk_DumpXml_Metadata()

Dtk_ErrorStatus Dtk_DumpXml_Metadata ( const Dtk_MetaDataPtr &  m)
5179  {
5180  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr( dump_file, m );
5181  }

◆ Dtk_DumpXml_MetaDataTypeEnum()

void Dtk_DumpXml_MetaDataTypeEnum ( FILE *  F,
const Dtk_MetaData::MetaDataTypeEnum &  inEnum,
const Dtk_string &  inPropertyName 
)
712  {
713  Dtk_string EnumToStr = Dtk_MetaData::MetaDataTypeEnumToString( inEnum );
714  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
715  }

◆ Dtk_DumpXml_NodeFullType()

void Dtk_DumpXml_NodeFullType ( FILE *  F,
const Dtk_Node::FullType &  inNodeFullType,
const Dtk_string &  inPropertyName 
)
703  {
704  Dtk_string EnumToStr = Dtk_Node::NodeDataTypeEnumToString( inNodeFullType.PrimaryType() );
705  const char *TmpChar = inPropertyName.c_str();
706  fprintf( F, "<%s Primary=\"%s\" Secondary=\"%s\" ></%s>\n", TmpChar, EnumToStr.c_str(), typedetkToDtk_string( inNodeFullType.SubType() ).c_str(), TmpChar );
707  }

◆ Dtk_DumpXml_NodeTypeEnum()

void Dtk_DumpXml_NodeTypeEnum ( FILE *  F,
const Dtk_Node::NodeDataTypeEnum &  inEnum,
const Dtk_string &  inPropertyName 
)
694  {
695  Dtk_string EnumToStr = Dtk_Node::NodeDataTypeEnumToString( inEnum );
696  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
697  }

◆ Dtk_DumpXml_PhysicalMaterialInfosTable()

Dtk_ErrorStatus Dtk_DumpXml_PhysicalMaterialInfosTable ( FILE *  F)
4009  {
4010  Dtk_API *api = Dtk_API::GetAPI();
4011  Dtk_ID i, nb = ( Dtk_ID )api->GetNumPhysicalMaterialInfosInTable();
4012  if( nb )
4013  fprintf( F, "<PhysicalMaterialInfosTable>\n" );
4014  for( i = 0; i < nb; i++ )
4015  {
4016  Dtk_PhysicalMaterialInfosPtr mat = api->GetPhysicalMaterialInfosInTable( i + 1 );
4017  Dtk_DumpXml_Dtk_PhysicalMaterialInfos( F, mat );
4018  }
4019  if( nb )
4020  fprintf( F, "</PhysicalMaterialInfosTable>\n" );
4021 
4022  return dtkNoError;
4023  }

◆ Dtk_DumpXml_RenderInfosTable()

Dtk_ErrorStatus Dtk_DumpXml_RenderInfosTable ( FILE *  F)
3973  {
3974  Dtk_API *api = Dtk_API::GetAPI();
3975  Dtk_ID i, nb = ( Dtk_ID )api->GetNumRenderInfosInTable();
3976  if( nb )
3977  fprintf( F, "<RenderInfosTable>\n" );
3978  for( i = 0; i < nb; i++ )
3979  {
3980  Dtk_RenderInfosPtr mat = api->GetRenderInfosInTable( i + 1 );
3981  Dtk_DumpXml_Dtk_RenderInfos( F, mat );
3982  }
3983  if( nb )
3984  fprintf( F, "</RenderInfosTable>\n" );
3985 
3986  return dtkNoError;
3987  }

◆ Dtk_DumpXml_TextAttributeEnum()

void Dtk_DumpXml_TextAttributeEnum ( FILE *  F,
const Dtk_TextStyle::TextAttributeEnum &  inEnum,
const Dtk_string &  inPropertyName 
)
814  {
815  Dtk_string EnumToStr;
816 
817  if( inEnum & Dtk_TextStyle::AttributeNone ) EnumToStr += L"AttributeNone,";
818  if( inEnum & Dtk_TextStyle::AttributeUnderline ) EnumToStr += L"AttributeUnderline,";
819  if( inEnum & Dtk_TextStyle::AttributeStrikethrough ) EnumToStr += L"AttributeStrikethrough,";
820  if( inEnum & Dtk_TextStyle::AttributeOverline ) EnumToStr += L"AttributeOverline,";
821  if( inEnum & Dtk_TextStyle::AttributeSuperscript ) EnumToStr += L"AttributeSuperscript,";
822  if( inEnum & Dtk_TextStyle::AttributeSubscript ) EnumToStr += L"AttributeSubscript,";
823 
824  int len = EnumToStr.len();
825  if( len > 0 ) EnumToStr[ len - 1 ] = 0;
826  else EnumToStr = L"None";
827 
828  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
829  }

◆ Dtk_DumpXml_TextJustificationEnum()

void Dtk_DumpXml_TextJustificationEnum ( FILE *  F,
const Dtk_TextStyle::TextJustificationEnum &  inEnum,
const Dtk_string &  inPropertyName 
)
943  {
944  Dtk_string EnumToStr;
945 
946  if( inEnum == Dtk_TextStyle::JustificationLeft ) EnumToStr += L"JustificationLeft,";
947  if( inEnum == Dtk_TextStyle::JustificationCenter )EnumToStr += L"JustificationCenter,";
948  if( inEnum == Dtk_TextStyle::JustificationRight ) EnumToStr += L"JustificationRight,";
949 
950  int len = EnumToStr.len();
951  if( len > 0 ) EnumToStr[ len - 1 ] = 0;
952  else EnumToStr = L"None";
953 
954  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
955  }

◆ Dtk_DumpXml_Value() [1/6]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const char *  inFormat,
  ... 
)
4374  {
4375  Dtk_string Value;
4376  {
4377  va_list ap;
4378  va_start( ap, inFormat );
4379  char buffer[ 512 ] = { 0 };
4380  Dtk_StandardTools::vsprintf_dtk( buffer, 512, inFormat, ap );
4381  va_end( ap );
4382  Value = buffer;
4383  }
4384 
4385  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Value";
4386  const char *TitleCharStr = Title.c_str();
4387 
4388  Value = ( Value.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( Value, XMLGenericString ) : L"Undefined.";
4389  fprintf( inFile, "<%s>%s</%s>\n",
4390  TitleCharStr,
4391  Value.c_str(),
4392  TitleCharStr );
4393 
4394  return dtkNoError;
4395  }

◆ Dtk_DumpXml_Value() [2/6]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_bool &  inValue 
)
4412  {
4413  //we check if the label is present - label overload -
4414  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_bool";
4415  const char *TitleCharStr = Title.c_str();
4416 
4417  fprintf( inFile, "<%s>%s</%s>\n",
4418  TitleCharStr,
4419  ( inValue == DTK_FALSE ) ? "DTK_FALSE" : "DTK_TRUE",
4420  TitleCharStr );
4421  return dtkNoError;
4422  }

◆ Dtk_DumpXml_Value() [3/6]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_Double64 &  inValue,
const char *  inFormat 
)
4398  {
4399  //we check if the label is present - label overload -
4400  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_Double64";
4401  const char *TitleCharStr = Title.c_str();
4402 
4403  char MyFormat[ 128 ] = { 0 };
4404  Dtk_StandardTools::sprintf_dtk( MyFormat, 128, "<%%s>%s</%%s>\n", inFormat );
4405  fprintf( inFile, MyFormat,
4406  TitleCharStr,
4407  inValue,
4408  TitleCharStr );
4409  return dtkNoError;
4410  }

◆ Dtk_DumpXml_Value() [4/6]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_Int64 &  inValue 
)
4424  {
4425  //we check if the label is present - label overload -
4426  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_Int64";
4427  const char *TitleCharStr = Title.c_str();
4428 
4429  fprintf( inFile, "<%s>\'" XmlFormat( "d" ) "\"</%s>\n",
4430  TitleCharStr,
4431  inValue,
4432  TitleCharStr );
4433  return dtkNoError;
4434  }

◆ Dtk_DumpXml_Value() [5/6]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_string &  inValue 
)
4448  {
4449  //we check if the label is present - label overload -
4450  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_string";
4451  const char *TitleCharStr = Title.c_str();
4452 
4453  if( inValue.len() > 0 )
4454  {
4455 
4456  Dtk_string Value = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inValue, XMLGenericString );
4457 
4458  fprintf( inFile, "<%s>&quot;%s&quot;</%s>\n",
4459  TitleCharStr,
4460  Value.c_str(),
4461  TitleCharStr );
4462  }
4463  else
4464  {
4465  fprintf( inFile, "<%s>(null)</%s>\n",
4466  TitleCharStr,
4467  TitleCharStr );
4468  }
4469  return dtkNoError;
4470  }

◆ Dtk_DumpXml_Value() [6/6]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_UInt64 &  inValue 
)
4436  {
4437  //we check if the label is present - label overload -
4438  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_UInt64";
4439  const char *TitleCharStr = Title.c_str();
4440 
4441  fprintf( inFile, "<%s>\'" XmlFormat( "u" ) "\"</%s>\n",
4442  TitleCharStr,
4443  inValue,
4444  TitleCharStr );
4445  return dtkNoError;
4446  }

◆ Dtk_DumpXml_WeldingSymbolEnum()

void Dtk_DumpXml_WeldingSymbolEnum ( FILE *  F,
const Dtk_Welding::WeldingSymbolEnum &  inEnum,
const Dtk_string &  inPropertyName 
)
845  {
846  Dtk_string EnumToStr = Dtk_Welding::WeldingSymbolEnumToString( inEnum );
847  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
848  }

◆ Dtk_End_Dump_Files()

Dtk_ErrorStatus Dtk_End_Dump_Files ( const Dtk_string &  inComponentFullName)
7971  {
7972  Dtk_string str_fic_param, str_fic_feat;
7973 
7974  if( FeaturesDumpFile )
7975  {
7976  str_fic_feat = inComponentFullName + Dtk_string( ".feat.log" );
7977  fclose( FeaturesDumpFile );
7978  FeaturesDumpFile = NULL;
7979  }
7980 
7981  return dtkNoError;
7982 
7983  }

◆ Dtk_FCFFeatureIndicatorTypeEnumToString()

Dtk_string Dtk_FCFFeatureIndicatorTypeEnumToString ( const Dtk_FCFFeatureIndicatorType::Dtk_FCFFeatureIndicatorTypeEnum &  inEnum)
2732  {
2733  switch( inEnum )
2734  {
2735  default:
2736  case Dtk_FCFFeatureIndicatorType::Unknown: return L"Unknown";
2737  case Dtk_FCFFeatureIndicatorType::DirectionFeature: return L"DirectionFeature";
2738  case Dtk_FCFFeatureIndicatorType::CollectionPlane: return L"CollectionPlane";
2739  case Dtk_FCFFeatureIndicatorType::IntersectionPlane: return L"IntersectionPlane";
2740  case Dtk_FCFFeatureIndicatorType::OrientationPlane: return L"OrientationPlane";
2741  }
2742  }

◆ Dtk_Init_Dump_Files()

Dtk_ErrorStatus Dtk_Init_Dump_Files ( const Dtk_string &  inDumpFileName,
Dtk_bool  dumpFeatures 
)
7957  {
7958  if( dumpFeatures )
7959  {
7960  FeaturesDumpFile = inDumpFileName.OpenFile( DTK_WP );
7961  if( FeaturesDumpFile == NULL )
7962  {
7963  return dtkErrorOpenFiles;
7964  }
7965  }
7966 
7967  return dtkNoError;
7968  }

◆ DtkPictureTypeEnumToString()

Dtk_string DtkPictureTypeEnumToString ( const Dtk_PictureType &  inEnum)
777  {
778  switch( inEnum )
779  {
780  default:
781  case DTK_PICTURE_UNKNOWN: return L"DTK_PICTURE_UNKNOWN";
782  case DTK_PICTURE_RGB24: return L"DTK_PICTURE_RGB24";
783  case DTK_PICTURE_RGBA32: return L"DTK_PICTURE_RGBA32";
784  case DTK_PICTURE_JPG: return L"DTK_PICTURE_JPG";
785  case DTK_PICTURE_BMP: return L"DTK_PICTURE_BMP";
786  case DTK_PICTURE_PNG: return L"DTK_PICTURE_PNG";
787  case DTK_PICTURE_CGM: return L"DTK_PICTURE_CGM";
788  case DTK_PICTURE_GIF: return L"DTK_PICTURE_GIF";
789  case DTK_PICTURE_TIFF: return L"DTK_PICTURE_TIFF";
790  case DTK_PICTURE_ICO: return L"DTK_PICTURE_ICO";
791  case DTK_PICTURE_PS: return L"DTK_PICTURE_PS";
792  case DTK_PICTURE_SVG: return L"DTK_PICTURE_SVG";
793  case DTK_PICTURE_OLE: return L"DTK_PICTURE_OLE";
794  case DTK_PICTURE_WMF: return L"DTK_PICTURE_WMF";
795  case DTK_PICTURE_EMF: return L"DTK_PICTURE_EMF";
796  }
797  }

◆ DtkReaderTypeEnumToString()

Dtk_string DtkReaderTypeEnumToString ( const DtkReaderType &  inReaderTypeEnum)
719  {
720  Dtk_string EnumToStr;
721  switch( inReaderTypeEnum )
722  {
723  case V5ReaderModule: EnumToStr = L"V5ReaderModule"; break;
724  case VdaReaderModule: EnumToStr = L"VdaReaderModule"; break;
725  case InvReaderModule: EnumToStr = L"InvReaderModule"; break;
726  case V4ReaderModule: EnumToStr = L"V4ReaderModule"; break;
727  case UgReaderModule: EnumToStr = L"UgReaderModule"; break;
728  case XmtReaderModule: EnumToStr = L"XmtReaderModule"; break;
729  case SwReaderModule: EnumToStr = L"SwReaderModule"; break;
730  case SeReaderModule: EnumToStr = L"SeReaderModule"; break;
731  case IgesReaderModule: EnumToStr = L"IgesReaderModule"; break;
732  case StepReaderModule: EnumToStr = L"StepReaderModule"; break;
733  case PsReaderModule: EnumToStr = L"PsReaderModule"; break;
734  case ProeReaderModule: EnumToStr = L"ProeReaderModule"; break;
735  case SatReaderModule: EnumToStr = L"SatReaderModule"; break;
736  case JtReaderModule: EnumToStr = L"JtReaderModule"; break;
737  case CgrReaderModule: EnumToStr = L"CgrReaderModule"; break;
738  case CgmReaderModule: EnumToStr = L"CgmReaderModule"; break;
739  case CaddsReaderModule: EnumToStr = L"CaddsReaderModule"; break;
740  case DwgReaderModule: EnumToStr = L"DwgReaderModule"; break;
741  case DwgDtkReaderModule: EnumToStr = L"DwgDtkReaderModule"; break;
742  case AcisReaderModule: EnumToStr = L"AcisReaderModule"; break;
743  case ProCeraReaderModule: EnumToStr = L"ProCeraReaderModule"; break;
744  case CerconReaderModule: EnumToStr = L"CerconReaderModule"; break;
745  case CerecReaderModule: EnumToStr = L"CerecReaderModule"; break;
746  case DcmReaderModule: EnumToStr = L"DcmReaderModule"; break;
747  case _3dXmlReaderModule: EnumToStr = L"_3dXmlReaderModule"; break;
748  case XmlReaderModule: EnumToStr = L"XmlReaderModule"; break;
749  case V6ReaderModule: EnumToStr = L"V6ReaderModule"; break;
750  case DxfReaderModule: EnumToStr = L"DxfReaderModule"; break;
751  case PlmXmlReaderModule: EnumToStr = L"PlmXmlReaderModule"; break;
752  case RnXmlReaderModule: EnumToStr = L"RnXmlReaderModule"; break;
753  case FbxReaderModule: EnumToStr = L"FbxReaderModule"; break;
754  case GltfReaderModule: EnumToStr = L"GltfReaderModule"; break;
755  case SdnfReaderModule: EnumToStr = L"SdnfReaderModule"; break;
756  case F3dReaderModule: EnumToStr = L"F3dReaderModule"; break;
757  case PrcReaderModule: EnumToStr = L"PrcReaderModule"; break;
758  case ArtReaderModule: EnumToStr = L"ArtReaderModule"; break;
759  case SmgReaderModule: EnumToStr = L"SmgReaderModule"; break;
760  case DstvReaderModule: EnumToStr = L"DstvReaderModule"; break;
761  case NavisReaderModule: EnumToStr = L"NavisReaderModule"; break;
762  case QifReaderModule: EnumToStr = L"QifReaderModule"; break;
763  case Zw3dReaderModule: EnumToStr = L"Zw3dReaderModule"; break;
764  case UsdReaderModule: EnumToStr = L"UsdReaderModule"; break;
765  case StlReaderModule: EnumToStr = L"StlReaderModule"; break;
766  case IfcReaderModule: EnumToStr = L"IfcReaderModule"; break;
767  case RevitReaderModule: EnumToStr = L"RevitReaderModule"; break;
768  case MaxReaderModules: EnumToStr = L"MaxReaderModules"; break;
769  case UnknownModule: EnumToStr = L"UnknownModule"; break;
770  default:
771  EnumToStr = L"UnknownModule";
772  }
773  return EnumToStr;
774  }

◆ dump_dtk_feat()

void dump_dtk_feat ( Dtk_feat *  feature,
FILE *  f,
int  vers = 0 
)

◆ typedetkToDtk_string()

Dtk_string typedetkToDtk_string ( const type_detk &  inVal)
100  {
101  switch( inVal )
102  {
103  case DTK_TYPE_CATIA_V5: return L"DTK_TYPE_CATIA_V5";
104  case DTK_TYPE_CATIA: return L"DTK_TYPE_CATIA";
105  case DTK_TYPE_SKIP: return L"DTK_TYPE_SKIP";
106  case DTK_TYPE_ERROR: return L"DTK_TYPE_ERROR";
107  case DTK_TYPE_UNKNOWN:
108  {
109  // #ifdef _DEBUG_DTK
110  // MessageBoxA(NULL, "Probleme type_detk UNKNOWN !!!!", "Probleme type_detk UNKNOWN !!!!", 0);
111  //#endif
112  return L"DTK_TYPE_UNKNOWN";
113  }
114  case DTK_TYPE_DIRECTION: return L"DTK_TYPE_DIRECTION";
115  case DTK_TYPE_VECTOR: return L"DTK_TYPE_VECTOR";
116  case DTK_TYPE_PLACEMENT: return L"DTK_TYPE_PLACEMENT";
117  case DTK_TYPE_AXIS1_PLACEMENT: return L"DTK_TYPE_AXIS1_PLACEMENT";
118  case DTK_TYPE_AXIS2_PLACEMENT_2D: return L"DTK_TYPE_AXIS2_PLACEMENT_2D";
119  case DTK_TYPE_AXIS2_PLACEMENT_3D: return L"DTK_TYPE_AXIS2_PLACEMENT_3D";
120  case DTK_TYPE_AXIS2_PLACEMENT: return L"DTK_TYPE_AXIS2_PLACEMENT";
121  case DTK_TYPE_AXIS_SYSTEM: return L"DTK_TYPE_AXIS_SYSTEM ";
122  case DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR: return L"DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR";
123  case DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR_2D: return L"DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR_2D";
124  case DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR_3D: return L"DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR_3D";
125  case DTK_TYPE_CARTESIAN_POINT: return L"DTK_TYPE_CARTESIAN_POINT";
126  case DTK_TYPE_POINT_ON_CURVE: return L"DTK_TYPE_POINT_ON_CURVE";
127  case DTK_TYPE_POINT_ON_SURFACE: return L"DTK_TYPE_POINT_ON_SURFACE";
128  case DTK_TYPE_DEGENERATE_PCURVE: return L"DTK_TYPE_DEGENERATE_PCURVE";
129  case DTK_TYPE_EVALUATED_DEGENERATE_PCURVE: return L"DTK_TYPE_EVALUATED_DEGENERATE_PCURVE";
130  case DTK_TYPE_POINT_REPLICA: return L"DTK_TYPE_POINT_REPLICA";
131  case DTK_TYPE_PNT: return L"DTK_TYPE_PNT";
132  case DTK_TYPE_CARTESIAN_POINT_WITH_INFOS: return L"DTK_TYPE_CARTESIAN_POINT_WITH_INFOS";
133  case DTK_TYPE_LINE: return L"DTK_TYPE_LINE";
134  case DTK_TYPE_POLYLINE: return L"DTK_TYPE_POLYLINE";
135  case DTK_TYPE_CONIC: return L"DTK_TYPE_CONIC";
136  case DTK_TYPE_CIRCLE: return L"DTK_TYPE_CIRCLE";
137  case DTK_TYPE_ELLIPSE: return L"DTK_TYPE_ELLIPSE";
138  case DTK_TYPE_HYPERBOLA: return L"DTK_TYPE_HYPERBOLA";
139  case DTK_TYPE_PARABOLA: return L"DTK_TYPE_PARABOLA";
140  case DTK_TYPE_SPIRAL: return L"DTK_TYPE_SPIRAL";
141  case DTK_TYPE_HELIX: return L"DTK_TYPE_HELIX";
142  case DTK_TYPE_SUPER_CURVE: return L"DTK_TYPE_SUPER_CURVE";
143  case DTK_TYPE_CURVE: return L"DTK_TYPE_CURVE";
144  case DTK_TYPE_UNIFORM_CURVE: return L"DTK_TYPE_UNIFORM_CURVE";
145  case DTK_TYPE_QUASI_UNIFORM_CURVE: return L"DTK_TYPE_QUASI_UNIFORM_CURVE";
146  case DTK_TYPE_BEZIER_CURVE: return L"DTK_TYPE_BEZIER_CURVE";
147  case DTK_TYPE_B_SPLINE_CURVE_WITH_KNOTS: return L"DTK_TYPE_B_SPLINE_CURVE_WITH_KNOTS";
148  case DTK_TYPE_RATIONAL_B_SPLINE_CURVE: return L"DTK_TYPE_RATIONAL_B_SPLINE_CURVE";
149  case DTK_TYPE_RATIONAL_B_SPLINE_CURVE_WITH_KNOTS: return L"DTK_TYPE_RATIONAL_B_SPLINE_CURVE_WITH_KNOTS";
150  case DTK_TYPE_B_SPLINE_CURVE: return L"DTK_TYPE_B_SPLINE_CURVE";
151  case DTK_TYPE_TRIMMED_CURVE: return L"DTK_TYPE_TRIMMED_CURVE";
152  case DTK_TYPE_PCURVE: return L"DTK_TYPE_PCURVE";
153  case DTK_TYPE_CURVE_REPLICA: return L"DTK_TYPE_CURVE_REPLICA";
154  case DTK_TYPE_PARAMETRIC_CURVE: return L"DTK_TYPE_PARAMETRIC_CURVE";
155  case DTK_TYPE_SINGLE_PARAMETER_CONSTRAINT: return L"DTK_TYPE_SINGLE_PARAMETER_CONSTRAINT";
156  case DTK_TYPE_COMPOSITE_CURVE: return L"DTK_TYPE_COMPOSITE_CURVE";
157  case DTK_TYPE_COMPOSITE_CURVE_ON_SURFACE: return L"DTK_TYPE_COMPOSITE_CURVE_ON_SURFACE";
158  case DTK_TYPE_BOUNDARY_CURVE: return L"DTK_TYPE_BOUNDARY_CURVE";
159  case DTK_TYPE_OUTER_BOUNDARY_CURVE: return L"DTK_TYPE_OUTER_BOUNDARY_CURVE";
160  case DTK_TYPE_COMPOSITE_CURVE_SEGMENT: return L"DTK_TYPE_COMPOSITE_CURVE_SEGMENT";
161  case DTK_TYPE_REPARAMETRISED_COMPOSITE_CURVE_SEGMENT: return L"DTK_TYPE_REPARAMETRISED_COMPOSITE_CURVE_SEGMENT";
162  case DTK_TYPE_OFFSET_CURVE_2D: return L"DTK_TYPE_OFFSET_CURVE_2D";
163  case DTK_TYPE_OFFSET_CURVE_3D: return L"DTK_TYPE_OFFSET_CURVE_3D";
164  case DTK_TYPE_SURFACE_CURVE: return L"DTK_TYPE_SURFACE_CURVE";
165  case DTK_TYPE_INTERSECTION_CURVE: return L"DTK_TYPE_INTERSECTION_CURVE";
166  case DTK_TYPE_SEAM_CURVE: return L"DTK_TYPE_SEAM_CURVE";
167  case DTK_TYPE_ELEMENTARY_SURFACE: return L"DTK_TYPE_ELEMENTARY_SURFACE";
168  case DTK_TYPE_PLANE: return L"DTK_TYPE_PLANE";
169  case DTK_TYPE_CYLINDRICAL_SURFACE: return L"DTK_TYPE_CYLINDRICAL_SURFACE";
170  case DTK_TYPE_CONICAL_SURFACE: return L"DTK_TYPE_CONICAL_SURFACE";
171  case DTK_TYPE_SPHERICAL_SURFACE: return L"DTK_TYPE_SPHERICAL_SURFACE";
172  case DTK_TYPE_TOROIDAL_SURFACE: return L"DTK_TYPE_TOROIDAL_SURFACE";
173  case DTK_TYPE_SWEPT_SURFACE: return L"DTK_TYPE_SWEPT_SURFACE";
174  case DTK_TYPE_SURFACE_OF_LINEAR_EXTRUSION: return L"DTK_TYPE_SURFACE_OF_LINEAR_EXTRUSION";
175  case DTK_TYPE_SURFACE_OF_REVOLUTION: return L"DTK_TYPE_SURFACE_OF_REVOLUTION";
176  case DTK_TYPE_RULED_SURFACE: return L"DTK_TYPE_RULED_SURFACE";
177  case DTK_TYPE_BLEND_SURFACE: return L"DTK_TYPE_BLEND_SURFACE";
178  case DTK_TYPE_NET: return L"DTK_TYPE_NET";
179  case DTK_TYPE_RECTANGULAR_COMPOSITE_SURFACE: return L"DTK_TYPE_RECTANGULAR_COMPOSITE_SURFACE";
180  case DTK_TYPE_RECTANGULAR_TRIMMED_SURFACE: return L"DTK_TYPE_RECTANGULAR_TRIMMED_SURFACE";
181  case DTK_TYPE_CURVE_BOUNDED_SURFACE: return L"DTK_TYPE_CURVE_BOUNDED_SURFACE";
182  case DTK_TYPE_SURFACE_PATCH: return L"DTK_TYPE_SURFACE_PATCH";
183  case DTK_TYPE_B_SPLINE_SURFACE: return L"DTK_TYPE_B_SPLINE_SURFACE";
184  case DTK_TYPE_B_SPLINE_SURFACE_WITH_KNOTS: return L"DTK_TYPE_B_SPLINE_SURFACE_WITH_KNOTS";
185  case DTK_TYPE_UNIFORM_SURFACE: return L"DTK_TYPE_UNIFORM_SURFACE";
186  case DTK_TYPE_QUASI_UNIFORM_SURFACE: return L"DTK_TYPE_QUASI_UNIFORM_SURFACE";
187  case DTK_TYPE_BEZIER_SURFACE: return L"DTK_TYPE_BEZIER_SURFACE";
188  case DTK_TYPE_RATIONAL_B_SPLINE_SURFACE: return L"DTK_TYPE_RATIONAL_B_SPLINE_SURFACE";
189  case DTK_TYPE_RATIONAL_B_SPLINE_SURFACE_WITH_KNOTS: return L"DTK_TYPE_RATIONAL_B_SPLINE_SURFACE_WITH_KNOTS";
190  case DTK_TYPE_SURFACE: return L"DTK_TYPE_SURFACE";
191  case DTK_TYPE_OFFSET_SURFACE: return L"DTK_TYPE_OFFSET_SURFACE";
192  case DTK_TYPE_FILLET_SURFACE: return L"DTK_TYPE_FILLET_SURFACE";
193  case DTK_TYPE_PARAMETRIC_SURFACE: return L"DTK_TYPE_PARAMETRIC_SURFACE";
194  case DTK_TYPE_SURFACE_REPLICA: return L"DTK_TYPE_SURFACE_REPLICA";
195  case DTK_TYPE_SUPER_SURFACE: return L"DTK_TYPE_SUPER_SURFACE";
196  case DTK_TYPE_GEOMETRIC_CURVE_SET: return L"DTK_TYPE_GEOMETRIC_CURVE_SET";
197  case DTK_TYPE_GEOMETRIC_SET_REPLICA: return L"DTK_TYPE_GEOMETRIC_SET_REPLICA";
198  case DTK_TYPE_GEOMETRIC_SET: return L"DTK_TYPE_GEOMETRIC_SET";
199  case DTK_TYPE_GEOMETRIC_SET_SELECT: return L"DTK_TYPE_GEOMETRIC_SET_SELECT";
200  case DTK_TYPE_GEOMETRIC_SET_SELECT_ENTITY: return L"DTK_TYPE_GEOMETRIC_SET_SELECT_ENTITY";
201  case DTK_TYPE_VERTEX: return L"DTK_TYPE_VERTEX";
202  case DTK_TYPE_EDGE_CURVE: return L"DTK_TYPE_EDGE_CURVE";
203  case DTK_TYPE_ORIENTED_EDGE: return L"DTK_TYPE_ORIENTED_EDGE";
204  case DTK_TYPE_EDGE: return L"DTK_TYPE_EDGE";
205  case DTK_TYPE_CONNECTED_EDGE_SET: return L"DTK_TYPE_CONNECTED_EDGE_SET";
206  case DTK_TYPE_EDGE_BASED_WIREFRAME_MODEL: return L"DTK_TYPE_EDGE_BASED_WIREFRAME_MODEL";
207  case DTK_TYPE_VERTEX_LOOP: return L"DTK_TYPE_VERTEX_LOOP";
208  case DTK_TYPE_EDGE_LOOP: return L"DTK_TYPE_EDGE_LOOP";
209  case DTK_TYPE_POLY_LOOP: return L"DTK_TYPE_POLY_LOOP";
210  case DTK_TYPE_LOOP: return L"DTK_TYPE_LOOP";
211  case DTK_TYPE_FACE_BOUND: return L"DTK_TYPE_FACE_BOUND";
212  case DTK_TYPE_FACE_OUTER_BOUND: return L"DTK_TYPE_FACE_OUTER_BOUND";
213  case DTK_TYPE_FACE_SURFACE: return L"DTK_TYPE_FACE_SURFACE";
214  case DTK_TYPE_ORIENTED_FACE: return L"DTK_TYPE_ORIENTED_FACE";
215  case DTK_TYPE_ADVANCED_FACE: return L"DTK_TYPE_ADVANCED_FACE";
216  case DTK_TYPE_SUBFACE: return L"DTK_TYPE_SUBFACE";
217  case DTK_TYPE_FACE: return L"DTK_TYPE_FACE";
218  case DTK_TYPE_VERTEX_SHELL: return L"DTK_TYPE_VERTEX_SHELL";
219  case DTK_TYPE_WIRE_SHELL: return L"DTK_TYPE_WIRE_SHELL";
220  case DTK_TYPE_OPEN_SHELL: return L"DTK_TYPE_OPEN_SHELL";
221  case DTK_TYPE_ORIENTED_OPEN_SHELL: return L"DTK_TYPE_ORIENTED_OPEN_SHELL";
222  case DTK_TYPE_CLOSED_SHELL: return L"DTK_TYPE_CLOSED_SHELL";
223  case DTK_TYPE_ORIENTED_CLOSED_SHELL: return L"DTK_TYPE_ORIENTED_CLOSED_SHELL";
224  case DTK_TYPE_CONNECTED_FACE_SET: return L"DTK_TYPE_CONNECTED_FACE_SET";
225  case DTK_TYPE_SHELL_BASED_WIREFRAME_REPRESENTATION: return L"DTK_TYPE_SHELL_BASED_WIREFRAME_REPRESENTATION";
226  case DTK_TYPE_SHELL_BASED_WIREFRAME_MODEL: return L"DTK_TYPE_SHELL_BASED_WIREFRAME_MODEL";
227  case DTK_TYPE_SHELL_BASED_SURFACE_MODEL: return L"DTK_TYPE_SHELL_BASED_SURFACE_MODEL";
228  case DTK_TYPE_FACE_BASED_SURFACE_MODEL: return L"DTK_TYPE_FACE_BASED_SURFACE_MODEL";
229  case DTK_TYPE_SHELL: return L"DTK_TYPE_SHELL";
230  case DTK_TYPE_SURFACE_MODEL: return L"DTK_TYPE_SURFACE_MODEL";
231  case DTK_TYPE_WIREFRAME_MODEL: return L"DTK_TYPE_WIREFRAME_MODEL";
232  case DTK_TYPE_ORIENTED_PATH: return L"DTK_TYPE_ORIENTED_PATH";
233  case DTK_TYPE_OPEN_PATH: return L"DTK_TYPE_OPEN_PATH";
234  case DTK_TYPE_PATH: return L"DTK_TYPE_PATH";
235  case DTK_TYPE_EDGE_ENTITY: return L"DTK_TYPE_EDGE_ENTITY";
236  case DTK_TYPE_FACE_ENTITY: return L"DTK_TYPE_FACE_ENTITY";
237  case DTK_TYPE_PATH_ENTITY: return L"DTK_TYPE_PATH_ENTITY";
238  case DTK_TYPE_CONNECTED_FACE_SET_ENTITY: return L"DTK_TYPE_CONNECTED_FACE_SET_ENTITY";
239  case DTK_TYPE_LIST_OF_REVERSIBLE_TOPOLOGY_ITEM: return L"DTK_TYPE_LIST_OF_REVERSIBLE_TOPOLOGY_ITEM";
240  case DTK_TYPE_SET_OF_REVERSIBLE_TOPOLOGY_ITEM: return L"DTK_TYPE_SET_OF_REVERSIBLE_TOPOLOGY_ITEM";
241  case DTK_TYPE_REVERSIBLE_TOPOLOGY_ITEM: return L"DTK_TYPE_REVERSIBLE_TOPOLOGY_ITEM";
242  case DTK_TYPE_REVERSIBLE_TOPOLOGY: return L"DTK_TYPE_REVERSIBLE_TOPOLOGY";
243  case DTK_TYPE_TOPOLOGICAL_REPRESENTATION_ITEM: return L"DTK_TYPE_TOPOLOGICAL_REPRESENTATION_ITEM";
244  case DTK_TYPE_EDGE_BASED_WIREFRAME_REPRESENTATION: return L"DTK_TYPE_EDGE_BASED_WIREFRAME_REPRESENTATION";
245  case DTK_TYPE_GEOMETRICALLY_BOUNDED_SURFACE_REPRESENTATION: return L"DTK_TYPE_GEOMETRICALLY_BOUNDED_SURFACE_REPRESENTATION";
246  case DTK_TYPE_GEOMETRICALLY_BOUNDED_WIREFRAME_REPRESENTATION: return L"DTK_TYPE_GEOMETRICALLY_BOUNDED_WIREFRAME_REPRESENTATION";
247  case DTK_TYPE_FACETTED_BREP_REPRESENTATION: return L"DTK_TYPE_FACETTED_BREP_REPRESENTATION";
248  case DTK_TYPE_MANIFOLD_SURFACE_WITH_TOPOLOGY_REPRESENTATION: return L"DTK_TYPE_MANIFOLD_SURFACE_WITH_TOPOLOGY_REPRESENTATION";
249  case DTK_TYPE_ADVANCED_BREP_REPRESENTATION: return L"DTK_TYPE_ADVANCED_BREP_REPRESENTATION";
250  case DTK_TYPE_BREP_WITH_VOIDS: return L"DTK_TYPE_BREP_WITH_VOIDS";
251  case DTK_TYPE_FACETTED_BREP: return L"DTK_TYPE_FACETTED_BREP";
252  case DTK_TYPE_MANIFOLD_SOLID_BREP: return L"DTK_TYPE_MANIFOLD_SOLID_BREP";
253  case DTK_TYPE_SOLID_REPLICA: return L"DTK_TYPE_SOLID_REPLICA";
254  case DTK_TYPE_SOLID_MODEL: return L"DTK_TYPE_SOLID_MODEL";
255  case DTK_TYPE_PIPING_ENTITY: return L"DTK_TYPE_PIPING_ENTITY";
256  case DTK_TYPE_CALENDAR_DATE: return L"DTK_TYPE_CALENDAR_DATE";
257  case DTK_TYPE_ORDINAL_DATE: return L"DTK_TYPE_ORDINAL_DATE";
258  case DTK_TYPE_WEEK_OF_YEAR_AND_DAY_DATE: return L"DTK_TYPE_WEEK_OF_YEAR_AND_DAY_DATE";
259  case DTK_TYPE_DATE_STEP: return L"DTK_TYPE_DATE_STEP";
260  case DTK_TYPE_DATE_TIME_ROLE: return L"DTK_TYPE_DATE_TIME_ROLE";
261  case DTK_TYPE_COORDINATED_UNIVERSAL_TIME_OFFSET: return L"DTK_TYPE_COORDINATED_UNIVERSAL_TIME_OFFSET";
262  case DTK_TYPE_LOCAL_TIME: return L"DTK_TYPE_LOCAL_TIME";
263  case DTK_TYPE_DATE_AND_TIME: return L"DTK_TYPE_DATE_AND_TIME";
264  case DTK_TYPE_DATE_TIME_SELECT: return L"DTK_TYPE_DATE_TIME_SELECT";
265  case DTK_TYPE_APPROVAL_DATE_TIME: return L"DTK_TYPE_APPROVAL_DATE_TIME";
266  case DTK_TYPE_DATED_EFFECTIVITY: return L"DTK_TYPE_DATED_EFFECTIVITY";
267  case DTK_TYPE_DATE_TIME_ITEM: return L"DTK_TYPE_DATE_TIME_ITEM";
268  case DTK_TYPE_CC_DESIGN_DATE_AND_TIME_ASSIGNMENT: return L"DTK_TYPE_CC_DESIGN_DATE_AND_TIME_ASSIGNMENT";
269  case DTK_TYPE_DATE_AND_TIME_ASSIGNMENT: return L"DTK_TYPE_DATE_AND_TIME_ASSIGNMENT";
270  case DTK_TYPE_LENGTH_MEASURE_WITH_UNIT: return L"DTK_TYPE_LENGTH_MEASURE_WITH_UNIT";
271  case DTK_TYPE_MASS_MEASURE_WITH_UNIT: return L"DTK_TYPE_MASS_MEASURE_WITH_UNIT";
272  case DTK_TYPE_PLANE_ANGLE_MEASURE_WITH_UNIT: return L"DTK_TYPE_PLANE_ANGLE_MEASURE_WITH_UNIT";
273  case DTK_TYPE_SOLID_ANGLE_MEASURE_WITH_UNIT: return L"DTK_TYPE_SOLID_ANGLE_MEASURE_WITH_UNIT";
274  case DTK_TYPE_AREA_MEASURE_WITH_UNIT: return L"DTK_TYPE_AREA_MEASURE_WITH_UNIT";
275  case DTK_TYPE_VOLUME_MEASURE_WITH_UNIT: return L"DTK_TYPE_VOLUME_MEASURE_WITH_UNIT";
276  case DTK_TYPE_MEASURE_WITH_UNIT: return L"DTK_TYPE_MEASURE_WITH_UNIT";
277  case DTK_TYPE_LENGTH_MEASURE: return L"DTK_TYPE_LENGTH_MEASURE";
278  case DTK_TYPE_MASS_MEASURE: return L"DTK_TYPE_MASS_MEASURE";
279  case DTK_TYPE_PLANE_ANGLE_MEASURE: return L"DTK_TYPE_PLANE_ANGLE_MEASURE";
280  case DTK_TYPE_SOLID_ANGLE_MEASURE: return L"DTK_TYPE_SOLID_ANGLE_MEASURE";
281  case DTK_TYPE_AREA_MEASURE: return L"DTK_TYPE_AREA_MEASURE";
282  case DTK_TYPE_VOLUME_MEASURE: return L"DTK_TYPE_VOLUME_MEASURE";
283  case DTK_TYPE_COUNT_MEASURE: return L"DTK_TYPE_COUNT_MEASURE";
284  case DTK_TYPE_CONTEXT_DEPENDENT_MEASURE: return L"DTK_TYPE_CONTEXT_DEPENDENT_MEASURE";
285  case DTK_TYPE_DESCRIPTIVE_MEASURE: return L"DTK_TYPE_DESCRIPTIVE_MEASURE";
286  case DTK_TYPE_POSITIVE_LENGTH_MEASURE: return L"DTK_TYPE_POSITIVE_LENGTH_MEASURE";
287  case DTK_TYPE_POSITIVE_PLANE_ANGLE_MEASURE: return L"DTK_TYPE_POSITIVE_PLANE_ANGLE_MEASURE";
288  case DTK_TYPE_CONVERSION_BASED_UNIT: return L"DTK_TYPE_CONVERSION_BASED_UNIT";
289  case DTK_TYPE_CONTEXT_DEPENDENT_UNIT: return L"DTK_TYPE_CONTEXT_DEPENDENT_UNIT";
290  case DTK_TYPE_SI_UNIT: return L"DTK_TYPE_SI_UNIT";
291  case DTK_TYPE_UNCERTAINTY_MEASURE_WITH_UNIT: return L"DTK_TYPE_UNCERTAINTY_MEASURE_WITH_UNIT";
292  case DTK_TYPE_LENGTH_UNIT: return L"DTK_TYPE_LENGTH_UNIT";
293  case DTK_TYPE_MASS_UNIT: return L"DTK_TYPE_MASS_UNIT";
294  case DTK_TYPE_AREA_UNIT: return L"DTK_TYPE_AREA_UNIT";
295  case DTK_TYPE_PLANE_ANGLE_UNIT: return L"DTK_TYPE_PLANE_ANGLE_UNIT";
296  case DTK_TYPE_SOLID_ANGLE_UNIT: return L"DTK_TYPE_SOLID_ANGLE_UNIT";
297  case DTK_TYPE_VOLUME_UNIT: return L"DTK_TYPE_VOLUME_UNIT";
298  case DTK_TYPE_APPLICATION_CONTEXT: return L"DTK_TYPE_APPLICATION_CONTEXT";
299  case DTK_TYPE_APPLICATION_CONTEXT_ELEMENT: return L"DTK_TYPE_APPLICATION_CONTEXT_ELEMENT";
300  case DTK_TYPE_CONFIGURATION_ITEM: return L"DTK_TYPE_CONFIGURATION_ITEM";
301  case DTK_TYPE_CONFIGURATION_DESIGN: return L"DTK_TYPE_CONFIGURATION_DESIGN";
302  case DTK_TYPE_PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS: return L"DTK_TYPE_PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS";
303  case DTK_TYPE_PRODUCT_CONCEPT_CONTEXT: return L"DTK_TYPE_PRODUCT_CONCEPT_CONTEXT";
304  case DTK_TYPE_PRODUCT_CONTEXT: return L"DTK_TYPE_PRODUCT_CONTEXT";
305  case DTK_TYPE_PRODUCT_DEFINITION_CONTEXT: return L"DTK_TYPE_PRODUCT_DEFINITION_CONTEXT";
306  case DTK_TYPE_PRODUCT: return L"DTK_TYPE_PRODUCT";
307  case DTK_TYPE_PRODUCT_VERSION: return L"DTK_TYPE_PRODUCT_VERSION";
308  case DTK_TYPE_WORK_ITEM: return L"DTK_TYPE_WORK_ITEM";
309  case DTK_TYPE_CHANGE_REQUEST_ITEM: return L"DTK_TYPE_CHANGE_REQUEST_ITEM";
310  case DTK_TYPE_START_REQUEST_ITEM: return L"DTK_TYPE_START_REQUEST_ITEM";
311  case DTK_TYPE_CONTRACTED_ITEM: return L"DTK_TYPE_CONTRACTED_ITEM";
312  case DTK_TYPE_CONTEXT_DEPENDENT_SHAPE_REPRESENTATION: return L"DTK_TYPE_CONTEXT_DEPENDENT_SHAPE_REPRESENTATION";
313  case DTK_TYPE_PRODUCT_DEFINITION: return L"DTK_TYPE_PRODUCT_DEFINITION";
314  case DTK_TYPE_MECHANICAL_CONTEXT: return L"DTK_TYPE_MECHANICAL_CONTEXT";
315  case DTK_TYPE_NEXT_ASSEMBLY_USAGE_OCCURENCE: return L"DTK_TYPE_NEXT_ASSEMBLY_USAGE_OCCURENCE";
316  case DTK_TYPE_PROMISSORY_USAGE_OCCURENCE: return L"DTK_TYPE_PROMISSORY_USAGE_OCCURENCE";
317  case DTK_TYPE_ASSEMBLY_COMPONENT_USAGE: return L"DTK_TYPE_ASSEMBLY_COMPONENT_USAGE";
318  case DTK_TYPE_PRODUCT_DEFINITION_USAGE: return L"DTK_TYPE_PRODUCT_DEFINITION_USAGE";
319  case DTK_TYPE_QUANTIFIED_ASSEMBLY_COMPONENT_USAGE: return L"DTK_TYPE_QUANTIFIED_ASSEMBLY_COMPONENT_USAGE";
320  case DTK_TYPE_ASSEMBLY_COMPONENT_USAGE_SUBSTITUTE: return L"DTK_TYPE_ASSEMBLY_COMPONENT_USAGE_SUBSTITUTE";
321  case DTK_TYPE_SPECIFIED_HIGHER_USAGE_OCCURRENCE: return L"DTK_TYPE_SPECIFIED_HIGHER_USAGE_OCCURRENCE";
322  case DTK_TYPE_SERIAL_NUMBERED_EFFECTIVITY: return L"DTK_TYPE_SERIAL_NUMBERED_EFFECTIVITY";
323  case DTK_TYPE_LOT_EFFECTIVITY: return L"DTK_TYPE_LOT_EFFECTIVITY";
324  case DTK_TYPE_PLANNED_EFFECTIVITY: return L"DTK_TYPE_PLANNED_EFFECTIVITY";
325  case DTK_TYPE_EFFECTIVITY: return L"DTK_TYPE_EFFECTIVITY";
326  case DTK_TYPE_CONFIGURATION_EFFECTIVITY: return L"DTK_TYPE_CONFIGURATION_EFFECTIVITY";
327  case DTK_TYPE_REQUESTED_ACTION: return L"DTK_TYPE_REQUESTED_ACTION";
328  case DTK_TYPE_ORDERED_ACTION: return L"DTK_TYPE_ORDERED_ACTION";
329  case DTK_TYPE_ACTION_METHOD: return L"DTK_TYPE_ACTION_METHOD";
330  case DTK_TYPE_ACTION: return L"DTK_TYPE_ACTION";
331  case DTK_TYPE_ACTION_EXECUTION: return L"DTK_TYPE_ACTION_EXECUTION";
332  case DTK_TYPE_ACTION_STATUS: return L"DTK_TYPE_ACTION_STATUS";
333  case DTK_TYPE_ACTION_REQUEST_STATUS: return L"DTK_TYPE_ACTION_REQUEST_STATUS";
334  case DTK_TYPE_EXECUTED_ACTION: return L"DTK_TYPE_EXECUTED_ACTION";
335  case DTK_TYPE_DIRECTED_ACTION: return L"DTK_TYPE_DIRECTED_ACTION";
336  case DTK_TYPE_CHANGE: return L"DTK_TYPE_CHANGE";
337  case DTK_TYPE_CHANGE_REQUEST: return L"DTK_TYPE_CHANGE_REQUEST";
338  case DTK_TYPE_SECURITY_CLASSIFICATION_LEVEL: return L"DTK_TYPE_SECURITY_CLASSIFICATION_LEVEL";
339  case DTK_TYPE_SECURITY_CLASSIFICATION: return L"DTK_TYPE_SECURITY_CLASSIFICATION";
340  case DTK_TYPE_START_REQUEST: return L"DTK_TYPE_START_REQUEST";
341  case DTK_TYPE_START_WORK: return L"DTK_TYPE_START_WORK";
342  case DTK_TYPE_CERTIFICATION: return L"DTK_TYPE_CERTIFICATION";
343  case DTK_TYPE_CONTRACT: return L"DTK_TYPE_CONTRACT";
344  case DTK_TYPE_APPROVED_ITEM: return L"DTK_TYPE_APPROVED_ITEM";
345  case DTK_TYPE_CLASSIFIED_ITEM: return L"DTK_TYPE_CLASSIFIED_ITEM";
346  case DTK_TYPE_PERSON_ORGANIZATION_ITEM: return L"DTK_TYPE_PERSON_ORGANIZATION_ITEM";
347  case DTK_TYPE_SPECIFIED_ITEM: return L"DTK_TYPE_SPECIFIED_ITEM";
348  case DTK_TYPE_PRODUCT_DEFINITION_RELATIONSHIP: return L"DTK_TYPE_PRODUCT_DEFINITION_RELATIONSHIP";
349  case DTK_TYPE_CHARACTERIZED_PRODUCT_DEFINITION: return L"DTK_TYPE_CHARACTERIZED_PRODUCT_DEFINITION";
350  case DTK_TYPE_PRODUCT_DEFINITION_SHAPE: return L"DTK_TYPE_PRODUCT_DEFINITION_SHAPE";
351  case DTK_TYPE_PRODUCT_DEFINITION_FORMATION: return L"DTK_TYPE_PRODUCT_DEFINITION_FORMATION";
352  case DTK_TYPE_PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE: return L"DTK_TYPE_PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE";
353  case DTK_TYPE_DESIGN_CONTEXT: return L"DTK_TYPE_DESIGN_CONTEXT";
354  case DTK_TYPE_REPRESENTATION_CONTEXT: return L"DTK_TYPE_REPRESENTATION_CONTEXT";
355  case DTK_TYPE_REPRESENTATION_ITEM: return L"DTK_TYPE_REPRESENTATION_ITEM";
356  case DTK_TYPE_PARAMETRIC_REPRESENTATION_CONTEXT: return L"DTK_TYPE_PARAMETRIC_REPRESENTATION_CONTEXT";
357  case DTK_TYPE_DEFINITIONAL_REPRESENTATION_ITEM: return L"DTK_TYPE_DEFINITIONAL_REPRESENTATION_ITEM";
358  case DTK_TYPE_REPRESENTATION: return L"DTK_TYPE_REPRESENTATION";
359  case DTK_TYPE_DEFINITIONAL_REPRESENTATION: return L"DTK_TYPE_DEFINITIONAL_REPRESENTATION";
360  case DTK_TYPE_SHAPE_REPRESENTATION_RELATIONSHIP: return L"DTK_TYPE_SHAPE_REPRESENTATION_RELATIONSHIP";
361  case DTK_TYPE_REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION: return L"DTK_TYPE_REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION";
362  case DTK_TYPE_REPRESENTATION_MAP: return L"DTK_TYPE_REPRESENTATION_MAP";
363  case DTK_TYPE_GEOMETRIC_REPRESENTATION_CONTEXT: return L"DTK_TYPE_GEOMETRIC_REPRESENTATION_CONTEXT";
364  case DTK_TYPE_GEOMETRIC_REPRESENTATION_ITEM: return L"DTK_TYPE_GEOMETRIC_REPRESENTATION_ITEM";
365  case DTK_TYPE_MAPPED_ITEM: return L"DTK_TYPE_MAPPED_ITEM";
366  case DTK_TYPE_REPRESENTATION_RELATIONSHIP: return L"DTK_TYPE_REPRESENTATION_RELATIONSHIP";
367  case DTK_TYPE_SHAPE_REPRESENTATION: return L"DTK_TYPE_SHAPE_REPRESENTATION";
368  case DTK_TYPE_SHELL_BASED_WIREFRAME_SHAPE_REPRESENTATION: return L"DTK_TYPE_SHELL_BASED_WIREFRAME_SHAPE_REPRESENTATION";
369  case DTK_TYPE_ADVANCED_BREP_SHAPE_REPRESENTATION: return L"DTK_TYPE_ADVANCED_BREP_SHAPE_REPRESENTATION";
370  case DTK_TYPE_MANIFOLD_SURFACE_SHAPE_REPRESENTATION: return L"DTK_TYPE_MANIFOLD_SURFACE_SHAPE_REPRESENTATION";
371  case DTK_TYPE_GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION: return L"DTK_TYPE_GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION";
372  case DTK_TYPE_GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION: return L"DTK_TYPE_GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION";
373  case DTK_TYPE_SHAPE_ASPECT_RELATIONSHIP: return L"DTK_TYPE_SHAPE_ASPECT_RELATIONSHIP";
374  case DTK_TYPE_SHAPE_DEFINITION: return L"DTK_TYPE_SHAPE_DEFINITION";
375  case DTK_TYPE_SHAPE_DEFINITION_REPRESENTATION: return L"DTK_TYPE_SHAPE_DEFINITION_REPRESENTATION";
376  case DTK_TYPE_SHAPE_ASPECT: return L"DTK_TYPE_SHAPE_ASPECT";
377  case DTK_TYPE_DESIGN_MAKE_FROM_RELATIONSHIP: return L"DTK_TYPE_DESIGN_MAKE_FROM_RELATIONSHIP";
378  case DTK_TYPE_SUPPLIED_PART_RELATIONSHIP: return L"DTK_TYPE_SUPPLIED_PART_RELATIONSHIP";
379  case DTK_TYPE_CERTIFIED_ITEM: return L"DTK_TYPE_CERTIFIED_ITEM";
380  case DTK_TYPE_PRODUCT_CATEGORY: return L"DTK_TYPE_PRODUCT_CATEGORY";
381  case DTK_TYPE_PRODUCT_RELATED_PRODUCT_CATEGORY: return L"DTK_TYPE_PRODUCT_RELATED_PRODUCT_CATEGORY";
382  case DTK_TYPE_PRODUCT_CATEGORY_RELATIONSHIP: return L"DTK_TYPE_PRODUCT_CATEGORY_RELATIONSHIP";
383  case DTK_TYPE_PRODUCT_VERSION_WITH_SPECIFIED_SOURCE: return L"DTK_TYPE_PRODUCT_VERSION_WITH_SPECIFIED_SOURCE";
384  case DTK_TYPE_ALTERNATE_PRODUCT_RELATIONSHIP: return L"DTK_TYPE_ALTERNATE_PRODUCT_RELATIONSHIP";
385  case DTK_TYPE_ACTION_REQUEST_ASSIGNMENT: return L"DTK_TYPE_ACTION_REQUEST_ASSIGNMENT";
386  case DTK_TYPE_ACTION_ASSIGNMENT: return L"DTK_TYPE_ACTION_ASSIGNMENT";
387  case DTK_TYPE_CERTIFICATION_ASSIGNMENT: return L"DTK_TYPE_CERTIFICATION_ASSIGNMENT";
388  case DTK_TYPE_APPROVAL_ASSIGNMENT: return L"DTK_TYPE_APPROVAL_ASSIGNMENT";
389  case DTK_TYPE_CONTRACT_ASSIGNMENT: return L"DTK_TYPE_CONTRACT_ASSIGNMENT";
390  case DTK_TYPE_SECURITY_CLASSIFICATION_ASSIGNMENT: return L"DTK_TYPE_SECURITY_CLASSIFICATION_ASSIGNMENT";
391  case DTK_TYPE_PERSON: return L"DTK_TYPE_PERSON";
392  case DTK_TYPE_ORGANIZATION: return L"DTK_TYPE_ORGANIZATION";
393  case DTK_TYPE_PERSON_AND_ORGANIZATION_ROLE: return L"DTK_TYPE_PERSON_AND_ORGANIZATION_ROLE";
394  case DTK_TYPE_PERSON_ORGANIZATION_SELECT: return L"DTK_TYPE_PERSON_ORGANIZATION_SELECT";
395  case DTK_TYPE_PERSON_AND_ORGANIZATION: return L"DTK_TYPE_PERSON_AND_ORGANIZATION";
396  case DTK_TYPE_PERSON_AND_ORGANIZATION_ASSIGNMENT: return L"DTK_TYPE_PERSON_AND_ORGANIZATION_ASSIGNMENT";
397  case DTK_TYPE_ORGANIZATION_RELATIONSHIP: return L"DTK_TYPE_ORGANIZATION_RELATIONSHIP";
398  case DTK_TYPE_APPROVAL: return L"DTK_TYPE_APPROVAL";
399  case DTK_TYPE_APPROVAL_STATUS: return L"DTK_TYPE_APPROVAL_STATUS";
400  case DTK_TYPE_APPROVAL_ROLE: return L"DTK_TYPE_APPROVAL_ROLE";
401  case DTK_TYPE_APPROVAL_PERSON_ORGANIZATION: return L"DTK_TYPE_APPROVAL_PERSON_ORGANIZATION";
402  case DTK_TYPE_APPROVAL_RELATIONSHIP: return L"DTK_TYPE_APPROVAL_RELATIONSHIP";
403  case DTK_TYPE_PERSONAL_ADDRESS: return L"DTK_TYPE_PERSONAL_ADDRESS";
404  case DTK_TYPE_ADDRESS: return L"DTK_TYPE_ADDRESS";
405  case DTK_TYPE_ORGANIZATIONAL_ADDRESS: return L"DTK_TYPE_ORGANIZATIONAL_ADDRESS";
406  case DTK_TYPE_FUNCTIONALLY_DEFINED_TRANSFORMATION: return L"DTK_TYPE_FUNCTIONALLY_DEFINED_TRANSFORMATION";
407  case DTK_TYPE_ITEM_DEFINED_TRANSFORMATION: return L"DTK_TYPE_ITEM_DEFINED_TRANSFORMATION";
408  case DTK_TYPE_TRANSFORMATION: return L"DTK_TYPE_TRANSFORMATION";
409  case DTK_TYPE_CC_DESIGN_CERTIFICATION: return L"DTK_TYPE_CC_DESIGN_CERTIFICATION";
410  case DTK_TYPE_CC_DESIGN_APPROVAL: return L"DTK_TYPE_CC_DESIGN_APPROVAL";
411  case DTK_TYPE_CC_DESIGN_CONTRACT: return L"DTK_TYPE_CC_DESIGN_CONTRACT";
412  case DTK_TYPE_CC_DESIGN_SECURITY_CLASSIFICATION: return L"DTK_TYPE_CC_DESIGN_SECURITY_CLASSIFICATION";
413  case DTK_TYPE_CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT: return L"DTK_TYPE_CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT";
414  case DTK_TYPE_CC_DESIGN_SPECIFICATION_REFERENCE: return L"DTK_TYPE_CC_DESIGN_SPECIFICATION_REFERENCE";
415  case DTK_TYPE_PROPERTY_DEFINITION: return L"DTK_TYPE_PROPERTY_DEFINITION";
416  case DTK_TYPE_PRE_DEFINED_TERMINATOR_SYMBOL: return L"DTK_TYPE_PRE_DEFINED_TERMINATOR_SYMBOL";
417  case DTK_TYPE_PRE_DEFINED_POINT_MARKER_SYMBOL: return L"DTK_TYPE_PRE_DEFINED_POINT_MARKER_SYMBOL";
418  case DTK_TYPE_PRE_DEFINED_DIMENSION_SYMBOL: return L"DTK_TYPE_PRE_DEFINED_DIMENSION_SYMBOL";
419  case DTK_TYPE_PRE_DEFINED_GEOMETRICAL_TOLERANCE_SYMBOL: return L"DTK_TYPE_PRE_DEFINED_GEOMETRICAL_TOLERANCE_SYMBOL";
420  case DTK_TYPE_DRAUGHTING_PRE_DEFINED_COLOUR: return L"DTK_TYPE_DRAUGHTING_PRE_DEFINED_COLOUR";
421  case DTK_TYPE_DRAUGHTING_PRE_DEFINED_CURVE_FONT: return L"DTK_TYPE_DRAUGHTING_PRE_DEFINED_CURVE_FONT";
422  case DTK_TYPE_PRE_DEFINED_CURVE_FONT: return L"DTK_TYPE_PRE_DEFINED_CURVE_FONT";
423  case DTK_TYPE_PRE_DEFINED_SYMBOL: return L"DTK_TYPE_PRE_DEFINED_SYMBOL";
424  case DTK_TYPE_PRE_DEFINED_COLOUR: return L"DTK_TYPE_PRE_DEFINED_COLOUR";
425  case DTK_TYPE_PRE_DEFINED_ITEM: return L"DTK_TYPE_PRE_DEFINED_ITEM";
426  case DTK_TYPE_LEADER_CURVE: return L"DTK_TYPE_LEADER_CURVE";
427  case DTK_TYPE_PROJECTION_CURVE: return L"DTK_TYPE_PROJECTION_CURVE";
428  case DTK_TYPE_DIMENSION_CURVE: return L"DTK_TYPE_DIMENSION_CURVE";
429  case DTK_TYPE_ONE_DIRECTION_REPEAT_FACTOR: return L"DTK_TYPE_ONE_DIRECTION_REPEAT_FACTOR";
430  case DTK_TYPE_TWO_DIRECTION_REPEAT_FACTOR: return L"DTK_TYPE_TWO_DIRECTION_REPEAT_FACTOR";
431  case DTK_TYPE_LEADER_TERMINATOR: return L"DTK_TYPE_LEADER_TERMINATOR";
432  case DTK_TYPE_DIMENSION_CURVE_TERMINATOR: return L"DTK_TYPE_DIMENSION_CURVE_TERMINATOR";
433  case DTK_TYPE_TERMINATOR_SYMBOL: return L"DTK_TYPE_TERMINATOR_SYMBOL";
434  case DTK_TYPE_DEFINED_SYMBOL_SELECT: return L"DTK_TYPE_DEFINED_SYMBOL_SELECT";
435  case DTK_TYPE_SYMBOL_TARGET: return L"DTK_TYPE_SYMBOL_TARGET";
436  case DTK_TYPE_DEFINED_SYMBOL: return L"DTK_TYPE_DEFINED_SYMBOL";
437  case DTK_TYPE_COLOUR_RGB: return L"DTK_TYPE_COLOUR_RGB";
438  case DTK_TYPE_COLOUR_SPECIFICATION: return L"DTK_TYPE_COLOUR_SPECIFICATION";
439  case DTK_TYPE_COLOUR: return L"DTK_TYPE_COLOUR";
440  case DTK_TYPE_SYMBOL_COLOUR: return L"DTK_TYPE_SYMBOL_COLOUR";
441  case DTK_TYPE_SYMBOL_STYLE_SELECT: return L"DTK_TYPE_SYMBOL_STYLE_SELECT";
442  case DTK_TYPE_TEXT_STYLE_FOR_DEFINED_FONT: return L"DTK_TYPE_TEXT_STYLE_FOR_DEFINED_FONT";
443  case DTK_TYPE_CHARACTER_STYLE_SELECT: return L"DTK_TYPE_CHARACTER_STYLE_SELECT";
444  case DTK_TYPE_CURVE_STYLE_FONT: return L"DTK_TYPE_CURVE_STYLE_FONT";
445  case DTK_TYPE_CURVE_STYLE_FONT_SELECT: return L"DTK_TYPE_CURVE_STYLE_FONT_SELECT";
446  case DTK_TYPE_CURVE_FONT_OR_SCALED_CURVE_STYLE_FONT_SELECT: return L"DTK_TYPE_CURVE_FONT_OR_SCALED_CURVE_STYLE_FONT_SELECT";
447  case DTK_TYPE_FILL_AREA_STYLE: return L"DTK_TYPE_FILL_AREA_STYLE";
448  case DTK_TYPE_SYMBOL_STYLE: return L"DTK_TYPE_SYMBOL_STYLE";
449  case DTK_TYPE_CURVE_STYLE: return L"DTK_TYPE_CURVE_STYLE";
450  case DTK_TYPE_FILL_AREA_STYLE_HATCHING: return L"DTK_TYPE_FILL_AREA_STYLE_HATCHING";
451  case DTK_TYPE_FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE: return L"DTK_TYPE_FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE";
452  case DTK_TYPE_FILL_AREA_STYLE_TILE_SHAPE_SELECT: return L"DTK_TYPE_FILL_AREA_STYLE_TILE_SHAPE_SELECT";
453  case DTK_TYPE_FILL_AREA_STYLE_TILES: return L"DTK_TYPE_FILL_AREA_STYLE_TILES";
454  case DTK_TYPE_FILL_AREA_STYLE_COLOUR: return L"DTK_TYPE_FILL_AREA_STYLE_COLOUR";
455  case DTK_TYPE_FILL_STYLE_SELECT: return L"DTK_TYPE_FILL_STYLE_SELECT";
456  case DTK_TYPE_TEXT_STYLE: return L"DTK_TYPE_TEXT_STYLE";
457  case DTK_TYPE_PRESENTATION_STYLE_SELECT: return L"DTK_TYPE_PRESENTATION_STYLE_SELECT";
458  case DTK_TYPE_PRESENTATION_STYLE_ASSIGNMENT: return L"DTK_TYPE_PRESENTATION_STYLE_ASSIGNMENT";
459  case DTK_TYPE_ANNOTATION_TEXT_OCCURRENCE: return L"DTK_TYPE_ANNOTATION_TEXT_OCCURRENCE";
460  case DTK_TYPE_ANNOTATION_SUBFIGURE_OCCURRENCE: return L"DTK_TYPE_ANNOTATION_SUBFIGURE_OCCURRENCE";
461  case DTK_TYPE_ANNOTATION_FILL_AREA_OCCURRENCE: return L"DTK_TYPE_ANNOTATION_FILL_AREA_OCCURRENCE";
462  case DTK_TYPE_ANNOTATION_FILL_AREA: return L"DTK_TYPE_ANNOTATION_FILL_AREA";
463  case DTK_TYPE_ANNOTATION_CURVE_OCCURRENCE: return L"DTK_TYPE_ANNOTATION_CURVE_OCCURRENCE";
464  case DTK_TYPE_ANNOTATION_SYMBOL_OCCURRENCE: return L"DTK_TYPE_ANNOTATION_SYMBOL_OCCURRENCE";
465  case DTK_TYPE_ANNOTATION_OCCURRENCE: return L"DTK_TYPE_ANNOTATION_OCCURRENCE";
466  case DTK_TYPE_DRAUGHTING_CALLOUT_ELEMENT: return L"DTK_TYPE_DRAUGHTING_CALLOUT_ELEMENT";
467  case DTK_TYPE_ANGULAR_DIMENSION: return L"DTK_TYPE_ANGULAR_DIMENSION";
468  case DTK_TYPE_CURVE_DIMENSION: return L"DTK_TYPE_CURVE_DIMENSION";
469  case DTK_TYPE_DIAMETER_DIMENSION: return L"DTK_TYPE_DIAMETER_DIMENSION";
470  case DTK_TYPE_LINEAR_DIMENSION: return L"DTK_TYPE_LINEAR_DIMENSION";
471  case DTK_TYPE_RADIUS_DIMENSION: return L"DTK_TYPE_RADIUS_DIMENSION";
472  case DTK_TYPE_ORDINATE_DIMENSION: return L"DTK_TYPE_ORDINATE_DIMENSION";
473  case DTK_TYPE_PROJECTION_DIRECTED_CALLOUT: return L"DTK_TYPE_PROJECTION_DIRECTED_CALLOUT";
474  case DTK_TYPE_DIMENSION_CURVE_DIRECTED_CALLOUT: return L"DTK_TYPE_DIMENSION_CURVE_DIRECTED_CALLOUT";
475  case DTK_TYPE_DRAUGHTING_CALLOUT: return L"DTK_TYPE_DRAUGHTING_CALLOUT";
476  case DTK_TYPE_DRAUGHTING_PRE_DEFINED_TEXT_FONT: return L"DTK_TYPE_DRAUGHTING_PRE_DEFINED_TEXT_FONT";
477  case DTK_TYPE_PRE_DEFINED_TEXT_FONT: return L"DTK_TYPE_PRE_DEFINED_TEXT_FONT";
478  case DTK_TYPE_FONT_SELECT: return L"DTK_TYPE_FONT_SELECT";
479  case DTK_TYPE_TEXT_LITERAL: return L"DTK_TYPE_TEXT_LITERAL";
480  case DTK_TYPE_TEXT_OR_CHARACTER: return L"DTK_TYPE_TEXT_OR_CHARACTER";
481  case DTK_TYPE_COMPOSITE_TEXT: return L"DTK_TYPE_COMPOSITE_TEXT";
482  case DTK_TYPE_TEXT_STYLE_WITH_MIRROR: return L"DTK_TYPE_TEXT_STYLE_WITH_MIRROR";
483  case DTK_TYPE_TEXT_STYLE_WITH_BOX_CHARACTERISTICS: return L"DTK_TYPE_TEXT_STYLE_WITH_BOX_CHARACTERISTICS";
484  case DTK_TYPE_DRAWING_REPLICA: return L"DTK_TYPE_DRAWING_REPLICA";
485  case DTK_TYPE_SYMBOL: return L"DTK_TYPE_SYMBOL";
486  case DTK_TYPE_SPHERE: return L"DTK_TYPE_SPHERE";
487  case DTK_TYPE_BLOCK: return L"DTK_TYPE_BLOCK";
488  case DTK_TYPE_RIGHT_ANGULAR_WEDGE: return L"DTK_TYPE_RIGHT_ANGULAR_WEDGE";
489  case DTK_TYPE_TORUS: return L"DTK_TYPE_TORUS";
490  case DTK_TYPE_RIGHT_CIRCULAR_CYLINDER: return L"DTK_TYPE_RIGHT_CIRCULAR_CYLINDER";
491  case DTK_TYPE_RIGHT_CIRCULAR_CONE: return L"DTK_TYPE_RIGHT_CIRCULAR_CONE";
492  case DTK_TYPE_HALF_SPACE_SOLID: return L"DTK_TYPE_HALF_SPACE_SOLID";
493  case DTK_TYPE_CSG_SOLID: return L"DTK_TYPE_CSG_SOLID";
494  case DTK_TYPE_BOOLEAN_RESULT: return L"DTK_TYPE_BOOLEAN_RESULT";
495  case DTK_TYPE_SWEPT_AREA_SOLID: return L"DTK_TYPE_SWEPT_AREA_SOLID";
496  case DTK_TYPE_SOLID_OF_LINEAR_EXTRUSION: return L"DTK_TYPE_SOLID_OF_LINEAR_EXTRUSION";
497  case DTK_TYPE_SOLID_OF_REVOLUTION: return L"DTK_TYPE_SOLID_OF_REVOLUTION";
498  case DTK_TYPE_BOX_DOMAIN: return L"DTK_TYPE_BOX_DOMAIN";
499  case DTK_TYPE_BOXED_HALF_SPACE: return L"DTK_TYPE_BOXED_HALF_SPACE";
500  case DTK_TYPE_BOOLEAN_OPERAND_ENTITY: return L"DTK_TYPE_BOOLEAN_OPERAND_ENTITY";
501  case DTK_TYPE_CSG_SELECT_ENTITY: return L"DTK_TYPE_CSG_SELECT_ENTITY";
502  case DTK_TYPE_CSG_PRIMITIVE: return L"DTK_TYPE_CSG_PRIMITIVE";
503  case DTK_TYPE_ASSOCIATIVE_ANGULAR_DIMENSION: return L"DTK_TYPE_ASSOCIATIVE_ANGULAR_DIMENSION";
504  case DTK_TYPE_ASSOCIATIVE_CURVE_DIMENSION: return L"DTK_TYPE_ASSOCIATIVE_CURVE_DIMENSION";
505  case DTK_TYPE_ASSOCIATIVE_DIAMETER_DIMENSION: return L"DTK_TYPE_ASSOCIATIVE_DIAMETER_DIMENSION";
506  case DTK_TYPE_ASSOCIATIVE_LINEAR_DIMENSION: return L"DTK_TYPE_ASSOCIATIVE_LINEAR_DIMENSION";
507  case DTK_TYPE_ASSOCIATIVE_RADIUS_DIMENSION: return L"DTK_TYPE_ASSOCIATIVE_RADIUS_DIMENSION";
508  case DTK_TYPE_ASSOCIATIVE_ORDINATE_DIMENSION: return L"DTK_TYPE_ASSOCIATIVE_ORDINATE_DIMENSION";
509  case DTK_TYPE_FDT: return L"DTK_TYPE_FDT";
510  case DTK_TYPE_TEXT: return L"DTK_TYPE_TEXT";
511  case DTK_TYPE_ANNOTATION_ROUGHNESS: return L"DTK_TYPE_ANNOTATION_ROUGHNESS";
512  case DTK_TYPE_ANNOTATION: return L"DTK_TYPE_ANNOTATION ";
513  case DTK_TYPE_DATUM_TARGET: return L"DTK_TYPE_DATUM_TARGET ";
514  case DTK_TYPE_TABLE_ANNOTATION: return L"DTK_TYPE_TABLE_ANNOTATION ";
515  case DTK_TYPE_GEOM_TOL: return L"DTK_TYPE_GEOM_TOL ";
516  case DTK_TYPE_DIMENSION: return L"DTK_TYPE_DIMENSION ";
517  case DTK_TYPE_CELL: return L"DTK_TYPE_CELL ";
518  case DTK_TYPE_ROUGHNESS: return L"DTK_TYPE_ROUGHNESS ";
519  case DTK_TYPE_VIEW: return L"DTK_TYPE_VIEW ";
520  case DTK_TYPE_DRAWING: return L"DTK_TYPE_DRAWING ";
521  case DTK_TYPE_WELDING: return L"DTK_TYPE_WELDING ";
522  case DTK_TYPE_FDT_ANNOTATION_SET: return L"DTK_TYPE_FDT_ANNOTATION_SET ";
523  case DTK_TYPE_FDT_VIEW: return L"DTK_TYPE_FDT_VIEW ";
524  case DTK_TYPE_FDT_CAPTURE: return L"DTK_TYPE_FDT_CAPTURE ";
525  case DTK_TYPE_COMPOSITE_ENTITY: return L"DTK_TYPE_COMPOSITE_ENTITY ";
526  case DTK_TYPE_GLOBAL_DATA_SET: return L"DTK_TYPE_GLOBAL_DATA_SET ";
527  case DTK_TYPE_SELECTION_DATA_SET: return L"DTK_TYPE_SELECTION_DATA_SET";
528  case DTK_TYPE_PUBLICATION_DATA_SET: return L"DTK_TYPE_PUBLICATION_DATA_SET";
529  case DTK_TYPE_FDT_DATA_SET: return L"DTK_TYPE_FDT_DATA_SET";
530  case DTK_TYPE_FDT_SET: return L"DTK_TYPE_FDT_SET";
531  case DTK_TYPE_FDT_SET_VIEW: return L"DTK_TYPE_FDT_SET_VIEW";
532  case DTK_TYPE_FDT_SET_CAPTURE: return L"DTK_TYPE_FDT_SET_CAPTURE";
533  case DTK_TYPE_FDT_SET_FDT_INFOS: return L"DTK_TYPE_FDT_SET_FDT_INFOS";
534  case DTK_TYPE_FDT_LINK: return L"DTK_TYPE_FDT_LINK ";
535  case DTK_TYPE_REGION: return L"DTK_TYPE_REGION";
536  case DTK_TYPE_SOLID_ARRAY: return L"DTK_TYPE_SOLID_ARRAY";
537  case DTK_TYPE_OBJECT: return L"DTK_TYPE_OBJECT ";
538  case DTK_TYPE_VAL: return L"DTK_TYPE_VAL ";
539  case DTK_TYPE_ENTITY: return L"DTK_TYPE_ENTITY ";
540  case DTK_TYPE_INFO: return L"DTK_TYPE_INFO ";
541  case DTK_TYPE_MATRIX: return L"DTK_TYPE_MATRIX ";
542  case DTK_TYPE_TRANSFO: return L"DTK_TYPE_TRANSFO ";
543  case DTK_TYPE_GROUP: return L"DTK_TYPE_GROUP ";
544  case DTK_TYPE_2D_ENTITY: return L"DTK_TYPE_2D_ENTITY ";
545  case DTK_TYPE_LEADER: return L"DTK_TYPE_LEADER ";
546  case DTK_TYPE_REFERENCE: return L"DTK_TYPE_REFERENCE ";
547  case DTK_TYPE_REFERENCE_FRAME: return L"DTK_TYPE_REFERENCE_FRAME ";
548  case DTK_TYPE_TOL_SPEC: return L"DTK_TYPE_TOL_SPEC ";
549  case DTK_TYPE_READ_SHELL: return L"DTK_TYPE_READ_SHELL";
550  case DTK_TYPE_MESH: return L"DTK_TYPE_MESH";
551  case DTK_TYPE_CAMERA: return L"DTK_TYPE_CAMERA";
552  case DTK_TYPE_MESH_CURVE: return L"DTK_TYPE_MESH_CURVE";
553  case DTK_TYPE_MESH_STRING: return L"DTK_TYPE_MESH_STRING";
554  case DTK_TYPE_CONNECTOR: return L"DTK_TYPE_CONNECTOR";
555  case DTK_TYPE_CONNECTOR_PART: return L"DTK_TYPE_CONNECTOR_PART";
556  case DTK_TYPE_NODE_CONNECTOR: return L"DTK_TYPE_NODE_CONNECTOR";
557  case DTK_TYPE_NODE_CONNECTOR_ENTITY: return L"DTK_TYPE_NODE_CONNECTOR_ENTITY";
558  case DTK_TYPE_MODEL_DISPLAY: return L"DTK_TYPE_MODEL_DISPLAY";
559  case DTK_TYPE_POINT: return L"DTK_TYPE_POINT";
560  case DTK_TYPE_TABLE: return L"DTK_TYPE_TABLE ";
561  case DTK_TYPE_BODY: return L"DTK_TYPE_BODY";
562  case DTK_TYPE_LUMP: return L"DTK_TYPE_LUMP";
563  case DTK_TYPE_VOLUME: return L"DTK_TYPE_VOLUME";
564  case DTK_TYPE_COEDGE: return L"DTK_TYPE_COEDGE";
565  case DTK_TYPE_NURBS_CURVE: return L"DTK_TYPE_NURBS_CURVE";
566  case DTK_TYPE_NURBS_SURFACE: return L"DTK_TYPE_NURBS_SURFACE";
567  case DTK_TYPE_REVOLUTION_SURFACE: return L"DTK_TYPE_REVOLUTION_SURFACE";
568  case DTK_TYPE_STANDARD_REVOLUTION_SURFACE: return L"DTK_TYPE_STANDARD_REVOLUTION_SURFACE";
569  case DTK_TYPE_LINEAR_EXTRUSION_SURFACE: return L"DTK_TYPE_LINEAR_EXTRUSION_SURFACE";
570  case DTK_TYPE_TRANSFORMED_SURFACE: return L"DTK_TYPE_TRANSFORMED_SURFACE";
571  case DTK_TYPE_TOL_SPEC_CONT: return L"DTK_TYPE_TOL_SPEC_CONT";
572  case DTK_TYPE_LAYER_INFOS_SET: return L"DTK_TYPE_LAYER_INFOS_SET";
573  case DTK_TYPE_LAYER_FILTER_INFOS: return L"DTK_TYPE_LAYER_FILTER_INFOS";
574  case DTK_TYPE_PREVIEW: return L"DTK_TYPE_PREVIEW";
575  case DTK_TYPE_DOCUMENT: return L"DTK_TYPE_DOCUMENT";
576  case DTK_TYPE_DOC_ELEMENT: return L"DTK_TYPE_DOC_ELEMENT";
577  case DTK_TYPE_NODE: return L"DTK_TYPE_NODE";
578  case DTK_TYPE_COMPONENT: return L"DTK_TYPE_COMPONENT";
579  case DTK_TYPE_INSTANCE: return L"DTK_TYPE_INSTANCE";
580  case DTK_TYPE_CATALOG: return L"DTK_TYPE_CATALOG";
581  case DTK_TYPE_PROTOTYPE: return L"DTK_TYPE_PROTOTYPE";
582  case DTK_TYPE_METADATA: return L"DTK_TYPE_METADATA";
583  case DTK_TYPE_METADATAWITHUNIT: return L"DTK_TYPE_METADATAWITHUNIT";
584  case DTK_TYPE_PROPERTY: return L"DTK_TYPE_PROPERTY";
585  case DTK_TYPE_ENTITY_LINK: return L"DTK_TYPE_ENTITY_LINK";
586  case DTK_TYPE_MATERIAL: return L"DTK_TYPE_MATERIAL";
587  case DTK_TYPE_MATERIAL_LIBRARY: return L"DTK_TYPE_MATERIAL_LIBRARY";
588  case DTK_TYPE_MEASURE: return L"DTK_TYPE_MEASURE";
589  case DTK_TYPE_MEASURE_PROPERTIES: return L"DTK_TYPE_MEASURE_PROPERTIES";
590  case DTK_TYPE_MESH_FACE: return L"DTK_TYPE_MESH_FACE";
591  case DTK_TYPE_PARAMETER_VALUE: return L"DTK_TYPE_PARAMETER_VALUE";
592  case DTK_TYPE_FEATURE: return L"DTK_TYPE_FEATURE";
593  case DTK_TYPE_KINEMATIC: return L"DTK_TYPE_KINEMATIC";
594  case DTK_TYPE_KIN_NAMED_VALUE: return L"DTK_TYPE_KIN_NAMED_VALUE";
595  case DTK_TYPE_KIN_CONSTRAINT: return L"DTK_TYPE_KIN_CONSTRAINT";
596  case DTK_TYPE_KIN_MECHANISM: return L"DTK_TYPE_KIN_MECHANISM";
597  case DTK_TYPE_KIN_PARAMETER: return L"DTK_TYPE_KIN_PARAMETER";
598  case DTK_TYPE_KIN_COMMAND: return L"DTK_TYPE_KIN_COMMAND";
599  case DTK_TYPE_KIN_JOINT: return L"DTK_TYPE_KIN_JOINT";
600  case DTK_TYPE_KIN_LAW: return L"DTK_TYPE_KIN_LAW";
601  case DTK_TYPE_KIN_SPEEDACCELERATION: return L"DTK_TYPE_KIN_SPEEDACCELERATION";
602  case DTK_TYPE_KIN_FIXPART: return L"DTK_TYPE_KIN_FIXPART";
603  case DTK_TYPE_KIN_CURVE: return L"DTK_TYPE_KIN_CURVE";
604  case DTK_TYPE_KIN_PRODUCT: return L"DTK_TYPE_KIN_PRODUCT";
605  case DTK_TYPE_KIN_FORMULA: return L"DTK_TYPE_KIN_FORMULA";
606  case DTK_TYPE_HATCHING: return L"DTK_TYPE_HATCHING";
607  case DTK_TYPE_ASMSEARCHPATH: return L"DTK_TYPE_ASMSEARCHPATH";
608  case DTK_TYPE_CONNECTR_ECP: return L"DTK_TYPE_CONNECTR_ECP";
609  case DTK_TYPE_SELECTION_SET: return L"DTK_TYPE_SELECTION_SET";
610  case DTK_TYPE_PUBLICATION: return L"DTK_TYPE_PUBLICATION";
611  case DTK_TYPE_BLEND_BOUND: return L"DTK_TYPE_BLEND_BOUND";
612  case DTK_TYPE_TEXTURE: return L"DTK_TYPE_TEXTURE";
613  case DTK_TYPE_LIGHT: return L"DTK_TYPE_LIGHT";
614  case DTK_TYPE_RENDER: return L"DTK_TYPE_RENDER";
615  case DTK_TYPE_GEOMETRY: return L"DTK_TYPE_GEOMETRY";
616  case DTK_TYPE_CENTER_POINT: return L"DTK_TYPE_CENTER_POINT";
617  case DTK_TYPE_SKETCH: return L"DTK_TYPE_SKETCH";
618  case DTK_TYPE_NO_SUBTYPE: return L"DTK_TYPE_NO_SUBTYPE";
619  case DTK_TYPE_REFERENCE_AXIS_SYSTEM: return L"DTK_TYPE_REFERENCE_AXIS_SYSTEM";
620  case DTK_TYPE_REFERENCE_AXIS: return L"DTK_TYPE_REFERENCE_AXIS";
621  case DTK_TYPE_REFERENCE_PLANE: return L"DTK_TYPE_REFERENCE_PLANE";
622  case DTK_TYPE_REFERENCE_PLANE_TRIANGLE: return L"DTK_TYPE_REFERENCE_PLANE_TRIANGLE";
623  case DTK_TYPE_REFERENCE_POINT: return L"DTK_TYPE_REFERENCE_POINT";
624  case DTK_TYPE_CONSTRAINT: return L"DTK_TYPE_CONSTRAINT";
625  case DTK_TYPE_CABLING: return L"DTK_TYPE_CABLING";
626  case DTK_TYPE_CLOUD_BODY: return L"DTK_TYPE_CLOUD_BODY";
627  case DTK_TYPE_MAX_ENTITY: return L"DTK_TYPE_MAX_ENTITY";
628  default:
629  {
630  Dtk_string Res; Res.convert_from_int( inVal );
631  return Res;
632  }
633  }
634  }

◆ validate_xml_string()

Dtk_status validate_xml_string ( Dtk_string &  inputString)
639  {
640  Dtk_string outputString;
641  Dtk_string quote = Dtk_string( "\"" );
642  //Dtk_string and = Dtk_string("\&");
643 
644  Dtk_string xmlQuote = Dtk_string( "&quot;" );
645  Dtk_string xmlAnd = Dtk_string( "&amp;" );
646  int pos = -1;
647 
648  if( inputString.is_not_NULL() )
649  {
650  /* Change the and // Pb is replacing the &amp with "&amp"mpmpmpmpmpmpmpmpmp infiniment
651  pos = inputString.find_substring(and);
652  while (pos != -1)
653  {
654  inputString = inputString.left_exclusive(pos) + xmlAnd + inputString.right_exclusive(pos);
655  pos = inputString.find_substring(and);
656  int omitPos = inputString.find_substring("&amp;");
657  if (pos == omitPos)
658  {
659  pos = -1;
660  }
661  }*/
662 
663  // Change the quot
664  pos = inputString.find_substring( quote );
665  while( pos != -1 )
666  {
667  inputString = inputString.left_exclusive( pos ) + xmlQuote + inputString.right_exclusive( pos );
668  pos = inputString.find_substring( quote );
669  }
670  }
671  else
672  {
673  return DTK_NOERROR;
674  }
675 
676  return DTK_NOERROR;
677  }

Variable Documentation

◆ dump_file

FILE* dump_file = NULL

◆ FeaturesDumpFile

FILE* FeaturesDumpFile = NULL

◆ inDumpFile

FILE* inDumpFile
Dtk_mesh_face::get_nbtriangle_fans
Dtk_Size_t get_nbtriangle_fans() const
Get the number of triangle fans kept in the class instance.
Dtk_Leader::LeaderTerminatorTypeEnumToString
static Dtk_string LeaderTerminatorTypeEnumToString(const LeaderTerminatorTypeEnum &inEnum)
Definition: util_draw_dtk.hpp:1909
Dtk_DumpXml_Dtk_SymbolPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SymbolPtr(FILE *F, const Dtk_SymbolPtr &D)
Definition: util_xml_dtk.cpp:2779
Dtk_DumpXml_Dtk_DatumTargetPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DatumTargetPtr(FILE *F, const Dtk_DatumTargetPtr &D)
Definition: util_xml_dtk.cpp:2081
Dtk_Welding::SymbolFoldJointWeld
@ SymbolFoldJointWeld
Definition: util_draw_dtk.hpp:2859
DTK_TYPE_PRE_DEFINED_GEOMETRICAL_TOLERANCE_SYMBOL
@ DTK_TYPE_PRE_DEFINED_GEOMETRICAL_TOLERANCE_SYMBOL
Definition: define.h:334
Dtk_KinLaw
Dtk_KinLaw represents a law associated at a command.
Definition: util_kinematics_dtk.hpp:2342
DTK_TYPE_ANNOTATION_FILL_AREA
@ DTK_TYPE_ANNOTATION_FILL_AREA
Definition: define.h:377
Dtk_feat_hole::GetNeckAngle
Dtk_Double64 GetNeckAngle() const
return the angle of the neck
Definition: str_feat_dtk.hpp:1970
Dtk_DumpXml_Dtk_NodePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr(FILE *F, const Dtk_NodePtr &inObject)
Definition: util_xml_dtk.cpp:4640
Dtk_DumpXml_Dtk_MainDocPtr_Init
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr_Init(FILE *F, const Dtk_MainDocPtr &inObject)
Definition: util_xml_dtk.cpp:4585
Dtk_KinJoint::getName
Dtk_string getName()
Returns the joint name.
DTK_PICTURE_UNKNOWN
@ DTK_PICTURE_UNKNOWN
Definition: dtk_picture.hpp:21
Dtk_Dimension::LinearDiameterDimension
@ LinearDiameterDimension
Definition: util_draw_dtk.hpp:4543
Dtk_Camera::UpVector
const Dtk_dir & UpVector() const
Retrieves the up vector - read only -.
DTK_TYPE_DRAUGHTING_PRE_DEFINED_TEXT_FONT
@ DTK_TYPE_DRAUGHTING_PRE_DEFINED_TEXT_FONT
Definition: define.h:391
Dtk_KinJoint::getConstraint
Dtk_KinConstraintPtr getConstraint(Dtk_Size_t inPosition)
Returns Constraint at position inPosition.
Dtk_TextStyle::Ratio
Dtk_Double64 & Ratio()
Retrieves the text ratio - get/set -.
DTK_TYPE_FDT_SET
@ DTK_TYPE_FDT_SET
Definition: define.h:449
DTK_TYPE_KIN_JOINT
@ DTK_TYPE_KIN_JOINT
Definition: define.h:541
Dtk_Info::FindAttribute
Dtk_ErrorStatus FindAttribute(const Dtk_string &name, Dtk_Val &val) const
DTK_TYPE_PLANE_ANGLE_MEASURE
@ DTK_TYPE_PLANE_ANGLE_MEASURE
Definition: define.h:194
Dtk_PhysicalMaterialInfos::GetDensity
Dtk_ErrorStatus GetDensity(Dtk_Double64 &outValue, Dtk_string &outUnits) const
Returns the material density.
Dtk_Dimension::LengthDimension
@ LengthDimension
Definition: util_draw_dtk.hpp:4555
Dtk_NodeConnector::ReasonLinkEnum
ReasonLinkEnum
Reason - Type of the Dtk_NodeConnector -. It's used to filter connectors to same elements.
Definition: dtk_maindoc.hpp:1091
Dtk_TextStyle::JustificationCenter
@ JustificationCenter
Definition: util_draw_dtk.hpp:283
DTK_FEAT_THREAD
@ DTK_FEAT_THREAD
Definition: str_feat_dtk.hpp:302
DTK_TYPE_DRAWING_REPLICA
@ DTK_TYPE_DRAWING_REPLICA
Definition: define.h:399
DTK_TYPE_SECURITY_CLASSIFICATION_ASSIGNMENT
@ DTK_TYPE_SECURITY_CLASSIFICATION_ASSIGNMENT
Definition: define.h:305
DTK_TYPE_LAYER_INFOS_SET
@ DTK_TYPE_LAYER_INFOS_SET
Definition: define.h:494
DTK_TYPE_CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT
@ DTK_TYPE_CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT
Definition: define.h:328
Dtk_KinJoint::_FIX_TOGETHER
Dtk_string _FIX_TOGETHER
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:934
Dtk_feat_limit::UP_TO_PLANE
@ UP_TO_PLANE
Definition: str_feat_dtk.hpp:624
DTK_TYPE_RECTANGULAR_COMPOSITE_SURFACE
@ DTK_TYPE_RECTANGULAR_COMPOSITE_SURFACE
Definition: define.h:94
DTK_TYPE_UNIFORM_CURVE
@ DTK_TYPE_UNIFORM_CURVE
Definition: define.h:57
Dtk_RGB::G
int & G()
Definition: dtk_rgb.hpp:39
Dtk_KinParameter::getParentType
DTK_KINEMATIC_TYPE getParentType()
Returns the node parent type of this parameter (joint, command or mechanism)
DTK_TYPE_ANNOTATION_ROUGHNESS
@ DTK_TYPE_ANNOTATION_ROUGHNESS
Definition: define.h:426
Dtk_picture::get_info
Dtk_InfoPtr get_info() const
DTK_VAL_TYPE_RGB
@ DTK_VAL_TYPE_RGB
Definition: dtk_val.hpp:24
CaddsReaderModule
@ CaddsReaderModule
Definition: dtk_maindoc.hpp:46
Dtk_Oriented2dBBox::GetXLength
Dtk_Double64 GetXLength() const
Retrieves the X length - Read Only -.
Definition: util_draw_dtk.hpp:565
Dtk_ToleranceSpecificationContainer::Typeunknown
@ Typeunknown
Definition: util_draw_dtk.hpp:5699
Dtk_DumpXml_Dtk_GeometricalTolerancePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GeometricalTolerancePtr(FILE *F, const Dtk_GeometricalTolerancePtr &D)
Definition: util_xml_dtk.cpp:2550
DTK_TYPE_GEOMETRIC_REPRESENTATION_CONTEXT
@ DTK_TYPE_GEOMETRIC_REPRESENTATION_CONTEXT
Definition: define.h:278
DTK_TYPE_SURFACE_PATCH
@ DTK_TYPE_SURFACE_PATCH
Definition: define.h:97
Dtk_DumpXml_Dtk_ToroidalSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToroidalSurfacePtr(FILE *F, const Dtk_ToroidalSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6249
Dtk_Grid::WCS
@ WCS
Definition: util_draw_dtk.hpp:4325
RnXmlReaderModule
@ RnXmlReaderModule
Definition: dtk_maindoc.hpp:60
Dtk_DumpXml_Dtk_ComponentAvailability
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentAvailability(FILE *F, const Dtk_ComponentPtr &inObject)
Definition: util_xml_dtk.cpp:4896
DTK_TYPE_KIN_MECHANISM
@ DTK_TYPE_KIN_MECHANISM
Definition: define.h:538
UsdReaderModule
@ UsdReaderModule
Definition: dtk_maindoc.hpp:82
Dtk_Region::CircularType
@ CircularType
Definition: util_draw_dtk.hpp:7457
Dtk_DumpXml_Dtk_LeaderPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LeaderPtr(FILE *F, const Dtk_LeaderPtr &L)
Definition: util_xml_dtk.cpp:1288
Dtk_Welding::ComplementarySymbolFlushFinishedWeld
@ ComplementarySymbolFlushFinishedWeld
Definition: util_draw_dtk.hpp:2916
Dtk_LineTypeDefinition::Dtk_LineTypePatternDescriptorType
Dtk_LineTypePatternDescriptorType
Definition: dtk_line_type_definition.hpp:26
Dtk_HatchingPattern::LineType
Dtk_Int32 & LineType()
Dtk_Font::Name
Dtk_string & Name()
Retrieves the font name - get/set -.
Dtk_Info::GetReferenceSet
Dtk_ErrorStatus GetReferenceSet(Dtk_tab< Dtk_string > &outArray, Dtk_Int32 inRemovePrefix=DTK_FALSE) const
Dtk_ID
uint32_t Dtk_ID
Definition: define.h:688
DTK_FDT_MODIFIER_NOT_SET
@ DTK_FDT_MODIFIER_NOT_SET
Definition: util_draw_dtk.hpp:57
Dtk_Dimension::CumulatedDimension
@ CumulatedDimension
Definition: util_draw_dtk.hpp:4549
DTK_FRAME_TYPE_DIAMOND
@ DTK_FRAME_TYPE_DIAMOND
Definition: util_draw_dtk.hpp:137
Dtk_RenderInfos::GetLightMap
Dtk_LightMapPtr GetLightMap() const
Returns the render light map.
CerconReaderModule
@ CerconReaderModule
Definition: dtk_maindoc.hpp:49
DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR_3D
@ DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR_3D
Definition: define.h:37
DTK_TYPE_FILL_STYLE_SELECT
@ DTK_TYPE_FILL_STYLE_SELECT
Definition: define.h:370
DTK_TYPE_RIGHT_ANGULAR_WEDGE
@ DTK_TYPE_RIGHT_ANGULAR_WEDGE
Definition: define.h:403
Dtk_DumpXml_Dtk_ConicalSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConicalSurfacePtr(FILE *F, const Dtk_ConicalSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6214
Dtk_RGB::R
int & R()
Definition: dtk_rgb.hpp:36
DTK_TYPE_CATALOG
@ DTK_TYPE_CATALOG
Definition: define.h:505
Dtk_DumpXml_Dtk_roughness_obtention_type
Dtk_ErrorStatus Dtk_DumpXml_Dtk_roughness_obtention_type(FILE *F, const Dtk_Roughness::ObtentionTypeEnum &D)
Definition: util_xml_dtk.cpp:1495
Dtk_mesh_face
This is a high level face class.
Definition: util_mesh_dtk.hpp:1076
dtk_text_type_roughness_text1
@ dtk_text_type_roughness_text1
Definition: str_def.h:26
Dtk_Roughness::ApplyToSurroundingSurfaces
@ ApplyToSurroundingSurfaces
Definition: util_draw_dtk.hpp:2443
Dtk_Text::TextStyle
Dtk_TextStyle & TextStyle()
Retrieves the text text style - get/set -.
Dtk_feat_hole::GetInnerThread
Dtk_feat_inner_thread * GetInnerThread() const
Definition: str_feat_dtk.hpp:1699
DTK_TYPE_GEOM_TOL
@ DTK_TYPE_GEOM_TOL
Definition: define.h:430
Dtk_DumpXml_Dtk_CylindricalSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CylindricalSurfacePtr(FILE *F, const Dtk_CylindricalSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6197
DTK_TYPE_DEFINED_SYMBOL
@ DTK_TYPE_DEFINED_SYMBOL
Definition: define.h:351
Dtk_KinJoint::_RATIO_PARAMETER
Dtk_string _RATIO_PARAMETER
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:973
Dtk_DumpXml_Dtk_frame_type
void Dtk_DumpXml_Dtk_frame_type(FILE *F, const Dtk_frame_type &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:1145
Dtk_Camera::ZoomFactor
Dtk_Double64 ZoomFactor() const
Processes the X - width - zoom factor - read only -.
Definition: util_draw_dtk.hpp:7100
PlmXmlReaderModule
@ PlmXmlReaderModule
Definition: dtk_maindoc.hpp:56
Dtk_DumpXml_FeatLimit
Dtk_ErrorStatus Dtk_DumpXml_FeatLimit(FILE *f, const Dtk_feat_limit *inToWrite)
Definition: util_xml_dtk.cpp:8042
Dtk_DumpXml_Dtk_VolumePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_VolumePtr(FILE *F, const Dtk_VolumePtr &inVol)
Definition: util_xml_dtk.cpp:6676
DTK_FRAME_TYPE_FLAG_LEFT
@ DTK_FRAME_TYPE_FLAG_LEFT
Definition: util_draw_dtk.hpp:143
DTK_TYPE_MESH_SURFACE
@ DTK_TYPE_MESH_SURFACE
Definition: define.h:602
DTK_TYPE_MASS_MEASURE_WITH_UNIT
@ DTK_TYPE_MASS_MEASURE_WITH_UNIT
Definition: define.h:186
DTK_TYPE_PERSON_AND_ORGANIZATION_ASSIGNMENT
@ DTK_TYPE_PERSON_AND_ORGANIZATION_ASSIGNMENT
Definition: define.h:311
DTK_TYPE_MESH_STRING
@ DTK_TYPE_MESH_STRING
Definition: define.h:471
Dtk_DumpXml_Dtk_dir
Dtk_ErrorStatus Dtk_DumpXml_Dtk_dir(FILE *F, const Dtk_dir &D, const char *b)
Definition: util_xml_dtk.cpp:4356
Dtk_Dimension::ShowDualValueFractional
@ ShowDualValueFractional
Definition: util_draw_dtk.hpp:4568
DTK_TYPE_PROTOTYPE
@ DTK_TYPE_PROTOTYPE
Definition: define.h:506
DTK_TYPE_ACTION_STATUS
@ DTK_TYPE_ACTION_STATUS
Definition: define.h:247
Dtk_DumpXml_Dtk_welding_finish_symbol
Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_finish_symbol(FILE *F, const Dtk_Welding::FinishSymbolEnum &D)
Definition: util_xml_dtk.cpp:1759
DTK_TYPE_BOOLEAN_RESULT
@ DTK_TYPE_BOOLEAN_RESULT
Definition: define.h:409
DTK_TYPE_DESIGN_CONTEXT
@ DTK_TYPE_DESIGN_CONTEXT
Definition: define.h:268
Dtk_Region::ArbitraryType
@ ArbitraryType
Definition: util_draw_dtk.hpp:7460
DTK_TYPE_REPRESENTATION_RELATIONSHIP
@ DTK_TYPE_REPRESENTATION_RELATIONSHIP
Definition: define.h:281
NavisReaderModule
@ NavisReaderModule
Definition: dtk_maindoc.hpp:78
DTK_TYPE_UNKNOWN
@ DTK_TYPE_UNKNOWN
Definition: define.h:26
Dtk_DumpXml_Dtk_MetadataPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataPtr(FILE *F, const Dtk_MetaDataPtr &inObject)
Definition: util_xml_dtk.cpp:5035
Dtk_DumpXml_DTK_FDT_MODIFIER
Dtk_ErrorStatus Dtk_DumpXml_DTK_FDT_MODIFIER(FILE *F, const DTK_FDT_MODIFIER &D)
Definition: util_xml_dtk.cpp:2624
Dtk_DumpXml_Dtk_LinePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LinePtr(FILE *F, const Dtk_LinePtr &inCurve)
Definition: util_xml_dtk.cpp:5194
Dtk_Leader::ArrowHead::GetType
const LeaderTerminatorTypeEnum GetType() const
Definition: util_draw_dtk.hpp:2037
Dtk_API::GetNumColorInTable
Dtk_Size_t GetNumColorInTable() const
Get Number of Colors in API Lut
Dtk_ModelDisplay::rendering_mode_wireframe_face_analysis
@ rendering_mode_wireframe_face_analysis
Definition: util_ent_dtk.hpp:987
Dtk_feat_thread::GetSupportDepthTolerance
Dtk_feat_tolerance_set * GetSupportDepthTolerance() const
Definition: str_feat_dtk.hpp:1526
XMLElement
@ XMLElement
Definition: util_xml_dtk.hpp:93
DTK_TYPE_FILL_AREA_STYLE_TILES
@ DTK_TYPE_FILL_AREA_STYLE_TILES
Definition: define.h:368
DTK_PICTURE_CGM
@ DTK_PICTURE_CGM
Definition: dtk_picture.hpp:27
Dtk_TextStyle::Justification
TextJustificationEnum & Justification()
Retrieves the text justification - get/set -.
Dtk_status::isNotOK
Dtk_bool isNotOK() const
DTK_TYPE_FDT_LINK
@ DTK_TYPE_FDT_LINK
Definition: define.h:453
Dtk_TextStyle::AttributeUnderline
@ AttributeUnderline
Definition: util_draw_dtk.hpp:269
Dtk_API::GetNumCurveLineTypeDefinitionsInTable
Dtk_Size_t GetNumCurveLineTypeDefinitionsInTable() const
DTK_TYPE_CHARACTER_STYLE_SELECT
@ DTK_TYPE_CHARACTER_STYLE_SELECT
Definition: define.h:358
Dtk_TextStyle::FontStyleEnumToString
static Dtk_string FontStyleEnumToString(const FontStyleEnum &inEnum)
Definition: util_draw_dtk.hpp:254
DTK_TYPE_AXIS2_PLACEMENT_3D
@ DTK_TYPE_AXIS2_PLACEMENT_3D
Definition: define.h:32
DTK_TYPE_DIMENSION
@ DTK_TYPE_DIMENSION
Definition: define.h:431
DTK_TYPE_MESH_FACE
@ DTK_TYPE_MESH_FACE
Definition: define.h:528
Dtk_Text::TextSubType
DTK_Text_subtype & TextSubType()
Retrieves the text subtype - get/set -.
Dtk_ViewDisplay::WireframeDisplay
@ WireframeDisplay
Definition: util_draw_dtk.hpp:6453
DTK_TYPE_VOLUME_MEASURE_WITH_UNIT
@ DTK_TYPE_VOLUME_MEASURE_WITH_UNIT
Definition: define.h:190
DTK_TYPE_MESH
@ DTK_TYPE_MESH
Definition: define.h:468
Dtk_DatumTarget::NumValues
@ NumValues
Definition: util_draw_dtk.hpp:3603
Dtk_TextStyle::JustificationLeft
@ JustificationLeft
Definition: util_draw_dtk.hpp:281
Dtk_KinJoint
Dtk_KinJoint represents a joint to define a mechanism.
Definition: util_kinematics_dtk.hpp:867
Dtk_KinJoint::getJoint1
Dtk_KinJointPtr getJoint1()
Returns the first joint associated at the joint.
DTK_TYPE_CONNECTED_FACE_SET_ENTITY
@ DTK_TYPE_CONNECTED_FACE_SET_ENTITY
Definition: define.h:153
Dtk_feat_hole::GetLimit
Dtk_feat_limit * GetLimit() const
Definition: str_feat_dtk.hpp:1722
XMLGenericString
@ XMLGenericString
Definition: util_xml_dtk.hpp:95
Dtk_DumpXml_Dtk_KinematicsFixPart
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFixPart(FILE *inFile, const Dtk_KinFixPartPtr &inFixPart)
Definition: util_xml_dtk.cpp:7702
DTK_WITH_HIERARCHY
@ DTK_WITH_HIERARCHY
Definition: util_draw_dtk.hpp:67
Dtk_feat_hole::GetType
HOLE_TYPE GetType() const
Definition: str_feat_dtk.hpp:1658
Dtk_NodeConnector::GetSubEntities
Dtk_ErrorStatus GetSubEntities(Dtk_tab< Dtk_ID > &outEntitiesIDs, Dtk_tab< type_detk > &outEntitiesTypes) const
Retrieves The connected SubEntities - IDs and types -.
DTK_TYPE_DESIGN_MAKE_FROM_RELATIONSHIP
@ DTK_TYPE_DESIGN_MAKE_FROM_RELATIONSHIP
Definition: define.h:292
DTK_TYPE_EXECUTED_ACTION
@ DTK_TYPE_EXECUTED_ACTION
Definition: define.h:249
DTK_TYPE_DEGENERATE_PCURVE
@ DTK_TYPE_DEGENERATE_PCURVE
Definition: define.h:41
dtk_text_type_text_add_top
@ dtk_text_type_text_add_top
Definition: str_def.h:37
DTK_TYPE_SECURITY_CLASSIFICATION
@ DTK_TYPE_SECURITY_CLASSIFICATION
Definition: define.h:254
Dtk_DumpXml_Dtk_Dimension_ShowDualValueType
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Dimension_ShowDualValueType(FILE *F, const Dtk_Dimension::ShowDualValueTypeEnum &D)
Definition: util_xml_dtk.cpp:1375
Dtk_CompositeText::GetNumTexts
Dtk_Size_t GetNumTexts() const
Retrieves the texts number.
Dtk_transfo::getOrigin
const Dtk_pnt & getOrigin() const
Return the O center point of the Dtk_transfo (the center O of the basis)
Dtk_LineTypeDefinition::DTK_LINE_TYPE_PATTERN_DESCRIPTOR_DASH
@ DTK_LINE_TYPE_PATTERN_DESCRIPTOR_DASH
Definition: dtk_line_type_definition.hpp:28
DTK_FRAME_TYPE_FLAG_BOTH
@ DTK_FRAME_TYPE_FLAG_BOTH
Definition: util_draw_dtk.hpp:145
Dtk_DumpXml_Dtk_FilletSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FilletSurfacePtr(FILE *F, const Dtk_FilletSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6368
Dtk_Roughness::ApplyToAllSurfaces
@ ApplyToAllSurfaces
Definition: util_draw_dtk.hpp:2447
Dtk_DumpXml_FeatHole
Dtk_ErrorStatus Dtk_DumpXml_FeatHole(FILE *f, const Dtk_feat_hole *inToWrite)
Definition: util_xml_dtk.cpp:8133
DTK_TYPE_PRODUCT_DEFINITION_CONTEXT
@ DTK_TYPE_PRODUCT_DEFINITION_CONTEXT
Definition: define.h:220
DTK_PICTURE_RGB24
@ DTK_PICTURE_RGB24
Definition: dtk_picture.hpp:22
DTK_FRAME_TYPE_STICKING
@ DTK_FRAME_TYPE_STICKING
Definition: util_draw_dtk.hpp:154
DTK_TYPE_NODE_CONNECTOR
@ DTK_TYPE_NODE_CONNECTOR
Definition: define.h:474
Dtk_DumpXml_Dtk_2dEntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_2dEntityPtr(FILE *F, const Dtk_2dEntityPtr &D, const int &compact)
Definition: util_xml_dtk.cpp:2802
DTK_FRAME_TYPE_FIXED_SUPPORT
@ DTK_FRAME_TYPE_FIXED_SUPPORT
Definition: util_draw_dtk.hpp:158
DTK_TYPE_POLY_LOOP
@ DTK_TYPE_POLY_LOOP
Definition: define.h:124
DTK_TYPE_CONIC
@ DTK_TYPE_CONIC
Definition: define.h:48
Dtk_Welding::FinishSymbolHammer
@ FinishSymbolHammer
Definition: util_draw_dtk.hpp:2960
Dtk_HatchingPattern::LineWidth
Dtk_Double64 & LineWidth()
Dtk_KinJoint::_LOWER_LIMIT2
Dtk_string _LOWER_LIMIT2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:952
Dtk_feat_hole::GetStartDiameter
Dtk_Double64 GetStartDiameter() const
return the diameter of the start chamfer
Definition: str_feat_dtk.hpp:1937
Dtk_DumpXml_Dtk_KinematicsProduct
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsProduct(FILE *inFile, const Dtk_KinProductPtr &inKinProduct, int &inKinProductIndex)
Definition: util_xml_dtk.cpp:7722
DTK_TYPE_DEFINITIONAL_REPRESENTATION_ITEM
@ DTK_TYPE_DEFINITIONAL_REPRESENTATION_ITEM
Definition: define.h:272
DTK_TYPE_CELL
@ DTK_TYPE_CELL
Definition: define.h:432
DTK_Text_subtype::IsUrl
Dtk_bool IsUrl() const
Tell if the associated Dtk_text is an url group - into Dtk_Dimension -.
Dtk_DatumTarget::DatumTargetValueEnumToString
static Dtk_string DatumTargetValueEnumToString(const DatumTargetValueEnum &inEnum)
Definition: util_draw_dtk.hpp:3606
DTK_TYPE_READ_SHELL
@ DTK_TYPE_READ_SHELL
Definition: define.h:467
DTK_TYPE_ANNOTATION
@ DTK_TYPE_ANNOTATION
Definition: define.h:427
Dtk_DumpXml_Dtk_BoundaryPtr
static Dtk_ErrorStatus Dtk_DumpXml_Dtk_BoundaryPtr(FILE *F, const Dtk_Boundary &boundary)
Definition: util_xml_dtk.cpp:2141
Dtk_feat::GetName
Dtk_string GetName() const
Definition: str_feat_dtk.hpp:7026
DTK_FDT_MODIFIER_LEAST_MATERIAL
@ DTK_FDT_MODIFIER_LEAST_MATERIAL
Definition: util_draw_dtk.hpp:59
Dtk_DumpXml_Dtk_OneCell
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OneCell(FILE *F, Dtk_OneCell &D)
Definition: util_xml_dtk.cpp:2231
DTK_TYPE_VAL
@ DTK_TYPE_VAL
Definition: define.h:456
DTK_TYPE_DOC_ELEMENT
@ DTK_TYPE_DOC_ELEMENT
Definition: define.h:501
Dtk_DumpXml_Dtk_Picture
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Picture(FILE *F, Dtk_picture *inPicture)
Definition: util_xml_dtk.cpp:3627
Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr(FILE *F, const Dtk_ToleranceSpecificationContainerPtr &D)
Definition: util_xml_dtk.cpp:2524
DTK_TYPE_CLOUD_BODY
@ DTK_TYPE_CLOUD_BODY
Definition: define.h:603
Dtk_Welding::SymbolPlugWeld
@ SymbolPlugWeld
Definition: util_draw_dtk.hpp:2823
DTK_TYPE_ASSOCIATIVE_ANGULAR_DIMENSION
@ DTK_TYPE_ASSOCIATIVE_ANGULAR_DIMENSION
Definition: define.h:418
Dtk_Constraint::ConstraintOrientationTypeEnum
ConstraintOrientationTypeEnum
Definition: util_ent_dtk.hpp:1165
Dtk_RenderInfos::GetShaderType
RenderMappingShaderTypeEnum GetShaderType() const
Returns shader type.
DTK_TYPE_QUASI_UNIFORM_SURFACE
@ DTK_TYPE_QUASI_UNIFORM_SURFACE
Definition: define.h:101
Dtk_OneCell::GetBorderTopBlanked
Dtk_Int32 GetBorderTopBlanked() const
Gets BorderTopBlanked of Top border.
Dtk_HatchingStyle_Hatching
@ Dtk_HatchingStyle_Hatching
Definition: util_draw_dtk.hpp:7138
PsReaderModule
@ PsReaderModule
Definition: dtk_maindoc.hpp:41
Dtk_SmartPtr::IsNotNULL
Dtk_bool IsNotNULL() const
Definition: util_ptr_dtk.hpp:119
DTK_TYPE_SELECTION_SET
@ DTK_TYPE_SELECTION_SET
Definition: define.h:555
Dtk_NodeConnector::GetColorId
Dtk_Int32 GetColorId() const
Retrieves the Color Id for ForceColor connectors.
Dtk_KinJoint::getParameter1
double getParameter1()
Returns the first parameter.
Dtk_DumpXml_Dtk_FacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FacePtr(FILE *F, const Dtk_FacePtr &inFace)
Definition: util_xml_dtk.cpp:6621
Dtk_Node::FullType::PrimaryType
NodeDataTypeEnum PrimaryType() const
Definition: dtk_maindoc.hpp:285
Dtk_feat_hole::IsStartActived
Dtk_Int32 IsStartActived() const
test if start chamfer is activated
Definition: str_feat_dtk.hpp:1927
Dtk_feat::IsActive
Dtk_bool IsActive() const
Definition: str_feat_dtk.hpp:7081
Dtk_Dimension::ShowDualValueSydeBySide
@ ShowDualValueSydeBySide
Definition: util_draw_dtk.hpp:4569
Dtk_NodeConnector::ForceColor
@ ForceColor
Definition: dtk_maindoc.hpp:1104
DTK_FDT_MODIFIER_NONE
@ DTK_FDT_MODIFIER_NONE
Definition: util_draw_dtk.hpp:61
Dtk_TextStyle::AttributeStrikethrough
@ AttributeStrikethrough
Definition: util_draw_dtk.hpp:271
DTK_TYPE_ASSOCIATIVE_DIAMETER_DIMENSION
@ DTK_TYPE_ASSOCIATIVE_DIAMETER_DIMENSION
Definition: define.h:420
DTK_TYPE_PERSON_AND_ORGANIZATION_ROLE
@ DTK_TYPE_PERSON_AND_ORGANIZATION_ROLE
Definition: define.h:308
Dtk_Roughness::ModePerpendicular
@ ModePerpendicular
Definition: util_draw_dtk.hpp:2465
DTK_TYPE_MODEL_DISPLAY
@ DTK_TYPE_MODEL_DISPLAY
Definition: define.h:476
Dtk_picture::PixelWidth
Dtk_Size_t & PixelWidth()
Retrieves the width (in pixels)
Definition: dtk_picture.hpp:85
DTK_FRAME_TYPE_OBLONG
@ DTK_FRAME_TYPE_OBLONG
Definition: util_draw_dtk.hpp:147
DTK_TYPE_ACTION_EXECUTION
@ DTK_TYPE_ACTION_EXECUTION
Definition: define.h:246
Dtk_feat_hole::HasDiameterTolerance
Dtk_bool HasDiameterTolerance() const
Definition: str_feat_dtk.hpp:1753
Dtk_KinJoint::_LOCAL_FRAME3
Dtk_string _LOCAL_FRAME3
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:958
DTK_TYPE_FACE_OUTER_BOUND
@ DTK_TYPE_FACE_OUTER_BOUND
Definition: define.h:127
DTK_TYPE_EDGE_ENTITY
@ DTK_TYPE_EDGE_ENTITY
Definition: define.h:150
Dtk_DatumTarget::DatumTargetValueEnum
DatumTargetValueEnum
Definition: util_draw_dtk.hpp:3594
DTK_TYPE_DATED_EFFECTIVITY
@ DTK_TYPE_DATED_EFFECTIVITY
Definition: define.h:181
DTK_PICTURE_WMF
@ DTK_PICTURE_WMF
Definition: dtk_picture.hpp:34
Dtk_ToleranceSpecificationContainer::TypeAxisIntersection
@ TypeAxisIntersection
Definition: util_draw_dtk.hpp:5729
DTK_TYPE_VERTEX
@ DTK_TYPE_VERTEX
Definition: define.h:116
Dtk_LayerInfosSet::Layer
Definition: util_ent_dtk.hpp:512
DTK_TYPE_TWO_DIRECTION_REPEAT_FACTOR
@ DTK_TYPE_TWO_DIRECTION_REPEAT_FACTOR
Definition: define.h:345
DTK_TYPE_CONFIGURATION_DESIGN
@ DTK_TYPE_CONFIGURATION_DESIGN
Definition: define.h:216
Dtk_feat_hole::IsNeckActived
Dtk_Int32 IsNeckActived() const
test if neck is activated , only neck or relief can be activated not both
Definition: str_feat_dtk.hpp:1965
Dtk_feat_thread::GetSupportDepth
Dtk_Double64 GetSupportDepth() const
Definition: str_feat_dtk.hpp:1516
Dtk_feat_inner_thread::GetDiameter
Dtk_Double64 GetDiameter() const
Definition: str_feat_dtk.hpp:1297
DTK_TYPE_PLACEMENT
@ DTK_TYPE_PLACEMENT
Definition: define.h:29
Dtk_KinJoint::_CONSTRAINT
Dtk_string _CONSTRAINT
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:925
Dtk_KinFixPart::getName
Dtk_string getName()
Returns the fix part name.
DTK_TYPE_CENTER_POINT
@ DTK_TYPE_CENTER_POINT
Definition: define.h:563
DTK_TYPE_CC_DESIGN_SECURITY_CLASSIFICATION
@ DTK_TYPE_CC_DESIGN_SECURITY_CLASSIFICATION
Definition: define.h:327
Dtk_KinJoint::_PARAMETER1
Dtk_string _PARAMETER1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:928
DTK_TYPE_FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE
@ DTK_TYPE_FILL_AREA_STYLE_TILE_SYMBOL_WITH_STYLE
Definition: define.h:366
DTK_TYPE_COMPOSITE_CURVE_SEGMENT
@ DTK_TYPE_COMPOSITE_CURVE_SEGMENT
Definition: define.h:75
Dtk_DumpXml_Dtk_ComponentPtr_Init
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_Init(FILE *F, const Dtk_ComponentPtr &inObject)
Definition: util_xml_dtk.cpp:4929
Dtk_CompositeText::GetInnerBoundingBox
const Dtk_Oriented2dBBox GetInnerBoundingBox() const
Processes the inner bounding box.
Dtk_Info::GetCurveThickNessInMM
Dtk_Double64 GetCurveThickNessInMM() const
Retrieves the curve thickness - if exists and relevant -.
DTK_TYPE_CARTESIAN_POINT
@ DTK_TYPE_CARTESIAN_POINT
Definition: define.h:38
Dtk_OneCell::GetBorderTopColor
const Dtk_RGB & GetBorderTopColor() const
Gets BorderTopColor of Top border.
DTK_FRAME_TYPE_OBLONG_RIGHT
@ DTK_FRAME_TYPE_OBLONG_RIGHT
Definition: util_draw_dtk.hpp:149
Dtk_PhysicalMaterialInfos::GetShearModulus
Dtk_ErrorStatus GetShearModulus(Dtk_Double64 outShearModulus[3], Dtk_string &outUnits) const
Returns the material shear modulus.
Dtk_KinCommand
Dtk_KinCommand represents a command to simulate a mechanism.
Definition: util_kinematics_dtk.hpp:1340
DTK_TYPE_SUPPLIED_PART_RELATIONSHIP
@ DTK_TYPE_SUPPLIED_PART_RELATIONSHIP
Definition: define.h:293
DTK_TYPE_SOLID_REPLICA
@ DTK_TYPE_SOLID_REPLICA
Definition: define.h:168
DTK_Text_subtype::IsTolSign
Dtk_bool IsTolSign() const
Tell if the associated Dtk_text is part of Tolerance Sign group - into Dtk_Dimension -.
DTK_TYPE_SHAPE_DEFINITION
@ DTK_TYPE_SHAPE_DEFINITION
Definition: define.h:289
Dtk_Dimension::RadiusDimension
@ RadiusDimension
Definition: util_draw_dtk.hpp:4545
Dtk_DumpXml_Dtk_VertexPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_VertexPtr(FILE *F, const Dtk_VertexPtr &inVertex)
Definition: util_xml_dtk.cpp:6517
Dtk_RGB::IndexReader
int & IndexReader()
Definition: dtk_rgb.hpp:48
DTK_TYPE_WIREFRAME_MODEL
@ DTK_TYPE_WIREFRAME_MODEL
Definition: define.h:146
DTK_TYPE_BEZIER_SURFACE
@ DTK_TYPE_BEZIER_SURFACE
Definition: define.h:102
Dtk_KinParameter::getRange
double getRange(int inPosition)
Get the range value at position inPosition.
Dtk_KinFixPart::getConstraint
Dtk_KinConstraintPtr getConstraint()
Returns the constraint associated to the fixed part.
DTK_TYPE_ENTITY
@ DTK_TYPE_ENTITY
Definition: define.h:457
Dtk_DumpXml_Dtk_Light
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Light(FILE *F, const Dtk_LightMapPtr &inLight)
Definition: util_xml_dtk.cpp:3650
CerecReaderModule
@ CerecReaderModule
Definition: dtk_maindoc.hpp:50
DTK_TYPE_POINT_REPLICA
@ DTK_TYPE_POINT_REPLICA
Definition: define.h:43
Dtk_DumpXml_Dtk_KinematicsParameter
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsParameter(FILE *inFile, const Dtk_KinParameterPtr &inParameter, Dtk_bool simplified)
Definition: util_xml_dtk.cpp:7193
Dtk_DumpXml_ComponentTypeEnum
void Dtk_DumpXml_ComponentTypeEnum(FILE *F, const Dtk_Component::ComponentTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:681
DTK_TYPE_SKETCH
@ DTK_TYPE_SKETCH
Definition: define.h:564
Dtk_Roughness::ApplyToBasicSurface
@ ApplyToBasicSurface
Definition: util_draw_dtk.hpp:2445
Dtk_KinParameter::getId
int getId()
Retrun the parameter id.
Dtk_Oriented2dBBox::BottomLeftPoint
Dtk_pnt BottomLeftPoint() const
Retrieves the bottom left point - Read Only -.
Definition: util_draw_dtk.hpp:491
Dtk_ToleranceSpecificationContainer::TypeFlatness
@ TypeFlatness
Definition: util_draw_dtk.hpp:5703
Dtk_Roughness::ModeMultiDirectional
@ ModeMultiDirectional
Definition: util_draw_dtk.hpp:2453
Dtk_Frame::GetFrameType
const Dtk_frame_type & GetFrameType() const
Retrieves the Frame Type - Read Only -.
Definition: util_draw_dtk.hpp:898
DTK_FRAME_TYPE_FLAG_RIGHT
@ DTK_FRAME_TYPE_FLAG_RIGHT
Definition: util_draw_dtk.hpp:141
Dtk_feat_hole::dimension_tolerance
char * dimension_tolerance
Definition: str_feat_dtk.hpp:1618
DTK_TYPE_LIGHT
@ DTK_TYPE_LIGHT
Definition: define.h:560
DTK_TYPE_VERTEX_SHELL
@ DTK_TYPE_VERTEX_SHELL
Definition: define.h:133
DTK_TYPE_DIAMETER_DIMENSION
@ DTK_TYPE_DIAMETER_DIMENSION
Definition: define.h:384
DTK_TYPE_POLYLINE
@ DTK_TYPE_POLYLINE
Definition: define.h:47
Dtk_DumpXml_Dtk_EllipsePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EllipsePtr(FILE *F, const Dtk_EllipsePtr &inCurve)
Definition: util_xml_dtk.cpp:5325
DTK_CENTERLINE
@ DTK_CENTERLINE
Definition: util_ent_dtk.hpp:55
DTK_TRUE
#define DTK_TRUE
Definition: define.h:726
Dtk_Welding::SymbolStakeWeld
@ SymbolStakeWeld
Definition: util_draw_dtk.hpp:2863
Dtk_OneCell::getnbCells_Top_Bottom
Dtk_Int32 getnbCells_Top_Bottom() const
Gets the number of cells at the bottom or left of the Dtk_OneCell.
DTK_TYPE_REGION
@ DTK_TYPE_REGION
Definition: define.h:550
Dtk_Node::NodeDataTypeEnum
NodeDataTypeEnum
Definition: dtk_maindoc.hpp:250
DTK_VAL_TYPE_CHAR
@ DTK_VAL_TYPE_CHAR
Definition: dtk_val.hpp:21
PrcReaderModule
@ PrcReaderModule
Definition: dtk_maindoc.hpp:74
DTK_TYPE_BOX_DOMAIN
@ DTK_TYPE_BOX_DOMAIN
Definition: define.h:413
DTK_TYPE_SHAPE_ASPECT_RELATIONSHIP
@ DTK_TYPE_SHAPE_ASPECT_RELATIONSHIP
Definition: define.h:288
Dtk_DumpXml_Dtk_CoedgePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CoedgePtr(FILE *F, const Dtk_CoedgePtr &inCoedge)
Definition: util_xml_dtk.cpp:6574
IND_DIAMETER
#define IND_DIAMETER
Definition: str_feat_dtk.hpp:27
DTK_TYPE_FILL_AREA_STYLE_HATCHING
@ DTK_TYPE_FILL_AREA_STYLE_HATCHING
Definition: define.h:365
Dtk_Welding::ComplementarySymbolWeldWithConcaveFace
@ ComplementarySymbolWeldWithConcaveFace
Definition: util_draw_dtk.hpp:2914
Dtk_DumpXml_Dtk_ViewDisplayDisplayMode3DEnum
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewDisplayDisplayMode3DEnum(FILE *F, const Dtk_ViewDisplay::DisplayMode3DEnum &inVal)
Definition: util_xml_dtk.cpp:2886
V5ReaderModule
@ V5ReaderModule
Definition: dtk_maindoc.hpp:31
Dtk_KinJoint::_UPPER_LIMIT1
Dtk_string _UPPER_LIMIT1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:943
DTK_TYPE_RATIONAL_B_SPLINE_SURFACE_WITH_KNOTS
@ DTK_TYPE_RATIONAL_B_SPLINE_SURFACE_WITH_KNOTS
Definition: define.h:104
Dtk_Welding::FinishSymbolRoll
@ FinishSymbolRoll
Definition: util_draw_dtk.hpp:2964
DTK_TYPE_ORDINATE_DIMENSION
@ DTK_TYPE_ORDINATE_DIMENSION
Definition: define.h:387
DTK_Text_subtype::IsSeparator
Dtk_bool IsSeparator() const
Tell if the associated Dtk_text is a separator - into Dtk_Dimension -.
Dtk_feat::GetFinalAssociatedGeometry
Dtk_feat_geometry * GetFinalAssociatedGeometry() const
Definition: str_feat_dtk.hpp:7070
DTK_TYPE_ADVANCED_BREP_SHAPE_REPRESENTATION
@ DTK_TYPE_ADVANCED_BREP_SHAPE_REPRESENTATION
Definition: define.h:284
DTK_TYPE_SHAPE_REPRESENTATION
@ DTK_TYPE_SHAPE_REPRESENTATION
Definition: define.h:282
DTK_TYPE_START_WORK
@ DTK_TYPE_START_WORK
Definition: define.h:256
DTK_PICTURE_GIF
@ DTK_PICTURE_GIF
Definition: dtk_picture.hpp:28
DTK_TYPE_SELECTION_DATA_SET
@ DTK_TYPE_SELECTION_DATA_SET
Definition: define.h:446
Dtk_Constraint::_ConstraintValue::_ValueUpper
Dtk_Double64 _ValueUpper
Definition: util_ent_dtk.hpp:1222
Dtk_KinFixPart::getId
int getId()
Retrun the fix part id.
Dtk_DumpXml_Dtk_SphericalSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SphericalSurfacePtr(FILE *F, const Dtk_SphericalSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6232
Dtk_feat_pattern::object_type
DTK_OBJECT_TYPE object_type
Definition: str_feat_dtk.hpp:3300
DTK_TYPE_SPHERICAL_SURFACE
@ DTK_TYPE_SPHERICAL_SURFACE
Definition: define.h:86
DTK_TYPE_CHANGE
@ DTK_TYPE_CHANGE
Definition: define.h:251
DTK_TYPE_FONT_SELECT
@ DTK_TYPE_FONT_SELECT
Definition: define.h:393
DTK_TYPE_MASS_MEASURE
@ DTK_TYPE_MASS_MEASURE
Definition: define.h:193
DTK_TYPE_CARTESIAN_POINT_WITH_INFOS
@ DTK_TYPE_CARTESIAN_POINT_WITH_INFOS
Definition: define.h:45
Dtk_Region::RectangularType
@ RectangularType
Definition: util_draw_dtk.hpp:7456
Dtk_Welding::SymbolFlangeEdge
@ SymbolFlangeEdge
Definition: util_draw_dtk.hpp:2833
DTK_TYPE_RIGHT_CIRCULAR_CYLINDER
@ DTK_TYPE_RIGHT_CIRCULAR_CYLINDER
Definition: define.h:405
DTK_TYPE_PRODUCT_DEFINITION_RELATIONSHIP
@ DTK_TYPE_PRODUCT_DEFINITION_RELATIONSHIP
Definition: define.h:263
dtkErrorUnspecified
@ dtkErrorUnspecified
Definition: error_dtk.hpp:17
Dtk_feat_hole::GetReliefDepth
Dtk_Double64 GetReliefDepth() const
return the depth of the relief
Definition: str_feat_dtk.hpp:1959
DTK_TYPE_CURVE_DIMENSION
@ DTK_TYPE_CURVE_DIMENSION
Definition: define.h:383
Dtk_Roughness::ObtentionTypeMachiningForbidden
@ ObtentionTypeMachiningForbidden
Definition: util_draw_dtk.hpp:2436
DTK_TYPE_CONTRACT
@ DTK_TYPE_CONTRACT
Definition: define.h:258
DTK_Text_subtype::IsTolBloc
Dtk_bool IsTolBloc() const
Tell if the associated Dtk_text is part of Tolerance Block group - into Dtk_Dimension -.
Dtk_LayerInfosSet::Layer::Status::Selectable
@ Selectable
DTK_TYPE_DATE_TIME_ROLE
@ DTK_TYPE_DATE_TIME_ROLE
Definition: define.h:175
dtk_text_type_tolerance
@ dtk_text_type_tolerance
Definition: str_def.h:18
DTK_TYPE_REFERENCE
@ DTK_TYPE_REFERENCE
Definition: define.h:464
SatReaderModule
@ SatReaderModule
Definition: dtk_maindoc.hpp:43
Dtk_PhysicalMaterialInfos::GetSpecificHeat
Dtk_ErrorStatus GetSpecificHeat(Dtk_Double64 &outValue, Dtk_string &outUnits) const
Returns the material specific heat.
Dtk_DumpXml_Dtk_StandardRevolutionSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_StandardRevolutionSurfacePtr(FILE *F, const Dtk_StandardRevolutionSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6289
dtk_text_type_value
@ dtk_text_type_value
Definition: str_def.h:14
Dtk_DumpXml_Dtk_LoopPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LoopPtr(FILE *F, const Dtk_LoopPtr &inLoop)
Definition: util_xml_dtk.cpp:6598
Dtk_DumpXml_Dtk_CameraPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraPtr(FILE *F, const Dtk_CameraPtr &inVal)
Definition: util_xml_dtk.cpp:3138
DTK_TYPE_APPLICATION_CONTEXT
@ DTK_TYPE_APPLICATION_CONTEXT
Definition: define.h:213
DTK_TYPE_CAMERA
@ DTK_TYPE_CAMERA
Definition: define.h:469
DTK_TYPE_KINEMATIC
@ DTK_TYPE_KINEMATIC
Definition: define.h:535
COUNTER_DRILLED
@ COUNTER_DRILLED
Definition: str_feat_dtk.hpp:110
Dtk_feat_inner_thread::GetDepth
Dtk_Double64 GetDepth() const
Definition: str_feat_dtk.hpp:1330
DTK_TYPE_SKIP
@ DTK_TYPE_SKIP
Definition: define.h:24
Dtk_DumpXml_Dtk_Oriented2dBBox
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Oriented2dBBox(FILE *F, const Dtk_Oriented2dBBox &BBox, const Dtk_string &inLabel=L"")
Definition: util_xml_dtk.cpp:915
DTK_Text_subtype::IsUpperFrac
Dtk_bool IsUpperFrac() const
Tell if the associated Dtk_text is part of Upper Fraction group - into Dtk_Dimension -.
DTK_PICTURE_EMF
@ DTK_PICTURE_EMF
Definition: dtk_picture.hpp:35
Zw3dReaderModule
@ Zw3dReaderModule
Definition: dtk_maindoc.hpp:81
Dtk_KinJoint::_RATIO
Dtk_string _RATIO
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:970
DTK_TYPE_CURVE_BOUNDED_SURFACE
@ DTK_TYPE_CURVE_BOUNDED_SURFACE
Definition: define.h:96
Dtk_Welding::SymbolSquareButtWeld
@ SymbolSquareButtWeld
Definition: util_draw_dtk.hpp:2799
Dtk_DumpXml_Dtk_PointPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PointPtr(FILE *F, const Dtk_PointPtr &inPoint)
Definition: util_xml_dtk.cpp:6501
Dtk_UInt32
uint32_t Dtk_UInt32
Definition: define.h:687
Dtk_Welding::FinishSymbolFlush
@ FinishSymbolFlush
Definition: util_draw_dtk.hpp:2956
DTK_Text_subtype::IsDual
Dtk_bool IsDual() const
Tell if the associated Dtk_text is part of dual group - into Dtk_Dimension -.
DTK_TYPE_FACE_BOUND
@ DTK_TYPE_FACE_BOUND
Definition: define.h:126
Dtk_RenderInfos::GetTexture
Dtk_TextureInfosPtr GetTexture() const
Returns the render texture.
DTK_TYPE_TEXTURE
@ DTK_TYPE_TEXTURE
Definition: define.h:559
DTK_TYPE_FACE_BASED_SURFACE_MODEL
@ DTK_TYPE_FACE_BASED_SURFACE_MODEL
Definition: define.h:143
Dtk_string
This is a high level string class.
Definition: dtk_string.hpp:53
DTK_TYPE_CONVERSION_BASED_UNIT
@ DTK_TYPE_CONVERSION_BASED_UNIT
Definition: define.h:203
DTK_TYPE_BLEND_BOUND
@ DTK_TYPE_BLEND_BOUND
Definition: define.h:558
Dtk_ModelDisplay::rendering_mode_shaded_with_visible_edges
@ rendering_mode_shaded_with_visible_edges
Definition: util_ent_dtk.hpp:983
Dtk_mesh_face::get_triangle_fan_indices
const Dtk_tab< Dtk_UInt32 > * get_triangle_fan_indices(Dtk_Size_t inI) const
Get inI-th triangle fan.
DTK_TYPE_MEASURE
@ DTK_TYPE_MEASURE
Definition: define.h:526
Dtk_API::GetPhysicalMaterialInfosInTable
Dtk_PhysicalMaterialInfosPtr GetPhysicalMaterialInfosInTable(Dtk_ID inId) const
Dtk_DumpXml_Dtk_MeshSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshSurfacePtr(FILE *F, const Dtk_MeshSurfacePtr &inMeshSurface)
Definition: util_xml_dtk.cpp:6388
Dtk_ModelDisplay::rendering_mode_wireframe_with_all_edges
@ rendering_mode_wireframe_with_all_edges
Definition: util_ent_dtk.hpp:984
Dtk_KinParameter::_RANGE
Dtk_string _RANGE
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:329
DTK_TYPE_PROPERTY
@ DTK_TYPE_PROPERTY
Definition: define.h:510
Dtk_feat_inner_thread::GetDefinitionValue
Dtk_string GetDefinitionValue() const
Definition: str_feat_dtk.hpp:1410
DTK_ANCHOR_BOTTOM_LEFT
@ DTK_ANCHOR_BOTTOM_LEFT
Definition: util_draw_dtk.hpp:99
Dtk_DumpXml_Dtk_HatchingStyleEnum
void Dtk_DumpXml_Dtk_HatchingStyleEnum(FILE *F, const Dtk_HatchingStyle &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:2161
Dtk_mesh_face::get_id
int get_id() const
Return the face Id.
Dtk_DumpXml_Dtk_KinematicsLaw
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsLaw(FILE *inFile, const Dtk_KinLawPtr &inLaw)
Definition: util_xml_dtk.cpp:7444
Dtk_DumpXml_Dtk_MainDocPtr_End
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr_End(FILE *F, const Dtk_MainDocPtr &inObject)
Definition: util_xml_dtk.cpp:4592
Dtk_DumpXml_Dtk_anchor_type
Dtk_ErrorStatus Dtk_DumpXml_Dtk_anchor_type(FILE *F, const Dtk_anchor_type &D)
Definition: util_xml_dtk.cpp:1180
Dtk_KinJoint::_CONNECTOR
Dtk_string _CONNECTOR
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:976
Dtk_feat_limit::UP_TO_SURFACE
@ UP_TO_SURFACE
Definition: str_feat_dtk.hpp:625
Dtk_Size_t
size_t Dtk_Size_t
Definition: define.h:711
Dtk_Info::GetColor
Dtk_RGB GetColor() const
Retrieves the entity color as Dtk_RGBA values.
Dtk_NodeConnector::SubEntity
Definition: dtk_maindoc.hpp:1227
DTK_TYPE_ACTION
@ DTK_TYPE_ACTION
Definition: define.h:245
DTK_TYPE_APPROVAL_DATE_TIME
@ DTK_TYPE_APPROVAL_DATE_TIME
Definition: define.h:180
Dtk_DumpXml_Dtk_LineTypeDefinitionPtr
void Dtk_DumpXml_Dtk_LineTypeDefinitionPtr(FILE *F, const Dtk_LineTypeDefinitionPtr &inLineTypeDefinition)
Definition: util_xml_dtk.cpp:4025
Dtk_DumpXml_Dtk_EdgePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EdgePtr(FILE *F, const Dtk_EdgePtr &inEdge)
Definition: util_xml_dtk.cpp:6540
DTK_TYPE_COMPOSITE_ENTITY
@ DTK_TYPE_COMPOSITE_ENTITY
Definition: define.h:441
DTK_ANCHOR_TOP_CENTER
@ DTK_ANCHOR_TOP_CENTER
Definition: util_draw_dtk.hpp:94
Dtk_ToleranceSpecificationContainer::TypeStraightness
@ TypeStraightness
Definition: util_draw_dtk.hpp:5701
Dtk_feat_limit::UP_TO_LAST
@ UP_TO_LAST
Definition: str_feat_dtk.hpp:623
DTK_TYPE_CC_DESIGN_CERTIFICATION
@ DTK_TYPE_CC_DESIGN_CERTIFICATION
Definition: define.h:324
DTK_TYPE_PRODUCT_VERSION
@ DTK_TYPE_PRODUCT_VERSION
Definition: define.h:222
XmlReaderModule
@ XmlReaderModule
Definition: dtk_maindoc.hpp:53
DTK_VAL_TYPE_PNT
@ DTK_VAL_TYPE_PNT
Definition: dtk_val.hpp:25
DTK_TYPE_AXIS_SYSTEM
@ DTK_TYPE_AXIS_SYSTEM
Definition: define.h:34
Dtk_Node::FullType::SubType
type_detk SubType() const
Definition: dtk_maindoc.hpp:286
DTK_TYPE_CONNECTR_ECP
@ DTK_TYPE_CONNECTR_ECP
Definition: define.h:554
Dtk_string::convert_from_int
void convert_from_int(const int integer, int force_unsigned_int=0)
affectation operator from a int
DTK_TYPE_COLOUR_SPECIFICATION
@ DTK_TYPE_COLOUR_SPECIFICATION
Definition: define.h:353
DTK_TYPE_CERTIFICATION
@ DTK_TYPE_CERTIFICATION
Definition: define.h:257
Dtk_Constraint::ConstraintValueTypeEnumToString
static Dtk_string ConstraintValueTypeEnumToString(const ConstraintValueTypeEnum &inEnum)
Definition: util_ent_dtk.hpp:1194
Dtk_Text::GetInfo
const Dtk_InfoPtr & GetInfo() const
Retrieves the text infos - read only -.
Dtk_mesh_face::get_polyline_indices
const Dtk_tab< Dtk_UInt32 > * get_polyline_indices(Dtk_Size_t inI) const
Get inI-th polygon.
Dtk_KinJoint::getConnectorSize
Dtk_Size_t getConnectorSize()
Return the attribute tab size.
DTK_WP
#define DTK_WP
Definition: dtk_string.hpp:39
DTK_TYPE_PREVIEW
@ DTK_TYPE_PREVIEW
Definition: define.h:496
Dtk_DumpXml_Dtk_val
Dtk_ErrorStatus Dtk_DumpXml_Dtk_val(FILE *F, const Dtk_Val &V)
Definition: util_xml_dtk.cpp:3555
DTK_TYPE_SWEPT_SURFACE
@ DTK_TYPE_SWEPT_SURFACE
Definition: define.h:88
Dtk_KinJoint::_JOINT2
Dtk_string _JOINT2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:967
DTK_TYPE_SHELL_BASED_SURFACE_MODEL
@ DTK_TYPE_SHELL_BASED_SURFACE_MODEL
Definition: define.h:142
DTK_TYPE_TOL_SPEC_CONT
@ DTK_TYPE_TOL_SPEC_CONT
Definition: define.h:491
Dtk_feat_hole::GetSupport
Dtk_feat_geometry * GetSupport() const
Definition: str_feat_dtk.hpp:1702
Dtk_Region::AnnularType
@ AnnularType
Definition: util_draw_dtk.hpp:7458
Dtk_DumpXml_Dtk_CompositeText
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CompositeText(FILE *F, const Dtk_CompositeText &T)
Definition: util_xml_dtk.cpp:1245
Dtk_feat_hole::HasDepthTolerance
Dtk_bool HasDepthTolerance() const
Definition: str_feat_dtk.hpp:1784
Dtk_DumpXml_Dtk_welding_complementary_symbol
Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_complementary_symbol(FILE *F, const Dtk_Welding::ComplementarySymbolEnum &D)
Definition: util_xml_dtk.cpp:1731
Dtk_UUID
Definition: dtk_uuid.hpp:8
DTK_VAL_TYPE_UUID
@ DTK_VAL_TYPE_UUID
Definition: dtk_val.hpp:27
Dtk_Val::GetIntArray
Dtk_tab< Dtk_Int32 > GetIntArray(Dtk_status &st=Dtk_status::GetDefaultStatus()) const
DTK_TYPE_DIMENSION_CURVE_DIRECTED_CALLOUT
@ DTK_TYPE_DIMENSION_CURVE_DIRECTED_CALLOUT
Definition: define.h:389
DTK_TYPE_ACTION_METHOD
@ DTK_TYPE_ACTION_METHOD
Definition: define.h:244
DTK_ANCHOR_BOTTOM_CENTER
@ DTK_ANCHOR_BOTTOM_CENTER
Definition: util_draw_dtk.hpp:100
DTK_TYPE_LENGTH_UNIT
@ DTK_TYPE_LENGTH_UNIT
Definition: define.h:207
DTK_Text_subtype::IsPow
Dtk_bool IsPow() const
Tell if the associated Dtk_text is part of Pow group - into Dtk_Dimension -.
DTK_TYPE_GEOMETRIC_SET_SELECT_ENTITY
@ DTK_TYPE_GEOMETRIC_SET_SELECT_ENTITY
Definition: define.h:115
DTK_TYPE_REFERENCE_POINT
@ DTK_TYPE_REFERENCE_POINT
Definition: define.h:596
DTK_TYPE_SWEPT_AREA_SOLID
@ DTK_TYPE_SWEPT_AREA_SOLID
Definition: define.h:410
DTK_TYPE_COMPOSITE_CURVE
@ DTK_TYPE_COMPOSITE_CURVE
Definition: define.h:71
Dtk_DumpXml_Dtk_RoughnessPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RoughnessPtr(FILE *F, const Dtk_RoughnessPtr &D)
Definition: util_xml_dtk.cpp:1573
DTK_TYPE_ASSOCIATIVE_ORDINATE_DIMENSION
@ DTK_TYPE_ASSOCIATIVE_ORDINATE_DIMENSION
Definition: define.h:423
DTK_TYPE_ORGANIZATION
@ DTK_TYPE_ORGANIZATION
Definition: define.h:307
Dtk_feat_inner_thread::thread_limit_type
DTK_THREAD_LIMIT_TYPE thread_limit_type
Definition: str_feat_dtk.hpp:1263
Dtk_Dimension::BasicDimensionTypeEnum
BasicDimensionTypeEnum
Definition: util_draw_dtk.hpp:4557
UnknownModule
@ UnknownModule
Definition: dtk_maindoc.hpp:84
DTK_TYPE_FDT_DATA_SET
@ DTK_TYPE_FDT_DATA_SET
Definition: define.h:448
DTK_TYPE_OBJECT
@ DTK_TYPE_OBJECT
Definition: define.h:455
DTK_TYPE_LOT_EFFECTIVITY
@ DTK_TYPE_LOT_EFFECTIVITY
Definition: define.h:238
DTK_TYPE_DATE_TIME_ITEM
@ DTK_TYPE_DATE_TIME_ITEM
Definition: define.h:182
Dtk_DumpXml_Dtk_FontLineTypeEnum
void Dtk_DumpXml_Dtk_FontLineTypeEnum(FILE *F, const Dtk_FontLineType &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:2348
Dtk_feat_inner_thread::GetTypeAsString
Dtk_string GetTypeAsString() const
Dtk_Fdt::Default
@ Default
The annotation display isn't bound to the viewport.
Definition: util_draw_dtk.hpp:6806
Dtk_Roughness::ModeParticular
@ ModeParticular
Definition: util_draw_dtk.hpp:2459
Dtk_picture::ScaleX
double & ScaleX()
Retrieves the X scale factor.
Definition: dtk_picture.hpp:108
Dtk_Welding::SymbolRemovableBackingStripUsed
@ SymbolRemovableBackingStripUsed
Definition: util_draw_dtk.hpp:2825
Dtk_status
Definition: dtk_status.hpp:16
Dtk_KinJoint::getRatioParameter
Dtk_KinParameterPtr getRatioParameter()
Returns the Dtk_KinParameter ratio of the joint.
DTK_TYPE_KIN_COMMAND
@ DTK_TYPE_KIN_COMMAND
Definition: define.h:540
DTK_TYPE_EDGE_BASED_WIREFRAME_MODEL
@ DTK_TYPE_EDGE_BASED_WIREFRAME_MODEL
Definition: define.h:121
DTK_TYPE_PNT
@ DTK_TYPE_PNT
Definition: define.h:44
DTK_BREAKLINE
@ DTK_BREAKLINE
Definition: util_ent_dtk.hpp:63
Dtk_KinJoint::getUpperLimit1
double getUpperLimit1()
Returns the upper limit 1.
Dtk_NodeConnector::GetPointingEntityType
Dtk_Node::FullType GetPointingEntityType() const
Retrieves the pointing entity FullType. Should be the FullType of the Dtk_Node containing the Dtk_Nod...
DTK_TYPE_PROJECTION_DIRECTED_CALLOUT
@ DTK_TYPE_PROJECTION_DIRECTED_CALLOUT
Definition: define.h:388
DTK_TYPE_LINEAR_DIMENSION
@ DTK_TYPE_LINEAR_DIMENSION
Definition: define.h:385
Dtk_Welding::SymbolFlareBevelWeld
@ SymbolFlareBevelWeld
Definition: util_draw_dtk.hpp:2841
DTK_TYPE_RECTANGULAR_TRIMMED_SURFACE
@ DTK_TYPE_RECTANGULAR_TRIMMED_SURFACE
Definition: define.h:95
DTK_TYPE_POSITIVE_PLANE_ANGLE_MEASURE
@ DTK_TYPE_POSITIVE_PLANE_ANGLE_MEASURE
Definition: define.h:202
Dtk_MetaData::MetaDataTypeEnumToString
static Dtk_string MetaDataTypeEnumToString(const MetaDataTypeEnum &inEnum)
Definition: dtk_metadata.hpp:40
Dtk_DumpXml_Dtk_OLEObjectPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OLEObjectPtr(FILE *F, const Dtk_OLEObjectPtr &O)
Definition: util_xml_dtk.cpp:8677
Dtk_Leader::ApplicationZone::ApplicationZoneEnumToString
static Dtk_string ApplicationZoneEnumToString(const ApplicationZoneEnum &inEnum)
Definition: util_draw_dtk.hpp:1741
Dtk_OneCell::GetBorderBottomColor
const Dtk_RGB & GetBorderBottomColor() const
Gets BorderBottomColor of Bottom border.
DTK_TYPE_PARABOLA
@ DTK_TYPE_PARABOLA
Definition: define.h:52
Dtk_Welding::SymbolNone
@ SymbolNone
Definition: util_draw_dtk.hpp:2797
DTK_TYPE_KIN_SPEEDACCELERATION
@ DTK_TYPE_KIN_SPEEDACCELERATION
Definition: define.h:543
Dtk_KinJoint::getId
int getId()
Retrun the joint id.
DTK_TYPE_SURFACE_REPLICA
@ DTK_TYPE_SURFACE_REPLICA
Definition: define.h:109
dtkWarningNoEntitiesWritten
@ dtkWarningNoEntitiesWritten
Definition: error_dtk.hpp:91
DTK_TYPE_SYMBOL_STYLE
@ DTK_TYPE_SYMBOL_STYLE
Definition: define.h:363
DTK_TYPE_CLOSED_SHELL
@ DTK_TYPE_CLOSED_SHELL
Definition: define.h:137
Dtk_DumpXml_FormatDtk_string
Dtk_string Dtk_DumpXml_FormatDtk_string(const Dtk_string &inString, const XML_StringType inXmlStringType)
Definition: util_xml_dtk.cpp:4472
DTK_TYPE_ANGULAR_DIMENSION
@ DTK_TYPE_ANGULAR_DIMENSION
Definition: define.h:382
DTK_TYPE_ANNOTATION_CURVE_OCCURRENCE
@ DTK_TYPE_ANNOTATION_CURVE_OCCURRENCE
Definition: define.h:378
Dtk_KinJoint::getAbsolutPos1
Dtk_transfo getAbsolutPos1()
Returns the part 1 absolute position.
Dtk_View::NoTypeView
@ NoTypeView
Definition: util_draw_dtk.hpp:6561
DTK_TYPE_SPHERE
@ DTK_TYPE_SPHERE
Definition: define.h:401
F3dReaderModule
@ F3dReaderModule
Definition: dtk_maindoc.hpp:75
DTK_FEAT_PATTERN
@ DTK_FEAT_PATTERN
Definition: str_feat_dtk.hpp:317
DTK_TYPE_ORIENTED_FACE
@ DTK_TYPE_ORIENTED_FACE
Definition: define.h:129
dtk_text_type_reference
@ dtk_text_type_reference
Definition: str_def.h:22
DTK_FALSE
#define DTK_FALSE
Definition: define.h:727
Dtk_DumpXml_Dtk_ParabolaPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ParabolaPtr(FILE *F, const Dtk_ParabolaPtr &inCurve)
Definition: util_xml_dtk.cpp:5303
DTK_TYPE_SOLID_OF_LINEAR_EXTRUSION
@ DTK_TYPE_SOLID_OF_LINEAR_EXTRUSION
Definition: define.h:411
DTK_TYPE_NURBS_CURVE
@ DTK_TYPE_NURBS_CURVE
Definition: define.h:485
DTK_TYPE_EDGE_LOOP
@ DTK_TYPE_EDGE_LOOP
Definition: define.h:123
StlReaderModule
@ StlReaderModule
Definition: dtk_maindoc.hpp:68
DTK_FRAME_TYPE_OBLONG_LEFT
@ DTK_FRAME_TYPE_OBLONG_LEFT
Definition: util_draw_dtk.hpp:151
DTK_TYPE_CERTIFIED_ITEM
@ DTK_TYPE_CERTIFIED_ITEM
Definition: define.h:294
DTK_TYPE_SHELL_BASED_WIREFRAME_SHAPE_REPRESENTATION
@ DTK_TYPE_SHELL_BASED_WIREFRAME_SHAPE_REPRESENTATION
Definition: define.h:283
DTK_TYPE_POINT_ON_CURVE
@ DTK_TYPE_POINT_ON_CURVE
Definition: define.h:39
Dtk_Symbol::TypeEnumToString
static const Dtk_string TypeEnumToString(const TypeEnum &inEnum)
Definition: util_draw_dtk.hpp:6014
DTK_TYPE_SYMBOL
@ DTK_TYPE_SYMBOL
Definition: define.h:400
DTK_TYPE_CONFIGURATION_ITEM
@ DTK_TYPE_CONFIGURATION_ITEM
Definition: define.h:215
Dtk_bool
char Dtk_bool
Definition: define.h:724
ProCeraReaderModule
@ ProCeraReaderModule
Definition: dtk_maindoc.hpp:48
Dtk_Welding::SymbolSteepFlankedSingleBevelButtWeld
@ SymbolSteepFlankedSingleBevelButtWeld
Definition: util_draw_dtk.hpp:2819
DTK_TYPE_SURFACE_OF_LINEAR_EXTRUSION
@ DTK_TYPE_SURFACE_OF_LINEAR_EXTRUSION
Definition: define.h:89
DTK_TYPE_VIEW
@ DTK_TYPE_VIEW
Definition: define.h:435
DTK_TYPE_INFO
@ DTK_TYPE_INFO
Definition: define.h:458
Dtk_DumpXml_Dtk_ViewDisplayPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewDisplayPtr(FILE *F, const Dtk_ViewDisplayPtr &V)
Definition: util_xml_dtk.cpp:2920
Dtk_string::OpenFile
FILE * OpenFile(const Dtk_string &inRights) const
File Utility : Open a file with the given rights.
DTK_TYPE_DATUM_TARGET
@ DTK_TYPE_DATUM_TARGET
Definition: define.h:428
DTK_TYPE_MATERIAL
@ DTK_TYPE_MATERIAL
Definition: define.h:515
Dtk_Val::GetUuid
Dtk_UUID GetUuid(Dtk_status &st=Dtk_status::GetDefaultStatus()) const
Dtk_picture::MetricWidth
double & MetricWidth()
Retrieves the width (in mm)
Definition: dtk_picture.hpp:95
Dtk_TextStyle::Slant
Dtk_Double64 & Slant()
Retrieves the text slant - get/set -.
Dtk_DatumTarget::DatumTargetTypeEnumToString
static Dtk_string DatumTargetTypeEnumToString(const DatumTargetTypeEnum &inEnum)
Definition: util_draw_dtk.hpp:3561
Dtk_TextStyle::Attributes
TextAttributeEnum & Attributes()
Retrieves the text attribute - get/set -.
Dtk_DumpXml_Dtk_PhysicalMaterialInfos
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PhysicalMaterialInfos(FILE *F, const Dtk_PhysicalMaterialInfosPtr &inMaterial)
Definition: util_xml_dtk.cpp:3739
Dtk_feat_pattern::type
DTK_PATTERN_TYPE type
Definition: str_feat_dtk.hpp:3299
AcisReaderModule
@ AcisReaderModule
Definition: dtk_maindoc.hpp:47
DTK_Text_subtype::IsBasisval
Dtk_bool IsBasisval() const
Tell if the associated Dtk_text is part of Basis group - into Dtk_Dimension -.
DTK_TYPE_PRODUCT_CONTEXT
@ DTK_TYPE_PRODUCT_CONTEXT
Definition: define.h:219
Dtk_DumpXml_NodeTypeEnum
void Dtk_DumpXml_NodeTypeEnum(FILE *F, const Dtk_Node::NodeDataTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:690
DTK_VAL_TYPE_INT
@ DTK_VAL_TYPE_INT
Definition: dtk_val.hpp:20
DTK_SOLIDLINE
@ DTK_SOLIDLINE
Definition: util_ent_dtk.hpp:49
Dtk_Symbol::Create
static Dtk_SymbolPtr Create()
Calls default constructor to allocate a new object.
Dtk_ModelDisplay::rendering_mode_wireframe_with_only_visible_edges
@ rendering_mode_wireframe_with_only_visible_edges
Definition: util_ent_dtk.hpp:985
DTK_ANCHOR_MIDDLE_CENTER
@ DTK_ANCHOR_MIDDLE_CENTER
Definition: util_draw_dtk.hpp:97
Dtk_feat_hole::GetStartAngle
Dtk_Double64 GetStartAngle() const
return the angle of the start chamfer
Definition: str_feat_dtk.hpp:1932
Dtk_Constraint::ValueTypeOrientation
@ ValueTypeOrientation
Definition: util_ent_dtk.hpp:1192
Dtk_RenderInfos::RenderMappingShaderTypeEnum
RenderMappingShaderTypeEnum
Definition: dtk_render.hpp:282
Dtk_PhysicalMaterialInfos::GetTensileStrength
Dtk_ErrorStatus GetTensileStrength(Dtk_Double64 &outValue, Dtk_string &outUnits) const
Returns the material tensile strength.
Dtk_mesh_face::get_subinfo
Dtk_InfoPtr & get_subinfo(Dtk_Size_t inI)
Dtk_Welding::FinishSymbolMachine
@ FinishSymbolMachine
Definition: util_draw_dtk.hpp:2962
Dtk_RenderInfos::Unknown
@ Unknown
Definition: dtk_render.hpp:283
Dtk_feat_inner_thread::HasDiameterTolerance
Dtk_bool HasDiameterTolerance() const
Definition: str_feat_dtk.hpp:1319
DTK_TYPE_FDT_ANNOTATION_SET
@ DTK_TYPE_FDT_ANNOTATION_SET
Definition: define.h:438
DTK_TYPE_CONTRACT_ASSIGNMENT
@ DTK_TYPE_CONTRACT_ASSIGNMENT
Definition: define.h:304
DTK_TYPE_SOLID_ARRAY
@ DTK_TYPE_SOLID_ARRAY
Definition: define.h:454
DTK_TYPE_OUTER_BOUNDARY_CURVE
@ DTK_TYPE_OUTER_BOUNDARY_CURVE
Definition: define.h:74
Dtk_Info::GetUuid
Dtk_UUID GetUuid() const
Retrieves the entity UniqueID if any.
Dtk_feat::GetId
int GetId() const
Definition: str_feat_dtk.hpp:7029
DTK_TYPE_MANIFOLD_SOLID_BREP
@ DTK_TYPE_MANIFOLD_SOLID_BREP
Definition: define.h:167
DTK_TYPE_INSTANCE
@ DTK_TYPE_INSTANCE
Definition: define.h:504
DTK_TYPE_VECTOR
@ DTK_TYPE_VECTOR
Definition: define.h:28
DTK_TYPE_MAPPED_ITEM
@ DTK_TYPE_MAPPED_ITEM
Definition: define.h:280
Dtk_Grid::Local
@ Local
Definition: util_draw_dtk.hpp:4326
DTK_TYPE_CHANGE_REQUEST
@ DTK_TYPE_CHANGE_REQUEST
Definition: define.h:252
Dtk_DumpXml_Dtk_NurbsCurvePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NurbsCurvePtr(FILE *F, const Dtk_NurbsCurvePtr &inCurve)
Definition: util_xml_dtk.cpp:5234
DTK_TYPE_ANNOTATION_SYMBOL_OCCURRENCE
@ DTK_TYPE_ANNOTATION_SYMBOL_OCCURRENCE
Definition: define.h:379
DTK_TYPE_TEXT_STYLE_WITH_BOX_CHARACTERISTICS
@ DTK_TYPE_TEXT_STYLE_WITH_BOX_CHARACTERISTICS
Definition: define.h:398
COUNTER_SUNK
@ COUNTER_SUNK
Definition: str_feat_dtk.hpp:109
SwReaderModule
@ SwReaderModule
Definition: dtk_maindoc.hpp:37
DTK_TYPE_START_REQUEST
@ DTK_TYPE_START_REQUEST
Definition: define.h:255
Dtk_DumpXml_DtkReaderType
void Dtk_DumpXml_DtkReaderType(FILE *F, const DtkReaderType &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:799
DTK_Text_subtype::IsChamfersign
Dtk_bool IsChamfersign() const
Tell if the associated Dtk_text is part of Chamfer Sign group - into Dtk_Dimension -.
Dtk_DumpXml_Dtk_NodeConnector
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodeConnector(FILE *inFile, const Dtk_NodeConnectorPtr &inNodeConnector)
Definition: util_xml_dtk.cpp:7012
DTK_TYPE_APPROVAL_ROLE
@ DTK_TYPE_APPROVAL_ROLE
Definition: define.h:315
DTK_TYPE_CONTEXT_DEPENDENT_MEASURE
@ DTK_TYPE_CONTEXT_DEPENDENT_MEASURE
Definition: define.h:199
DTK_Text_subtype::IsMainvalpart
Dtk_bool IsMainvalpart() const
Tell if the associated Dtk_text is part of Main Value Part group - into Dtk_Dimension -.
DTK_TYPE_TERMINATOR_SYMBOL
@ DTK_TYPE_TERMINATOR_SYMBOL
Definition: define.h:348
DTK_TYPE_PRE_DEFINED_CURVE_FONT
@ DTK_TYPE_PRE_DEFINED_CURVE_FONT
Definition: define.h:337
DTK_TYPE_SOLID_ANGLE_MEASURE_WITH_UNIT
@ DTK_TYPE_SOLID_ANGLE_MEASURE_WITH_UNIT
Definition: define.h:188
Dtk_Double64
double Dtk_Double64
Definition: define.h:698
Dtk_DumpXml_Dtk_FeaturePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FeaturePtr(FILE *f, const Dtk_FeaturePtr &inToWrite)
Definition: util_xml_dtk.cpp:8444
Dtk_DumpXml_Dtk_welding_symbol
Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_symbol(FILE *F, const Dtk_Welding::WeldingSymbolEnum &D)
Definition: util_xml_dtk.cpp:1630
Dtk_View::SheetView
@ SheetView
Definition: util_draw_dtk.hpp:6571
Dtk_DumpXml_Dtk_TextStyle
Dtk_ErrorStatus Dtk_DumpXml_Dtk_TextStyle(FILE *F, const Dtk_TextStyle &T)
Definition: util_xml_dtk.cpp:957
Dtk_DumpXml_FeatThread
Dtk_ErrorStatus Dtk_DumpXml_FeatThread(FILE *f, const Dtk_feat_thread *inToWrite)
Definition: util_xml_dtk.cpp:8074
DTK_TYPE_COUNT_MEASURE
@ DTK_TYPE_COUNT_MEASURE
Definition: define.h:198
DTK_TYPE_GEOMETRICALLY_BOUNDED_WIREFRAME_REPRESENTATION
@ DTK_TYPE_GEOMETRICALLY_BOUNDED_WIREFRAME_REPRESENTATION
Definition: define.h:161
Dtk_string::find_substring
int find_substring(const Dtk_string &s1) const
find the position of a substring into a Dtk_string
DTK_TYPE_REPRESENTATION_MAP
@ DTK_TYPE_REPRESENTATION_MAP
Definition: define.h:277
Dtk_feat_hole::GetAxis
Dtk_feat_axis * GetAxis() const
Definition: str_feat_dtk.hpp:1712
Dtk_feat_hole::thread
Dtk_feat_inner_thread * thread
Definition: str_feat_dtk.hpp:1611
dtk_text_type_symbol
@ dtk_text_type_symbol
Definition: str_def.h:13
Dtk_mesh_face::get_nbpolylines
Dtk_Size_t get_nbpolylines() const
Get the number of polylines kept in the class instance.
DTK_TYPE_CC_DESIGN_APPROVAL
@ DTK_TYPE_CC_DESIGN_APPROVAL
Definition: define.h:325
Dtk_Oriented2dBBox::GetYLength
Dtk_Double64 GetYLength() const
Retrieves the Y length - Read Only -.
Definition: util_draw_dtk.hpp:572
Dtk_Dimension::LinearRadiusDimension
@ LinearRadiusDimension
Definition: util_draw_dtk.hpp:4547
Dtk_picture::PixelHeight
Dtk_Size_t & PixelHeight()
Retrieves the height (in pixels)
Definition: dtk_picture.hpp:90
Dtk_ModelDisplay::RenderingModeEnum
RenderingModeEnum
Definition: util_ent_dtk.hpp:981
Dtk_DumpXml_Dtk_Font
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Font(FILE *F, const Dtk_Font &T)
Definition: util_xml_dtk.cpp:931
Dtk_OneCell::GetAdditionnalGeometries
const Dtk_tab< Dtk_EntityPtr > & GetAdditionnalGeometries() const
Retrieves the additionnal geometries of the Dtk_OneCell.
Dtk_Camera::Focus
Dtk_Double64 Focus() const
Definition: util_draw_dtk.hpp:7104
Dtk_Entity::get_type_detk
virtual enum type_detk get_type_detk() const =0
DTK_TYPE_APPLICATION_CONTEXT_ELEMENT
@ DTK_TYPE_APPLICATION_CONTEXT_ELEMENT
Definition: define.h:214
DTK_KIN_TYPE_LAW
@ DTK_KIN_TYPE_LAW
Definition: util_kinematics_dtk.hpp:112
DTK_TYPE_KIN_LAW
@ DTK_TYPE_KIN_LAW
Definition: define.h:542
Dtk_PhysicalMaterialInfos::GetHardeningRatio
Dtk_ErrorStatus GetHardeningRatio(Dtk_Double64 ouHardeningRatio[3]) const
Returns the material hardening ratio.
Dtk_OneCell::GetBorderLeftColor
const Dtk_RGB & GetBorderLeftColor() const
Gets BorderLeftColor of Left border.
Dtk_DumpXml_Dtk_SelectionSet
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SelectionSet(FILE *F, const Dtk_SelectionSetPtr &inSelectionSet)
Definition: util_xml_dtk.cpp:7100
DTK_Text_subtype::IsNotDefined
Dtk_bool IsNotDefined() const
Dtk_feat_axis::GetDirection
Dtk_dir GetDirection() const
Definition: str_feat_dtk.hpp:590
DTK_TYPE_CURVE
@ DTK_TYPE_CURVE
Definition: define.h:56
Dtk_feat_pattern::input_ids
Dtk_tab< long > input_ids
Definition: str_feat_dtk.hpp:3287
Dtk_feat_tolerance_set::GetInferiorTolerance
Dtk_Double64 GetInferiorTolerance() const
Definition: str_feat_dtk.hpp:849
DTK_TYPE_FDT_SET_VIEW
@ DTK_TYPE_FDT_SET_VIEW
Definition: define.h:450
DTK_TYPE_REVERSIBLE_TOPOLOGY_ITEM
@ DTK_TYPE_REVERSIBLE_TOPOLOGY_ITEM
Definition: define.h:156
DTK_TYPE_DRAUGHTING_PRE_DEFINED_CURVE_FONT
@ DTK_TYPE_DRAUGHTING_PRE_DEFINED_CURVE_FONT
Definition: define.h:336
Dtk_Dimension::DistanceDimension
@ DistanceDimension
Definition: util_draw_dtk.hpp:4553
DTK_TYPE_FACETTED_BREP_REPRESENTATION
@ DTK_TYPE_FACETTED_BREP_REPRESENTATION
Definition: define.h:162
Dtk_DumpXml_TextAttributeEnum
void Dtk_DumpXml_TextAttributeEnum(FILE *F, const Dtk_TextStyle::TextAttributeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:810
Dtk_feat::GetInputGeometry
Dtk_feat_geometry * GetInputGeometry() const
Definition: str_feat_dtk.hpp:7039
Dtk_Welding::SymbolSurfaceJointWeld
@ SymbolSurfaceJointWeld
Definition: util_draw_dtk.hpp:2851
Dtk_feat_inner_thread::IsRightThreaded
Dtk_bool IsRightThreaded() const
Definition: str_feat_dtk.hpp:1388
DTK_TYPE_OPEN_SHELL
@ DTK_TYPE_OPEN_SHELL
Definition: define.h:135
Dtk_DumpXml_Value
Dtk_ErrorStatus Dtk_DumpXml_Value(FILE *inFile, const Dtk_string &inLabel, const char *inFormat,...)
Definition: util_xml_dtk.cpp:4373
DTK_TYPE_NODE
@ DTK_TYPE_NODE
Definition: define.h:502
Dtk_TextStyle::CharWidth
Dtk_Double64 & CharWidth()
Retrieves the char width - get/set -.
DTK_TYPE_NURBS_SURFACE
@ DTK_TYPE_NURBS_SURFACE
Definition: define.h:486
DTK_TYPE_PRODUCT_CATEGORY
@ DTK_TYPE_PRODUCT_CATEGORY
Definition: define.h:295
XmlFormat
#define XmlFormat(inOldFormat)
Definition: util_xml_dtk.cpp:44
Dtk_KinJoint::_ABSOLUT_POS1
Dtk_string _ABSOLUT_POS1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:937
DTK_ANCHOR_TOP_LEFT
@ DTK_ANCHOR_TOP_LEFT
Definition: util_draw_dtk.hpp:93
DTK_TYPE_DATE_AND_TIME
@ DTK_TYPE_DATE_AND_TIME
Definition: define.h:178
DTK_TYPE_MESH_CURVE
@ DTK_TYPE_MESH_CURVE
Definition: define.h:470
DTK_VAL_TYPE_DIR
@ DTK_VAL_TYPE_DIR
Definition: dtk_val.hpp:26
Dtk_transfo::getZdir
const Dtk_dir & getZdir() const
Return the Z vector.
CgrReaderModule
@ CgrReaderModule
Definition: dtk_maindoc.hpp:45
DTK_TYPE_ORGANIZATION_RELATIONSHIP
@ DTK_TYPE_ORGANIZATION_RELATIONSHIP
Definition: define.h:312
DTK_TYPE_LUMP
@ DTK_TYPE_LUMP
Definition: define.h:482
Dtk_Fdt::ScreenDisplayEnum
ScreenDisplayEnum
Definition: util_draw_dtk.hpp:6805
DTK_TYPE_PLANE_ANGLE_MEASURE_WITH_UNIT
@ DTK_TYPE_PLANE_ANGLE_MEASURE_WITH_UNIT
Definition: define.h:187
DTK_W
#define DTK_W
Definition: dtk_string.hpp:38
Dtk_Region::CylindricalType
@ CylindricalType
Definition: util_draw_dtk.hpp:7459
Dtk_DumpXml_Dtk_KinematicsMechanism
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsMechanism(FILE *inFile, const Dtk_KinMechanismPtr &inKinMechanism)
Definition: util_xml_dtk.cpp:7786
DTK_TYPE_PRESENTATION_STYLE_SELECT
@ DTK_TYPE_PRESENTATION_STYLE_SELECT
Definition: define.h:372
Dtk_DumpXml_Dtk_KinematicsFormula
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFormula(FILE *inFile, const Dtk_KinFormulaPtr &inFormula)
Definition: util_xml_dtk.cpp:7428
DTK_VAL_TYPE_UNKNOWN
@ DTK_VAL_TYPE_UNKNOWN
Definition: dtk_val.hpp:19
Dtk_string::is_not_NULL
Dtk_bool is_not_NULL() const
Dtk_ConvertFontLineTypeEnumToString
Dtk_string Dtk_ConvertFontLineTypeEnumToString(const Dtk_FontLineType &inEnum)
Definition: util_xml_dtk.cpp:2327
Dtk_Camera::ProjectionTypePerspective
@ ProjectionTypePerspective
Definition: util_draw_dtk.hpp:6942
DTK_TYPE_AXIS1_PLACEMENT
@ DTK_TYPE_AXIS1_PLACEMENT
Definition: define.h:30
Dtk_RGB::A
int & A()
Definition: dtk_rgb.hpp:45
Dtk_Dimension::ChamferDimension
@ ChamferDimension
Definition: util_draw_dtk.hpp:4551
DTK_PICTURE_RGBA32
@ DTK_PICTURE_RGBA32
Definition: dtk_picture.hpp:23
Dtk_DumpXml_Dtk_info
Dtk_ErrorStatus Dtk_DumpXml_Dtk_info(FILE *F, const Dtk_InfoPtr &I)
Definition: util_xml_dtk.cpp:4121
Dtk_OverrideSet::Dtk_OverrideSetEnumToString
static Dtk_string Dtk_OverrideSetEnumToString(const SemanticType &inEnum)
Definition: dtk_override.hpp:95
Dtk_KinJoint::getParameter2
double getParameter2()
Returns the second parameter.
Dtk_Val
Definition: dtk_val.hpp:67
Dtk_feat_hole::GetReliefDiameter
Dtk_Double64 GetReliefDiameter() const
return the diameter of the relief
Definition: str_feat_dtk.hpp:1954
DTK_TYPE_BOOLEAN_OPERAND_ENTITY
@ DTK_TYPE_BOOLEAN_OPERAND_ENTITY
Definition: define.h:415
DTK_TYPE_DEFINED_SYMBOL_SELECT
@ DTK_TYPE_DEFINED_SYMBOL_SELECT
Definition: define.h:349
Dtk_KinParameter::getNamedValue
Dtk_KinNamedValuePtr getNamedValue()
Returns the named value associated at the parameter.
DTK_TYPE_PRE_DEFINED_DIMENSION_SYMBOL
@ DTK_TYPE_PRE_DEFINED_DIMENSION_SYMBOL
Definition: define.h:333
DTK_TYPE_PERSON_AND_ORGANIZATION
@ DTK_TYPE_PERSON_AND_ORGANIZATION
Definition: define.h:310
Dtk_KinJoint::getLocalFrame3
Dtk_transfo getLocalFrame3()
Returns the local frame 3 value.
DTK_TYPE_SEAM_CURVE
@ DTK_TYPE_SEAM_CURVE
Definition: define.h:81
DTK_TYPE_MECHANICAL_CONTEXT
@ DTK_TYPE_MECHANICAL_CONTEXT
Definition: define.h:229
DTK_TYPE_FILL_AREA_STYLE
@ DTK_TYPE_FILL_AREA_STYLE
Definition: define.h:362
dtk_text_type_valueaff
@ dtk_text_type_valueaff
Definition: str_def.h:15
QifReaderModule
@ QifReaderModule
Definition: dtk_maindoc.hpp:79
Dtk_DumpXml_Dtk_LinearExtrusionSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LinearExtrusionSurfacePtr(FILE *F, const Dtk_LinearExtrusionSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6314
Dtk_Info::GetMetaData
Dtk_ErrorStatus GetMetaData(Dtk_tab< Dtk_MetaDataPtr > &outArray) const
DTK_TYPE_PCURVE
@ DTK_TYPE_PCURVE
Definition: define.h:65
Dtk_Dimension::CurvilinearDimension
@ CurvilinearDimension
Definition: util_draw_dtk.hpp:4539
Dtk_Dimension::BasicTypeFlagRight
@ BasicTypeFlagRight
Definition: util_draw_dtk.hpp:4561
Dtk_feat_pattern::angle
double angle
Definition: str_feat_dtk.hpp:3290
Dtk_picture::FileType
Dtk_PictureType & FileType()
Retrieves the file type.
Definition: dtk_picture.hpp:81
DTK_TYPE_SURFACE
@ DTK_TYPE_SURFACE
Definition: define.h:105
DTK_TYPE_HALF_SPACE_SOLID
@ DTK_TYPE_HALF_SPACE_SOLID
Definition: define.h:407
DTK_THREAD_UP_TO_PLANE
@ DTK_THREAD_UP_TO_PLANE
Definition: str_feat_dtk.hpp:289
Dtk_Welding::ComplementarySymbolEnumToString
static Dtk_string ComplementarySymbolEnumToString(const ComplementarySymbolEnum &inEnum)
Definition: util_draw_dtk.hpp:2937
Dtk_Dimension::BasicTypeNone
@ BasicTypeNone
Definition: util_draw_dtk.hpp:4558
Dtk_FCFFeatureIndicatorType::CollectionPlane
@ CollectionPlane
Definition: util_draw_dtk.hpp:5472
DTK_TYPE_DIMENSION_CURVE_TERMINATOR
@ DTK_TYPE_DIMENSION_CURVE_TERMINATOR
Definition: define.h:347
DTK_TYPE_ELEMENTARY_SURFACE
@ DTK_TYPE_ELEMENTARY_SURFACE
Definition: define.h:82
Dtk_DumpXml_Dtk_NurbsSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NurbsSurfacePtr(FILE *F, const Dtk_NurbsSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6089
Dtk_Val::GetInt
int GetInt(Dtk_status &st=Dtk_status::GetDefaultStatus()) const
DTK_TYPE_TORUS
@ DTK_TYPE_TORUS
Definition: define.h:404
Dtk_DumpXml_Dtk_LumpPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LumpPtr(FILE *F, const Dtk_LumpPtr &inLump)
Definition: util_xml_dtk.cpp:6695
Dtk_Text::Text
Dtk_string & Text()
Retrieves the text string - get/set -.
DTK_TYPE_STANDARD_REVOLUTION_SURFACE
@ DTK_TYPE_STANDARD_REVOLUTION_SURFACE
Definition: define.h:488
DTK_TYPE_COEDGE
@ DTK_TYPE_COEDGE
Definition: define.h:484
DTK_TYPE_MANIFOLD_SURFACE_SHAPE_REPRESENTATION
@ DTK_TYPE_MANIFOLD_SURFACE_SHAPE_REPRESENTATION
Definition: define.h:285
Dtk_Fdt::ScreenDisplayEnumToString
static Dtk_string ScreenDisplayEnumToString(const ScreenDisplayEnum &inEnum)
Definition: util_draw_dtk.hpp:6812
Dtk_Constraint::ConstraintOrientationTypeEnumToString
static Dtk_string ConstraintOrientationTypeEnumToString(const ConstraintOrientationTypeEnum &inEnum)
Definition: util_ent_dtk.hpp:1172
Dtk_Constraint::_ConstraintValue::_ValueType
ConstraintValueTypeEnum _ValueType
Definition: util_ent_dtk.hpp:1217
DTK_TYPE_SECURITY_CLASSIFICATION_LEVEL
@ DTK_TYPE_SECURITY_CLASSIFICATION_LEVEL
Definition: define.h:253
Dtk_ModelDisplay::SectionPlane
@ SectionPlane
Definition: util_ent_dtk.hpp:993
Dtk_Leader::TypeUnknown
@ TypeUnknown
Definition: util_draw_dtk.hpp:2082
DTK_TYPE_KIN_CONSTRAINT
@ DTK_TYPE_KIN_CONSTRAINT
Definition: define.h:537
Dtk_API::GetAPI
static Dtk_API * GetAPI()
Get DATAKIT API.
DTK_TYPE_TRIMMED_CURVE
@ DTK_TYPE_TRIMMED_CURVE
Definition: define.h:64
DTK_FRAME_TYPE_SYMMETRICAL_SET
@ DTK_FRAME_TYPE_SYMMETRICAL_SET
Definition: util_draw_dtk.hpp:164
DTK_TYPE_REFERENCE_FRAME
@ DTK_TYPE_REFERENCE_FRAME
Definition: define.h:465
DTK_TYPE_NET
@ DTK_TYPE_NET
Definition: define.h:93
Dtk_DumpXml_Dtk_transfo
Dtk_ErrorStatus Dtk_DumpXml_Dtk_transfo(FILE *F, const Dtk_transfo &T)
Definition: util_xml_dtk.cpp:4362
Dtk_OneCell::getHeight
Dtk_Double64 getHeight() const
Gets the height of the Dtk_OneCell.
Dtk_OLEObject::Dtk_OLEObjectViewingAspectToString
static Dtk_string Dtk_OLEObjectViewingAspectToString(const Dtk_OLEObjectViewingAspect &inEnum)
Definition: dtk_oleobject.hpp:33
Dtk_KinJoint::getLowerLimit2
double getLowerLimit2()
Returns the lower limit 2.
Dtk_Welding::SymbolSurfacingWeld
@ SymbolSurfacingWeld
Definition: util_draw_dtk.hpp:2829
Dtk_Welding::SymbolScarfWeld
@ SymbolScarfWeld
Definition: util_draw_dtk.hpp:2843
Dtk_ToleranceSpecificationContainer::TypeCylindricity
@ TypeCylindricity
Definition: util_draw_dtk.hpp:5707
DTK_TYPE_COMPOSITE_CURVE_ON_SURFACE
@ DTK_TYPE_COMPOSITE_CURVE_ON_SURFACE
Definition: define.h:72
Dtk_feat_hole::IsEndActived
Dtk_Int32 IsEndActived() const
test if end chamfer is activated
Definition: str_feat_dtk.hpp:1985
DTK_FRAME_TYPE_SQUARE
@ DTK_FRAME_TYPE_SQUARE
Definition: util_draw_dtk.hpp:131
Dtk_PhysicalMaterialInfos::GetThermalConductivity
Dtk_ErrorStatus GetThermalConductivity(Dtk_Double64 &outValue, Dtk_string &outUnits) const
Returns the material thermal conductivity.
DTK_TYPE_BLEND_SURFACE
@ DTK_TYPE_BLEND_SURFACE
Definition: define.h:92
DTK_FRAME_TYPE_CIRCLE
@ DTK_FRAME_TYPE_CIRCLE
Definition: util_draw_dtk.hpp:133
Dtk_OneCell::GetBorderRightBlanked
Dtk_Int32 GetBorderRightBlanked() const
Gets BorderRightBlanked of Right border.
DTK_Text_subtype::IsChamferright
Dtk_bool IsChamferright() const
Tell if the associated Dtk_text is part of Chamfer Right group - into Dtk_Dimension -.
Dtk_DumpXml_MetaDataTypeEnum
void Dtk_DumpXml_MetaDataTypeEnum(FILE *F, const Dtk_MetaData::MetaDataTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:708
Dtk_picture::MetricHeight
double & MetricHeight()
Retrieves the height (in mm)
Definition: dtk_picture.hpp:99
Dtk_Component::ComponentFound
@ ComponentFound
Definition: dtk_maindoc.hpp:563
Dtk_DumpXml_Dtk_StreamPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_StreamPtr(FILE *F, const Dtk_StreamPtr &inVal)
Definition: util_xml_dtk.cpp:8782
Dtk_DumpXml_Dtk_WeldingPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_WeldingPtr(FILE *F, const Dtk_WeldingPtr &D)
Definition: util_xml_dtk.cpp:1793
Dtk_ModelDisplay::rendering_mode_wireframe_partially_shade
@ rendering_mode_wireframe_partially_shade
Definition: util_ent_dtk.hpp:988
DxfReaderModule
@ DxfReaderModule
Definition: dtk_maindoc.hpp:55
DTK_TYPE_FEATURE
@ DTK_TYPE_FEATURE
Definition: define.h:534
Dtk_Component::ComponentAssemblyGeometry
@ ComponentAssemblyGeometry
Definition: dtk_maindoc.hpp:567
Pdtk_Assert
#define Pdtk_Assert(X)
Definition: define.h:742
Dtk_feat_pattern::objects_to_pattern
Dtk_tab< Dtk_feat_geometry * > objects_to_pattern
Definition: str_feat_dtk.hpp:3285
dtk_text_type_roughness_text3
@ dtk_text_type_roughness_text3
Definition: str_def.h:28
Dtk_feat_thread::GetLimit
Dtk_feat_geometry * GetLimit() const
Definition: str_feat_dtk.hpp:1576
DTK_TYPE_LEADER
@ DTK_TYPE_LEADER
Definition: define.h:463
DTK_TYPE_AXIS2_PLACEMENT_2D
@ DTK_TYPE_AXIS2_PLACEMENT_2D
Definition: define.h:31
Dtk_KinJoint::getLocalFrame1
Dtk_transfo getLocalFrame1()
Returns the local frame 1 value.
DTK_TYPE_GROUP
@ DTK_TYPE_GROUP
Definition: define.h:461
DTK_TYPE_CONNECTED_EDGE_SET
@ DTK_TYPE_CONNECTED_EDGE_SET
Definition: define.h:120
Dtk_DumpXml_Dtk_CurvePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CurvePtr(FILE *F, const Dtk_CurvePtr &inCurve)
Definition: util_xml_dtk.cpp:6015
DTK_DASHED
@ DTK_DASHED
Definition: util_ent_dtk.hpp:51
Dtk_Welding::SymbolSingeVButtWeld
@ SymbolSingeVButtWeld
Definition: util_draw_dtk.hpp:2801
DTK_TYPE_PROMISSORY_USAGE_OCCURENCE
@ DTK_TYPE_PROMISSORY_USAGE_OCCURENCE
Definition: define.h:231
Dtk_DumpXml_Dtk_AnnotationPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_AnnotationPtr(FILE *F, const Dtk_AnnotationPtr &D)
Definition: util_xml_dtk.cpp:877
DTK_Text_subtype::IsValSplitPart1
Dtk_bool IsValSplitPart1() const
Tell if the associated Dtk_text is part of Value Split Part 1 - for Degrees/Minutes/Seconds form - gr...
DTK_INDIFFERENT_HIERARCHY
@ DTK_INDIFFERENT_HIERARCHY
Definition: util_draw_dtk.hpp:69
Dtk_feat_hole::GetSketch
Dtk_feat_geometry * GetSketch() const
Definition: str_feat_dtk.hpp:1701
DTK_TYPE_ONE_DIRECTION_REPEAT_FACTOR
@ DTK_TYPE_ONE_DIRECTION_REPEAT_FACTOR
Definition: define.h:344
DTK_TYPE_POINT
@ DTK_TYPE_POINT
Definition: define.h:479
Dtk_feat_inner_thread
Feature Inner Thread.
Definition: str_feat_dtk.hpp:1249
Dtk_Welding::FinishSymbolNone
@ FinishSymbolNone
Definition: util_draw_dtk.hpp:2952
Dtk_DumpXml_Dtk_DrawingPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DrawingPtr(FILE *F, const Dtk_DrawingPtr &D, const int &compact)
Definition: util_xml_dtk.cpp:3042
IgesReaderModule
@ IgesReaderModule
Definition: dtk_maindoc.hpp:39
Dtk_HatchingPattern::HatchingStyle
Dtk_HatchingStyle & HatchingStyle()
Dtk_feat::GetTypeAsString
Dtk_string GetTypeAsString()
Dtk_ModelDisplay::rendering_mode_shaded_only
@ rendering_mode_shaded_only
Definition: util_ent_dtk.hpp:982
Dtk_NodeConnector::ReasonCategoryEnum
ReasonCategoryEnum
Reason Category. Global Category of the NodeConnector uesed to gather Reason into families.
Definition: dtk_maindoc.hpp:1200
DTK_TYPE_QUASI_UNIFORM_CURVE
@ DTK_TYPE_QUASI_UNIFORM_CURVE
Definition: define.h:58
DTK_TYPE_VERTEX_LOOP
@ DTK_TYPE_VERTEX_LOOP
Definition: define.h:122
Dtk_picture::File
Dtk_tab< char > & File()
Retrieves the binary file.
Definition: dtk_picture.hpp:77
DTK_TYPE_PRODUCT
@ DTK_TYPE_PRODUCT
Definition: define.h:221
DTK_TYPE_SPECIFIED_ITEM
@ DTK_TYPE_SPECIFIED_ITEM
Definition: define.h:262
_3dXmlReaderModule
@ _3dXmlReaderModule
Definition: dtk_maindoc.hpp:52
DTK_TYPE_APPROVED_ITEM
@ DTK_TYPE_APPROVED_ITEM
Definition: define.h:259
Dtk_ModelDisplay::SectionBox
@ SectionBox
Definition: util_ent_dtk.hpp:996
DTK_TYPE_SOLID_OF_REVOLUTION
@ DTK_TYPE_SOLID_OF_REVOLUTION
Definition: define.h:412
dtk_text_type_roughness_contact_area
@ dtk_text_type_roughness_contact_area
Definition: str_def.h:34
DTK_TYPE_DRAUGHTING_PRE_DEFINED_COLOUR
@ DTK_TYPE_DRAUGHTING_PRE_DEFINED_COLOUR
Definition: define.h:335
Dtk_View::TitleBlockView
@ TitleBlockView
Definition: util_draw_dtk.hpp:6569
DTK_TYPE_PRE_DEFINED_ITEM
@ DTK_TYPE_PRE_DEFINED_ITEM
Definition: define.h:340
Dtk_feat_inner_thread::GetDepthTolerance
Dtk_feat_tolerance_set * GetDepthTolerance() const
Definition: str_feat_dtk.hpp:1339
DTK_TYPE_GEOMETRIC_SET_REPLICA
@ DTK_TYPE_GEOMETRIC_SET_REPLICA
Definition: define.h:112
Dtk_Component::ComponentAdditionnalReference
@ ComponentAdditionnalReference
Definition: dtk_maindoc.hpp:566
Dtk_DumpXml_LeaderTerminatorTypeEnum
void Dtk_DumpXml_LeaderTerminatorTypeEnum(FILE *F, const Dtk_Leader::LeaderTerminatorTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:832
DTK_TYPE_INTERSECTION_CURVE
@ DTK_TYPE_INTERSECTION_CURVE
Definition: define.h:80
Dtk_Leader::TypeLinear
@ TypeLinear
Definition: util_draw_dtk.hpp:2083
Dtk_Welding::FinishSymbolGrind
@ FinishSymbolGrind
Definition: util_draw_dtk.hpp:2958
DTK_TYPE_AREA_MEASURE_WITH_UNIT
@ DTK_TYPE_AREA_MEASURE_WITH_UNIT
Definition: define.h:189
DTK_TYPE_METADATA
@ DTK_TYPE_METADATA
Definition: define.h:507
V6ReaderModule
@ V6ReaderModule
Definition: dtk_maindoc.hpp:54
DTK_TYPE_CSG_SELECT_ENTITY
@ DTK_TYPE_CSG_SELECT_ENTITY
Definition: define.h:416
Dtk_KinJoint::getUpperLimit2
double getUpperLimit2()
Returns the upper limit 2.
DTK_TYPE_CONNECTED_FACE_SET
@ DTK_TYPE_CONNECTED_FACE_SET
Definition: define.h:139
SeReaderModule
@ SeReaderModule
Definition: dtk_maindoc.hpp:38
DTK_TYPE_PRODUCT_DEFINITION
@ DTK_TYPE_PRODUCT_DEFINITION
Definition: define.h:228
Dtk_Oriented2dBBox::XLocalVector
Dtk_dir XLocalVector() const
Retrieves the X local vector - Read Only -.
Definition: util_draw_dtk.hpp:579
Dtk_Component::ComponentWithUnavailableReader
@ ComponentWithUnavailableReader
Definition: dtk_maindoc.hpp:568
DcmReaderModule
@ DcmReaderModule
Definition: dtk_maindoc.hpp:51
MaxReaderModules
@ MaxReaderModules
Definition: dtk_maindoc.hpp:85
Dtk_DumpXml_Dtk_Dimension_DimensionType
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Dimension_DimensionType(FILE *F, const Dtk_Dimension::DimensionTypeEnum &D)
Definition: util_xml_dtk.cpp:1402
DtkPictureTypeEnumToString
Dtk_string DtkPictureTypeEnumToString(const Dtk_PictureType &inEnum)
Definition: util_xml_dtk.cpp:776
Dtk_Roughness::ModeParallel
@ ModeParallel
Definition: util_draw_dtk.hpp:2463
DTK_TYPE_ADDRESS
@ DTK_TYPE_ADDRESS
Definition: define.h:319
DTK_ANCHOR_TOP_RIGHT
@ DTK_ANCHOR_TOP_RIGHT
Definition: util_draw_dtk.hpp:95
DTK_TYPE_LIST_OF_REVERSIBLE_TOPOLOGY_ITEM
@ DTK_TYPE_LIST_OF_REVERSIBLE_TOPOLOGY_ITEM
Definition: define.h:154
DTK_FDT_MODIFIER_MAX_MATERIAL
@ DTK_FDT_MODIFIER_MAX_MATERIAL
Definition: util_draw_dtk.hpp:58
Dtk_feat_inner_thread::GetLimitTypeAsString
Dtk_string GetLimitTypeAsString() const
dtk_text_type_roughness_text6
@ dtk_text_type_roughness_text6
Definition: str_def.h:31
Dtk_DumpXml_Dtk_EntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EntityPtr(FILE *inDumpFile, const Dtk_EntityPtr &inEntity)
Definition: util_xml_dtk.cpp:5346
Dtk_Welding::SymbolFilletWeld
@ SymbolFilletWeld
Definition: util_draw_dtk.hpp:2813
Dtk_ModelDisplay::rendering_mode_static_wireframe
@ rendering_mode_static_wireframe
Definition: util_ent_dtk.hpp:986
DTK_TYPE_REVERSIBLE_TOPOLOGY
@ DTK_TYPE_REVERSIBLE_TOPOLOGY
Definition: define.h:157
DTK_TYPE_CONNECTOR_PART
@ DTK_TYPE_CONNECTOR_PART
Definition: define.h:473
Dtk_OneCell::getWidth
Dtk_Double64 getWidth() const
Gets the width of the Dtk_OneCell.
DTK_TYPE_PRE_DEFINED_COLOUR
@ DTK_TYPE_PRE_DEFINED_COLOUR
Definition: define.h:339
Dtk_DumpXml_Dtk_Grid_ShowLabelOptionEnum
void Dtk_DumpXml_Dtk_Grid_ShowLabelOptionEnum(FILE *F, const Dtk_Grid::ShowLabelOption &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:2357
RevitReaderModule
@ RevitReaderModule
Definition: dtk_maindoc.hpp:66
DTK_TYPE_BODY
@ DTK_TYPE_BODY
Definition: define.h:481
DTK_TYPE_PLANE
@ DTK_TYPE_PLANE
Definition: define.h:83
Dtk_Camera::ProjectionType
const Dtk_Camera::ProjectionTypeEnum & ProjectionType() const
Retrieves the projection type - read only -.
Dtk_NodeConnector::ReasonLinkEnumToString
static Dtk_string ReasonLinkEnumToString(const ReasonLinkEnum &inEnum)
Definition: dtk_maindoc.hpp:1146
DTK_TYPE_CIRCLE
@ DTK_TYPE_CIRCLE
Definition: define.h:49
DTK_TYPE_GEOMETRICALLY_BOUNDED_SURFACE_REPRESENTATION
@ DTK_TYPE_GEOMETRICALLY_BOUNDED_SURFACE_REPRESENTATION
Definition: define.h:160
DTK_TYPE_SUPER_CURVE
@ DTK_TYPE_SUPER_CURVE
Definition: define.h:55
Dtk_Int32
int32_t Dtk_Int32
Definition: define.h:686
DTK_TYPE_ASSEMBLY_COMPONENT_USAGE_SUBSTITUTE
@ DTK_TYPE_ASSEMBLY_COMPONENT_USAGE_SUBSTITUTE
Definition: define.h:235
Dtk_Grid::Absolute
@ Absolute
Definition: util_draw_dtk.hpp:4324
DTK_TYPE_APPROVAL_RELATIONSHIP
@ DTK_TYPE_APPROVAL_RELATIONSHIP
Definition: define.h:317
Dtk_Node::FullType
This is the Node FullType Class The Dtk_Node::FullType object is used to retrieve the full informatio...
Definition: dtk_maindoc.hpp:273
dtk_text_type_text_add_left
@ dtk_text_type_text_add_left
Definition: str_def.h:35
Dtk_feat_limit::LENGTH
@ LENGTH
Definition: str_feat_dtk.hpp:621
DTK_DOTTED
@ DTK_DOTTED
Definition: util_ent_dtk.hpp:57
ArtReaderModule
@ ArtReaderModule
Definition: dtk_maindoc.hpp:72
Dtk_Text::TextType
DTK_Text_type & TextType()
Retrieves the text type - get/set -.
Dtk_FCFFeatureIndicatorType::Unknown
@ Unknown
Definition: util_draw_dtk.hpp:5468
DTK_TYPE_CONTRACTED_ITEM
@ DTK_TYPE_CONTRACTED_ITEM
Definition: define.h:226
Dtk_Welding::SymbolStudWeld
@ SymbolStudWeld
Definition: util_draw_dtk.hpp:2845
Dtk_Roughness::ObtentionTypeNotDefined
@ ObtentionTypeNotDefined
Definition: util_draw_dtk.hpp:2432
Dtk_DumpXml_Dtk_RGB
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RGB(FILE *F, const Dtk_RGB &RGB)
Definition: util_xml_dtk.cpp:3543
DTK_TYPE_PUBLICATION
@ DTK_TYPE_PUBLICATION
Definition: define.h:556
DTK_TYPE_SYMBOL_TARGET
@ DTK_TYPE_SYMBOL_TARGET
Definition: define.h:350
DTK_TYPE_FACE
@ DTK_TYPE_FACE
Definition: define.h:132
DTK_TYPE_CHARACTERIZED_PRODUCT_DEFINITION
@ DTK_TYPE_CHARACTERIZED_PRODUCT_DEFINITION
Definition: define.h:264
Dtk_NodeConnector::ForceRender
@ ForceRender
Definition: dtk_maindoc.hpp:1105
DTK_TYPE_BOUNDARY_CURVE
@ DTK_TYPE_BOUNDARY_CURVE
Definition: define.h:73
DTK_TYPE_GLOBAL_DATA_SET
@ DTK_TYPE_GLOBAL_DATA_SET
Definition: define.h:445
DTK_TYPE_DRAUGHTING_CALLOUT
@ DTK_TYPE_DRAUGHTING_CALLOUT
Definition: define.h:390
DTK_TYPE_PUBLICATION_DATA_SET
@ DTK_TYPE_PUBLICATION_DATA_SET
Definition: define.h:447
DTK_TYPE_PATH_ENTITY
@ DTK_TYPE_PATH_ENTITY
Definition: define.h:152
DTK_TYPE_CSG_PRIMITIVE
@ DTK_TYPE_CSG_PRIMITIVE
Definition: define.h:417
Dtk_KinJoint::_PARAMETER2
Dtk_string _PARAMETER2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:931
DTK_BODY_SELECT
@ DTK_BODY_SELECT
Definition: str_feat_dtk.hpp:156
Dtk_Dimension::BasicTypeOblong
@ BasicTypeOblong
Definition: util_draw_dtk.hpp:4562
DTK_PICTURE_PNG
@ DTK_PICTURE_PNG
Definition: dtk_picture.hpp:26
Dtk_DumpXml_FeatAxis
Dtk_ErrorStatus Dtk_DumpXml_FeatAxis(FILE *f, const Dtk_feat_axis *inToWrite)
Definition: util_xml_dtk.cpp:8029
Dtk_KinJoint::getLocalFrame4
Dtk_transfo getLocalFrame4()
Returns the local frame 4 value.
Dtk_ModelDisplay::rendering_mode_studio
@ rendering_mode_studio
Definition: util_ent_dtk.hpp:989
DTK_TYPE_GRID
@ DTK_TYPE_GRID
Definition: define.h:442
DTK_TYPE_COLOUR
@ DTK_TYPE_COLOUR
Definition: define.h:354
DTK_TYPE_FDT_VIEW
@ DTK_TYPE_FDT_VIEW
Definition: define.h:439
DTK_TYPE_BLOCK
@ DTK_TYPE_BLOCK
Definition: define.h:402
DTK_TYPE_SURFACE_OF_REVOLUTION
@ DTK_TYPE_SURFACE_OF_REVOLUTION
Definition: define.h:90
Dtk_Constraint::ConstraintTypeEnumToString
static Dtk_string ConstraintTypeEnumToString(const ConstraintTypeEnum &inEnum)
Definition: util_ent_dtk.hpp:1276
V4ReaderModule
@ V4ReaderModule
Definition: dtk_maindoc.hpp:34
DTK_TYPE_CURVE_REPLICA
@ DTK_TYPE_CURVE_REPLICA
Definition: define.h:66
Dtk_ToleranceSpecificationContainer::TypeSymmetry
@ TypeSymmetry
Definition: util_draw_dtk.hpp:5723
Dtk_mesh_face::get_triangle_indices
const Dtk_UInt32 * get_triangle_indices(Dtk_Size_t inI) const
Get pointer of triangle indices of i-th triangle.
Dtk_DumpXml_Dtk_TablePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_TablePtr(FILE *F, const Dtk_TablePtr &D)
Definition: util_xml_dtk.cpp:2290
DTK_TYPE_LAYER_FILTER_INFOS
@ DTK_TYPE_LAYER_FILTER_INFOS
Definition: define.h:495
Dtk_Welding::SymbolPermanentBackingStripUsed
@ SymbolPermanentBackingStripUsed
Definition: util_draw_dtk.hpp:2827
DTK_TYPE_DATE_AND_TIME_ASSIGNMENT
@ DTK_TYPE_DATE_AND_TIME_ASSIGNMENT
Definition: define.h:184
Dtk_feat_limit::UP_TO_NEXT
@ UP_TO_NEXT
Definition: str_feat_dtk.hpp:622
Dtk_feat_thread::GetInnerThread
Dtk_feat_inner_thread * GetInnerThread() const
Definition: str_feat_dtk.hpp:1495
DTK_TYPE_DESCRIPTIVE_MEASURE
@ DTK_TYPE_DESCRIPTIVE_MEASURE
Definition: define.h:200
Dtk_Leader::ArrowHead::GetArrowLocation
const Dtk_pnt & GetArrowLocation() const
Definition: util_draw_dtk.hpp:2036
DTK_TYPE_AREA_UNIT
@ DTK_TYPE_AREA_UNIT
Definition: define.h:209
DTK_Text_subtype::IsTolUpperTol
Dtk_bool IsTolUpperTol() const
Tell if the associated Dtk_text is part of Tolerance Upper Value group - into Dtk_Dimension -.
Dtk_Component::ComponentTypeEnumToString
static Dtk_string ComponentTypeEnumToString(const ComponentTypeEnum &inEnum)
Definition: dtk_maindoc.hpp:596
Dtk_feat_axis::GetOrigin
Dtk_pnt GetOrigin() const
Definition: str_feat_dtk.hpp:580
DTK_TYPE_FACE_SURFACE
@ DTK_TYPE_FACE_SURFACE
Definition: define.h:128
DTK_TYPE_PERSONAL_ADDRESS
@ DTK_TYPE_PERSONAL_ADDRESS
Definition: define.h:318
Dtk_Leader::ArrowHead::GetWidthHeight
void GetWidthHeight(Dtk_Double64 &outWidth, Dtk_Double64 &outHeight) const
Definition: util_draw_dtk.hpp:2045
Dtk_KinSpeedAcceleration
Dtk_KinSpeedAcceleration represents a mechanism speed/acceleration.
Definition: util_kinematics_dtk.hpp:2511
Dtk_Dimension::ShowDualValueNone
@ ShowDualValueNone
Definition: util_draw_dtk.hpp:4566
DTK_TYPE_SHAPE_REPRESENTATION_RELATIONSHIP
@ DTK_TYPE_SHAPE_REPRESENTATION_RELATIONSHIP
Definition: define.h:275
DTK_TYPE_REPRESENTATION_CONTEXT
@ DTK_TYPE_REPRESENTATION_CONTEXT
Definition: define.h:269
DTK_Text_subtype::IsLeftText
Dtk_bool IsLeftText() const
Tell if the associated Dtk_text is part of left group - into Dtk_Dimension -.
DTK_TYPE_DIRECTION
@ DTK_TYPE_DIRECTION
Definition: define.h:27
DTK_TYPE_LINE
@ DTK_TYPE_LINE
Definition: define.h:46
DTK_PHANTOM
@ DTK_PHANTOM
Definition: util_ent_dtk.hpp:53
DTK_TYPE_EDGE_BASED_WIREFRAME_REPRESENTATION
@ DTK_TYPE_EDGE_BASED_WIREFRAME_REPRESENTATION
Definition: define.h:159
dtk_text_type_text_add_right
@ dtk_text_type_text_add_right
Definition: str_def.h:36
Dtk_feat_hole::hole_params
Dtk_hole_params hole_params
Definition: str_feat_dtk.hpp:1600
Dtk_feat::GetOutputGeometry
Dtk_feat_geometry * GetOutputGeometry() const
Definition: str_feat_dtk.hpp:7049
StepReaderModule
@ StepReaderModule
Definition: dtk_maindoc.hpp:40
Dtk_Welding::SymbolVFlareWeld
@ SymbolVFlareWeld
Definition: util_draw_dtk.hpp:2839
DTK_TYPE_SOLID_ANGLE_MEASURE
@ DTK_TYPE_SOLID_ANGLE_MEASURE
Definition: define.h:195
Dtk_feat_limit::GetTypeAsString
Dtk_string GetTypeAsString() const
DTK_TYPE_APPROVAL_PERSON_ORGANIZATION
@ DTK_TYPE_APPROVAL_PERSON_ORGANIZATION
Definition: define.h:316
Dtk_ToleranceSpecificationContainer::TypeTotalRunout
@ TypeTotalRunout
Definition: util_draw_dtk.hpp:5727
DTK_TYPE_START_REQUEST_ITEM
@ DTK_TYPE_START_REQUEST_ITEM
Definition: define.h:225
DTK_DOTTED_DASHED
@ DTK_DOTTED_DASHED
Definition: util_ent_dtk.hpp:61
DTK_TYPE_KIN_PRODUCT
@ DTK_TYPE_KIN_PRODUCT
Definition: define.h:546
DstvReaderModule
@ DstvReaderModule
Definition: dtk_maindoc.hpp:76
Dtk_API::GetColorInTable
Dtk_ErrorStatus GetColorInTable(const Dtk_Int32 inIndex, Dtk_RGB &outColor)
GetColor in API Lut form index.
Dtk_SmartPtr::DtkDynamicCast
static Dtk_SmartPtr< T > DtkDynamicCast(const Dtk_SmartPtr< T2 > &p)
Definition: util_ptr_dtk.hpp:101
Dtk_DumpXml_Dtk_Text_DTK_Text_subtype
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Text_DTK_Text_subtype(FILE *F, const DTK_Text_subtype &subType)
Definition: util_xml_dtk.cpp:1018
DTK_TYPE_ASSEMBLY_COMPONENT_USAGE
@ DTK_TYPE_ASSEMBLY_COMPONENT_USAGE
Definition: define.h:232
Dtk_DumpXml_Dtk_ComponentPtr_End
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_End(FILE *F)
Definition: util_xml_dtk.cpp:5022
Dtk_MetaData::MetaDataTypeEnum
MetaDataTypeEnum
Definition: dtk_metadata.hpp:27
Dtk_Oriented2dBBox::YLocalVector
Dtk_dir YLocalVector() const
Retrieves the Y local vector - Read Only -.
Definition: util_draw_dtk.hpp:586
Dtk_KinParameter::getParentElement
void * getParentElement()
Returns the parent element.
DTK_FRAME_TYPE_OCTANGLE
@ DTK_FRAME_TYPE_OCTANGLE
Definition: util_draw_dtk.hpp:169
DTK_TYPE_BREP_WITH_VOIDS
@ DTK_TYPE_BREP_WITH_VOIDS
Definition: define.h:165
Dtk_ToleranceSpecificationContainer::TypeCircularRunout
@ TypeCircularRunout
Definition: util_draw_dtk.hpp:5725
Dtk_Welding::SymbolSolderedJointWeld
@ SymbolSolderedJointWeld
Definition: util_draw_dtk.hpp:2857
DTK_TYPE_REFERENCE_PLANE_TRIANGLE
@ DTK_TYPE_REFERENCE_PLANE_TRIANGLE
Definition: define.h:595
DTK_PICTURE_PS
@ DTK_PICTURE_PS
Definition: dtk_picture.hpp:31
DTK_TYPE_GEOMETRIC_REPRESENTATION_ITEM
@ DTK_TYPE_GEOMETRIC_REPRESENTATION_ITEM
Definition: define.h:279
Dtk_feat_thread::GetSupportDiameter
Dtk_Double64 GetSupportDiameter() const
Definition: str_feat_dtk.hpp:1546
Dtk_DumpXml_NodeFullType
void Dtk_DumpXml_NodeFullType(FILE *F, const Dtk_Node::FullType &inNodeFullType, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:699
Dtk_KinFixPart::getPart
Dtk_KinPartPtr getPart()
Returns the part fixed.
Dtk_TextStyle::AttributeSubscript
@ AttributeSubscript
Definition: util_draw_dtk.hpp:277
Dtk_ErrorStatus
Dtk_ErrorStatus
Definition: error_dtk.hpp:6
Dtk_Roughness::ObtentionTypeMachiningMandatory
@ ObtentionTypeMachiningMandatory
Definition: util_draw_dtk.hpp:2434
Dtk_feat_hole::GetReliefAngle
Dtk_Double64 GetReliefAngle() const
return the angle of the relief
Definition: str_feat_dtk.hpp:1949
DTK_TYPE_KIN_PARAMETER
@ DTK_TYPE_KIN_PARAMETER
Definition: define.h:539
Dtk_SmartPtr::IsNULL
Dtk_bool IsNULL() const
Definition: util_ptr_dtk.hpp:118
dtkErrorNotYetImplemented
@ dtkErrorNotYetImplemented
Definition: error_dtk.hpp:32
Dtk_View::DetailView
@ DetailView
Definition: util_draw_dtk.hpp:6563
dtk_text_type_lower_text
@ dtk_text_type_lower_text
Definition: str_def.h:24
Dtk_DumpXml_Dtk_pnt
Dtk_ErrorStatus Dtk_DumpXml_Dtk_pnt(FILE *F, const Dtk_pnt &P, const char *b)
Definition: util_xml_dtk.cpp:4350
Dtk_KinJoint::getCompoundType
int getCompoundType()
Returns the compound type attribute.
SdnfReaderModule
@ SdnfReaderModule
Definition: dtk_maindoc.hpp:71
Dtk_Dimension::ShowDualValueBelow
@ ShowDualValueBelow
Definition: util_draw_dtk.hpp:4567
DTK_Text_subtype::IsUpText
Dtk_bool IsUpText() const
Tell if the associated Dtk_text is part of Up group - into Dtk_Dimension -.
Dtk_DumpXml_TextJustificationEnum
void Dtk_DumpXml_TextJustificationEnum(FILE *F, const Dtk_TextStyle::TextJustificationEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:939
Dtk_feat_hole::GetEndDiameter
Dtk_Double64 GetEndDiameter() const
return the diameter of the end chamfer
Definition: str_feat_dtk.hpp:1995
Dtk_Roughness::ModeNone
@ ModeNone
Definition: util_draw_dtk.hpp:2451
Dtk_Camera::ProjectionTypeParallel
@ ProjectionTypeParallel
Definition: util_draw_dtk.hpp:6941
DTK_TYPE_ASSOCIATIVE_RADIUS_DIMENSION
@ DTK_TYPE_ASSOCIATIVE_RADIUS_DIMENSION
Definition: define.h:422
DTK_TYPE_REPARAMETRISED_COMPOSITE_CURVE_SEGMENT
@ DTK_TYPE_REPARAMETRISED_COMPOSITE_CURVE_SEGMENT
Definition: define.h:76
Dtk_Info::GetRenderInfos
Dtk_RenderInfosPtr GetRenderInfos() const
Retrieves the entity RenderInfos of the entity.
Dtk_KinJoint::getAbsolutPos2
Dtk_transfo getAbsolutPos2()
Returns the part 2 absolute position.
typedetkToDtk_string
Dtk_string typedetkToDtk_string(const type_detk &inVal)
Definition: util_xml_dtk.cpp:99
DTK_TYPE_PRE_DEFINED_TERMINATOR_SYMBOL
@ DTK_TYPE_PRE_DEFINED_TERMINATOR_SYMBOL
Definition: define.h:331
Dtk_NodeConnector::GetPointedEntityType
type_detk GetPointedEntityType() const
Retrieves the pointed entity Type.
Dtk_DumpXml_Dtk_RegionPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RegionPtr(FILE *F, const Dtk_RegionPtr &D)
Definition: util_xml_dtk.cpp:2418
DTK_TYPE_FDT
@ DTK_TYPE_FDT
Definition: define.h:424
Dtk_transfo::getXdir
const Dtk_dir & getXdir() const
Return the X vector.
Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr(FILE *F, const Dtk_FCFFeatureIndicatorPtr &D)
Definition: util_xml_dtk.cpp:2761
Dtk_StandardTools::sprintf_dtk
int sprintf_dtk(char *Buffer, size_t BufferCount, const char *Format,...)
XMLAttribute
@ XMLAttribute
Definition: util_xml_dtk.hpp:94
DTK_TYPE_SPCURVE
@ DTK_TYPE_SPCURVE
Definition: define.h:566
DTK_FRAME_TYPE_NONE
@ DTK_FRAME_TYPE_NONE
Definition: util_draw_dtk.hpp:127
DTK_TYPE_REFERENCE_AXIS_SYSTEM
@ DTK_TYPE_REFERENCE_AXIS_SYSTEM
Definition: define.h:592
Dtk_Dimension::AngularDimension
@ AngularDimension
Definition: util_draw_dtk.hpp:4537
Dtk_feat_hole::GetCounterDepth
Dtk_Double64 GetCounterDepth() const
Definition: str_feat_dtk.hpp:1868
DTK_TYPE_CC_DESIGN_DATE_AND_TIME_ASSIGNMENT
@ DTK_TYPE_CC_DESIGN_DATE_AND_TIME_ASSIGNMENT
Definition: define.h:183
DTK_TYPE_AREA_MEASURE
@ DTK_TYPE_AREA_MEASURE
Definition: define.h:196
DTK_TYPE_LOOP
@ DTK_TYPE_LOOP
Definition: define.h:125
Dtk_ToleranceSpecificationContainer::TypeParallelism
@ TypeParallelism
Definition: util_draw_dtk.hpp:5717
DTK_TYPE_VOLUME_MEASURE
@ DTK_TYPE_VOLUME_MEASURE
Definition: define.h:197
DTK_KIN_TYPE_JOINT
@ DTK_KIN_TYPE_JOINT
Definition: util_kinematics_dtk.hpp:109
Dtk_KinJoint::getType
JOINT_TYPE getType()
Returns the joint type.
DTK_TYPE_TOPOLOGICAL_REPRESENTATION_ITEM
@ DTK_TYPE_TOPOLOGICAL_REPRESENTATION_ITEM
Definition: define.h:158
DTK_TYPE_AXIS2_PLACEMENT
@ DTK_TYPE_AXIS2_PLACEMENT
Definition: define.h:33
DTK_TYPE_ANNOTATION_SUBFIGURE_OCCURRENCE
@ DTK_TYPE_ANNOTATION_SUBFIGURE_OCCURRENCE
Definition: define.h:375
Dtk_Camera::OriginPoint
const Dtk_pnt & OriginPoint() const
Retrieves the origin point - read only -.
DTK_TYPE_POINT_ON_SURFACE
@ DTK_TYPE_POINT_ON_SURFACE
Definition: define.h:40
Dtk_DumpXml_Dtk_Text_DTK_Text_type
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Text_DTK_Text_type(FILE *F, const DTK_Text_type &D)
Definition: util_xml_dtk.cpp:980
Dtk_SmartPtr
Definition: util_ptr_dtk.hpp:37
Dtk_DumpXml_Dtk_Frame
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Frame(FILE *F, const Dtk_Frame &T)
Definition: util_xml_dtk.cpp:1200
Dtk_Welding::SymbolKGrooveWeld
@ SymbolKGrooveWeld
Definition: util_draw_dtk.hpp:2861
Dtk_Region::UnknownType
@ UnknownType
Definition: util_draw_dtk.hpp:7461
Dtk_feat_hole::GetBottomAngleTolerance
Dtk_feat_tolerance_set * GetBottomAngleTolerance() const
Definition: str_feat_dtk.hpp:1805
Dtk_DumpXml_Dtk_DimensionPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DimensionPtr(FILE *F, const Dtk_DimensionPtr &D)
Definition: util_xml_dtk.cpp:1425
DTK_TYPE_BEZIER_CURVE
@ DTK_TYPE_BEZIER_CURVE
Definition: define.h:59
DTK_TYPE_PRODUCT_DEFINITION_USAGE
@ DTK_TYPE_PRODUCT_DEFINITION_USAGE
Definition: define.h:233
DTK_TYPE_SYMBOL_STYLE_SELECT
@ DTK_TYPE_SYMBOL_STYLE_SELECT
Definition: define.h:356
Dtk_Grid::None
@ None
Definition: util_draw_dtk.hpp:4317
DTK_PICTURE_OLE
@ DTK_PICTURE_OLE
Definition: dtk_picture.hpp:33
Dtk_Leader::ArrowHead::GetInfo
const Dtk_InfoPtr & GetInfo() const
Definition: util_draw_dtk.hpp:2034
DTK_FRAME_TYPE_ELLIPSE
@ DTK_FRAME_TYPE_ELLIPSE
Definition: util_draw_dtk.hpp:153
DTK_UNKNOWN
@ DTK_UNKNOWN
Definition: util_draw_dtk.hpp:66
DTK_FRAME_TYPE_PARALLELOGRAM
@ DTK_FRAME_TYPE_PARALLELOGRAM
Definition: util_draw_dtk.hpp:168
DTK_TYPE_UNCERTAINTY_MEASURE_WITH_UNIT
@ DTK_TYPE_UNCERTAINTY_MEASURE_WITH_UNIT
Definition: define.h:206
Dtk_string::is_NULL
Dtk_bool is_NULL() const
DTK_TYPE_B_SPLINE_CURVE_WITH_KNOTS
@ DTK_TYPE_B_SPLINE_CURVE_WITH_KNOTS
Definition: define.h:60
Dtk_TextStyle::JustificationNone
@ JustificationNone
Definition: util_draw_dtk.hpp:286
DTK_TYPE_PRODUCT_CONCEPT_CONTEXT
@ DTK_TYPE_PRODUCT_CONCEPT_CONTEXT
Definition: define.h:218
Dtk_feat_hole::GetTypeAsString
Dtk_string GetTypeAsString() const
Dtk_feat_hole::IsReliefActived
Dtk_Int32 IsReliefActived() const
test if relief is activated , only relief or neck can be activated not both
Definition: str_feat_dtk.hpp:1944
DTK_ANCHOR_MIDDLE_LEFT
@ DTK_ANCHOR_MIDDLE_LEFT
Definition: util_draw_dtk.hpp:96
Dtk_DumpXml_Dtk_HatchingPattern
Dtk_ErrorStatus Dtk_DumpXml_Dtk_HatchingPattern(FILE *F, const Dtk_HatchingPattern &D)
Definition: util_xml_dtk.cpp:2179
Dtk_transfo::getScale
const double & getScale() const
Retrieves the scale factor.
DTK_TYPE_LEADER_CURVE
@ DTK_TYPE_LEADER_CURVE
Definition: define.h:341
Dtk_HatchingStyle_Dotting
@ Dtk_HatchingStyle_Dotting
Definition: util_draw_dtk.hpp:7140
validate_xml_string
Dtk_status validate_xml_string(Dtk_string &inputString)
Definition: util_xml_dtk.cpp:638
DTK_TYPE_FDT_SET_FDT_INFOS
@ DTK_TYPE_FDT_SET_FDT_INFOS
Definition: define.h:452
DTK_TYPE_GEOMETRIC_CURVE_SET
@ DTK_TYPE_GEOMETRIC_CURVE_SET
Definition: define.h:111
Dtk_feat_limit::type
LIMIT_TYPE type
Definition: str_feat_dtk.hpp:633
SIMPLE
@ SIMPLE
Definition: str_feat_dtk.hpp:106
dtk_text_type_roughness_text2
@ dtk_text_type_roughness_text2
Definition: str_def.h:27
Dtk_DatumTarget::NonMovable
@ NonMovable
Definition: util_draw_dtk.hpp:3580
Dtk_Component::ComponentInternal
@ ComponentInternal
Definition: dtk_maindoc.hpp:564
catiav5w::NodeType
NodeType
Type of Specification Tree Node used into a CATPart file.
Definition: catiav5w.hpp:409
VdaReaderModule
@ VdaReaderModule
Definition: dtk_maindoc.hpp:32
Dtk_TextStyle::CharSpacing
Dtk_Double64 & CharSpacing()
Retrieves the char spacing - get/set -.
DTK_TYPE_SHELL_BASED_WIREFRAME_REPRESENTATION
@ DTK_TYPE_SHELL_BASED_WIREFRAME_REPRESENTATION
Definition: define.h:140
Dtk_ModelDisplay::SectionParallelePlane
@ SectionParallelePlane
Definition: util_ent_dtk.hpp:995
DTK_PICTURE_ICO
@ DTK_PICTURE_ICO
Definition: dtk_picture.hpp:30
Dtk_Val::GetPnt
Dtk_pnt GetPnt(Dtk_status &st=Dtk_status::GetDefaultStatus()) const
DTK_TYPE_PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE
@ DTK_TYPE_PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE
Definition: define.h:267
Dtk_string::c_str
const char * c_str() const
Retrieve the ASCII conversion string.
Dtk_feat_axis::IsReversed
Dtk_bool IsReversed() const
Definition: str_feat_dtk.hpp:592
DTK_TYPE_APPROVAL_ASSIGNMENT
@ DTK_TYPE_APPROVAL_ASSIGNMENT
Definition: define.h:303
Dtk_Welding::SymbolStickWeld
@ SymbolStickWeld
Definition: util_draw_dtk.hpp:2835
DTK_TYPE_REFERENCE_AXIS
@ DTK_TYPE_REFERENCE_AXIS
Definition: define.h:593
DTK_TYPE_PARAMETRIC_CURVE
@ DTK_TYPE_PARAMETRIC_CURVE
Definition: define.h:67
DTK_TYPE_EDGE_CURVE
@ DTK_TYPE_EDGE_CURVE
Definition: define.h:117
Dtk_mesh_face::get_nbsubinfos
Dtk_Size_t get_nbsubinfos() const
Dtk_RGB::IsFilled
bool IsFilled() const
Definition: dtk_rgb.hpp:34
DTK_TYPE_MASS_UNIT
@ DTK_TYPE_MASS_UNIT
Definition: define.h:208
DTK_TYPE_QUANTIFIED_ASSEMBLY_COMPONENT_USAGE
@ DTK_TYPE_QUANTIFIED_ASSEMBLY_COMPONENT_USAGE
Definition: define.h:234
DTK_TYPE_GEOMETRIC_SET_SELECT
@ DTK_TYPE_GEOMETRIC_SET_SELECT
Definition: define.h:114
DTK_Text_subtype::IsLowerFrac
Dtk_bool IsLowerFrac() const
Tell if the associated Dtk_text is part of Lower Fraction group - into Dtk_Dimension -.
DTK_TYPE_DATE_STEP
@ DTK_TYPE_DATE_STEP
Definition: define.h:174
DTK_TYPE_CSG_SOLID
@ DTK_TYPE_CSG_SOLID
Definition: define.h:408
Dtk_API::GetNumPhysicalMaterialInfosInTable
Dtk_Size_t GetNumPhysicalMaterialInfosInTable() const
Dtk_feat_hole::HasBottomAngleTolerance
Dtk_bool HasBottomAngleTolerance() const
Definition: str_feat_dtk.hpp:1815
Dtk_KinJoint::getPart1
Dtk_KinPartPtr getPart1()
Returns the first part associated at the joint.
Dtk_feat_pattern::row1
int row1
Definition: str_feat_dtk.hpp:3292
DTK_TYPE_ALTERNATE_PRODUCT_RELATIONSHIP
@ DTK_TYPE_ALTERNATE_PRODUCT_RELATIONSHIP
Definition: define.h:299
DTK_TYPE_DOCUMENT
@ DTK_TYPE_DOCUMENT
Definition: define.h:500
DTK_TYPE_VOLUME_UNIT
@ DTK_TYPE_VOLUME_UNIT
Definition: define.h:212
DTK_Text_subtype::IsFractionBar
Dtk_bool IsFractionBar() const
Tell if the associated Dtk_text is a fraction bar group - into Dtk_Dimension -.
DTK_TYPE_FDT_CAPTURE
@ DTK_TYPE_FDT_CAPTURE
Definition: define.h:440
Dtk_ToleranceSpecificationContainer::TypeSurfaceProfile
@ TypeSurfaceProfile
Definition: util_draw_dtk.hpp:5711
DTK_TYPE_PRODUCT_CATEGORY_RELATIONSHIP
@ DTK_TYPE_PRODUCT_CATEGORY_RELATIONSHIP
Definition: define.h:297
TAPERED
@ TAPERED
Definition: str_feat_dtk.hpp:107
DTK_TYPE_CC_DESIGN_SPECIFICATION_REFERENCE
@ DTK_TYPE_CC_DESIGN_SPECIFICATION_REFERENCE
Definition: define.h:329
Dtk_RGB::B
int & B()
Definition: dtk_rgb.hpp:42
DTK_Text_subtype::IsTolRightParenthesis
Dtk_bool IsTolRightParenthesis() const
Tell if the associated Dtk_text is part of Tolerance Right Parenthesis group - into Dtk_Dimension -.
Dtk_Camera::Angle
Dtk_Double64 Angle() const
Definition: util_draw_dtk.hpp:7094
DTK_TYPE_RATIONAL_B_SPLINE_SURFACE
@ DTK_TYPE_RATIONAL_B_SPLINE_SURFACE
Definition: define.h:103
dtk_text_type_modifier
@ dtk_text_type_modifier
Definition: str_def.h:21
DTK_TYPE_VOLUME
@ DTK_TYPE_VOLUME
Definition: define.h:483
Dtk_ViewDisplay::ShadingWithEdgeDisplay
@ ShadingWithEdgeDisplay
Definition: util_draw_dtk.hpp:6461
DTK_FRAME_TYPE_NOTA
@ DTK_FRAME_TYPE_NOTA
Definition: util_draw_dtk.hpp:160
Dtk_Val::GetString
Dtk_string GetString(Dtk_status &st=Dtk_status::GetDefaultStatus()) const
Dtk_Roughness::ApplyToSpecifiedSurface
@ ApplyToSpecifiedSurface
Definition: util_draw_dtk.hpp:2441
Dtk_KinJoint::_PART3
Dtk_string _PART3
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:955
Dtk_PhysicalMaterialInfos::GetTypeAsString
Dtk_string GetTypeAsString() const
Returns the material type as a Dtk_string.
Dtk_KinJoint::_ABSOLUT_POS2
Dtk_string _ABSOLUT_POS2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:940
Dtk_OneCell::GetBorderRightColor
const Dtk_RGB & GetBorderRightColor() const
Gets BorderRightColor of Right border.
DumpTransfo
void DumpTransfo(FILE *inFile, Dtk_transfo transfo)
DTK_TYPE_POSITIVE_LENGTH_MEASURE
@ DTK_TYPE_POSITIVE_LENGTH_MEASURE
Definition: define.h:201
Dtk_string::left_exclusive
Dtk_string left_exclusive(int pos) const
retrieve the left part of the Dtk_string from a position
DTK_TYPE_B_SPLINE_CURVE
@ DTK_TYPE_B_SPLINE_CURVE
Definition: define.h:63
Dtk_pnt
This is a mathematical point class.
Definition: dtk_pnt.hpp:20
DTK_TYPE_CLASSIFIED_ITEM
@ DTK_TYPE_CLASSIFIED_ITEM
Definition: define.h:260
Dtk_KinJoint::getConnector
Dtk_KinConnectorPtr getConnector(Dtk_Size_t inPosition)
Returns Connector at position inPosition.
DTK_TYPE_TABLE_ANNOTATION
@ DTK_TYPE_TABLE_ANNOTATION
Definition: define.h:429
w_str
#define w_str
Definition: dtk_string.hpp:30
type_detk
type_detk
Definition: define.h:21
Dtk_Component::ComponentPhantom
@ ComponentPhantom
Definition: dtk_maindoc.hpp:565
DTK_TYPE_LENGTH_MEASURE_WITH_UNIT
@ DTK_TYPE_LENGTH_MEASURE_WITH_UNIT
Definition: define.h:185
DTK_TYPE_TRANSFORMED_SURFACE
@ DTK_TYPE_TRANSFORMED_SURFACE
Definition: define.h:490
Dtk_KinJoint::getPart3
Dtk_KinPartPtr getPart3()
Returns the third part associated at the joint.
Dtk_feat::GetThread
Dtk_feat_thread * GetThread() const
Definition: str_feat_dtk.hpp:7106
Dtk_DumpXml_Dtk_ComponentPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr(FILE *F, const Dtk_ComponentPtr &inObject)
Definition: util_xml_dtk.cpp:4844
DTK_TYPE_TEXT_STYLE_WITH_MIRROR
@ DTK_TYPE_TEXT_STYLE_WITH_MIRROR
Definition: define.h:397
DTK_TYPE_PRODUCT_DEFINITION_FORMATION
@ DTK_TYPE_PRODUCT_DEFINITION_FORMATION
Definition: define.h:266
DTK_TYPE_NEXT_ASSEMBLY_USAGE_OCCURENCE
@ DTK_TYPE_NEXT_ASSEMBLY_USAGE_OCCURENCE
Definition: define.h:230
DTK_TYPE_CYLINDRICAL_SURFACE
@ DTK_TYPE_CYLINDRICAL_SURFACE
Definition: define.h:84
Dtk_Dimension::LinearDimension
@ LinearDimension
Definition: util_draw_dtk.hpp:4535
Dtk_Welding::SymbolFlareVButtWeld
@ SymbolFlareVButtWeld
Definition: util_draw_dtk.hpp:2805
DTK_TYPE_PERSON_ORGANIZATION_ITEM
@ DTK_TYPE_PERSON_ORGANIZATION_ITEM
Definition: define.h:261
DTK_TYPE_ITEM_DEFINED_TRANSFORMATION
@ DTK_TYPE_ITEM_DEFINED_TRANSFORMATION
Definition: define.h:322
Dtk_Val::GetDir
Dtk_dir GetDir(Dtk_status &st=Dtk_status::GetDefaultStatus()) const
DTK_TYPE_MEASURE_PROPERTIES
@ DTK_TYPE_MEASURE_PROPERTIES
Definition: define.h:527
Dtk_Welding::ComplementarySymbolFilletWeldWithSmoothBlendedFace
@ ComplementarySymbolFilletWeldWithSmoothBlendedFace
Definition: util_draw_dtk.hpp:2918
DTK_Text_subtype::IsTolValPart
Dtk_bool IsTolValPart() const
Tell if the associated Dtk_text is part of Tolerance Value group - into Dtk_Dimension -.
DTK_TYPE_APPROVAL
@ DTK_TYPE_APPROVAL
Definition: define.h:313
DTK_TYPE_WIRE_SHELL
@ DTK_TYPE_WIRE_SHELL
Definition: define.h:134
Dtk_feat_hole::IsThreaded
Dtk_bool IsThreaded() const
Definition: str_feat_dtk.hpp:1689
DTK_TYPE_SINGLE_PARAMETER_CONSTRAINT
@ DTK_TYPE_SINGLE_PARAMETER_CONSTRAINT
Definition: define.h:68
DTK_TYPE_LEADER_TERMINATOR
@ DTK_TYPE_LEADER_TERMINATOR
Definition: define.h:346
Dtk_CompositeText
This is the composite text class. It's basically a Dtk_Text Container. This class represents a group ...
Definition: util_draw_dtk.hpp:1445
Dtk_feat_limit::GetRefenceObject
Dtk_feat_geometry * GetRefenceObject() const
Definition: str_feat_dtk.hpp:669
Dtk_FCFFeatureIndicatorType::OrientationPlane
@ OrientationPlane
Definition: util_draw_dtk.hpp:5476
Dtk_API::GetCurveLineTypeDefinitionInTable
Dtk_LineTypeDefinitionPtr GetCurveLineTypeDefinitionInTable(const Dtk_ID inId) const
Dtk_ModelDisplay::SectionTypeEnum
SectionTypeEnum
Definition: util_ent_dtk.hpp:992
Dtk_FontLineType
Dtk_FontLineType
This is a set of line styles.
Definition: util_ent_dtk.hpp:46
Dtk_Welding::SymbolSingleBevelButtWeld
@ SymbolSingleBevelButtWeld
Definition: util_draw_dtk.hpp:2803
Dtk_ToleranceSpecificationContainer::TypeCircularity
@ TypeCircularity
Definition: util_draw_dtk.hpp:5705
DTK_TYPE_CHANGE_REQUEST_ITEM
@ DTK_TYPE_CHANGE_REQUEST_ITEM
Definition: define.h:224
DTK_TYPE_CATIA_V5
@ DTK_TYPE_CATIA_V5
Definition: define.h:22
Dtk_TextStyle::AttributeOverline
@ AttributeOverline
Definition: util_draw_dtk.hpp:273
Dtk_TextStyle::JustificationRight
@ JustificationRight
Definition: util_draw_dtk.hpp:285
Dtk_DumpXml_ConstraintOrientationEnum
void Dtk_DumpXml_ConstraintOrientationEnum(FILE *F, const Dtk_Constraint::ConstraintOrientationTypeEnum &inEnum)
Definition: util_xml_dtk.cpp:8562
DTK_TYPE_SUBFACE
@ DTK_TYPE_SUBFACE
Definition: define.h:131
Dtk_DumpXml_Dtk_CompositeEntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CompositeEntityPtr(FILE *F, const Dtk_CompositeEntityPtr &D)
Definition: util_xml_dtk.cpp:2479
Dtk_feat_limit::UP_THRU_NEXT_LIMIT
@ UP_THRU_NEXT_LIMIT
Definition: str_feat_dtk.hpp:626
DTK_TYPE_PRESENTATION_STYLE_ASSIGNMENT
@ DTK_TYPE_PRESENTATION_STYLE_ASSIGNMENT
Definition: define.h:373
Dtk_feat_inner_thread::GetLimitReference
Dtk_feat_geometry * GetLimitReference() const
Definition: str_feat_dtk.hpp:1443
DTK_TYPE_REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION
@ DTK_TYPE_REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION
Definition: define.h:276
DTK_TYPE_TEXT
@ DTK_TYPE_TEXT
Definition: define.h:425
IND_DEPTH
#define IND_DEPTH
Definition: str_feat_dtk.hpp:26
DTK_TYPE_HELIX
@ DTK_TYPE_HELIX
Definition: define.h:54
DTK_TYPE_BOXED_HALF_SPACE
@ DTK_TYPE_BOXED_HALF_SPACE
Definition: define.h:414
Dtk_ToleranceSpecificationContainer::TypeConcentricity
@ TypeConcentricity
Definition: util_draw_dtk.hpp:5721
Dtk_DumpXml_Dtk_KinematicsCommand
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCommand(FILE *inFile, const Dtk_KinCommandPtr &inCommand, Dtk_bool simplified)
Definition: util_xml_dtk.cpp:7684
Dtk_PhysicalMaterialInfos::GetPoissonRatio
Dtk_ErrorStatus GetPoissonRatio(Dtk_Double64 outPoissonRatio[3]) const
Returns the material poisson ratio.
Dtk_feat::GetType
DTK_FEATURE_TYPE GetType() const
Definition: str_feat_dtk.hpp:7013
Dtk_Info::ListAllAttributes
Dtk_ErrorStatus ListAllAttributes(Dtk_tab< Dtk_string > &tab_keys) const
DTK_TYPE_PATH
@ DTK_TYPE_PATH
Definition: define.h:149
Dtk_Frame
This is the frame class. It's used to gather all frame information.
Definition: util_draw_dtk.hpp:855
Dtk_Dimension::DiameterDimension
@ DiameterDimension
Definition: util_draw_dtk.hpp:4541
Dtk_Text::GetFrame
void GetFrame(Dtk_Frame &outFrame) const
Retrieves the Frame - read only -.
Dtk_View::SectionView
@ SectionView
Definition: util_draw_dtk.hpp:6565
Dtk_Leader::ArrowHead
This class graphically represents a leader head.
Definition: util_draw_dtk.hpp:1956
Dtk_DumpXml_Dtk_ReferenceFramePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceFramePtr(FILE *F, const Dtk_ReferenceFramePtr &D)
Definition: util_xml_dtk.cpp:2584
DTK_Text_subtype::IsTolPrefix
Dtk_bool IsTolPrefix() const
Tell if the associated Dtk_text is part of Tolerance Prefix group - into Dtk_Dimension -.
DTK_TYPE_ORIENTED_PATH
@ DTK_TYPE_ORIENTED_PATH
Definition: define.h:147
Dtk_ModelDisplay::SectionBody
@ SectionBody
Definition: util_ent_dtk.hpp:997
Dtk_mesh_face::get_nbtriangles
Dtk_Size_t get_nbtriangles() const
Get the number of simple triangles kept in the class instance.
Dtk_feat_thread::HasSupportDepthTolerance
Dtk_bool HasSupportDepthTolerance() const
Definition: str_feat_dtk.hpp:1536
Dtk_Node::NodeDataTypeEnumToString
static Dtk_string NodeDataTypeEnumToString(const NodeDataTypeEnum &inEnum)
Definition: dtk_maindoc.hpp:290
DTK_TYPE_CONFIGURATION_EFFECTIVITY
@ DTK_TYPE_CONFIGURATION_EFFECTIVITY
Definition: define.h:241
DTK_TYPE_REPRESENTATION_ITEM
@ DTK_TYPE_REPRESENTATION_ITEM
Definition: define.h:270
DTK_TYPE_ENTITY_LINK
@ DTK_TYPE_ENTITY_LINK
Definition: define.h:511
DTK_TYPE_KIN_CURVE
@ DTK_TYPE_KIN_CURVE
Definition: define.h:545
DTK_TYPE_DEFINITIONAL_REPRESENTATION
@ DTK_TYPE_DEFINITIONAL_REPRESENTATION
Definition: define.h:274
DTK_Text_subtype::IsValSplitPart3
Dtk_bool IsValSplitPart3() const
Tell if the associated Dtk_text is part of Value Split Part 3 - for Degrees/Minutes/Seconds form - gr...
Dtk_DumpXml_Dtk_RenderInfos
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RenderInfos(FILE *F, const Dtk_RenderInfosPtr &inRender)
Definition: util_xml_dtk.cpp:3709
Dtk_PhysicalMaterialInfos::GetYoungModulus
Dtk_ErrorStatus GetYoungModulus(Dtk_Double64 outYoungModulus[3], Dtk_string &outUnits) const
Returns the material young modulus.
Dtk_LineTypeDefinition::DTK_LINE_TYPE_PATTERN_DESCRIPTOR_DOT
@ DTK_LINE_TYPE_PATTERN_DESCRIPTOR_DOT
Definition: dtk_line_type_definition.hpp:29
dtk_text_type_text_add_bottom
@ dtk_text_type_text_add_bottom
Definition: str_def.h:38
Dtk_Roughness::ModeWithAngles
@ ModeWithAngles
Definition: util_draw_dtk.hpp:2461
Dtk_ViewDisplay::WithHiddenDisplay
@ WithHiddenDisplay
Definition: util_draw_dtk.hpp:6455
Dtk_feat_inner_thread::GetDiameterTolerance
Dtk_feat_tolerance_set * GetDiameterTolerance() const
Definition: str_feat_dtk.hpp:1308
Dtk_KinMechanism
Dtk_KinMechanism represents a kinematic mechanism.
Definition: util_kinematics_dtk.hpp:1618
Dtk_DumpXml_Dtk_HatchingPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_HatchingPtr(FILE *F, const Dtk_HatchingPtr &D)
Definition: util_xml_dtk.cpp:2196
DTK_TYPE_CONNECTOR
@ DTK_TYPE_CONNECTOR
Definition: define.h:472
DtkReaderTypeEnumToString
Dtk_string DtkReaderTypeEnumToString(const DtkReaderType &inReaderTypeEnum)
Definition: util_xml_dtk.cpp:718
DTK_TYPE_COMPONENT
@ DTK_TYPE_COMPONENT
Definition: define.h:503
Dtk_NodeConnector::GetRenderId
Dtk_ID GetRenderId() const
Retrieves the Render Id for ForceRender connectors.
Dtk_Welding::SymbolSingleUButtWeld
@ SymbolSingleUButtWeld
Definition: util_draw_dtk.hpp:2809
Dtk_Text::GetOuterBoundingBox
const Dtk_Oriented2dBBox & GetOuterBoundingBox() const
Processes the outer bounding box.
dtk_text_type_text_add
@ dtk_text_type_text_add
Definition: str_def.h:20
Dtk_Boundary::GetExactRepresentation
dtk::Span< Dtk_CurvePtr > GetExactRepresentation() const
Retrieves all curves linked together that makes a boundary.
Dtk_feat_inner_thread::HasDepthTolerance
Dtk_bool HasDepthTolerance() const
Definition: str_feat_dtk.hpp:1349
DTK_TYPE_TABLE
@ DTK_TYPE_TABLE
Definition: define.h:480
Dtk_Leader::ArrowHead::GetDirections
void GetDirections(Dtk_dir &outRefDir, Dtk_dir &outAxisDir) const
Definition: util_draw_dtk.hpp:2040
Dtk_Camera::TargetPoint
const Dtk_pnt & TargetPoint() const
Retrieves the target point - read only -.
Dtk_Welding::SymbolSpotWeld
@ SymbolSpotWeld
Definition: util_draw_dtk.hpp:2815
Dtk_Camera::GetZoomFitMode
const Dtk_Camera::ZoomFitModeEnum & GetZoomFitMode() const
Retrieves the zoom fit mode - read only -.
DTK_TYPE_DRAUGHTING_CALLOUT_ELEMENT
@ DTK_TYPE_DRAUGHTING_CALLOUT_ELEMENT
Definition: define.h:381
Dtk_feat_inner_thread::GetPitch
Dtk_Double64 GetPitch() const
Definition: str_feat_dtk.hpp:1358
DTK_TYPE_SHAPE_DEFINITION_REPRESENTATION
@ DTK_TYPE_SHAPE_DEFINITION_REPRESENTATION
Definition: define.h:290
DTK_TYPE_SERIAL_NUMBERED_EFFECTIVITY
@ DTK_TYPE_SERIAL_NUMBERED_EFFECTIVITY
Definition: define.h:237
DTK_TYPE_ASSOCIATIVE_CURVE_DIMENSION
@ DTK_TYPE_ASSOCIATIVE_CURVE_DIMENSION
Definition: define.h:419
DTK_Text_subtype::IsTolLowerTol
Dtk_bool IsTolLowerTol() const
Tell if the associated Dtk_text is part of Tolerance Lower Value group - into Dtk_Dimension -.
DTK_TYPE_RADIUS_DIMENSION
@ DTK_TYPE_RADIUS_DIMENSION
Definition: define.h:386
DTK_PICTURE_JPG
@ DTK_PICTURE_JPG
Definition: dtk_picture.hpp:24
DTK_TYPE_EDGE
@ DTK_TYPE_EDGE
Definition: define.h:119
Dtk_Roughness::ModeCircular
@ ModeCircular
Definition: util_draw_dtk.hpp:2455
DTK_NO_PATTERN
@ DTK_NO_PATTERN
Definition: util_ent_dtk.hpp:47
DTK_TYPE_TEXT_STYLE_FOR_DEFINED_FONT
@ DTK_TYPE_TEXT_STYLE_FOR_DEFINED_FONT
Definition: define.h:357
DTK_FEAT_HOLE
@ DTK_FEAT_HOLE
Definition: str_feat_dtk.hpp:299
DTK_TYPE_MATERIAL_LIBRARY
@ DTK_TYPE_MATERIAL_LIBRARY
Definition: define.h:517
Dtk_API::GetRenderInfosInTable
Dtk_RenderInfosPtr GetRenderInfosInTable(Dtk_ID inId) const
DTK_TYPE_2D_ENTITY
@ DTK_TYPE_2D_ENTITY
Definition: define.h:462
Dtk_Val::GetDouble
double GetDouble(Dtk_status &st=Dtk_status::GetDefaultStatus()) const
DTK_TYPE_HATCHING
@ DTK_TYPE_HATCHING
Definition: define.h:549
Dtk_Welding::SymbolSingleJButtWeld
@ SymbolSingleJButtWeld
Definition: util_draw_dtk.hpp:2811
Dtk_feat_thread::GetSupportDiameterTolerance
Dtk_feat_tolerance_set * GetSupportDiameterTolerance() const
Definition: str_feat_dtk.hpp:1556
DTK_TYPE_ORIENTED_OPEN_SHELL
@ DTK_TYPE_ORIENTED_OPEN_SHELL
Definition: define.h:136
Dtk_TextStyle::CharHeight
Dtk_Double64 & CharHeight()
Retrieves the char height - get/set -.
DTK_LONG_DASHED
@ DTK_LONG_DASHED
Definition: util_ent_dtk.hpp:59
DTK_TYPE_FILL_AREA_STYLE_COLOUR
@ DTK_TYPE_FILL_AREA_STYLE_COLOUR
Definition: define.h:369
DTK_TYPE_KIN_NAMED_VALUE
@ DTK_TYPE_KIN_NAMED_VALUE
Definition: define.h:536
Dtk_Frame::CreateGeometries
Dtk_ErrorStatus CreateGeometries(Dtk_tab< Dtk_CurvePtr > &outGeoms) const
Process Related geometries.
Dtk_tab
This is a high level array class.
Definition: util_stl_dtk.hpp:84
dtk_text_type_roughness_type
@ dtk_text_type_roughness_type
Definition: str_def.h:33
Dtk_OneCell::GetBorderBottomBlanked
Dtk_Int32 GetBorderBottomBlanked() const
Gets BorderBottomBlanked of Bottom border.
DTK_TYPE_PARAMETRIC_REPRESENTATION_CONTEXT
@ DTK_TYPE_PARAMETRIC_REPRESENTATION_CONTEXT
Definition: define.h:271
DTK_TYPE_FILLET_SURFACE
@ DTK_TYPE_FILLET_SURFACE
Definition: define.h:107
Dtk_feat::name
Dtk_string name
Definition: str_feat_dtk.hpp:6884
Dtk_DumpXml_Dtk_ReferenceBlockPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceBlockPtr(FILE *F, const Dtk_ReferenceBlockPtr &D)
Definition: util_xml_dtk.cpp:2566
DTK_TYPE_ORIENTED_EDGE
@ DTK_TYPE_ORIENTED_EDGE
Definition: define.h:118
Dtk_KinParameter::hasAttribute
Dtk_bool hasAttribute(Dtk_string inAttributeName)
Test if an attribute name belong at the attribute table.
Dtk_KinJoint::getJoint2
Dtk_KinJointPtr getJoint2()
Returns the second joint associated at the joint.
Dtk_LayerInfosSet::Layer::Status::Visible
@ Visible
DwgDtkReaderModule
@ DwgDtkReaderModule
Definition: dtk_maindoc.hpp:80
Dtk_tab::size
Dtk_Size_t size() const
Returns the size of the array.
Definition: util_stl_dtk.hpp:503
DTK_VAL_TYPE_INTARRAY
@ DTK_VAL_TYPE_INTARRAY
Definition: dtk_val.hpp:28
inFace
const Dtk_mesh_face * inFace
Definition: tess.h:288
DTK_TYPE_TRANSFO
@ DTK_TYPE_TRANSFO
Definition: define.h:460
Dtk_DumpXml_Dtk_OverrideInfo
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OverrideInfo(FILE *F, const Dtk_OverrideInfoPtr &inOverrideInfo)
Definition: util_xml_dtk.cpp:8700
Dtk_DumpXml_Dtk_HyperbolaPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_HyperbolaPtr(FILE *F, const Dtk_HyperbolaPtr &inCurve)
Definition: util_xml_dtk.cpp:5282
Dtk_ToleranceSpecificationContainer::TypePerpendicularity
@ TypePerpendicularity
Definition: util_draw_dtk.hpp:5715
Dtk_API::GetNumRenderInfosInTable
Dtk_Size_t GetNumRenderInfosInTable() const
DTK_TYPE_COLOUR_RGB
@ DTK_TYPE_COLOUR_RGB
Definition: define.h:352
DTK_TYPE_CALENDAR_DATE
@ DTK_TYPE_CALENDAR_DATE
Definition: define.h:171
Dtk_Dimension::BasicTypeRectangle
@ BasicTypeRectangle
Definition: util_draw_dtk.hpp:4559
Dtk_KinJoint::_JOINT1
Dtk_string _JOINT1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:964
DTK_Text_subtype::IsTolSymetricalTol
Dtk_bool IsTolSymetricalTol() const
Tell if the associated Dtk_text is part of Tolerance Symetrical Value group - into Dtk_Dimension -.
Dtk_TextStyle::AttributeNone
@ AttributeNone
Definition: util_draw_dtk.hpp:267
Dtk_HatchingStyle_Unknown
@ Dtk_HatchingStyle_Unknown
Definition: util_draw_dtk.hpp:7137
Dtk_transfo::getYdir
const Dtk_dir & getYdir() const
Return the Y vector.
dump_file
FILE * dump_file
Definition: util_xml_dtk.cpp:58
DTK_NOERROR
@ DTK_NOERROR
Definition: dtk_status.hpp:10
DTK_TYPE_SURFACE_MODEL
@ DTK_TYPE_SURFACE_MODEL
Definition: define.h:145
Dtk_Grid::Always
@ Always
Definition: util_draw_dtk.hpp:4319
DTK_TYPE_ELLIPSE
@ DTK_TYPE_ELLIPSE
Definition: define.h:50
Dtk_DumpXml_Dtk_ShellPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ShellPtr(FILE *F, const Dtk_ShellPtr &inShell)
Definition: util_xml_dtk.cpp:6646
DTK_TYPE_EVALUATED_DEGENERATE_PCURVE
@ DTK_TYPE_EVALUATED_DEGENERATE_PCURVE
Definition: define.h:42
DTK_TYPE_CONSTRAINT
@ DTK_TYPE_CONSTRAINT
Definition: define.h:599
Dtk_string::right_exclusive
Dtk_string right_exclusive(int pos) const
retrieve the right part of the Dtk_string from a position
Dtk_DumpXml_Dtk_TransformedSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_TransformedSurfacePtr(FILE *F, const Dtk_TransformedSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6354
DTK_FRAME_TYPE_SYMMETRICAL_PART
@ DTK_FRAME_TYPE_SYMMETRICAL_PART
Definition: util_draw_dtk.hpp:162
Dtk_Roughness::ModeRadial
@ ModeRadial
Definition: util_draw_dtk.hpp:2457
DTK_TYPE_SI_UNIT
@ DTK_TYPE_SI_UNIT
Definition: define.h:205
Dtk_CompositeText::GetInfo
const Dtk_InfoPtr & GetInfo() const
Retrieves the infos.
Dtk_DumpXml_Dtk_Dimension_BasicDimensionType
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Dimension_BasicDimensionType(FILE *F, const Dtk_Dimension::BasicDimensionTypeEnum &D)
Definition: util_xml_dtk.cpp:1349
Dtk_KinJoint::getConstraintSize
Dtk_Size_t getConstraintSize()
Return the attribute tab size.
dtk_text_type_roughness_text5
@ dtk_text_type_roughness_text5
Definition: str_def.h:30
Dtk_DumpXml_Dtk_MetadataGroupPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataGroupPtr(FILE *F, const Dtk_MetaDataGroupPtr &inObject)
Definition: util_xml_dtk.cpp:5098
DTK_TYPE_B_SPLINE_SURFACE_WITH_KNOTS
@ DTK_TYPE_B_SPLINE_SURFACE_WITH_KNOTS
Definition: define.h:99
DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR_2D
@ DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR_2D
Definition: define.h:36
DTK_TYPE_DIRECTED_ACTION
@ DTK_TYPE_DIRECTED_ACTION
Definition: define.h:250
Dtk_Constraint::_ConstraintValue::_ValueLower
Dtk_Double64 _ValueLower
Definition: util_ent_dtk.hpp:1221
DTK_TYPE_CURVE_STYLE_FONT_SELECT
@ DTK_TYPE_CURVE_STYLE_FONT_SELECT
Definition: define.h:360
Dtk_HatchingPattern::Pitch
Dtk_Double64 & Pitch()
CgmReaderModule
@ CgmReaderModule
Definition: dtk_maindoc.hpp:70
DTK_TYPE_DATE_TIME_SELECT
@ DTK_TYPE_DATE_TIME_SELECT
Definition: define.h:179
Dtk_NodeConnector::GetReasonLink
Dtk_NodeConnector::ReasonLinkEnum GetReasonLink(ReasonCategoryEnum &outReasonCategory) const
Gets the Reason Link of the Dtk_NodeConnector to specify the reason of the connection.
DTK_TYPE_FILL_AREA_STYLE_TILE_SHAPE_SELECT
@ DTK_TYPE_FILL_AREA_STYLE_TILE_SHAPE_SELECT
Definition: define.h:367
Dtk_Welding::SymbolBackWeld
@ SymbolBackWeld
Definition: util_draw_dtk.hpp:2817
DTK_TYPE_MAX_ENTITY
@ DTK_TYPE_MAX_ENTITY
Definition: define.h:621
Dtk_feat_hole::GetDepthTolerance
Dtk_feat_tolerance_set * GetDepthTolerance() const
Definition: str_feat_dtk.hpp:1773
DTK_Text_subtype::IsSuffix
Dtk_bool IsSuffix() const
Tell if the associated Dtk_text is part of Suffix group - into Dtk_Dimension -.
Dtk_DumpXml_Dtk_bool
Dtk_ErrorStatus Dtk_DumpXml_Dtk_bool(FILE *F, const Dtk_bool &B)
Definition: util_xml_dtk.cpp:1272
Dtk_Leader::TypeAngular
@ TypeAngular
Definition: util_draw_dtk.hpp:2084
FbxReaderModule
@ FbxReaderModule
Definition: dtk_maindoc.hpp:69
DTK_TYPE_CERTIFICATION_ASSIGNMENT
@ DTK_TYPE_CERTIFICATION_ASSIGNMENT
Definition: define.h:302
Dtk_NodeConnector::GetNodeId
Dtk_ID GetNodeId() const
Returns the Node id referenced by the connector.
DTK_TYPE_LOCAL_TIME
@ DTK_TYPE_LOCAL_TIME
Definition: define.h:177
DTK_TYPE_OFFSET_SURFACE
@ DTK_TYPE_OFFSET_SURFACE
Definition: define.h:106
SmgReaderModule
@ SmgReaderModule
Definition: dtk_maindoc.hpp:73
Dtk_DumpXml_Dtk_KinematicsConstraint
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsConstraint(FILE *inFile, const Dtk_KinConstraintPtr &inConstraint, Dtk_bool simplified)
Definition: util_xml_dtk.cpp:7476
IfcReaderModule
@ IfcReaderModule
Definition: dtk_maindoc.hpp:64
Dtk_Val::GetRgb
Dtk_RGB GetRgb(Dtk_status &st=Dtk_status::GetDefaultStatus()) const
DTK_TYPE_NO_SUBTYPE
@ DTK_TYPE_NO_SUBTYPE
Definition: define.h:532
DTK_TYPE_ACTION_REQUEST_ASSIGNMENT
@ DTK_TYPE_ACTION_REQUEST_ASSIGNMENT
Definition: define.h:300
DTK_FRAME_TYPE_SET
@ DTK_FRAME_TYPE_SET
Definition: util_draw_dtk.hpp:156
DTK_TYPE_RULED_SURFACE
@ DTK_TYPE_RULED_SURFACE
Definition: define.h:91
Dtk_DumpXml_Dtk_roughness_roughness_applyto
Dtk_ErrorStatus Dtk_DumpXml_Dtk_roughness_roughness_applyto(FILE *F, const Dtk_Roughness::ApplyToEnum &D)
Definition: util_xml_dtk.cpp:1515
Dtk_PhysicalMaterialInfos::GetName
Dtk_string GetName() const
Returns the material name.
DTK_Text_subtype::IsDownText
Dtk_bool IsDownText() const
Tell if the associated Dtk_text is part of Down group - into Dtk_Dimension -.
dtk_text_type_undefined
@ dtk_text_type_undefined
Definition: str_def.h:25
Dtk_mesh_face::get_nbtriangle_strips
Dtk_Size_t get_nbtriangle_strips() const
Get the number of triangle strips kept in the class instance.
DTK_TYPE_PLANE_ANGLE_UNIT
@ DTK_TYPE_PLANE_ANGLE_UNIT
Definition: define.h:210
Dtk_DumpXml_Dtk_ViewPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewPtr(FILE *F, const Dtk_ViewPtr &V, const int &compact)
Definition: util_xml_dtk.cpp:2960
Dtk_DumpXml_FeatGeometry
Dtk_ErrorStatus Dtk_DumpXml_FeatGeometry(FILE *f, const Dtk_feat_geometry *inToWrite, const char *inName)
Definition: util_xml_dtk.cpp:7988
Dtk_KinJoint::getLowerLimit1
double getLowerLimit1()
Returns the lower limit 1.
Dtk_Component::PrototypeComponentType
@ PrototypeComponentType
Definition: dtk_maindoc.hpp:574
DTK_VAL_TYPE_STRING
@ DTK_VAL_TYPE_STRING
Definition: dtk_val.hpp:23
DTK_KIN_TYPE_COMMAND
@ DTK_KIN_TYPE_COMMAND
Definition: util_kinematics_dtk.hpp:110
DTK_TYPE_SOLID_MODEL
@ DTK_TYPE_SOLID_MODEL
Definition: define.h:169
DTK_TYPE_ACTION_REQUEST_STATUS
@ DTK_TYPE_ACTION_REQUEST_STATUS
Definition: define.h:248
Dtk_DumpXml_Dtk_BodyPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_BodyPtr(FILE *F, const Dtk_BodyPtr &inBody)
Definition: util_xml_dtk.cpp:6714
Dtk_OneCell::getnbCells_Left_Right
Dtk_Int32 getnbCells_Left_Right() const
Gets the Dtk_OneCell nbCells_Left_Right.
DTK_TYPE_CONTEXT_DEPENDENT_SHAPE_REPRESENTATION
@ DTK_TYPE_CONTEXT_DEPENDENT_SHAPE_REPRESENTATION
Definition: define.h:227
DTK_TYPE_DRAWING
@ DTK_TYPE_DRAWING
Definition: define.h:436
Dtk_DumpXml_ConstraintTypeEnum
void Dtk_DumpXml_ConstraintTypeEnum(FILE *F, const Dtk_Constraint::ConstraintTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:8553
DTK_TYPE_ORDERED_ACTION
@ DTK_TYPE_ORDERED_ACTION
Definition: define.h:243
DTK_TYPE_SURFACE_CURVE
@ DTK_TYPE_SURFACE_CURVE
Definition: define.h:79
Dtk_RenderInfos::GetName
Dtk_string GetName() const
Returns the texture name.
DTK_PICTURE_SVG
@ DTK_PICTURE_SVG
Definition: dtk_picture.hpp:32
Dtk_Welding::ComplementarySymbolNone
@ ComplementarySymbolNone
Definition: util_draw_dtk.hpp:2908
Dtk_feat::GetPattern
Dtk_feat_pattern * GetPattern() const
Definition: str_feat_dtk.hpp:7249
DTK_TYPE_PERSON_ORGANIZATION_SELECT
@ DTK_TYPE_PERSON_ORGANIZATION_SELECT
Definition: define.h:309
XmtReaderModule
@ XmtReaderModule
Definition: dtk_maindoc.hpp:36
Dtk_DumpXml_Dtk_roughness_rough_mode
Dtk_ErrorStatus Dtk_DumpXml_Dtk_roughness_rough_mode(FILE *F, const Dtk_Roughness::RoughModeEnum &D)
Definition: util_xml_dtk.cpp:1538
DTK_TYPE_SHAPE_ASPECT
@ DTK_TYPE_SHAPE_ASPECT
Definition: define.h:291
Dtk_picture::ScaleY
double & ScaleY()
Retrieves the Y scale factor.
Definition: dtk_picture.hpp:112
Dtk_feat_thread::HasSupportDiameterTolerance
Dtk_bool HasSupportDiameterTolerance() const
Definition: str_feat_dtk.hpp:1566
Dtk_Component::ComponentMissing
@ ComponentMissing
Definition: dtk_maindoc.hpp:562
Dtk_Grid::ParallelToView
@ ParallelToView
Definition: util_draw_dtk.hpp:4318
Dtk_DumpXml_Dtk_MeshPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshPtr(FILE *F, const Dtk_MeshPtr &inMesh)
Definition: util_xml_dtk.cpp:6855
Dtk_ModelDisplay::SectionPlaneList
@ SectionPlaneList
Definition: util_ent_dtk.hpp:994
Dtk_string::len
int len() const
Retrieve the length of the Dtk_string.
Dtk_feat_hole::GetBottomAngle
Dtk_Double64 GetBottomAngle() const
Definition: str_feat_dtk.hpp:1794
DTK_TYPE_PRE_DEFINED_SYMBOL
@ DTK_TYPE_PRE_DEFINED_SYMBOL
Definition: define.h:338
Dtk_TextStyle::Font
Dtk_Font & Font()
Retrieves the font - get/set -.
DTK_TYPE_RATIONAL_B_SPLINE_CURVE
@ DTK_TYPE_RATIONAL_B_SPLINE_CURVE
Definition: define.h:61
Dtk_HatchingStyle_Coloring
@ Dtk_HatchingStyle_Coloring
Definition: util_draw_dtk.hpp:7139
DTK_TYPE_TOROIDAL_SURFACE
@ DTK_TYPE_TOROIDAL_SURFACE
Definition: define.h:87
DTK_TYPE_SOLID_ANGLE_UNIT
@ DTK_TYPE_SOLID_ANGLE_UNIT
Definition: define.h:211
DTK_FRAME_TYPE_SCORED_CIRCLE
@ DTK_FRAME_TYPE_SCORED_CIRCLE
Definition: util_draw_dtk.hpp:135
Dtk_feat_limit::DEFAULT
@ DEFAULT
Definition: str_feat_dtk.hpp:620
dtk_text_type_prefix
@ dtk_text_type_prefix
Definition: str_def.h:12
Dtk_Welding::SymbolFlareBevelButtWeld
@ SymbolFlareBevelButtWeld
Definition: util_draw_dtk.hpp:2807
Dtk_DumpXml_FeatPattern
Dtk_ErrorStatus Dtk_DumpXml_FeatPattern(FILE *f, const Dtk_feat_pattern *inToWrite)
Definition: util_xml_dtk.cpp:8334
DTK_TYPE_REFERENCE_PLANE
@ DTK_TYPE_REFERENCE_PLANE
Definition: define.h:594
DTK_TYPE_ANNOTATION_TEXT_OCCURRENCE
@ DTK_TYPE_ANNOTATION_TEXT_OCCURRENCE
Definition: define.h:374
DTK_TYPE_TEXT_OR_CHARACTER
@ DTK_TYPE_TEXT_OR_CHARACTER
Definition: define.h:395
DTK_ANCHOR_BOTTOM_RIGHT
@ DTK_ANCHOR_BOTTOM_RIGHT
Definition: util_draw_dtk.hpp:101
DTK_TYPE_GEOMETRIC_SET
@ DTK_TYPE_GEOMETRIC_SET
Definition: define.h:113
DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR
@ DTK_TYPE_CARTESIAN_TRANSFORMATION_OPERATOR
Definition: define.h:35
DTK_TYPE_OPEN_PATH
@ DTK_TYPE_OPEN_PATH
Definition: define.h:148
Dtk_ViewDisplay::ShadingDisplay
@ ShadingDisplay
Definition: util_draw_dtk.hpp:6459
InvReaderModule
@ InvReaderModule
Definition: dtk_maindoc.hpp:33
Dtk_KinJoint::_LOWER_LIMIT1
Dtk_string _LOWER_LIMIT1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:946
Dtk_DumpXml_Dtk_Texture
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Texture(FILE *F, const Dtk_TextureInfosPtr &inTexture)
Definition: util_xml_dtk.cpp:3687
Dtk_KinParameter::getName
Dtk_string getName()
Returns the parameter name.
FeaturesDumpFile
FILE * FeaturesDumpFile
Definition: util_xml_dtk.cpp:59
Dtk_DumpXml_Dtk_Grid_OriginReferenceOptionEnum
void Dtk_DumpXml_Dtk_Grid_OriginReferenceOptionEnum(FILE *F, const Dtk_Grid::OriginReferenceOption &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:2374
Dtk_DumpXml_Dtk_PolylinePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PolylinePtr(FILE *F, const Dtk_PolylinePtr &inCurve)
Definition: util_xml_dtk.cpp:5214
Dtk_PhysicalMaterialInfos::GetThermalExpansion
Dtk_ErrorStatus GetThermalExpansion(Dtk_Double64 &outValue, Dtk_string &outUnits) const
Returns the material thermal expansion.
Dtk_LineTypeDefinition::DTK_LINE_TYPE_PATTERN_DESCRIPTOR_GAP
@ DTK_LINE_TYPE_PATTERN_DESCRIPTOR_GAP
Definition: dtk_line_type_definition.hpp:30
Dtk_Info::GetCurveLineTypeDefinitionId
Dtk_ID GetCurveLineTypeDefinitionId() const
Retrieves the Id of Dtk_LineTypeDefinition of the entity in The Dtk_API table.
Dtk_feat_inner_thread::no_standard_table
Bool no_standard_table
Definition: str_feat_dtk.hpp:1259
DTK_TYPE_ERROR
@ DTK_TYPE_ERROR
Definition: define.h:25
Dtk_KinJoint::getPart2
Dtk_KinPartPtr getPart2()
Returns the second part associated at the joint.
Dtk_feat_hole::GetCounterDiameter
Dtk_Double64 GetCounterDiameter() const
Definition: str_feat_dtk.hpp:1825
Dtk_NodeConnector::SubEntity::GetSubEntityType
type_detk GetSubEntityType() const
Definition: dtk_maindoc.hpp:1237
Dtk_DumpXml_Dtk_Text
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Text(FILE *F, const Dtk_Text &T)
Definition: util_xml_dtk.cpp:1218
DTK_ANCHOR_MIDDLE_RIGHT
@ DTK_ANCHOR_MIDDLE_RIGHT
Definition: util_draw_dtk.hpp:98
DTK_TYPE_PERSON
@ DTK_TYPE_PERSON
Definition: define.h:306
Dtk_Info::GetRenderInfosId
Dtk_ID GetRenderInfosId() const
Retrieves the Id of RenderInfos of the entity in The Dtk_API table.
Dtk_Constraint::_ConstraintValue::_EnableLower
Dtk_Int32 _EnableLower
Definition: util_ent_dtk.hpp:1219
Dtk_FCFFeatureIndicatorType::GetIndicatorType
const Dtk_FCFFeatureIndicatorTypeEnum & GetIndicatorType() const
Retrieves the IndicatorType semantic Type - Read Only -.
Definition: util_draw_dtk.hpp:5538
DTK_TYPE_PRE_DEFINED_POINT_MARKER_SYMBOL
@ DTK_TYPE_PRE_DEFINED_POINT_MARKER_SYMBOL
Definition: define.h:332
Dtk_feat_inner_thread::GetDefinitionType
Dtk_string GetDefinitionType() const
Definition: str_feat_dtk.hpp:1400
DTK_TYPE_GEOMETRY
@ DTK_TYPE_GEOMETRY
Definition: define.h:562
Dtk_tab::at
T & at(Dtk_Size_t k)
Definition: util_stl_dtk.hpp:397
dtkNoError
@ dtkNoError
Definition: error_dtk.hpp:151
DTK_TYPE_TRANSFORMATION
@ DTK_TYPE_TRANSFORMATION
Definition: define.h:323
Dtk_DumpXml_Dtk_ConstraintReferencePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConstraintReferencePtr(FILE *F, const Dtk_ConstraintReferencePtr &inVal)
Definition: util_xml_dtk.cpp:8604
JtReaderModule
@ JtReaderModule
Definition: dtk_maindoc.hpp:44
Dtk_KinJoint::getRatio
double getRatio()
Returns the joint ratio value.
Dtk_DumpXml_Dtk_ToleranceSpecificationPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationPtr(FILE *F, const Dtk_ToleranceSpecificationPtr &D)
Definition: util_xml_dtk.cpp:2708
Dtk_FCFFeatureIndicatorTypeEnumToString
Dtk_string Dtk_FCFFeatureIndicatorTypeEnumToString(const Dtk_FCFFeatureIndicatorType::Dtk_FCFFeatureIndicatorTypeEnum &inEnum)
Definition: util_xml_dtk.cpp:2731
Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration(FILE *inFile, const Dtk_KinSpeedAccelerationPtr &inSpeedAcceleration)
Definition: util_xml_dtk.cpp:7252
Dtk_Text::GetInnerBoundingBox
const Dtk_Oriented2dBBox & GetInnerBoundingBox() const
Processes the inner bounding box.
Dtk_mesh_face::info
Dtk_InfoPtr & info()
acces to class info of mesh_face
dtk_text_type_roughness_mode
@ dtk_text_type_roughness_mode
Definition: str_def.h:32
DTK_TYPE_CURVE_STYLE
@ DTK_TYPE_CURVE_STYLE
Definition: define.h:364
DTK_FRAME_TYPE_RECTANGLE
@ DTK_FRAME_TYPE_RECTANGLE
Definition: util_draw_dtk.hpp:129
Dtk_KinJoint::getLocalFrame2
Dtk_transfo getLocalFrame2()
Returns the local frame 2 value.
Dtk_Camera::GetClippingDistance
void GetClippingDistance(Dtk_Double64 &outFrontDistance, Dtk_Double64 &outBackDistance) const
get the Front Clipping Distance et Back Clipping Distance
Dtk_feat_hole::GetNeckDiameter
Dtk_Double64 GetNeckDiameter() const
return the diameter of the neck
Definition: str_feat_dtk.hpp:1975
DTK_TYPE_COORDINATED_UNIVERSAL_TIME_OFFSET
@ DTK_TYPE_COORDINATED_UNIVERSAL_TIME_OFFSET
Definition: define.h:176
Dtk_View::BrokenView
@ BrokenView
Definition: util_draw_dtk.hpp:6567
Dtk_KinJoint::getFixTogether
Dtk_KinConstraintPtr getFixTogether()
Returns the fix together constraint.
Dtk_feat_hole::GetCounterAngle
Dtk_Double64 GetCounterAngle() const
Definition: str_feat_dtk.hpp:1899
DTK_TYPE_GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION
@ DTK_TYPE_GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION
Definition: define.h:287
DTK_TYPE_ORDINAL_DATE
@ DTK_TYPE_ORDINAL_DATE
Definition: define.h:172
DTK_TYPE_PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS
@ DTK_TYPE_PRODUCT_DEFINITION_WITH_ASSOCIATED_DOCUMENTS
Definition: define.h:217
DTK_TYPE_SPECIFIED_HIGHER_USAGE_OCCURRENCE
@ DTK_TYPE_SPECIFIED_HIGHER_USAGE_OCCURRENCE
Definition: define.h:236
Dtk_DumpXml_Dtk_KinematicsCurve
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCurve(FILE *inFile, const Dtk_KinCurvePtr &inCurve)
Definition: util_xml_dtk.cpp:7417
Dtk_Welding::FinishSymbolEnumToString
static Dtk_string FinishSymbolEnumToString(const FinishSymbolEnum &inEnum)
Definition: util_draw_dtk.hpp:2970
DTK_TYPE_PROPERTY_DEFINITION
@ DTK_TYPE_PROPERTY_DEFINITION
Definition: define.h:330
DTK_TYPE_SET_OF_REVERSIBLE_TOPOLOGY_ITEM
@ DTK_TYPE_SET_OF_REVERSIBLE_TOPOLOGY_ITEM
Definition: define.h:155
Dtk_Welding::FinishSymbolUnspecified
@ FinishSymbolUnspecified
Definition: util_draw_dtk.hpp:2968
DTK_TYPE_TEXT_STYLE
@ DTK_TYPE_TEXT_STYLE
Definition: define.h:371
DTK_TYPE_LENGTH_MEASURE
@ DTK_TYPE_LENGTH_MEASURE
Definition: define.h:192
Dtk_Info::GetId
int GetId() const
DTK_FDT_MODIFIER_REGARDLESS_OF_FEATURE_SIZE
@ DTK_FDT_MODIFIER_REGARDLESS_OF_FEATURE_SIZE
Definition: util_draw_dtk.hpp:60
Dtk_DumpXml_Dtk_SurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SurfacePtr(FILE *F, const Dtk_SurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6396
Dtk_Boundary::GetSimplifiedRepresentation
const Dtk_PolylinePtr & GetSimplifiedRepresentation() const
Retrieves a simplified representation of the boundary as a polyline. Useful for simple display.
DTK_TYPE_HYPERBOLA
@ DTK_TYPE_HYPERBOLA
Definition: define.h:51
DTK_TYPE_SYMBOL_COLOUR
@ DTK_TYPE_SYMBOL_COLOUR
Definition: define.h:355
Dtk_feat::GetHole
Dtk_feat_hole * GetHole() const
Definition: str_feat_dtk.hpp:7093
Dtk_ToleranceSpecificationContainer::TypeAngularity
@ TypeAngularity
Definition: util_draw_dtk.hpp:5713
dtk_text_type_unit
@ dtk_text_type_unit
Definition: str_def.h:17
Dtk_Welding::WeldingSymbolEnumToString
static Dtk_string WeldingSymbolEnumToString(const WeldingSymbolEnum &inEnum)
Definition: util_draw_dtk.hpp:2865
DTK_TYPE_FUNCTIONALLY_DEFINED_TRANSFORMATION
@ DTK_TYPE_FUNCTIONALLY_DEFINED_TRANSFORMATION
Definition: define.h:321
DTK_FRAME_TYPE_TRIANGLE
@ DTK_FRAME_TYPE_TRIANGLE
Definition: util_draw_dtk.hpp:139
Dtk_feat_hole::GetEndAngle
Dtk_Double64 GetEndAngle() const
return the angle of the end chamfer
Definition: str_feat_dtk.hpp:1990
DTK_TYPE_PRE_DEFINED_TEXT_FONT
@ DTK_TYPE_PRE_DEFINED_TEXT_FONT
Definition: define.h:392
DTK_TYPE_PARAMETRIC_SURFACE
@ DTK_TYPE_PARAMETRIC_SURFACE
Definition: define.h:108
DTK_TYPE_CC_DESIGN_CONTRACT
@ DTK_TYPE_CC_DESIGN_CONTRACT
Definition: define.h:326
DTK_TYPE_CONICAL_SURFACE
@ DTK_TYPE_CONICAL_SURFACE
Definition: define.h:85
DTK_TYPE_OFFSET_CURVE_2D
@ DTK_TYPE_OFFSET_CURVE_2D
Definition: define.h:77
DTK_TYPE_ANNOTATION_FILL_AREA_OCCURRENCE
@ DTK_TYPE_ANNOTATION_FILL_AREA_OCCURRENCE
Definition: define.h:376
Dtk_RGB
Definition: dtk_rgb.hpp:8
DTK_Text_subtype::IsTolLeftParenthesis
Dtk_bool IsTolLeftParenthesis() const
Tell if the associated Dtk_text is part of Tolerance Left Parenthesis group - into Dtk_Dimension -.
Dtk_Welding::SymbolSteepFlankedSingleVWeld
@ SymbolSteepFlankedSingleVWeld
Definition: util_draw_dtk.hpp:2821
DTK_TYPE_CONTEXT_DEPENDENT_UNIT
@ DTK_TYPE_CONTEXT_DEPENDENT_UNIT
Definition: define.h:204
DTK_TYPE_PARAMETER_VALUE
@ DTK_TYPE_PARAMETER_VALUE
Definition: define.h:531
DTK_WITHOUT_HIERARCHY
@ DTK_WITHOUT_HIERARCHY
Definition: util_draw_dtk.hpp:68
DTK_Text_subtype::IsPrefix
Dtk_bool IsPrefix() const
Tell if the associated Dtk_text is part of Prefix group - into Dtk_Dimension -.
Dtk_TextStyle::LineSpacing
Dtk_Double64 & LineSpacing()
Retrieves the line spacing - get/set -.
DTK_TYPE_UNIFORM_SURFACE
@ DTK_TYPE_UNIFORM_SURFACE
Definition: define.h:100
DTK_TYPE_SHELL
@ DTK_TYPE_SHELL
Definition: define.h:144
DTK_TYPE_CABLING
@ DTK_TYPE_CABLING
Definition: define.h:492
GltfReaderModule
@ GltfReaderModule
Definition: dtk_maindoc.hpp:77
Dtk_PhysicalMaterialInfos::GetYieldStrength
Dtk_ErrorStatus GetYieldStrength(Dtk_Double64 &outValue, Dtk_string &outUnits) const
Returns the material yield strength.
inDumpFile
FILE * inDumpFile
Definition: util_xml_dtk.cpp:5442
dtkTopologyShellHasNoFaces
@ dtkTopologyShellHasNoFaces
Definition: error_dtk.hpp:200
Dtk_Oriented2dBBox
This is the base bounding box class. It's used into a lot of 2D Entities This class represents the ba...
Definition: util_draw_dtk.hpp:450
Dtk_feat_tolerance_set::GetSuperiorTolerance
Dtk_Double64 GetSuperiorTolerance() const
Definition: str_feat_dtk.hpp:848
DTK_TYPE_PROJECTION_CURVE
@ DTK_TYPE_PROJECTION_CURVE
Definition: define.h:342
Dtk_StandardTools::vsprintf_dtk
int vsprintf_dtk(char *Buffer, size_t BufferCount, const char *Format, va_list inArgList)
Dtk_feat_limit::BLIND
@ BLIND
Definition: str_feat_dtk.hpp:629
DTK_TYPE_WEEK_OF_YEAR_AND_DAY_DATE
@ DTK_TYPE_WEEK_OF_YEAR_AND_DAY_DATE
Definition: define.h:173
DTK_VAL_TYPE_DOUBLE
@ DTK_VAL_TYPE_DOUBLE
Definition: dtk_val.hpp:22
DTK_TYPE_PRODUCT_DEFINITION_SHAPE
@ DTK_TYPE_PRODUCT_DEFINITION_SHAPE
Definition: define.h:265
DTK_TYPE_APPROVAL_STATUS
@ DTK_TYPE_APPROVAL_STATUS
Definition: define.h:314
Dtk_FCFFeatureIndicatorType::CreateGeometries
Dtk_ErrorStatus CreateGeometries(Dtk_tab< Dtk_CurvePtr > &outGeoms) const
Process IndicatorType Related geometries.
Dtk_Component::ComponentNotRequired
@ ComponentNotRequired
Definition: dtk_maindoc.hpp:569
DTK_TYPE_PRODUCT_VERSION_WITH_SPECIFIED_SOURCE
@ DTK_TYPE_PRODUCT_VERSION_WITH_SPECIFIED_SOURCE
Definition: define.h:298
DTK_TYPE_REQUESTED_ACTION
@ DTK_TYPE_REQUESTED_ACTION
Definition: define.h:242
DTK_TYPE_REVOLUTION_SURFACE
@ DTK_TYPE_REVOLUTION_SURFACE
Definition: define.h:487
DTK_TYPE_CATIA
@ DTK_TYPE_CATIA
Definition: define.h:23
Dtk_DumpXml_Dtk_RuledSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RuledSurfacePtr(FILE *F, const Dtk_RuledSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6340
DTK_KIN_TYPE_MECHANISM
@ DTK_KIN_TYPE_MECHANISM
Definition: util_kinematics_dtk.hpp:111
Dtk_feat_pattern::row2
int row2
Definition: str_feat_dtk.hpp:3293
Dtk_feat_thread::GetSupport
Dtk_feat_geometry * GetSupport() const
Definition: str_feat_dtk.hpp:1505
DTK_TYPE_MANIFOLD_SURFACE_WITH_TOPOLOGY_REPRESENTATION
@ DTK_TYPE_MANIFOLD_SURFACE_WITH_TOPOLOGY_REPRESENTATION
Definition: define.h:163
Dtk_mesh_face::get_triangle_strip_indices
const Dtk_tab< Dtk_UInt32 > * get_triangle_strip_indices(Dtk_Size_t inI) const
Get inI-th triangle strip.
Dtk_HatchingPattern::Angle
Dtk_Double64 & Angle()
DTK_TYPE_DIMENSION_CURVE
@ DTK_TYPE_DIMENSION_CURVE
Definition: define.h:343
DTK_TYPE_RATIONAL_B_SPLINE_CURVE_WITH_KNOTS
@ DTK_TYPE_RATIONAL_B_SPLINE_CURVE_WITH_KNOTS
Definition: define.h:62
DTK_TYPE_PRODUCT_RELATED_PRODUCT_CATEGORY
@ DTK_TYPE_PRODUCT_RELATED_PRODUCT_CATEGORY
Definition: define.h:296
DTK_TYPE_REPRESENTATION
@ DTK_TYPE_REPRESENTATION
Definition: define.h:273
Dtk_Welding::SymbolSeamWeld
@ SymbolSeamWeld
Definition: util_draw_dtk.hpp:2831
DTK_TYPE_ROUGHNESS
@ DTK_TYPE_ROUGHNESS
Definition: define.h:434
DTK_TYPE_CURVE_STYLE_FONT
@ DTK_TYPE_CURVE_STYLE_FONT
Definition: define.h:359
DTK_KIN_TYPE_SPEED_ACCELERATION
@ DTK_KIN_TYPE_SPEED_ACCELERATION
Definition: util_kinematics_dtk.hpp:113
Dtk_ViewDisplay::NoHiddenDisplay
@ NoHiddenDisplay
Definition: util_draw_dtk.hpp:6457
Dtk_Welding::ComplementarySymbolWeldWithConvexFace
@ ComplementarySymbolWeldWithConvexFace
Definition: util_draw_dtk.hpp:2912
dtk_text_type_fakevalue
@ dtk_text_type_fakevalue
Definition: str_def.h:16
DTK_PICTURE_BMP
@ DTK_PICTURE_BMP
Definition: dtk_picture.hpp:25
DTK_Text_subtype::IsValSplitPart2
Dtk_bool IsValSplitPart2() const
Tell if the associated Dtk_text is part of Value Split Part 2 - for Degrees/Minutes/Seconds form - gr...
Dtk_TextStyle::AttributeSuperscript
@ AttributeSuperscript
Definition: util_draw_dtk.hpp:275
Dtk_feat_hole::GetDiameterTolerance
Dtk_feat_tolerance_set * GetDiameterTolerance() const
Definition: str_feat_dtk.hpp:1742
DTK_TYPE_TOL_SPEC
@ DTK_TYPE_TOL_SPEC
Definition: define.h:466
Dtk_DumpXml_Dtk_FCFFeatureIndicatorType
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FCFFeatureIndicatorType(FILE *F, const Dtk_FCFFeatureIndicatorType &D)
Definition: util_xml_dtk.cpp:2744
Dtk_dir
This is a mathematical direction class.
Definition: dtk_dir.hpp:14
DTK_TYPE_PIPING_ENTITY
@ DTK_TYPE_PIPING_ENTITY
Definition: define.h:170
DTK_TYPE_SHELL_BASED_WIREFRAME_MODEL
@ DTK_TYPE_SHELL_BASED_WIREFRAME_MODEL
Definition: define.h:141
dtkErrorOpenFiles
@ dtkErrorOpenFiles
Definition: error_dtk.hpp:145
Dtk_Val::GetValType
Dtk_val_type GetValType() const
DTK_TYPE_ORGANIZATIONAL_ADDRESS
@ DTK_TYPE_ORGANIZATIONAL_ADDRESS
Definition: define.h:320
Dtk_Welding::FinishSymbolChip
@ FinishSymbolChip
Definition: util_draw_dtk.hpp:2954
dtk_text_type_upper_text
@ dtk_text_type_upper_text
Definition: str_def.h:23
Dtk_DumpXml_Dtk_GridPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GridPtr(FILE *F, const Dtk_GridPtr &D)
Definition: util_xml_dtk.cpp:2392
Dtk_OneCell::GetBorderLeftBlanked
Dtk_Int32 GetBorderLeftBlanked() const
Gets BorderLeftBlanked of Left border.
Dtk_HatchingPattern::Color
Dtk_RGB & Color()
Dtk_FCFFeatureIndicatorType::IntersectionPlane
@ IntersectionPlane
Definition: util_draw_dtk.hpp:5474
Dtk_DumpXml_Dtk_CameraProjectionTypeEnum
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraProjectionTypeEnum(FILE *F, const Dtk_Camera::ProjectionTypeEnum &inVal)
Definition: util_xml_dtk.cpp:3112
Dtk_feat_limit::GetVal
Dtk_Double64 GetVal() const
Definition: str_feat_dtk.hpp:659
Dtk_Constraint::_ConstraintValue::_EnableUpper
Dtk_Int32 _EnableUpper
Definition: util_ent_dtk.hpp:1220
DTK_TYPE_GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION
@ DTK_TYPE_GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION
Definition: define.h:286
Dtk_TextStyle::FontStyle
FontStyleEnum & FontStyle()
Retrieves the font style - get/set -.
COUNTER_BORED
@ COUNTER_BORED
Definition: str_feat_dtk.hpp:108
DTK_TYPE_SPIRAL
@ DTK_TYPE_SPIRAL
Definition: define.h:53
Dtk_HatchingStyle
Dtk_HatchingStyle
Definition: util_draw_dtk.hpp:7136
DTK_TYPE_ACTION_ASSIGNMENT
@ DTK_TYPE_ACTION_ASSIGNMENT
Definition: define.h:301
DTK_TYPE_EFFECTIVITY
@ DTK_TYPE_EFFECTIVITY
Definition: define.h:240
DTK_TYPE_RENDER
@ DTK_TYPE_RENDER
Definition: define.h:561
DTK_TYPE_OFFSET_CURVE_3D
@ DTK_TYPE_OFFSET_CURVE_3D
Definition: define.h:78
Dtk_DumpXml_Dtk_KinematicsNamedValue
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsNamedValue(FILE *inFile, const Dtk_KinNamedValuePtr &inNamedValue)
Definition: util_xml_dtk.cpp:7183
DTK_TYPE_WELDING
@ DTK_TYPE_WELDING
Definition: define.h:437
DTK_TYPE_WORK_ITEM
@ DTK_TYPE_WORK_ITEM
Definition: define.h:223
DTK_TYPE_FACE_ENTITY
@ DTK_TYPE_FACE_ENTITY
Definition: define.h:151
dtkErrorNullPointer
@ dtkErrorNullPointer
Definition: error_dtk.hpp:23
DTK_TYPE_KIN_FIXPART
@ DTK_TYPE_KIN_FIXPART
Definition: define.h:544
Dtk_DumpXml_Dtk_KinematicsJoint
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsJoint(FILE *inFile, const Dtk_KinJointPtr &inJoint, Dtk_bool simplified)
Definition: util_xml_dtk.cpp:7536
DTK_PICTURE_TIFF
@ DTK_PICTURE_TIFF
Definition: dtk_picture.hpp:29
Dtk_Val::GetChar
char GetChar(Dtk_status &st=Dtk_status::GetDefaultStatus()) const
DTK_TYPE_CURVE_FONT_OR_SCALED_CURVE_STYLE_FONT_SELECT
@ DTK_TYPE_CURVE_FONT_OR_SCALED_CURVE_STYLE_FONT_SELECT
Definition: define.h:361
DTK_TYPE_METADATAWITHUNIT
@ DTK_TYPE_METADATAWITHUNIT
Definition: define.h:509
DTK_TYPE_SUPER_SURFACE
@ DTK_TYPE_SUPER_SURFACE
Definition: define.h:110
Dtk_Dimension::BasicTypeCircle
@ BasicTypeCircle
Definition: util_draw_dtk.hpp:4560
DTK_TYPE_NODE_CONNECTOR_ENTITY
@ DTK_TYPE_NODE_CONNECTOR_ENTITY
Definition: define.h:475
Dtk_Welding::ComplementarySymbolWeldWithFlatFace
@ ComplementarySymbolWeldWithFlatFace
Definition: util_draw_dtk.hpp:2910
Dtk_Constraint::_ConstraintValue::_Value
Dtk_Val _Value
Definition: util_ent_dtk.hpp:1218
Dtk_DumpXml_Dtk_PlaneSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PlaneSurfacePtr(FILE *F, const Dtk_PlaneSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6177
Dtk_feat_inner_thread::IsNoStandardTable
Dtk_bool IsNoStandardTable() const
Definition: str_feat_dtk.hpp:1389
Dtk_ViewDisplay::DefaultDisplay
@ DefaultDisplay
Definition: util_draw_dtk.hpp:6451
dtk_text_type_suffix
@ dtk_text_type_suffix
Definition: str_def.h:19
Dtk_KinJoint::hasAttribute
Dtk_bool hasAttribute(Dtk_string inAttributeName)
Test if an attribute name belong at the attribute table.
Dtk_API
Definition: dtk_api.hpp:75
Dtk_feat_limit::GetType
LIMIT_TYPE GetType() const
Definition: str_feat_dtk.hpp:650
DTK_TYPE_ASSOCIATIVE_LINEAR_DIMENSION
@ DTK_TYPE_ASSOCIATIVE_LINEAR_DIMENSION
Definition: define.h:421
DTK_TYPE_ADVANCED_FACE
@ DTK_TYPE_ADVANCED_FACE
Definition: define.h:130
ProeReaderModule
@ ProeReaderModule
Definition: dtk_maindoc.hpp:42
DTK_Text_subtype::IsRightText
Dtk_bool IsRightText() const
Tell if the associated Dtk_text is part of right group - into Dtk_Dimension -.
Dtk_CompositeText::GetOuterBoundingBox
const Dtk_Oriented2dBBox GetOuterBoundingBox(Dtk_bool inIncludeInvisible=DTK_TRUE) const
Processes the outer bounding box.
Dtk_DumpXml_Dtk_OffsetSurfacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OffsetSurfacePtr(FILE *F, const Dtk_OffsetSurfacePtr &inSurf)
Definition: util_xml_dtk.cpp:6328
DTK_TYPE_FDT_SET_CAPTURE
@ DTK_TYPE_FDT_SET_CAPTURE
Definition: define.h:451
Dtk_KinJoint::_LOCAL_FRAME4
Dtk_string _LOCAL_FRAME4
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:961
Dtk_HatchingPattern::Offset
Dtk_Double64 & Offset()
Dtk_feat::GetAssociatedGeometry
Dtk_feat_geometry * GetAssociatedGeometry() const
Definition: str_feat_dtk.hpp:7059
Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType(FILE *F, const Dtk_ToleranceSpecificationContainer::TypeEnum &D)
Definition: util_xml_dtk.cpp:2650
Dtk_DumpXml_Dtk_Constraint_ConstraintValue
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Constraint_ConstraintValue(FILE *F, const Dtk_Constraint::_ConstraintValue &inVal)
Definition: util_xml_dtk.cpp:8577
UgReaderModule
@ UgReaderModule
Definition: dtk_maindoc.hpp:35
DTK_TYPE_MEASURE_WITH_UNIT
@ DTK_TYPE_MEASURE_WITH_UNIT
Definition: define.h:191
DTK_TYPE_FACETTED_BREP
@ DTK_TYPE_FACETTED_BREP
Definition: define.h:166
DTK_TYPE_ANNOTATION_OCCURRENCE
@ DTK_TYPE_ANNOTATION_OCCURRENCE
Definition: define.h:380
DTK_TYPE_ADVANCED_BREP_REPRESENTATION
@ DTK_TYPE_ADVANCED_BREP_REPRESENTATION
Definition: define.h:164
DTK_TYPE_TEXT_LITERAL
@ DTK_TYPE_TEXT_LITERAL
Definition: define.h:394
Dtk_ToleranceSpecificationContainer::TypePosition
@ TypePosition
Definition: util_draw_dtk.hpp:5719
DTK_TYPE_LINEAR_EXTRUSION_SURFACE
@ DTK_TYPE_LINEAR_EXTRUSION_SURFACE
Definition: define.h:489
Dtk_feat_hole::GetAnchorTypeAsString
Dtk_string GetAnchorTypeAsString() const
DTK_TYPE_ORIENTED_CLOSED_SHELL
@ DTK_TYPE_ORIENTED_CLOSED_SHELL
Definition: define.h:138
Dtk_Entity::info
Dtk_InfoPtr & info()
Dtk_DumpXml_Dtk_FdtPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtPtr(FILE *F, const Dtk_FdtPtr &D, const int &compact)
Definition: util_xml_dtk.cpp:3065
Dtk_Camera::ProjectionTypeUnknown
@ ProjectionTypeUnknown
Definition: util_draw_dtk.hpp:6940
DTK_TYPE_PLANNED_EFFECTIVITY
@ DTK_TYPE_PLANNED_EFFECTIVITY
Definition: define.h:239
Dtk_FCFFeatureIndicatorType::DirectionFeature
@ DirectionFeature
Definition: util_draw_dtk.hpp:5470
DTK_TYPE_B_SPLINE_SURFACE
@ DTK_TYPE_B_SPLINE_SURFACE
Definition: define.h:98
DwgReaderModule
@ DwgReaderModule
Definition: dtk_maindoc.hpp:62
DTK_TYPE_RIGHT_CIRCULAR_CONE
@ DTK_TYPE_RIGHT_CIRCULAR_CONE
Definition: define.h:406
Dtk_KinJoint::_UPPER_LIMIT2
Dtk_string _UPPER_LIMIT2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:949
dtk_text_type_roughness_text4
@ dtk_text_type_roughness_text4
Definition: str_def.h:29
Dtk_NodeConnector::GetAssociatedPathComponentID
const Dtk_tab< Dtk_ID > & GetAssociatedPathComponentID() const
Returns the Path Component ID referenced by the connector from Root to Target.
DTK_FRAME_TYPE_SCORED_RECTANGLE
@ DTK_FRAME_TYPE_SCORED_RECTANGLE
Definition: util_draw_dtk.hpp:166
DTK_TYPE_KIN_FORMULA
@ DTK_TYPE_KIN_FORMULA
Definition: define.h:547
Dtk_DatumTarget::DatumTargetMovableStatusEnumToString
static Dtk_string DatumTargetMovableStatusEnumToString(const DatumTargetMovableStatusEnum &inEnum)
Definition: util_draw_dtk.hpp:3583
DTK_TYPE_ASMSEARCHPATH
@ DTK_TYPE_ASMSEARCHPATH
Definition: define.h:552
Dtk_FCFFeatureIndicatorType::GetOuterBoundingBox
const Dtk_Oriented2dBBox & GetOuterBoundingBox() const
Retrieves the IndicatorType Outer Bounding Box - basically the related geometries BBox - - Read Only ...
Definition: util_draw_dtk.hpp:5549
DTK_TYPE_MATRIX
@ DTK_TYPE_MATRIX
Definition: define.h:459
Dtk_ToleranceSpecificationContainer::TypeLineProfile
@ TypeLineProfile
Definition: util_draw_dtk.hpp:5709
DTK_TYPE_COMPOSITE_TEXT
@ DTK_TYPE_COMPOSITE_TEXT
Definition: define.h:396
Dtk_Welding::SymbolISOEdgeWeld
@ SymbolISOEdgeWeld
Definition: util_draw_dtk.hpp:2849
Dtk_picture::Origin
Dtk_pnt & Origin()
Retrieves the origin (in mm)
Definition: dtk_picture.hpp:103
Dtk_NodeConnector::SubEntity::GetSubEntityId
Dtk_ID GetSubEntityId() const
Definition: dtk_maindoc.hpp:1236