DATAKIT API  V2025.3
Macros | Enumerations | Functions
util_xml_dtk.hpp File Reference

Go to the source code of this file.

Macros

#define Dtk_DumpXMLNamespace
 

Enumerations

enum  XML_StringType { XMLElement = 0, XMLAttribute, XMLGenericString }
 

Functions

void Dtk_DumpXml_Body (FILE *inDump, const Dtk_BodyPtr &inBody)
 
void Dtk_DumpXml_ComponentTypeEnum (FILE *F, const Dtk_Component::ComponentTypeEnum &inEnum, const Dtk_string &inPropertyName)
 
Dtk_ErrorStatus Dtk_DumpXml_Drawing (const Dtk_DrawingPtr &)
 
void Dtk_DumpXml_Drawing (FILE *inDump, const Dtk_DrawingPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_2dEntityPtr (FILE *F, const Dtk_2dEntityPtr &D, const int &compact=1)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_anchor_type (FILE *F, const Dtk_anchor_type &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)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraPtr (FILE *F, const Dtk_CameraPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ColorInfosSetPtr (FILE *F, const Dtk_ColorInfosSetPtr &inVal)
 
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_ConstraintPtr (FILE *F, const Dtk_ConstraintPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CurvePtr (FILE *F, const Dtk_CurvePtr &inCurve)
 
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_dir (FILE *F, const Dtk_dir &D, const char *b="Dir")
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DrawingPtr (FILE *, const Dtk_DrawingPtr &, const int &compact=1)
 
Dtk_ErrorStatus Dtk_DumpXml_DTK_FDT_MODIFIER (FILE *F, const DTK_FDT_MODIFIER &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtCapturePtr (FILE *F, const Dtk_FdtCapturePtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtDataSet (FILE *F, const Dtk_ComponentPtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtPtr (FILE *F, const Dtk_FdtPtr &D, const int &compact=1)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtViewPtr (FILE *F, const Dtk_FdtViewPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FeaturePtr (FILE *F, const Dtk_FeaturePtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GeometricalTolerancePtr (FILE *F, const Dtk_GeometricalTolerancePtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GraphicalDataPtr (FILE *F, const Dtk_GraphicalDataPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GridPtr (FILE *F, const Dtk_GridPtr &D)
 
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_FALSE)
 
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_LeaderPtr (FILE *F, const Dtk_LeaderPtr &L)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr (FILE *F, const Dtk_MainDocPtr &inObject)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshPtr (FILE *F, const Dtk_MeshPtr &inMesh)
 
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_OLEObjectPtr (FILE *F, const Dtk_OLEObjectPtr &O)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OneCell (FILE *F, Dtk_OneCell &D)
 
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="Pnt")
 
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_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_SelectionDataSet (FILE *F, const Dtk_GlobalDataSetPtr &ptrGlobalDataSet)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_StreamPtr (FILE *F, const Dtk_StreamPtr &inVal)
 
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_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_transfo (FILE *F, const Dtk_transfo &V)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewPtr (FILE *F, const Dtk_ViewPtr &V)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_WeldingPtr (FILE *F, const Dtk_WeldingPtr &D)
 
Dtk_ErrorStatus Dtk_DumpXml_End ()
 
Dtk_ErrorStatus Dtk_DumpXml_End (FILE *F)
 
Dtk_ErrorStatus Dtk_DumpXml_Fdt (const Dtk_FdtPtr &D)
 
Dtk_string Dtk_DumpXml_FormatDtk_string (const Dtk_string &inString, const XML_StringType inXmlStringType=XMLGenericString)
 
FILE * Dtk_DumpXml_GetFeaturesDumpFile ()
 
FILE * Dtk_DumpXml_GetFile ()
 
FILE * Dtk_DumpXml_GetParametersDumpFile ()
 
Dtk_ErrorStatus Dtk_DumpXml_Init (const Dtk_string &xml_file)
 
Dtk_ErrorStatus Dtk_DumpXml_LineTypeDefinitionTable (FILE *F)
 
Dtk_ErrorStatus Dtk_DumpXml_PhysicalMaterialInfosTable (FILE *F)
 
Dtk_ErrorStatus Dtk_DumpXml_RenderInfosTable (FILE *F)
 
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="%lf")
 
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)
 
template<typename ValueType >
Dtk_ErrorStatus Dtk_DumpXml_Value (FILE *inFile, const Dtk_string &inLabel, const ValueType &inValue)
 
Dtk_ErrorStatus Dtk_End_Dump_Files (const Dtk_string &inComponentFullName)
 
Dtk_ErrorStatus Dtk_Init_Dump_Files (const Dtk_string &inDumpFileName, Dtk_bool dumpFeatures=0)
 
Dtk_string DtkReaderTypeEnumToString (const DtkReaderType &inReaderTypeEnum)
 

Macro Definition Documentation

◆ Dtk_DumpXMLNamespace

#define Dtk_DumpXMLNamespace

Enumeration Type Documentation

◆ XML_StringType

enum XML_StringType
Enumerator
XMLElement 
XMLAttribute 
XMLGenericString 
94 {
95  XMLElement = 0,
96  XMLAttribute,
97  XMLGenericString
98 };

Function Documentation

◆ Dtk_DumpXml_Body()

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

◆ Dtk_DumpXml_ComponentTypeEnum()

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

◆ Dtk_DumpXml_Drawing() [1/2]

Dtk_ErrorStatus Dtk_DumpXml_Drawing ( const Dtk_DrawingPtr &  )
4940  {
4941  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_DrawingPtr( dump_file, d, 0 );
4942  }

◆ Dtk_DumpXml_Drawing() [2/2]

void Dtk_DumpXml_Drawing ( FILE *  inDump,
const Dtk_DrawingPtr &  D 
)

◆ Dtk_DumpXml_Dtk_2dEntityPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_2dEntityPtr ( FILE *  F,
const Dtk_2dEntityPtr &  D,
const int &  compact = 1 
)
2766  {
2767  int toto;
2768  toto = compact;
2769  fprintf( F, "\n<Dtk_2dEntityPtr>\n" );
2770  enum type_detk type = D->get_type_detk();
2771  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, D->info() );
2772 #ifdef Convert2dEntitiesToSymbol
2773  {
2774  Dtk_SymbolPtr Converted = Dtk_Symbol::Create( D );
2775  if( Converted.IsNotNULL() )
2776  {
2777  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_SymbolPtr( F, Dtk_SymbolPtr::DtkDynamicCast( Converted ) ); // downcasting
2778  }
2779  else
2780  {
2781  fprintf( F, "Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_2dEntityPtr : Unknow type (%d)\n", type );
2782  }
2783  }
2784 #else //#ifdef Convert2dEntitiesToSymbol
2785  switch( type )
2786  {
2787  case DTK_TYPE_TABLE:
2788  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_TablePtr( F, Dtk_TablePtr::DtkDynamicCast( D ) ); // downcasting
2789  break;
2790  case DTK_TYPE_SYMBOL:
2791  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_SymbolPtr( F, Dtk_SymbolPtr::DtkDynamicCast( D ) ); // downcasting
2792  break;
2793  case DTK_TYPE_DIMENSION:
2794  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_DimensionPtr( F, Dtk_DimensionPtr::DtkDynamicCast( D ) ); // downcasting
2795  break;
2796  case DTK_TYPE_GEOM_TOL:
2797  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_GeometricalTolerancePtr( F, Dtk_GeometricalTolerancePtr::DtkDynamicCast( D ) ); // downcasting
2798  break;
2799  case DTK_TYPE_ROUGHNESS:
2800  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RoughnessPtr( F, Dtk_RoughnessPtr::DtkDynamicCast( D ) ); // downcasting
2801  break;
2802  case DTK_TYPE_WELDING:
2803  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_WeldingPtr( F, Dtk_WeldingPtr::DtkDynamicCast( D ) ); // downcasting
2804  break;
2805  case DTK_TYPE_DATUM_TARGET:
2806  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_DatumTargetPtr( F, Dtk_DatumTargetPtr::DtkDynamicCast( D ) ); // downcasting
2807  break;
2808  case DTK_TYPE_GRID:
2809  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_GridPtr( F, Dtk_GridPtr::DtkDynamicCast( D ) ); // downcasting
2810  break;
2811  case DTK_TYPE_REGION:
2812  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RegionPtr( F, Dtk_RegionPtr::DtkDynamicCast( D ) ); // downcasting
2813  break;
2814  case DTK_TYPE_COMPOSITE_ENTITY:
2815  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeEntityPtr( F, Dtk_CompositeEntityPtr::DtkDynamicCast( D ) ); // downcasting
2816  break;
2817  default:
2818  fprintf( F, "Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_2dEntityPtr : Unknow type (%d)\n", type );
2819  }
2820 #endif //#ifdef Convert2dEntitiesToSymbol
2821  const Dtk_CompositeText &CompoText = D->GetAdditionnalTexts();
2822  if( CompoText.GetNumTexts() > 0 )
2823  {
2824  fprintf( F, "<AdditionnalTexts>\n" );
2825  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, CompoText );
2826  fprintf( F, "</AdditionnalTexts>\n" );
2827  }
2828 
2829  const Dtk_tab< Dtk_EntityPtr > &AdditionnalGeometries = D->GetAdditionnalGeometries();
2830  Dtk_Size_t nbgeoms = AdditionnalGeometries.size();
2831  if( nbgeoms > 0 )
2832  {
2833  Dtk_Size_t i;
2834  fprintf( F, "<AdditionnalGeometries size=\"" XmlFormat( "u" )"\">\n", nbgeoms );
2835  for( i = 0; i < nbgeoms; i++ )
2836  {
2837  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EntityPtr( F, AdditionnalGeometries[ i ] );
2838  }
2839  fprintf( F, "</AdditionnalGeometries>\n" );
2840  }
2841 
2842  fprintf( F, "</Dtk_2dEntityPtr>\n" );
2843  return dtkNoError;
2844  }

◆ Dtk_DumpXml_Dtk_anchor_type()

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

◆ Dtk_DumpXml_Dtk_AxisSystemPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_AxisSystemPtr ( FILE *  F,
const Dtk_AxisSystemPtr &  inVal 
)
3280  {
3281  fprintf( F, "<Dtk_AxisSystemPtr>\n" );
3282  if( inVal.IsNotNULL() )
3283  {
3284  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->get_info() );
3285 
3286 
3287  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"AxisName", inVal->GetName() );
3288  fprintf( F, "<IsDefault> %s </IsDefault>\n", inVal->IsDefault() ? "True" : "False" );
3289  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inVal->GetMatrix() );
3290  }
3291  else
3292  {
3293  fprintf( F, "Null" );
3294  }
3295  fprintf( F, "</Dtk_AxisSystemPtr>\n" );
3296 
3297  return dtkNoError;
3298  }

◆ Dtk_DumpXml_Dtk_BodyPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_BodyPtr ( FILE *  F,
const Dtk_BodyPtr &  inBody 
)
6456  {
6457  Dtk_Size_t numLump, i, j;
6458 
6459  fprintf( F, "<Dtk_BodyPtr>" );
6460  fprintf( F, "<Status>%d</Status>", inBody->GetBodyStatus() );
6461  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inBody->get_info() );
6462  // fprintf(F,"<Id>%d</Id>",inBody->GetID());
6463  numLump = inBody->GetNumLumps();
6464  for( i = 0; i < numLump; i++ )
6465  {
6466  Dtk_LumpPtr lump;
6467  inBody->GetLump( i, lump );
6468  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LumpPtr( F, lump );
6469 
6470  }
6471  Dtk_ShellPtr myshell;
6472  Dtk_Size_t m, NumOpenshell = inBody->GetNumOpenShells();
6473 
6474  for( m = 0; m < NumOpenshell; m++ )
6475  {
6476  inBody->GetOpenShell( m, myshell );
6477  if( myshell.IsNotNULL() )
6478  {
6479  fprintf( F, "<Dtk_OpenShellPtr>" );
6480  if( myshell->info().IsNotNULL() )
6481  {
6482  fprintf( F, "<Id>%d</Id>", myshell->info()->GetId() );
6483  }
6484 
6485  Dtk_Size_t NumFaces = myshell->GetNumFaces();
6486  for( i = 0; i < NumFaces; i++ )
6487  {
6488  Dtk_FacePtr FacePtr;
6489  Dtk_bool Orientation;
6490  myshell->GetFace( i, FacePtr, Orientation );
6491  //fprintf( F, "<orientation>%d</orientation>", Orientation );
6492  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FacePtr( F, FacePtr );
6493  }
6494  Dtk_Size_t nbWires = myshell->GetNumWireSet();
6495  if( nbWires != 0 )
6496  {
6497  fprintf( F, "<Wireframe>" );
6498  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, myshell->get_info() );
6499  for( i = 0; i < nbWires; i++ )
6500  {
6501  fprintf( F, "<WireSet>" );
6502 
6503  Dtk_tab<Dtk_EntityPtr> wireSet;
6504  Dtk_tab<Dtk_bool> orientation;
6505  Dtk_bool looporientation = -1;
6506  myshell->GetWireSetTopo( i, wireSet , orientation, looporientation);
6507  fprintf(F, "<WireLoopOrientation>%d</WireLoopOrientation>", looporientation);
6508  for( j = 0; j < wireSet.size(); j++ )
6509  {
6510  if( wireSet[ j ]->get_type_detk() != DTK_TYPE_VERTEX )
6511  {
6512  fprintf(F, "<WireEdgeOrientation>%d</WireEdgeOrientation>", orientation[j]);
6513  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EdgePtr( F, Dtk_EdgePtr::DtkDynamicCast( wireSet[ j ] ) );
6514  }
6515  else
6516  {
6517  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_VertexPtr( F, Dtk_VertexPtr::DtkDynamicCast( wireSet[ j ] ) );
6518  }
6519  }
6520  fprintf( F, "</WireSet>" );
6521  }
6522  fprintf( F, "</Wireframe>" );
6523  }
6524  fprintf( F, "</Dtk_OpenShellPtr>" );
6525  }
6526  }
6527  Dtk_Size_t numStream = inBody->GetNumStream();
6528  for( i = 0; i < numStream; i++ )
6529  {
6530  Dtk_StreamPtr stream;
6531  stream = inBody->GetStream( i );
6532  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_StreamPtr( F, stream );
6533 
6534  }
6535 
6536  fprintf( F, "</Dtk_BodyPtr>" );
6537 
6538  return dtkNoError;
6539  }

◆ Dtk_DumpXml_Dtk_bool()

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

◆ Dtk_DumpXml_Dtk_CameraPtr()

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

◆ Dtk_DumpXml_Dtk_ColorInfosSetPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ColorInfosSetPtr ( FILE *  F,
const Dtk_ColorInfosSetPtr &  inVal 
)
3301  {
3302  fprintf( F, "<Dtk_ColorInfosSet>\n" );
3303  if( inVal.IsNotNULL() )
3304  {
3305  Dtk_Size_t i;
3306  Dtk_Size_t NumColors = inVal->GetNumColors();
3307  Dtk_Int32 DefaultColor;
3308 
3309  inVal->GetDefaultColor( DefaultColor );
3310  fprintf( F, "<Colors Num=\"" XmlFormat( "u" )"\" DefaultColor=\" %d\">\n", NumColors, DefaultColor );
3311  for( i = 0; i < NumColors; i++ )
3312  {
3313  Dtk_string ColorName;
3314  Dtk_ID ColorReadId;
3315  Dtk_RGB ColorDef;
3316  Dtk_ErrorStatus errd = inVal->GetColorDefinition( i, ColorDef );
3317  Dtk_ErrorStatus errn = inVal->GetColorName( i, ColorName );
3318  Dtk_ErrorStatus erri = inVal->GetColorID( i, ColorReadId );
3319  if( errn == dtkNoError && erri == dtkNoError )
3320  {
3321  ColorName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( ColorName, XMLGenericString );
3322  fprintf( F, "<__%d__ Name=\"%S\"", ColorReadId, ColorName.w_str() );
3323  }
3324  else
3325  {
3326  if( erri == dtkNoError )
3327  fprintf( F, "<__%d__ Name=\"\"", ColorReadId );
3328  else
3329  fprintf( F, "<__" XmlFormat( "u" )"__ Name=\"\"", i );
3330 
3331  }
3332  if( errd == dtkNoError )
3333  {
3334  //Dtk_DumpXml_Dtk_RGB(F, ColorDef);
3335  if( ColorDef.IndexReader() >= 0 )
3336  {
3337  fprintf( F, " RGBA=\"%d %d %d %d %d \" ", ColorDef[ 0 ], ColorDef[ 1 ], ColorDef[ 2 ], ColorDef[ 3 ], ColorDef.IndexReader() );
3338  }
3339  else
3340  {
3341  fprintf( F, " RGBA=\"%d %d %d %d\" ", ColorDef[ 0 ], ColorDef[ 1 ], ColorDef[ 2 ], ColorDef[ 3 ] );
3342  }
3343  }
3344  fprintf( F, "/>\n" );
3345  }
3346  fprintf( F, "</Colors>\n" );
3347  }
3348  else
3349  {
3350  fprintf( F, "Null" );
3351  }
3352  fprintf( F, "</Dtk_ColorInfosSet>\n" );
3353 
3354  return dtkNoError;
3355  }

◆ Dtk_DumpXml_Dtk_ComponentPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr ( FILE *  F,
const Dtk_ComponentPtr &  inObject 
)
4638  {
4639  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr_Init( F, inObject );
4640  Dtk_Size_t NumChildren = inObject->GetNumChildren();
4641  for( Dtk_Size_t i = 0; i < NumChildren; i++ )
4642  {
4643  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->GetChild( i ) );
4644  }
4645 
4646  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr_End( F );
4647  /*fprintf( F, "<Dtk_ComponentPtr>\n" );
4648  if( inObject.IsNotNULL() )
4649  {
4650  Dtk_Size_t i, NumChildren, NumFathers = inObject->GetNumFathers();
4651  Dtk_MaterialPtr mat = NULL;
4652  fprintf( F, "<ComponentID>%u</ComponentID>\n", inObject->GetID() );
4653  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4654  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4655  Dtk_ID readid;
4656  inObject->GetReadID( readid );
4657  if( readid > 0 )
4658  fprintf( F, "<ReadID>%d</ReadID>\n", readid );
4659  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FullPathName", inObject->FullPathName() );
4660  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"InstanceName", inObject->InstanceName() );
4661  if( inObject->GetFileVersion().icmp( L"" ) != 0 )
4662  {
4663  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FileVersion", inObject->GetFileVersion() );
4664  }
4665  fprintf( F, "<ComponentUnitScale>%f</ComponentUnitScale>\n", inObject->GetConceptionUnitScale() );
4666  for( i = 0; i < NumFathers; i++ )
4667  fprintf( F, "<FatherID>%u</FatherID>\n", inObject->GetFatherID( i ) );
4668  Dtk_DumpXMLNamespace::Dtk_DumpXml_DtkReaderType( F, inObject->GetAssociatedModuleType(), L"AssociatedModule" );
4669  Dtk_DumpXMLNamespace::Dtk_DumpXml_ComponentTypeEnum( F, inObject->ComponentType(), L"ComponentType" );
4670  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inObject->TransformationMatrix() );
4671  // mat = inObject->GetMaterial();
4672  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_material(F,mat);
4673 
4674 
4675  NumChildren = inObject->GetNumChildren();
4676  for( i = 0; i < NumChildren; i++ )
4677  {
4678  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->GetChild( i ) );
4679  }
4680 
4681  }
4682  else
4683  {
4684  fprintf( F, "'Null'" );
4685  }
4686  fprintf( F, "</Dtk_ComponentPtr>\n" );*/
4687  return dtkNoError;
4688  }

◆ Dtk_DumpXml_Dtk_ComponentPtr_End()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_End ( FILE *  F)
4786  {
4787  if( F == NULL )
4788  {
4789  return dtkErrorNullPointer;
4790  }
4791 
4792  fprintf( F, "</Dtk_ComponentPtr>\n" );
4793  return dtkNoError;
4794  }

◆ Dtk_DumpXml_Dtk_ComponentPtr_Init()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_Init ( FILE *  F,
const Dtk_ComponentPtr &  inObject 
)
4692  {
4693  if( F == NULL )
4694  {
4695  return dtkErrorNullPointer;
4696  }
4697 
4698  fprintf( F, "<Dtk_ComponentPtr>\n" );
4699  if( inObject.IsNotNULL() )
4700  {
4701  Dtk_Size_t i;
4702  Dtk_MaterialPtr mat = NULL;
4703  fprintf( F, "<ComponentID>%u</ComponentID>\n", inObject->GetID() );
4704  fprintf( F, "<IsAssembly>%d</IsAssembly>\n", inObject->IsAssembly() );
4705  if( inObject->ComponentType() == Dtk_Component::PrototypeComponentType )
4706  {
4707  Dtk_string avail = Dtk_Component::ComponentAvailabilityEnumToString( inObject->ComponentAvailability() );
4708  fprintf( F, "<ComponentAvailability>%ls</ComponentAvailability>\n", avail.w_str() );
4709  if( inObject->IsAdditionnalReference() )
4710  fprintf( F, "<IsAdditionnalReference>1</IsAdditionnalReference>\n" );
4711  }
4712  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4713  if( inObject->Name().len() > 0 )
4714  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4715 
4716  Dtk_ID readid;
4717  inObject->GetReadID( readid );
4718  if( readid > 0 )
4719  fprintf( F, "<ReadID>%d</ReadID>\n", readid );
4720 
4721  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FullPathName", inObject->FullPathName() );
4722  if( inObject->OriginalPathName().len() > 0 )
4723  {
4724  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"OriginalPathName", inObject->OriginalPathName() );
4725  }
4726  if( inObject->InstanceName().len() > 0 )
4727  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"InstanceName", inObject->InstanceName() );
4728  if( inObject->GetFileVersion().len() > 0 )
4729  {
4730  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FileVersion", inObject->GetFileVersion() );
4731  }
4732  Dtk_Double64 UnitScale;
4733  inObject->GetConceptionUnitScale( UnitScale );
4734  fprintf( F, "<ComponentUnitScale>%f</ComponentUnitScale>\n", UnitScale );
4735  fprintf( F, "<FatherID>%u</FatherID>\n", inObject->GetFatherID( 0 ) );
4736  Dtk_DumpXMLNamespace::Dtk_DumpXml_DtkReaderType( F, inObject->GetAssociatedModuleType(), L"AssociatedModule" );
4737  Dtk_DumpXMLNamespace::Dtk_DumpXml_ComponentTypeEnum( F, inObject->ComponentType(), L"ComponentType" );
4738 
4739  Dtk_PreviewPtr preview = inObject->GetPreview();
4740  if( preview.IsNotNULL() )
4741  {
4742  Dtk_Size_t size = preview->GetSize();
4743  fprintf( F, "<PreviewSize>\"" XmlFormat( "u" )"\"</PreviewSize>", size );
4744  }
4745 
4746  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inObject->TransformationMatrix() );
4747  // mat = inObject->GetMaterial();
4748  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_material(F,mat);
4749 
4750  Dtk_Size_t NumMetaData;
4751  NumMetaData = inObject->GetNumMetaData();
4752  if( NumMetaData )
4753  {
4754  fprintf( F, "<Dtk_MetaData Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaData );
4755  for( i = 0; i < NumMetaData; i++ )
4756  {
4757  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr( F, inObject->GetMetaData( i ) );
4758  }
4759  fprintf( F, "</Dtk_MetaData>\n" );
4760  }
4761 
4762 #ifdef XML_GROUP_METADATA
4763  Dtk_Size_t NumMetaDataGroup;
4764  NumMetaDataGroup = inObject->GetNumMetaDataGroup();
4765  if( NumMetaDataGroup )
4766  {
4767  fprintf( F, "<Dtk_MetaDataGroup Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaDataGroup );
4768  for( i = 0; i < NumMetaDataGroup; i++ )
4769  {
4770  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataGroupPtr( F, inObject->GetMetaDataGroup( i ) );
4771  }
4772  fprintf( F, "</Dtk_MetaDataGroup>\n" );
4773  }
4774 #endif
4775  }
4776  else
4777  {
4778  fprintf( F, "'Null'" );
4779  }
4780 
4781  return dtkNoError;
4782  }

◆ Dtk_DumpXml_Dtk_ConstraintPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConstraintPtr ( FILE *  F,
const Dtk_ConstraintPtr &  inVal 
)
8299  {
8300  fprintf( F, "<Dtk_ConstraintPtr>\n" );
8301  if( inVal.IsNULL() == DTK_TRUE )
8302  fprintf( F, "Null" );
8303  else
8304  {
8305  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->get_info() );
8306  Dtk_DumpXMLNamespace::Dtk_DumpXml_ConstraintTypeEnum( F, inVal->GetConstraintType(), L"ConstraintType" );
8307 
8308  const Dtk_Size_t nbConstraintValues = inVal->GetNumberOfConstraintValues();
8309  for( Dtk_Size_t i = 0; i < nbConstraintValues; ++i )
8310  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Constraint_ConstraintValue( F, inVal->GetConstraintValue( i ) );
8311 
8312  const Dtk_Size_t nbConstraintReferences = inVal->GetNumberOfConstraintReferences();
8313  for( Dtk_Size_t i = 0; i < nbConstraintReferences; ++i )
8314  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ConstraintReferencePtr( F, inVal->GetConstraintReference( i ) );
8315  }
8316  fprintf( F, "</Dtk_ConstraintPtr>\n" );
8317  return dtkNoError;
8318  }

