DATAKIT API  V2025.4
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_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_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 
92 {
93  XMLElement = 0,
94  XMLAttribute,
95  XMLGenericString
96 };

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 
)
685  {
686  Dtk_string EnumToStr = Dtk_Component::ComponentTypeEnumToString( inEnum );
687  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, inPropertyName, EnumToStr );
688  }

◆ Dtk_DumpXml_Drawing() [1/2]

Dtk_ErrorStatus Dtk_DumpXml_Drawing ( const Dtk_DrawingPtr &  )
4930  {
4931  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_DrawingPtr( dump_file, d, 0 );
4932  }

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

◆ Dtk_DumpXml_Dtk_anchor_type()

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

◆ Dtk_DumpXml_Dtk_AxisSystemPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_AxisSystemPtr ( FILE *  F,
const Dtk_AxisSystemPtr &  inVal 
)
3243  {
3244  fprintf( F, "<Dtk_AxisSystemPtr>\n" );
3245  if( inVal.IsNotNULL() )
3246  {
3247  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->get_info() );
3248 
3249 
3250  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"AxisName", inVal->GetName() );
3251  fprintf( F, "<IsDefault> %s </IsDefault>\n", inVal->IsDefault() ? "True" : "False" );
3252  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inVal->GetMatrix() );
3253  }
3254  else
3255  {
3256  fprintf( F, "Null" );
3257  }
3258  fprintf( F, "</Dtk_AxisSystemPtr>\n" );
3259 
3260  return dtkNoError;
3261  }

◆ Dtk_DumpXml_Dtk_BodyPtr()

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

◆ Dtk_DumpXml_Dtk_bool()

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

◆ Dtk_DumpXml_Dtk_CameraPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraPtr ( FILE *  F,
const Dtk_CameraPtr &  inVal 
)
3094  {
3095  fprintf( F, "<Dtk_Camera>\n" );
3096  if( inVal.IsNotNULL() )
3097  {
3098  //info
3099  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->info() );
3100  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inVal->OriginPoint(), "OriginPoint" );
3101  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inVal->TargetPoint(), "TargetPoint" );
3102  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inVal->UpVector(), "UpVector" );
3103  fprintf( F, "<Angle>%f</Angle>\n", inVal->Angle() );
3104  fprintf( F, "<Focus>%f</Focus>\n", inVal->Focus() );
3105  fprintf( F, "<ZoomFactor>%f</ZoomFactor>\n", inVal->ZoomFactor() );
3106  fprintf( F, "<ZoomFitMode>%i</ZoomFitMode>\n", inVal->GetZoomFitMode() );
3107 
3108  Dtk_Double64 front, back;
3109  inVal->GetClippingDistance( front, back );
3110  if( front != 0.0 || back != 0.0 )
3111  {
3112  fprintf( F, "<FrontClippingDistance>%f</FrontClippingDistance>\n", front );
3113  fprintf( F, "<BackClippingDistance>%f</BackClippingDistance>\n", back );
3114  }
3115 
3116 
3117  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CameraProjectionTypeEnum( F, inVal->ProjectionType() );
3118  }
3119  else
3120  {
3121  fprintf( F, "Null" );
3122  }
3123  fprintf( F, "</Dtk_Camera>\n" );
3124  return dtkNoError;
3125  }

◆ Dtk_DumpXml_Dtk_ColorInfosSetPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ColorInfosSetPtr ( FILE *  F,
const Dtk_ColorInfosSetPtr &  inVal 
)
3264  {
3265  fprintf( F, "<Dtk_ColorInfosSet>\n" );
3266  if( inVal.IsNotNULL() )
3267  {
3268  Dtk_Size_t i;
3269  Dtk_Size_t NumColors = inVal->GetNumColors();
3270  Dtk_Int32 DefaultColor;
3271 
3272  inVal->GetDefaultColor( DefaultColor );
3273  fprintf( F, "<Colors Num=\"" XmlFormat( "u" )"\" DefaultColor=\" %d\">\n", NumColors, DefaultColor );
3274  for( i = 0; i < NumColors; i++ )
3275  {
3276  Dtk_string ColorName;
3277  Dtk_ID ColorReadId;
3278  Dtk_RGB ColorDef;
3279  Dtk_ErrorStatus errd = inVal->GetColorDefinition( i, ColorDef );
3280  Dtk_ErrorStatus errn = inVal->GetColorName( i, ColorName );
3281  Dtk_ErrorStatus erri = inVal->GetColorID( i, ColorReadId );
3282  if( errn == dtkNoError && erri == dtkNoError )
3283  {
3284  ColorName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( ColorName, XMLGenericString );
3285  fprintf( F, "<__%d__ Name=\"%S\"", ColorReadId, ColorName.w_str() );
3286  }
3287  else
3288  {
3289  if( erri == dtkNoError )
3290  fprintf( F, "<__%d__ Name=\"\"", ColorReadId );
3291  else
3292  fprintf( F, "<__" XmlFormat( "u" )"__ Name=\"\"", i );
3293 
3294  }
3295  if( errd == dtkNoError )
3296  {
3297  //Dtk_DumpXml_Dtk_RGB(F, ColorDef);
3298  if( ColorDef.IndexReader() >= 0 )
3299  {
3300  fprintf( F, " RGBA=\"%d %d %d %d %d \" ", ColorDef[ 0 ], ColorDef[ 1 ], ColorDef[ 2 ], ColorDef[ 3 ], ColorDef.IndexReader() );
3301  }
3302  else
3303  {
3304  fprintf( F, " RGBA=\"%d %d %d %d\" ", ColorDef[ 0 ], ColorDef[ 1 ], ColorDef[ 2 ], ColorDef[ 3 ] );
3305  }
3306  }
3307  fprintf( F, "/>\n" );
3308  }
3309  fprintf( F, "</Colors>\n" );
3310  }
3311  else
3312  {
3313  fprintf( F, "Null" );
3314  }
3315  fprintf( F, "</Dtk_ColorInfosSet>\n" );
3316 
3317  return dtkNoError;
3318  }

◆ Dtk_DumpXml_Dtk_ComponentPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr ( FILE *  F,
const Dtk_ComponentPtr &  inObject 
)
4616  {
4617  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr_Init( F, inObject );
4618  Dtk_Size_t NumChildren = inObject->GetNumChildren();
4619  for( Dtk_Size_t i = 0; i < NumChildren; i++ )
4620  {
4621  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->GetChild( i ) );
4622  }
4623 
4624  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr_End( F );
4625  /*fprintf( F, "<Dtk_ComponentPtr>\n" );
4626  if( inObject.IsNotNULL() )
4627  {
4628  Dtk_Size_t i, NumChildren, NumFathers = inObject->GetNumFathers();
4629  Dtk_MaterialPtr mat = NULL;
4630  fprintf( F, "<ComponentID>%u</ComponentID>\n", inObject->GetID() );
4631  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4632  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4633  Dtk_ID readid;
4634  inObject->GetReadID( readid );
4635  if( readid > 0 )
4636  fprintf( F, "<ReadID>%d</ReadID>\n", readid );
4637  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FullPathName", inObject->FullPathName() );
4638  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"InstanceName", inObject->InstanceName() );
4639  if( inObject->GetFileVersion().icmp( L"" ) != 0 )
4640  {
4641  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FileVersion", inObject->GetFileVersion() );
4642  }
4643  fprintf( F, "<ComponentUnitScale>%f</ComponentUnitScale>\n", inObject->GetConceptionUnitScale() );
4644  for( i = 0; i < NumFathers; i++ )
4645  fprintf( F, "<FatherID>%u</FatherID>\n", inObject->GetFatherID( i ) );
4646  Dtk_DumpXMLNamespace::Dtk_DumpXml_DtkReaderType( F, inObject->GetAssociatedModuleType(), L"AssociatedModule" );
4647  Dtk_DumpXMLNamespace::Dtk_DumpXml_ComponentTypeEnum( F, inObject->ComponentType(), L"ComponentType" );
4648  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inObject->TransformationMatrix() );
4649  // mat = inObject->GetMaterial();
4650  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_material(F,mat);
4651 
4652 
4653  NumChildren = inObject->GetNumChildren();
4654  for( i = 0; i < NumChildren; i++ )
4655  {
4656  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->GetChild( i ) );
4657  }
4658 
4659  }
4660  else
4661  {
4662  fprintf( F, "'Null'" );
4663  }
4664  fprintf( F, "</Dtk_ComponentPtr>\n" );*/
4665  return dtkNoError;
4666  }

◆ Dtk_DumpXml_Dtk_ComponentPtr_End()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_End ( FILE *  F)
4764  {
4765  if( F == NULL )
4766  {
4767  return dtkErrorNullPointer;
4768  }
4769 
4770  fprintf( F, "</Dtk_ComponentPtr>\n" );
4771  return dtkNoError;
4772  }

◆ Dtk_DumpXml_Dtk_ComponentPtr_Init()

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

◆ Dtk_DumpXml_Dtk_ConstraintPtr()

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

◆ Dtk_DumpXml_Dtk_CurvePtr()

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

◆ Dtk_DumpXml_DTK_DATUM_COMPOSING_RULE()

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

◆ Dtk_DumpXml_Dtk_DatumTargetPtr()

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

◆ Dtk_DumpXml_Dtk_dir()

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

◆ Dtk_DumpXml_Dtk_DrawingPtr()

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

◆ Dtk_DumpXml_DTK_FDT_MODIFIER()

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

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

◆ Dtk_DumpXml_Dtk_FeaturePtr()

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

◆ Dtk_DumpXml_Dtk_GeometricalTolerancePtr()

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

◆ Dtk_DumpXml_Dtk_GraphicalDataPtr()

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

◆ Dtk_DumpXml_Dtk_GridPtr()

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

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