◆ Dtk_DumpXml_Dtk_CurvePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_CurvePtr ( FILE *  F,
const Dtk_CurvePtr &  inCurve 
)
5775  {
5776  type_detk type;
5777  if( inCurve.IsNULL() )
5778  {
5779  return dtkErrorNullPointer;
5780  }
5781  fprintf( F, "<Dtk_CurvePtr>" );
5782  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inCurve->get_info() );
5783  // fprintf(F,"<Id>%d</Id>",inCurve->GetID());
5784 
5785  if( inCurve->IsTrimmed() )
5786  {
5787  fprintf( F, "<Domain>" );
5788 
5789  fprintf( F, "<UMin>%f</UMin>", inCurve->GetTrimUMin() );
5790  fprintf( F, "<UMax>%f</UMax>", inCurve->GetTrimUMax() );
5791 
5792  fprintf( F, "</Domain>" );
5793  }
5794 
5795 
5796 
5797  type = inCurve->get_type_detk();
5798  switch( type )
5799  {
5800  case DTK_TYPE_LINE:
5801  {
5802  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LinePtr( F, Dtk_LinePtr::DtkDynamicCast( inCurve ) );
5803  break;
5804  }
5805  case DTK_TYPE_POLYLINE:
5806  {
5807  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_PolylinePtr( F, Dtk_PolylinePtr::DtkDynamicCast( inCurve ) );
5808  break;
5809  }
5810  case DTK_TYPE_NURBS_CURVE:
5811  {
5812  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NurbsCurvePtr( F, Dtk_NurbsCurvePtr::DtkDynamicCast( inCurve ) );
5813  break;
5814  }
5815  case DTK_TYPE_HYPERBOLA:
5816  {
5817  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_HyperbolaPtr( F, Dtk_HyperbolaPtr::DtkDynamicCast( inCurve ) );
5818  break;
5819  }
5820  case DTK_TYPE_PARABOLA:
5821  {
5822  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ParabolaPtr( F, Dtk_ParabolaPtr::DtkDynamicCast( inCurve ) );
5823  break;
5824  }
5825  case DTK_TYPE_CIRCLE:
5826  case DTK_TYPE_ELLIPSE:
5827  {
5828  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EllipsePtr( F, Dtk_EllipsePtr::DtkDynamicCast( inCurve ) );
5829  break;
5830  }
5831  case DTK_TYPE_INTERSECTION_CURVE:
5832  case DTK_TYPE_SPCURVE:
5833  {
5834  //Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_IntersectCurvePtr( F, Dtk_IntersectCurvePtr::DtkDynamicCast( inCurve ) );
5835  type = type;
5836  break;
5837  }
5838  default:
5839  {
5840  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NurbsCurvePtr( F, Dtk_NurbsCurvePtr::DtkDynamicCast( inCurve->ToNurbs() ) );
5841  break;
5842  }
5843  }
5844  fprintf( F, "</Dtk_CurvePtr>" );
5845  return dtkNoError;
5846  }

◆ Dtk_DumpXml_DTK_DATUM_COMPOSING_RULE()

Dtk_ErrorStatus Dtk_DumpXml_DTK_DATUM_COMPOSING_RULE ( FILE *  F,
const DTK_DATUM_COMPOSING_RULE &  D 
)
2566  {
2567  fprintf( F, "<DTK_DATUM_COMPOSING_RULE>" );
2568  switch( D )
2569  {
2570  default:
2571  case DTK_UNKNOWN:
2572  fprintf( F, "DTK_UNKNOWN" );
2573  break;
2574  case DTK_WITH_HIERARCHY:
2575  fprintf( F, "DTK_WITH_HIERARCHY" );
2576  break;
2577  case DTK_WITHOUT_HIERARCHY:
2578  fprintf( F, "DTK_WITHOUT_HIERARCHY" );
2579  break;
2580  case DTK_INDIFFERENT_HIERARCHY:
2581  fprintf( F, "DTK_INDIFFERENT_HIERARCHY" );
2582  break;
2583  }
2584  fprintf( F, "</DTK_DATUM_COMPOSING_RULE>\n" );
2585  return dtkNoError;
2586  }

◆ Dtk_DumpXml_Dtk_DatumTargetPtr()

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

◆ Dtk_DumpXml_Dtk_dir()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_dir ( FILE *  F,
const Dtk_dir &  D,
const char *  b = "Dir" 
)
4189  {
4190  fprintf( F, "<%s>(%f %f %f)</%s>\n", b, D[ 0 ], D[ 1 ], D[ 2 ], b );
4191  return dtkNoError;
4192  }

◆ Dtk_DumpXml_Dtk_DrawingPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_DrawingPtr ( FILE *  ,
const Dtk_DrawingPtr &  ,
const int &  compact = 1 
)
2999  {
3000  if( F == NULL )
3001  {
3002  return dtkErrorNullPointer;
3003  }
3004  Dtk_Size_t i;
3005  fprintf( F, "<Dtk_DrawingPtr>\n" );
3006  Dtk_DumpXml_Dtk_info( F, D->get_info() );
3007  fprintf( F, "<Width>%f</Width><Height>%f</Height>\n", D->Width(), D->Height() );
3008  fprintf( F, "<Annotations><Number>" XmlFormat( "u" )"</Number>\n", D->GetNum2dEntities() );
3009  for( i = 0; i < D->GetNum2dEntities(); i++ )
3010  {
3011  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_2dEntityPtr( F, D->Get2dEntity( i ), compact );
3012  }
3013  fprintf( F, "</Annotations>\n" );
3014  fprintf( F, "<Views><Number>" XmlFormat( "u" )"</Number>\n", D->GetNumViews() );
3015  for( i = 0; i < D->GetNumViews(); i++ )
3016  {
3017  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, D->GetOrigin( i ), "Origin" );
3018  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ViewPtr( F, D->GetView( i ), compact );
3019  }
3020  fprintf( F, "</Views>\n" );
3021  fprintf( F, "</Dtk_DrawingPtr>\n" );
3022  return dtkNoError;
3023  }

◆ Dtk_DumpXml_DTK_FDT_MODIFIER()

Dtk_ErrorStatus Dtk_DumpXml_DTK_FDT_MODIFIER ( FILE *  F,
const DTK_FDT_MODIFIER &  D 
)
2588  {
2589  fprintf( F, "<DTK_FDT_MODIFIER>" );
2590  switch( D )
2591  {
2592  default:
2593  case DTK_FDT_MODIFIER_NOT_SET:
2594  fprintf( F, "DTK_FDT_MODIFIER_NOT_SET" );
2595  break;
2596  case DTK_FDT_MODIFIER_MAX_MATERIAL:
2597  fprintf( F, "DTK_FDT_MODIFIER_MAX_MATERIAL" );
2598  break;
2599  case DTK_FDT_MODIFIER_LEAST_MATERIAL:
2600  fprintf( F, "DTK_FDT_MODIFIER_LEAST_MATERIAL" );
2601  break;
2602  case DTK_FDT_MODIFIER_REGARDLESS_OF_FEATURE_SIZE:
2603  fprintf( F, "DTK_FDT_MODIFIER_REGARDLESS_OF_FEATURE_SIZE" );
2604  break;
2605  case DTK_FDT_MODIFIER_NONE:
2606  fprintf( F, "DTK_FDT_MODIFIER_NONE" );
2607  break;
2608  }
2609  fprintf( F, "</DTK_FDT_MODIFIER>\n" );
2610  return dtkNoError;
2611  }

◆ Dtk_DumpXml_Dtk_FdtCapturePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtCapturePtr ( FILE *  F,
const Dtk_FdtCapturePtr &  inVal 
)

◆ Dtk_DumpXml_Dtk_FdtDataSet()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtDataSet ( FILE *  F,
const Dtk_ComponentPtr &  inObject 
)

◆ Dtk_DumpXml_Dtk_FdtPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtPtr ( FILE *  F,
const Dtk_FdtPtr &  D,
const int &  compact = 1 
)
3028  {
3029  fprintf( F, "<Dtk_FdtPtr>\n" );
3030  if( D.IsNotNULL() )
3031  {
3032  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, D->info() );
3033 
3034  if( D->info().IsNotNULL() )
3035  {
3036  D->Sub2DEntity()->info()->SetBlankedStatus( D->info()->GetBlankedStatus() );
3037  }
3038 
3039 
3040  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, D->TransformationMatrix() );
3041  Dtk_Fdt::ScreenDisplayEnum ScreenDisplayAttribute = D->GetScreenDisplayAttribute();
3042 
3043  if( ScreenDisplayAttribute != Dtk_Fdt::Default )
3044  {
3045  fprintf( F, "<ScreenDisplayAttribute>%s</ScreenDisplayAttribute>\n", Dtk_Fdt::ScreenDisplayEnumToString( ScreenDisplayAttribute ).c_str() );
3046  }
3047  fprintf( F, "<IsZoomable>%s</IsZoomable>\n", D->GetIsZoomableAttribute() == true ? "True" : "False" );
3048 
3049  Dtk_Int32 ColorIdData = -1;
3050  if ( D->GetDisplayBackgroundColorId(ColorIdData) == dtkNoError )
3051  {
3052  fprintf(F, "<DisplayBackgroundColor>\n");
3053  Dtk_RGB rgb;
3054  Dtk_API::GetAPI()->GetColorInTable(ColorIdData, rgb);
3055  Dtk_DumpXml_Dtk_RGB(F, rgb);
3056  fprintf(F, "</DisplayBackgroundColor>\n");
3057  }
3058 
3059  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_2dEntityPtr( F, D->Sub2DEntity(), compact );
3060 
3061  }
3062  else
3063  {
3064  fprintf( F, "Null" );
3065  }
3066  fprintf( F, "</Dtk_FdtPtr>\n" );
3067  return dtkNoError;
3068  }

◆ Dtk_DumpXml_Dtk_FdtViewPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtViewPtr ( FILE *  F,
const Dtk_FdtViewPtr &  inVal 
)
3071  {
3072  Dtk_Size_t i;
3073 
3074  fprintf( F, "<Dtk_FdtView>\n" );
3075  if( inVal.IsNotNULL() )
3076  {
3077  //info
3078  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->info() );
3079 
3080  //FDTs
3081  Dtk_Size_t NumFdts = inVal->GetNumFdtIds();
3082  fprintf( F, "<FDTs Size=\'" XmlFormat( "u" )"\'>\n", NumFdts );
3083  for( i = 0; i < NumFdts; i++ )
3084  {
3085  fprintf( F, "<Id%d/>\n", inVal->GetFdtId( i ) );
3086  }
3087  fprintf( F, "</FDTs>\n" );
3088 
3089  //Matrix
3090  fprintf( F, "<Placement_Matrix>\n" );
3091  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inVal->PlacementMatrix() );
3092  fprintf( F, "</Placement_Matrix>\n" );
3093  }
3094  else
3095  {
3096  fprintf( F, "Null" );
3097  }
3098  fprintf( F, "</Dtk_FdtView>\n" );
3099  return dtkNoError;
3100 
3101  }

◆ Dtk_DumpXml_Dtk_FeaturePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FeaturePtr ( FILE *  F,
const Dtk_FeaturePtr &  inVal 
)
8118  {
8119  fprintf( f, "<Dtk_FeaturePtr>\n" );
8120  fprintf( f, "<FeatId>%d</FeatId>\n", inToWrite->GetId() );
8121  if( inToWrite->name.len() )
8122  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( f, L"Name", inToWrite->GetName() );
8123  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( f, L"Type", inToWrite->GetTypeAsString() );
8124  fprintf( f, "<IsActive>%d</IsActive>\n", inToWrite->IsActive() );
8125 
8126  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetInputGeometry(), "InputGeometry" );
8127  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetOutputGeometry(), "OutputGeometry" );
8128  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetAssociatedGeometry(), "AssociatedGeometry" );
8129  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetFinalAssociatedGeometry(), "FinalAssociatedGeometry" );
8130 
8131  switch( inToWrite->GetType() )
8132  {
8133  case DTK_FEAT_HOLE:
8134  Dtk_DumpXml_FeatHole( f, inToWrite->GetHole() );
8135  break;
8136  // case DTK_FEAT_HOLE_SERIES :
8137  // Dtk_DumpXml_FeatHoleSeries(f,inToWrite->GetHoleSeries());
8138  // break;
8139  // case DTK_FEAT_UDF :
8140  // Dtk_DumpXml_FeatUDF(f,inToWrite->GetUdf());
8141  // break;
8142  case DTK_FEAT_THREAD:
8143  Dtk_DumpXml_FeatThread( f, inToWrite->GetThread() );
8144  break;
8145  // case DTK_FEAT_PRISM :
8146  // Dtk_DumpXml_FeatPrism(f, inToWrite->GetPrism());
8147  // break;
8148  // case DTK_FEAT_REVOL :
8149  // Dtk_DumpXml_FeatRevol (f, inToWrite->GetRevol());
8150  // break;
8151  // case DTK_FEAT_SHELL:
8152  // Dtk_DumpXml_FeatShell (f, inToWrite->GetRevol());
8153  // break;
8154  // case DTK_FEAT_FILLET:
8155  // Dtk_DumpXml_FeatFillet (f, inToWrite->GetRevol());
8156  // break;
8157  // case DTK_FEAT_SWEEP:
8158  // Dtk_DumpXml_FeatSweep (f, inToWrite->GetRevol());
8159  // break;
8160  // case DTK_FEAT_CHAMFER:
8161  // Dtk_DumpXml_FeatChamfer (f, inToWrite->GetRevol());
8162  // break;
8163  // case DTK_FEAT_SPLIT_SURF:
8164  // Dtk_DumpXml_FeatSplitSurf (f, inToWrite->GetRevol());
8165  // break;
8166  // case DTK_FEAT_THICK_SURF:
8167  // Dtk_DumpXml_FeatThickSurf (f, inToWrite->GetRevol());
8168  // break;
8169  // case DTK_FEAT_SEW_SURF:
8170  // Dtk_DumpXml_FeatSewSurf (f, inToWrite->GetRevol());
8171  // break;
8172  // case DTK_FEAT_CLOSE_SURF:
8173  // Dtk_DumpXml_FeatCloseSurf(f, inToWrite->GetRevol());
8174  // break;
8175  case DTK_FEAT_PATTERN:
8176  Dtk_DumpXml_FeatPattern( f, inToWrite->GetPattern() );
8177  break;
8178  // case DTK_FEAT_USER_PATTERN:
8179  // Dtk_DumpXml_FeatUserPattern (f, inToWrite->GetRevol());
8180  // break;
8181  // case DTK_FEAT_MIRROR:
8182  // Dtk_DumpXml_FeatMirror(f, inToWrite->GetRevol());
8183  // break;
8184  // case DTK_FEAT_DRAFT :
8185  // Dtk_DumpXml_FeatDraft(f, inToWrite->GetRevol());
8186  // break;
8187  // case DTK_FEAT_TRANSLATE:
8188  // break;
8189  // case DTK_FEAT_ROTATE:
8190  // break;
8191  // case DTK_FEAT_REMOVE_FACE :
8192  // break;
8193  // case DTK_FEAT_STIFFENER:
8194  // break;
8195  // case DTK_FEAT_FACE_FILLET:
8196  // break;
8197  // case DTK_FEAT_TRITANGENT_FILLET:
8198  // break;
8199  // case DTK_FEAT_MULTI_PAD:
8200  // break;
8201  // case DTK_FEAT_MULTI_POCKET:
8202  // break;
8203  // case DTK_FEAT_LOFT:
8204  // break;
8205  // case DTK_FEAT_THICKNESS:
8206  // break;
8207  // case DTK_FEAT_SCALING:
8208  // break;
8209  // case DTK_FEAT_USER_DEFINED:
8210  // Dtk_DumpXml_FeatUserDefined (f, inToWrite->GetUserDefined());
8211  // break;
8212  // case DTK_FEAT_PIPE:
8213  // Dtk_DumpXml_FeatPipe (f, inToWrite->GetPipe());
8214  // break;
8215  // case DTK_FEAT_SPOT_POINT:
8216  // Dtk_DumpXml_FeatSpotPoint(f, inToWrite->GetSpotPoint());
8217  // break;
8218 
8219  default:
8220  break;
8221  }
8222  fprintf( f, "</Dtk_FeaturePtr>\n" );
8223  return dtkNoError;
8224  }

◆ Dtk_DumpXml_Dtk_GeometricalTolerancePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_GeometricalTolerancePtr ( FILE *  F,
const Dtk_GeometricalTolerancePtr &  D 
)
2514  {
2515  fprintf( F, "<Dtk_GeometricalTolerancePtr>\n" );
2516  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_AnnotationPtr( F, Dtk_AnnotationPtr::DtkDynamicCast( D ) ); // upcasting
2517 
2518  Dtk_Size_t i, TolSpecContNb;
2519  TolSpecContNb = D->GetToleranceSpecificationContainerNb();
2520  fprintf( F, "<TolSpecConts TolSpecContNb = \"" XmlFormat( "u" )"\">\n", TolSpecContNb );
2521  for( i = 0; i < TolSpecContNb; i++ )
2522  {
2523  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr( F, D->at( i ) );
2524  }
2525  fprintf( F, "</TolSpecConts>\n" );
2526  fprintf( F, "</Dtk_GeometricalTolerancePtr>\n" );
2527  return dtkNoError;
2528  }

◆ Dtk_DumpXml_Dtk_GraphicalDataPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_GraphicalDataPtr ( FILE *  F,
const Dtk_GraphicalDataPtr &  inVal 
)
8321  {
8322  if( inGraphicalData.IsNULL() )
8323  return dtkErrorNullPointer;
8324  int nbt = 0;
8325  int i, nb = ( int )inGraphicalData->GetNumMeshes();
8326  for( i = 0; i < nb; i++ )
8327  {
8328  Dtk_MeshPtr me = inGraphicalData->GetMesh( i );
8329  Dtk_DumpXml_Dtk_MeshPtr( F, me );
8330  }
8331  nbt = nb;
8332  nb = ( int )inGraphicalData->GetNumDrawings();
8333  nbt += nb;
8334  for( i = 0; i < nb; i++ )
8335  {
8336  Dtk_DrawingPtr dr = inGraphicalData->GetDrawing( i );
8337  Dtk_DumpXml_Dtk_DrawingPtr( F, dr );
8338  }
8339  Dtk_CameraPtr defcam = inGraphicalData->GetDefaultCamera();
8340  if( defcam.IsNotNULL() )
8341  {
8342  Dtk_DumpXml_Dtk_CameraPtr( F, defcam );
8343  }
8344  if( nbt == 0 )
8345  return dtkWarningNoEntitiesWritten;
8346  else
8347  return dtkNoError;
8348  }

◆ Dtk_DumpXml_Dtk_GridPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_GridPtr ( FILE *  F,
const Dtk_GridPtr &  D 
)
2356  {
2357  Dtk_string majorStyle, minorStyle;
2358  fprintf( F, "<Dtk_Grid>\n" );
2359 
2360  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_AnnotationPtr( F, Dtk_AnnotationPtr::DtkDynamicCast( D ) ); // upcasting
2361  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, D->GetBoundingBox() );
2362  fprintf( F, "<uSpacing>%f</uSpacing>\n", D->GetUSpacing() );
2363  fprintf( F, "<vSpacing>%f</vSpacing>\n", D->GetVSpacing() );
2364  fprintf( F, "<uMinorPerMajor>%d</uMinorPerMajor>\n", D->GetUMinorPerMajor() );
2365  fprintf( F, "<vMinorPerMajor>%d</vMinorPerMajor>\n", D->GetVMinorPerMajor() );
2366  Dtk_DumpXml_Dtk_FontLineTypeEnum( F, D->GetMajorLineStyle(), "majorLineStyle" );
2367  Dtk_DumpXml_Dtk_FontLineTypeEnum( F, D->GetMinorLineStyle(), "minorLineStyle" );
2368  fprintf( F, "<majorLineWidth>%f</majorLineWidth>\n", D->GetMajorLineWidth() );
2369  fprintf( F, "<minorLineWidth>%f</minorLineWidth>\n", D->GetMinorLineWidth() );
2370  fprintf( F, "<displayGridOption>%d</displayGridOption>\n", D->GetDisplayGridOption() );
2371  fprintf( F, "<displayOnTopOption>%d</displayOnTopOption>\n", D->GetDisplayOnTopOption() );
2372  fprintf( F, "<displayMajorLinesOption>%d</displayMajorLinesOption>\n", D->GetDisplayMajorLinesOption() );
2373  Dtk_DumpXml_Dtk_Grid_ShowLabelOptionEnum( F, D->GetDisplayShowLabelOption(), "displayShowLabelOption" );
2374  Dtk_DumpXml_Dtk_Grid_OriginReferenceOptionEnum( F, D->GetDisplayOriginReferenceOption(), "displayOriginReferenceOption" );
2375 
2376  fprintf( F, "</Dtk_Grid>\n" );
2377  return dtkNoError;
2378  }

◆ 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() ); } /*

4002  {
4003  Dtk_status st;
4004  Dtk_MaterialPtr material = NULL;
4005 
4006  if( I.IsNULL() )
4007  return dtkNoError;
4008 
4009  Dtk_tab<Dtk_string> lst;
4010  I->ListAllAttributes( lst );
4011  Dtk_Size_t i;
4012  const Dtk_Size_t size = lst.size();
4013  {
4014  fprintf( F, "<Dtk_Info>\n" );
4015 
4016  fprintf( F, "<Dtk_ID>%i</Dtk_ID>\n", I->GetId() );
4017 
4018 
4019  for( i = 0; i < size; i++ )
4020  {
4021  Dtk_Val v;
4022  if( lst[ i ] == "Dtk_Render" )
4023  {
4024  //int index = I->GetColorId();
4025  Dtk_RenderInfosPtr color = I->GetRenderInfos();
4026  //shader type
4027  Dtk_RenderInfos::RenderMappingShaderTypeEnum shadertype = Dtk_RenderInfos::Unknown;
4028  shadertype = color->GetShaderType();
4029  //
4030  const Dtk_string colorName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( color->GetName() );
4031  if( color->GetLightMap().IsNotNULL() )
4032  {
4033  if( shadertype != Dtk_RenderInfos::Unknown )
4034  {
4035  Dtk_RGB ambient = color->GetLightMap()->GetAmbientColor();
4036  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",
4037  I->GetRenderInfosId(), colorName.c_str(), shadertype, ambient[ 0 ], ambient[ 1 ], ambient[ 2 ], ambient[ 3 ] );
4038 
4039  }
4040  else
4041  {
4042  Dtk_RGB ambient = color->GetLightMap()->GetAmbientColor();
4043  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",
4044  I->GetRenderInfosId(), colorName.c_str(), ambient[ 0 ], ambient[ 1 ], ambient[ 2 ], ambient[ 3 ] );
4045  }
4046  }
4047  else
4048  {
4049  if( shadertype != Dtk_RenderInfos::Unknown )
4050  {
4051  fprintf( F, "<Dtk_Render><id>%d</id><name>%s</name><shadertype>%d</shadertype></Dtk_Render>\n",
4052  I->GetRenderInfosId(), colorName.c_str(), shadertype ); // render sans lightmap (texture possible)
4053  }
4054  else
4055  {
4056  fprintf( F, "<Dtk_Render><id>%d</id><name>%s</name></Dtk_Render>\n",
4057  I->GetRenderInfosId(), colorName.c_str() ); // render sans lightmap (texture possible)
4058  }
4059  }
4060  }
4061  else if( lst[ i ] == "Dtk_ColorId" )
4062  {
4063  //int index = I->GetColorId();
4064  Dtk_RGB color = I->GetColor();
4065  fprintf( F, "<Dtk_Color><r>%d</r><g>%d</g><b>%d</b><a>%d</a>", color[ 0 ], color[ 1 ], color[ 2 ], color[ 3 ] );
4066  if( color.IndexReader() >= 0 )
4067  {
4068  fprintf( F, "<IndexReader>%d</IndexReader>", color.IndexReader() );
4069  }
4070  fprintf( F, "</Dtk_Color>\n" );
4071 
4072 
4073 
4074  }
4075  else if( lst[ i ] == "Dtk_CurveThickNessInMM" )
4076  {
4077  double bval = I->GetCurveThickNessInMM();
4078  fprintf( F, "<Dtk_CurveThickNessInMM><double>%f</double></Dtk_CurveThickNessInMM>\n", bval );
4079  }
4087  else if( lst[ i ] == "Dtk_Uuid" )
4088  {
4089  Dtk_UUID uuid;
4090  uuid = I->GetUuid();
4091  fprintf( F, "<Dtk_uuid>\n" );
4092  for( Dtk_Size_t j = 0; j < 4; j++ )
4093  {
4094  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, uuid[ j ] );
4095  }
4096  fprintf( F, "</Dtk_uuid>\n" );
4097  }
4098  else if( lst[ i ] == "Dtk_CurveLineTypeDefinition" )
4099  {
4100  bool couldNotSpecialDump = true;
4101 
4102  const Dtk_ID curveLineDefinitionId = I->GetCurveLineTypeDefinitionId();
4103  const Dtk_API *const dtkAPI = Dtk_API::GetAPI();
4104  if( dtkAPI )
4105  {
4106  const Dtk_LineTypeDefinitionPtr &lineTypeDefinition = dtkAPI->GetCurveLineTypeDefinitionInTable( curveLineDefinitionId );
4107  if( lineTypeDefinition.IsNotNULL() )
4108  {
4109  const Dtk_string name = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lineTypeDefinition->GetName(), XMLGenericString );
4110  const Dtk_string dtkFontLineTypeEnum = Dtk_ConvertFontLineTypeEnumToString( lineTypeDefinition->GetClosestAppearanceInFontLineTypeEnumeration() );
4111  const Dtk_Size_t nbPatterns = lineTypeDefinition->GetPatternLength();
4112 
4113  const bool isNameNull = name.is_NULL();
4114 
4115  const Dtk_string xmlTitle = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lst[ i ], XMLElement );
4116  const Dtk_string printFDef = "<int>%d (=> Name: " +
4117  Dtk_string( isNameNull ? "(null)" : "&quot;%s&quot;" ) +
4118  " - ClosestDtk_FontLineType: &quot;%s&quot; - PatternLength: " XmlFormat( "u" ) ")</int> \n";
4119 
4120  fprintf( F, "<%s>\n", xmlTitle.c_str() );
4121  if( isNameNull )
4122  {
4123  fprintf( F,
4124  printFDef.c_str(),
4125  curveLineDefinitionId,
4126  dtkFontLineTypeEnum.c_str(),
4127  nbPatterns );
4128  }
4129  else
4130  {
4131  fprintf( F,
4132  printFDef.c_str(),
4133  curveLineDefinitionId,
4134  name.c_str(),
4135  dtkFontLineTypeEnum.c_str(),
4136  nbPatterns );
4137  }
4138  fprintf( F, "</%s>\n", xmlTitle.c_str() );
4139 
4140  couldNotSpecialDump = false;
4141  }
4142  }
4143 
4144  // If could not dump correctly, use usual dump (Should not happen).
4145  if( couldNotSpecialDump )
4146  {
4147  I->FindAttribute( lst[ i ], v );
4148  Dtk_string title = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lst[ i ], XMLElement );
4149 
4150  fprintf( F, "<%s>\n", title.c_str() );
4151  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, v );
4152  fprintf( F, "</%s>\n", title.c_str() );
4153  }
4154  }
4155  else
4156  {
4157  I->FindAttribute( lst[ i ], v );
4158  Dtk_string title = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lst[ i ], XMLElement );
4159 
4160  fprintf( F, "<%s>\n", title.c_str() );
4161  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, v );
4162  fprintf( F, "</%s>\n", title.c_str() );
4163  }
4164  }
4165 
4166  //Usefull if you want to handle NX referenceSet
4167  /*
4168  Dtk_tab <Dtk_string> refset;
4169  I->GetReferenceSet(refset,DTK_TRUE);
4170  for (i = 0; i < refset.size(); i++)
4171  fprintf(F, "<Dtk_ReferenceSet_%u>%S</Dtk_ReferenceSet_%u>\n", i, refset[i].w_str(), i);
4172  */
4173 
4174  fprintf( F, "</Dtk_Info>\n" );
4175  }
4176 
4177  return dtkNoError;
4178  }