3965  {
3966  Dtk_status st;
3967  Dtk_MaterialPtr material = NULL;
3968 
3969  if( I.IsNULL() )
3970  return dtkNoError;
3971 
3972  Dtk_tab<Dtk_string> lst;
3973  I->ListAllAttributes( lst );
3974  Dtk_Size_t i;
3975  const Dtk_Size_t size = lst.size();
3976  {
3977  fprintf( F, "<Dtk_Info>\n" );
3978 
3979  fprintf( F, "<Dtk_ID>%i</Dtk_ID>\n", I->GetId() );
3980 
3981 #if 0 // dump Referenceset : (UG & JT)
3982  Dtk_tab<Dtk_string> array;
3983  I->GetReferenceSet( array, DTK_TRUE );
3984  if( array.size() > 0 )
3985  {
3986  fprintf(F, "<GetReferenceSet>\n");
3987  fprintf(F, "<size>%i</size>\n", array.size());
3988 
3989  for ( i = 0; i < array.size(); i++ )
3990  {
3991  fprintf(F, "%ls,", array[i].w_str());
3992  }
3993  fprintf(F, "</GetReferenceSet>\n");
3994  }
3995 #endif
3996 
3997  for( i = 0; i < size; i++ )
3998  {
3999  Dtk_Val v;
4000  if( lst[ i ] == "Dtk_Render" )
4001  {
4002  //int index = I->GetColorId();
4003  Dtk_RenderInfosPtr color = I->GetRenderInfos();
4004  //shader type
4005  Dtk_RenderInfos::RenderMappingShaderTypeEnum shadertype = Dtk_RenderInfos::Unknown;
4006  shadertype = color->GetShaderType();
4007  //
4008  const Dtk_string colorName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( color->GetName() );
4009  if( color->GetLightMap().IsNotNULL() )
4010  {
4011  if( shadertype != Dtk_RenderInfos::Unknown )
4012  {
4013  Dtk_RGB ambient = color->GetLightMap()->GetAmbientColor();
4014  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",
4015  I->GetRenderInfosId(), colorName.c_str(), shadertype, ambient[ 0 ], ambient[ 1 ], ambient[ 2 ], ambient[ 3 ] );
4016 
4017  }
4018  else
4019  {
4020  Dtk_RGB ambient = color->GetLightMap()->GetAmbientColor();
4021  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",
4022  I->GetRenderInfosId(), colorName.c_str(), ambient[ 0 ], ambient[ 1 ], ambient[ 2 ], ambient[ 3 ] );
4023  }
4024  }
4025  else
4026  {
4027  if( shadertype != Dtk_RenderInfos::Unknown )
4028  {
4029  fprintf( F, "<Dtk_Render><id>%d</id><name>%s</name><shadertype>%d</shadertype></Dtk_Render>\n",
4030  I->GetRenderInfosId(), colorName.c_str(), shadertype ); // render sans lightmap (texture possible)
4031  }
4032  else
4033  {
4034  fprintf( F, "<Dtk_Render><id>%d</id><name>%s</name></Dtk_Render>\n",
4035  I->GetRenderInfosId(), colorName.c_str() ); // render sans lightmap (texture possible)
4036  }
4037  }
4038  }
4039  else if( lst[ i ] == "Dtk_ColorId" )
4040  {
4041  //int index = I->GetColorId();
4042  Dtk_RGB color = I->GetColor();
4043  fprintf( F, "<Dtk_Color><r>%d</r><g>%d</g><b>%d</b><a>%d</a>", color[ 0 ], color[ 1 ], color[ 2 ], color[ 3 ] );
4044  if( color.IndexReader() >= 0 )
4045  {
4046  fprintf( F, "<IndexReader>%d</IndexReader>", color.IndexReader() );
4047  }
4048  fprintf( F, "</Dtk_Color>\n" );
4049 
4050 
4051 
4052  }
4053  else if( lst[ i ] == "Dtk_CurveThickNessInMM" )
4054  {
4055  double bval = I->GetCurveThickNessInMM();
4056  fprintf( F, "<Dtk_CurveThickNessInMM><double>%f</double></Dtk_CurveThickNessInMM>\n", bval );
4057  }
4065  else if( lst[ i ] == "Dtk_Uuid" )
4066  {
4067  Dtk_UUID uuid;
4068  uuid = I->GetUuid();
4069  fprintf( F, "<Dtk_uuid>\n" );
4070  for( Dtk_Size_t j = 0; j < 4; j++ )
4071  {
4072  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, uuid[ j ] );
4073  }
4074  fprintf( F, "</Dtk_uuid>\n" );
4075  }
4076  else if( lst[ i ] == "Dtk_CurveLineTypeDefinition" )
4077  {
4078  bool couldNotSpecialDump = true;
4079 
4080  const Dtk_ID curveLineDefinitionId = I->GetCurveLineTypeDefinitionId();
4081  const Dtk_API *const dtkAPI = Dtk_API::GetAPI();
4082  if( dtkAPI )
4083  {
4084  const Dtk_LineTypeDefinitionPtr &lineTypeDefinition = dtkAPI->GetCurveLineTypeDefinitionInTable( curveLineDefinitionId );
4085  if( lineTypeDefinition.IsNotNULL() )
4086  {
4087  const Dtk_string name = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lineTypeDefinition->GetName(), XMLGenericString );
4088  const Dtk_string dtkFontLineTypeEnum = Dtk_ConvertFontLineTypeEnumToString( lineTypeDefinition->GetClosestAppearanceInFontLineTypeEnumeration() );
4089  const Dtk_Size_t nbPatterns = lineTypeDefinition->GetPatternLength();
4090 
4091  const bool isNameNull = name.is_NULL();
4092 
4093  const Dtk_string xmlTitle = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lst[ i ], XMLElement );
4094  const Dtk_string printFDef = "<int>%d (=> Name: " +
4095  Dtk_string( isNameNull ? "(null)" : "&quot;%s&quot;" ) +
4096  " - ClosestDtk_FontLineType: &quot;%s&quot; - PatternLength: " XmlFormat( "u" ) ")</int> \n";
4097 
4098  fprintf( F, "<%s>\n", xmlTitle.c_str() );
4099  if( isNameNull )
4100  {
4101  fprintf( F,
4102  printFDef.c_str(),
4103  curveLineDefinitionId,
4104  dtkFontLineTypeEnum.c_str(),
4105  nbPatterns );
4106  }
4107  else
4108  {
4109  fprintf( F,
4110  printFDef.c_str(),
4111  curveLineDefinitionId,
4112  name.c_str(),
4113  dtkFontLineTypeEnum.c_str(),
4114  nbPatterns );
4115  }
4116  fprintf( F, "</%s>\n", xmlTitle.c_str() );
4117 
4118  couldNotSpecialDump = false;
4119  }
4120  }
4121 
4122  // If could not dump correctly, use usual dump (Should not happen).
4123  if( couldNotSpecialDump )
4124  {
4125  I->FindAttribute( lst[ i ], v );
4126  Dtk_string title = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lst[ i ], XMLElement );
4127 
4128  fprintf( F, "<%s>\n", title.c_str() );
4129  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, v );
4130  fprintf( F, "</%s>\n", title.c_str() );
4131  }
4132  }
4133  else
4134  {
4135  I->FindAttribute( lst[ i ], v );
4136  Dtk_string title = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( lst[ i ], XMLElement );
4137 
4138  fprintf( F, "<%s>\n", title.c_str() );
4139  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_val( F, v );
4140  fprintf( F, "</%s>\n", title.c_str() );
4141  }
4142  }
4143 
4144  //Usefull if you want to handle NX referenceSet
4145  /*
4146  Dtk_tab <Dtk_string> refset;
4147  I->GetReferenceSet(refset,DTK_TRUE);
4148  for (i = 0; i < refset.size(); i++)
4149  fprintf(F, "<Dtk_ReferenceSet_%u>%S</Dtk_ReferenceSet_%u>\n", i, refset[i].w_str(), i);
4150  */
4151 
4152  fprintf( F, "</Dtk_Info>\n" );
4153  }
4154 
4155  return dtkNoError;
4156  }

◆ Dtk_DumpXml_Dtk_KinematicsCommand()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCommand ( FILE *  inFile,
const Dtk_KinCommandPtr &  inCommand,
Dtk_bool  simplified 
)
7354  {
7355  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7356  if( inFile == NULL )
7357  return dtkErrorNullPointer;
7358 
7359  fprintf( inFile, "<command name=\"%s\" id=\"%d\">\n", inCommand->getName().c_str(), inCommand->getId() );
7360  if( simplified == DTK_FALSE )
7361  {
7362  fprintf( inFile, "<attributCommand type=\"%d\" value=\"%f\"/>\n", inCommand->getType(), inCommand->getValue() );
7363  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, inCommand->getJoint(), DTK_TRUE );
7364  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inCommand->getParameter() );
7365  }
7366  fprintf( inFile, "</command>\n" );
7367 
7368  return dtkErrorStatus;
7369  }

◆ Dtk_DumpXml_Dtk_KinematicsConstraint()

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

◆ Dtk_DumpXml_Dtk_KinematicsCurve()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCurve ( FILE *  inFile,
const Dtk_KinCurvePtr &  inCurve 
)
7087  {
7088  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7089  if( inFile == NULL )
7090  return dtkErrorNullPointer;
7091 
7092  fprintf( inFile, "<curve fileName=\"%s\" idBlock=\"%d\"/>\n", inCurve->getFileName().c_str(), inCurve->getIdBlock() );
7093 
7094  return dtkErrorStatus;
7095  }

◆ Dtk_DumpXml_Dtk_KinematicsFixPart()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFixPart ( FILE *  inFile,
const Dtk_KinFixPartPtr &  inFixPart 
)
7372  {
7373  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7374  if( inFile == NULL )
7375  return dtkErrorNullPointer;
7376 
7377  fprintf( inFile, "<fixPart name=\"%s\" id=\"%d\">\n", inFixPart->getName().c_str(), inFixPart->getId() );
7378  if( inFixPart->getConstraint().IsNotNULL() )
7379  {
7380  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, inFixPart->getConstraint(), DTK_TRUE );
7381  }
7382  if( inFixPart->getPart().IsNotNULL() )
7383  {
7384  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inFixPart->getPart() );
7385  }
7386  fprintf( inFile, "</fixPart>\n" );
7387 
7388  return dtkErrorStatus;
7389  }

◆ Dtk_DumpXml_Dtk_KinematicsFormula()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFormula ( FILE *  inFile,
const Dtk_KinFormulaPtr &  inFormula 
)
7098  {
7099  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7100  if( inFile == NULL )
7101  return dtkErrorNullPointer;
7102 
7103  fprintf( inFile, "<formula name=\"%s\" id=\"%d\">\n", inFormula->getName().c_str(), inFormula->getId() );
7104  fprintf( inFile, "<attributFormula" );
7105  fprintf( inFile, " comment=\"%s\"", inFormula->getComment().c_str() );
7106  fprintf( inFile, " formula=\"%s\"", inFormula->getFormula().c_str() );
7107  fprintf( inFile, " parameter=\"%s\"/>\n", inFormula->getParam().c_str() );
7108  fprintf( inFile, "</formula>\n" );
7109 
7110  return dtkErrorStatus;
7111  }

◆ Dtk_DumpXml_Dtk_KinematicsJoint()

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

◆ Dtk_DumpXml_Dtk_KinematicsLaw()

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

◆ Dtk_DumpXml_Dtk_KinematicsMechanism()

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

◆ Dtk_DumpXml_Dtk_KinematicsNamedValue()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsNamedValue ( FILE *  inFile,
const Dtk_KinNamedValuePtr &  inNamedValue 
)
6853  {
6854  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
6855  if( inFile == NULL )
6856  return dtkErrorNullPointer;
6857 
6858  fprintf( inFile, "<namedValue name=\"%s\" value=\"%f\"/>\n", inNamedValue->getName().c_str(), inNamedValue->getValue() );
6859  return dtkErrorStatus;
6860  }

◆ Dtk_DumpXml_Dtk_KinematicsParameter()

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

◆ Dtk_DumpXml_Dtk_KinematicsProduct()

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

◆ Dtk_DumpXml_Dtk_KinematicsPtr()

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

◆ Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration()

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

◆ Dtk_DumpXml_Dtk_LayerInfosSetPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_LayerInfosSetPtr ( FILE *  F,
const Dtk_LayerInfosSetPtr &  inVal 
)
3323  {
3324  fprintf( F, "<Dtk_LayerInfosSet>\n" );
3325  if( inVal.IsNotNULL() )
3326  {
3327  Dtk_Size_t LayerIdx;
3328  Dtk_Size_t NumLayers = inVal->GetNumLayers();
3329  Dtk_Size_t DefaultLayer;
3330 
3331  inVal->GetDefaultLayer( DefaultLayer );
3332  fprintf( F, "<Layers Num=\"" XmlFormat( "u" )"\" DefaultLayer=\"" XmlFormat( "d" )"\">\n", NumLayers, DefaultLayer );
3333  for( LayerIdx = 0; LayerIdx < NumLayers; LayerIdx++ )
3334  {
3335  Dtk_string LayerName;
3336  Dtk_ID LayerId;
3337  Dtk_ErrorStatus errn = inVal->GetLayerName( LayerIdx, LayerName );
3338  Dtk_ErrorStatus erri = inVal->GetLayerID( LayerIdx, LayerId );
3339  if( errn == dtkNoError && erri == dtkNoError )
3340  {
3341  LayerName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( LayerName, XMLGenericString );
3342  fprintf( F, "<__" XmlFormat( "u" ) "__ ID= \"%d\" Name=\"%S\"/>\n", LayerIdx, LayerId ,LayerName.w_str() );
3343  }
3344  else
3345  {
3346  if( erri == dtkNoError )
3347  fprintf( F, "<__%d__ Name=\"\"/>\n", LayerId );
3348  else
3349  fprintf( F, "<__" XmlFormat( "u" )"__ Name=\"\"/>\n", LayerIdx );
3350 
3351  }
3352  }
3353  fprintf( F, "</Layers>\n" );
3354 
3355  Dtk_Size_t LayerFiltersIdx;
3356  Dtk_Size_t NumLayersFilters = inVal->GetNumLayerFilters();
3357  Dtk_Size_t DefaultLayerFilter; inVal->GetDefaultLayerFilter( DefaultLayerFilter );
3358  Dtk_LayerFilterInfosPtr CurrentLayerFilterInfo = inVal->GetLayerFilterByPos( DefaultLayerFilter );
3359  Dtk_string CurrentLayerFilterName = L"None";
3360  if( CurrentLayerFilterInfo.IsNotNULL() )
3361  {
3362  Dtk_string LayerFilterName;
3363  CurrentLayerFilterInfo->GetName( LayerFilterName );
3364  CurrentLayerFilterName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( LayerFilterName, XMLGenericString );
3365  }
3366  fprintf( F, "<LayerFilters Num=\"" XmlFormat( "u" )"\" DefaultLayerFilter=\"%s\">\n", NumLayersFilters, CurrentLayerFilterName.c_str() );
3367  for( LayerFiltersIdx = 0; LayerFiltersIdx < NumLayersFilters; LayerFiltersIdx++ )
3368  {
3369  Dtk_LayerFilterInfosPtr TmpLayerFilterInfo = inVal->GetLayerFilterByPos( LayerFiltersIdx );
3370  if( TmpLayerFilterInfo.IsNotNULL() )
3371  {
3372  Dtk_string LayerFilterName, LayerFilterDescription;
3373  Dtk_tab< Dtk_Size_t > SelectedLayers;
3374  TmpLayerFilterInfo->GetName( LayerFilterName );
3375  LayerFilterName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( LayerFilterName, XMLGenericString );
3376  TmpLayerFilterInfo->GetDescription( LayerFilterDescription );
3377  TmpLayerFilterInfo->GetSelectedLayers( SelectedLayers );
3378  Dtk_Size_t SelectedLayersIdx, NumSelectedLayers = SelectedLayers.size();
3379 
3380  fprintf( F, "<LayerFilterInfo Name=\"%S\">\n", LayerFilterName.w_str() );
3381  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Description", LayerFilterDescription );
3382  fprintf( F, "<SelectedLayers Num=\"" XmlFormat( "u" )"\">\n", NumSelectedLayers );
3383  for( SelectedLayersIdx = 0; SelectedLayersIdx < NumSelectedLayers; SelectedLayersIdx++ )
3384  {
3385  fprintf( F, "<__" XmlFormat( "u" )"__/>\n", SelectedLayers[ SelectedLayersIdx ] );
3386  }
3387  fprintf( F, "</SelectedLayers>\n" );
3388  fprintf( F, "</LayerFilterInfo>\n" );
3389  }
3390  }
3391  fprintf( F, "</LayerFilters>\n" );
3392  }
3393  else
3394  {
3395  fprintf( F, "Null" );
3396  }
3397  fprintf( F, "</Dtk_LayerInfosSet>\n" );
3398 
3399  return dtkNoError;
3400  }

◆ Dtk_DumpXml_Dtk_LeaderPtr()

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

◆ Dtk_DumpXml_Dtk_MainDocPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr ( FILE *  F,
const Dtk_MainDocPtr &  inObject 
)
4398  {
4399  fprintf( F, "<Dtk_MainDocPtr>\n" );
4400  if( inObject.IsNotNULL() )
4401  {
4402  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->RootComponent() );
4403  }
4404  else
4405  {
4406  fprintf( F, "Null" );
4407  }
4408  fprintf( F, "</Dtk_MainDocPtr>\n" );
4409  return dtkNoError;
4410  }

◆ Dtk_DumpXml_Dtk_MeshPtr()

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

◆ Dtk_DumpXml_Dtk_MetadataGroupPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataGroupPtr ( FILE *  F,
const Dtk_MetaDataGroupPtr &  inObject 
)
4840  {
4841  if( F == NULL )
4842  {
4843  return dtkErrorOpenFiles;
4844  }
4845 
4846 
4847  fprintf( F, "<Dtk_MetaDataGroupPtr>\n" );
4848 
4849  if( inObject.IsNULL() )
4850  {
4851  fprintf( F, "'Null'" );
4852  fprintf( F, "</Dtk_MetaDataGroupPtr>\n" );
4853  return dtkNoError;
4854  }
4855 
4856  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"GroupName", inObject->GetGroupName() );
4857 
4858  Dtk_tab<Dtk_MetaDataPtr> list_metadata = inObject->GetListOfMetadatas();
4859 
4860  Dtk_Size_t size = list_metadata.size();
4861 
4862  for( Dtk_Size_t i = 0; i < size; ++i )
4863  {
4864  Dtk_DumpXml_Dtk_MetadataPtr( F, list_metadata[ i ] );
4865  }
4866 
4867  fprintf( F, "</Dtk_MetaDataGroupPtr>\n" );
4868 
4869  return dtkNoError;
4870  }

◆ Dtk_DumpXml_Dtk_MetadataPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataPtr ( FILE *  F,
const Dtk_MetaDataPtr &  inObject 
)
4777  {
4778  if( F == NULL )
4779  {
4780  return dtkErrorOpenFiles;
4781  }
4782 
4783  fprintf( F, "<Dtk_MetaDataPtr>\n" );
4784  if( inObject.IsNotNULL() )
4785  {
4786  Dtk_string outFormula;
4787  Dtk_string outEstimatedValue;
4788  Dtk_string outTitle;
4789  Dtk_string outResultType;
4790 
4791  Dtk_MetaData::MetaDataTypeEnum MetaDataType = inObject->MetaDataType();
4792  Dtk_DumpXMLNamespace::Dtk_DumpXml_MetaDataTypeEnum( F, MetaDataType, L"MetaDataType" );
4793  if( inObject->GetFormula( outFormula, outEstimatedValue, outTitle, outResultType ) == dtkNoError )
4794  {
4795  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Formula", outFormula );
4796  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"EstimatedValue", outEstimatedValue );
4797  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", outTitle );
4798  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"ResultType", outResultType );
4799  }
4800  else
4801  {
4802  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", inObject->GetTitle() );
4803 
4804  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Type", inObject->GetType() );
4805  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Value", inObject->GetValue() );
4806 
4807  Dtk_string unit;
4808  Dtk_ErrorStatus err = inObject->GetUnits( unit );
4809  if( err == dtkNoError )
4810  {
4811  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Units", unit );
4812  }
4813  if( inObject->GetCategory().len() > 0 )
4814  {
4815  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Category", inObject->GetCategory() );
4816  }
4817  //if (inObject->IsTime_t())
4818  //{
4819  // Dtk_string val = inObject->GetValue();
4820  // int timeint = atoi(val.c_str());
4821  // time_t time;
4822  // time = (time_t)timeint;
4823  // char buffer[100];
4824  // memset(buffer, 0, sizeof(buffer));
4825  // ctime_s(buffer, 100, &time);
4826  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Value(F, L"TIME_T", Dtk_string(buffer));
4827 
4828  //}
4829  }
4830  }
4831  else
4832  {
4833  fprintf( F, "'Null'" );
4834  }
4835  fprintf( F, "</Dtk_MetaDataPtr>\n" );
4836  return dtkNoError;
4837  }

◆ Dtk_DumpXml_Dtk_ModelDisplayPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ModelDisplayPtr ( FILE *  F,
const Dtk_ModelDisplayPtr &  inVal 
)
3127  {
3128  fprintf( F, "<Dtk_ModelDisplay>\n" );
3129  if( inVal.IsNotNULL() )
3130  {
3131  fprintf( F, "<IsActivated>%s</IsActivated>\n", inVal->IsActivated() == DTK_TRUE ? "True" : "False" );
3132  if( inVal->GetIsStandardView() )
3133  {
3134  fprintf( F, "<StandardView>True</StandardView>\n" );
3135  } //info
3136  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->info() );
3137  //Camera
3138  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_CameraPtr( F, inVal->GetCamera() );
3139  //Clipping Plane
3140  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EntityPtr( F, inVal->GetClippingEntity() );
3141 
3142  Dtk_ModelDisplay::RenderingModeEnum renderingmode = inVal->GetRenderingMode();
3143 
3144  switch( renderingmode )
3145  {
3146  case Dtk_ModelDisplay::rendering_mode_shaded_only:
3147  {
3148  fprintf( F, "<RenderingModeEnum>rendering_mode_shaded_only</RenderingModeEnum>\n" );
3149  break;
3150  }
3151  case Dtk_ModelDisplay::rendering_mode_shaded_with_visible_edges:
3152  {
3153  fprintf( F, "<RenderingModeEnum>rendering_mode_shaded_with_visible_edges</RenderingModeEnum>\n" );
3154  break;
3155  }
3156  case Dtk_ModelDisplay::rendering_mode_studio:
3157  {
3158  fprintf( F, "<RenderingModeEnum>rendering_mode_studio</RenderingModeEnum>\n" );
3159  break;
3160  }
3161  case Dtk_ModelDisplay::rendering_mode_wireframe_with_all_edges:
3162  {
3163  fprintf( F, "<RenderingModeEnum>rendering_mode_wireframe_with_all_edges</RenderingModeEnum>\n" );
3164  break;
3165  }
3166  case Dtk_ModelDisplay::rendering_mode_wireframe_with_only_visible_edges:
3167  {
3168  fprintf( F, "<RenderingModeEnum>rendering_mode_wireframe_with_only_visible_edges</RenderingModeEnum>\n" );
3169  break;
3170  }
3171  case Dtk_ModelDisplay::rendering_mode_static_wireframe:
3172  {
3173  fprintf( F, "<RenderingModeEnum>rendering_mode_static_wireframe</RenderingModeEnum>\n" );
3174  break;
3175  }
3176  case Dtk_ModelDisplay::rendering_mode_wireframe_face_analysis:
3177  {
3178  fprintf( F, "<RenderingModeEnum>rendering_mode_wireframe_face_analysis</RenderingModeEnum>\n" );
3179  break;
3180  }
3181  case Dtk_ModelDisplay::rendering_mode_wireframe_partially_shade:
3182  {
3183  fprintf( F, "<RenderingModeEnum>rendering_mode_wireframe_partially_shade</RenderingModeEnum>\n" );
3184  break;
3185  }
3186  default:
3187  break;
3188  }
3189 
3190 
3191  Dtk_ModelDisplay::SectionTypeEnum SectionType;
3192  Dtk_Int32 IsLocked = DTK_FALSE;
3193  Dtk_Double64 Thickness = 0.0;
3194 
3195  inVal->GetSectionInformation( SectionType, IsLocked, Thickness );
3196  if( SectionType != Dtk_ModelDisplay::SectionPlane )
3197  {
3198  if( SectionType == Dtk_ModelDisplay::SectionParallelePlane )
3199  {
3200  fprintf( F, "<SectionType>SectionParallelePlane</SectionType>\n" );
3201  fprintf( F, "<Thickness>%f</Thickness>\n", Thickness );
3202  }
3203  else
3204  {
3205  if( SectionType == Dtk_ModelDisplay::SectionBox )
3206  {
3207  fprintf( F, "<SectionType>SectionBox</SectionType>\n" );
3208  }
3209  else
3210  {
3211  if( SectionType == Dtk_ModelDisplay::SectionBody )
3212  {
3213  fprintf( F, "<SectionType>SectionBody</SectionType>\n" );
3214  }
3215  }
3216  }
3217  }
3218  Dtk_tab<Dtk_Int32> VisibleLayers;
3219  inVal->GetVisibleLayers( VisibleLayers );
3220  if( VisibleLayers.size() > 0 )
3221  {
3222  fprintf( F, "<VisibleLayers>\n" );
3223 
3224  for( Dtk_Size_t i = 0; i < VisibleLayers.size(); i++ )
3225  {
3226  if( VisibleLayers[ i ] == 1 )
3227  {
3228  fprintf( F, "\"" XmlFormat( "u" )"\",\n", i );
3229  }
3230  }
3231  fprintf( F, "</VisibleLayers>\n" );
3232  }
3233  }
3234  else
3235  {
3236  fprintf( F, "Null" );
3237  }
3238  fprintf( F, "</Dtk_ModelDisplay>\n" );
3239  return dtkNoError;
3240  }