◆ Dtk_DumpXml_Dtk_KinematicsCommand()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCommand ( FILE *  inFile,
const Dtk_KinCommandPtr &  inCommand,
Dtk_bool  simplified 
)
7364  {
7365  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7366  if( inFile == NULL )
7367  return dtkErrorNullPointer;
7368 
7369  fprintf( inFile, "<command name=\"%s\" id=\"%d\">\n", inCommand->getName().c_str(), inCommand->getId() );
7370  if( simplified == DTK_FALSE )
7371  {
7372  fprintf( inFile, "<attributCommand type=\"%d\" value=\"%f\"/>\n", inCommand->getType(), inCommand->getValue() );
7373  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, inCommand->getJoint(), DTK_TRUE );
7374  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inCommand->getParameter() );
7375  }
7376  fprintf( inFile, "</command>\n" );
7377 
7378  return dtkErrorStatus;
7379  }

◆ Dtk_DumpXml_Dtk_KinematicsConstraint()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsConstraint ( FILE *  inFile,
const Dtk_KinConstraintPtr &  inConstraint,
Dtk_bool  simplified 
)
7156  {
7157  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7158  if( inFile == NULL )
7159  return dtkErrorNullPointer;
7160 
7161  Dtk_Size_t i, nbVal;
7162 
7163  const Dtk_string inConstraintName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inConstraint->getName() );
7164  fprintf( inFile, "<constraint name=\"%s\" id=\"%d\">\n", inConstraintName.c_str(), inConstraint->getId() );
7165  if( simplified == DTK_FALSE )
7166  {
7167  if( inConstraint->hasAttribute( inConstraint->_MODE_INTEGER ) ||
7168  inConstraint->hasAttribute( inConstraint->_VALUE ) ||
7169  inConstraint->hasAttribute( inConstraint->_ORIENTATION ) ||
7170  inConstraint->hasAttribute( inConstraint->_REFERENCE ) ||
7171  inConstraint->hasAttribute( inConstraint->_POSITION ) )
7172  {
7173  fprintf( inFile, "<attributConstraint" );
7174  if( inConstraint->hasAttribute( inConstraint->_MODE_INTEGER ) )
7175  {
7176  fprintf( inFile, " modeInteger=\"%d\"", inConstraint->getModeInteger() );
7177  }
7178  if( inConstraint->hasAttribute( inConstraint->_VALUE ) )
7179  {
7180  fprintf( inFile, " value=\"%f\"", inConstraint->getValue()->getNamedValue()->getValue() );
7181  }
7182  if( inConstraint->hasAttribute( inConstraint->_ORIENTATION ) )
7183  {
7184  fprintf( inFile, " orientation=\"%f\"", inConstraint->getOrientation()->getNamedValue()->getValue() );
7185  }
7186  if( inConstraint->hasAttribute( inConstraint->_REFERENCE ) )
7187  {
7188  fprintf( inFile, " fixInSpace=\"%.0f\"", inConstraint->getReference()->getNamedValue()->getValue() );
7189  }
7190  fprintf( inFile, ">\n" );
7191  if( inConstraint->hasAttribute( inConstraint->_POSITION ) )
7192  {
7193  fprintf( inFile, "<matricePosition nbValue=\"12\"" );
7194  DumpTransfo( inFile, inConstraint->getPosition() );
7195  fprintf( inFile, "/>\n" );
7196  }
7197  fprintf( inFile, "</attributConstraint>\n" );
7198  }
7199  nbVal = inConstraint->getConnectorSize();
7200  if( nbVal > 0 )
7201  {
7202  fprintf( inFile, "<connectors>\n" );
7203  for( i = 0; i < nbVal; i++ )
7204  {
7205  Dtk_DumpXml_Dtk_NodeConnector( inFile, inConstraint->getConnector( i ) );
7206  }
7207  fprintf( inFile, "</connectors>\n" );
7208  }
7209  }
7210  fprintf( inFile, "</constraint>\n" );
7211 
7212  return dtkErrorStatus;
7213  }

◆ Dtk_DumpXml_Dtk_KinematicsCurve()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCurve ( FILE *  inFile,
const Dtk_KinCurvePtr &  inCurve 
)
7097  {
7098  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7099  if( inFile == NULL )
7100  return dtkErrorNullPointer;
7101 
7102  fprintf( inFile, "<curve fileName=\"%s\" idBlock=\"%d\"/>\n", inCurve->getFileName().c_str(), inCurve->getIdBlock() );
7103 
7104  return dtkErrorStatus;
7105  }

◆ Dtk_DumpXml_Dtk_KinematicsFixPart()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFixPart ( FILE *  inFile,
const Dtk_KinFixPartPtr &  inFixPart 
)
7382  {
7383  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7384  if( inFile == NULL )
7385  return dtkErrorNullPointer;
7386 
7387  fprintf( inFile, "<fixPart name=\"%s\" id=\"%d\">\n", inFixPart->getName().c_str(), inFixPart->getId() );
7388  if( inFixPart->getConstraint().IsNotNULL() )
7389  {
7390  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, inFixPart->getConstraint(), DTK_TRUE );
7391  }
7392  if( inFixPart->getPart().IsNotNULL() )
7393  {
7394  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inFixPart->getPart() );
7395  }
7396  fprintf( inFile, "</fixPart>\n" );
7397 
7398  return dtkErrorStatus;
7399  }

◆ Dtk_DumpXml_Dtk_KinematicsFormula()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFormula ( FILE *  inFile,
const Dtk_KinFormulaPtr &  inFormula 
)
7108  {
7109  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7110  if( inFile == NULL )
7111  return dtkErrorNullPointer;
7112 
7113  fprintf( inFile, "<formula name=\"%s\" id=\"%d\">\n", inFormula->getName().c_str(), inFormula->getId() );
7114  fprintf( inFile, "<attributFormula" );
7115  fprintf( inFile, " comment=\"%s\"", inFormula->getComment().c_str() );
7116  fprintf( inFile, " formula=\"%s\"", inFormula->getFormula().c_str() );
7117  fprintf( inFile, " parameter=\"%s\"/>\n", inFormula->getParam().c_str() );
7118  fprintf( inFile, "</formula>\n" );
7119 
7120  return dtkErrorStatus;
7121  }

◆ Dtk_DumpXml_Dtk_KinematicsJoint()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsJoint ( FILE *  inFile,
const Dtk_KinJointPtr &  inJoint,
Dtk_bool  simplified 
)
7216  {
7217  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7218  if( inFile == NULL )
7219  return dtkErrorNullPointer;
7220 
7221  Dtk_Size_t i, nb;
7222  Dtk_KinConstraintPtr constraint;
7223 
7224  fprintf( inFile, "<joint name=\"%s\" id=\"%d\">\n", inJoint->getName().c_str(), inJoint->getId() );
7225  if( simplified == DTK_FALSE )
7226  {
7227  fprintf( inFile, "<attributJoint type=\"%d\"", inJoint->getType() );
7228  if( inJoint->hasAttribute( L"_compoundType" ) )
7229  {
7230  fprintf( inFile, " compoundType=\"%d\"", inJoint->getCompoundType() );
7231  }
7232  if( inJoint->hasAttribute( inJoint->_PARAMETER1 ) )
7233  {
7234  fprintf( inFile, " parameter1=\"%f\"", inJoint->getParameter1() );
7235  }
7236  if( inJoint->hasAttribute( inJoint->_PARAMETER2 ) )
7237  {
7238  fprintf( inFile, " parameter2=\"%f\"", inJoint->getParameter2() );
7239  }
7240  if( inJoint->hasAttribute( inJoint->_RATIO ) )
7241  {
7242  fprintf( inFile, " ratio=\"%f\"", inJoint->getRatio() );
7243  }
7244  fprintf( inFile, ">\n" );
7245  if( inJoint->hasAttribute( inJoint->_UPPER_LIMIT1 ) ||
7246  inJoint->hasAttribute( inJoint->_LOWER_LIMIT1 ) ||
7247  inJoint->hasAttribute( inJoint->_UPPER_LIMIT2 ) ||
7248  inJoint->hasAttribute( inJoint->_LOWER_LIMIT2 ) )
7249  {
7250  fprintf( inFile, "<limit" );
7251  if( inJoint->hasAttribute( inJoint->_UPPER_LIMIT1 ) )
7252  {
7253  fprintf( inFile, " upperLimit1=\"%f\"", inJoint->getUpperLimit1() );
7254  }
7255  if( inJoint->hasAttribute( inJoint->_LOWER_LIMIT1 ) )
7256  {
7257  fprintf( inFile, " lowerLimit1=\"%f\"", inJoint->getLowerLimit1() );
7258  }
7259  if( inJoint->hasAttribute( inJoint->_UPPER_LIMIT2 ) )
7260  {
7261  fprintf( inFile, " upperLimit2=\"%f\"", inJoint->getUpperLimit2() );
7262  }
7263  if( inJoint->hasAttribute( inJoint->_LOWER_LIMIT2 ) )
7264  {
7265  fprintf( inFile, " lowerLimit2=\"%f\"", inJoint->getLowerLimit2() );
7266  }
7267  fprintf( inFile, "/>\n" );
7268  }
7269  fprintf( inFile, "<localFrame1 nbValue=\"12\"" );
7270  DumpTransfo( inFile, inJoint->getLocalFrame1() );
7271  fprintf( inFile, "/>\n" );
7272  fprintf( inFile, "<localFrame2 nbValue=\"12\"" );
7273  DumpTransfo( inFile, inJoint->getLocalFrame2() );
7274  fprintf( inFile, "/>\n" );
7275  if( inJoint->hasAttribute( inJoint->_LOCAL_FRAME3 ) )
7276  {
7277  fprintf( inFile, "<localFrame3 nbValue=\"12\"" );
7278  DumpTransfo( inFile, inJoint->getLocalFrame3() );
7279  fprintf( inFile, "/>\n" );
7280  }
7281  if( inJoint->hasAttribute( inJoint->_LOCAL_FRAME4 ) )
7282  {
7283  fprintf( inFile, "<localFrame4 nbValue=\"12\"" );
7284  DumpTransfo( inFile, inJoint->getLocalFrame4() );
7285  fprintf( inFile, "/>\n" );
7286  }
7287  if( inJoint->hasAttribute( inJoint->_ABSOLUT_POS1 ) )
7288  {
7289  fprintf( inFile, "<absolutePos1 nbValue=\"12\"" );
7290  DumpTransfo( inFile, inJoint->getAbsolutPos1() );
7291  fprintf( inFile, "/>\n" );
7292  }
7293  if( inJoint->hasAttribute( inJoint->_ABSOLUT_POS2 ) )
7294  {
7295  fprintf( inFile, "<absolutePos2 nbValue=\"12\"" );
7296  DumpTransfo( inFile, inJoint->getAbsolutPos2() );
7297  fprintf( inFile, "/>\n" );
7298  }
7299  fprintf( inFile, "</attributJoint>\n" );
7300  fprintf( inFile, "<parts>\n" );
7301  if( inJoint->hasAttribute( L"_part1" ) )
7302  {
7303  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inJoint->getPart1() );
7304  }
7305  if( inJoint->hasAttribute( L"_part2" ) )
7306  {
7307  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inJoint->getPart2() );
7308  }
7309  if( inJoint->hasAttribute( inJoint->_PART3 ) )
7310  {
7311  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inJoint->getPart3() );
7312  }
7313  fprintf( inFile, "</parts>\n" );
7314  if( inJoint->hasAttribute( inJoint->_CONSTRAINT ) )
7315  {
7316  fprintf( inFile, "<constraints>\n" );
7317  nb = inJoint->getConstraintSize();
7318  for( i = 0; i < nb; i++ )
7319  {
7320  constraint = inJoint->getConstraint( i );
7321  Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, constraint, DTK_TRUE );
7322  }
7323  fprintf( inFile, "</constraints>\n" );
7324  }
7325  if( inJoint->hasAttribute( inJoint->_CONNECTOR ) )
7326  {
7327  fprintf( inFile, "<connectors>\n" );
7328  nb = inJoint->getConnectorSize();
7329  for( i = 0; i < nb; i++ )
7330  {
7331  Dtk_DumpXml_Dtk_NodeConnector( inFile, inJoint->getConnector( i ) );
7332  }
7333  fprintf( inFile, "</connectors>\n" );
7334  }
7335  if( inJoint->hasAttribute( inJoint->_FIX_TOGETHER ) )
7336  {
7337  fprintf( inFile, "<fixTogether>\n" );
7338  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, inJoint->getFixTogether(), DTK_TRUE );
7339  fprintf( inFile, "</fixTogether>\n" );
7340  }
7341  if( inJoint->hasAttribute( inJoint->_RATIO_PARAMETER ) )
7342  {
7343  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inJoint->getRatioParameter() );
7344  }
7345  if( inJoint->hasAttribute( inJoint->_JOINT1 ) || inJoint->hasAttribute( inJoint->_JOINT2 ) )
7346  {
7347  fprintf( inFile, "<joints>\n" );
7348  if( inJoint->hasAttribute( inJoint->_JOINT1 ) )
7349  {
7350  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, inJoint->getJoint1(), DTK_TRUE );
7351  }
7352  if( inJoint->hasAttribute( inJoint->_JOINT2 ) )
7353  {
7354  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, inJoint->getJoint2(), DTK_TRUE );
7355  }
7356  fprintf( inFile, "</joints>\n" );
7357  }
7358  }
7359  fprintf( inFile, "</joint>\n" );
7360  return dtkNoError;
7361  }

◆ Dtk_DumpXml_Dtk_KinematicsLaw()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsLaw ( FILE *  inFile,
const Dtk_KinLawPtr &  inLaw 
)
7124  {
7125  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7126  if( inFile == NULL )
7127  return dtkErrorNullPointer;
7128 
7129  Dtk_Size_t i, nb;
7130 
7131  fprintf( inFile, "<law name=\"%s\" id=\"%d\">\n", inLaw->getName().c_str(), inLaw->getId() );
7132  fprintf( inFile, "<attributLaw comment=\"%s\" synchrone=\"%d\" active=\"%d\" algo=\"%d\"/>\n", inLaw->getComment().c_str(), inLaw->getSynchrone(), inLaw->getActive(), inLaw->getAlgo() );
7133  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsFormula( inFile, inLaw->getExpression() );
7134 
7135  if( inLaw->getCurveSize() + inLaw->getParameter().size() > 0 )
7136  {
7137  fprintf( inFile, "<parameters>\n" );
7138  nb = inLaw->getCurveSize();
7139  for( i = 0; i < nb; i++ )
7140  {
7141  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsCurve( inFile, inLaw->getCurve( i ) );
7142  }
7143  nb = inLaw->getParameter().size();
7144  for( i = 0; i < nb; i++ )
7145  {
7146  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inLaw->getParameter().at( i ), DTK_TRUE );
7147  }
7148  fprintf( inFile, "</parameters>\n" );
7149  }
7150  fprintf( inFile, "</law>\n" );
7151 
7152  return dtkNoError;
7153  }

◆ Dtk_DumpXml_Dtk_KinematicsMechanism()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsMechanism ( FILE *  inFile,
const Dtk_KinMechanismPtr &  inKinMechanism 
)
7466  {
7467  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7468  if( inFile == NULL )
7469  return dtkErrorNullPointer;
7470 
7471  Dtk_Size_t i, nbElt;
7472  Dtk_KinJointPtr joint;
7473  Dtk_KinCommandPtr cmd;
7474  Dtk_KinFixPartPtr fixPart;
7475 
7476  fprintf( inFile, "<mechanism name=\"%s\" id=\"%d\" version=\"%s\">\n", inKinMechanism->getName().c_str(), inKinMechanism->getId(), inKinMechanism->getVersion().c_str() );
7477 
7478  // Dump Mechanism joints
7479  fprintf( inFile, "<joints>\n" );
7480  nbElt = inKinMechanism->getJointSize();
7481  for( i = 0; i < nbElt; i++ )
7482  {
7483  joint = inKinMechanism->getJoint( i );
7484  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, joint, DTK_TRUE );
7485  }
7486  fprintf( inFile, "</joints>\n" );
7487 
7488  // Dump Mechanism commands
7489  fprintf( inFile, "<commands>\n" );
7490  nbElt = inKinMechanism->getCommandSize();
7491  for( i = 0; i < nbElt; i++ )
7492  {
7493  cmd = inKinMechanism->getCommand( i );
7494  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsCommand( inFile, cmd, DTK_TRUE );
7495  }
7496  fprintf( inFile, "</commands>\n" );
7497 
7498  // Dump Mechanism fix part
7499  fixPart = inKinMechanism->getFixPart();
7500  if( fixPart.IsNotNULL() )
7501  {
7502  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsFixPart( inFile, fixPart );
7503  }
7504 
7505  // Dump Mechanism time parameter
7506  fprintf( inFile, "<paramTime>\n" );
7507  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inKinMechanism->getParamTime() );
7508  fprintf( inFile, "</paramTime>\n" );
7509 
7510  // Dump Mechanism laws
7511  nbElt = inKinMechanism->getLawSize();
7512  if( nbElt > 0 )
7513  {
7514  fprintf( inFile, "<laws>\n" );
7515  for( i = 0; i < nbElt; i++ )
7516  {
7517  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsLaw( inFile, inKinMechanism->getLaw( i ) );
7518  }
7519  fprintf( inFile, "</laws>\n" );
7520  }
7521 
7522  // Dump Mechanism Speed Acceleration
7523  nbElt = inKinMechanism->getSpeedAccelerationSize();
7524  if( nbElt > 0 )
7525  {
7526  fprintf( inFile, "<speedsAccelerations>\n" );
7527  for( i = 0; i < nbElt; i++ )
7528  {
7529  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration( inFile, inKinMechanism->getSpeedAcceleration( i ) );
7530  }
7531  fprintf( inFile, "</speedsAccelerations>\n" );
7532  }
7533  fprintf( inFile, "</mechanism>\n" );
7534 
7535  return dtkErrorStatus;
7536  }

◆ Dtk_DumpXml_Dtk_KinematicsNamedValue()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsNamedValue ( FILE *  inFile,
const Dtk_KinNamedValuePtr &  inNamedValue 
)
6863  {
6864  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
6865  if( inFile == NULL )
6866  return dtkErrorNullPointer;
6867 
6868  fprintf( inFile, "<namedValue name=\"%s\" value=\"%f\"/>\n", inNamedValue->getName().c_str(), inNamedValue->getValue() );
6869  return dtkErrorStatus;
6870  }

◆ Dtk_DumpXml_Dtk_KinematicsParameter()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsParameter ( FILE *  inFile,
const Dtk_KinParameterPtr &  inParameter,
Dtk_bool  simplified = DTK_FALSE 
)
6873  {
6874  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
6875  if( inFile == NULL )
6876  return dtkErrorNullPointer;
6877 
6878  int i;
6879 
6880  fprintf( inFile, "<parameter name=\"%s\" id=\"%d\"", inParameter->getName().c_str(), inParameter->getId() );
6881  if( simplified == DTK_TRUE )
6882  {
6883  Dtk_string tmp;
6884  switch( inParameter->getParentType() )
6885  {
6886  case DTK_KIN_TYPE_COMMAND:
6887  tmp.convert_from_int( ( ( Dtk_KinCommand * )inParameter->getParentElement() )->getId() );
6888  tmp += L"_COMMAND";
6889  break;
6890  case DTK_KIN_TYPE_JOINT:
6891  tmp.convert_from_int( ( ( Dtk_KinJoint * )inParameter->getParentElement() )->getId() );
6892  tmp += L"_JOINT";
6893  break;
6894  case DTK_KIN_TYPE_MECHANISM:
6895  tmp.convert_from_int( ( ( Dtk_KinMechanism * )inParameter->getParentElement() )->getId() );
6896  tmp += L"_MECHANISM";
6897  break;
6898  case DTK_KIN_TYPE_LAW:
6899  tmp.convert_from_int( ( ( Dtk_KinLaw * )inParameter->getParentElement() )->getId() );
6900  tmp += L"_LAW";
6901  break;
6902  case DTK_KIN_TYPE_SPEED_ACCELERATION:
6903  tmp.convert_from_int( ( ( Dtk_KinSpeedAcceleration * )inParameter->getParentElement() )->getId() );
6904  tmp += L"_SPEED_ACCELERATION";
6905  break;
6906  default:
6907  tmp = L"DTK_UNKNOWN";
6908  break;
6909  }
6910  fprintf( inFile, " parent=\"%s\"", tmp.c_str() );
6911  }
6912  fprintf( inFile, ">\n" );
6913  if( simplified == DTK_FALSE )
6914  {
6915  if( inParameter->hasAttribute( inParameter->_RANGE ) )
6916  {
6917  fprintf( inFile, "<range nbValue=\"4\"" );
6918  for( i = 0; i < 4; i++ )
6919  {
6920  fprintf( inFile, " _%d=\"%f\"", i + 1, inParameter->getRange( i ) );
6921  }
6922  fprintf( inFile, "/>\n" );
6923  }
6924  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsNamedValue( inFile, inParameter->getNamedValue() );
6925  }
6926  fprintf( inFile, "</parameter>\n" );
6927 
6928  return dtkErrorStatus;
6929  }

◆ Dtk_DumpXml_Dtk_KinematicsProduct()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsProduct ( FILE *  inFile,
const Dtk_KinProductPtr &  inKinProduct,
int &  inKinProductIndex 
)
7402  {
7403  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7404  if( inFile == NULL )
7405  return dtkErrorNullPointer;
7406 
7407  Dtk_Size_t i, nb;
7408  Dtk_KinPartPtr part;
7409  Dtk_KinProductPtr prod;
7410  Dtk_string xmlName, productName, instanceName, fileName;
7411  Dtk_status tempDst;
7412 
7413  fprintf( inFile, "<product" );
7414  productName = inKinProduct->name();
7415  if( productName.is_not_NULL() )
7416  {
7417  xmlName = productName;
7418  tempDst = validate_xml_string( xmlName );
7419  fprintf( inFile, " name=\"%s\"", xmlName.c_str() );
7420  }
7421  fprintf( inFile, " id=\"%d\"", inKinProduct->id() );
7422 
7423  instanceName = inKinProduct->instanceName();
7424  if( instanceName.is_not_NULL() )
7425  {
7426  xmlName = instanceName;
7427  tempDst = validate_xml_string( xmlName );
7428  fprintf( inFile, " instanceName=\"%s\"", xmlName.c_str() );
7429  }
7430  fileName = inKinProduct->fileName();
7431  if( fileName.is_not_NULL() )
7432  {
7433  xmlName = fileName;
7434  tempDst = validate_xml_string( xmlName );
7435  fprintf( inFile, " fileName=\"%s\"", xmlName.c_str() );
7436  }
7437 
7438  fprintf( inFile, ">\n<components>\n" );
7439  nb = inKinProduct->getNbPart();
7440  nb += inKinProduct->getNbProduct();
7441  part = NULL;
7442  prod = NULL;
7443  for( i = 0; i < nb; i++ )
7444  {
7445  inKinProductIndex++;
7446  prod = inKinProduct->searchProductByNumChild( inKinProductIndex );
7447  if( part.IsNotNULL() )
7448  {
7449  Dtk_DumpXml_Dtk_ComponentPtr( inFile, part );
7450  part = NULL;
7451  }
7452  if( prod.IsNotNULL() )
7453  {
7454  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsProduct( inFile, prod, inKinProductIndex );
7455  prod = NULL;
7456  }
7457  }
7458 
7459  fprintf( inFile, "</components>\n" );
7460  fprintf( inFile, "</product>\n" );
7461 
7462  return dtkNoError;
7463  }