◆ Dtk_DumpXml_Dtk_NodeConnector()

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

◆ Dtk_DumpXml_Dtk_NodePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr ( FILE *  F,
const Dtk_NodePtr &  inObject 
)
4414  {
4415 
4416  fprintf( F, "<Dtk_NodePtr>\n" );
4417  if( inObject.IsNotNULL() )
4418  {
4419  Dtk_Node::NodeDataTypeEnum NodeType = inObject->GetNodeType();
4420  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4421  Dtk_DumpXMLNamespace::Dtk_DumpXml_NodeTypeEnum( F, NodeType, L"NodeType" );
4422  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"NodeSubType", typedetkToDtk_string( inObject->GetNodeSubType() ) );
4423 
4424  fprintf( F, "<NodeID>%u</NodeID>\n", inObject->GetID() );
4425  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4426  Dtk_StoredInfoPtr sti = inObject->GetStoredInfos();
4427  if( sti.IsNotNULL() )
4428  {
4429  fprintf( F, "<StoredInfos>\n" );
4430  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, Dtk_InfoPtr::DtkDynamicCast( sti ) );
4431  fprintf( F, "</StoredInfos>\n" );
4432  }
4433 
4434  Dtk_Size_t i, NumChildren;
4435  NumChildren = inObject->GetNumChildren();
4436 
4437  for( i = 0; i < NumChildren; i++ )
4438  {
4439  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NodePtr( F, inObject->GetChild( i ) );
4440  }
4441  Dtk_Size_t NumMetaData;
4442  NumMetaData = inObject->GetNumMetaData();
4443  if( NumMetaData )
4444  {
4445  fprintf( F, "<Dtk_MetaData Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaData );
4446  for( i = 0; i < NumMetaData; i++ )
4447  {
4448  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr( F, inObject->GetMetaData( i ) );
4449  }
4450  fprintf( F, "</Dtk_MetaData>\n" );
4451 
4452  }
4453 #ifdef XML_GROUP_METADATA
4454  Dtk_Size_t NumMetaDataGroup;
4455  NumMetaDataGroup = inObject->GetNumMetaDataGroup();
4456  if( NumMetaDataGroup )
4457  {
4458  fprintf( F, "<Dtk_MetaDataGroup Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaDataGroup );
4459  for( i = 0; i < NumMetaDataGroup; i++ )
4460  {
4461  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataGroupPtr( F, inObject->GetMetaDataGroup( i ) );
4462  }
4463  fprintf( F, "</Dtk_MetaDataGroup>\n" );
4464  }
4465 #endif
4466  Dtk_tab< Dtk_NodeConnectorPtr > AssociatedEntities;
4467  inObject->GetAssociatedEntities( AssociatedEntities );
4468  Dtk_Size_t NumConnector = AssociatedEntities.size();
4469  if( NumConnector )
4470  {
4471  fprintf( F, "<NodeConnectors Num=\'" XmlFormat( "u" ) "\'>\n", NumConnector );
4472 
4473  for( i = 0; i < NumConnector; i++ )
4474  {
4475  Dtk_DumpXml_Dtk_NodeConnector( F, AssociatedEntities[ i ] );
4476  }
4477  fprintf( F, "</NodeConnectors>\n" );
4478 
4479  }
4480  }
4481  else
4482  {
4483  fprintf( F, "<Null></Null>\n" );
4484  }
4485  fprintf( F, "</Dtk_NodePtr>\n" );
4486  return dtkNoError;
4487  }

◆ Dtk_DumpXml_Dtk_NodePtr_End()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr_End ( FILE *  F)
4587  {
4588  if( F == NULL )
4589  {
4590  return dtkErrorNullPointer;
4591  }
4592  fprintf( F, "</Dtk_NodePtr>\n" );
4593  return dtkNoError;
4594  }

◆ Dtk_DumpXml_Dtk_NodePtr_Init()

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

◆ Dtk_DumpXml_Dtk_OLEObjectPtr()

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

◆ Dtk_DumpXml_Dtk_OneCell()

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

◆ Dtk_DumpXml_Dtk_PlaneSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_PlaneSurfacePtr ( FILE *  F,
const Dtk_PlaneSurfacePtr &  inSurf 
)
5927  {
5928  fprintf( F, "<Dtk_PlaneSurfacePtr>" );
5929 
5930  if( inSurf.IsNotNULL() )
5931  {
5932  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inSurf->GetOrigin(), "Origin" );
5933  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetNormal(), "Normal" );
5934  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetUDirection(), "UDir" );
5935  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetVDirection(), "VDir" );
5936  }
5937  else
5938  {
5939  fprintf( F, "Null" );
5940  }
5941 
5942  fprintf( F, "</Dtk_PlaneSurfacePtr>" );
5943  return dtkNoError;
5944  }

◆ Dtk_DumpXml_Dtk_pnt()

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

◆ Dtk_DumpXml_Dtk_ReferenceBlockPtr()

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

◆ Dtk_DumpXml_Dtk_ReferenceFramePtr()

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

◆ Dtk_DumpXml_Dtk_roughness_obtention_type()

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

◆ Dtk_DumpXml_Dtk_roughness_rough_mode()

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

◆ Dtk_DumpXml_Dtk_roughness_roughness_applyto()

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

◆ Dtk_DumpXml_Dtk_RoughnessPtr()

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

◆ Dtk_DumpXml_Dtk_SelectionDataSet()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_SelectionDataSet ( FILE *  F,
const Dtk_GlobalDataSetPtr &  ptrGlobalDataSet 
)
6814  {
6815  if( F == NULL )
6816  {
6817  return dtkErrorNullPointer;
6818  }
6819  Dtk_Size_t i = 0;
6820 
6821  //Dtk_GlobalDataSetPtr ptrGlobalDataSet = inObject->GetGlobalDataSet();
6822  if( ptrGlobalDataSet.IsNotNULL() )
6823  {
6824  Dtk_SelectionDataSetPtr ptrSelectionDataSet = ptrGlobalDataSet->GetSelectionDataSet();
6825  if( ptrSelectionDataSet.IsNULL() )
6826  {
6827  return dtkErrorNullPointer;
6828  }
6829  Dtk_Size_t ptrSelectionDataSetNb = ptrSelectionDataSet->GetNumSelectionSets();
6830  if( ptrSelectionDataSetNb > 0 )
6831  {
6832  fprintf( F, "<Dtk_SelectionDataSet>\n" );
6833  }
6834  for( i = 0; i < ptrSelectionDataSetNb; i++ )
6835  {
6836  Dtk_SelectionSetPtr curSelectionSet = ptrSelectionDataSet->GetSelectionSetByPos( i );
6837  if( curSelectionSet.IsNotNULL() )
6838  Dtk_DumpXml_Dtk_SelectionSet( F, curSelectionSet );
6839  }
6840  if( ptrSelectionDataSetNb > 0 )
6841  {
6842  fprintf( F, "</Dtk_SelectionDataSet>\n" );
6843  }
6844  }
6845 
6846  return dtkNoError;
6847  }

◆ Dtk_DumpXml_Dtk_StreamPtr()

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

◆ Dtk_DumpXml_Dtk_TablePtr()

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

◆ Dtk_DumpXml_Dtk_Text()

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

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr()

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

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType()

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

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationPtr()

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

◆ Dtk_DumpXml_Dtk_transfo()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_transfo ( FILE *  F,
const Dtk_transfo &  V 
)
4173  {
4174  fprintf( F, "<Transfo_matrix>\n" );
4175  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getXdir(), "X" );
4176  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getYdir(), "Y" );
4177  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getZdir(), "Z" );
4178  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, T.getOrigin(), "Origin" );
4179  fprintf( F, "<Scale>%f</Scale>\n", T.getScale() );
4180  fprintf( F, "</Transfo_matrix>\n" );
4181  return dtkNoError;
4182  }

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

◆ Dtk_DumpXml_End() [1/2]

Dtk_ErrorStatus Dtk_DumpXml_End ( )
4894  {
4895  if( dump_file == NULL )
4896  return dtkErrorUnspecified;
4897  fprintf( dump_file, "</root>\n" );
4898  fclose( dump_file );
4899  return dtkNoError;
4900  }

◆ Dtk_DumpXml_End() [2/2]

Dtk_ErrorStatus Dtk_DumpXml_End ( FILE *  F)
4902  {
4903  if( F == NULL )
4904  return dtkErrorUnspecified;
4905  fprintf( F, "</root>\n" );
4906  fclose( F );
4907  return dtkNoError;
4908  }

◆ Dtk_DumpXml_Fdt()

Dtk_ErrorStatus Dtk_DumpXml_Fdt ( const Dtk_FdtPtr &  D)
4876  {
4877  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FdtPtr( dump_file, D, 0 );
4878  }

◆ Dtk_DumpXml_FormatDtk_string()

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

◆ Dtk_DumpXml_GetFeaturesDumpFile()

FILE* Dtk_DumpXml_GetFeaturesDumpFile ( )
4915  {
4916  return FeaturesDumpFile;
4917  }

◆ Dtk_DumpXml_GetFile()

FILE* Dtk_DumpXml_GetFile ( )
4910  {
4911  return dump_file;
4912  }

◆ Dtk_DumpXml_GetParametersDumpFile()

FILE* Dtk_DumpXml_GetParametersDumpFile ( )

◆ Dtk_DumpXml_Init()

Dtk_ErrorStatus Dtk_DumpXml_Init ( const Dtk_string &  xml_file)
4881  {
4882  Dtk_string xmlFileOut;
4883 
4884  xmlFileOut = xml_file;
4885 
4886  dump_file = xmlFileOut.OpenFile( DTK_W );
4887  if( dump_file == NULL )
4888  return dtkErrorUnspecified;
4889  // dump_file = fopen(xml_file.c_str(),"w");
4890  fprintf( dump_file, "<root>\n" );
4891  return dtkNoError;
4892  }

◆ Dtk_DumpXml_LineTypeDefinitionTable()

Dtk_ErrorStatus Dtk_DumpXml_LineTypeDefinitionTable ( FILE *  F)
3935  {
3936  Dtk_ErrorStatus outDtkStatus = dtkNoError;
3937 
3938  const Dtk_API *const api = Dtk_API::GetAPI();
3939  if( api )
3940  {
3941  const Dtk_Size_t nbDefinitions = api->GetNumCurveLineTypeDefinitionsInTable();
3942 
3943  if( nbDefinitions > 0 )
3944  {
3945  fprintf( F, "<LineTypeDefinitionTable>\n" );
3946 
3947  for( Dtk_Size_t i_def = 1; i_def <= nbDefinitions; ++i_def )
3948  {
3949  Dtk_DumpXml_Dtk_LineTypeDefinitionPtr( F,
3950  api->GetCurveLineTypeDefinitionInTable( ( Dtk_ID )i_def ) );
3951  }
3952 
3953  fprintf( F, "</LineTypeDefinitionTable>\n" );
3954  }
3955  }
3956  else
3957  {
3958  outDtkStatus = dtkErrorNullPointer;
3959  }
3960 
3961  return outDtkStatus;
3962  }

◆ Dtk_DumpXml_PhysicalMaterialInfosTable()

Dtk_ErrorStatus Dtk_DumpXml_PhysicalMaterialInfosTable ( FILE *  F)
3852  {
3853  Dtk_API *api = Dtk_API::GetAPI();
3854  Dtk_ID i, nb = ( Dtk_ID )api->GetNumPhysicalMaterialInfosInTable();
3855  if( nb )
3856  fprintf( F, "<PhysicalMaterialInfosTable>\n" );
3857  for( i = 0; i < nb; i++ )
3858  {
3859  Dtk_PhysicalMaterialInfosPtr mat = api->GetPhysicalMaterialInfosInTable( i + 1 );
3860  Dtk_DumpXml_Dtk_PhysicalMaterialInfos( F, mat );
3861  }
3862  if( nb )
3863  fprintf( F, "</PhysicalMaterialInfosTable>\n" );
3864 
3865  return dtkNoError;
3866  }

◆ Dtk_DumpXml_RenderInfosTable()

Dtk_ErrorStatus Dtk_DumpXml_RenderInfosTable ( FILE *  F)
3835  {
3836  Dtk_API *api = Dtk_API::GetAPI();
3837  Dtk_ID i, nb = ( Dtk_ID )api->GetNumRenderInfosInTable();
3838  if( nb )
3839  fprintf( F, "<RenderInfosTable>\n" );
3840  for( i = 0; i < nb; i++ )
3841  {
3842  Dtk_RenderInfosPtr mat = api->GetRenderInfosInTable( i + 1 );
3843  Dtk_DumpXml_Dtk_RenderInfos( F, mat );
3844  }
3845  if( nb )
3846  fprintf( F, "</RenderInfosTable>\n" );
3847 
3848  return dtkNoError;
3849  }

◆ Dtk_DumpXml_Value() [1/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const char *  inFormat,
  ... 
)
4184  {
4185  Dtk_string Value;
4186  {
4187  va_list ap;
4188  va_start( ap, inFormat );
4189  char buffer[ 512 ] = { 0 };
4190  Dtk_StandardTools::vsprintf_dtk( buffer, 512, inFormat, ap );
4191  va_end( ap );
4192  Value = buffer;
4193  }
4194 
4195  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Value";
4196  const char *TitleCharStr = Title.c_str();
4197 
4198  Value = ( Value.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( Value, XMLGenericString ) : L"Undefined.";
4199  fprintf( inFile, "<%s>%s</%s>\n",
4200  TitleCharStr,
4201  Value.c_str(),
4202  TitleCharStr );
4203 
4204  return dtkNoError;
4205  }

◆ Dtk_DumpXml_Value() [2/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_bool &  inValue 
)
4222  {
4223  //we check if the label is present - label overload -
4224  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_bool";
4225  const char *TitleCharStr = Title.c_str();
4226 
4227  fprintf( inFile, "<%s>%s</%s>\n",
4228  TitleCharStr,
4229  ( inValue == DTK_FALSE ) ? "DTK_FALSE" : "DTK_TRUE",
4230  TitleCharStr );
4231  return dtkNoError;
4232  }

◆ Dtk_DumpXml_Value() [3/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_Double64 &  inValue,
const char *  inFormat = "%lf" 
)
4208  {
4209  //we check if the label is present - label overload -
4210  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_Double64";
4211  const char *TitleCharStr = Title.c_str();
4212 
4213  char MyFormat[ 128 ] = { 0 };
4214  Dtk_StandardTools::sprintf_dtk( MyFormat, 128, "<%%s>%s</%%s>\n", inFormat );
4215  fprintf( inFile, MyFormat,
4216  TitleCharStr,
4217  inValue,
4218  TitleCharStr );
4219  return dtkNoError;
4220  }

◆ Dtk_DumpXml_Value() [4/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_Int64 &  inValue 
)
4234  {
4235  //we check if the label is present - label overload -
4236  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_Int64";
4237  const char *TitleCharStr = Title.c_str();
4238 
4239  fprintf( inFile, "<%s>\'" XmlFormat( "d" ) "\"</%s>\n",
4240  TitleCharStr,
4241  inValue,
4242  TitleCharStr );
4243  return dtkNoError;
4244  }

◆ Dtk_DumpXml_Value() [5/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_string &  inValue 
)
4258  {
4259  //we check if the label is present - label overload -
4260  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_string";
4261  const char *TitleCharStr = Title.c_str();
4262 
4263  if( inValue.len() > 0 )
4264  {
4265 
4266  Dtk_string Value = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inValue, XMLGenericString );
4267 
4268  fprintf( inFile, "<%s>&quot;%s&quot;</%s>\n",
4269  TitleCharStr,
4270  Value.c_str(),
4271  TitleCharStr );
4272  }
4273  else
4274  {
4275  fprintf( inFile, "<%s>(null)</%s>\n",
4276  TitleCharStr,
4277  TitleCharStr );
4278  }
4279  return dtkNoError;
4280  }

◆ Dtk_DumpXml_Value() [6/7]

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

◆ Dtk_DumpXml_Value() [7/7]

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

◆ Dtk_End_Dump_Files()

Dtk_ErrorStatus Dtk_End_Dump_Files ( const Dtk_string &  inComponentFullName)
7640  {
7641  Dtk_string str_fic_param, str_fic_feat;
7642 
7643  if( FeaturesDumpFile )
7644  {
7645  str_fic_feat = inComponentFullName + Dtk_string( ".feat.log" );
7646  fclose( FeaturesDumpFile );
7647  FeaturesDumpFile = NULL;
7648  }
7649 
7650  return dtkNoError;
7651 
7652  }

◆ Dtk_Init_Dump_Files()

Dtk_ErrorStatus Dtk_Init_Dump_Files ( const Dtk_string &  inDumpFileName,
Dtk_bool  dumpFeatures = 0 
)
7626  {
7627  if( dumpFeatures )
7628  {
7629  FeaturesDumpFile = inDumpFileName.OpenFile( DTK_WP );
7630  if( FeaturesDumpFile == NULL )
7631  {
7632  return dtkErrorOpenFiles;
7633  }
7634  }
7635 
7636  return dtkNoError;
7637  }

◆ DtkReaderTypeEnumToString()