◆ Dtk_DumpXml_Dtk_KinematicsPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsPtr ( FILE *  inFile,
const Dtk_KinematicPtr &  inKinematic 
)
7539  {
7540  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7541  if( inFile == NULL )
7542  return dtkErrorNullPointer;
7543 
7544  Dtk_Size_t size, i;
7545  Dtk_KinPartPtr part;
7546  Dtk_KinConstraintPtr constraint;
7547  Dtk_KinJointPtr joint;
7548  Dtk_KinCommandPtr command;
7549  Dtk_KinMechanismPtr mechanism;
7550  Dtk_status dstat;
7551 
7552  fprintf( inFile, "<kinematics>\n" );
7553 
7554  // Dump Kinematics Product
7555  if( inKinematic->getProduct().IsNotNULL() )
7556  {
7557  int iProductIndex = 0;
7558  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsProduct( inFile, inKinematic->getProduct(), iProductIndex );
7559  }
7560 
7561  // Dump Kinematics Parts
7562  fprintf( inFile, "<parts>\n" );
7563  size = inKinematic->getPartSize();
7564  for( i = 0; i < size; i++ )
7565  {
7566  part = inKinematic->getPart( i );
7567  Dtk_DumpXml_Dtk_ComponentPtr( inFile, part );
7568  if( dstat.isNotOK() )
7569  {
7570  return dtkErrorUnspecified;
7571  }
7572  }
7573  fprintf( inFile, "</parts>\n" );
7574 
7575  // Dump kinematics Constraints
7576  fprintf( inFile, "<constraints>\n" );
7577  size = inKinematic->getConstraintSize();
7578  for( i = 0; i < size; i++ )
7579  {
7580  constraint = inKinematic->getConstraint( i );
7581  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, constraint, DTK_FALSE );
7582  if( dtkErrorStatus != dtkNoError )
7583  {
7584  return dtkErrorStatus;
7585  }
7586  }
7587  fprintf( inFile, "</constraints>\n" );
7588 
7589  // Dump kinematics Joints
7590  fprintf( inFile, "<joints>\n" );
7591  size = inKinematic->getJointSize();
7592  for( i = 0; i < size; i++ )
7593  {
7594  joint = inKinematic->getJoint( i );
7595  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, joint, DTK_FALSE );
7596  if( dtkErrorStatus != dtkNoError )
7597  {
7598  return dtkErrorStatus;
7599  }
7600  }
7601  fprintf( inFile, "</joints>\n" );
7602 
7603  // Dump kinematics commands
7604  fprintf( inFile, "<commands>\n" );
7605  size = inKinematic->getCommandSize();
7606  for( i = 0; i < size; i++ )
7607  {
7608  command = inKinematic->getCommand( i );
7609  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsCommand( inFile, command, DTK_FALSE );
7610  if( dtkErrorStatus != dtkNoError )
7611  {
7612  return dtkErrorStatus;
7613  }
7614  }
7615  fprintf( inFile, "</commands>\n" );
7616 
7617  // Dump kinematics commands
7618  fprintf( inFile, "<mechanisms>\n" );
7619  size = inKinematic->getMechanismSize();
7620  for( i = 0; i < size; i++ )
7621  {
7622  mechanism = inKinematic->getMechanism( i );
7623  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsMechanism( inFile, mechanism );
7624  if( dtkErrorStatus != dtkNoError )
7625  {
7626  return dtkErrorStatus;
7627  }
7628  }
7629  fprintf( inFile, "</mechanisms>\n" );
7630 
7631  fprintf( inFile, "</kinematics>\n" );
7632  return dtkErrorStatus;
7633  }

◆ Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration ( FILE *  inFile,
const Dtk_KinSpeedAccelerationPtr &  inSpeedAcceleration 
)
6932  {
6933  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
6934  if( inFile == NULL )
6935  return dtkErrorNullPointer;
6936 
6937  fprintf( inFile, "<speedAcceleration name=\"%s\" id=\"%d\">\n", inSpeedAcceleration->getName().c_str(), inSpeedAcceleration->getId() );
6938 
6939  if( inSpeedAcceleration->getRefProd().IsNotNULL() )
6940  {
6941  fprintf( inFile, "<refProd>\n" );
6942  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inSpeedAcceleration->getRefProd() );
6943  fprintf( inFile, "</refProd>\n" );
6944  }
6945  if( inSpeedAcceleration->getPoint().IsNotNULL() )
6946  {
6947  fprintf( inFile, "<point>\n" );
6948  Dtk_DumpXml_Dtk_NodeConnector( inFile, inSpeedAcceleration->getPoint() );
6949  fprintf( inFile, "</point>\n" );
6950  }
6951 
6952  if( inSpeedAcceleration->getPtX().IsNotNULL() )
6953  {
6954  fprintf( inFile, "<pointX>\n" );
6955  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getPtX() );
6956  fprintf( inFile, "</pointX>\n" );
6957  }
6958  if( inSpeedAcceleration->getPtY().IsNotNULL() )
6959  {
6960  fprintf( inFile, "<pointY>\n" );
6961  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getPtY() );
6962  fprintf( inFile, "</pointY>\n" );
6963  }
6964  if( inSpeedAcceleration->getPtZ().IsNotNULL() )
6965  {
6966  fprintf( inFile, "<pointZ>\n" );
6967  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getPtZ() );
6968  fprintf( inFile, "</pointZ>\n" );
6969  }
6970 
6971  if( inSpeedAcceleration->getLinearSpeedX().IsNotNULL() )
6972  {
6973  fprintf( inFile, "<linearSpeedX>\n" );
6974  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeedX() );
6975  fprintf( inFile, "</linearSpeedX>\n" );
6976  }
6977  if( inSpeedAcceleration->getLinearSpeedY().IsNotNULL() )
6978  {
6979  fprintf( inFile, "<linearSpeedY>\n" );
6980  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeedY() );
6981  fprintf( inFile, "</linearSpeedY>\n" );
6982  }
6983  if( inSpeedAcceleration->getLinearSpeedZ().IsNotNULL() )
6984  {
6985  fprintf( inFile, "<linearSpeedZ>\n" );
6986  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeedZ() );
6987  fprintf( inFile, "</linearSpeedZ>\n" );
6988  }
6989  if( inSpeedAcceleration->getLinearSpeed().IsNotNULL() )
6990  {
6991  fprintf( inFile, "<linearSpeed>\n" );
6992  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeed() );
6993  fprintf( inFile, "</linearSpeed>\n" );
6994  }
6995 
6996  if( inSpeedAcceleration->getLinearAccelerationX().IsNotNULL() )
6997  {
6998  fprintf( inFile, "<linearAccelerationX>\n" );
6999  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAccelerationX() );
7000  fprintf( inFile, "</linearAccelerationX>\n" );
7001  }
7002  if( inSpeedAcceleration->getLinearAccelerationY().IsNotNULL() )
7003  {
7004  fprintf( inFile, "<linearAccelerationY>\n" );
7005  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAccelerationY() );
7006  fprintf( inFile, "</linearAccelerationY>\n" );
7007  }
7008  if( inSpeedAcceleration->getLinearAccelerationZ().IsNotNULL() )
7009  {
7010  fprintf( inFile, "<linearAccelerationZ>\n" );
7011  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAccelerationZ() );
7012  fprintf( inFile, "</linearAccelerationZ>\n" );
7013  }
7014  if( inSpeedAcceleration->getLinearAcceleration().IsNotNULL() )
7015  {
7016  fprintf( inFile, "<linearAcceleration>\n" );
7017  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAcceleration() );
7018  fprintf( inFile, "</linearAcceleration>\n" );
7019  }
7020 
7021  if( inSpeedAcceleration->getAngularSpeedX().IsNotNULL() )
7022  {
7023  fprintf( inFile, "<angularSpeedX>\n" );
7024  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeedX() );
7025  fprintf( inFile, "</angularSpeedX>\n" );
7026  }
7027  if( inSpeedAcceleration->getAngularSpeedY().IsNotNULL() )
7028  {
7029  fprintf( inFile, "<angularSpeedY>\n" );
7030  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeedY() );
7031  fprintf( inFile, "</angularSpeedY>\n" );
7032  }
7033  if( inSpeedAcceleration->getAngularSpeedZ().IsNotNULL() )
7034  {
7035  fprintf( inFile, "<angularSpeedZ>\n" );
7036  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeedZ() );
7037  fprintf( inFile, "</angularSpeedZ>\n" );
7038  }
7039  if( inSpeedAcceleration->getAngularSpeed().IsNotNULL() )
7040  {
7041  fprintf( inFile, "<angularSpeed>\n" );
7042  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeed() );
7043  fprintf( inFile, "</angularSpeed>\n" );
7044  }
7045 
7046  if( inSpeedAcceleration->getAngularAccelerationX().IsNotNULL() )
7047  {
7048  fprintf( inFile, "<angularAccelerationX>\n" );
7049  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAccelerationX() );
7050  fprintf( inFile, "</angularAccelerationX>\n" );
7051  }
7052  if( inSpeedAcceleration->getAngularAccelerationY().IsNotNULL() )
7053  {
7054  fprintf( inFile, "<angularAccelerationY>\n" );
7055  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAccelerationY() );
7056  fprintf( inFile, "</angularAccelerationY>\n" );
7057  }
7058  if( inSpeedAcceleration->getAngularAccelerationZ().IsNotNULL() )
7059  {
7060  fprintf( inFile, "<angularAccelerationZ>\n" );
7061  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAccelerationZ() );
7062  fprintf( inFile, "</angularAccelerationZ>\n" );
7063  }
7064  if( inSpeedAcceleration->getAngularAcceleration().IsNotNULL() )
7065  {
7066  fprintf( inFile, "<angularAcceleration>\n" );
7067  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAcceleration() );
7068  fprintf( inFile, "</angularAcceleration>\n" );
7069  }
7070 
7071  if( inSpeedAcceleration->getCirX().IsNotNULL() )
7072  {
7073  fprintf( inFile, "<cirX>\n" );
7074  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getCirX() );
7075  fprintf( inFile, "</cirX>\n" );
7076  }
7077  if( inSpeedAcceleration->getCirY().IsNotNULL() )
7078  {
7079  fprintf( inFile, "<cirY>\n" );
7080  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getCirY() );
7081  fprintf( inFile, "</cirY>\n" );
7082  }
7083  if( inSpeedAcceleration->getCirZ().IsNotNULL() )
7084  {
7085  fprintf( inFile, "<cirZ>\n" );
7086  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getCirZ() );
7087  fprintf( inFile, "</cirZ>\n" );
7088  }
7089 
7090  fprintf( inFile, "</speedAcceleration>\n" );
7091 
7092  return dtkNoError;
7093  }

◆ Dtk_DumpXml_Dtk_LayerInfosSetPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_LayerInfosSetPtr ( FILE *  F,
const Dtk_LayerInfosSetPtr &  inVal 
)
3360  {
3361  fprintf( F, "<Dtk_LayerInfosSet>\n" );
3362  if( inVal.IsNotNULL() )
3363  {
3364  Dtk_Size_t LayerIdx;
3365  Dtk_Size_t NumLayers = inVal->GetNumLayers();
3366  Dtk_Size_t DefaultLayer;
3367 
3368  inVal->GetDefaultLayer( DefaultLayer );
3369  fprintf( F, "<Layers Num=\"" XmlFormat( "u" )"\" DefaultLayer=\"" XmlFormat( "d" )"\">\n", NumLayers, DefaultLayer );
3370  for( LayerIdx = 0; LayerIdx < NumLayers; LayerIdx++ )
3371  {
3372  Dtk_string LayerName;
3373  Dtk_ID LayerId;
3374  Dtk_ErrorStatus errn = inVal->GetLayerName( LayerIdx, LayerName );
3375  Dtk_ErrorStatus erri = inVal->GetLayerID( LayerIdx, LayerId );
3376  if( errn == dtkNoError && erri == dtkNoError )
3377  {
3378  LayerName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( LayerName, XMLGenericString );
3379  fprintf( F, "<__" XmlFormat( "u" ) "__ ID= \"%d\" Name=\"%S\"/>\n", LayerIdx, LayerId ,LayerName.w_str() );
3380  }
3381  else
3382  {
3383  if( erri == dtkNoError )
3384  fprintf( F, "<__%d__ Name=\"\"/>\n", LayerId );
3385  else
3386  fprintf( F, "<__" XmlFormat( "u" )"__ Name=\"\"/>\n", LayerIdx );
3387 
3388  }
3389  }
3390  fprintf( F, "</Layers>\n" );
3391 
3392  Dtk_Size_t LayerFiltersIdx;
3393  Dtk_Size_t NumLayersFilters = inVal->GetNumLayerFilters();
3394  Dtk_Size_t DefaultLayerFilter; inVal->GetDefaultLayerFilter( DefaultLayerFilter );
3395  Dtk_LayerFilterInfosPtr CurrentLayerFilterInfo = inVal->GetLayerFilterByPos( DefaultLayerFilter );
3396  Dtk_string CurrentLayerFilterName = L"None";
3397  if( CurrentLayerFilterInfo.IsNotNULL() )
3398  {
3399  Dtk_string LayerFilterName;
3400  CurrentLayerFilterInfo->GetName( LayerFilterName );
3401  CurrentLayerFilterName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( LayerFilterName, XMLGenericString );
3402  }
3403  fprintf( F, "<LayerFilters Num=\"" XmlFormat( "u" )"\" DefaultLayerFilter=\"%s\">\n", NumLayersFilters, CurrentLayerFilterName.c_str() );
3404  for( LayerFiltersIdx = 0; LayerFiltersIdx < NumLayersFilters; LayerFiltersIdx++ )
3405  {
3406  Dtk_LayerFilterInfosPtr TmpLayerFilterInfo = inVal->GetLayerFilterByPos( LayerFiltersIdx );
3407  if( TmpLayerFilterInfo.IsNotNULL() )
3408  {
3409  Dtk_string LayerFilterName, LayerFilterDescription;
3410  Dtk_tab< Dtk_Size_t > SelectedLayers;
3411  TmpLayerFilterInfo->GetName( LayerFilterName );
3412  LayerFilterName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( LayerFilterName, XMLGenericString );
3413  TmpLayerFilterInfo->GetDescription( LayerFilterDescription );
3414  TmpLayerFilterInfo->GetSelectedLayers( SelectedLayers );
3415  Dtk_Size_t SelectedLayersIdx, NumSelectedLayers = SelectedLayers.size();
3416 
3417  fprintf( F, "<LayerFilterInfo Name=\"%S\">\n", LayerFilterName.w_str() );
3418  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Description", LayerFilterDescription );
3419  fprintf( F, "<SelectedLayers Num=\"" XmlFormat( "u" )"\">\n", NumSelectedLayers );
3420  for( SelectedLayersIdx = 0; SelectedLayersIdx < NumSelectedLayers; SelectedLayersIdx++ )
3421  {
3422  fprintf( F, "<__" XmlFormat( "u" )"__/>\n", SelectedLayers[ SelectedLayersIdx ] );
3423  }
3424  fprintf( F, "</SelectedLayers>\n" );
3425  fprintf( F, "</LayerFilterInfo>\n" );
3426  }
3427  }
3428  fprintf( F, "</LayerFilters>\n" );
3429  }
3430  else
3431  {
3432  fprintf( F, "Null" );
3433  }
3434  fprintf( F, "</Dtk_LayerInfosSet>\n" );
3435 
3436  return dtkNoError;
3437  }

◆ Dtk_DumpXml_Dtk_LeaderPtr()

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

◆ Dtk_DumpXml_Dtk_MainDocPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr ( FILE *  F,
const Dtk_MainDocPtr &  inObject 
)
4420  {
4421  fprintf( F, "<Dtk_MainDocPtr>\n" );
4422  if( inObject.IsNotNULL() )
4423  {
4424  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->RootComponent() );
4425  }
4426  else
4427  {
4428  fprintf( F, "Null" );
4429  }
4430  fprintf( F, "</Dtk_MainDocPtr>\n" );
4431  return dtkNoError;
4432  }

◆ Dtk_DumpXml_Dtk_MeshPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshPtr ( FILE *  F,
const Dtk_MeshPtr &  inMesh 
)
6597  {
6598  Dtk_ID id = 0;
6599  if( inMesh->get_info().IsNotNULL() )
6600  id = inMesh->get_info()->GetId();
6601 
6602  fprintf( F, "<Dtk_MeshPtr>\n" );
6603  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inMesh->info() );
6604 
6605  Dtk_Size_t iVert, NbVert = inMesh->get_nb_vertices();
6606 
6607  fprintf( F, "<Vertices nb = \"" XmlFormat( "u" )"\">\n", NbVert );
6608  for( iVert = 0; iVert < NbVert; iVert++ )
6609  {
6610  Dtk_pnt pt = inMesh->get_vertex( iVert );
6611  fprintf( F, "<Vertex id = \"" XmlFormat( "u" )"\" X = \"%lf\" Y = \"%lf\" Z = \"%lf\">", iVert, pt[ 0 ], pt[ 1 ], pt[ 2 ] );
6612  fprintf( F, "</Vertex>\n" );
6613  }
6614  fprintf( F, "</Vertices>\n" );
6615 
6616 
6617  Dtk_Size_t NbMeshFaces = inMesh->get_nb_mesh_face();
6618  fprintf( F, "<MeshFaces nb =\"" XmlFormat( "u" )"\">\n", NbMeshFaces );
6619 
6620  for( Dtk_Size_t iMeshFace = 0; iMeshFace < NbMeshFaces; iMeshFace++ )
6621  {
6622  const Dtk_UInt32 *pnt;
6623  Dtk_mesh_face *curMeshFace = inMesh->get_mesh_face( iMeshFace );
6624  Dtk_Size_t NbTriangles = curMeshFace->get_nbtriangles();
6625  fprintf( F, "<Dtk_mesh_face>\n" );
6626  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, curMeshFace->info() );
6627  fprintf( F, "<Triangles nb = \"" XmlFormat( "u" )"\">\n", NbTriangles );
6628  for( Dtk_Size_t iTriangle = 0; iTriangle < NbTriangles; iTriangle++ )
6629  {
6630  pnt = curMeshFace->get_triangle_indices( iTriangle );
6631  fprintf( F, "<Triangle id = \"" XmlFormat( "u" )"\" vertices = \"%d , %d , %d\" >", iTriangle, pnt[ 0 ], pnt[ 1 ], pnt[ 2 ] );
6632  fprintf( F, "</Triangle>\n" );
6633  }
6634  fprintf( F, "</Triangles>\n" );
6635 
6636  Dtk_Size_t NbPoly = curMeshFace->get_nbpolylines();
6637  fprintf( F, "<Polylines nb =\"" XmlFormat( "u" )"\">\n", NbPoly );
6638  for( Dtk_Size_t iPoly = 0; iPoly < NbPoly; iPoly++ )
6639  {
6640  Dtk_Val dtk_val;
6641  int topoid = 0;
6642  if( curMeshFace->get_nbsubinfos() > 0 )
6643  {
6644  Dtk_InfoPtr inf = curMeshFace->get_subinfo( iPoly );
6645  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inf );
6646  if( inf->FindAttribute( "TOPO_ID_EDGE", dtk_val ) == dtkNoError )
6647  topoid = dtk_val.GetInt();
6648  }
6649 
6650  const Dtk_tab<Dtk_UInt32> *pntpol;
6651  pntpol = curMeshFace->get_polyline_indices( iPoly );
6652  Dtk_Size_t nbpnt;
6653  nbpnt = pntpol->size();
6654 
6655  fprintf( F, "<Polyline id = \"" XmlFormat( "u" )"\" idtopo = \"%i\" vertices = \"", iPoly, topoid );
6656  for( Dtk_Size_t j = 0; j < nbpnt; j++ )
6657  {
6658  fprintf( F, " %d , ", ( *pntpol )[ j ] );
6659  }
6660  fprintf( F, "\"></Polyline>\n" );
6661  }
6662  fprintf( F, "</Polylines>\n" );
6663 
6664 
6665  fprintf( F, "</Dtk_mesh_face>\n" );
6666 
6667  }
6668  fprintf( F, "</MeshFaces>\n" );
6669 
6670  Dtk_StreamPtr stream;
6671  stream = inMesh->GetStream();
6672  if( stream.IsNotNULL() )
6673  {
6674  Dtk_Val val;
6675  if( inMesh->get_info()->FindAttribute( L"Dtk_NxIndexColor", val ) == dtkNoError )
6676  {
6677  Dtk_tab<Dtk_Int32> ArrayColor = val.GetIntArray();
6678 
6679  fprintf( F, "<Dtk_NxIndexColor Num=\'" XmlFormat( "u" ) "\'>\n", ArrayColor.size() );
6680 
6681  for( size_t i = 0; i < ArrayColor.size(); i++ )
6682  {
6683  Dtk_RGB rgb;
6684  Dtk_API::GetAPI()->GetColorInTable( ArrayColor[ i ], rgb );
6685  Dtk_DumpXml_Dtk_RGB( F, rgb );
6686  }
6687  fprintf( F, "</Dtk_NxIndexColor>\n" );
6688 
6689  }
6690  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_StreamPtr( F, stream );
6691  }
6692 
6693  fprintf( F, "</Dtk_MeshPtr>\n" );
6694 
6695  return dtkNoError;
6696 
6697  }

◆ Dtk_DumpXml_Dtk_MetadataGroupPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataGroupPtr ( FILE *  F,
const Dtk_MetaDataGroupPtr &  inObject 
)
4850  {
4851  if( F == NULL )
4852  {
4853  return dtkErrorOpenFiles;
4854  }
4855 
4856 
4857  fprintf( F, "<Dtk_MetaDataGroupPtr>\n" );
4858 
4859  if( inObject.IsNULL() )
4860  {
4861  fprintf( F, "'Null'" );
4862  fprintf( F, "</Dtk_MetaDataGroupPtr>\n" );
4863  return dtkNoError;
4864  }
4865 
4866  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"GroupName", inObject->GetGroupName() );
4867 
4868  Dtk_tab<Dtk_MetaDataPtr> list_metadata = inObject->GetListOfMetadatas();
4869 
4870  Dtk_Size_t size = list_metadata.size();
4871 
4872  for( Dtk_Size_t i = 0; i < size; ++i )
4873  {
4874  Dtk_DumpXml_Dtk_MetadataPtr( F, list_metadata[ i ] );
4875  }
4876 
4877  fprintf( F, "</Dtk_MetaDataGroupPtr>\n" );
4878 
4879  return dtkNoError;
4880  }

◆ Dtk_DumpXml_Dtk_MetadataPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataPtr ( FILE *  F,
const Dtk_MetaDataPtr &  inObject 
)
4799  {
4800  if( F == NULL )
4801  {
4802  return dtkErrorOpenFiles;
4803  }
4804 
4805  fprintf( F, "<Dtk_MetaDataPtr>\n" );
4806  if( inObject.IsNotNULL() )
4807  {
4808  Dtk_string outFormula;
4809  Dtk_string outEstimatedValue;
4810  Dtk_string outTitle;
4811  Dtk_string outResultType;
4812 
4813  Dtk_MetaData::MetaDataTypeEnum MetaDataType = inObject->MetaDataType();
4814  Dtk_DumpXMLNamespace::Dtk_DumpXml_MetaDataTypeEnum( F, MetaDataType, L"MetaDataType" );
4815  if( inObject->GetFormula( outFormula, outEstimatedValue, outTitle, outResultType ) == dtkNoError )
4816  {
4817  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Formula", outFormula );
4818  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"EstimatedValue", outEstimatedValue );
4819  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", outTitle );
4820  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"ResultType", outResultType );
4821  }
4822  else
4823  {
4824  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", inObject->GetTitle() );
4825 
4826  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Type", inObject->GetType() );
4827  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Value", inObject->GetValue() );
4828 
4829  Dtk_string unit;
4830  Dtk_ErrorStatus err = inObject->GetUnits( unit );
4831  if( err == dtkNoError )
4832  {
4833  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Units", unit );
4834  }
4835  if( inObject->GetCategory().len() > 0 )
4836  {
4837  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Category", inObject->GetCategory() );
4838  }
4839  }
4840  }
4841  else
4842  {
4843  fprintf( F, "'Null'" );
4844  }
4845  fprintf( F, "</Dtk_MetaDataPtr>\n" );
4846  return dtkNoError;
4847  }

◆ Dtk_DumpXml_Dtk_ModelDisplayPtr()

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

◆ Dtk_DumpXml_Dtk_NodeConnector()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodeConnector ( FILE *  inFile,
const Dtk_NodeConnectorPtr &  inNodeConnector 
)
6701  {
6702 
6703  Dtk_ErrorStatus dst = dtkNoError;
6704  Dtk_string ConnectorType;
6705 
6706  if( inNodeConnector.IsNULL() )
6707  {
6708  return dtkErrorNullPointer;
6709  }
6710 
6711  Dtk_tab< Dtk_NodeConnector::SubEntity > SubEntities;
6712  Dtk_tab<Dtk_ID> ComponentPathId;
6713  Dtk_ID NodeId = inNodeConnector->GetNodeId();
6714  inNodeConnector->GetSubEntities( SubEntities );
6715  inNodeConnector->GetAssociatedPathComponentID( ComponentPathId );
6716  Dtk_Node::FullType NodeFullType = inNodeConnector->GetPointingEntityType();
6717  Dtk_Size_t NumSubEntities = SubEntities.size();
6718  Dtk_Size_t NumComp = ComponentPathId.size();
6719 
6720 
6721  if( NumComp <= 1 ) //if only 1 component => Local Component or Prototype
6722  {
6723  ConnectorType = L"Prototype";
6724  }
6725  else
6726  {
6727  ConnectorType = L"ComponentPathId";
6728  }
6729  if( NodeId > 0 )
6730  {
6731  ConnectorType += L" + Node";
6732  }
6733  if( NumSubEntities > 0 )
6734  {
6735  ConnectorType += L" + SubEntities";
6736  }
6737 
6738  fprintf( inFile, "<Dtk_NodeConnector Type=\"%s\">\n", ConnectorType.c_str() );
6739 
6740  Dtk_NodeConnector::ReasonCategoryEnum ReasonCategory;
6741  Dtk_NodeConnector::ReasonLinkEnum ReasonLink = inNodeConnector->GetReasonLink( ReasonCategory );
6742  fprintf( inFile, "<ReasonLink>\"%s\"</ReasonLink>\n", Dtk_NodeConnector::ReasonLinkEnumToString( ReasonLink ).c_str() );
6743  // fprintf(inFile, "<ReasonCategory>\"%s\"</ReasonCategory>\n", Dtk_NodeConnector::ReasonCategoryEnumToString( ReasonCategory ).c_str() );
6744 
6745  fprintf( inFile, "<PathCompId>" );
6746  if( NumComp > 0 )
6747  {
6748  Dtk_Size_t i;
6749  for( i = 0; i < NumComp; i++ ) fprintf( inFile, "%d ", ComponentPathId[ i ] );
6750  }
6751  else
6752  {
6753  fprintf( inFile, "LocalComponent" );
6754  }
6755  fprintf( inFile, "</PathCompId>\n" );
6756 
6757 
6758  if( NodeId > 0 )
6759  fprintf( inFile, "<NodeID>%d</NodeID>\n", NodeId );
6760  Dtk_DumpXMLNamespace::Dtk_DumpXml_NodeFullType( inFile, NodeFullType, L"PointingEntityType" );
6761  fprintf( inFile, "<PointedEntityType>%s</PointedEntityType>\n", typedetkToDtk_string( inNodeConnector->GetPointedEntityType() ).c_str() );
6762  //SubEntities
6763  if( NumSubEntities )
6764  {
6765  fprintf( inFile, "<SubEntities Num=\"" XmlFormat( "u" )"\">", NumSubEntities );
6766  for( Dtk_Size_t i = 0; i < NumSubEntities; i++ )
6767  {
6768  Dtk_NodeConnector::SubEntity TmpSub = SubEntities[ i ];
6769  fprintf( inFile, "<SubEntity id=\"%d\" type=\"%s\" ></SubEntity>\n",
6770  TmpSub.GetSubEntityId(),
6771  typedetkToDtk_string( TmpSub.GetSubEntityType() ).c_str() );
6772  }
6773  fprintf( inFile, "</SubEntities>\n" );
6774  }
6775  fprintf( inFile, "</Dtk_NodeConnector>\n" );
6776  return dst;
6777  }