Dtk_string DtkReaderTypeEnumToString ( const DtkReaderType &  inReaderTypeEnum)
719  {
720  Dtk_string EnumToStr;
721  switch( inReaderTypeEnum )
722  {
723  case V5ReaderModule: EnumToStr = L"V5ReaderModule"; break;
724  case VdaReaderModule: EnumToStr = L"VdaReaderModule"; break;
725  case InvReaderModule: EnumToStr = L"InvReaderModule"; break;
726  case V4ReaderModule: EnumToStr = L"V4ReaderModule"; break;
727  case UgReaderModule: EnumToStr = L"UgReaderModule"; break;
728  case XmtReaderModule: EnumToStr = L"XmtReaderModule"; break;
729  case SwReaderModule: EnumToStr = L"SwReaderModule"; break;
730  case SeReaderModule: EnumToStr = L"SeReaderModule"; break;
731  case IgesReaderModule: EnumToStr = L"IgesReaderModule"; break;
732  case StepReaderModule: EnumToStr = L"StepReaderModule"; break;
733  case PsReaderModule: EnumToStr = L"PsReaderModule"; break;
734  case ProeReaderModule: EnumToStr = L"ProeReaderModule"; break;
735  case SatReaderModule: EnumToStr = L"SatReaderModule"; break;
736  case JtReaderModule: EnumToStr = L"JtReaderModule"; break;
737  case CgrReaderModule: EnumToStr = L"CgrReaderModule"; break;
738  case CgmReaderModule: EnumToStr = L"CgmReaderModule"; break;
739  case CaddsReaderModule: EnumToStr = L"CaddsReaderModule"; break;
740  case DwgReaderModule: EnumToStr = L"DwgReaderModule"; break;
741  case DwgDtkReaderModule: EnumToStr = L"DwgDtkReaderModule"; break;
742  case AcisReaderModule: EnumToStr = L"AcisReaderModule"; break;
743  case ProCeraReaderModule: EnumToStr = L"ProCeraReaderModule"; break;
744  case CerconReaderModule: EnumToStr = L"CerconReaderModule"; break;
745  case CerecReaderModule: EnumToStr = L"CerecReaderModule"; break;
746  case DcmReaderModule: EnumToStr = L"DcmReaderModule"; break;
747  case _3dXmlReaderModule: EnumToStr = L"_3dXmlReaderModule"; break;
748  case XmlReaderModule: EnumToStr = L"XmlReaderModule"; break;
749  case V6ReaderModule: EnumToStr = L"V6ReaderModule"; break;
750  case DxfReaderModule: EnumToStr = L"DxfReaderModule"; break;
751  case PlmXmlReaderModule: EnumToStr = L"PlmXmlReaderModule"; break;
752  case RnXmlReaderModule: EnumToStr = L"RnXmlReaderModule"; break;
753  case FbxReaderModule: EnumToStr = L"FbxReaderModule"; break;
754  case GltfReaderModule: EnumToStr = L"GltfReaderModule"; break;
755  case SdnfReaderModule: EnumToStr = L"SdnfReaderModule"; break;
756  case F3dReaderModule: EnumToStr = L"F3dReaderModule"; break;
757  case PrcReaderModule: EnumToStr = L"PrcReaderModule"; break;
758  case ArtReaderModule: EnumToStr = L"ArtReaderModule"; break;
759  case SmgReaderModule: EnumToStr = L"SmgReaderModule"; break;
760  case DstvReaderModule: EnumToStr = L"DstvReaderModule"; break;
761  case NavisReaderModule: EnumToStr = L"NavisReaderModule"; break;
762  case QifReaderModule: EnumToStr = L"QifReaderModule"; break;
763  case Zw3dReaderModule: EnumToStr = L"Zw3dReaderModule"; break;
764  case StlReaderModule: EnumToStr = L"StlReaderModule"; break;
765  case IfcReaderModule: EnumToStr = L"IfcReaderModule"; break;
766  case RevitReaderModule: EnumToStr = L"RevitReaderModule"; break;
767  case MaxReaderModules: EnumToStr = L"MaxReaderModules"; break;
768  case UnknownModule: EnumToStr = L"UnknownModule"; break;
769  default:
770  EnumToStr = L"UnknownModule";
771  }
772  return EnumToStr;
773  }
Dtk_DumpXml_Dtk_SymbolPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SymbolPtr(FILE *F, const Dtk_SymbolPtr &D)
Definition: util_xml_dtk.cpp:2743
Dtk_DumpXml_Dtk_DatumTargetPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DatumTargetPtr(FILE *F, const Dtk_DatumTargetPtr &D)
Definition: util_xml_dtk.cpp:2080
Dtk_KinLaw
Dtk_KinLaw represents a law associated at a command.
Definition: util_kinematics_dtk.hpp:2342
Dtk_DumpXml_Dtk_NodePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr(FILE *F, const Dtk_NodePtr &inObject)
Definition: util_xml_dtk.cpp:4413
Dtk_KinJoint::getName
Dtk_string getName()
Returns the joint name.
Dtk_Camera::UpVector
const Dtk_dir & UpVector() const
Retrieves the up vector - read only -.
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:1075
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:934
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:6067
Dtk_DumpXml_Dtk_GeometricalTolerancePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GeometricalTolerancePtr(FILE *F, const Dtk_GeometricalTolerancePtr &D)
Definition: util_xml_dtk.cpp:2514
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:1287
Dtk_Info::GetReferenceSet
Dtk_ErrorStatus GetReferenceSet(Dtk_tab< Dtk_string > &outArray, Dtk_Int32 inRemovePrefix=DTK_FALSE) const
Dtk_ID
uint32_t Dtk_ID
Definition: define.h:691
DTK_FDT_MODIFIER_NOT_SET
@ DTK_FDT_MODIFIER_NOT_SET
Definition: util_draw_dtk.hpp:58
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:1494
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:2581
Dtk_Text::TextStyle
Dtk_TextStyle & TextStyle()
Retrieves the text text style - get/set -.
DTK_TYPE_GEOM_TOL
@ DTK_TYPE_GEOM_TOL
Definition: define.h:441
Dtk_KinJoint::_RATIO_PARAMETER
Dtk_string _RATIO_PARAMETER
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:973
Dtk_Camera::ZoomFactor
Dtk_Double64 ZoomFactor() const
Processes the X - width - zoom factor - read only -.
Definition: util_draw_dtk.hpp:7526
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:4166
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:1758
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:4776
Dtk_DumpXml_DTK_FDT_MODIFIER
Dtk_ErrorStatus Dtk_DumpXml_DTK_FDT_MODIFIER(FILE *F, const DTK_FDT_MODIFIER &D)
Definition: util_xml_dtk.cpp:2588
Dtk_DumpXml_Dtk_LinePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LinePtr(FILE *F, const Dtk_LinePtr &inCurve)
Definition: util_xml_dtk.cpp:4935
Dtk_Leader::ArrowHead::GetType
const LeaderTerminatorTypeEnum GetType() const
Definition: util_draw_dtk.hpp:2136
Dtk_ModelDisplay::rendering_mode_wireframe_face_analysis
@ rendering_mode_wireframe_face_analysis
Definition: util_ent_dtk.hpp:872
XMLElement
@ XMLElement
Definition: util_xml_dtk.hpp:93
Dtk_status::isNotOK
Dtk_bool isNotOK() const
Dtk_API::GetNumCurveLineTypeDefinitionsInTable
Dtk_Size_t GetNumCurveLineTypeDefinitionsInTable() const
DTK_TYPE_DIMENSION
@ DTK_TYPE_DIMENSION
Definition: define.h:442
Dtk_Text::TextSubType
DTK_Text_subtype & TextSubType()
Retrieves the text subtype - get/set -.
Dtk_DatumTarget::NumValues
@ NumValues
Definition: util_draw_dtk.hpp:3763
Dtk_KinJoint
Dtk_KinJoint represents a joint to define a mechanism.
Definition: util_kinematics_dtk.hpp:867
Dtk_KinJoint::getJoint1
Dtk_KinJointPtr getJoint1()
Returns the first joint associated at the joint.
XMLGenericString
@ XMLGenericString
Definition: util_xml_dtk.hpp:95
Dtk_DumpXml_Dtk_KinematicsFixPart
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFixPart(FILE *inFile, const Dtk_KinFixPartPtr &inFixPart)
Definition: util_xml_dtk.cpp:7371
DTK_WITH_HIERARCHY
@ DTK_WITH_HIERARCHY
Definition: util_draw_dtk.hpp:68
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:2585
Dtk_DumpXml_FeatHole
Dtk_ErrorStatus Dtk_DumpXml_FeatHole(FILE *f, const Dtk_feat_hole *inToWrite)
Definition: util_xml_dtk.cpp:7802
Dtk_DumpXml_Dtk_2dEntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_2dEntityPtr(FILE *F, const Dtk_2dEntityPtr &D, const int &compact)
Definition: util_xml_dtk.cpp:2766
Dtk_KinJoint::_LOWER_LIMIT2
Dtk_string _LOWER_LIMIT2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:952
Dtk_DumpXml_Dtk_KinematicsProduct
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsProduct(FILE *inFile, const Dtk_KinProductPtr &inKinProduct, int &inKinProductIndex)
Definition: util_xml_dtk.cpp:7391
Dtk_DatumTarget::DatumTargetValueEnumToString
static Dtk_string DatumTargetValueEnumToString(const DatumTargetValueEnum &inEnum)
Definition: util_draw_dtk.hpp:3766
DTK_FDT_MODIFIER_LEAST_MATERIAL
@ DTK_FDT_MODIFIER_LEAST_MATERIAL
Definition: util_draw_dtk.hpp:60
Dtk_DumpXml_Dtk_OneCell
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OneCell(FILE *F, Dtk_OneCell &D)
Definition: util_xml_dtk.cpp:2195
Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr(FILE *F, const Dtk_ToleranceSpecificationContainerPtr &D)
Definition: util_xml_dtk.cpp:2488
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:6356
DTK_FDT_MODIFIER_NONE
@ DTK_FDT_MODIFIER_NONE
Definition: util_draw_dtk.hpp:62
Dtk_OneCell::GetBorderBottomColor
const Dtk_RGB & GetBorderBottomColor()
Gets BorderBottomColor of Bottom border.
Dtk_Roughness::ModePerpendicular
@ ModePerpendicular
Definition: util_draw_dtk.hpp:2603
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:958
Dtk_DatumTarget::DatumTargetValueEnum
DatumTargetValueEnum
Definition: util_draw_dtk.hpp:3754
Dtk_ToleranceSpecificationContainer::TypeAxisIntersection
@ TypeAxisIntersection
Definition: util_draw_dtk.hpp:6097
DTK_TYPE_VERTEX
@ DTK_TYPE_VERTEX
Definition: define.h:127
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:925
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:928
Dtk_DumpXml_Dtk_ComponentPtr_Init
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_Init(FILE *F, const Dtk_ComponentPtr &inObject)
Definition: util_xml_dtk.cpp:4669
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:1340
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:6266
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:6862
Dtk_DumpXml_ComponentTypeEnum
void Dtk_DumpXml_ComponentTypeEnum(FILE *F, const Dtk_Component::ComponentTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:681
Dtk_Roughness::ApplyToBasicSurface
@ ApplyToBasicSurface
Definition: util_draw_dtk.hpp:2583
Dtk_KinParameter::getId
int getId()
Retrun the parameter id.
Dtk_ToleranceSpecificationContainer::TypeFlatness
@ TypeFlatness
Definition: util_draw_dtk.hpp:6071
Dtk_Roughness::ModeMultiDirectional
@ ModeMultiDirectional
Definition: util_draw_dtk.hpp:2591
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:5066
DTK_TRUE
#define DTK_TRUE
Definition: define.h:729
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:561
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:943
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:2574
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:3093
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:914
Zw3dReaderModule
@ Zw3dReaderModule
Definition: dtk_maindoc.hpp:80
Dtk_KinJoint::_RATIO
Dtk_string _RATIO
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:970
Dtk_UInt32
uint32_t Dtk_UInt32
Definition: define.h:690
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:868
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:869
Dtk_KinParameter::_RANGE
Dtk_string _RANGE
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:329
DTK_ANCHOR_BOTTOM_LEFT
@ DTK_ANCHOR_BOTTOM_LEFT
Definition: util_draw_dtk.hpp:100
Dtk_DumpXml_Dtk_KinematicsLaw
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsLaw(FILE *inFile, const Dtk_KinLawPtr &inLaw)
Definition: util_xml_dtk.cpp:7113
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:976
Dtk_Size_t
size_t Dtk_Size_t
Definition: define.h:714
Dtk_Info::GetColor
Dtk_RGB GetColor() const
Retrieves the entity color as Dtk_RGBA values.
Dtk_NodeConnector::SubEntity
Definition: dtk_maindoc.hpp:1205
Dtk_DumpXml_Dtk_LineTypeDefinitionPtr
void Dtk_DumpXml_Dtk_LineTypeDefinitionPtr(FILE *F, const Dtk_LineTypeDefinitionPtr &inLineTypeDefinition)
Definition: util_xml_dtk.cpp:3868
Dtk_DumpXml_Dtk_EdgePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EdgePtr(FILE *F, const Dtk_EdgePtr &inEdge)
Definition: util_xml_dtk.cpp:6282
DTK_TYPE_COMPOSITE_ENTITY
@ DTK_TYPE_COMPOSITE_ENTITY
Definition: define.h:452
DTK_ANCHOR_TOP_CENTER
@ DTK_ANCHOR_TOP_CENTER
Definition: util_draw_dtk.hpp:95
Dtk_ToleranceSpecificationContainer::TypeStraightness
@ TypeStraightness
Definition: util_draw_dtk.hpp:6069
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:3417
Dtk_KinJoint::_JOINT2
Dtk_string _JOINT2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:967
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:1244
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:1730
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:101
Dtk_DumpXml_Dtk_RoughnessPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RoughnessPtr(FILE *F, const Dtk_RoughnessPtr &D)
Definition: util_xml_dtk.cpp:1572
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:2312
Dtk_Fdt::Default
@ Default
The annotation display isn't bound to the viewport.
Definition: util_draw_dtk.hpp:7221
Dtk_Roughness::ModeParticular
@ ModeParticular
Definition: util_draw_dtk.hpp:2597
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:1843
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:4282
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:730
Dtk_DumpXml_Dtk_ParabolaPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ParabolaPtr(FILE *F, const Dtk_ParabolaPtr &inCurve)
Definition: util_xml_dtk.cpp:5044
DTK_TYPE_NURBS_CURVE
@ DTK_TYPE_NURBS_CURVE
Definition: define.h:496
StlReaderModule
@ StlReaderModule
Definition: dtk_maindoc.hpp:67
DTK_TYPE_SYMBOL
@ DTK_TYPE_SYMBOL
Definition: define.h:411
Dtk_bool
char Dtk_bool
Definition: define.h:727
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:439
Dtk_DatumTarget::DatumTargetTypeEnumToString
static Dtk_string DatumTargetTypeEnumToString(const DatumTargetTypeEnum &inEnum)
Definition: util_draw_dtk.hpp:3721
Dtk_DumpXml_Dtk_PhysicalMaterialInfos
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PhysicalMaterialInfos(FILE *F, const Dtk_PhysicalMaterialInfosPtr &inMaterial)
Definition: util_xml_dtk.cpp:3601
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:690
Dtk_Symbol::Create
static Dtk_SymbolPtr Create()
Calls default constructor to allocate a new object.
Dtk_ModelDisplay::rendering_mode_wireframe_with_only_visible_edges
@ rendering_mode_wireframe_with_only_visible_edges
Definition: util_ent_dtk.hpp:870
DTK_ANCHOR_MIDDLE_CENTER
@ DTK_ANCHOR_MIDDLE_CENTER
Definition: util_draw_dtk.hpp:98
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:4975
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:798
Dtk_Node::GetChild
const Dtk_NodePtr GetChild(const Dtk_Size_t &inPos) const
Retrieves the ith Dtk_Node - read only -.
Definition: dtk_maindoc.hpp:384
Dtk_DumpXml_Dtk_NodeConnector
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodeConnector(FILE *inFile, const Dtk_NodeConnectorPtr &inNodeConnector)
Definition: util_xml_dtk.cpp:6690
Dtk_Double64
double Dtk_Double64
Definition: define.h:701
Dtk_DumpXml_Dtk_welding_symbol
Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_symbol(FILE *F, const Dtk_Welding::WeldingSymbolEnum &D)
Definition: util_xml_dtk.cpp:1629
Dtk_DumpXml_Dtk_TextStyle
Dtk_ErrorStatus Dtk_DumpXml_Dtk_TextStyle(FILE *F, const Dtk_TextStyle &T)
Definition: util_xml_dtk.cpp:956
Dtk_DumpXml_FeatThread
Dtk_ErrorStatus Dtk_DumpXml_FeatThread(FILE *f, const Dtk_feat_thread *inToWrite)
Definition: util_xml_dtk.cpp:7743
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:866
Dtk_OneCell::GetAdditionnalGeometries
const Dtk_tab< Dtk_EntityPtr > & GetAdditionnalGeometries() const
Retrieves the additionnal geometries of the Dtk_OneCell.
Dtk_Camera::Focus
Dtk_Double64 Focus() const
Definition: util_draw_dtk.hpp:7530
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:6769
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:4183
XmlFormat
#define XmlFormat(inOldFormat)
Definition: util_xml_dtk.cpp:44
Dtk_KinJoint::_ABSOLUT_POS1
Dtk_string _ABSOLUT_POS1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:937
DTK_ANCHOR_TOP_LEFT
@ DTK_ANCHOR_TOP_LEFT
Definition: util_draw_dtk.hpp:94
CgrReaderModule
@ CgrReaderModule
Definition: dtk_maindoc.hpp:44
Dtk_Fdt::ScreenDisplayEnum
ScreenDisplayEnum
Definition: util_draw_dtk.hpp:7220
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:7455
Dtk_DumpXml_Dtk_KinematicsFormula
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFormula(FILE *inFile, const Dtk_KinFormulaPtr &inFormula)
Definition: util_xml_dtk.cpp:7097
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:2291
Dtk_DumpXml_Dtk_info
Dtk_ErrorStatus Dtk_DumpXml_Dtk_info(FILE *F, const Dtk_InfoPtr &I)
Definition: util_xml_dtk.cpp:3964
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:6426
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:7227
Dtk_ModelDisplay::SectionPlane
@ SectionPlane
Definition: util_ent_dtk.hpp:878
Dtk_Leader::TypeUnknown
@ TypeUnknown
Definition: util_draw_dtk.hpp:2195
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:4172
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:6075
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:708
Dtk_DumpXml_Dtk_StreamPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_StreamPtr(FILE *F, const Dtk_StreamPtr &inVal)
Definition: util_xml_dtk.cpp:8443
Dtk_DumpXml_Dtk_WeldingPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_WeldingPtr(FILE *F, const Dtk_WeldingPtr &D)
Definition: util_xml_dtk.cpp:1792
Dtk_ModelDisplay::rendering_mode_wireframe_partially_shade
@ rendering_mode_wireframe_partially_shade
Definition: util_ent_dtk.hpp:873
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:5764
Dtk_DumpXml_Dtk_AnnotationPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_AnnotationPtr(FILE *F, const Dtk_AnnotationPtr &D)
Definition: util_xml_dtk.cpp:876
DTK_INDIFFERENT_HIERARCHY
@ DTK_INDIFFERENT_HIERARCHY
Definition: util_draw_dtk.hpp:70
Dtk_DumpXml_Dtk_DrawingPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DrawingPtr(FILE *F, const Dtk_DrawingPtr &D, const int &compact)
Definition: util_xml_dtk.cpp:2999
IgesReaderModule
@ IgesReaderModule
Definition: dtk_maindoc.hpp:38
Dtk_ModelDisplay::rendering_mode_shaded_only
@ rendering_mode_shaded_only
Definition: util_ent_dtk.hpp:867
Dtk_NodeConnector::ReasonCategoryEnum
ReasonCategoryEnum
Reason Category. Global Category of the NodeConnector uesed to gather Reason into families.
Definition: dtk_maindoc.hpp:1180
_3dXmlReaderModule
@ _3dXmlReaderModule
Definition: dtk_maindoc.hpp:51
Dtk_ModelDisplay::SectionBox
@ SectionBox
Definition: util_ent_dtk.hpp:881
Dtk_DumpXml_LeaderTerminatorTypeEnum
void Dtk_DumpXml_LeaderTerminatorTypeEnum(FILE *F, const Dtk_Leader::LeaderTerminatorTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:831
DTK_TYPE_INTERSECTION_CURVE
@ DTK_TYPE_INTERSECTION_CURVE
Definition: define.h:91
Dtk_Leader::TypeLinear
@ TypeLinear
Definition: util_draw_dtk.hpp:2196
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:2601
DTK_ANCHOR_TOP_RIGHT
@ DTK_ANCHOR_TOP_RIGHT
Definition: util_draw_dtk.hpp:96
DTK_FDT_MODIFIER_MAX_MATERIAL
@ DTK_FDT_MODIFIER_MAX_MATERIAL
Definition: util_draw_dtk.hpp:59
Dtk_DumpXml_Dtk_EntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EntityPtr(FILE *inDumpFile, const Dtk_EntityPtr &inEntity)
Definition: util_xml_dtk.cpp:5087
Dtk_ModelDisplay::rendering_mode_static_wireframe
@ rendering_mode_static_wireframe
Definition: util_ent_dtk.hpp:871
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:2321
RevitReaderModule
@ RevitReaderModule
Definition: dtk_maindoc.hpp:65
Dtk_Camera::ProjectionType
const Dtk_Camera::ProjectionTypeEnum & ProjectionType() const
Retrieves the projection type - read only -.
Dtk_NodeConnector::ReasonLinkEnumToString
static Dtk_string ReasonLinkEnumToString(const ReasonLinkEnum &inEnum)
Definition: dtk_maindoc.hpp:1128
DTK_TYPE_CIRCLE
@ DTK_TYPE_CIRCLE
Definition: define.h:60
Dtk_Int32
int32_t Dtk_Int32
Definition: define.h:689
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:575
Dtk_Roughness::ObtentionTypeNotDefined
@ ObtentionTypeNotDefined
Definition: util_draw_dtk.hpp:2570
Dtk_DumpXml_Dtk_RGB
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RGB(FILE *F, const Dtk_RGB &RGB)
Definition: util_xml_dtk.cpp:3405
Dtk_KinJoint::_PARAMETER2
Dtk_string _PARAMETER2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:931
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:874
DTK_TYPE_GRID
@ DTK_TYPE_GRID
Definition: define.h:453
V4ReaderModule
@ V4ReaderModule
Definition: dtk_maindoc.hpp:33
Dtk_ToleranceSpecificationContainer::TypeSymmetry
@ TypeSymmetry
Definition: util_draw_dtk.hpp:6091
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:2254
Dtk_Leader::ArrowHead::GetArrowLocation
const Dtk_pnt & GetArrowLocation() const
Definition: util_draw_dtk.hpp:2135
Dtk_Component::ComponentTypeEnumToString
static Dtk_string ComponentTypeEnumToString(const ComponentTypeEnum &inEnum)
Definition: dtk_maindoc.hpp:591
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:2144
Dtk_KinSpeedAcceleration
Dtk_KinSpeedAcceleration represents a mechanism speed/acceleration.
Definition: util_kinematics_dtk.hpp:2511
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:6095
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:1017
Dtk_DumpXml_Dtk_ComponentPtr_End
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_End(FILE *F)
Definition: util_xml_dtk.cpp:4763
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:6093
Dtk_DumpXml_NodeFullType
void Dtk_DumpXml_NodeFullType(FILE *F, const Dtk_Node::FullType &inNodeFullType, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:699
Dtk_KinFixPart::getPart
Dtk_KinPartPtr getPart()
Returns the part fixed.
Dtk_ErrorStatus
Dtk_ErrorStatus
Definition: error_dtk.hpp:6
Dtk_Roughness::ObtentionTypeMachiningMandatory
@ ObtentionTypeMachiningMandatory
Definition: util_draw_dtk.hpp:2572
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:4160
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:2589
Dtk_Info::GetRenderInfos
Dtk_RenderInfosPtr GetRenderInfos() const
Retrieves the entity RenderInfos of the entity.
Dtk_KinJoint::getAbsolutPos2
Dtk_transfo getAbsolutPos2()
Returns the part 2 absolute position.
typedetkToDtk_string
Dtk_string typedetkToDtk_string(const type_detk &inVal)
Definition: util_xml_dtk.cpp:99
Dtk_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:2382
Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr(FILE *F, const Dtk_FCFFeatureIndicatorPtr &D)
Definition: util_xml_dtk.cpp:2725
Dtk_StandardTools::sprintf_dtk
int sprintf_dtk(char *Buffer, size_t BufferCount, const char *Format,...)
XMLAttribute
@ XMLAttribute
Definition: util_xml_dtk.hpp:94
DTK_TYPE_SPCURVE
@ DTK_TYPE_SPCURVE
Definition: define.h:577
DTK_FRAME_TYPE_NONE
@ DTK_FRAME_TYPE_NONE
Definition: util_draw_dtk.hpp:128
Dtk_OneCell::GetBorderBottomBlanked
Dtk_Int32 GetBorderBottomBlanked()
Gets BorderBottomBlanked of Bottom border.
Dtk_ToleranceSpecificationContainer::TypeParallelism
@ TypeParallelism
Definition: util_draw_dtk.hpp:6085
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_Camera::OriginPoint
const Dtk_pnt & OriginPoint() const
Retrieves the origin point - read only -.
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:979
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:1199
Dtk_DumpXml_Dtk_DimensionPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DimensionPtr(FILE *F, const Dtk_DimensionPtr &D)
Definition: util_xml_dtk.cpp:1424
Dtk_Leader::ArrowHead::GetInfo
const Dtk_InfoPtr & GetInfo() const
Definition: util_draw_dtk.hpp:2133
DTK_UNKNOWN
@ DTK_UNKNOWN
Definition: util_draw_dtk.hpp:67
Dtk_string::is_NULL
Dtk_bool is_NULL() const
DTK_ANCHOR_MIDDLE_LEFT
@ DTK_ANCHOR_MIDDLE_LEFT
Definition: util_draw_dtk.hpp:97
validate_xml_string
Dtk_status validate_xml_string(Dtk_string &inputString)
Definition: util_xml_dtk.cpp:638
Dtk_DatumTarget::NonMovable
@ NonMovable
Definition: util_draw_dtk.hpp:3740
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:428
VdaReaderModule
@ VdaReaderModule
Definition: dtk_maindoc.hpp:31
Dtk_ModelDisplay::SectionParallelePlane
@ SectionParallelePlane
Definition: util_ent_dtk.hpp:880
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:6079
Dtk_Camera::Angle
Dtk_Double64 Angle() const
Definition: util_draw_dtk.hpp:7520
Dtk_Roughness::ApplyToSpecifiedSurface
@ ApplyToSpecifiedSurface
Definition: util_draw_dtk.hpp:2579
Dtk_KinJoint::_PART3
Dtk_string _PART3
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:955
Dtk_KinJoint::_ABSOLUT_POS2
Dtk_string _ABSOLUT_POS2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:940
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:4615
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:1536
Dtk_API::GetCurveLineTypeDefinitionInTable
Dtk_LineTypeDefinitionPtr GetCurveLineTypeDefinitionInTable(const Dtk_ID inId) const
Dtk_ModelDisplay::SectionTypeEnum
SectionTypeEnum
Definition: util_ent_dtk.hpp:877
Dtk_ToleranceSpecificationContainer::TypeCircularity
@ TypeCircularity
Definition: util_draw_dtk.hpp:6073
Dtk_DumpXml_Dtk_CompositeEntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CompositeEntityPtr(FILE *F, const Dtk_CompositeEntityPtr &D)
Definition: util_xml_dtk.cpp:2443
Dtk_ToleranceSpecificationContainer::TypeConcentricity
@ TypeConcentricity
Definition: util_draw_dtk.hpp:6089
Dtk_DumpXml_Dtk_KinematicsCommand
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCommand(FILE *inFile, const Dtk_KinCommandPtr &inCommand, Dtk_bool simplified)
Definition: util_xml_dtk.cpp:7353
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 information.
Definition: util_draw_dtk.hpp:908
Dtk_Text::GetFrame
void GetFrame(Dtk_Frame &outFrame) const
Retrieves the Frame - read only -.
Dtk_Leader::ArrowHead
This class graphically represents a leader head.
Definition: util_draw_dtk.hpp:2070
Dtk_DumpXml_Dtk_ReferenceFramePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceFramePtr(FILE *F, const Dtk_ReferenceFramePtr &D)
Definition: util_xml_dtk.cpp:2548
Dtk_ModelDisplay::SectionBody
@ SectionBody
Definition: util_ent_dtk.hpp:882
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:3571
Dtk_Roughness::ModeWithAngles
@ ModeWithAngles
Definition: util_draw_dtk.hpp:2599
Dtk_KinMechanism
Dtk_KinMechanism represents a kinematic mechanism.
Definition: util_kinematics_dtk.hpp:1618
Dtk_Text::GetOuterBoundingBox
const Dtk_Oriented2dBBox & GetOuterBoundingBox() const
Processes the outer bounding box.
DTK_TYPE_TABLE
@ DTK_TYPE_TABLE
Definition: define.h:491
Dtk_Leader::ArrowHead::GetDirections
void GetDirections(Dtk_dir &outRefDir, Dtk_dir &outAxisDir) const
Definition: util_draw_dtk.hpp:2139
Dtk_Camera::TargetPoint
const Dtk_pnt & TargetPoint() const
Retrieves the target point - read only -.
Dtk_Camera::GetZoomFitMode
const Dtk_Camera::ZoomFitModeEnum & GetZoomFitMode() const
Retrieves the zoom fit mode - read only -.
Dtk_Roughness::ModeCircular
@ ModeCircular
Definition: util_draw_dtk.hpp:2593
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:2530
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:5023
Dtk_ToleranceSpecificationContainer::TypePerpendicularity
@ TypePerpendicularity
Definition: util_draw_dtk.hpp:6083
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:964
dump_file
FILE * dump_file
Definition: util_xml_dtk.cpp:58
DTK_TYPE_ELLIPSE
@ DTK_TYPE_ELLIPSE
Definition: define.h:61
Dtk_Roughness::ModeRadial
@ ModeRadial
Definition: util_draw_dtk.hpp:2595
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:4839
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:1271
Dtk_Leader::TypeAngular
@ TypeAngular
Definition: util_draw_dtk.hpp:2197
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:7145
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:1514
Dtk_DumpXml_FormatDtk_string
Dtk_string Dtk_DumpXml_FormatDtk_string(const Dtk_string &inString, const XML_StringType inXmlStringType=XMLGenericString)
Definition: util_xml_dtk.cpp:4282
Dtk_DumpXml_Dtk_ViewPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewPtr(FILE *F, const Dtk_ViewPtr &V, const int &compact)
Definition: util_xml_dtk.cpp:2921
Dtk_DumpXml_FeatGeometry
Dtk_ErrorStatus Dtk_DumpXml_FeatGeometry(FILE *f, const Dtk_feat_geometry *inToWrite, const char *inName)
Definition: util_xml_dtk.cpp:7657
Dtk_KinJoint::getLowerLimit1
double getLowerLimit1()
Returns the lower limit 1.
Dtk_Component::PrototypeComponentType
@ PrototypeComponentType
Definition: dtk_maindoc.hpp:569
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:8222
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:1537
Dtk_DumpXml_Dtk_MeshPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshPtr(FILE *F, const Dtk_MeshPtr &inMesh)
Definition: util_xml_dtk.cpp:6586
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:8003
DTK_ANCHOR_BOTTOM_RIGHT
@ DTK_ANCHOR_BOTTOM_RIGHT
Definition: util_draw_dtk.hpp:102
InvReaderModule
@ InvReaderModule
Definition: dtk_maindoc.hpp:32
Dtk_KinJoint::_LOWER_LIMIT1
Dtk_string _LOWER_LIMIT1
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:946
Dtk_KinParameter::getName
Dtk_string getName()
Returns the parameter name.
FeaturesDumpFile
FILE * FeaturesDumpFile
Definition: util_xml_dtk.cpp:59
Dtk_DumpXml_Dtk_Grid_OriginReferenceOptionEnum
void Dtk_DumpXml_Dtk_Grid_OriginReferenceOptionEnum(FILE *F, const Dtk_Grid::OriginReferenceOption &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:2338
Dtk_DumpXml_Dtk_PolylinePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PolylinePtr(FILE *F, const Dtk_PolylinePtr &inCurve)
Definition: util_xml_dtk.cpp:4955
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:1217
Dtk_NodeConnector::SubEntity::GetSubEntityType
type_detk GetSubEntityType() const
Definition: dtk_maindoc.hpp:1216
DTK_ANCHOR_MIDDLE_RIGHT
@ DTK_ANCHOR_MIDDLE_RIGHT
Definition: util_draw_dtk.hpp:99
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:8273
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:2672
Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration(FILE *inFile, const Dtk_KinSpeedAccelerationPtr &inSpeedAcceleration)
Definition: util_xml_dtk.cpp:6921
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_Camera::GetClippingDistance
void GetClippingDistance(Dtk_Double64 &outFrontDistance, Dtk_Double64 &outBackDistance) const
get the Front Clipping Distance et Back Clipping Distance
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:7086
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:61
DTK_TYPE_HYPERBOLA
@ DTK_TYPE_HYPERBOLA
Definition: define.h:62
Dtk_ToleranceSpecificationContainer::TypeAngularity
@ TypeAngularity
Definition: util_draw_dtk.hpp:6081
Dtk_RGB
Definition: dtk_rgb.hpp:7
DTK_WITHOUT_HIERARCHY
@ DTK_WITHOUT_HIERARCHY
Definition: util_draw_dtk.hpp:69
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:471
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:445
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:2356
Dtk_DumpXml_Dtk_CameraProjectionTypeEnum
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraProjectionTypeEnum(FILE *F, const Dtk_Camera::ProjectionTypeEnum &inVal)
Definition: util_xml_dtk.cpp:3067
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:6852
DTK_TYPE_WELDING
@ DTK_TYPE_WELDING
Definition: define.h:448
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:7205
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:961
Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType(FILE *F, const Dtk_ToleranceSpecificationContainer::TypeEnum &D)
Definition: util_xml_dtk.cpp:2614
Dtk_DumpXml_Dtk_Constraint_ConstraintValue
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Constraint_ConstraintValue(FILE *F, const Dtk_Constraint::_ConstraintValue &inVal)
Definition: util_xml_dtk.cpp:8246
UgReaderModule
@ UgReaderModule
Definition: dtk_maindoc.hpp:34
Dtk_ToleranceSpecificationContainer::TypePosition
@ TypePosition
Definition: util_draw_dtk.hpp:6087
Dtk_Entity::info
Dtk_InfoPtr & info()
Dtk_DumpXml_Dtk_FdtPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FdtPtr(FILE *F, const Dtk_FdtPtr &D, const int &compact)
Definition: util_xml_dtk.cpp:3022
DwgReaderModule
@ DwgReaderModule
Definition: dtk_maindoc.hpp:61
Dtk_KinJoint::_UPPER_LIMIT2
Dtk_string _UPPER_LIMIT2
Name for optional attribute.
Definition: util_kinematics_dtk.hpp:949
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:3743
Dtk_ToleranceSpecificationContainer::TypeLineProfile
@ TypeLineProfile
Definition: util_draw_dtk.hpp:6077
Dtk_NodeConnector::SubEntity::GetSubEntityId
Dtk_ID GetSubEntityId() const
Definition: dtk_maindoc.hpp:1215