◆ Dtk_DumpXml_Dtk_NodePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr ( FILE *  F,
const Dtk_NodePtr &  inObject 
)
4436  {
4437 
4438  fprintf( F, "<Dtk_NodePtr>\n" );
4439  if( inObject.IsNotNULL() )
4440  {
4441  Dtk_Node::NodeDataTypeEnum NodeType = inObject->GetNodeType();
4442  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4443  Dtk_DumpXMLNamespace::Dtk_DumpXml_NodeTypeEnum( F, NodeType, L"NodeType" );
4444  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"NodeSubType", typedetkToDtk_string( inObject->GetNodeSubType() ) );
4445 
4446  fprintf( F, "<NodeID>%u</NodeID>\n", inObject->GetID() );
4447  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4448  Dtk_StoredInfoPtr sti = inObject->GetStoredInfos();
4449  if( sti.IsNotNULL() )
4450  {
4451  fprintf( F, "<StoredInfos>\n" );
4452  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, Dtk_InfoPtr::DtkDynamicCast( sti ) );
4453  fprintf( F, "</StoredInfos>\n" );
4454  }
4455 
4456  Dtk_Size_t i, NumChildren;
4457  NumChildren = inObject->GetNumChildren();
4458 
4459  for( i = 0; i < NumChildren; i++ )
4460  {
4461  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NodePtr( F, inObject->GetChild( i ) );
4462  }
4463  Dtk_Size_t NumMetaData;
4464  NumMetaData = inObject->GetNumMetaData();
4465  if( NumMetaData )
4466  {
4467  fprintf( F, "<Dtk_MetaData Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaData );
4468  for( i = 0; i < NumMetaData; i++ )
4469  {
4470  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr( F, inObject->GetMetaData( i ) );
4471  }
4472  fprintf( F, "</Dtk_MetaData>\n" );
4473 
4474  }
4475 #ifdef XML_GROUP_METADATA
4476  Dtk_Size_t NumMetaDataGroup;
4477  NumMetaDataGroup = inObject->GetNumMetaDataGroup();
4478  if( NumMetaDataGroup )
4479  {
4480  fprintf( F, "<Dtk_MetaDataGroup Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaDataGroup );
4481  for( i = 0; i < NumMetaDataGroup; i++ )
4482  {
4483  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataGroupPtr( F, inObject->GetMetaDataGroup( i ) );
4484  }
4485  fprintf( F, "</Dtk_MetaDataGroup>\n" );
4486  }
4487 #endif
4488  Dtk_tab< Dtk_NodeConnectorPtr > AssociatedEntities;
4489  inObject->GetAssociatedEntities( AssociatedEntities );
4490  Dtk_Size_t NumConnector = AssociatedEntities.size();
4491  if( NumConnector )
4492  {
4493  fprintf( F, "<NodeConnectors Num=\'" XmlFormat( "u" ) "\'>\n", NumConnector );
4494 
4495  for( i = 0; i < NumConnector; i++ )
4496  {
4497  Dtk_DumpXml_Dtk_NodeConnector( F, AssociatedEntities[ i ] );
4498  }
4499  fprintf( F, "</NodeConnectors>\n" );
4500 
4501  }
4502  }
4503  else
4504  {
4505  fprintf( F, "<Null></Null>\n" );
4506  }
4507  fprintf( F, "</Dtk_NodePtr>\n" );
4508  return dtkNoError;
4509  }

◆ Dtk_DumpXml_Dtk_NodePtr_End()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr_End ( FILE *  F)
4609  {
4610  if( F == NULL )
4611  {
4612  return dtkErrorNullPointer;
4613  }
4614  fprintf( F, "</Dtk_NodePtr>\n" );
4615  return dtkNoError;
4616  }

◆ Dtk_DumpXml_Dtk_NodePtr_Init()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr_Init ( FILE *  F,
const Dtk_NodePtr &  inObject 
)
4512  {
4513  if( F == NULL )
4514  {
4515  return dtkErrorNullPointer;
4516  }
4517  Dtk_Size_t i = 0;
4518  fprintf( F, "<Dtk_NodePtr>\n" );
4519  if( inObject.IsNotNULL() )
4520  {
4521  fprintf( F, "<NodeID>%u</NodeID>\n", inObject->GetID() );
4522  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4523  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4524  fprintf( F, "<FatherID>%u</FatherID>\n", inObject->GetFatherID( 0 ) );
4525 
4526  Dtk_Node::NodeDataTypeEnum NodeType = inObject->GetNodeType();
4527  Dtk_DumpXMLNamespace::Dtk_DumpXml_NodeTypeEnum( F, NodeType, L"NodeType" );
4528  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"NodeSubType", typedetkToDtk_string( inObject->GetNodeSubType() ) );
4529  if( inObject->NodeHasAxis() )
4530  fprintf( F, "<HasAxis>1</HasAxis>\n" );
4531  if( inObject->NodeHasPoints() )
4532  fprintf( F, "<HasPoints>1</HasPoints>\n" );
4533  if( inObject->NodeHasCurves() )
4534  fprintf( F, "<HasCurves>1</HasCurves>\n" );
4535  if( inObject->NodeHasSurfaces() )
4536  fprintf( F, "<HasSurfaces>1</HasSurfaces>\n" );
4537  if( inObject->NodeHasSolids() )
4538  fprintf( F, "<HasSolids>1</HasSolids>\n" );
4539  if( inObject->NodeHasMesh() )
4540  fprintf( F, "<HasMesh>1</HasMesh>\n" );
4541  if( inObject->NodeHasMeshSurfaces() )
4542  fprintf( F, "<HasMeshSurfaces>1</HasMeshSurfaces>\n" );
4543 
4544  Dtk_StoredInfoPtr sti = inObject->GetStoredInfos();
4545  if( sti.IsNotNULL() )
4546  {
4547  fprintf( F, "<StoredInfos>\n" );
4548  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, Dtk_InfoPtr::DtkDynamicCast( sti ) );
4549  fprintf( F, "</StoredInfos>\n" );
4550  }
4551 
4552  Dtk_Size_t NumMetaData;
4553  NumMetaData = inObject->GetNumMetaData();
4554  if( NumMetaData )
4555  {
4556  fprintf( F, "<Dtk_MetaData Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaData );
4557  for( i = 0; i < NumMetaData; i++ )
4558  {
4559  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr( F, inObject->GetMetaData( i ) );
4560  }
4561  fprintf( F, "</Dtk_MetaData>\n" );
4562  }
4563 #ifdef XML_GROUP_METADATA
4564  Dtk_Size_t NumMetaDataGroup;
4565  NumMetaDataGroup = inObject->GetNumMetaDataGroup();
4566  if( NumMetaDataGroup )
4567  {
4568  fprintf( F, "<Dtk_MetaDataGroup Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaDataGroup );
4569  for( i = 0; i < NumMetaDataGroup; i++ )
4570  {
4571  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataGroupPtr( F, inObject->GetMetaDataGroup( i ) );
4572  }
4573  fprintf( F, "</Dtk_MetaDataGroup>\n" );
4574  }
4575 #endif
4576  // Dtk_MaterialPtr mat = inObject->GetMaterial();
4577  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_material(F,mat);
4578 
4579  Dtk_tab< Dtk_NodeConnectorPtr > AssociatedEntities;
4580  inObject->GetAssociatedEntities( AssociatedEntities );
4581  Dtk_Size_t NumConnector = AssociatedEntities.size();
4582  if( NumConnector )
4583  {
4584  fprintf( F, "<NodeConnectors Num=\'" XmlFormat( "u" ) "\'>\n", NumConnector );
4585 
4586  for( i = 0; i < NumConnector; i++ )
4587  {
4588  Dtk_DumpXml_Dtk_NodeConnector( F, AssociatedEntities[ i ] );
4589  }
4590  fprintf( F, "</NodeConnectors>\n" );
4591 
4592  }
4593  Dtk_PreviewPtr preview = inObject->GetPreview();
4594  if( preview.IsNotNULL() )
4595  {
4596  Dtk_Size_t size = preview->GetSize();
4597  fprintf( F, "<PreviewSize>\"" XmlFormat( "u" )"\"</PreviewSize>", size );
4598  }
4599  }
4600  else
4601  {
4602  //fprintf(F,"'Null'");
4603  fprintf( F, "<Null></Null>\n" );
4604  }
4605  return dtkNoError;
4606  }

◆ Dtk_DumpXml_Dtk_OLEObjectPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_OLEObjectPtr ( FILE *  F,
const Dtk_OLEObjectPtr &  O 
)
8351  {
8352  fprintf( F, "<Dtk_OLEObjectPtr>\n" );
8353  if( O )
8354  {
8355  fprintf( F, "<BinaryContentSize>" XmlFormat( "u" ) "</BinaryContentSize>\n", O->GetBinaryContentSize() );
8356  fprintf( F, "<ViewingAspect>%s</ViewingAspect>\n", Dtk_OLEObject::Dtk_OLEObjectViewingAspectToString( O->GetViewingAspect() ).c_str() );
8357  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, O->GetPlacement() );
8358  fprintf( F, "<Scale>%lf</Scale>\n", O->GetScale() );
8359  }
8360  else
8361  {
8362  fprintf( F, "Empty" );
8363  }
8364  fprintf( F, "</Dtk_OLEObjectPtr>\n" );
8365  return dtkNoError;
8366  }

◆ Dtk_DumpXml_Dtk_OneCell()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_OneCell ( FILE *  F,
Dtk_OneCell &  D 
)
2195  {
2196  fprintf( F, "<Dtk_OneCell>\n" );
2197 
2198  fprintf( F, "<_Height>%f</_Height>\n", D.getHeight() );
2199  fprintf( F, "<_Width>%f</_Width>\n", D.getWidth() );
2200  fprintf( F, "<nbCells_Left_Right>%u</nbCells_Left_Right>\n", D.getnbCells_Left_Right() );
2201  fprintf( F, "<nbCells_Top_Bottom>%u</nbCells_Top_Bottom>\n", D.getnbCells_Top_Bottom() );
2202 
2203  if( D.GetBorderTopColor().IsFilled() || D.GetBorderBottomColor().IsFilled() || D.GetBorderLeftColor().IsFilled() || D.GetBorderRightColor().IsFilled() )
2204  {
2205  fprintf( F, "<BorderColor>\n" );
2206 
2207  fprintf( F, "<Top>" );
2208  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RGB( F, D.GetBorderTopColor() );
2209  fprintf( F, "</Top>\n" );
2210 
2211  fprintf( F, "<Bottom>" );
2212  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RGB( F, D.GetBorderBottomColor() );
2213  fprintf( F, "</Bottom>\n" );
2214 
2215  fprintf( F, "<Left>" );
2216  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RGB( F, D.GetBorderLeftColor() );
2217  fprintf( F, "</Left>\n" );
2218 
2219  fprintf( F, "<Right>" );
2220  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_RGB( F, D.GetBorderRightColor() );
2221  fprintf( F, "</Right>\n" );
2222 
2223  fprintf( F, "</BorderColor>\n" );
2224  }
2225 
2226  if( D.GetBorderTopBlanked() != DTK_FALSE || D.GetBorderBottomBlanked() != DTK_FALSE || D.GetBorderLeftBlanked() != DTK_FALSE || D.GetBorderRightBlanked() != DTK_FALSE )
2227  {
2228  fprintf( F, "<BorderBlanked>\n" );
2229  fprintf( F, "<Top>%d</Top>\n", D.GetBorderTopBlanked() );
2230  fprintf( F, "<Bottom>%d</Bottom>\n", D.GetBorderBottomBlanked() );
2231  fprintf( F, "<Lef>%d</Lef>\n", D.GetBorderLeftBlanked() );
2232  fprintf( F, "<Right>%d</Right>\n", D.GetBorderRightBlanked() );
2233  fprintf( F, "</BorderBlanked>\n" );
2234  }
2235 
2236  const Dtk_tab< Dtk_EntityPtr > &additionnalgeometries = D.GetAdditionnalGeometries();
2237  Dtk_Size_t k, sizek = additionnalgeometries.size();
2238  if( sizek > 0 )
2239  {
2240  fprintf( F, "<AdditionnalGeometries>\n" );
2241  for( k = 0; k < sizek; k++ )
2242  {
2243  Dtk_DumpXml_Dtk_EntityPtr( F, additionnalgeometries[ k ] );
2244  }
2245  fprintf( F, "</AdditionnalGeometries>\n" );
2246  }
2247 
2248  fprintf( F, "</Dtk_OneCell>\n" );
2249  return dtkNoError;
2250  }

◆ Dtk_DumpXml_Dtk_PlaneSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_PlaneSurfacePtr ( FILE *  F,
const Dtk_PlaneSurfacePtr &  inSurf 
)
5937  {
5938  fprintf( F, "<Dtk_PlaneSurfacePtr>" );
5939 
5940  if( inSurf.IsNotNULL() )
5941  {
5942  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inSurf->GetOrigin(), "Origin" );
5943  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetNormal(), "Normal" );
5944  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetUDirection(), "UDir" );
5945  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetVDirection(), "VDir" );
5946  }
5947  else
5948  {
5949  fprintf( F, "Null" );
5950  }
5951 
5952  fprintf( F, "</Dtk_PlaneSurfacePtr>" );
5953  return dtkNoError;
5954  }

◆ Dtk_DumpXml_Dtk_pnt()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_pnt ( FILE *  F,
const Dtk_pnt &  P,
const char *  b = "Pnt" 
)
4183  {
4184  fprintf( F, "<%s>(%f %f %f)</%s>\n", b, P[ 0 ], P[ 1 ], P[ 2 ], b );
4185  return dtkNoError;
4186  }

◆ Dtk_DumpXml_Dtk_ReferenceBlockPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceBlockPtr ( FILE *  F,
const Dtk_ReferenceBlockPtr &  D 
)
2530  {
2531  Dtk_Size_t i;
2532  Dtk_Size_t NumReferences = D->GetNumReferences();
2533 
2534  fprintf( F, "<Dtk_ReferenceBlockPtr NumReferences=\"" XmlFormat( "u" )"\">\n", NumReferences );
2535  for( i = 0; i < NumReferences; i++ )
2536  {
2537  fprintf( F, "<Dtk_Reference>\n" );
2538  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"label", D->GetReferenceLabel( i ) );
2539  //Dtk_DumpXMLNamespace::Dtk_DumpXml_DTK_FDT_MODIFIER(F, D->GetMaterialModifier(i));
2540  fprintf( F, "</Dtk_Reference>\n" );
2541 
2542  }
2543  fprintf( F, "</Dtk_ReferenceBlockPtr>\n" );
2544  return dtkNoError;
2545  }

◆ Dtk_DumpXml_Dtk_ReferenceFramePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceFramePtr ( FILE *  F,
const Dtk_ReferenceFramePtr &  D 
)
2548  {
2549  if( D.IsNotNULL() )
2550  {
2551  Dtk_Size_t nb_refs = D->GetNumReferences();
2552  fprintf( F, "<Dtk_ReferenceFramePtr NumReferencesBlocks = \"" XmlFormat( "u" )"\">\n", nb_refs );
2553 
2554  Dtk_ReferenceBlockPtr Ref;
2555  Ref = D->FirstReference();
2556  if( Ref.IsNotNULL() ) Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ReferenceBlockPtr( F, Ref );
2557  Ref = D->SecondReference();
2558  if( Ref.IsNotNULL() ) Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ReferenceBlockPtr( F, Ref );
2559  Ref = D->ThirdReference();
2560  if( Ref.IsNotNULL() ) Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ReferenceBlockPtr( F, Ref );
2561  fprintf( F, "</Dtk_ReferenceFramePtr>\n" );
2562  }
2563  return dtkNoError;
2564  }

◆ Dtk_DumpXml_Dtk_roughness_obtention_type()

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

◆ Dtk_DumpXml_Dtk_roughness_rough_mode()

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

◆ Dtk_DumpXml_Dtk_roughness_roughness_applyto()

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

◆ Dtk_DumpXml_Dtk_RoughnessPtr()

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

◆ Dtk_DumpXml_Dtk_SelectionDataSet()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_SelectionDataSet ( FILE *  F,
const Dtk_GlobalDataSetPtr &  ptrGlobalDataSet 
)
6824  {
6825  if( F == NULL )
6826  {
6827  return dtkErrorNullPointer;
6828  }
6829  Dtk_Size_t i = 0;
6830 
6831  //Dtk_GlobalDataSetPtr ptrGlobalDataSet = inObject->GetGlobalDataSet();
6832  if( ptrGlobalDataSet.IsNotNULL() )
6833  {
6834  Dtk_SelectionDataSetPtr ptrSelectionDataSet = ptrGlobalDataSet->GetSelectionDataSet();
6835  if( ptrSelectionDataSet.IsNULL() )
6836  {
6837  return dtkErrorNullPointer;
6838  }
6839  Dtk_Size_t ptrSelectionDataSetNb = ptrSelectionDataSet->GetNumSelectionSets();
6840  if( ptrSelectionDataSetNb > 0 )
6841  {
6842  fprintf( F, "<Dtk_SelectionDataSet>\n" );
6843  }
6844  for( i = 0; i < ptrSelectionDataSetNb; i++ )
6845  {
6846  Dtk_SelectionSetPtr curSelectionSet = ptrSelectionDataSet->GetSelectionSetByPos( i );
6847  if( curSelectionSet.IsNotNULL() )
6848  Dtk_DumpXml_Dtk_SelectionSet( F, curSelectionSet );
6849  }
6850  if( ptrSelectionDataSetNb > 0 )
6851  {
6852  fprintf( F, "</Dtk_SelectionDataSet>\n" );
6853  }
6854  }
6855 
6856  return dtkNoError;
6857  }

◆ Dtk_DumpXml_Dtk_StreamPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_StreamPtr ( FILE *  F,
const Dtk_StreamPtr &  inVal 
)
8447  {
8448  fprintf( F, "<Dtk_StreamPtr>\n" );
8449  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inVal->GetName() );
8450  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"StreamType", inVal->GetStreamType() );
8451  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"StreamSize", inVal->GetBinaryContentSize() );
8452  fprintf( F, "</Dtk_StreamPtr>\n" );
8453  return dtkNoError;
8454  }

◆ Dtk_DumpXml_Dtk_TablePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_TablePtr ( FILE *  F,
const Dtk_TablePtr &  D 
)
2254  {
2255  Dtk_Size_t nbLine, nbCol, i, j;
2256  fprintf( F, "<Dtk_Table>\n" );
2257 
2258  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_AnnotationPtr( F, Dtk_AnnotationPtr::DtkDynamicCast( D ) ); // upcasting
2259  fprintf( F, "<nbRows>" XmlFormat( "u" )"</nbRows>\n", D->getNbrows() );
2260  fprintf( F, "<nbCols>" XmlFormat( "u" )"</nbCols>\n", D->getNbcols() );
2261  nbLine = D->getNbrows();
2262  nbCol = D->getNbcols();
2263  for( i = 0; i < nbLine; i++ )
2264  {
2265  fprintf( F, "<nbCells_in_Line" XmlFormat( "u" )">" XmlFormat( "u" )"</nbCells_in_Line" XmlFormat( "u" )">\n", i, D->Cell_Line( i ), i );
2266  }
2267  for( i = 0; i < nbCol; i++ )
2268  {
2269  fprintf( F, "<nbCells_in_Col" XmlFormat( "u" )">" XmlFormat( "u" )"</nbCells_in_Col" XmlFormat( "u" )">\n", i, D->Cell_Col( i ), i );
2270  }
2271  for( i = 0; i < nbLine; i++ )
2272  {
2273  fprintf( F, "<LineNum" XmlFormat( "u" )">\n", i + 1 );
2274 
2275  for( j = 0; j < nbCol; j++ )
2276  {
2277  fprintf( F, "<ColNum" XmlFormat( "u" )">\n", j + 1 );
2278  if( D->getCell( i, j ).HasText() == DTK_TRUE )
2279  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->Text( i, j ) );
2280  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_OneCell( F, D->getCell( i, j ) );
2281  fprintf( F, "</ColNum" XmlFormat( "u" )">\n", j + 1 );
2282  }
2283  fprintf( F, "</LineNum" XmlFormat( "u" )">\n", i + 1 );
2284  }
2285 
2286  fprintf( F, "</Dtk_Table>\n" );
2287  return dtkNoError;
2288  }

◆ Dtk_DumpXml_Dtk_Text()

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

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr ( FILE *  F,
const Dtk_ToleranceSpecificationContainerPtr &  D 
)
2488  {
2489  fprintf( F, "<Dtk_ToleranceSpecificationContainerPtr>\n" );
2490  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType( F, D->ToleranceSpecificationContainerType() );
2491  //We retrieve the TolType BBoxes
2492  Dtk_Oriented2dBBox TmpBBox;
2493  D->GetToleranceTypeOuterBoundingBox( TmpBBox );
2494  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, TmpBBox, L"TopSpecContTypeOuterBBox" );
2495  D->GetToleranceTypeInnerBoundingBox( TmpBBox );
2496  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, TmpBBox, L"TopSpecContTypeInnerBBox" );
2497  fprintf( F, "<TopText>\n" ); Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->TopTextAsCompositeText() ); fprintf( F, "</TopText>\n" );
2498  fprintf( F, "<BottomText>\n" ); Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->BottomTextAsCompositeText() ); fprintf( F, "</BottomText>\n" );
2499  fprintf( F, "<RightText>\n" ); Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->RightTextAsCompositeText() ); fprintf( F, "</RightText>\n" );
2500  fprintf( F, "<LeftText>\n" ); Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->LeftTextAsCompositeText() ); fprintf( F, "</LeftText>\n" );
2501 
2502  Dtk_Size_t i, nbtolspecs;
2503  nbtolspecs = D->GetNumToleranceSpecifications();
2504  fprintf( F, "<tol_specs num_tol_specs = \"" XmlFormat( "u" )"\">\n", nbtolspecs );
2505  for( i = 0; i < nbtolspecs; i++ )
2506  {
2507  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ToleranceSpecificationPtr( F, D->GetToleranceSpecification( i ) );
2508  }
2509  fprintf( F, "</tol_specs>\n" );
2510  fprintf( F, "</Dtk_ToleranceSpecificationContainerPtr>\n" );
2511  return dtkNoError;
2512  }

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType ( FILE *  F,
const Dtk_ToleranceSpecificationContainer::TypeEnum &  D 
)
2614  {
2615  fprintf( F, "<ToleranceSpecificationContainerType>" );
2616  switch( D )
2617  {
2618  default:
2619  case Dtk_ToleranceSpecificationContainer::Typeunknown:
2620  fprintf( F, "TypeUnknown" );
2621  break;
2622  case Dtk_ToleranceSpecificationContainer::TypeStraightness:
2623  fprintf( F, "TypeStraightness" );
2624  break;
2625  case Dtk_ToleranceSpecificationContainer::TypeFlatness:
2626  fprintf( F, "TypeFlatness" );
2627  break;
2628  case Dtk_ToleranceSpecificationContainer::TypeCircularity:
2629  fprintf( F, "TypeCircularity" );
2630  break;
2631  case Dtk_ToleranceSpecificationContainer::TypeCylindricity:
2632  fprintf( F, "TypeCylindricity" );
2633  break;
2634  case Dtk_ToleranceSpecificationContainer::TypeLineProfile:
2635  fprintf( F, "TypeLineProfile" );
2636  break;
2637  case Dtk_ToleranceSpecificationContainer::TypeSurfaceProfile:
2638  fprintf( F, "TypeSurfaceProfile" );
2639  break;
2640  case Dtk_ToleranceSpecificationContainer::TypeAngularity:
2641  fprintf( F, "TypeAngularity" );
2642  break;
2643  case Dtk_ToleranceSpecificationContainer::TypePerpendicularity:
2644  fprintf( F, "TypePerpendicularity" );
2645  break;
2646  case Dtk_ToleranceSpecificationContainer::TypeParallelism:
2647  fprintf( F, "TypeParallelism" );
2648  break;
2649  case Dtk_ToleranceSpecificationContainer::TypePosition:
2650  fprintf( F, "TypePosition" );
2651  break;
2652  case Dtk_ToleranceSpecificationContainer::TypeConcentricity:
2653  fprintf( F, "TypeConcentricity" );
2654  break;
2655  case Dtk_ToleranceSpecificationContainer::TypeSymmetry:
2656  fprintf( F, "TypeSymmetry" );
2657  break;
2658  case Dtk_ToleranceSpecificationContainer::TypeCircularRunout:
2659  fprintf( F, "TypeCircularRunout" );
2660  break;
2661  case Dtk_ToleranceSpecificationContainer::TypeTotalRunout:
2662  fprintf( F, "TypeTotalRunout" );
2663  break;
2664  case Dtk_ToleranceSpecificationContainer::TypeAxisIntersection:
2665  fprintf( F, "TypeAxisIntersection" );
2666  break;
2667  }
2668  fprintf( F, "</ToleranceSpecificationContainerType>\n" );
2669  return dtkNoError;
2670  }

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationPtr ( FILE *  F,
const Dtk_ToleranceSpecificationPtr &  D 
)
2672  {
2673  fprintf( F, "<Dtk_ToleranceSpecificationPtr>\n" );
2674 
2675  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ReferenceFramePtr( F, D->ReferenceFrame() );
2676 
2677  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CompositeText( F, D->GetMainValue() );
2678  //Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir(F, D->GetXAxis(), "X_axis");
2679  //Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir(F, D->GetYAxis(), "Y_axis");
2680  Dtk_DumpXMLNamespace::Dtk_DumpXml_DTK_FDT_MODIFIER( F, D->GetMaterialModifier() );
2681  fprintf( F, "<FreeStateModifier>" );
2682  if( D->HasFreeStateModifier() == DTK_TRUE )
2683  fprintf( F, "Present" );
2684  else
2685  fprintf( F, "Not Present" );
2686  fprintf( F, "</FreeStateModifier>" );
2687  for( Dtk_Size_t i = 0; i < D->GetNumIndicators(); ++i )
2688  {
2689  Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr( F, D->GetIndicator( i ) );
2690  }
2691  fprintf( F, "</Dtk_ToleranceSpecificationPtr>\n" );
2692  return dtkNoError;
2693  }

◆ Dtk_DumpXml_Dtk_transfo()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_transfo ( FILE *  F,
const Dtk_transfo &  V 
)
4195  {
4196  fprintf( F, "<Transfo_matrix>\n" );
4197  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getXdir(), "X" );
4198  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getYdir(), "Y" );
4199  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getZdir(), "Z" );
4200  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, T.getOrigin(), "Origin" );
4201  fprintf( F, "<Scale>%f</Scale>\n", T.getScale() );
4202  fprintf( F, "</Transfo_matrix>\n" );
4203  return dtkNoError;
4204  }

◆ Dtk_DumpXml_Dtk_ViewPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewPtr ( FILE *  F,
const Dtk_ViewPtr &  V 
)

◆ Dtk_DumpXml_Dtk_WeldingPtr()

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

◆ Dtk_DumpXml_End() [1/2]

Dtk_ErrorStatus Dtk_DumpXml_End ( )
4904  {
4905  if( dump_file == NULL )
4906  return dtkErrorUnspecified;
4907  fprintf( dump_file, "</root>\n" );
4908  fclose( dump_file );
4909  return dtkNoError;
4910  }

◆ Dtk_DumpXml_End() [2/2]

Dtk_ErrorStatus Dtk_DumpXml_End ( FILE *  F)
4912  {
4913  if( F == NULL )
4914  return dtkErrorUnspecified;
4915  fprintf( F, "</root>\n" );
4916  fclose( F );
4917  return dtkNoError;
4918  }

◆ Dtk_DumpXml_Fdt()

Dtk_ErrorStatus Dtk_DumpXml_Fdt ( const Dtk_FdtPtr &  D)
4886  {
4887  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FdtPtr( dump_file, D, 0 );
4888  }

◆ Dtk_DumpXml_FormatDtk_string()

Dtk_string Dtk_DumpXml_FormatDtk_string ( const Dtk_string &  inString,
const XML_StringType  inXmlStringType = XMLGenericString 
)
4305  {
4306  //if( inString.c_str() != NULL )
4307  {
4308  int StrLen = inString.len();
4309  if( StrLen > 0 )
4310  {
4311  int Idx = 0;
4312  Dtk_string Res;
4313  switch( inXmlStringType )
4314  {
4315  case XMLAttribute:
4316  case XMLElement:
4317  {
4318  //XMLElement
4319  if( isascii( inString[ 0 ] ) == 0 || isdigit( inString[ 0 ] ) )
4320  {
4321  //we add an additional underscore char because an anchor can't start with a digit
4322  Res = L"_" + inString;
4323  Idx++; //we increment the index
4324  }
4325  else
4326  {
4327  Res = inString;
4328  }
4329 
4330  for( int i = 0; i < StrLen; i++, Idx++ )
4331  {
4332  unsigned int Val = ( unsigned int )inString[ i ];
4333  if( Val > 0x007F || Val < 0x002C )
4334  {
4335  Res[ Idx ] = '_';
4336  }
4337  else
4338  {
4339  switch( Val )
4340  {
4341  case 0x002F: //'/'
4342  case 0x003A: //':'
4343  case 0x003B: //';'
4344  case 0x003C: //'<'
4345  case 0x003D: //'='
4346  case 0x003E: //'>'
4347  case 0x003F: //'?'
4348  case 0x0040: //'@'
4349  case 0x005B: //'['
4350  case 0x005C: //'\\'
4351  case 0x005D: //']'
4352  case 0x005E: //'^'
4353  case 0x0060: //'`'
4354  case 0x007B: //'{'
4355  case 0x007C: //'|'
4356  case 0x007D: //'}'
4357  case 0x007E: //'~'
4358  {
4359  Res[ Idx ] = '_';
4360  break;
4361  }
4362  default:
4363  {
4364  break;
4365  }
4366  }
4367 
4368  }
4369  }
4370  break;
4371  }
4372  case XMLGenericString:
4373  {
4374  //XMLGenericString
4375  std::string fast;
4376  fast.reserve( StrLen );
4377  for( int i = 0; i < StrLen; i++ )
4378  {
4379  char buf[ 10 ] = { 0 };
4380  unsigned int Val = ( unsigned int )inString[ i ];
4381  if( Val > 127
4382  || Val == 0x0022 //'"' => this char is valid but could be ugly if we encapsulate with quotes
4383  || Val == 0x0026 //'&'
4384  || Val == 0x003C //'<'
4385  || Val == 0x003E //'>'
4386  || Val == 0x000A //'line feed'
4387  || Val == 0x000D //'carriage return'
4388  )
4389  {
4390  Dtk_StandardTools::sprintf_dtk( buf, 10, "&#x%X;", Val );
4391  }
4392  else if( Val >= 0x0020 ) //we remove ascii character prior 'space'
4393  {
4394  Dtk_StandardTools::sprintf_dtk( buf, 10, "%c", ( char )Val );
4395  }
4396  else
4397  {
4398  Dtk_StandardTools::sprintf_dtk( buf, 10, "_" ); //if control char => underscore
4399  }
4400  fast += buf;
4401  }
4402  Res += fast.c_str();
4403  break;
4404  }
4405  default:
4406  {
4407  break;
4408  }
4409  }
4410  return Res;
4411  }
4412  }
4413  return inString; //same string by default - error -
4414  }

◆ Dtk_DumpXml_GetFeaturesDumpFile()

FILE* Dtk_DumpXml_GetFeaturesDumpFile ( )
4925  {
4926  return FeaturesDumpFile;
4927  }

◆ Dtk_DumpXml_GetFile()

FILE* Dtk_DumpXml_GetFile ( )
4920  {
4921  return dump_file;
4922  }

◆ Dtk_DumpXml_GetParametersDumpFile()

FILE* Dtk_DumpXml_GetParametersDumpFile ( )

◆ Dtk_DumpXml_Init()

Dtk_ErrorStatus Dtk_DumpXml_Init ( const Dtk_string &  xml_file)
4891  {
4892  Dtk_string xmlFileOut;
4893 
4894  xmlFileOut = xml_file;
4895 
4896  dump_file = xmlFileOut.OpenFile( DTK_W );
4897  if( dump_file == NULL )
4898  return dtkErrorUnspecified;
4899  // dump_file = fopen(xml_file.c_str(),"w");
4900  fprintf( dump_file, "<root>\n" );
4901  return dtkNoError;
4902  }

◆ Dtk_DumpXml_LineTypeDefinitionTable()

Dtk_ErrorStatus Dtk_DumpXml_LineTypeDefinitionTable ( FILE *  F)
3972  {
3973  Dtk_ErrorStatus outDtkStatus = dtkNoError;
3974 
3975  const Dtk_API *const api = Dtk_API::GetAPI();
3976  if( api )
3977  {
3978  const Dtk_Size_t nbDefinitions = api->GetNumCurveLineTypeDefinitionsInTable();
3979 
3980  if( nbDefinitions > 0 )
3981  {
3982  fprintf( F, "<LineTypeDefinitionTable>\n" );
3983 
3984  for( Dtk_Size_t i_def = 1; i_def <= nbDefinitions; ++i_def )
3985  {
3986  Dtk_DumpXml_Dtk_LineTypeDefinitionPtr( F,
3987  api->GetCurveLineTypeDefinitionInTable( ( Dtk_ID )i_def ) );
3988  }
3989 
3990  fprintf( F, "</LineTypeDefinitionTable>\n" );
3991  }
3992  }
3993  else
3994  {
3995  outDtkStatus = dtkErrorNullPointer;
3996  }
3997 
3998  return outDtkStatus;
3999  }

◆ Dtk_DumpXml_PhysicalMaterialInfosTable()

Dtk_ErrorStatus Dtk_DumpXml_PhysicalMaterialInfosTable ( FILE *  F)
3889  {
3890  Dtk_API *api = Dtk_API::GetAPI();
3891  Dtk_ID i, nb = ( Dtk_ID )api->GetNumPhysicalMaterialInfosInTable();
3892  if( nb )
3893  fprintf( F, "<PhysicalMaterialInfosTable>\n" );
3894  for( i = 0; i < nb; i++ )
3895  {
3896  Dtk_PhysicalMaterialInfosPtr mat = api->GetPhysicalMaterialInfosInTable( i + 1 );
3897  Dtk_DumpXml_Dtk_PhysicalMaterialInfos( F, mat );
3898  }
3899  if( nb )
3900  fprintf( F, "</PhysicalMaterialInfosTable>\n" );
3901 
3902  return dtkNoError;
3903  }

◆ Dtk_DumpXml_RenderInfosTable()

Dtk_ErrorStatus Dtk_DumpXml_RenderInfosTable ( FILE *  F)
3872  {
3873  Dtk_API *api = Dtk_API::GetAPI();
3874  Dtk_ID i, nb = ( Dtk_ID )api->GetNumRenderInfosInTable();
3875  if( nb )
3876  fprintf( F, "<RenderInfosTable>\n" );
3877  for( i = 0; i < nb; i++ )
3878  {
3879  Dtk_RenderInfosPtr mat = api->GetRenderInfosInTable( i + 1 );
3880  Dtk_DumpXml_Dtk_RenderInfos( F, mat );
3881  }
3882  if( nb )
3883  fprintf( F, "</RenderInfosTable>\n" );
3884 
3885  return dtkNoError;
3886  }

◆ Dtk_DumpXml_Value() [1/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const char *  inFormat,
  ... 
)
4206  {
4207  Dtk_string Value;
4208  {
4209  va_list ap;
4210  va_start( ap, inFormat );
4211  char buffer[ 512 ] = { 0 };
4212  Dtk_StandardTools::vsprintf_dtk( buffer, 512, inFormat, ap );
4213  va_end( ap );
4214  Value = buffer;
4215  }
4216 
4217  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Value";
4218  const char *TitleCharStr = Title.c_str();
4219 
4220  Value = ( Value.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( Value, XMLGenericString ) : L"Undefined.";
4221  fprintf( inFile, "<%s>%s</%s>\n",
4222  TitleCharStr,
4223  Value.c_str(),
4224  TitleCharStr );
4225 
4226  return dtkNoError;
4227  }

◆ Dtk_DumpXml_Value() [2/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_bool &  inValue 
)
4244  {
4245  //we check if the label is present - label overload -
4246  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_bool";
4247  const char *TitleCharStr = Title.c_str();
4248 
4249  fprintf( inFile, "<%s>%s</%s>\n",
4250  TitleCharStr,
4251  ( inValue == DTK_FALSE ) ? "DTK_FALSE" : "DTK_TRUE",
4252  TitleCharStr );
4253  return dtkNoError;
4254  }

◆ Dtk_DumpXml_Value() [3/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_Double64 &  inValue,
const char *  inFormat = "%lf" 
)
4230  {
4231  //we check if the label is present - label overload -
4232  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_Double64";
4233  const char *TitleCharStr = Title.c_str();
4234 
4235  char MyFormat[ 128 ] = { 0 };
4236  Dtk_StandardTools::sprintf_dtk( MyFormat, 128, "<%%s>%s</%%s>\n", inFormat );
4237  fprintf( inFile, MyFormat,
4238  TitleCharStr,
4239  inValue,
4240  TitleCharStr );
4241  return dtkNoError;
4242  }

◆ Dtk_DumpXml_Value() [4/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_Int64 &  inValue 
)
4256  {
4257  //we check if the label is present - label overload -
4258  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_Int64";
4259  const char *TitleCharStr = Title.c_str();
4260 
4261  fprintf( inFile, "<%s>\'" XmlFormat( "d" ) "\"</%s>\n",
4262  TitleCharStr,
4263  inValue,
4264  TitleCharStr );
4265  return dtkNoError;
4266  }

◆ Dtk_DumpXml_Value() [5/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_string &  inValue 
)
4280  {
4281  //we check if the label is present - label overload -
4282  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_string";
4283  const char *TitleCharStr = Title.c_str();
4284 
4285  if( inValue.len() > 0 )
4286  {
4287 
4288  Dtk_string Value = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inValue, XMLGenericString );
4289 
4290  fprintf( inFile, "<%s>&quot;%s&quot;</%s>\n",
4291  TitleCharStr,
4292  Value.c_str(),
4293  TitleCharStr );
4294  }
4295  else
4296  {
4297  fprintf( inFile, "<%s>(null)</%s>\n",
4298  TitleCharStr,
4299  TitleCharStr );
4300  }
4301  return dtkNoError;
4302  }

◆ Dtk_DumpXml_Value() [6/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_UInt64 &  inValue 
)
4268  {
4269  //we check if the label is present - label overload -
4270  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_UInt64";
4271  const char *TitleCharStr = Title.c_str();
4272 
4273  fprintf( inFile, "<%s>\'" XmlFormat( "u" ) "\"</%s>\n",
4274  TitleCharStr,
4275  inValue,
4276  TitleCharStr );
4277  return dtkNoError;
4278  }

◆ Dtk_DumpXml_Value() [7/7]

template<typename ValueType >
Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const ValueType &  inValue 
)
103 {
104  //we check if the label is present - label overload -
105  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Value";
106  std::wstringstream sstream; sstream << inValue;
107  Dtk_string Value = ( sstream.str().length() > 0 ) ? Dtk_DumpXml_FormatDtk_string( sstream.str().c_str(), XMLGenericString ) : L"Undefined.";
108 
109  const char *titleStr = Title.c_str();
110  fprintf( inFile, "<%s>%s</%s>\n",
111  titleStr,
112  Value.c_str(),
113  titleStr );
114 
115  return dtkNoError;
116 }

◆ Dtk_End_Dump_Files()

Dtk_ErrorStatus Dtk_End_Dump_Files ( const Dtk_string &  inComponentFullName)
7650  {
7651  Dtk_string str_fic_param, str_fic_feat;
7652 
7653  if( FeaturesDumpFile )
7654  {
7655  str_fic_feat = inComponentFullName + Dtk_string( ".feat.log" );
7656  fclose( FeaturesDumpFile );
7657  FeaturesDumpFile = NULL;
7658  }
7659 
7660  return dtkNoError;
7661 
7662  }

◆ Dtk_Init_Dump_Files()

Dtk_ErrorStatus Dtk_Init_Dump_Files ( const Dtk_string &  inDumpFileName,
Dtk_bool  dumpFeatures = 0 
)
7636  {
7637  if( dumpFeatures )
7638  {
7639  FeaturesDumpFile = inDumpFileName.OpenFile( DTK_WP );
7640  if( FeaturesDumpFile == NULL )
7641  {
7642  return dtkErrorOpenFiles;
7643  }
7644  }
7645 
7646  return dtkNoError;
7647  }

◆ DtkReaderTypeEnumToString()

Dtk_string DtkReaderTypeEnumToString ( const DtkReaderType &  inReaderTypeEnum)
718  {
719  Dtk_string EnumToStr;
720  switch( inReaderTypeEnum )
721  {
722  case V5ReaderModule: EnumToStr = L"V5ReaderModule"; break;
723  case VdaReaderModule: EnumToStr = L"VdaReaderModule"; break;
724  case InvReaderModule: EnumToStr = L"InvReaderModule"; break;
725  case V4ReaderModule: EnumToStr = L"V4ReaderModule"; break;
726  case UgReaderModule: EnumToStr = L"UgReaderModule"; break;
727  case XmtReaderModule: EnumToStr = L"XmtReaderModule"; break;
728  case SwReaderModule: EnumToStr = L"SwReaderModule"; break;
729  case SeReaderModule: EnumToStr = L"SeReaderModule"; break;
730  case IgesReaderModule: EnumToStr = L"IgesReaderModule"; break;
731  case StepReaderModule: EnumToStr = L"StepReaderModule"; break;
732  case PsReaderModule: EnumToStr = L"PsReaderModule"; break;
733  case ProeReaderModule: EnumToStr = L"ProeReaderModule"; break;
734  case SatReaderModule: EnumToStr = L"SatReaderModule"; break;
735  case JtReaderModule: EnumToStr = L"JtReaderModule"; break;
736  case CgrReaderModule: EnumToStr = L"CgrReaderModule"; break;
737  case CgmReaderModule: EnumToStr = L"CgmReaderModule"; break;
738  case CaddsReaderModule: EnumToStr = L"CaddsReaderModule"; break;
739  case DwgReaderModule: EnumToStr = L"DwgReaderModule"; break;
740  case DwgDtkReaderModule: EnumToStr = L"DwgDtkReaderModule"; break;
741  case AcisReaderModule: EnumToStr = L"AcisReaderModule"; break;
742  case ProCeraReaderModule: EnumToStr = L"ProCeraReaderModule"; break;
743  case CerconReaderModule: EnumToStr = L"CerconReaderModule"; break;
744  case CerecReaderModule: EnumToStr = L"CerecReaderModule"; break;
745  case DcmReaderModule: EnumToStr = L"DcmReaderModule"; break;
746  case _3dXmlReaderModule: EnumToStr = L"_3dXmlReaderModule"; break;
747  case XmlReaderModule: EnumToStr = L"XmlReaderModule"; break;
748  case V6ReaderModule: EnumToStr = L"V6ReaderModule"; break;
749  case DxfReaderModule: EnumToStr = L"DxfReaderModule"; break;
750  case PlmXmlReaderModule: EnumToStr = L"PlmXmlReaderModule"; break;
751  case RnXmlReaderModule: EnumToStr = L"RnXmlReaderModule"; break;
752  case FbxReaderModule: EnumToStr = L"FbxReaderModule"; break;
753  case GltfReaderModule: EnumToStr = L"GltfReaderModule"; break;
754  case SdnfReaderModule: EnumToStr = L"SdnfReaderModule"; break;
755  case F3dReaderModule: EnumToStr = L"F3dReaderModule"; break;
756  case PrcReaderModule: EnumToStr = L"PrcReaderModule"; break;
757  case ArtReaderModule: EnumToStr = L"ArtReaderModule"; break;
758  case SmgReaderModule: EnumToStr = L"SmgReaderModule"; break;
759  case DstvReaderModule: EnumToStr = L"DstvReaderModule"; break;
760  case NavisReaderModule: EnumToStr = L"NavisReaderModule"; break;
761  case QifReaderModule: EnumToStr = L"QifReaderModule"; break;
762  case Zw3dReaderModule: EnumToStr = L"Zw3dReaderModule"; break;
763  case StlReaderModule: EnumToStr = L"StlReaderModule"; break;
764  case IfcReaderModule: EnumToStr = L"IfcReaderModule"; break;
765  case RevitReaderModule: EnumToStr = L"RevitReaderModule"; break;
766  case MaxReaderModules: EnumToStr = L"MaxReaderModules"; break;
767  case UnknownModule: EnumToStr = L"UnknownModule"; break;
768  default:
769  EnumToStr = L"UnknownModule";
770  }
771  return EnumToStr;
772  }
Dtk_DumpXml_Dtk_SymbolPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SymbolPtr(FILE *F, const Dtk_SymbolPtr &D)
Definition: util_xml_dtk.cpp:2742
Dtk_DumpXml_Dtk_DatumTargetPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DatumTargetPtr(FILE *F, const Dtk_DatumTargetPtr &D)
Definition: util_xml_dtk.cpp:2079
Dtk_KinLaw
Dtk_KinLaw represents a law associated at a command.
Definition: util_kinematics_dtk.hpp:2335
Dtk_DumpXml_Dtk_NodePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr(FILE *F, const Dtk_NodePtr &inObject)
Definition: util_xml_dtk.cpp:4435
Dtk_KinJoint::getName
Dtk_string getName()
Returns the joint name.
Dtk_KinJoint::getConstraint
Dtk_KinConstraintPtr getConstraint(Dtk_Size_t inPosition)
Returns Constraint at position inPosition.
Dtk_Info::FindAttribute
Dtk_ErrorStatus FindAttribute(const Dtk_string &name, Dtk_Val &val) const
Dtk_NodeConnector::ReasonLinkEnum
ReasonLinkEnum
Reason - Type of the Dtk_NodeConnector -. It's used to filter connectors to same elements.
Definition: dtk_maindoc.hpp:1082
DTK_FEAT_THREAD
@ DTK_FEAT_THREAD
Definition: str_feat_dtk.hpp:302
Dtk_KinJoint::_FIX_TOGETHER
Dtk_string _FIX_TOGETHER
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:931
Dtk_KinParameter::getParentType
DTK_KINEMATIC_TYPE getParentType()
Returns the node parent type of this parameter (joint, command or mechanism)
CaddsReaderModule
@ CaddsReaderModule
Definition: dtk_maindoc.hpp:45
Dtk_ToleranceSpecificationContainer::Typeunknown
@ Typeunknown
Definition: util_draw_dtk.hpp:6208
Dtk_DumpXml_Dtk_GeometricalTolerancePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GeometricalTolerancePtr(FILE *F, const Dtk_GeometricalTolerancePtr &D)
Definition: util_xml_dtk.cpp:2513
RnXmlReaderModule
@ RnXmlReaderModule
Definition: dtk_maindoc.hpp:59
Dtk_DumpXml_Dtk_LeaderPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LeaderPtr(FILE *F, const Dtk_LeaderPtr &L)
Definition: util_xml_dtk.cpp:1286
Dtk_ID
uint32_t Dtk_ID
Definition: define.h:689
DTK_FDT_MODIFIER_NOT_SET
@ DTK_FDT_MODIFIER_NOT_SET
Definition: util_draw_dtk.hpp:64
Dtk_RenderInfos::GetLightMap
Dtk_LightMapPtr GetLightMap() const
Returns Dtk_LightMap.
CerconReaderModule
@ CerconReaderModule
Definition: dtk_maindoc.hpp:48
Dtk_DocElement::GetFatherID
Dtk_ID GetFatherID(Dtk_Size_t inIndex) const
Retrieves Dtk_DocElement ith FatherID - read only -.
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:1493
Dtk_mesh_face
This is a high level face class.
Definition: util_mesh_dtk.hpp:865
Dtk_Roughness::ApplyToSurroundingSurfaces
@ ApplyToSurroundingSurfaces
Definition: util_draw_dtk.hpp:2712
Dtk_Text::TextStyle
Dtk_TextStyle & TextStyle()
Retrieves the text text style - get/set -.
DTK_TYPE_GEOM_TOL
@ DTK_TYPE_GEOM_TOL
Definition: define.h:439
Dtk_KinJoint::_RATIO_PARAMETER
Dtk_string _RATIO_PARAMETER
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:970
PlmXmlReaderModule
@ PlmXmlReaderModule
Definition: dtk_maindoc.hpp:55
Dtk_DumpXml_Dtk_dir
Dtk_ErrorStatus Dtk_DumpXml_Dtk_dir(FILE *F, const Dtk_dir &D, const char *b)
Definition: util_xml_dtk.cpp:4188
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:1757
NavisReaderModule
@ NavisReaderModule
Definition: dtk_maindoc.hpp:77
Dtk_DumpXml_Dtk_MetadataPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataPtr(FILE *F, const Dtk_MetaDataPtr &inObject)
Definition: util_xml_dtk.cpp:4798
Dtk_DumpXml_DTK_FDT_MODIFIER
Dtk_ErrorStatus Dtk_DumpXml_DTK_FDT_MODIFIER(FILE *F, const DTK_FDT_MODIFIER &D)
Definition: util_xml_dtk.cpp:2587
Dtk_DumpXml_Dtk_LinePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LinePtr(FILE *F, const Dtk_LinePtr &inCurve)
Definition: util_xml_dtk.cpp:4945
Dtk_Leader::ArrowHead::GetType
const LeaderTerminatorTypeEnum GetType() const
Definition: util_draw_dtk.hpp:2165
Dtk_ModelDisplay::rendering_mode_wireframe_face_analysis
@ rendering_mode_wireframe_face_analysis
Definition: util_ent_dtk.hpp:851
XMLElement
@ XMLElement
Definition: util_xml_dtk.hpp:95
Dtk_status::isNotOK
Dtk_bool isNotOK() const
Dtk_API::GetNumCurveLineTypeDefinitionsInTable
Dtk_Size_t GetNumCurveLineTypeDefinitionsInTable() const
DTK_TYPE_DIMENSION
@ DTK_TYPE_DIMENSION
Definition: define.h:440
Dtk_Text::TextSubType
DTK_Text_subtype & TextSubType()
Retrieves the text subtype - get/set -.
Dtk_DatumTarget::NumValues
@ NumValues
Definition: util_draw_dtk.hpp:3894
Dtk_KinJoint
Dtk_KinJoint represents a joint to define a mechanism.
Definition: util_kinematics_dtk.hpp:863
Dtk_KinJoint::getJoint1
Dtk_KinJointPtr getJoint1()
Returns the first joint associated at the joint.
XMLGenericString
@ XMLGenericString
Definition: util_xml_dtk.hpp:97
Dtk_DumpXml_Dtk_KinematicsFixPart
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFixPart(FILE *inFile, const Dtk_KinFixPartPtr &inFixPart)
Definition: util_xml_dtk.cpp:7381
DTK_WITH_HIERARCHY
@ DTK_WITH_HIERARCHY
Definition: util_draw_dtk.hpp:74
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_CompositeText::GetNumTexts
Dtk_Size_t GetNumTexts() const
Retrieves the texts number.
Dtk_Roughness::ApplyToAllSurfaces
@ ApplyToAllSurfaces
Definition: util_draw_dtk.hpp:2716
Dtk_DumpXml_FeatHole
Dtk_ErrorStatus Dtk_DumpXml_FeatHole(FILE *f, const Dtk_feat_hole *inToWrite)
Definition: util_xml_dtk.cpp:7812
Dtk_DumpXml_Dtk_2dEntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_2dEntityPtr(FILE *F, const Dtk_2dEntityPtr &D, const int &compact)
Definition: util_xml_dtk.cpp:2765
Dtk_KinJoint::_LOWER_LIMIT2
Dtk_string _LOWER_LIMIT2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:949
Dtk_DumpXml_Dtk_KinematicsProduct
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsProduct(FILE *inFile, const Dtk_KinProductPtr &inKinProduct, int &inKinProductIndex)
Definition: util_xml_dtk.cpp:7401
Dtk_DatumTarget::DatumTargetValueEnumToString
static Dtk_string DatumTargetValueEnumToString(const DatumTargetValueEnum &inEnum)
Definition: util_draw_dtk.hpp:3897
DTK_FDT_MODIFIER_LEAST_MATERIAL
@ DTK_FDT_MODIFIER_LEAST_MATERIAL
Definition: util_draw_dtk.hpp:66
Dtk_DumpXml_Dtk_OneCell
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OneCell(FILE *F, Dtk_OneCell &D)
Definition: util_xml_dtk.cpp:2194
Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr(FILE *F, const Dtk_ToleranceSpecificationContainerPtr &D)
Definition: util_xml_dtk.cpp:2487
Dtk_RenderInfos::GetShaderType
RenderMappingShaderTypeEnum GetShaderType() const
Returns shader type.
PsReaderModule
@ PsReaderModule
Definition: dtk_maindoc.hpp:40
Dtk_SmartPtr::IsNotNULL
Dtk_bool IsNotNULL() const
Definition: util_ptr_dtk.hpp:119
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:6366
DTK_FDT_MODIFIER_NONE
@ DTK_FDT_MODIFIER_NONE
Definition: util_draw_dtk.hpp:68
Dtk_OneCell::GetBorderBottomColor
const Dtk_RGB & GetBorderBottomColor()
Gets BorderBottomColor of Bottom border.
Dtk_Roughness::ModePerpendicular
@ ModePerpendicular
Definition: util_draw_dtk.hpp:2734
Dtk_Node::NodeHasSolids
Dtk_bool NodeHasSolids() const
Return DTK_TRUE if Dtk_Node Type Body contains solid entity.
Dtk_Node::NodeHasPoints
Dtk_bool NodeHasPoints() const
Return DTK_TRUE if Dtk_Node Type Body or Mesh contains points entity.
Dtk_KinJoint::_LOCAL_FRAME3
Dtk_string _LOCAL_FRAME3
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:955
Dtk_DatumTarget::DatumTargetValueEnum
DatumTargetValueEnum
Definition: util_draw_dtk.hpp:3885
Dtk_ToleranceSpecificationContainer::TypeAxisIntersection
@ TypeAxisIntersection
Definition: util_draw_dtk.hpp:6238
DTK_TYPE_VERTEX
@ DTK_TYPE_VERTEX
Definition: define.h:125
Dtk_OneCell::GetBorderRightColor
const Dtk_RGB & GetBorderRightColor()
Gets BorderRightColor of Right border.
Dtk_KinJoint::_CONSTRAINT
Dtk_string _CONSTRAINT
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:922
Dtk_KinFixPart::getName
Dtk_string getName()
Returns the fix part name.
Dtk_KinJoint::_PARAMETER1
Dtk_string _PARAMETER1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:925
Dtk_DumpXml_Dtk_ComponentPtr_Init
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_Init(FILE *F, const Dtk_ComponentPtr &inObject)
Definition: util_xml_dtk.cpp:4691
Dtk_Info::GetCurveThickNessInMM
Dtk_Double64 GetCurveThickNessInMM() const
Retrieves the curve thickness - if exists and relevant -.
Dtk_OneCell::GetBorderLeftColor
const Dtk_RGB & GetBorderLeftColor()
Gets BorderLeftColor of Left border.
Dtk_KinCommand
Dtk_KinCommand represents a command to simulate a mechanism.
Definition: util_kinematics_dtk.hpp:1336
Dtk_DocElement::GetMetaData
Dtk_MetaDataPtr GetMetaData(const Dtk_Size_t &inPos) const
Retrieves the ith Dtk_MetaDataPtr - read only -.
Dtk_DumpXml_Dtk_VertexPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_VertexPtr(FILE *F, const Dtk_VertexPtr &inVertex)
Definition: util_xml_dtk.cpp:6276
Dtk_RGB::IndexReader
int & IndexReader()
Definition: dtk_rgb.hpp:46
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.
CerecReaderModule
@ CerecReaderModule
Definition: dtk_maindoc.hpp:49
Dtk_DumpXml_Dtk_KinematicsParameter
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsParameter(FILE *inFile, const Dtk_KinParameterPtr &inParameter, Dtk_bool simplified)
Definition: util_xml_dtk.cpp:6872
Dtk_DumpXml_ComponentTypeEnum
void Dtk_DumpXml_ComponentTypeEnum(FILE *F, const Dtk_Component::ComponentTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:680
Dtk_Roughness::ApplyToBasicSurface
@ ApplyToBasicSurface
Definition: util_draw_dtk.hpp:2714
Dtk_KinParameter::getId
int getId()
Retrun the parameter id.
Dtk_ToleranceSpecificationContainer::TypeFlatness
@ TypeFlatness
Definition: util_draw_dtk.hpp:6212
Dtk_Roughness::ModeMultiDirectional
@ ModeMultiDirectional
Definition: util_draw_dtk.hpp:2722
DTK_TYPE_POLYLINE
@ DTK_TYPE_POLYLINE
Definition: define.h:58
Dtk_DumpXml_Dtk_EllipsePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EllipsePtr(FILE *F, const Dtk_EllipsePtr &inCurve)
Definition: util_xml_dtk.cpp:5076
DTK_TRUE
#define DTK_TRUE
Definition: define.h:727
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:559
Dtk_Node::NodeDataTypeEnum
NodeDataTypeEnum
Definition: dtk_maindoc.hpp:246
PrcReaderModule
@ PrcReaderModule
Definition: dtk_maindoc.hpp:73
V5ReaderModule
@ V5ReaderModule
Definition: dtk_maindoc.hpp:30
Dtk_KinJoint::_UPPER_LIMIT1
Dtk_string _UPPER_LIMIT1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:940
Dtk_KinFixPart::getId
int getId()
Retrun the fix part id.
dtkErrorUnspecified
@ dtkErrorUnspecified
Definition: error_dtk.hpp:17
Dtk_Roughness::ObtentionTypeMachiningForbidden
@ ObtentionTypeMachiningForbidden
Definition: util_draw_dtk.hpp:2705
SatReaderModule
@ SatReaderModule
Definition: dtk_maindoc.hpp:42
Dtk_DumpXml_Dtk_CameraPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraPtr(FILE *F, const Dtk_CameraPtr &inVal)
Definition: util_xml_dtk.cpp:3130
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:913
Zw3dReaderModule
@ Zw3dReaderModule
Definition: dtk_maindoc.hpp:80
Dtk_KinJoint::_RATIO
Dtk_string _RATIO
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:967
Dtk_UInt32
uint32_t Dtk_UInt32
Definition: define.h:688
Dtk_string
This is a high level string class.
Definition: dtk_string.hpp:58
Dtk_ModelDisplay::rendering_mode_shaded_with_visible_edges
@ rendering_mode_shaded_with_visible_edges
Definition: util_ent_dtk.hpp:847
Dtk_API::GetPhysicalMaterialInfosInTable
Dtk_PhysicalMaterialInfosPtr GetPhysicalMaterialInfosInTable(Dtk_ID inId) const
Dtk_ModelDisplay::rendering_mode_wireframe_with_all_edges
@ rendering_mode_wireframe_with_all_edges
Definition: util_ent_dtk.hpp:848
Dtk_KinParameter::_RANGE
Dtk_string _RANGE
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:327
DTK_ANCHOR_BOTTOM_LEFT
@ DTK_ANCHOR_BOTTOM_LEFT
Definition: util_draw_dtk.hpp:106
Dtk_DumpXml_Dtk_KinematicsLaw
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsLaw(FILE *inFile, const Dtk_KinLawPtr &inLaw)
Definition: util_xml_dtk.cpp:7123
Dtk_Node::NodeHasMeshSurfaces
Dtk_bool NodeHasMeshSurfaces() const
Return DTK_TRUE if Dtk_Node Type Body contains mesh surface entity.
Dtk_KinJoint::_CONNECTOR
Dtk_string _CONNECTOR
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:973
Dtk_Size_t
size_t Dtk_Size_t
Definition: define.h:712
Dtk_Info::GetColor
Dtk_RGB GetColor() const
Retrieves the entity color as Dtk_RGBA values.
Dtk_NodeConnector::SubEntity
Definition: dtk_maindoc.hpp:1212
Dtk_DumpXml_Dtk_LineTypeDefinitionPtr
void Dtk_DumpXml_Dtk_LineTypeDefinitionPtr(FILE *F, const Dtk_LineTypeDefinitionPtr &inLineTypeDefinition)
Definition: util_xml_dtk.cpp:3905
Dtk_DumpXml_Dtk_EdgePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EdgePtr(FILE *F, const Dtk_EdgePtr &inEdge)
Definition: util_xml_dtk.cpp:6292
DTK_TYPE_COMPOSITE_ENTITY
@ DTK_TYPE_COMPOSITE_ENTITY
Definition: define.h:450
DTK_ANCHOR_TOP_CENTER
@ DTK_ANCHOR_TOP_CENTER
Definition: util_draw_dtk.hpp:101
Dtk_ToleranceSpecificationContainer::TypeStraightness
@ TypeStraightness
Definition: util_draw_dtk.hpp:6210
XmlReaderModule
@ XmlReaderModule
Definition: dtk_maindoc.hpp:52
Dtk_string::convert_from_int
void convert_from_int(const int integer, int force_unsigned_int=0)
affectation operator from a int
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:44
Dtk_DumpXml_Dtk_val
Dtk_ErrorStatus Dtk_DumpXml_Dtk_val(FILE *F, const Dtk_Val &V)
Definition: util_xml_dtk.cpp:3454
Dtk_KinJoint::_JOINT2
Dtk_string _JOINT2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:964
Dtk_Node::NodeHasAxis
Dtk_bool NodeHasAxis() const
Return DTK_TRUE if Dtk_Node Type Body contains axis entity.
Dtk_DumpXml_Dtk_CompositeText
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CompositeText(FILE *F, const Dtk_CompositeText &T)
Definition: util_xml_dtk.cpp:1243
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:1729
Dtk_UUID
Definition: dtk_uuid.hpp:8
Dtk_Val::GetIntArray
Dtk_tab< Dtk_Int32 > GetIntArray(Dtk_status &st=Dtk_status::GetDefaultStatus()) const
DTK_ANCHOR_BOTTOM_CENTER
@ DTK_ANCHOR_BOTTOM_CENTER
Definition: util_draw_dtk.hpp:107
Dtk_DumpXml_Dtk_RoughnessPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RoughnessPtr(FILE *F, const Dtk_RoughnessPtr &D)
Definition: util_xml_dtk.cpp:1571
UnknownModule
@ UnknownModule
Definition: dtk_maindoc.hpp:82
Dtk_DumpXml_Dtk_FontLineTypeEnum
void Dtk_DumpXml_Dtk_FontLineTypeEnum(FILE *F, const Dtk_FontLineType &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:2311
Dtk_Fdt::Default
@ Default
Definition: util_draw_dtk.hpp:7378
Dtk_Roughness::ModeParticular
@ ModeParticular
Definition: util_draw_dtk.hpp:2728
Dtk_status
Definition: dtk_status.hpp:16
Dtk_KinJoint::getRatioParameter
Dtk_KinParameterPtr getRatioParameter()
Returns the Dtk_KinParameter ratio of the joint.
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_Leader::ApplicationZone::ApplicationZoneEnumToString
static Dtk_string ApplicationZoneEnumToString(const ApplicationZoneEnum &inEnum)
Definition: util_draw_dtk.hpp:1876
DTK_TYPE_PARABOLA
@ DTK_TYPE_PARABOLA
Definition: define.h:63
Dtk_KinJoint::getId
int getId()
Retrun the joint id.
dtkWarningNoEntitiesWritten
@ dtkWarningNoEntitiesWritten
Definition: error_dtk.hpp:87
Dtk_DumpXml_FormatDtk_string
Dtk_string Dtk_DumpXml_FormatDtk_string(const Dtk_string &inString, const XML_StringType inXmlStringType)
Definition: util_xml_dtk.cpp:4304
Dtk_KinJoint::getAbsolutPos1
Dtk_transfo getAbsolutPos1()
Returns the part 1 absolute position.
F3dReaderModule
@ F3dReaderModule
Definition: dtk_maindoc.hpp:74
DTK_FEAT_PATTERN
@ DTK_FEAT_PATTERN
Definition: str_feat_dtk.hpp:317
DTK_FALSE
#define DTK_FALSE
Definition: define.h:728
Dtk_DumpXml_Dtk_ParabolaPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ParabolaPtr(FILE *F, const Dtk_ParabolaPtr &inCurve)
Definition: util_xml_dtk.cpp:5054
DTK_TYPE_NURBS_CURVE
@ DTK_TYPE_NURBS_CURVE
Definition: define.h:494
StlReaderModule
@ StlReaderModule
Definition: dtk_maindoc.hpp:67
DTK_TYPE_SYMBOL
@ DTK_TYPE_SYMBOL
Definition: define.h:409
Dtk_bool
char Dtk_bool
Definition: define.h:725
ProCeraReaderModule
@ ProCeraReaderModule
Definition: dtk_maindoc.hpp:47
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:437
Dtk_DatumTarget::DatumTargetTypeEnumToString
static Dtk_string DatumTargetTypeEnumToString(const DatumTargetTypeEnum &inEnum)
Definition: util_draw_dtk.hpp:3852
Dtk_DumpXml_Dtk_PhysicalMaterialInfos
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PhysicalMaterialInfos(FILE *F, const Dtk_PhysicalMaterialInfosPtr &inMaterial)
Definition: util_xml_dtk.cpp:3638
AcisReaderModule
@ AcisReaderModule
Definition: dtk_maindoc.hpp:46
Dtk_DumpXml_NodeTypeEnum
void Dtk_DumpXml_NodeTypeEnum(FILE *F, const Dtk_Node::NodeDataTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:689
Dtk_Symbol::Create
static Dtk_SymbolPtr Create()
Base constructor.
Dtk_ModelDisplay::rendering_mode_wireframe_with_only_visible_edges
@ rendering_mode_wireframe_with_only_visible_edges
Definition: util_ent_dtk.hpp:849
DTK_ANCHOR_MIDDLE_CENTER
@ DTK_ANCHOR_MIDDLE_CENTER
Definition: util_draw_dtk.hpp:104
Dtk_RenderInfos::RenderMappingShaderTypeEnum
RenderMappingShaderTypeEnum
Definition: dtk_render.hpp:289
Dtk_mesh_face::get_subinfo
Dtk_InfoPtr & get_subinfo(Dtk_Size_t inI)
Dtk_RenderInfos::Unknown
@ Unknown
Definition: dtk_render.hpp:290
Dtk_Info::GetUuid
Dtk_UUID GetUuid() const
Dtk_DumpXml_Dtk_NurbsCurvePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NurbsCurvePtr(FILE *F, const Dtk_NurbsCurvePtr &inCurve)
Definition: util_xml_dtk.cpp:4985
SwReaderModule
@ SwReaderModule
Definition: dtk_maindoc.hpp:36
Dtk_DumpXml_DtkReaderType
void Dtk_DumpXml_DtkReaderType(FILE *F, const DtkReaderType &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:797
Dtk_Node::GetChild
const Dtk_NodePtr GetChild(const Dtk_Size_t &inPos) const
Retrieves the ith Dtk_Node - read only -.
Definition: dtk_maindoc.hpp:385
Dtk_DumpXml_Dtk_NodeConnector
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodeConnector(FILE *inFile, const Dtk_NodeConnectorPtr &inNodeConnector)
Definition: util_xml_dtk.cpp:6700
Dtk_Double64
double Dtk_Double64
Definition: define.h:699
Dtk_DumpXml_Dtk_welding_symbol
Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_symbol(FILE *F, const Dtk_Welding::WeldingSymbolEnum &D)
Definition: util_xml_dtk.cpp:1628
Dtk_DumpXml_Dtk_TextStyle
Dtk_ErrorStatus Dtk_DumpXml_Dtk_TextStyle(FILE *F, const Dtk_TextStyle &T)
Definition: util_xml_dtk.cpp:955
Dtk_DumpXml_FeatThread
Dtk_ErrorStatus Dtk_DumpXml_FeatThread(FILE *f, const Dtk_feat_thread *inToWrite)
Definition: util_xml_dtk.cpp:7753
Dtk_mesh_face::get_nbpolylines
Dtk_Size_t get_nbpolylines() const
Get the number of polylines kept in the class instance.
Dtk_ModelDisplay::RenderingModeEnum
RenderingModeEnum
Definition: util_ent_dtk.hpp:845
Dtk_OneCell::GetAdditionnalGeometries
const Dtk_tab< Dtk_EntityPtr > & GetAdditionnalGeometries() const
Retrieves the additionnal geometries of the Dtk_OneCell.
DTK_KIN_TYPE_LAW
@ DTK_KIN_TYPE_LAW
Definition: util_kinematics_dtk.hpp:112
Dtk_DumpXml_Dtk_SelectionSet
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SelectionSet(FILE *F, const Dtk_SelectionSetPtr &inSelectionSet)
Definition: util_xml_dtk.cpp:6779
Dtk_Node::GetAssociatedEntities
Dtk_ErrorStatus GetAssociatedEntities(Dtk_tab< Dtk_NodeConnectorPtr > &outAssociatedEntities)
Retrieves the entities associated to the Dtk_Node. They are retrieved via Dtk_NodeConnectorPtr.
Dtk_DumpXml_Value
Dtk_ErrorStatus Dtk_DumpXml_Value(FILE *inFile, const Dtk_string &inLabel, const char *inFormat,...)
Definition: util_xml_dtk.cpp:4205
XmlFormat
#define XmlFormat(inOldFormat)
Definition: util_xml_dtk.cpp:43
Dtk_KinJoint::_ABSOLUT_POS1
Dtk_string _ABSOLUT_POS1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:934
DTK_ANCHOR_TOP_LEFT
@ DTK_ANCHOR_TOP_LEFT
Definition: util_draw_dtk.hpp:100
CgrReaderModule
@ CgrReaderModule
Definition: dtk_maindoc.hpp:44
Dtk_Fdt::ScreenDisplayEnum
ScreenDisplayEnum
Definition: util_draw_dtk.hpp:7377
DTK_W
#define DTK_W
Definition: dtk_string.hpp:43
Dtk_DumpXml_Dtk_KinematicsMechanism
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsMechanism(FILE *inFile, const Dtk_KinMechanismPtr &inKinMechanism)
Definition: util_xml_dtk.cpp:7465
Dtk_DumpXml_Dtk_KinematicsFormula
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFormula(FILE *inFile, const Dtk_KinFormulaPtr &inFormula)
Definition: util_xml_dtk.cpp:7107
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:2290
Dtk_DumpXml_Dtk_info
Dtk_ErrorStatus Dtk_DumpXml_Dtk_info(FILE *F, const Dtk_InfoPtr &I)
Definition: util_xml_dtk.cpp:4001
Dtk_KinJoint::getParameter2
double getParameter2()
Returns the second parameter.
Dtk_Val
Definition: dtk_val.hpp:67
Dtk_KinParameter::getNamedValue
Dtk_KinNamedValuePtr getNamedValue()
Returns the named value associated at the parameter.
Dtk_KinJoint::getLocalFrame3
Dtk_transfo getLocalFrame3()
Returns the local frame 3 value.
QifReaderModule
@ QifReaderModule
Definition: dtk_maindoc.hpp:78
Dtk_Node::GetNodeType
NodeDataTypeEnum GetNodeType() const
Retrieves the Dtk_Node Node Type - read only -.
Dtk_Val::GetInt
int GetInt(Dtk_status &st=Dtk_status::GetDefaultStatus()) const
Dtk_DumpXml_Dtk_LumpPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LumpPtr(FILE *F, const Dtk_LumpPtr &inLump)
Definition: util_xml_dtk.cpp:6436
Dtk_Text::Text
Dtk_string & Text()
Retrieves the text string - get/set -.
Dtk_Fdt::ScreenDisplayEnumToString
static Dtk_string ScreenDisplayEnumToString(const ScreenDisplayEnum &inEnum)
Definition: util_draw_dtk.hpp:7382
Dtk_ModelDisplay::SectionPlane
@ SectionPlane
Definition: util_ent_dtk.hpp:857
Dtk_Leader::TypeUnknown
@ TypeUnknown
Definition: util_draw_dtk.hpp:2224
Dtk_API::GetAPI
static Dtk_API * GetAPI()
Get DATAKIT API.
Dtk_DumpXml_Dtk_transfo
Dtk_ErrorStatus Dtk_DumpXml_Dtk_transfo(FILE *F, const Dtk_transfo &T)
Definition: util_xml_dtk.cpp:4194
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:32
Dtk_KinJoint::getLowerLimit2
double getLowerLimit2()
Returns the lower limit 2.
Dtk_ToleranceSpecificationContainer::TypeCylindricity
@ TypeCylindricity
Definition: util_draw_dtk.hpp:6216
Dtk_OneCell::GetBorderTopColor
const Dtk_RGB & GetBorderTopColor()
Gets BorderTopColor of Top border.
Dtk_DumpXml_MetaDataTypeEnum
void Dtk_DumpXml_MetaDataTypeEnum(FILE *F, const Dtk_MetaData::MetaDataTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:707
Dtk_DumpXml_Dtk_StreamPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_StreamPtr(FILE *F, const Dtk_StreamPtr &inVal)
Definition: util_xml_dtk.cpp:8446
Dtk_DumpXml_Dtk_WeldingPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_WeldingPtr(FILE *F, const Dtk_WeldingPtr &D)
Definition: util_xml_dtk.cpp:1791
Dtk_ModelDisplay::rendering_mode_wireframe_partially_shade
@ rendering_mode_wireframe_partially_shade
Definition: util_ent_dtk.hpp:852
DxfReaderModule
@ DxfReaderModule
Definition: dtk_maindoc.hpp:54
Dtk_OneCell::GetBorderLeftBlanked
Dtk_Int32 GetBorderLeftBlanked()
Gets BorderLeftBlanked of Left border.
Dtk_KinJoint::getLocalFrame1
Dtk_transfo getLocalFrame1()
Returns the local frame 1 value.
Dtk_DocElement::Name
const Dtk_string & Name() const
Retrieves the Dtk_DocElement Name - read only -.
Dtk_DumpXml_Dtk_CurvePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CurvePtr(FILE *F, const Dtk_CurvePtr &inCurve)
Definition: util_xml_dtk.cpp:5774
Dtk_DumpXml_Dtk_AnnotationPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_AnnotationPtr(FILE *F, const Dtk_AnnotationPtr &D)
Definition: util_xml_dtk.cpp:875
DTK_INDIFFERENT_HIERARCHY
@ DTK_INDIFFERENT_HIERARCHY
Definition: util_draw_dtk.hpp:76
Dtk_DumpXml_Dtk_DrawingPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DrawingPtr(FILE *F, const Dtk_DrawingPtr &D, const int &compact)
Definition: util_xml_dtk.cpp:2998
IgesReaderModule
@ IgesReaderModule
Definition: dtk_maindoc.hpp:38
Dtk_ModelDisplay::rendering_mode_shaded_only
@ rendering_mode_shaded_only
Definition: util_ent_dtk.hpp:846
Dtk_NodeConnector::ReasonCategoryEnum
ReasonCategoryEnum
Reason Category. Global Category of the NodeConnector uesed to gather Reason into families.
Definition: dtk_maindoc.hpp:1187
_3dXmlReaderModule
@ _3dXmlReaderModule
Definition: dtk_maindoc.hpp:51
Dtk_ModelDisplay::SectionBox
@ SectionBox
Definition: util_ent_dtk.hpp:860
Dtk_DumpXml_LeaderTerminatorTypeEnum
void Dtk_DumpXml_LeaderTerminatorTypeEnum(FILE *F, const Dtk_Leader::LeaderTerminatorTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:830
DTK_TYPE_INTERSECTION_CURVE
@ DTK_TYPE_INTERSECTION_CURVE
Definition: define.h:89
Dtk_Leader::TypeLinear
@ TypeLinear
Definition: util_draw_dtk.hpp:2225
V6ReaderModule
@ V6ReaderModule
Definition: dtk_maindoc.hpp:53
Dtk_KinJoint::getUpperLimit2
double getUpperLimit2()
Returns the upper limit 2.
SeReaderModule
@ SeReaderModule
Definition: dtk_maindoc.hpp:37
DcmReaderModule
@ DcmReaderModule
Definition: dtk_maindoc.hpp:50
MaxReaderModules
@ MaxReaderModules
Definition: dtk_maindoc.hpp:83
Dtk_Roughness::ModeParallel
@ ModeParallel
Definition: util_draw_dtk.hpp:2732
DTK_ANCHOR_TOP_RIGHT
@ DTK_ANCHOR_TOP_RIGHT
Definition: util_draw_dtk.hpp:102
DTK_FDT_MODIFIER_MAX_MATERIAL
@ DTK_FDT_MODIFIER_MAX_MATERIAL
Definition: util_draw_dtk.hpp:65
Dtk_DumpXml_Dtk_EntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EntityPtr(FILE *inDumpFile, const Dtk_EntityPtr &inEntity)
Definition: util_xml_dtk.cpp:5097
Dtk_ModelDisplay::rendering_mode_static_wireframe
@ rendering_mode_static_wireframe
Definition: util_ent_dtk.hpp:850
Dtk_Node::GetStoredInfos
Dtk_StoredInfoPtr GetStoredInfos() const
Dtk_OneCell::getWidth
Dtk_Double64 getWidth() const
Gets the width of the Dtk_OneCell.
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:2320
RevitReaderModule
@ RevitReaderModule
Definition: dtk_maindoc.hpp:65
Dtk_NodeConnector::ReasonLinkEnumToString
static Dtk_string ReasonLinkEnumToString(const ReasonLinkEnum &inEnum)
Definition: dtk_maindoc.hpp:1135
DTK_TYPE_CIRCLE
@ DTK_TYPE_CIRCLE
Definition: define.h:60
Dtk_Int32
int32_t Dtk_Int32
Definition: define.h:687
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:269
ArtReaderModule
@ ArtReaderModule
Definition: dtk_maindoc.hpp:71
Dtk_Text::TextType
DTK_Text_type & TextType()
Retrieves the text type - get/set -.
Dtk_Component::ComponentAvailabilityEnumToString
static Dtk_string ComponentAvailabilityEnumToString(const ComponentAvailabilityEnum &inEnum)
Definition: dtk_maindoc.hpp:584
Dtk_Roughness::ObtentionTypeNotDefined
@ ObtentionTypeNotDefined
Definition: util_draw_dtk.hpp:2701
Dtk_DumpXml_Dtk_RGB
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RGB(FILE *F, const Dtk_RGB &RGB)
Definition: util_xml_dtk.cpp:3442
Dtk_KinJoint::_PARAMETER2
Dtk_string _PARAMETER2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:928
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:853
DTK_TYPE_GRID
@ DTK_TYPE_GRID
Definition: define.h:451
V4ReaderModule
@ V4ReaderModule
Definition: dtk_maindoc.hpp:33
Dtk_ToleranceSpecificationContainer::TypeSymmetry
@ TypeSymmetry
Definition: util_draw_dtk.hpp:6232
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:2253
Dtk_Leader::ArrowHead::GetArrowLocation
const Dtk_pnt & GetArrowLocation() const
Definition: util_draw_dtk.hpp:2164
Dtk_Component::ComponentTypeEnumToString
static Dtk_string ComponentTypeEnumToString(const ComponentTypeEnum &inEnum)
Definition: dtk_maindoc.hpp:600
Dtk_DocElement::GetInfos
Dtk_InfoPtr GetInfos() const
Retrieves the Dtk_DocElement Dtk_InfoPtr - read only -.
Dtk_Leader::ArrowHead::GetWidthHeight
void GetWidthHeight(Dtk_Double64 &outWidth, Dtk_Double64 &outHeight) const
Definition: util_draw_dtk.hpp:2173
Dtk_KinSpeedAcceleration
Dtk_KinSpeedAcceleration represents a mechanism speed/acceleration.
Definition: util_kinematics_dtk.hpp:2503
DTK_TYPE_LINE
@ DTK_TYPE_LINE
Definition: define.h:57
StepReaderModule
@ StepReaderModule
Definition: dtk_maindoc.hpp:39
Dtk_ToleranceSpecificationContainer::TypeTotalRunout
@ TypeTotalRunout
Definition: util_draw_dtk.hpp:6236
DstvReaderModule
@ DstvReaderModule
Definition: dtk_maindoc.hpp:75
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:1016
Dtk_DumpXml_Dtk_ComponentPtr_End
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_End(FILE *F)
Definition: util_xml_dtk.cpp:4785
Dtk_MetaData::MetaDataTypeEnum
MetaDataTypeEnum
Definition: dtk_metadata.hpp:26
Dtk_KinParameter::getParentElement
void * getParentElement()
Returns the parent element.
Dtk_ToleranceSpecificationContainer::TypeCircularRunout
@ TypeCircularRunout
Definition: util_draw_dtk.hpp:6234
Dtk_DumpXml_NodeFullType
void Dtk_DumpXml_NodeFullType(FILE *F, const Dtk_Node::FullType &inNodeFullType, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:698
Dtk_KinFixPart::getPart
Dtk_KinPartPtr getPart()
Returns the part fixed.
Dtk_ErrorStatus
Dtk_ErrorStatus
Definition: error_dtk.hpp:6
Dtk_Roughness::ObtentionTypeMachiningMandatory
@ ObtentionTypeMachiningMandatory
Definition: util_draw_dtk.hpp:2703
Dtk_SmartPtr::IsNULL
Dtk_bool IsNULL() const
Definition: util_ptr_dtk.hpp:118
Dtk_DumpXml_Dtk_pnt
Dtk_ErrorStatus Dtk_DumpXml_Dtk_pnt(FILE *F, const Dtk_pnt &P, const char *b)
Definition: util_xml_dtk.cpp:4182
Dtk_KinJoint::getCompoundType
int getCompoundType()
Returns the compound type attribute.
Dtk_DocElement::GetNumChildren
Dtk_Size_t GetNumChildren() const
Retrieves the number of the Dtk_DocElement children - read only -.
SdnfReaderModule
@ SdnfReaderModule
Definition: dtk_maindoc.hpp:70
Dtk_Roughness::ModeNone
@ ModeNone
Definition: util_draw_dtk.hpp:2720
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:98
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:2381
Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr(FILE *F, const Dtk_FCFFeatureIndicatorPtr &D)
Definition: util_xml_dtk.cpp:2724
Dtk_StandardTools::sprintf_dtk
int sprintf_dtk(char *Buffer, size_t BufferCount, const char *Format,...)
XMLAttribute
@ XMLAttribute
Definition: util_xml_dtk.hpp:96
DTK_TYPE_SPCURVE
@ DTK_TYPE_SPCURVE
Definition: define.h:575
DTK_FRAME_TYPE_NONE
@ DTK_FRAME_TYPE_NONE
Definition: util_draw_dtk.hpp:134
Dtk_OneCell::GetBorderBottomBlanked
Dtk_Int32 GetBorderBottomBlanked()
Gets BorderBottomBlanked of Bottom border.
Dtk_ToleranceSpecificationContainer::TypeParallelism
@ TypeParallelism
Definition: util_draw_dtk.hpp:6226
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_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:978
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:1198
Dtk_DumpXml_Dtk_DimensionPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DimensionPtr(FILE *F, const Dtk_DimensionPtr &D)
Definition: util_xml_dtk.cpp:1423
Dtk_Leader::ArrowHead::GetInfo
const Dtk_InfoPtr & GetInfo() const
Definition: util_draw_dtk.hpp:2162
DTK_UNKNOWN
@ DTK_UNKNOWN
Definition: util_draw_dtk.hpp:73
Dtk_string::is_NULL
Dtk_bool is_NULL() const
DTK_ANCHOR_MIDDLE_LEFT
@ DTK_ANCHOR_MIDDLE_LEFT
Definition: util_draw_dtk.hpp:103
validate_xml_string
Dtk_status validate_xml_string(Dtk_string &inputString)
Definition: util_xml_dtk.cpp:637
Dtk_DatumTarget::NonMovable
@ NonMovable
Definition: util_draw_dtk.hpp:3871
Dtk_OneCell::GetBorderTopBlanked
Dtk_Int32 GetBorderTopBlanked()
Gets BorderTopBlanked of Top border.
catiav5w::NodeType
NodeType
Type of Specification Tree Node used into a CATPart file.
Definition: catiav5w.hpp:426
VdaReaderModule
@ VdaReaderModule
Definition: dtk_maindoc.hpp:31
Dtk_ModelDisplay::SectionParallelePlane
@ SectionParallelePlane
Definition: util_ent_dtk.hpp:859
Dtk_Node::NodeHasCurves
Dtk_bool NodeHasCurves() const
Return DTK_TRUE if Dtk_Node Type Body or Mesh contains curves entity.
Dtk_string::c_str
const char * c_str() const
Retrieve the ASCII conversion string.
Dtk_mesh_face::get_nbsubinfos
Dtk_Size_t get_nbsubinfos() const
Dtk_RGB::IsFilled
bool IsFilled() const
Definition: dtk_rgb.hpp:32
Dtk_DocElement::GetID
Dtk_ID GetID() const
Retrieves the Dtk_DocElement ID - read only -.
Dtk_API::GetNumPhysicalMaterialInfosInTable
Dtk_Size_t GetNumPhysicalMaterialInfosInTable() const
Dtk_KinJoint::getPart1
Dtk_KinPartPtr getPart1()
Returns the first part associated at the joint.
Dtk_ToleranceSpecificationContainer::TypeSurfaceProfile
@ TypeSurfaceProfile
Definition: util_draw_dtk.hpp:6220
Dtk_Roughness::ApplyToSpecifiedSurface
@ ApplyToSpecifiedSurface
Definition: util_draw_dtk.hpp:2710
Dtk_KinJoint::_PART3
Dtk_string _PART3
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:952
Dtk_KinJoint::_ABSOLUT_POS2
Dtk_string _ABSOLUT_POS2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:937
DumpTransfo
void DumpTransfo(FILE *inFile, Dtk_transfo transfo)
Dtk_pnt
This is a mathematical point class.
Definition: dtk_pnt.hpp:22
Dtk_KinJoint::getConnector
Dtk_KinConnectorPtr getConnector(Dtk_Size_t inPosition)
Returns Connector at position inPosition.
w_str
#define w_str
Definition: dtk_string.hpp:35
type_detk
type_detk
Definition: define.h:32
Dtk_DocElement::GetMetaDataGroup
Dtk_MetaDataGroupPtr GetMetaDataGroup(const Dtk_Size_t &inPos) const
Retrieves the ith Dtk_MetaDataGrouplPtr - read only -.
Dtk_KinJoint::getPart3
Dtk_KinPartPtr getPart3()
Returns the third part associated at the joint.
Dtk_DumpXml_Dtk_ComponentPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr(FILE *F, const Dtk_ComponentPtr &inObject)
Definition: util_xml_dtk.cpp:4637
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:1557
Dtk_API::GetCurveLineTypeDefinitionInTable
Dtk_LineTypeDefinitionPtr GetCurveLineTypeDefinitionInTable(const Dtk_ID inId) const
Dtk_ModelDisplay::SectionTypeEnum
SectionTypeEnum
Definition: util_ent_dtk.hpp:856
Dtk_ToleranceSpecificationContainer::TypeCircularity
@ TypeCircularity
Definition: util_draw_dtk.hpp:6214
Dtk_DumpXml_Dtk_CompositeEntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CompositeEntityPtr(FILE *F, const Dtk_CompositeEntityPtr &D)
Definition: util_xml_dtk.cpp:2442
Dtk_ToleranceSpecificationContainer::TypeConcentricity
@ TypeConcentricity
Definition: util_draw_dtk.hpp:6230
Dtk_DumpXml_Dtk_KinematicsCommand
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCommand(FILE *inFile, const Dtk_KinCommandPtr &inCommand, Dtk_bool simplified)
Definition: util_xml_dtk.cpp:7363
Dtk_Info::ListAllAttributes
Dtk_ErrorStatus ListAllAttributes(Dtk_tab< Dtk_string > &tab_keys) const
Dtk_Frame
This is the frame class. It's used to gather all frame informations.
Definition: util_draw_dtk.hpp:916
Dtk_Text::GetFrame
void GetFrame(Dtk_Frame &outFrame) const
Retrieves the Frame - read only -.
Dtk_Leader::ArrowHead
Definition: util_draw_dtk.hpp:2101
Dtk_DumpXml_Dtk_ReferenceFramePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceFramePtr(FILE *F, const Dtk_ReferenceFramePtr &D)
Definition: util_xml_dtk.cpp:2547
Dtk_ModelDisplay::SectionBody
@ SectionBody
Definition: util_ent_dtk.hpp:861
Dtk_mesh_face::get_nbtriangles
Dtk_Size_t get_nbtriangles() const
Get the number of simple triangles kept in the class instance.
Dtk_OneCell::GetBorderRightBlanked
Dtk_Int32 GetBorderRightBlanked()
Gets BorderRightBlanked of Right border.
Dtk_DumpXml_Dtk_RenderInfos
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RenderInfos(FILE *F, const Dtk_RenderInfosPtr &inRender)
Definition: util_xml_dtk.cpp:3608
Dtk_Roughness::ModeWithAngles
@ ModeWithAngles
Definition: util_draw_dtk.hpp:2730
Dtk_KinMechanism
Dtk_KinMechanism represents a kinematic mechanism.
Definition: util_kinematics_dtk.hpp:1614
Dtk_Text::GetOuterBoundingBox
const Dtk_Oriented2dBBox & GetOuterBoundingBox() const
Processes the outer bounding box.
DTK_TYPE_TABLE
@ DTK_TYPE_TABLE
Definition: define.h:489
Dtk_Leader::ArrowHead::GetDirections
void GetDirections(Dtk_dir &outRefDir, Dtk_dir &outAxisDir) const
Definition: util_draw_dtk.hpp:2168
Dtk_Roughness::ModeCircular
@ ModeCircular
Definition: util_draw_dtk.hpp:2724
DTK_FEAT_HOLE
@ DTK_FEAT_HOLE
Definition: str_feat_dtk.hpp:299
Dtk_API::GetRenderInfosInTable
Dtk_RenderInfosPtr GetRenderInfosInTable(Dtk_ID inId) const
Dtk_tab
This is a high level array class.
Definition: util_stl_dtk.hpp:85
Dtk_DumpXml_Dtk_ReferenceBlockPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceBlockPtr(FILE *F, const Dtk_ReferenceBlockPtr &D)
Definition: util_xml_dtk.cpp:2529
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.
DwgDtkReaderModule
@ DwgDtkReaderModule
Definition: dtk_maindoc.hpp:79
Dtk_tab::size
Dtk_Size_t size() const
Returns the size of the array.
Definition: util_stl_dtk.hpp:504
Dtk_DumpXml_Dtk_HyperbolaPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_HyperbolaPtr(FILE *F, const Dtk_HyperbolaPtr &inCurve)
Definition: util_xml_dtk.cpp:5033
Dtk_ToleranceSpecificationContainer::TypePerpendicularity
@ TypePerpendicularity
Definition: util_draw_dtk.hpp:6224
Dtk_API::GetNumRenderInfosInTable
Dtk_Size_t GetNumRenderInfosInTable() const
Dtk_DocElement::GetNumMetaData
Dtk_Size_t GetNumMetaData() const
Retrieves the number of the Dtk_MetaDataPtr - read only -.
Dtk_KinJoint::_JOINT1
Dtk_string _JOINT1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:961
dump_file
FILE * dump_file
Definition: util_xml_dtk.cpp:57
DTK_TYPE_ELLIPSE
@ DTK_TYPE_ELLIPSE
Definition: define.h:61
Dtk_Roughness::ModeRadial
@ ModeRadial
Definition: util_draw_dtk.hpp:2726
Dtk_KinJoint::getConstraintSize
Dtk_Size_t getConstraintSize()
Return the attribute tab size.
Dtk_DumpXml_Dtk_MetadataGroupPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataGroupPtr(FILE *F, const Dtk_MetaDataGroupPtr &inObject)
Definition: util_xml_dtk.cpp:4849
CgmReaderModule
@ CgmReaderModule
Definition: dtk_maindoc.hpp:69
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_DumpXml_Dtk_bool
Dtk_ErrorStatus Dtk_DumpXml_Dtk_bool(FILE *F, const Dtk_bool &B)
Definition: util_xml_dtk.cpp:1270
Dtk_Leader::TypeAngular
@ TypeAngular
Definition: util_draw_dtk.hpp:2226
FbxReaderModule
@ FbxReaderModule
Definition: dtk_maindoc.hpp:68
Dtk_NodeConnector::GetNodeId
Dtk_ID GetNodeId() const
Returns the Node id referenced by the connector.
SmgReaderModule
@ SmgReaderModule
Definition: dtk_maindoc.hpp:72
Dtk_DumpXml_Dtk_KinematicsConstraint
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsConstraint(FILE *inFile, const Dtk_KinConstraintPtr &inConstraint, Dtk_bool simplified)
Definition: util_xml_dtk.cpp:7155
IfcReaderModule
@ IfcReaderModule
Definition: dtk_maindoc.hpp:63
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:1513
Dtk_DumpXml_FormatDtk_string
Dtk_string Dtk_DumpXml_FormatDtk_string(const Dtk_string &inString, const XML_StringType inXmlStringType=XMLGenericString)
Definition: util_xml_dtk.cpp:4304
Dtk_DumpXml_Dtk_ViewPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewPtr(FILE *F, const Dtk_ViewPtr &V, const int &compact)
Definition: util_xml_dtk.cpp:2920
Dtk_DumpXml_FeatGeometry
Dtk_ErrorStatus Dtk_DumpXml_FeatGeometry(FILE *f, const Dtk_feat_geometry *inToWrite, const char *inName)
Definition: util_xml_dtk.cpp:7667
Dtk_KinJoint::getLowerLimit1
double getLowerLimit1()
Returns the lower limit 1.
Dtk_Component::PrototypeComponentType
@ PrototypeComponentType
Definition: dtk_maindoc.hpp:578
DTK_KIN_TYPE_COMMAND
@ DTK_KIN_TYPE_COMMAND
Definition: util_kinematics_dtk.hpp:110
Dtk_OneCell::getnbCells_Left_Right
Dtk_Int32 getnbCells_Left_Right() const
Gets the Dtk_OneCell nbCells_Left_Right.
Dtk_DumpXml_ConstraintTypeEnum
void Dtk_DumpXml_ConstraintTypeEnum(FILE *F, const Dtk_Constraint::ConstraintTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:8226
Dtk_RenderInfos::GetName
Dtk_string GetName() const
Returns the texture name.
XmtReaderModule
@ XmtReaderModule
Definition: dtk_maindoc.hpp:35
Dtk_DocElement::GetNumMetaDataGroup
Dtk_Size_t GetNumMetaDataGroup() const
Retrieves the number of the Dtk_MetaDataGroupPtr - read only -.
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:1536
Dtk_DumpXml_Dtk_MeshPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshPtr(FILE *F, const Dtk_MeshPtr &inMesh)
Definition: util_xml_dtk.cpp:6596
Dtk_string::len
int len() const
Retrieve the length of the Dtk_string.
Dtk_DumpXml_FeatPattern
Dtk_ErrorStatus Dtk_DumpXml_FeatPattern(FILE *f, const Dtk_feat_pattern *inToWrite)
Definition: util_xml_dtk.cpp:8007
DTK_ANCHOR_BOTTOM_RIGHT
@ DTK_ANCHOR_BOTTOM_RIGHT
Definition: util_draw_dtk.hpp:108
InvReaderModule
@ InvReaderModule
Definition: dtk_maindoc.hpp:32
Dtk_KinJoint::_LOWER_LIMIT1
Dtk_string _LOWER_LIMIT1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:943
Dtk_KinParameter::getName
Dtk_string getName()
Returns the parameter name.
FeaturesDumpFile
FILE * FeaturesDumpFile
Definition: util_xml_dtk.cpp:58
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:2337
Dtk_DumpXml_Dtk_PolylinePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PolylinePtr(FILE *F, const Dtk_PolylinePtr &inCurve)
Definition: util_xml_dtk.cpp:4965
Dtk_Info::GetCurveLineTypeDefinitionId
Dtk_ID GetCurveLineTypeDefinitionId() const
Retrieves the Id of Dtk_LineTypeDefinition of the entity in The Dtk_API table.
Dtk_KinJoint::getPart2
Dtk_KinPartPtr getPart2()
Returns the second part associated at the joint.
Dtk_DumpXml_Dtk_Text
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Text(FILE *F, const Dtk_Text &T)
Definition: util_xml_dtk.cpp:1216
Dtk_NodeConnector::SubEntity::GetSubEntityType
type_detk GetSubEntityType() const
Definition: dtk_maindoc.hpp:1223
DTK_ANCHOR_MIDDLE_RIGHT
@ DTK_ANCHOR_MIDDLE_RIGHT
Definition: util_draw_dtk.hpp:105
Dtk_Info::GetRenderInfosId
Dtk_ID GetRenderInfosId() const
Retrieves the Id of RenderInfos of the entity in The Dtk_API table.
dtkNoError
@ dtkNoError
Definition: error_dtk.hpp:144
Dtk_DumpXml_Dtk_ConstraintReferencePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConstraintReferencePtr(FILE *F, const Dtk_ConstraintReferencePtr &inVal)
Definition: util_xml_dtk.cpp:8277
JtReaderModule
@ JtReaderModule
Definition: dtk_maindoc.hpp:43
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:2671
Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration(FILE *inFile, const Dtk_KinSpeedAccelerationPtr &inSpeedAcceleration)
Definition: util_xml_dtk.cpp:6931
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_KinJoint::getLocalFrame2
Dtk_transfo getLocalFrame2()
Returns the local frame 2 value.
Dtk_KinJoint::getFixTogether
Dtk_KinConstraintPtr getFixTogether()
Returns the fix together constraint.
Dtk_DumpXml_Dtk_KinematicsCurve
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCurve(FILE *inFile, const Dtk_KinCurvePtr &inCurve)
Definition: util_xml_dtk.cpp:7096
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:67
DTK_TYPE_HYPERBOLA
@ DTK_TYPE_HYPERBOLA
Definition: define.h:62
Dtk_ToleranceSpecificationContainer::TypeAngularity
@ TypeAngularity
Definition: util_draw_dtk.hpp:6222
Dtk_RGB
Definition: dtk_rgb.hpp:7
DTK_WITHOUT_HIERARCHY
@ DTK_WITHOUT_HIERARCHY
Definition: util_draw_dtk.hpp:75
Dtk_Node::NodeHasSurfaces
Dtk_bool NodeHasSurfaces() const
Return DTK_TRUE if Dtk_Node Type Body contains surfacic entity.
GltfReaderModule
@ GltfReaderModule
Definition: dtk_maindoc.hpp:76
Dtk_Node::NodeHasMesh
Dtk_bool NodeHasMesh() const
Return DTK_TRUE if Dtk_Node Type Body or Mesh contains mesh entity.
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:479
Dtk_StandardTools::vsprintf_dtk
int vsprintf_dtk(char *Buffer, size_t BufferCount, const char *Format, va_list inArgList)
DTK_KIN_TYPE_MECHANISM
@ DTK_KIN_TYPE_MECHANISM
Definition: util_kinematics_dtk.hpp:111
DTK_TYPE_ROUGHNESS
@ DTK_TYPE_ROUGHNESS
Definition: define.h:443
DTK_KIN_TYPE_SPEED_ACCELERATION
@ DTK_KIN_TYPE_SPEED_ACCELERATION
Definition: util_kinematics_dtk.hpp:113
Dtk_dir
This is a mathematical direction class.
Definition: dtk_dir.hpp:15
dtkErrorOpenFiles
@ dtkErrorOpenFiles
Definition: error_dtk.hpp:138
Dtk_Node::GetNodeSubType
type_detk GetNodeSubType() const
Retrieves the Node SubType - if relevant - - read only -.
Dtk_DumpXml_Dtk_GridPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GridPtr(FILE *F, const Dtk_GridPtr &D)
Definition: util_xml_dtk.cpp:2355
Dtk_DumpXml_Dtk_CameraProjectionTypeEnum
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraProjectionTypeEnum(FILE *F, const Dtk_Camera::ProjectionTypeEnum &inVal)
Definition: util_xml_dtk.cpp:3104
Dtk_DocElement::GetPreview
Dtk_PreviewPtr GetPreview() const
Retrieves the Dtk_DocElement Dtk_PreviewPtr - read only -.
Dtk_DumpXml_Dtk_KinematicsNamedValue
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsNamedValue(FILE *inFile, const Dtk_KinNamedValuePtr &inNamedValue)
Definition: util_xml_dtk.cpp:6862
DTK_TYPE_WELDING
@ DTK_TYPE_WELDING
Definition: define.h:446
dtkErrorNullPointer
@ dtkErrorNullPointer
Definition: error_dtk.hpp:23
Dtk_DumpXml_Dtk_KinematicsJoint
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsJoint(FILE *inFile, const Dtk_KinJointPtr &inJoint, Dtk_bool simplified)
Definition: util_xml_dtk.cpp:7215
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
ProeReaderModule
@ ProeReaderModule
Definition: dtk_maindoc.hpp:41
Dtk_KinJoint::_LOCAL_FRAME4
Dtk_string _LOCAL_FRAME4
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:958
Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType(FILE *F, const Dtk_ToleranceSpecificationContainer::TypeEnum &D)
Definition: util_xml_dtk.cpp:2613
Dtk_DumpXml_Dtk_Constraint_ConstraintValue
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Constraint_ConstraintValue(FILE *F, const Dtk_Constraint::_ConstraintValue &inVal)
Definition: util_xml_dtk.cpp:8250
UgReaderModule
@ UgReaderModule
Definition: dtk_maindoc.hpp:34
Dtk_ToleranceSpecificationContainer::TypePosition
@ TypePosition
Definition: util_draw_dtk.hpp:6228
Dtk_DumpXml_Dtk_FdtPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtPtr(FILE *F, const Dtk_FdtPtr &D, const int &compact)
Definition: util_xml_dtk.cpp:3027
DwgReaderModule
@ DwgReaderModule
Definition: dtk_maindoc.hpp:61
Dtk_KinJoint::_UPPER_LIMIT2
Dtk_string _UPPER_LIMIT2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:946
Dtk_NodeConnector::GetAssociatedPathComponentID
const Dtk_tab< Dtk_ID > & GetAssociatedPathComponentID() const
Returns the Path Component ID referenced by the connector from Root to Target.
Dtk_DatumTarget::DatumTargetMovableStatusEnumToString
static Dtk_string DatumTargetMovableStatusEnumToString(const DatumTargetMovableStatusEnum &inEnum)
Definition: util_draw_dtk.hpp:3874
Dtk_ToleranceSpecificationContainer::TypeLineProfile
@ TypeLineProfile
Definition: util_draw_dtk.hpp:6218
Dtk_NodeConnector::SubEntity::GetSubEntityId
Dtk_ID GetSubEntityId() const
Definition: dtk_maindoc.hpp:1222