DATAKIT SDK  V2026.2
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_LayerInfosSetPtr_Deprecated (FILE *F, const Dtk_LayerInfosSetPtr &inVal)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LeaderPtr (FILE *F, const Dtk_LeaderPtr &L)
 
Dtk_ErrorStatus Dtk_DumpXml_Dtk_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 &  )
5112  {
5113  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_DrawingPtr( dump_file, d, 0 );
5114  }

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

◆ Dtk_DumpXml_Dtk_anchor_type()

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

◆ Dtk_DumpXml_Dtk_AxisSystemPtr()

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

◆ Dtk_DumpXml_Dtk_BodyPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_BodyPtr ( FILE *  F,
const Dtk_BodyPtr &  inBody 
)
6646  {
6647  Dtk_Size_t numLump, i, j;
6648 
6649  fprintf( F, "<Dtk_BodyPtr>" );
6650  fprintf( F, "<Status>%d</Status>", inBody->GetBodyStatus() );
6651  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inBody->get_info() );
6652  // fprintf(F,"<Id>%d</Id>",inBody->GetID());
6653  numLump = inBody->GetNumLumps();
6654  for( i = 0; i < numLump; i++ )
6655  {
6656  Dtk_LumpPtr lump;
6657  inBody->GetLump( i, lump );
6658  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LumpPtr( F, lump );
6659 
6660  }
6661  Dtk_ShellPtr myshell;
6662  Dtk_Size_t m, NumOpenshell = inBody->GetNumOpenShells();
6663 
6664  for( m = 0; m < NumOpenshell; m++ )
6665  {
6666  inBody->GetOpenShell( m, myshell );
6667  if( myshell.IsNotNULL() )
6668  {
6669  fprintf( F, "<Dtk_OpenShellPtr>" );
6670  if( myshell->info().IsNotNULL() )
6671  {
6672  fprintf( F, "<Id>%d</Id>", myshell->info()->GetId() );
6673  }
6674 
6675  Dtk_Size_t NumFaces = myshell->GetNumFaces();
6676  for( i = 0; i < NumFaces; i++ )
6677  {
6678  Dtk_FacePtr FacePtr;
6679  Dtk_bool Orientation;
6680  myshell->GetFace( i, FacePtr, Orientation );
6681  //fprintf( F, "<orientation>%d</orientation>", Orientation );
6682  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FacePtr( F, FacePtr );
6683  }
6684  Dtk_Size_t nbWires = myshell->GetNumWireSet();
6685  if( nbWires != 0 )
6686  {
6687  fprintf( F, "<Wireframe>" );
6688  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, myshell->get_info() );
6689  for( i = 0; i < nbWires; i++ )
6690  {
6691  fprintf( F, "<WireSet>" );
6692 
6693  Dtk_tab<Dtk_EntityPtr> wireSet;
6694  Dtk_tab<Dtk_bool> orientation;
6695  Dtk_bool looporientation = -1;
6696  myshell->GetWireSetTopo( i, wireSet , orientation, looporientation);
6697  fprintf(F, "<WireLoopOrientation>%d</WireLoopOrientation>", looporientation);
6698  for( j = 0; j < wireSet.size(); j++ )
6699  {
6700  if( wireSet[ j ]->get_type_detk() != DTK_TYPE_VERTEX )
6701  {
6702  fprintf(F, "<WireEdgeOrientation>%d</WireEdgeOrientation>", orientation[j]);
6703  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EdgePtr( F, Dtk_EdgePtr::DtkDynamicCast( wireSet[ j ] ) );
6704  }
6705  else
6706  {
6707  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_VertexPtr( F, Dtk_VertexPtr::DtkDynamicCast( wireSet[ j ] ) );
6708  }
6709  }
6710  fprintf( F, "</WireSet>" );
6711  }
6712  fprintf( F, "</Wireframe>" );
6713  }
6714  fprintf( F, "</Dtk_OpenShellPtr>" );
6715  }
6716  }
6717  Dtk_Size_t numStream = inBody->GetNumStream();
6718  for( i = 0; i < numStream; i++ )
6719  {
6720  Dtk_StreamPtr stream;
6721  stream = inBody->GetStream( i );
6722  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_StreamPtr( F, stream );
6723 
6724  }
6725 
6726  fprintf( F, "</Dtk_BodyPtr>" );
6727 
6728  return dtkNoError;
6729  }

◆ Dtk_DumpXml_Dtk_bool()

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

◆ Dtk_DumpXml_Dtk_CameraPtr()

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

◆ Dtk_DumpXml_Dtk_ColorInfosSetPtr()

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

◆ Dtk_DumpXml_Dtk_ComponentPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr ( FILE *  F,
const Dtk_ComponentPtr &  inObject 
)
4796  {
4797  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr_Init( F, inObject );
4798  Dtk_Size_t NumChildren = inObject->GetNumChildren();
4799  for( Dtk_Size_t i = 0; i < NumChildren; i++ )
4800  {
4801  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->GetChild( i ) );
4802  }
4803 
4804  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr_End( F );
4805  /*fprintf( F, "<Dtk_ComponentPtr>\n" );
4806  if( inObject.IsNotNULL() )
4807  {
4808  Dtk_Size_t i, NumChildren, NumFathers = inObject->GetNumFathers();
4809  Dtk_MaterialPtr mat = NULL;
4810  fprintf( F, "<ComponentID>%u</ComponentID>\n", inObject->GetID() );
4811  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4812  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4813  Dtk_ID readid;
4814  inObject->GetReadID( readid );
4815  if( readid > 0 )
4816  fprintf( F, "<ReadID>%d</ReadID>\n", readid );
4817  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FullPathName", inObject->FullPathName() );
4818  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"InstanceName", inObject->InstanceName() );
4819  if( inObject->GetFileVersion().icmp( L"" ) != 0 )
4820  {
4821  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FileVersion", inObject->GetFileVersion() );
4822  }
4823  fprintf( F, "<ComponentUnitScale>%f</ComponentUnitScale>\n", inObject->GetConceptionUnitScale() );
4824  for( i = 0; i < NumFathers; i++ )
4825  fprintf( F, "<FatherID>%u</FatherID>\n", inObject->GetFatherID( i ) );
4826  Dtk_DumpXMLNamespace::Dtk_DumpXml_DtkReaderType( F, inObject->GetAssociatedModuleType(), L"AssociatedModule" );
4827  Dtk_DumpXMLNamespace::Dtk_DumpXml_ComponentTypeEnum( F, inObject->ComponentType(), L"ComponentType" );
4828  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inObject->TransformationMatrix() );
4829  // mat = inObject->GetMaterial();
4830  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_material(F,mat);
4831 
4832 
4833  NumChildren = inObject->GetNumChildren();
4834  for( i = 0; i < NumChildren; i++ )
4835  {
4836  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->GetChild( i ) );
4837  }
4838 
4839  }
4840  else
4841  {
4842  fprintf( F, "'Null'" );
4843  }
4844  fprintf( F, "</Dtk_ComponentPtr>\n" );*/
4845  return dtkNoError;
4846  }

◆ Dtk_DumpXml_Dtk_ComponentPtr_End()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_End ( FILE *  F)
4946  {
4947  if( F == NULL )
4948  {
4949  return dtkErrorNullPointer;
4950  }
4951 
4952  fprintf( F, "</Dtk_ComponentPtr>\n" );
4953  return dtkNoError;
4954  }

◆ Dtk_DumpXml_Dtk_ComponentPtr_Init()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_Init ( FILE *  F,
const Dtk_ComponentPtr &  inObject 
)
4850  {
4851  if( F == NULL )
4852  {
4853  return dtkErrorNullPointer;
4854  }
4855 
4856  fprintf( F, "<Dtk_ComponentPtr>\n" );
4857  if( inObject.IsNotNULL() )
4858  {
4859  Dtk_Size_t i;
4860  Dtk_MaterialPtr mat = NULL;
4861  fprintf( F, "<ComponentID>%u</ComponentID>\n", inObject->GetID() );
4862  fprintf( F, "<IsAssembly>%d</IsAssembly>\n", inObject->IsAssembly() );
4863  if( inObject->ComponentType() == Dtk_Component::PrototypeComponentType )
4864  {
4865  Dtk_string avail = Dtk_Component::ComponentAvailabilityEnumToString( inObject->ComponentAvailability() );
4866  fprintf( F, "<ComponentAvailability>%ls</ComponentAvailability>\n", avail.w_str() );
4867  if( inObject->IsAdditionnalReference() )
4868  fprintf( F, "<IsAdditionnalReference>1</IsAdditionnalReference>\n" );
4869  }
4870  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4871  if( inObject->Name().len() > 0 )
4872  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4873 
4874  Dtk_ID readid;
4875  inObject->GetReadID( readid );
4876  if( readid > 0 )
4877  fprintf( F, "<ReadID>%d</ReadID>\n", readid );
4878 
4879  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FullPathName", inObject->FullPathName() );
4880  if( inObject->OriginalPathName().len() > 0 )
4881  {
4882  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"OriginalPathName", inObject->OriginalPathName() );
4883  }
4884  if( inObject->InstanceName().len() > 0 )
4885  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"InstanceName", inObject->InstanceName() );
4886  if( inObject->GetFileVersion().len() > 0 )
4887  {
4888  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"FileVersion", inObject->GetFileVersion() );
4889  }
4890  Dtk_Double64 UnitScale;
4891  inObject->GetConceptionUnitScale( UnitScale );
4892  fprintf( F, "<ComponentUnitScale>%f</ComponentUnitScale>\n", UnitScale );
4893  Dtk_ID FatherID = inObject->GetFatherID( 0 );
4894  if( FatherID )
4895  fprintf( F, "<FatherID>%u</FatherID>\n", FatherID );
4896  Dtk_DumpXMLNamespace::Dtk_DumpXml_DtkReaderType( F, inObject->GetAssociatedModuleType(), L"AssociatedModule" );
4897  Dtk_DumpXMLNamespace::Dtk_DumpXml_ComponentTypeEnum( F, inObject->ComponentType(), L"ComponentType" );
4898 
4899  Dtk_PreviewPtr preview = inObject->GetPreview();
4900  if( preview.IsNotNULL() )
4901  {
4902  Dtk_Size_t size = preview->GetStreamSize();
4903  fprintf( F, "<PreviewSize>\"" XmlFormat( "u" )"\"</PreviewSize>", size );
4904  }
4905 
4906  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_transfo( F, inObject->TransformationMatrix() );
4907  // mat = inObject->GetMaterial();
4908  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_material(F,mat);
4909 
4910  Dtk_Size_t NumMetaData;
4911  NumMetaData = inObject->GetNumMetaData();
4912  if( NumMetaData )
4913  {
4914  fprintf( F, "<Dtk_MetaData Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaData );
4915  for( i = 0; i < NumMetaData; i++ )
4916  {
4917  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr( F, inObject->GetMetaData( i ) );
4918  }
4919  fprintf( F, "</Dtk_MetaData>\n" );
4920  }
4921 
4922 #ifdef XML_GROUP_METADATA
4923  Dtk_Size_t NumMetaDataGroup;
4924  NumMetaDataGroup = inObject->GetNumMetaDataGroup();
4925  if( NumMetaDataGroup )
4926  {
4927  fprintf( F, "<Dtk_MetaDataGroup Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaDataGroup );
4928  for( i = 0; i < NumMetaDataGroup; i++ )
4929  {
4930  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataGroupPtr( F, inObject->GetMetaDataGroup( i ) );
4931  }
4932  fprintf( F, "</Dtk_MetaDataGroup>\n" );
4933  }
4934 #endif
4935  }
4936  else
4937  {
4938  fprintf( F, "'Null'" );
4939  }
4940 
4941  return dtkNoError;
4942  }

◆ Dtk_DumpXml_Dtk_ConstraintPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConstraintPtr ( FILE *  F,
const Dtk_ConstraintPtr &  inVal 
)
8557  {
8558  fprintf( F, "<Dtk_ConstraintPtr>\n" );
8559  if( inVal.IsNULL() == DTK_TRUE )
8560  fprintf( F, "Null" );
8561  else
8562  {
8563  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inVal->get_info() );
8564  Dtk_DumpXMLNamespace::Dtk_DumpXml_ConstraintTypeEnum( F, inVal->GetConstraintType(), L"ConstraintType" );
8565 
8566  const Dtk_Size_t nbConstraintValues = inVal->GetNumberOfConstraintValues();
8567  for( Dtk_Size_t i = 0; i < nbConstraintValues; ++i )
8568  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Constraint_ConstraintValue( F, inVal->GetConstraintValue( i ) );
8569 
8570  const Dtk_Size_t nbConstraintReferences = inVal->GetNumberOfConstraintReferences();
8571  for( Dtk_Size_t i = 0; i < nbConstraintReferences; ++i )
8572  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ConstraintReferencePtr( F, inVal->GetConstraintReference( i ) );
8573  }
8574  fprintf( F, "</Dtk_ConstraintPtr>\n" );
8575  return dtkNoError;
8576  }

◆ Dtk_DumpXml_Dtk_CurvePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_CurvePtr ( FILE *  F,
const Dtk_CurvePtr &  inCurve 
)
5947  {
5948  type_detk type;
5949  if( inCurve.IsNULL() )
5950  {
5951  return dtkErrorNullPointer;
5952  }
5953  fprintf( F, "<Dtk_CurvePtr>" );
5954  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inCurve->get_info() );
5955  // fprintf(F,"<Id>%d</Id>",inCurve->GetID());
5956 
5957  if( inCurve->IsTrimmed() )
5958  {
5959  fprintf( F, "<Domain>" );
5960 
5961  fprintf( F, "<UMin>%f</UMin>", inCurve->GetTrimUMin() );
5962  fprintf( F, "<UMax>%f</UMax>", inCurve->GetTrimUMax() );
5963 
5964  fprintf( F, "</Domain>" );
5965  }
5966 
5967 
5968 
5969  type = inCurve->get_type_detk();
5970  switch( type )
5971  {
5972  case DTK_TYPE_LINE:
5973  {
5974  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_LinePtr( F, Dtk_LinePtr::DtkDynamicCast( inCurve ) );
5975  break;
5976  }
5977  case DTK_TYPE_POLYLINE:
5978  {
5979  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_PolylinePtr( F, Dtk_PolylinePtr::DtkDynamicCast( inCurve ) );
5980  break;
5981  }
5982  case DTK_TYPE_NURBS_CURVE:
5983  {
5984  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NurbsCurvePtr( F, Dtk_NurbsCurvePtr::DtkDynamicCast( inCurve ) );
5985  break;
5986  }
5987  case DTK_TYPE_HYPERBOLA:
5988  {
5989  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_HyperbolaPtr( F, Dtk_HyperbolaPtr::DtkDynamicCast( inCurve ) );
5990  break;
5991  }
5992  case DTK_TYPE_PARABOLA:
5993  {
5994  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ParabolaPtr( F, Dtk_ParabolaPtr::DtkDynamicCast( inCurve ) );
5995  break;
5996  }
5997  case DTK_TYPE_CIRCLE:
5998  case DTK_TYPE_ELLIPSE:
5999  {
6000  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_EllipsePtr( F, Dtk_EllipsePtr::DtkDynamicCast( inCurve ) );
6001  break;
6002  }
6003  case DTK_TYPE_INTERSECTION_CURVE:
6004  case DTK_TYPE_SPCURVE:
6005  {
6006  //Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_IntersectCurvePtr( F, Dtk_IntersectCurvePtr::DtkDynamicCast( inCurve ) );
6007  type = type;
6008  break;
6009  }
6010  default:
6011  {
6012  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NurbsCurvePtr( F, Dtk_NurbsCurvePtr::DtkDynamicCast( inCurve->ToNurbs() ) );
6013  break;
6014  }
6015  }
6016  fprintf( F, "</Dtk_CurvePtr>" );
6017  return dtkNoError;
6018  }

◆ Dtk_DumpXml_DTK_DATUM_COMPOSING_RULE()

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

◆ Dtk_DumpXml_Dtk_DatumTargetPtr()

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

◆ Dtk_DumpXml_Dtk_dir()

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

◆ Dtk_DumpXml_Dtk_DrawingPtr()

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

◆ Dtk_DumpXml_DTK_FDT_MODIFIER()

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

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

◆ Dtk_DumpXml_Dtk_FeaturePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_FeaturePtr ( FILE *  F,
const Dtk_FeaturePtr &  inVal 
)
8376  {
8377  fprintf( f, "<Dtk_FeaturePtr>\n" );
8378  fprintf( f, "<FeatId>%d</FeatId>\n", inToWrite->GetId() );
8379  if( inToWrite->name.len() )
8380  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( f, L"Name", inToWrite->GetName() );
8381  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( f, L"Type", inToWrite->GetTypeAsString() );
8382  fprintf( f, "<IsActive>%d</IsActive>\n", inToWrite->IsActive() );
8383 
8384  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetInputGeometry(), "InputGeometry" );
8385  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetOutputGeometry(), "OutputGeometry" );
8386  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetAssociatedGeometry(), "AssociatedGeometry" );
8387  Dtk_DumpXml_FeatGeometry( f, inToWrite->GetFinalAssociatedGeometry(), "FinalAssociatedGeometry" );
8388 
8389  switch( inToWrite->GetType() )
8390  {
8391  case DTK_FEAT_HOLE:
8392  Dtk_DumpXml_FeatHole( f, inToWrite->GetHole() );
8393  break;
8394  // case DTK_FEAT_HOLE_SERIES :
8395  // Dtk_DumpXml_FeatHoleSeries(f,inToWrite->GetHoleSeries());
8396  // break;
8397  // case DTK_FEAT_UDF :
8398  // Dtk_DumpXml_FeatUDF(f,inToWrite->GetUdf());
8399  // break;
8400  case DTK_FEAT_THREAD:
8401  Dtk_DumpXml_FeatThread( f, inToWrite->GetThread() );
8402  break;
8403  // case DTK_FEAT_PRISM :
8404  // Dtk_DumpXml_FeatPrism(f, inToWrite->GetPrism());
8405  // break;
8406  // case DTK_FEAT_REVOL :
8407  // Dtk_DumpXml_FeatRevol (f, inToWrite->GetRevol());
8408  // break;
8409  // case DTK_FEAT_SHELL:
8410  // Dtk_DumpXml_FeatShell (f, inToWrite->GetRevol());
8411  // break;
8412  // case DTK_FEAT_FILLET:
8413  // Dtk_DumpXml_FeatFillet (f, inToWrite->GetRevol());
8414  // break;
8415  // case DTK_FEAT_SWEEP:
8416  // Dtk_DumpXml_FeatSweep (f, inToWrite->GetRevol());
8417  // break;
8418  // case DTK_FEAT_CHAMFER:
8419  // Dtk_DumpXml_FeatChamfer (f, inToWrite->GetRevol());
8420  // break;
8421  // case DTK_FEAT_SPLIT_SURF:
8422  // Dtk_DumpXml_FeatSplitSurf (f, inToWrite->GetRevol());
8423  // break;
8424  // case DTK_FEAT_THICK_SURF:
8425  // Dtk_DumpXml_FeatThickSurf (f, inToWrite->GetRevol());
8426  // break;
8427  // case DTK_FEAT_SEW_SURF:
8428  // Dtk_DumpXml_FeatSewSurf (f, inToWrite->GetRevol());
8429  // break;
8430  // case DTK_FEAT_CLOSE_SURF:
8431  // Dtk_DumpXml_FeatCloseSurf(f, inToWrite->GetRevol());
8432  // break;
8433  case DTK_FEAT_PATTERN:
8434  Dtk_DumpXml_FeatPattern( f, inToWrite->GetPattern() );
8435  break;
8436  // case DTK_FEAT_USER_PATTERN:
8437  // Dtk_DumpXml_FeatUserPattern (f, inToWrite->GetRevol());
8438  // break;
8439  // case DTK_FEAT_MIRROR:
8440  // Dtk_DumpXml_FeatMirror(f, inToWrite->GetRevol());
8441  // break;
8442  // case DTK_FEAT_DRAFT :
8443  // Dtk_DumpXml_FeatDraft(f, inToWrite->GetRevol());
8444  // break;
8445  // case DTK_FEAT_TRANSLATE:
8446  // break;
8447  // case DTK_FEAT_ROTATE:
8448  // break;
8449  // case DTK_FEAT_REMOVE_FACE :
8450  // break;
8451  // case DTK_FEAT_STIFFENER:
8452  // break;
8453  // case DTK_FEAT_FACE_FILLET:
8454  // break;
8455  // case DTK_FEAT_TRITANGENT_FILLET:
8456  // break;
8457  // case DTK_FEAT_MULTI_PAD:
8458  // break;
8459  // case DTK_FEAT_MULTI_POCKET:
8460  // break;
8461  // case DTK_FEAT_LOFT:
8462  // break;
8463  // case DTK_FEAT_THICKNESS:
8464  // break;
8465  // case DTK_FEAT_SCALING:
8466  // break;
8467  // case DTK_FEAT_USER_DEFINED:
8468  // Dtk_DumpXml_FeatUserDefined (f, inToWrite->GetUserDefined());
8469  // break;
8470  // case DTK_FEAT_PIPE:
8471  // Dtk_DumpXml_FeatPipe (f, inToWrite->GetPipe());
8472  // break;
8473  // case DTK_FEAT_SPOT_POINT:
8474  // Dtk_DumpXml_FeatSpotPoint(f, inToWrite->GetSpotPoint());
8475  // break;
8476 
8477  default:
8478  break;
8479  }
8480  fprintf( f, "</Dtk_FeaturePtr>\n" );
8481  return dtkNoError;
8482  }

◆ Dtk_DumpXml_Dtk_GeometricalTolerancePtr()

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

◆ Dtk_DumpXml_Dtk_GraphicalDataPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_GraphicalDataPtr ( FILE *  F,
const Dtk_GraphicalDataPtr &  inVal 
)
8579  {
8580  if( inGraphicalData.IsNULL() )
8581  return dtkErrorNullPointer;
8582  int nbt = 0;
8583  int i, nb = ( int )inGraphicalData->GetNumMeshes();
8584  for( i = 0; i < nb; i++ )
8585  {
8586  Dtk_MeshPtr me = inGraphicalData->GetMesh( i );
8587  Dtk_DumpXml_Dtk_MeshPtr( F, me );
8588  }
8589  nbt = nb;
8590  nb = ( int )inGraphicalData->GetNumDrawings();
8591  nbt += nb;
8592  for( i = 0; i < nb; i++ )
8593  {
8594  Dtk_DrawingPtr dr = inGraphicalData->GetDrawing( i );
8595  Dtk_DumpXml_Dtk_DrawingPtr( F, dr );
8596  }
8597  Dtk_CameraPtr defcam = inGraphicalData->GetDefaultCamera();
8598  if( defcam.IsNotNULL() )
8599  {
8600  Dtk_DumpXml_Dtk_CameraPtr( F, defcam );
8601  }
8602  if( nbt == 0 )
8603  return dtkWarningNoEntitiesWritten;
8604  else
8605  return dtkNoError;
8606  }

◆ Dtk_DumpXml_Dtk_GridPtr()

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

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

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

◆ Dtk_DumpXml_Dtk_KinematicsCommand()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCommand ( FILE *  inFile,
const Dtk_KinCommandPtr &  inCommand,
Dtk_bool  simplified 
)
7616  {
7617  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7618  if( inFile == NULL )
7619  return dtkErrorNullPointer;
7620 
7621  fprintf( inFile, "<command name=\"%s\" id=\"%d\">\n", inCommand->getName().c_str(), inCommand->getId() );
7622  if( simplified == DTK_FALSE )
7623  {
7624  fprintf( inFile, "<attributCommand type=\"%d\" value=\"%f\"/>\n", inCommand->getType(), inCommand->getValue() );
7625  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, inCommand->getJoint(), DTK_TRUE );
7626  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inCommand->getParameter() );
7627  }
7628  fprintf( inFile, "</command>\n" );
7629 
7630  return dtkErrorStatus;
7631  }

◆ Dtk_DumpXml_Dtk_KinematicsConstraint()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsConstraint ( FILE *  inFile,
const Dtk_KinConstraintPtr &  inConstraint,
Dtk_bool  simplified 
)
7408  {
7409  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7410  if( inFile == NULL )
7411  return dtkErrorNullPointer;
7412 
7413  Dtk_Size_t i, nbVal;
7414 
7415  const Dtk_string inConstraintName = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inConstraint->getName() );
7416  fprintf( inFile, "<constraint name=\"%s\" id=\"%d\">\n", inConstraintName.c_str(), inConstraint->getId() );
7417  if( simplified == DTK_FALSE )
7418  {
7419  if( inConstraint->hasAttribute( inConstraint->_MODE_INTEGER ) ||
7420  inConstraint->hasAttribute( inConstraint->_VALUE ) ||
7421  inConstraint->hasAttribute( inConstraint->_ORIENTATION ) ||
7422  inConstraint->hasAttribute( inConstraint->_REFERENCE ) ||
7423  inConstraint->hasAttribute( inConstraint->_POSITION ) )
7424  {
7425  fprintf( inFile, "<attributConstraint" );
7426  if( inConstraint->hasAttribute( inConstraint->_MODE_INTEGER ) )
7427  {
7428  fprintf( inFile, " modeInteger=\"%d\"", inConstraint->getModeInteger() );
7429  }
7430  if( inConstraint->hasAttribute( inConstraint->_VALUE ) )
7431  {
7432  fprintf( inFile, " value=\"%f\"", inConstraint->getValue()->getNamedValue()->getValue() );
7433  }
7434  if( inConstraint->hasAttribute( inConstraint->_ORIENTATION ) )
7435  {
7436  fprintf( inFile, " orientation=\"%f\"", inConstraint->getOrientation()->getNamedValue()->getValue() );
7437  }
7438  if( inConstraint->hasAttribute( inConstraint->_REFERENCE ) )
7439  {
7440  fprintf( inFile, " fixInSpace=\"%.0f\"", inConstraint->getReference()->getNamedValue()->getValue() );
7441  }
7442  fprintf( inFile, ">\n" );
7443  if( inConstraint->hasAttribute( inConstraint->_POSITION ) )
7444  {
7445  fprintf( inFile, "<matricePosition nbValue=\"12\"" );
7446  DumpTransfo( inFile, inConstraint->getPosition() );
7447  fprintf( inFile, "/>\n" );
7448  }
7449  fprintf( inFile, "</attributConstraint>\n" );
7450  }
7451  nbVal = inConstraint->getConnectorSize();
7452  if( nbVal > 0 )
7453  {
7454  fprintf( inFile, "<connectors>\n" );
7455  for( i = 0; i < nbVal; i++ )
7456  {
7457  Dtk_DumpXml_Dtk_NodeConnector( inFile, inConstraint->getConnector( i ) );
7458  }
7459  fprintf( inFile, "</connectors>\n" );
7460  }
7461  }
7462  fprintf( inFile, "</constraint>\n" );
7463 
7464  return dtkErrorStatus;
7465  }

◆ Dtk_DumpXml_Dtk_KinematicsCurve()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCurve ( FILE *  inFile,
const Dtk_KinCurvePtr &  inCurve 
)
7349  {
7350  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7351  if( inFile == NULL )
7352  return dtkErrorNullPointer;
7353 
7354  fprintf( inFile, "<curve fileName=\"%s\" idBlock=\"%d\"/>\n", inCurve->getFileName().c_str(), inCurve->getIdBlock() );
7355 
7356  return dtkErrorStatus;
7357  }

◆ Dtk_DumpXml_Dtk_KinematicsFixPart()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFixPart ( FILE *  inFile,
const Dtk_KinFixPartPtr &  inFixPart 
)
7634  {
7635  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7636  if( inFile == NULL )
7637  return dtkErrorNullPointer;
7638 
7639  fprintf( inFile, "<fixPart name=\"%s\" id=\"%d\">\n", inFixPart->getName().c_str(), inFixPart->getId() );
7640  if( inFixPart->getConstraint().IsNotNULL() )
7641  {
7642  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, inFixPart->getConstraint(), DTK_TRUE );
7643  }
7644  if( inFixPart->getPart().IsNotNULL() )
7645  {
7646  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inFixPart->getPart() );
7647  }
7648  fprintf( inFile, "</fixPart>\n" );
7649 
7650  return dtkErrorStatus;
7651  }

◆ Dtk_DumpXml_Dtk_KinematicsFormula()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFormula ( FILE *  inFile,
const Dtk_KinFormulaPtr &  inFormula 
)
7360  {
7361  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7362  if( inFile == NULL )
7363  return dtkErrorNullPointer;
7364 
7365  fprintf( inFile, "<formula name=\"%s\" id=\"%d\">\n", inFormula->getName().c_str(), inFormula->getId() );
7366  fprintf( inFile, "<attributFormula" );
7367  fprintf( inFile, " comment=\"%s\"", inFormula->getComment().c_str() );
7368  fprintf( inFile, " formula=\"%s\"", inFormula->getFormula().c_str() );
7369  fprintf( inFile, " parameter=\"%s\"/>\n", inFormula->getParam().c_str() );
7370  fprintf( inFile, "</formula>\n" );
7371 
7372  return dtkErrorStatus;
7373  }

◆ Dtk_DumpXml_Dtk_KinematicsJoint()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsJoint ( FILE *  inFile,
const Dtk_KinJointPtr &  inJoint,
Dtk_bool  simplified 
)
7468  {
7469  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7470  if( inFile == NULL )
7471  return dtkErrorNullPointer;
7472 
7473  Dtk_Size_t i, nb;
7474  Dtk_KinConstraintPtr constraint;
7475 
7476  fprintf( inFile, "<joint name=\"%s\" id=\"%d\">\n", inJoint->getName().c_str(), inJoint->getId() );
7477  if( simplified == DTK_FALSE )
7478  {
7479  fprintf( inFile, "<attributJoint type=\"%d\"", inJoint->getType() );
7480  if( inJoint->hasAttribute( L"_compoundType" ) )
7481  {
7482  fprintf( inFile, " compoundType=\"%d\"", inJoint->getCompoundType() );
7483  }
7484  if( inJoint->hasAttribute( inJoint->_PARAMETER1 ) )
7485  {
7486  fprintf( inFile, " parameter1=\"%f\"", inJoint->getParameter1() );
7487  }
7488  if( inJoint->hasAttribute( inJoint->_PARAMETER2 ) )
7489  {
7490  fprintf( inFile, " parameter2=\"%f\"", inJoint->getParameter2() );
7491  }
7492  if( inJoint->hasAttribute( inJoint->_RATIO ) )
7493  {
7494  fprintf( inFile, " ratio=\"%f\"", inJoint->getRatio() );
7495  }
7496  fprintf( inFile, ">\n" );
7497  if( inJoint->hasAttribute( inJoint->_UPPER_LIMIT1 ) ||
7498  inJoint->hasAttribute( inJoint->_LOWER_LIMIT1 ) ||
7499  inJoint->hasAttribute( inJoint->_UPPER_LIMIT2 ) ||
7500  inJoint->hasAttribute( inJoint->_LOWER_LIMIT2 ) )
7501  {
7502  fprintf( inFile, "<limit" );
7503  if( inJoint->hasAttribute( inJoint->_UPPER_LIMIT1 ) )
7504  {
7505  fprintf( inFile, " upperLimit1=\"%f\"", inJoint->getUpperLimit1() );
7506  }
7507  if( inJoint->hasAttribute( inJoint->_LOWER_LIMIT1 ) )
7508  {
7509  fprintf( inFile, " lowerLimit1=\"%f\"", inJoint->getLowerLimit1() );
7510  }
7511  if( inJoint->hasAttribute( inJoint->_UPPER_LIMIT2 ) )
7512  {
7513  fprintf( inFile, " upperLimit2=\"%f\"", inJoint->getUpperLimit2() );
7514  }
7515  if( inJoint->hasAttribute( inJoint->_LOWER_LIMIT2 ) )
7516  {
7517  fprintf( inFile, " lowerLimit2=\"%f\"", inJoint->getLowerLimit2() );
7518  }
7519  fprintf( inFile, "/>\n" );
7520  }
7521  fprintf( inFile, "<localFrame1 nbValue=\"12\"" );
7522  DumpTransfo( inFile, inJoint->getLocalFrame1() );
7523  fprintf( inFile, "/>\n" );
7524  fprintf( inFile, "<localFrame2 nbValue=\"12\"" );
7525  DumpTransfo( inFile, inJoint->getLocalFrame2() );
7526  fprintf( inFile, "/>\n" );
7527  if( inJoint->hasAttribute( inJoint->_LOCAL_FRAME3 ) )
7528  {
7529  fprintf( inFile, "<localFrame3 nbValue=\"12\"" );
7530  DumpTransfo( inFile, inJoint->getLocalFrame3() );
7531  fprintf( inFile, "/>\n" );
7532  }
7533  if( inJoint->hasAttribute( inJoint->_LOCAL_FRAME4 ) )
7534  {
7535  fprintf( inFile, "<localFrame4 nbValue=\"12\"" );
7536  DumpTransfo( inFile, inJoint->getLocalFrame4() );
7537  fprintf( inFile, "/>\n" );
7538  }
7539  if( inJoint->hasAttribute( inJoint->_ABSOLUT_POS1 ) )
7540  {
7541  fprintf( inFile, "<absolutePos1 nbValue=\"12\"" );
7542  DumpTransfo( inFile, inJoint->getAbsolutPos1() );
7543  fprintf( inFile, "/>\n" );
7544  }
7545  if( inJoint->hasAttribute( inJoint->_ABSOLUT_POS2 ) )
7546  {
7547  fprintf( inFile, "<absolutePos2 nbValue=\"12\"" );
7548  DumpTransfo( inFile, inJoint->getAbsolutPos2() );
7549  fprintf( inFile, "/>\n" );
7550  }
7551  fprintf( inFile, "</attributJoint>\n" );
7552  fprintf( inFile, "<parts>\n" );
7553  if( inJoint->hasAttribute( L"_part1" ) )
7554  {
7555  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inJoint->getPart1() );
7556  }
7557  if( inJoint->hasAttribute( L"_part2" ) )
7558  {
7559  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inJoint->getPart2() );
7560  }
7561  if( inJoint->hasAttribute( inJoint->_PART3 ) )
7562  {
7563  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inJoint->getPart3() );
7564  }
7565  fprintf( inFile, "</parts>\n" );
7566  if( inJoint->hasAttribute( inJoint->_CONSTRAINT ) )
7567  {
7568  fprintf( inFile, "<constraints>\n" );
7569  nb = inJoint->getConstraintSize();
7570  for( i = 0; i < nb; i++ )
7571  {
7572  constraint = inJoint->getConstraint( i );
7573  Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, constraint, DTK_TRUE );
7574  }
7575  fprintf( inFile, "</constraints>\n" );
7576  }
7577  if( inJoint->hasAttribute( inJoint->_CONNECTOR ) )
7578  {
7579  fprintf( inFile, "<connectors>\n" );
7580  nb = inJoint->getConnectorSize();
7581  for( i = 0; i < nb; i++ )
7582  {
7583  Dtk_DumpXml_Dtk_NodeConnector( inFile, inJoint->getConnector( i ) );
7584  }
7585  fprintf( inFile, "</connectors>\n" );
7586  }
7587  if( inJoint->hasAttribute( inJoint->_FIX_TOGETHER ) )
7588  {
7589  fprintf( inFile, "<fixTogether>\n" );
7590  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, inJoint->getFixTogether(), DTK_TRUE );
7591  fprintf( inFile, "</fixTogether>\n" );
7592  }
7593  if( inJoint->hasAttribute( inJoint->_RATIO_PARAMETER ) )
7594  {
7595  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inJoint->getRatioParameter() );
7596  }
7597  if( inJoint->hasAttribute( inJoint->_JOINT1 ) || inJoint->hasAttribute( inJoint->_JOINT2 ) )
7598  {
7599  fprintf( inFile, "<joints>\n" );
7600  if( inJoint->hasAttribute( inJoint->_JOINT1 ) )
7601  {
7602  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, inJoint->getJoint1(), DTK_TRUE );
7603  }
7604  if( inJoint->hasAttribute( inJoint->_JOINT2 ) )
7605  {
7606  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, inJoint->getJoint2(), DTK_TRUE );
7607  }
7608  fprintf( inFile, "</joints>\n" );
7609  }
7610  }
7611  fprintf( inFile, "</joint>\n" );
7612  return dtkNoError;
7613  }

◆ Dtk_DumpXml_Dtk_KinematicsLaw()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsLaw ( FILE *  inFile,
const Dtk_KinLawPtr &  inLaw 
)
7376  {
7377  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7378  if( inFile == NULL )
7379  return dtkErrorNullPointer;
7380 
7381  Dtk_Size_t i, nb;
7382 
7383  fprintf( inFile, "<law name=\"%s\" id=\"%d\">\n", inLaw->getName().c_str(), inLaw->getId() );
7384  fprintf( inFile, "<attributLaw comment=\"%s\" synchrone=\"%d\" active=\"%d\" algo=\"%d\"/>\n", inLaw->getComment().c_str(), inLaw->getSynchrone(), inLaw->getActive(), inLaw->getAlgo() );
7385  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsFormula( inFile, inLaw->getExpression() );
7386 
7387  if( inLaw->getCurveSize() + inLaw->getParameter().size() > 0 )
7388  {
7389  fprintf( inFile, "<parameters>\n" );
7390  nb = inLaw->getCurveSize();
7391  for( i = 0; i < nb; i++ )
7392  {
7393  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsCurve( inFile, inLaw->getCurve( i ) );
7394  }
7395  nb = inLaw->getParameter().size();
7396  for( i = 0; i < nb; i++ )
7397  {
7398  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inLaw->getParameter().at( i ), DTK_TRUE );
7399  }
7400  fprintf( inFile, "</parameters>\n" );
7401  }
7402  fprintf( inFile, "</law>\n" );
7403 
7404  return dtkNoError;
7405  }

◆ Dtk_DumpXml_Dtk_KinematicsMechanism()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsMechanism ( FILE *  inFile,
const Dtk_KinMechanismPtr &  inKinMechanism 
)
7718  {
7719  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7720  if( inFile == NULL )
7721  return dtkErrorNullPointer;
7722 
7723  Dtk_Size_t i, nbElt;
7724  Dtk_KinJointPtr joint;
7725  Dtk_KinCommandPtr cmd;
7726  Dtk_KinFixPartPtr fixPart;
7727 
7728  fprintf( inFile, "<mechanism name=\"%s\" id=\"%d\" version=\"%s\">\n", inKinMechanism->getName().c_str(), inKinMechanism->getId(), inKinMechanism->getVersion().c_str() );
7729 
7730  // Dump Mechanism joints
7731  fprintf( inFile, "<joints>\n" );
7732  nbElt = inKinMechanism->getJointSize();
7733  for( i = 0; i < nbElt; i++ )
7734  {
7735  joint = inKinMechanism->getJoint( i );
7736  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, joint, DTK_TRUE );
7737  }
7738  fprintf( inFile, "</joints>\n" );
7739 
7740  // Dump Mechanism commands
7741  fprintf( inFile, "<commands>\n" );
7742  nbElt = inKinMechanism->getCommandSize();
7743  for( i = 0; i < nbElt; i++ )
7744  {
7745  cmd = inKinMechanism->getCommand( i );
7746  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsCommand( inFile, cmd, DTK_TRUE );
7747  }
7748  fprintf( inFile, "</commands>\n" );
7749 
7750  // Dump Mechanism fix part
7751  fixPart = inKinMechanism->getFixPart();
7752  if( fixPart.IsNotNULL() )
7753  {
7754  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsFixPart( inFile, fixPart );
7755  }
7756 
7757  // Dump Mechanism time parameter
7758  fprintf( inFile, "<paramTime>\n" );
7759  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inKinMechanism->getParamTime() );
7760  fprintf( inFile, "</paramTime>\n" );
7761 
7762  // Dump Mechanism laws
7763  nbElt = inKinMechanism->getLawSize();
7764  if( nbElt > 0 )
7765  {
7766  fprintf( inFile, "<laws>\n" );
7767  for( i = 0; i < nbElt; i++ )
7768  {
7769  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsLaw( inFile, inKinMechanism->getLaw( i ) );
7770  }
7771  fprintf( inFile, "</laws>\n" );
7772  }
7773 
7774  // Dump Mechanism Speed Acceleration
7775  nbElt = inKinMechanism->getSpeedAccelerationSize();
7776  if( nbElt > 0 )
7777  {
7778  fprintf( inFile, "<speedsAccelerations>\n" );
7779  for( i = 0; i < nbElt; i++ )
7780  {
7781  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration( inFile, inKinMechanism->getSpeedAcceleration( i ) );
7782  }
7783  fprintf( inFile, "</speedsAccelerations>\n" );
7784  }
7785  fprintf( inFile, "</mechanism>\n" );
7786 
7787  return dtkErrorStatus;
7788  }

◆ Dtk_DumpXml_Dtk_KinematicsNamedValue()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsNamedValue ( FILE *  inFile,
const Dtk_KinNamedValuePtr &  inNamedValue 
)
7115  {
7116  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7117  if( inFile == NULL )
7118  return dtkErrorNullPointer;
7119 
7120  fprintf( inFile, "<namedValue name=\"%s\" value=\"%f\"/>\n", inNamedValue->getName().c_str(), inNamedValue->getValue() );
7121  return dtkErrorStatus;
7122  }

◆ Dtk_DumpXml_Dtk_KinematicsParameter()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsParameter ( FILE *  inFile,
const Dtk_KinParameterPtr &  inParameter,
Dtk_bool  simplified = DTK_FALSE 
)
7125  {
7126  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7127  if( inFile == NULL )
7128  return dtkErrorNullPointer;
7129 
7130  int i;
7131 
7132  fprintf( inFile, "<parameter name=\"%s\" id=\"%d\"", inParameter->getName().c_str(), inParameter->getId() );
7133  if( simplified == DTK_TRUE )
7134  {
7135  Dtk_string tmp;
7136  switch( inParameter->getParentType() )
7137  {
7138  case DTK_KIN_TYPE_COMMAND:
7139  tmp.convert_from_int( ( ( Dtk_KinCommand * )inParameter->getParentElement() )->getId() );
7140  tmp += L"_COMMAND";
7141  break;
7142  case DTK_KIN_TYPE_JOINT:
7143  tmp.convert_from_int( ( ( Dtk_KinJoint * )inParameter->getParentElement() )->getId() );
7144  tmp += L"_JOINT";
7145  break;
7146  case DTK_KIN_TYPE_MECHANISM:
7147  tmp.convert_from_int( ( ( Dtk_KinMechanism * )inParameter->getParentElement() )->getId() );
7148  tmp += L"_MECHANISM";
7149  break;
7150  case DTK_KIN_TYPE_LAW:
7151  tmp.convert_from_int( ( ( Dtk_KinLaw * )inParameter->getParentElement() )->getId() );
7152  tmp += L"_LAW";
7153  break;
7154  case DTK_KIN_TYPE_SPEED_ACCELERATION:
7155  tmp.convert_from_int( ( ( Dtk_KinSpeedAcceleration * )inParameter->getParentElement() )->getId() );
7156  tmp += L"_SPEED_ACCELERATION";
7157  break;
7158  default:
7159  tmp = L"DTK_UNKNOWN";
7160  break;
7161  }
7162  fprintf( inFile, " parent=\"%s\"", tmp.c_str() );
7163  }
7164  fprintf( inFile, ">\n" );
7165  if( simplified == DTK_FALSE )
7166  {
7167  if( inParameter->hasAttribute( inParameter->_RANGE ) )
7168  {
7169  fprintf( inFile, "<range nbValue=\"4\"" );
7170  for( i = 0; i < 4; i++ )
7171  {
7172  fprintf( inFile, " _%d=\"%f\"", i + 1, inParameter->getRange( i ) );
7173  }
7174  fprintf( inFile, "/>\n" );
7175  }
7176  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsNamedValue( inFile, inParameter->getNamedValue() );
7177  }
7178  fprintf( inFile, "</parameter>\n" );
7179 
7180  return dtkErrorStatus;
7181  }

◆ Dtk_DumpXml_Dtk_KinematicsProduct()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsProduct ( FILE *  inFile,
const Dtk_KinProductPtr &  inKinProduct,
int &  inKinProductIndex 
)
7654  {
7655  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7656  if( inFile == NULL )
7657  return dtkErrorNullPointer;
7658 
7659  Dtk_Size_t i, nb;
7660  Dtk_KinPartPtr part;
7661  Dtk_KinProductPtr prod;
7662  Dtk_string xmlName, productName, instanceName, fileName;
7663  Dtk_status tempDst;
7664 
7665  fprintf( inFile, "<product" );
7666  productName = inKinProduct->name();
7667  if( productName.is_not_NULL() )
7668  {
7669  xmlName = productName;
7670  tempDst = validate_xml_string( xmlName );
7671  fprintf( inFile, " name=\"%s\"", xmlName.c_str() );
7672  }
7673  fprintf( inFile, " id=\"%d\"", inKinProduct->id() );
7674 
7675  instanceName = inKinProduct->instanceName();
7676  if( instanceName.is_not_NULL() )
7677  {
7678  xmlName = instanceName;
7679  tempDst = validate_xml_string( xmlName );
7680  fprintf( inFile, " instanceName=\"%s\"", xmlName.c_str() );
7681  }
7682  fileName = inKinProduct->fileName();
7683  if( fileName.is_not_NULL() )
7684  {
7685  xmlName = fileName;
7686  tempDst = validate_xml_string( xmlName );
7687  fprintf( inFile, " fileName=\"%s\"", xmlName.c_str() );
7688  }
7689 
7690  fprintf( inFile, ">\n<components>\n" );
7691  nb = inKinProduct->getNbPart();
7692  nb += inKinProduct->getNbProduct();
7693  part = NULL;
7694  prod = NULL;
7695  for( i = 0; i < nb; i++ )
7696  {
7697  inKinProductIndex++;
7698  prod = inKinProduct->searchProductByNumChild( inKinProductIndex );
7699  if( part.IsNotNULL() )
7700  {
7701  Dtk_DumpXml_Dtk_ComponentPtr( inFile, part );
7702  part = NULL;
7703  }
7704  if( prod.IsNotNULL() )
7705  {
7706  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsProduct( inFile, prod, inKinProductIndex );
7707  prod = NULL;
7708  }
7709  }
7710 
7711  fprintf( inFile, "</components>\n" );
7712  fprintf( inFile, "</product>\n" );
7713 
7714  return dtkNoError;
7715  }

◆ Dtk_DumpXml_Dtk_KinematicsPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsPtr ( FILE *  inFile,
const Dtk_KinematicPtr &  inKinematic 
)
7791  {
7792  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7793  if( inFile == NULL )
7794  return dtkErrorNullPointer;
7795 
7796  Dtk_Size_t size, i;
7797  Dtk_KinPartPtr part;
7798  Dtk_KinConstraintPtr constraint;
7799  Dtk_KinJointPtr joint;
7800  Dtk_KinCommandPtr command;
7801  Dtk_KinMechanismPtr mechanism;
7802  Dtk_status dstat;
7803 
7804  fprintf( inFile, "<kinematics>\n" );
7805 
7806  // Dump Kinematics Product
7807  if( inKinematic->getProduct().IsNotNULL() )
7808  {
7809  int iProductIndex = 0;
7810  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsProduct( inFile, inKinematic->getProduct(), iProductIndex );
7811  }
7812 
7813  // Dump Kinematics Parts
7814  fprintf( inFile, "<parts>\n" );
7815  size = inKinematic->getPartSize();
7816  for( i = 0; i < size; i++ )
7817  {
7818  part = inKinematic->getPart( i );
7819  Dtk_DumpXml_Dtk_ComponentPtr( inFile, part );
7820  if( dstat.isNotOK() )
7821  {
7822  return dtkErrorUnspecified;
7823  }
7824  }
7825  fprintf( inFile, "</parts>\n" );
7826 
7827  // Dump kinematics Constraints
7828  fprintf( inFile, "<constraints>\n" );
7829  size = inKinematic->getConstraintSize();
7830  for( i = 0; i < size; i++ )
7831  {
7832  constraint = inKinematic->getConstraint( i );
7833  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsConstraint( inFile, constraint, DTK_FALSE );
7834  if( dtkErrorStatus != dtkNoError )
7835  {
7836  return dtkErrorStatus;
7837  }
7838  }
7839  fprintf( inFile, "</constraints>\n" );
7840 
7841  // Dump kinematics Joints
7842  fprintf( inFile, "<joints>\n" );
7843  size = inKinematic->getJointSize();
7844  for( i = 0; i < size; i++ )
7845  {
7846  joint = inKinematic->getJoint( i );
7847  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsJoint( inFile, joint, DTK_FALSE );
7848  if( dtkErrorStatus != dtkNoError )
7849  {
7850  return dtkErrorStatus;
7851  }
7852  }
7853  fprintf( inFile, "</joints>\n" );
7854 
7855  // Dump kinematics commands
7856  fprintf( inFile, "<commands>\n" );
7857  size = inKinematic->getCommandSize();
7858  for( i = 0; i < size; i++ )
7859  {
7860  command = inKinematic->getCommand( i );
7861  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsCommand( inFile, command, DTK_FALSE );
7862  if( dtkErrorStatus != dtkNoError )
7863  {
7864  return dtkErrorStatus;
7865  }
7866  }
7867  fprintf( inFile, "</commands>\n" );
7868 
7869  // Dump kinematics commands
7870  fprintf( inFile, "<mechanisms>\n" );
7871  size = inKinematic->getMechanismSize();
7872  for( i = 0; i < size; i++ )
7873  {
7874  mechanism = inKinematic->getMechanism( i );
7875  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsMechanism( inFile, mechanism );
7876  if( dtkErrorStatus != dtkNoError )
7877  {
7878  return dtkErrorStatus;
7879  }
7880  }
7881  fprintf( inFile, "</mechanisms>\n" );
7882 
7883  fprintf( inFile, "</kinematics>\n" );
7884  return dtkErrorStatus;
7885  }

◆ Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration ( FILE *  inFile,
const Dtk_KinSpeedAccelerationPtr &  inSpeedAcceleration 
)
7184  {
7185  Dtk_ErrorStatus dtkErrorStatus = dtkNoError;
7186  if( inFile == NULL )
7187  return dtkErrorNullPointer;
7188 
7189  fprintf( inFile, "<speedAcceleration name=\"%s\" id=\"%d\">\n", inSpeedAcceleration->getName().c_str(), inSpeedAcceleration->getId() );
7190 
7191  if( inSpeedAcceleration->getRefProd().IsNotNULL() )
7192  {
7193  fprintf( inFile, "<refProd>\n" );
7194  Dtk_DumpXml_Dtk_ComponentPtr( inFile, inSpeedAcceleration->getRefProd() );
7195  fprintf( inFile, "</refProd>\n" );
7196  }
7197  if( inSpeedAcceleration->getPoint().IsNotNULL() )
7198  {
7199  fprintf( inFile, "<point>\n" );
7200  Dtk_DumpXml_Dtk_NodeConnector( inFile, inSpeedAcceleration->getPoint() );
7201  fprintf( inFile, "</point>\n" );
7202  }
7203 
7204  if( inSpeedAcceleration->getPtX().IsNotNULL() )
7205  {
7206  fprintf( inFile, "<pointX>\n" );
7207  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getPtX() );
7208  fprintf( inFile, "</pointX>\n" );
7209  }
7210  if( inSpeedAcceleration->getPtY().IsNotNULL() )
7211  {
7212  fprintf( inFile, "<pointY>\n" );
7213  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getPtY() );
7214  fprintf( inFile, "</pointY>\n" );
7215  }
7216  if( inSpeedAcceleration->getPtZ().IsNotNULL() )
7217  {
7218  fprintf( inFile, "<pointZ>\n" );
7219  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getPtZ() );
7220  fprintf( inFile, "</pointZ>\n" );
7221  }
7222 
7223  if( inSpeedAcceleration->getLinearSpeedX().IsNotNULL() )
7224  {
7225  fprintf( inFile, "<linearSpeedX>\n" );
7226  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeedX() );
7227  fprintf( inFile, "</linearSpeedX>\n" );
7228  }
7229  if( inSpeedAcceleration->getLinearSpeedY().IsNotNULL() )
7230  {
7231  fprintf( inFile, "<linearSpeedY>\n" );
7232  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeedY() );
7233  fprintf( inFile, "</linearSpeedY>\n" );
7234  }
7235  if( inSpeedAcceleration->getLinearSpeedZ().IsNotNULL() )
7236  {
7237  fprintf( inFile, "<linearSpeedZ>\n" );
7238  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeedZ() );
7239  fprintf( inFile, "</linearSpeedZ>\n" );
7240  }
7241  if( inSpeedAcceleration->getLinearSpeed().IsNotNULL() )
7242  {
7243  fprintf( inFile, "<linearSpeed>\n" );
7244  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearSpeed() );
7245  fprintf( inFile, "</linearSpeed>\n" );
7246  }
7247 
7248  if( inSpeedAcceleration->getLinearAccelerationX().IsNotNULL() )
7249  {
7250  fprintf( inFile, "<linearAccelerationX>\n" );
7251  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAccelerationX() );
7252  fprintf( inFile, "</linearAccelerationX>\n" );
7253  }
7254  if( inSpeedAcceleration->getLinearAccelerationY().IsNotNULL() )
7255  {
7256  fprintf( inFile, "<linearAccelerationY>\n" );
7257  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAccelerationY() );
7258  fprintf( inFile, "</linearAccelerationY>\n" );
7259  }
7260  if( inSpeedAcceleration->getLinearAccelerationZ().IsNotNULL() )
7261  {
7262  fprintf( inFile, "<linearAccelerationZ>\n" );
7263  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAccelerationZ() );
7264  fprintf( inFile, "</linearAccelerationZ>\n" );
7265  }
7266  if( inSpeedAcceleration->getLinearAcceleration().IsNotNULL() )
7267  {
7268  fprintf( inFile, "<linearAcceleration>\n" );
7269  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getLinearAcceleration() );
7270  fprintf( inFile, "</linearAcceleration>\n" );
7271  }
7272 
7273  if( inSpeedAcceleration->getAngularSpeedX().IsNotNULL() )
7274  {
7275  fprintf( inFile, "<angularSpeedX>\n" );
7276  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeedX() );
7277  fprintf( inFile, "</angularSpeedX>\n" );
7278  }
7279  if( inSpeedAcceleration->getAngularSpeedY().IsNotNULL() )
7280  {
7281  fprintf( inFile, "<angularSpeedY>\n" );
7282  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeedY() );
7283  fprintf( inFile, "</angularSpeedY>\n" );
7284  }
7285  if( inSpeedAcceleration->getAngularSpeedZ().IsNotNULL() )
7286  {
7287  fprintf( inFile, "<angularSpeedZ>\n" );
7288  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeedZ() );
7289  fprintf( inFile, "</angularSpeedZ>\n" );
7290  }
7291  if( inSpeedAcceleration->getAngularSpeed().IsNotNULL() )
7292  {
7293  fprintf( inFile, "<angularSpeed>\n" );
7294  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularSpeed() );
7295  fprintf( inFile, "</angularSpeed>\n" );
7296  }
7297 
7298  if( inSpeedAcceleration->getAngularAccelerationX().IsNotNULL() )
7299  {
7300  fprintf( inFile, "<angularAccelerationX>\n" );
7301  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAccelerationX() );
7302  fprintf( inFile, "</angularAccelerationX>\n" );
7303  }
7304  if( inSpeedAcceleration->getAngularAccelerationY().IsNotNULL() )
7305  {
7306  fprintf( inFile, "<angularAccelerationY>\n" );
7307  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAccelerationY() );
7308  fprintf( inFile, "</angularAccelerationY>\n" );
7309  }
7310  if( inSpeedAcceleration->getAngularAccelerationZ().IsNotNULL() )
7311  {
7312  fprintf( inFile, "<angularAccelerationZ>\n" );
7313  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAccelerationZ() );
7314  fprintf( inFile, "</angularAccelerationZ>\n" );
7315  }
7316  if( inSpeedAcceleration->getAngularAcceleration().IsNotNULL() )
7317  {
7318  fprintf( inFile, "<angularAcceleration>\n" );
7319  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getAngularAcceleration() );
7320  fprintf( inFile, "</angularAcceleration>\n" );
7321  }
7322 
7323  if( inSpeedAcceleration->getCirX().IsNotNULL() )
7324  {
7325  fprintf( inFile, "<cirX>\n" );
7326  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getCirX() );
7327  fprintf( inFile, "</cirX>\n" );
7328  }
7329  if( inSpeedAcceleration->getCirY().IsNotNULL() )
7330  {
7331  fprintf( inFile, "<cirY>\n" );
7332  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getCirY() );
7333  fprintf( inFile, "</cirY>\n" );
7334  }
7335  if( inSpeedAcceleration->getCirZ().IsNotNULL() )
7336  {
7337  fprintf( inFile, "<cirZ>\n" );
7338  dtkErrorStatus = Dtk_DumpXml_Dtk_KinematicsParameter( inFile, inSpeedAcceleration->getCirZ() );
7339  fprintf( inFile, "</cirZ>\n" );
7340  }
7341 
7342  fprintf( inFile, "</speedAcceleration>\n" );
7343 
7344  return dtkNoError;
7345  }

◆ Dtk_DumpXml_Dtk_LayerInfosSetPtr()

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

◆ Dtk_DumpXml_Dtk_LayerInfosSetPtr_Deprecated()

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

◆ Dtk_DumpXml_Dtk_LeaderPtr()

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

◆ Dtk_DumpXml_Dtk_MainDocPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MainDocPtr ( FILE *  F,
const Dtk_MainDocPtr &  inObject 
)
4576  {
4577  fprintf( F, "<Dtk_MainDocPtr>\n" );
4578  if( inObject.IsNotNULL() )
4579  {
4580  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_ComponentPtr( F, inObject->RootComponent() );
4581  }
4582  else
4583  {
4584  fprintf( F, "Null" );
4585  }
4586  fprintf( F, "</Dtk_MainDocPtr>\n" );
4587  return dtkNoError;
4588  }

◆ Dtk_DumpXml_Dtk_MeshPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshPtr ( FILE *  F,
const Dtk_MeshPtr &  inMesh 
)
6787  {
6788  Dtk_ID id = 0;
6789  if( inMesh->get_info().IsNotNULL() )
6790  id = inMesh->get_info()->GetId();
6791 
6792  fprintf( F, "<Dtk_MeshPtr>\n" );
6793  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inMesh->info() );
6794 
6795  Dtk_Size_t iVert, NbVert = inMesh->get_nb_vertices();
6796 
6797  fprintf( F, "<Vertices nb = \"" XmlFormat( "u" )"\">\n", NbVert );
6798  for( iVert = 0; iVert < NbVert; iVert++ )
6799  {
6800  Dtk_pnt pt = inMesh->get_vertex( iVert );
6801  fprintf( F, "<Vertex id = \"" XmlFormat( "u" )"\" X = \"%lf\" Y = \"%lf\" Z = \"%lf\">", iVert, pt[ 0 ], pt[ 1 ], pt[ 2 ] );
6802  fprintf( F, "</Vertex>\n" );
6803  }
6804  fprintf( F, "</Vertices>\n" );
6805 
6806 
6807  Dtk_Size_t NbMeshFaces = inMesh->get_nb_mesh_face();
6808  fprintf( F, "<MeshFaces nb =\"" XmlFormat( "u" )"\">\n", NbMeshFaces );
6809 
6810  for( Dtk_Size_t iMeshFace = 0; iMeshFace < NbMeshFaces; iMeshFace++ )
6811  {
6812  const Dtk_UInt32 *pnt;
6813  Dtk_mesh_face *curMeshFace = inMesh->get_mesh_face( iMeshFace );
6814  Dtk_Size_t NbTriangles = curMeshFace->get_nbtriangles();
6815  fprintf( F, "<Dtk_mesh_face>\n" );
6816  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, curMeshFace->info() );
6817  if( NbTriangles > 0 )
6818  {
6819  fprintf( F, "<Triangles nb = \"" XmlFormat( "u" )"\">\n", NbTriangles );
6820  for( Dtk_Size_t iTriangle = 0; iTriangle < NbTriangles; iTriangle++ )
6821  {
6822  pnt = curMeshFace->get_triangle_indices( iTriangle );
6823  fprintf( F, "<Triangle id = \"" XmlFormat( "u" )"\" vertices = \"%d , %d , %d\" >", iTriangle, pnt[ 0 ], pnt[ 1 ], pnt[ 2 ] );
6824  fprintf( F, "</Triangle>\n" );
6825  }
6826  fprintf( F, "</Triangles>\n" );
6827  }
6828 
6829  Dtk_Size_t NbTriFan = curMeshFace->get_nbtriangle_fans();
6830  if( NbTriFan > 0 )
6831  {
6832 
6833  fprintf( F, "<TriFans nb = \"" XmlFormat( "u" )"\">\n", NbTriFan );
6834  for( Dtk_Size_t iTriFanIdx = 0; iTriFanIdx < NbTriFan; iTriFanIdx++ )
6835  {
6836  const Dtk_tab<Dtk_ID> *tabIndices;
6837  tabIndices = curMeshFace->get_triangle_fan_indices( iTriFanIdx );
6838  fprintf( F, "<TriFan id = \"" XmlFormat( "u" )"\" indices = \" ", iTriFanIdx );
6839  for( int iIndex = 0; iIndex < tabIndices->size(); iIndex++ )
6840  {
6841  fprintf( F, "%d", ( *tabIndices )[ iIndex ] );
6842  if( iIndex < tabIndices->size() - 1 )
6843  {
6844  fprintf( F, " , " );
6845  }
6846  }
6847  fprintf( F, " \" >" );
6848  fprintf( F, "</TriFan>\n" );
6849  }
6850  fprintf( F, "</TriFans>\n" );
6851  }
6852 
6853  Dtk_Size_t NbTriStrip = curMeshFace->get_nbtriangle_strips();
6854  if( NbTriStrip > 0 )
6855  {
6856 
6857  fprintf( F, "<TriStrips nb = \"" XmlFormat( "u" )"\">\n", NbTriStrip );
6858  for( Dtk_Size_t iTriStripIdx = 0; iTriStripIdx < NbTriStrip; iTriStripIdx++ )
6859  {
6860  const Dtk_tab<Dtk_ID> *tabIndices;
6861  tabIndices = curMeshFace->get_triangle_strip_indices( iTriStripIdx );
6862  fprintf( F, "<TriStrip id = \"" XmlFormat( "u" )"\" indices = \" ", iTriStripIdx );
6863  for( int iIndex = 0; iIndex < tabIndices->size(); iIndex++ )
6864  {
6865  fprintf( F, "%d", ( *tabIndices )[ iIndex ] );
6866  if( iIndex < tabIndices->size() - 1 )
6867  {
6868  fprintf( F, " , " );
6869  }
6870  }
6871  fprintf( F, " \" >" );
6872  fprintf( F, "</TriStrip>\n" );
6873  }
6874  fprintf( F, "</TriStrips>\n" );
6875  }
6876 
6877  Dtk_Size_t NbPoly = curMeshFace->get_nbpolylines();
6878  if( NbPoly > 0 )
6879  {
6880  fprintf( F, "<Polylines nb =\"" XmlFormat( "u" )"\">\n", NbPoly );
6881  for( Dtk_Size_t iPoly = 0; iPoly < NbPoly; iPoly++ )
6882  {
6883  Dtk_Val dtk_val;
6884  int topoid = 0;
6885  if( curMeshFace->get_nbsubinfos() > 0 )
6886  {
6887  Dtk_InfoPtr inf = curMeshFace->get_subinfo( iPoly );
6888  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inf );
6889  if( inf->FindAttribute( "TOPO_ID_EDGE", dtk_val ) == dtkNoError )
6890  topoid = dtk_val.GetInt();
6891  }
6892 
6893  const Dtk_tab<Dtk_UInt32> *pntpol;
6894  pntpol = curMeshFace->get_polyline_indices( iPoly );
6895  Dtk_Size_t nbpnt;
6896  nbpnt = pntpol->size();
6897 
6898  fprintf( F, "<Polyline id = \"" XmlFormat( "u" )"\" idtopo = \"%i\" vertices = \"", iPoly, topoid );
6899  for( Dtk_Size_t j = 0; j < nbpnt; j++ )
6900  {
6901  fprintf( F, " %d , ", ( *pntpol )[ j ] );
6902  }
6903  fprintf( F, "\"></Polyline>\n" );
6904  }
6905  fprintf( F, "</Polylines>\n" );
6906  }
6907 
6908  fprintf( F, "</Dtk_mesh_face>\n" );
6909 
6910  }
6911  fprintf( F, "</MeshFaces>\n" );
6912 
6913  Dtk_StreamPtr stream;
6914  stream = inMesh->GetStream();
6915  if( stream.IsNotNULL() )
6916  {
6917  Dtk_Val val;
6918  if( inMesh->get_info()->FindAttribute( L"Dtk_NxIndexColor", val ) == dtkNoError )
6919  {
6920  Dtk_tab<Dtk_Int32> ArrayColor = val.GetIntArray();
6921 
6922  fprintf( F, "<Dtk_NxIndexColor Num=\'" XmlFormat( "u" ) "\'>\n", ArrayColor.size() );
6923 
6924  for( size_t i = 0; i < ArrayColor.size(); i++ )
6925  {
6926  Dtk_RGB rgb;
6927  Dtk_API::GetAPI()->GetColorInTable( ArrayColor[ i ], rgb );
6928  Dtk_DumpXml_Dtk_RGB( F, rgb );
6929  }
6930  fprintf( F, "</Dtk_NxIndexColor>\n" );
6931 
6932  }
6933  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_StreamPtr( F, stream );
6934  }
6935 
6936  fprintf( F, "</Dtk_MeshPtr>\n" );
6937 
6938  return dtkNoError;
6939 
6940  }

◆ Dtk_DumpXml_Dtk_MetadataGroupPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataGroupPtr ( FILE *  F,
const Dtk_MetaDataGroupPtr &  inObject 
)
5022  {
5023  if( F == NULL )
5024  {
5025  return dtkErrorOpenFiles;
5026  }
5027 
5028 
5029  fprintf( F, "<Dtk_MetaDataGroupPtr>\n" );
5030 
5031  if( inObject.IsNULL() )
5032  {
5033  fprintf( F, "'Null'" );
5034  fprintf( F, "</Dtk_MetaDataGroupPtr>\n" );
5035  return dtkNoError;
5036  }
5037 
5038  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"GroupName", inObject->GetGroupName() );
5039 
5040  Dtk_tab<Dtk_MetaDataPtr> list_metadata = inObject->GetListOfMetadatas();
5041 
5042  Dtk_Size_t size = list_metadata.size();
5043 
5044  for( Dtk_Size_t i = 0; i < size; ++i )
5045  {
5046  Dtk_DumpXml_Dtk_MetadataPtr( F, list_metadata[ i ] );
5047  }
5048 
5049  fprintf( F, "</Dtk_MetaDataGroupPtr>\n" );
5050 
5051  return dtkNoError;
5052  }

◆ Dtk_DumpXml_Dtk_MetadataPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_MetadataPtr ( FILE *  F,
const Dtk_MetaDataPtr &  inObject 
)
4959  {
4960  if( F == NULL )
4961  {
4962  return dtkErrorOpenFiles;
4963  }
4964 
4965  fprintf( F, "<Dtk_MetaDataPtr>\n" );
4966  if( inObject.IsNotNULL() )
4967  {
4968  Dtk_string outFormula;
4969  Dtk_string outEstimatedValue;
4970  Dtk_string outTitle;
4971  Dtk_string outResultType;
4972 
4973  Dtk_MetaData::MetaDataTypeEnum MetaDataType = inObject->MetaDataType();
4974  Dtk_DumpXMLNamespace::Dtk_DumpXml_MetaDataTypeEnum( F, MetaDataType, L"MetaDataType" );
4975  if( inObject->GetFormula( outFormula, outEstimatedValue, outTitle, outResultType ) == dtkNoError )
4976  {
4977  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Formula", outFormula );
4978  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"EstimatedValue", outEstimatedValue );
4979  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", outTitle );
4980  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"ResultType", outResultType );
4981  }
4982  else
4983  {
4984  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Title", inObject->GetTitle() );
4985 
4986  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Type", inObject->GetType() );
4987  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Value", inObject->GetValue() );
4988 
4989  Dtk_string unit;
4990  Dtk_ErrorStatus err = inObject->GetUnits( unit );
4991  if( err == dtkNoError )
4992  {
4993  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Units", unit );
4994  }
4995  if( inObject->GetCategory().len() > 0 )
4996  {
4997  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Category", inObject->GetCategory() );
4998  }
4999  //if (inObject->IsTime_t())
5000  //{
5001  // Dtk_string val = inObject->GetValue();
5002  // int timeint = atoi(val.c_str());
5003  // time_t time;
5004  // time = (time_t)timeint;
5005  // char buffer[100];
5006  // memset(buffer, 0, sizeof(buffer));
5007  // ctime_s(buffer, 100, &time);
5008  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Value(F, L"TIME_T", Dtk_string(buffer));
5009 
5010  //}
5011  }
5012  }
5013  else
5014  {
5015  fprintf( F, "'Null'" );
5016  }
5017  fprintf( F, "</Dtk_MetaDataPtr>\n" );
5018  return dtkNoError;
5019  }

◆ Dtk_DumpXml_Dtk_ModelDisplayPtr()

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

◆ Dtk_DumpXml_Dtk_NodeConnector()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodeConnector ( FILE *  inFile,
const Dtk_NodeConnectorPtr &  inNodeConnector 
)
6944  {
6945 
6946  Dtk_ErrorStatus dst = dtkNoError;
6947  Dtk_string ConnectorType;
6948 
6949  if( inNodeConnector.IsNULL() )
6950  {
6951  return dtkErrorNullPointer;
6952  }
6953 
6954  Dtk_tab< Dtk_NodeConnector::SubEntity > SubEntities;
6955  Dtk_tab<Dtk_ID> ComponentPathId;
6956  Dtk_ID NodeId = inNodeConnector->GetNodeId();
6957  inNodeConnector->GetSubEntities( SubEntities );
6958  inNodeConnector->GetAssociatedPathComponentID( ComponentPathId );
6959  Dtk_Node::FullType NodeFullType = inNodeConnector->GetPointingEntityType();
6960  Dtk_Size_t NumSubEntities = SubEntities.size();
6961  Dtk_Size_t NumComp = ComponentPathId.size();
6962 
6963 
6964  if( NumComp <= 1 ) //if only 1 component => Local Component or Prototype
6965  {
6966  ConnectorType = L"Prototype";
6967  }
6968  else
6969  {
6970  ConnectorType = L"ComponentPathId";
6971  }
6972  if( NodeId > 0 )
6973  {
6974  ConnectorType += L" + Node";
6975  }
6976  if( NumSubEntities > 0 )
6977  {
6978  ConnectorType += L" + SubEntities";
6979  }
6980 
6981  fprintf( inFile, "<Dtk_NodeConnector Type=\"%s\">\n", ConnectorType.c_str() );
6982 
6983  Dtk_NodeConnector::ReasonCategoryEnum ReasonCategory;
6984  Dtk_NodeConnector::ReasonLinkEnum ReasonLink = inNodeConnector->GetReasonLink( ReasonCategory );
6985  fprintf( inFile, "<ReasonLink>\"%s\"</ReasonLink>\n", Dtk_NodeConnector::ReasonLinkEnumToString( ReasonLink ).c_str() );
6986  // fprintf(inFile, "<ReasonCategory>\"%s\"</ReasonCategory>\n", Dtk_NodeConnector::ReasonCategoryEnumToString( ReasonCategory ).c_str() );
6987 
6988  if( ReasonLink == Dtk_NodeConnector::ForceColor )
6989  {
6990  fprintf( inFile, "<ColorId>%d</ColorId>\n", inNodeConnector->GetColorId() );
6991  }
6992  if( ReasonLink == Dtk_NodeConnector::ForceRender )
6993  {
6994  fprintf( inFile, "<RenderId>%d</RenderId>\n", inNodeConnector->GetRenderId() );
6995  }
6996 
6997  fprintf( inFile, "<PathCompId>" );
6998  if( NumComp > 0 )
6999  {
7000  Dtk_Size_t i;
7001  for( i = 0; i < NumComp; i++ ) fprintf( inFile, "%d ", ComponentPathId[ i ] );
7002  }
7003  else
7004  {
7005  fprintf( inFile, "LocalComponent" );
7006  }
7007  fprintf( inFile, "</PathCompId>\n" );
7008 
7009 
7010  if( NodeId > 0 )
7011  fprintf( inFile, "<NodeID>%d</NodeID>\n", NodeId );
7012  Dtk_DumpXMLNamespace::Dtk_DumpXml_NodeFullType( inFile, NodeFullType, L"PointingEntityType" );
7013  fprintf( inFile, "<PointedEntityType>%s</PointedEntityType>\n", typedetkToDtk_string( inNodeConnector->GetPointedEntityType() ).c_str() );
7014  //SubEntities
7015  if( NumSubEntities )
7016  {
7017  fprintf( inFile, "<SubEntities Num=\"" XmlFormat( "u" )"\">", NumSubEntities );
7018  for( Dtk_Size_t i = 0; i < NumSubEntities; i++ )
7019  {
7020  Dtk_NodeConnector::SubEntity TmpSub = SubEntities[ i ];
7021  fprintf( inFile, "<SubEntity id=\"%d\" type=\"%s\" ></SubEntity>\n",
7022  TmpSub.GetSubEntityId(),
7023  typedetkToDtk_string( TmpSub.GetSubEntityType() ).c_str() );
7024  }
7025  fprintf( inFile, "</SubEntities>\n" );
7026  }
7027  fprintf( inFile, "</Dtk_NodeConnector>\n" );
7028  return dst;
7029  }

◆ Dtk_DumpXml_Dtk_NodePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr ( FILE *  F,
const Dtk_NodePtr &  inObject 
)
4592  {
4593 
4594  fprintf( F, "<Dtk_NodePtr>\n" );
4595  if( inObject.IsNotNULL() )
4596  {
4597  Dtk_Node::NodeDataTypeEnum NodeType = inObject->GetNodeType();
4598  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4599  Dtk_DumpXMLNamespace::Dtk_DumpXml_NodeTypeEnum( F, NodeType, L"NodeType" );
4600  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"NodeSubType", typedetkToDtk_string( inObject->GetNodeSubType() ) );
4601 
4602  fprintf( F, "<NodeID>%u</NodeID>\n", inObject->GetID() );
4603  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4604  Dtk_StoredInfoPtr sti = inObject->GetStoredInfos();
4605  if( sti.IsNotNULL() )
4606  {
4607  fprintf( F, "<StoredInfos>\n" );
4608  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, Dtk_InfoPtr::DtkDynamicCast( sti ) );
4609  fprintf( F, "</StoredInfos>\n" );
4610  }
4611 
4612  Dtk_Size_t i, NumChildren;
4613  NumChildren = inObject->GetNumChildren();
4614 
4615  for( i = 0; i < NumChildren; i++ )
4616  {
4617  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_NodePtr( F, inObject->GetChild( i ) );
4618  }
4619  Dtk_Size_t NumMetaData;
4620  NumMetaData = inObject->GetNumMetaData();
4621  if( NumMetaData )
4622  {
4623  fprintf( F, "<Dtk_MetaData Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaData );
4624  for( i = 0; i < NumMetaData; i++ )
4625  {
4626  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr( F, inObject->GetMetaData( i ) );
4627  }
4628  fprintf( F, "</Dtk_MetaData>\n" );
4629 
4630  }
4631 #ifdef XML_GROUP_METADATA
4632  Dtk_Size_t NumMetaDataGroup;
4633  NumMetaDataGroup = inObject->GetNumMetaDataGroup();
4634  if( NumMetaDataGroup )
4635  {
4636  fprintf( F, "<Dtk_MetaDataGroup Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaDataGroup );
4637  for( i = 0; i < NumMetaDataGroup; i++ )
4638  {
4639  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataGroupPtr( F, inObject->GetMetaDataGroup( i ) );
4640  }
4641  fprintf( F, "</Dtk_MetaDataGroup>\n" );
4642  }
4643 #endif
4644  Dtk_tab< Dtk_NodeConnectorPtr > AssociatedEntities;
4645  inObject->GetAssociatedEntities( AssociatedEntities );
4646  Dtk_Size_t NumConnector = AssociatedEntities.size();
4647  if( NumConnector )
4648  {
4649  fprintf( F, "<NodeConnectors Num=\'" XmlFormat( "u" ) "\'>\n", NumConnector );
4650 
4651  for( i = 0; i < NumConnector; i++ )
4652  {
4653  Dtk_DumpXml_Dtk_NodeConnector( F, AssociatedEntities[ i ] );
4654  }
4655  fprintf( F, "</NodeConnectors>\n" );
4656 
4657  }
4658  }
4659  else
4660  {
4661  fprintf( F, "<Null></Null>\n" );
4662  }
4663  fprintf( F, "</Dtk_NodePtr>\n" );
4664  return dtkNoError;
4665  }

◆ Dtk_DumpXml_Dtk_NodePtr_End()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr_End ( FILE *  F)
4767  {
4768  if( F == NULL )
4769  {
4770  return dtkErrorNullPointer;
4771  }
4772  fprintf( F, "</Dtk_NodePtr>\n" );
4773  return dtkNoError;
4774  }

◆ Dtk_DumpXml_Dtk_NodePtr_Init()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodePtr_Init ( FILE *  F,
const Dtk_NodePtr &  inObject 
)
4668  {
4669  if( F == NULL )
4670  {
4671  return dtkErrorNullPointer;
4672  }
4673  Dtk_Size_t i = 0;
4674  fprintf( F, "<Dtk_NodePtr>\n" );
4675  if( inObject.IsNotNULL() )
4676  {
4677  fprintf( F, "<NodeID>%u</NodeID>\n", inObject->GetID() );
4678  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inObject->GetInfos() );
4679  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inObject->Name() );
4680  Dtk_ID FatherID = inObject->GetFatherID( 0 );
4681  if( FatherID )
4682  fprintf( F, "<FatherID>%u</FatherID>\n", FatherID );
4683 
4684  Dtk_Node::NodeDataTypeEnum NodeType = inObject->GetNodeType();
4685  Dtk_DumpXMLNamespace::Dtk_DumpXml_NodeTypeEnum( F, NodeType, L"NodeType" );
4686  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"NodeSubType", typedetkToDtk_string( inObject->GetNodeSubType() ) );
4687  if( inObject->NodeHasAxis() )
4688  fprintf( F, "<HasAxis>1</HasAxis>\n" );
4689  if( inObject->NodeHasPoints() )
4690  fprintf( F, "<HasPoints>1</HasPoints>\n" );
4691  if( inObject->NodeHasCurves() )
4692  fprintf( F, "<HasCurves>1</HasCurves>\n" );
4693  if( inObject->NodeHasSurfaces() )
4694  fprintf( F, "<HasSurfaces>1</HasSurfaces>\n" );
4695  if( inObject->NodeHasSolids() )
4696  fprintf( F, "<HasSolids>1</HasSolids>\n" );
4697  if( inObject->NodeHasMesh() )
4698  fprintf( F, "<HasMesh>1</HasMesh>\n" );
4699  if( inObject->NodeHasMeshSurfaces() )
4700  fprintf( F, "<HasMeshSurfaces>1</HasMeshSurfaces>\n" );
4701 
4702  Dtk_StoredInfoPtr sti = inObject->GetStoredInfos();
4703  if( sti.IsNotNULL() )
4704  {
4705  fprintf( F, "<StoredInfos>\n" );
4706  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, Dtk_InfoPtr::DtkDynamicCast( sti ) );
4707  fprintf( F, "</StoredInfos>\n" );
4708  }
4709 
4710  Dtk_Size_t NumMetaData;
4711  NumMetaData = inObject->GetNumMetaData();
4712  if( NumMetaData )
4713  {
4714  fprintf( F, "<Dtk_MetaData Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaData );
4715  for( i = 0; i < NumMetaData; i++ )
4716  {
4717  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataPtr( F, inObject->GetMetaData( i ) );
4718  }
4719  fprintf( F, "</Dtk_MetaData>\n" );
4720  }
4721 #ifdef XML_GROUP_METADATA
4722  Dtk_Size_t NumMetaDataGroup;
4723  NumMetaDataGroup = inObject->GetNumMetaDataGroup();
4724  if( NumMetaDataGroup )
4725  {
4726  fprintf( F, "<Dtk_MetaDataGroup Num=\'" XmlFormat( "u" ) "\'>\n", NumMetaDataGroup );
4727  for( i = 0; i < NumMetaDataGroup; i++ )
4728  {
4729  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_MetadataGroupPtr( F, inObject->GetMetaDataGroup( i ) );
4730  }
4731  fprintf( F, "</Dtk_MetaDataGroup>\n" );
4732  }
4733 #endif
4734  // Dtk_MaterialPtr mat = inObject->GetMaterial();
4735  // Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_material(F,mat);
4736 
4737  Dtk_tab< Dtk_NodeConnectorPtr > AssociatedEntities;
4738  inObject->GetAssociatedEntities( AssociatedEntities );
4739  Dtk_Size_t NumConnector = AssociatedEntities.size();
4740  if( NumConnector )
4741  {
4742  fprintf( F, "<NodeConnectors Num=\'" XmlFormat( "u" ) "\'>\n", NumConnector );
4743 
4744  for( i = 0; i < NumConnector; i++ )
4745  {
4746  Dtk_DumpXml_Dtk_NodeConnector( F, AssociatedEntities[ i ] );
4747  }
4748  fprintf( F, "</NodeConnectors>\n" );
4749 
4750  }
4751  Dtk_PreviewPtr preview = inObject->GetPreview();
4752  if( preview.IsNotNULL() )
4753  {
4754  Dtk_Size_t size = preview->GetStreamSize();
4755  fprintf( F, "<PreviewSize>\"" XmlFormat( "u" )"\"</PreviewSize>", size );
4756  }
4757  }
4758  else
4759  {
4760  //fprintf(F,"'Null'");
4761  fprintf( F, "<Null></Null>\n" );
4762  }
4763  return dtkNoError;
4764  }

◆ Dtk_DumpXml_Dtk_OLEObjectPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_OLEObjectPtr ( FILE *  F,
const Dtk_OLEObjectPtr &  O 
)
8609  {
8610  fprintf( F, "<Dtk_OLEObjectPtr>\n" );
8611  if( O )
8612  {
8613  Dtk_InfoPtr inf = O->get_info();
8614  if( inf.IsNotNULL() )
8615  {
8616  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_info( F, inf );
8617  }
8618  fprintf( F, "<BinaryContentSize>" XmlFormat( "u" ) "</BinaryContentSize>\n", O->GetBinaryContentSize() );
8619  fprintf( F, "<ViewingAspect>%s</ViewingAspect>\n", Dtk_OLEObject::Dtk_OLEObjectViewingAspectToString( O->GetViewingAspect() ).c_str() );
8620  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_Oriented2dBBox( F, O->GetPlacement() );
8621  fprintf( F, "<Scale>%lf</Scale>\n", O->GetScale() );
8622  }
8623  else
8624  {
8625  fprintf( F, "Empty" );
8626  }
8627  fprintf( F, "</Dtk_OLEObjectPtr>\n" );
8628  return dtkNoError;
8629  }

◆ Dtk_DumpXml_Dtk_OneCell()

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

◆ Dtk_DumpXml_Dtk_PlaneSurfacePtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_PlaneSurfacePtr ( FILE *  F,
const Dtk_PlaneSurfacePtr &  inSurf 
)
6109  {
6110  fprintf( F, "<Dtk_PlaneSurfacePtr>" );
6111 
6112  if( inSurf.IsNotNULL() )
6113  {
6114  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, inSurf->GetOrigin(), "Origin" );
6115  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetNormal(), "Normal" );
6116  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetUDirection(), "UDir" );
6117  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, inSurf->GetVDirection(), "VDir" );
6118  }
6119  else
6120  {
6121  fprintf( F, "Null" );
6122  }
6123 
6124  fprintf( F, "</Dtk_PlaneSurfacePtr>" );
6125  return dtkNoError;
6126  }

◆ Dtk_DumpXml_Dtk_pnt()

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

◆ Dtk_DumpXml_Dtk_ReferenceBlockPtr()

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

◆ Dtk_DumpXml_Dtk_ReferenceFramePtr()

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

◆ Dtk_DumpXml_Dtk_roughness_obtention_type()

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

◆ Dtk_DumpXml_Dtk_roughness_rough_mode()

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

◆ Dtk_DumpXml_Dtk_roughness_roughness_applyto()

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

◆ Dtk_DumpXml_Dtk_RoughnessPtr()

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

◆ Dtk_DumpXml_Dtk_SelectionDataSet()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_SelectionDataSet ( FILE *  F,
const Dtk_GlobalDataSetPtr &  ptrGlobalDataSet 
)
7076  {
7077  if( F == NULL )
7078  {
7079  return dtkErrorNullPointer;
7080  }
7081  Dtk_Size_t i = 0;
7082 
7083  //Dtk_GlobalDataSetPtr ptrGlobalDataSet = inObject->GetGlobalDataSet();
7084  if( ptrGlobalDataSet.IsNotNULL() )
7085  {
7086  Dtk_SelectionDataSetPtr ptrSelectionDataSet = ptrGlobalDataSet->GetSelectionDataSet();
7087  if( ptrSelectionDataSet.IsNULL() )
7088  {
7089  return dtkErrorNullPointer;
7090  }
7091  Dtk_Size_t ptrSelectionDataSetNb = ptrSelectionDataSet->GetNumSelectionSets();
7092  if( ptrSelectionDataSetNb > 0 )
7093  {
7094  fprintf( F, "<Dtk_SelectionDataSet>\n" );
7095  }
7096  for( i = 0; i < ptrSelectionDataSetNb; i++ )
7097  {
7098  Dtk_SelectionSetPtr curSelectionSet = ptrSelectionDataSet->GetSelectionSetByPos( i );
7099  if( curSelectionSet.IsNotNULL() )
7100  Dtk_DumpXml_Dtk_SelectionSet( F, curSelectionSet );
7101  }
7102  if( ptrSelectionDataSetNb > 0 )
7103  {
7104  fprintf( F, "</Dtk_SelectionDataSet>\n" );
7105  }
7106  }
7107 
7108  return dtkNoError;
7109  }

◆ Dtk_DumpXml_Dtk_StreamPtr()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_StreamPtr ( FILE *  F,
const Dtk_StreamPtr &  inVal 
)
8711  {
8712  fprintf( F, "<Dtk_StreamPtr>\n" );
8713  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"Name", inVal->GetName() );
8714  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"StreamType", inVal->GetStreamType() );
8715  Dtk_DumpXMLNamespace::Dtk_DumpXml_Value( F, L"StreamSize", inVal->GetBinaryContentSize() );
8716  fprintf( F, "</Dtk_StreamPtr>\n" );
8717  return dtkNoError;
8718  }

◆ Dtk_DumpXml_Dtk_TablePtr()

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

◆ Dtk_DumpXml_Dtk_Text()

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

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr()

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

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtrType()

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

◆ Dtk_DumpXml_Dtk_ToleranceSpecificationPtr()

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

◆ Dtk_DumpXml_Dtk_transfo()

Dtk_ErrorStatus Dtk_DumpXml_Dtk_transfo ( FILE *  F,
const Dtk_transfo &  V 
)
4351  {
4352  fprintf( F, "<Transfo_matrix>\n" );
4353  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getXdir(), "X" );
4354  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getYdir(), "Y" );
4355  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_dir( F, T.getZdir(), "Z" );
4356  Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_pnt( F, T.getOrigin(), "Origin" );
4357  fprintf( F, "<Scale>%f</Scale>\n", T.getScale() );
4358  fprintf( F, "</Transfo_matrix>\n" );
4359  return dtkNoError;
4360  }

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

◆ Dtk_DumpXml_End() [1/2]

Dtk_ErrorStatus Dtk_DumpXml_End ( )
5076  {
5077  if( dump_file == NULL )
5078  return dtkErrorUnspecified;
5079  fprintf( dump_file, "</root>\n" );
5080  fclose( dump_file );
5081  return dtkNoError;
5082  }

◆ Dtk_DumpXml_End() [2/2]

Dtk_ErrorStatus Dtk_DumpXml_End ( FILE *  F)
5084  {
5085  if( F == NULL )
5086  return dtkErrorUnspecified;
5087  fprintf( F, "</root>\n" );
5088  fclose( F );
5089  return dtkNoError;
5090  }

◆ Dtk_DumpXml_Fdt()

Dtk_ErrorStatus Dtk_DumpXml_Fdt ( const Dtk_FdtPtr &  D)
5058  {
5059  return Dtk_DumpXMLNamespace::Dtk_DumpXml_Dtk_FdtPtr( dump_file, D, 0 );
5060  }

◆ Dtk_DumpXml_FormatDtk_string()

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

◆ Dtk_DumpXml_GetFeaturesDumpFile()

FILE* Dtk_DumpXml_GetFeaturesDumpFile ( )
5097  {
5098  return FeaturesDumpFile;
5099  }

◆ Dtk_DumpXml_GetFile()

FILE* Dtk_DumpXml_GetFile ( )
5092  {
5093  return dump_file;
5094  }

◆ Dtk_DumpXml_GetParametersDumpFile()

FILE* Dtk_DumpXml_GetParametersDumpFile ( )

◆ Dtk_DumpXml_Init()

Dtk_ErrorStatus Dtk_DumpXml_Init ( const Dtk_string &  xml_file)
5063  {
5064  Dtk_string xmlFileOut;
5065 
5066  xmlFileOut = xml_file;
5067 
5068  dump_file = xmlFileOut.OpenFile( DTK_W );
5069  if( dump_file == NULL )
5070  return dtkErrorUnspecified;
5071  // dump_file = fopen(xml_file.c_str(),"w");
5072  fprintf( dump_file, "<root>\n" );
5073  return dtkNoError;
5074  }

◆ Dtk_DumpXml_LineTypeDefinitionTable()

Dtk_ErrorStatus Dtk_DumpXml_LineTypeDefinitionTable ( FILE *  F)
4080  {
4081  Dtk_ErrorStatus outDtkStatus = dtkNoError;
4082 
4083  const Dtk_API *const api = Dtk_API::GetAPI();
4084  if( api )
4085  {
4086  const Dtk_Size_t nbDefinitions = api->GetNumCurveLineTypeDefinitionsInTable();
4087 
4088  if( nbDefinitions > 0 )
4089  {
4090  fprintf( F, "<LineTypeDefinitionTable>\n" );
4091 
4092  for( Dtk_Size_t i_def = 1; i_def <= nbDefinitions; ++i_def )
4093  {
4094  Dtk_DumpXml_Dtk_LineTypeDefinitionPtr( F,
4095  api->GetCurveLineTypeDefinitionInTable( ( Dtk_ID )i_def ) );
4096  }
4097 
4098  fprintf( F, "</LineTypeDefinitionTable>\n" );
4099  }
4100  }
4101  else
4102  {
4103  outDtkStatus = dtkErrorNullPointer;
4104  }
4105 
4106  return outDtkStatus;
4107  }

◆ Dtk_DumpXml_PhysicalMaterialInfosTable()

Dtk_ErrorStatus Dtk_DumpXml_PhysicalMaterialInfosTable ( FILE *  F)
3997  {
3998  Dtk_API *api = Dtk_API::GetAPI();
3999  Dtk_ID i, nb = ( Dtk_ID )api->GetNumPhysicalMaterialInfosInTable();
4000  if( nb )
4001  fprintf( F, "<PhysicalMaterialInfosTable>\n" );
4002  for( i = 0; i < nb; i++ )
4003  {
4004  Dtk_PhysicalMaterialInfosPtr mat = api->GetPhysicalMaterialInfosInTable( i + 1 );
4005  Dtk_DumpXml_Dtk_PhysicalMaterialInfos( F, mat );
4006  }
4007  if( nb )
4008  fprintf( F, "</PhysicalMaterialInfosTable>\n" );
4009 
4010  return dtkNoError;
4011  }

◆ Dtk_DumpXml_RenderInfosTable()

Dtk_ErrorStatus Dtk_DumpXml_RenderInfosTable ( FILE *  F)
3961  {
3962  Dtk_API *api = Dtk_API::GetAPI();
3963  Dtk_ID i, nb = ( Dtk_ID )api->GetNumRenderInfosInTable();
3964  if( nb )
3965  fprintf( F, "<RenderInfosTable>\n" );
3966  for( i = 0; i < nb; i++ )
3967  {
3968  Dtk_RenderInfosPtr mat = api->GetRenderInfosInTable( i + 1 );
3969  Dtk_DumpXml_Dtk_RenderInfos( F, mat );
3970  }
3971  if( nb )
3972  fprintf( F, "</RenderInfosTable>\n" );
3973 
3974  return dtkNoError;
3975  }

◆ Dtk_DumpXml_Value() [1/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const char *  inFormat,
  ... 
)
4362  {
4363  Dtk_string Value;
4364  {
4365  va_list ap;
4366  va_start( ap, inFormat );
4367  char buffer[ 512 ] = { 0 };
4368  Dtk_StandardTools::vsprintf_dtk( buffer, 512, inFormat, ap );
4369  va_end( ap );
4370  Value = buffer;
4371  }
4372 
4373  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Value";
4374  const char *TitleCharStr = Title.c_str();
4375 
4376  Value = ( Value.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( Value, XMLGenericString ) : L"Undefined.";
4377  fprintf( inFile, "<%s>%s</%s>\n",
4378  TitleCharStr,
4379  Value.c_str(),
4380  TitleCharStr );
4381 
4382  return dtkNoError;
4383  }

◆ Dtk_DumpXml_Value() [2/7]

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

◆ Dtk_DumpXml_Value() [3/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_Double64 &  inValue,
const char *  inFormat = "%lf" 
)
4386  {
4387  //we check if the label is present - label overload -
4388  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_Double64";
4389  const char *TitleCharStr = Title.c_str();
4390 
4391  char MyFormat[ 128 ] = { 0 };
4392  Dtk_StandardTools::sprintf_dtk( MyFormat, 128, "<%%s>%s</%%s>\n", inFormat );
4393  fprintf( inFile, MyFormat,
4394  TitleCharStr,
4395  inValue,
4396  TitleCharStr );
4397  return dtkNoError;
4398  }

◆ Dtk_DumpXml_Value() [4/7]

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

◆ Dtk_DumpXml_Value() [5/7]

Dtk_ErrorStatus Dtk_DumpXml_Value ( FILE *  inFile,
const Dtk_string &  inLabel,
const Dtk_string &  inValue 
)
4436  {
4437  //we check if the label is present - label overload -
4438  Dtk_string Title = ( inLabel.len() > 0 ) ? Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inLabel, XMLElement ) : L"Dtk_string";
4439  const char *TitleCharStr = Title.c_str();
4440 
4441  if( inValue.len() > 0 )
4442  {
4443 
4444  Dtk_string Value = Dtk_DumpXMLNamespace::Dtk_DumpXml_FormatDtk_string( inValue, XMLGenericString );
4445 
4446  fprintf( inFile, "<%s>&quot;%s&quot;</%s>\n",
4447  TitleCharStr,
4448  Value.c_str(),
4449  TitleCharStr );
4450  }
4451  else
4452  {
4453  fprintf( inFile, "<%s>(null)</%s>\n",
4454  TitleCharStr,
4455  TitleCharStr );
4456  }
4457  return dtkNoError;
4458  }

◆ Dtk_DumpXml_Value() [6/7]

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

◆ 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)
7902  {
7903  Dtk_string str_fic_param, str_fic_feat;
7904 
7905  if( FeaturesDumpFile )
7906  {
7907  str_fic_feat = inComponentFullName + Dtk_string( ".feat.log" );
7908  fclose( FeaturesDumpFile );
7909  FeaturesDumpFile = NULL;
7910  }
7911 
7912  return dtkNoError;
7913 
7914  }

◆ Dtk_Init_Dump_Files()

Dtk_ErrorStatus Dtk_Init_Dump_Files ( const Dtk_string &  inDumpFileName,
Dtk_bool  dumpFeatures = 0 
)
7888  {
7889  if( dumpFeatures )
7890  {
7891  FeaturesDumpFile = inDumpFileName.OpenFile( DTK_WP );
7892  if( FeaturesDumpFile == NULL )
7893  {
7894  return dtkErrorOpenFiles;
7895  }
7896  }
7897 
7898  return dtkNoError;
7899  }

◆ DtkReaderTypeEnumToString()

Dtk_string DtkReaderTypeEnumToString ( const DtkReaderType &  inReaderTypeEnum)
719  {
720  Dtk_string EnumToStr;
721  switch( inReaderTypeEnum )
722  {
723  case V5ReaderModule: EnumToStr = L"V5ReaderModule"; break;
724  case VdaReaderModule: EnumToStr = L"VdaReaderModule"; break;
725  case InvReaderModule: EnumToStr = L"InvReaderModule"; break;
726  case V4ReaderModule: EnumToStr = L"V4ReaderModule"; break;
727  case UgReaderModule: EnumToStr = L"UgReaderModule"; break;
728  case XmtReaderModule: EnumToStr = L"XmtReaderModule"; break;
729  case SwReaderModule: EnumToStr = L"SwReaderModule"; break;
730  case SeReaderModule: EnumToStr = L"SeReaderModule"; break;
731  case IgesReaderModule: EnumToStr = L"IgesReaderModule"; break;
732  case StepReaderModule: EnumToStr = L"StepReaderModule"; break;
733  case PsReaderModule: EnumToStr = L"PsReaderModule"; break;
734  case ProeReaderModule: EnumToStr = L"ProeReaderModule"; break;
735  case SatReaderModule: EnumToStr = L"SatReaderModule"; break;
736  case JtReaderModule: EnumToStr = L"JtReaderModule"; break;
737  case CgrReaderModule: EnumToStr = L"CgrReaderModule"; break;
738  case CgmReaderModule: EnumToStr = L"CgmReaderModule"; break;
739  case CaddsReaderModule: EnumToStr = L"CaddsReaderModule"; break;
740  case DwgReaderModule: EnumToStr = L"DwgReaderModule"; break;
741  case DwgDtkReaderModule: EnumToStr = L"DwgDtkReaderModule"; break;
742  case AcisReaderModule: EnumToStr = L"AcisReaderModule"; break;
743  case ProCeraReaderModule: EnumToStr = L"ProCeraReaderModule"; break;
744  case CerconReaderModule: EnumToStr = L"CerconReaderModule"; break;
745  case CerecReaderModule: EnumToStr = L"CerecReaderModule"; break;
746  case DcmReaderModule: EnumToStr = L"DcmReaderModule"; break;
747  case _3dXmlReaderModule: EnumToStr = L"_3dXmlReaderModule"; break;
748  case XmlReaderModule: EnumToStr = L"XmlReaderModule"; break;
749  case V6ReaderModule: EnumToStr = L"V6ReaderModule"; break;
750  case DxfReaderModule: EnumToStr = L"DxfReaderModule"; break;
751  case PlmXmlReaderModule: EnumToStr = L"PlmXmlReaderModule"; break;
752  case RnXmlReaderModule: EnumToStr = L"RnXmlReaderModule"; break;
753  case FbxReaderModule: EnumToStr = L"FbxReaderModule"; break;
754  case GltfReaderModule: EnumToStr = L"GltfReaderModule"; break;
755  case SdnfReaderModule: EnumToStr = L"SdnfReaderModule"; break;
756  case F3dReaderModule: EnumToStr = L"F3dReaderModule"; break;
757  case PrcReaderModule: EnumToStr = L"PrcReaderModule"; break;
758  case ArtReaderModule: EnumToStr = L"ArtReaderModule"; break;
759  case SmgReaderModule: EnumToStr = L"SmgReaderModule"; break;
760  case DstvReaderModule: EnumToStr = L"DstvReaderModule"; break;
761  case NavisReaderModule: EnumToStr = L"NavisReaderModule"; break;
762  case QifReaderModule: EnumToStr = L"QifReaderModule"; break;
763  case Zw3dReaderModule: EnumToStr = L"Zw3dReaderModule"; break;
764  case UsdReaderModule: EnumToStr = L"UsdReaderModule"; break;
765  case StlReaderModule: EnumToStr = L"StlReaderModule"; break;
766  case IfcReaderModule: EnumToStr = L"IfcReaderModule"; break;
767  case RevitReaderModule: EnumToStr = L"RevitReaderModule"; break;
768  case MaxReaderModules: EnumToStr = L"MaxReaderModules"; break;
769  case UnknownModule: EnumToStr = L"UnknownModule"; break;
770  default:
771  EnumToStr = L"UnknownModule";
772  }
773  return EnumToStr;
774  }
Dtk_mesh_face::get_nbtriangle_fans
Dtk_Size_t get_nbtriangle_fans() const
Get the number of triangle fans kept in the class instance.
Dtk_DumpXml_Dtk_SymbolPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_SymbolPtr(FILE *F, const Dtk_SymbolPtr &D)
Definition: util_xml_dtk.cpp:2779
Dtk_DumpXml_Dtk_DatumTargetPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DatumTargetPtr(FILE *F, const Dtk_DatumTargetPtr &D)
Definition: util_xml_dtk.cpp:2081
Dtk_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:4591
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:1087
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:6056
Dtk_DumpXml_Dtk_GeometricalTolerancePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_GeometricalTolerancePtr(FILE *F, const Dtk_GeometricalTolerancePtr &D)
Definition: util_xml_dtk.cpp:2550
RnXmlReaderModule
@ RnXmlReaderModule
Definition: dtk_maindoc.hpp:59
UsdReaderModule
@ UsdReaderModule
Definition: dtk_maindoc.hpp:81
Dtk_DumpXml_Dtk_LeaderPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LeaderPtr(FILE *F, const Dtk_LeaderPtr &L)
Definition: util_xml_dtk.cpp:1288
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:681
DTK_FDT_MODIFIER_NOT_SET
@ DTK_FDT_MODIFIER_NOT_SET
Definition: util_draw_dtk.hpp:55
Dtk_RenderInfos::GetLightMap
Dtk_LightMapPtr GetLightMap() const
Returns the render light map.
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:1495
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:2570
Dtk_Text::TextStyle
Dtk_TextStyle & TextStyle()
Retrieves the text text style - get/set -.
DTK_TYPE_GEOM_TOL
@ DTK_TYPE_GEOM_TOL
Definition: define.h:430
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:4344
Dtk_DumpXml_Dtk_welding_finish_symbol
Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_finish_symbol(FILE *F, const Dtk_Welding::FinishSymbolEnum &D)
Definition: util_xml_dtk.cpp:1759
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:4958
Dtk_DumpXml_DTK_FDT_MODIFIER
Dtk_ErrorStatus Dtk_DumpXml_DTK_FDT_MODIFIER(FILE *F, const DTK_FDT_MODIFIER &D)
Definition: util_xml_dtk.cpp:2624
Dtk_DumpXml_Dtk_LinePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_LinePtr(FILE *F, const Dtk_LinePtr &inCurve)
Definition: util_xml_dtk.cpp:5117
Dtk_Leader::ArrowHead::GetType
const LeaderTerminatorTypeEnum GetType() const
Definition: util_draw_dtk.hpp:2125
Dtk_ModelDisplay::rendering_mode_wireframe_face_analysis
@ rendering_mode_wireframe_face_analysis
Definition: util_ent_dtk.hpp:997
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:431
Dtk_Text::TextSubType
DTK_Text_subtype & TextSubType()
Retrieves the text subtype - get/set -.
Dtk_DatumTarget::NumValues
@ NumValues
Definition: util_draw_dtk.hpp:3752
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:7633
DTK_WITH_HIERARCHY
@ DTK_WITH_HIERARCHY
Definition: util_draw_dtk.hpp:65
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:2574
Dtk_DumpXml_FeatHole
Dtk_ErrorStatus Dtk_DumpXml_FeatHole(FILE *f, const Dtk_feat_hole *inToWrite)
Definition: util_xml_dtk.cpp:8064
Dtk_DumpXml_Dtk_2dEntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_2dEntityPtr(FILE *F, const Dtk_2dEntityPtr &D, const int &compact)
Definition: util_xml_dtk.cpp:2802
Dtk_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:7653
Dtk_DatumTarget::DatumTargetValueEnumToString
static Dtk_string DatumTargetValueEnumToString(const DatumTargetValueEnum &inEnum)
Definition: util_draw_dtk.hpp:3755
DTK_FDT_MODIFIER_LEAST_MATERIAL
@ DTK_FDT_MODIFIER_LEAST_MATERIAL
Definition: util_draw_dtk.hpp:57
Dtk_DumpXml_Dtk_OneCell
Dtk_ErrorStatus Dtk_DumpXml_Dtk_OneCell(FILE *F, Dtk_OneCell &D)
Definition: util_xml_dtk.cpp:2231
Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ToleranceSpecificationContainerPtr(FILE *F, const Dtk_ToleranceSpecificationContainerPtr &D)
Definition: util_xml_dtk.cpp:2524
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_NodeConnector::GetColorId
Dtk_Int32 GetColorId() const
Retrieves the Color Id for ForceColor connectors.
Dtk_KinJoint::getParameter1
double getParameter1()
Returns the first parameter.
Dtk_DumpXml_Dtk_FacePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FacePtr(FILE *F, const Dtk_FacePtr &inFace)
Definition: util_xml_dtk.cpp:6552
Dtk_NodeConnector::ForceColor
@ ForceColor
Definition: dtk_maindoc.hpp:1100
DTK_FDT_MODIFIER_NONE
@ DTK_FDT_MODIFIER_NONE
Definition: util_draw_dtk.hpp:59
Dtk_OneCell::GetBorderBottomColor
const Dtk_RGB & GetBorderBottomColor()
Gets BorderBottomColor of Bottom border.
Dtk_Roughness::ModePerpendicular
@ ModePerpendicular
Definition: util_draw_dtk.hpp:2592
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:3743
Dtk_ToleranceSpecificationContainer::TypeAxisIntersection
@ TypeAxisIntersection
Definition: util_draw_dtk.hpp:6086
DTK_TYPE_VERTEX
@ DTK_TYPE_VERTEX
Definition: define.h:116
Dtk_LayerInfosSet::Layer
Definition: util_ent_dtk.hpp:519
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:4849
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:6448
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:7124
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:2572
Dtk_KinParameter::getId
int getId()
Retrun the parameter id.
Dtk_ToleranceSpecificationContainer::TypeFlatness
@ TypeFlatness
Definition: util_draw_dtk.hpp:6060
Dtk_Roughness::ModeMultiDirectional
@ ModeMultiDirectional
Definition: util_draw_dtk.hpp:2580
DTK_TYPE_POLYLINE
@ DTK_TYPE_POLYLINE
Definition: define.h:47
Dtk_DumpXml_Dtk_EllipsePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EllipsePtr(FILE *F, const Dtk_EllipsePtr &inCurve)
Definition: util_xml_dtk.cpp:5248
DTK_TRUE
#define DTK_TRUE
Definition: define.h:719
Dtk_OneCell::getnbCells_Top_Bottom
Dtk_Int32 getnbCells_Top_Bottom() const
Gets the number of cells at the bottom or left of the Dtk_OneCell.
DTK_TYPE_REGION
@ DTK_TYPE_REGION
Definition: define.h:550
Dtk_Node::NodeDataTypeEnum
NodeDataTypeEnum
Definition: dtk_maindoc.hpp:247
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:2563
Dtk_LayerInfosSet::Layer::Status::Selectable
@ Selectable
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:3133
Dtk_DumpXml_Dtk_Oriented2dBBox
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Oriented2dBBox(FILE *F, const Dtk_Oriented2dBBox &BBox, const Dtk_string &inLabel=L"")
Definition: util_xml_dtk.cpp:915
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:680
Dtk_string
This is a high level string class.
Definition: dtk_string.hpp:53
Dtk_ModelDisplay::rendering_mode_shaded_with_visible_edges
@ rendering_mode_shaded_with_visible_edges
Definition: util_ent_dtk.hpp:993
Dtk_mesh_face::get_triangle_fan_indices
const Dtk_tab< Dtk_UInt32 > * get_triangle_fan_indices(Dtk_Size_t inI) const
Get inI-th triangle fan.
Dtk_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:994
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:97
Dtk_DumpXml_Dtk_KinematicsLaw
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsLaw(FILE *inFile, const Dtk_KinLawPtr &inLaw)
Definition: util_xml_dtk.cpp:7375
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:704
Dtk_Info::GetColor
Dtk_RGB GetColor() const
Retrieves the entity color as Dtk_RGBA values.
Dtk_NodeConnector::SubEntity
Definition: dtk_maindoc.hpp:1223
Dtk_DumpXml_Dtk_LineTypeDefinitionPtr
void Dtk_DumpXml_Dtk_LineTypeDefinitionPtr(FILE *F, const Dtk_LineTypeDefinitionPtr &inLineTypeDefinition)
Definition: util_xml_dtk.cpp:4013
Dtk_DumpXml_Dtk_EdgePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EdgePtr(FILE *F, const Dtk_EdgePtr &inEdge)
Definition: util_xml_dtk.cpp:6471
DTK_TYPE_COMPOSITE_ENTITY
@ DTK_TYPE_COMPOSITE_ENTITY
Definition: define.h:441
DTK_ANCHOR_TOP_CENTER
@ DTK_ANCHOR_TOP_CENTER
Definition: util_draw_dtk.hpp:92
Dtk_ToleranceSpecificationContainer::TypeStraightness
@ TypeStraightness
Definition: util_draw_dtk.hpp:6058
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:39
Dtk_DumpXml_Dtk_val
Dtk_ErrorStatus Dtk_DumpXml_Dtk_val(FILE *F, const Dtk_Val &V)
Definition: util_xml_dtk.cpp:3543
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:1245
Dtk_DumpXml_Dtk_welding_complementary_symbol
Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_complementary_symbol(FILE *F, const Dtk_Welding::ComplementarySymbolEnum &D)
Definition: util_xml_dtk.cpp:1731
Dtk_UUID
Definition: dtk_uuid.hpp:8
Dtk_Val::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:98
Dtk_DumpXml_Dtk_RoughnessPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RoughnessPtr(FILE *F, const Dtk_RoughnessPtr &D)
Definition: util_xml_dtk.cpp:1573
UnknownModule
@ UnknownModule
Definition: dtk_maindoc.hpp:83
Dtk_DumpXml_Dtk_FontLineTypeEnum
void Dtk_DumpXml_Dtk_FontLineTypeEnum(FILE *F, const Dtk_FontLineType &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:2348
Dtk_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:2586
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:1832
DTK_TYPE_PARABOLA
@ DTK_TYPE_PARABOLA
Definition: define.h:52
Dtk_KinJoint::getId
int getId()
Retrun the joint id.
dtkWarningNoEntitiesWritten
@ dtkWarningNoEntitiesWritten
Definition: error_dtk.hpp:89
Dtk_DumpXml_FormatDtk_string
Dtk_string Dtk_DumpXml_FormatDtk_string(const Dtk_string &inString, const XML_StringType inXmlStringType)
Definition: util_xml_dtk.cpp:4460
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:720
Dtk_DumpXml_Dtk_ParabolaPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ParabolaPtr(FILE *F, const Dtk_ParabolaPtr &inCurve)
Definition: util_xml_dtk.cpp:5226
DTK_TYPE_NURBS_CURVE
@ DTK_TYPE_NURBS_CURVE
Definition: define.h:485
StlReaderModule
@ StlReaderModule
Definition: dtk_maindoc.hpp:67
DTK_TYPE_SYMBOL
@ DTK_TYPE_SYMBOL
Definition: define.h:400
Dtk_bool
char Dtk_bool
Definition: define.h:717
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:428
Dtk_DatumTarget::DatumTargetTypeEnumToString
static Dtk_string DatumTargetTypeEnumToString(const DatumTargetTypeEnum &inEnum)
Definition: util_draw_dtk.hpp:3710
Dtk_DumpXml_Dtk_PhysicalMaterialInfos
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PhysicalMaterialInfos(FILE *F, const Dtk_PhysicalMaterialInfosPtr &inMaterial)
Definition: util_xml_dtk.cpp:3727
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:995
DTK_ANCHOR_MIDDLE_CENTER
@ DTK_ANCHOR_MIDDLE_CENTER
Definition: util_draw_dtk.hpp:95
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
Retrieves the entity UniqueID if any.
Dtk_DumpXml_Dtk_NurbsCurvePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NurbsCurvePtr(FILE *F, const Dtk_NurbsCurvePtr &inCurve)
Definition: util_xml_dtk.cpp:5157
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:799
Dtk_Node::GetChild
const Dtk_NodePtr GetChild(const Dtk_Size_t &inPos) const
Retrieves the ith Dtk_Node - read only -.
Definition: dtk_maindoc.hpp:385
Dtk_DumpXml_Dtk_NodeConnector
Dtk_ErrorStatus Dtk_DumpXml_Dtk_NodeConnector(FILE *inFile, const Dtk_NodeConnectorPtr &inNodeConnector)
Definition: util_xml_dtk.cpp:6943
Dtk_Double64
double Dtk_Double64
Definition: define.h:691
Dtk_DumpXml_Dtk_welding_symbol
Dtk_ErrorStatus Dtk_DumpXml_Dtk_welding_symbol(FILE *F, const Dtk_Welding::WeldingSymbolEnum &D)
Definition: util_xml_dtk.cpp:1630
Dtk_DumpXml_Dtk_TextStyle
Dtk_ErrorStatus Dtk_DumpXml_Dtk_TextStyle(FILE *F, const Dtk_TextStyle &T)
Definition: util_xml_dtk.cpp:957
Dtk_DumpXml_FeatThread
Dtk_ErrorStatus Dtk_DumpXml_FeatThread(FILE *f, const Dtk_feat_thread *inToWrite)
Definition: util_xml_dtk.cpp:8005
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:991
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:7031
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:4361
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:91
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:38
Dtk_DumpXml_Dtk_KinematicsMechanism
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsMechanism(FILE *inFile, const Dtk_KinMechanismPtr &inKinMechanism)
Definition: util_xml_dtk.cpp:7717
Dtk_DumpXml_Dtk_KinematicsFormula
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsFormula(FILE *inFile, const Dtk_KinFormulaPtr &inFormula)
Definition: util_xml_dtk.cpp:7359
Dtk_string::is_not_NULL
Dtk_bool is_not_NULL() const
Dtk_ConvertFontLineTypeEnumToString
Dtk_string Dtk_ConvertFontLineTypeEnumToString(const Dtk_FontLineType &inEnum)
Definition: util_xml_dtk.cpp:2327
Dtk_DumpXml_Dtk_info
Dtk_ErrorStatus Dtk_DumpXml_Dtk_info(FILE *F, const Dtk_InfoPtr &I)
Definition: util_xml_dtk.cpp:4109
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_Info::GetMetaData
Dtk_ErrorStatus GetMetaData(Dtk_tab< Dtk_MetaDataPtr > &outArray) const
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:6626
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:1003
Dtk_Leader::TypeUnknown
@ TypeUnknown
Definition: util_draw_dtk.hpp:2184
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:4350
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:6064
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:8710
Dtk_DumpXml_Dtk_WeldingPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_WeldingPtr(FILE *F, const Dtk_WeldingPtr &D)
Definition: util_xml_dtk.cpp:1793
Dtk_ModelDisplay::rendering_mode_wireframe_partially_shade
@ rendering_mode_wireframe_partially_shade
Definition: util_ent_dtk.hpp:998
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:5946
Dtk_DumpXml_Dtk_AnnotationPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_AnnotationPtr(FILE *F, const Dtk_AnnotationPtr &D)
Definition: util_xml_dtk.cpp:877
DTK_INDIFFERENT_HIERARCHY
@ DTK_INDIFFERENT_HIERARCHY
Definition: util_draw_dtk.hpp:67
Dtk_DumpXml_Dtk_DrawingPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DrawingPtr(FILE *F, const Dtk_DrawingPtr &D, const int &compact)
Definition: util_xml_dtk.cpp:3039
IgesReaderModule
@ IgesReaderModule
Definition: dtk_maindoc.hpp:38
Dtk_ModelDisplay::rendering_mode_shaded_only
@ rendering_mode_shaded_only
Definition: util_ent_dtk.hpp:992
Dtk_NodeConnector::ReasonCategoryEnum
ReasonCategoryEnum
Reason Category. Global Category of the NodeConnector uesed to gather Reason into families.
Definition: dtk_maindoc.hpp:1196
_3dXmlReaderModule
@ _3dXmlReaderModule
Definition: dtk_maindoc.hpp:51
Dtk_ModelDisplay::SectionBox
@ SectionBox
Definition: util_ent_dtk.hpp:1006
Dtk_DumpXml_LeaderTerminatorTypeEnum
void Dtk_DumpXml_LeaderTerminatorTypeEnum(FILE *F, const Dtk_Leader::LeaderTerminatorTypeEnum &inEnum, const Dtk_string &inPropertyName)
Definition: util_xml_dtk.cpp:832
DTK_TYPE_INTERSECTION_CURVE
@ DTK_TYPE_INTERSECTION_CURVE
Definition: define.h:80
Dtk_Leader::TypeLinear
@ TypeLinear
Definition: util_draw_dtk.hpp:2185
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:84
Dtk_Roughness::ModeParallel
@ ModeParallel
Definition: util_draw_dtk.hpp:2590
DTK_ANCHOR_TOP_RIGHT
@ DTK_ANCHOR_TOP_RIGHT
Definition: util_draw_dtk.hpp:93
DTK_FDT_MODIFIER_MAX_MATERIAL
@ DTK_FDT_MODIFIER_MAX_MATERIAL
Definition: util_draw_dtk.hpp:56
Dtk_DumpXml_Dtk_EntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_EntityPtr(FILE *inDumpFile, const Dtk_EntityPtr &inEntity)
Definition: util_xml_dtk.cpp:5269
Dtk_ModelDisplay::rendering_mode_static_wireframe
@ rendering_mode_static_wireframe
Definition: util_ent_dtk.hpp:996
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:2357
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:1142
DTK_TYPE_CIRCLE
@ DTK_TYPE_CIRCLE
Definition: define.h:49
Dtk_Int32
int32_t Dtk_Int32
Definition: define.h:679
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:270
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:576
Dtk_Roughness::ObtentionTypeNotDefined
@ ObtentionTypeNotDefined
Definition: util_draw_dtk.hpp:2559
Dtk_DumpXml_Dtk_RGB
Dtk_ErrorStatus Dtk_DumpXml_Dtk_RGB(FILE *F, const Dtk_RGB &RGB)
Definition: util_xml_dtk.cpp:3531
Dtk_NodeConnector::ForceRender
@ ForceRender
Definition: dtk_maindoc.hpp:1101
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:999
DTK_TYPE_GRID
@ DTK_TYPE_GRID
Definition: define.h:442
V4ReaderModule
@ V4ReaderModule
Definition: dtk_maindoc.hpp:33
Dtk_ToleranceSpecificationContainer::TypeSymmetry
@ TypeSymmetry
Definition: util_draw_dtk.hpp:6080
Dtk_mesh_face::get_triangle_indices
const Dtk_UInt32 * get_triangle_indices(Dtk_Size_t inI) const
Get pointer of triangle indices of i-th triangle.
Dtk_DumpXml_Dtk_TablePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_TablePtr(FILE *F, const Dtk_TablePtr &D)
Definition: util_xml_dtk.cpp:2290
Dtk_Leader::ArrowHead::GetArrowLocation
const Dtk_pnt & GetArrowLocation() const
Definition: util_draw_dtk.hpp:2124
Dtk_Component::ComponentTypeEnumToString
static Dtk_string ComponentTypeEnumToString(const ComponentTypeEnum &inEnum)
Definition: dtk_maindoc.hpp:592
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:2133
Dtk_KinSpeedAcceleration
Dtk_KinSpeedAcceleration represents a mechanism speed/acceleration.
Definition: util_kinematics_dtk.hpp:2511
DTK_TYPE_LINE
@ DTK_TYPE_LINE
Definition: define.h:46
StepReaderModule
@ StepReaderModule
Definition: dtk_maindoc.hpp:39
Dtk_ToleranceSpecificationContainer::TypeTotalRunout
@ TypeTotalRunout
Definition: util_draw_dtk.hpp:6084
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:1018
Dtk_DumpXml_Dtk_ComponentPtr_End
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ComponentPtr_End(FILE *F)
Definition: util_xml_dtk.cpp:4945
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:6082
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:2561
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:4338
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:2578
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:2418
Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_FCFFeatureIndicatorPtr(FILE *F, const Dtk_FCFFeatureIndicatorPtr &D)
Definition: util_xml_dtk.cpp:2761
Dtk_StandardTools::sprintf_dtk
int sprintf_dtk(char *Buffer, size_t BufferCount, const char *Format,...)
XMLAttribute
@ XMLAttribute
Definition: util_xml_dtk.hpp:94
DTK_TYPE_SPCURVE
@ DTK_TYPE_SPCURVE
Definition: define.h:566
DTK_FRAME_TYPE_NONE
@ DTK_FRAME_TYPE_NONE
Definition: util_draw_dtk.hpp:125
Dtk_OneCell::GetBorderBottomBlanked
Dtk_Int32 GetBorderBottomBlanked()
Gets BorderBottomBlanked of Bottom border.
Dtk_ToleranceSpecificationContainer::TypeParallelism
@ TypeParallelism
Definition: util_draw_dtk.hpp:6074
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:980
Dtk_SmartPtr
Definition: util_ptr_dtk.hpp:37
Dtk_DumpXml_Dtk_Frame
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Frame(FILE *F, const Dtk_Frame &T)
Definition: util_xml_dtk.cpp:1200
Dtk_DumpXml_Dtk_DimensionPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_DimensionPtr(FILE *F, const Dtk_DimensionPtr &D)
Definition: util_xml_dtk.cpp:1425
Dtk_Leader::ArrowHead::GetInfo
const Dtk_InfoPtr & GetInfo() const
Definition: util_draw_dtk.hpp:2122
DTK_UNKNOWN
@ DTK_UNKNOWN
Definition: util_draw_dtk.hpp:64
Dtk_string::is_NULL
Dtk_bool is_NULL() const
DTK_ANCHOR_MIDDLE_LEFT
@ DTK_ANCHOR_MIDDLE_LEFT
Definition: util_draw_dtk.hpp:94
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:3729
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:1005
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:6068
Dtk_Camera::Angle
Dtk_Double64 Angle() const
Definition: util_draw_dtk.hpp:7520
Dtk_Roughness::ApplyToSpecifiedSurface
@ ApplyToSpecifiedSurface
Definition: util_draw_dtk.hpp:2568
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:20
Dtk_KinJoint::getConnector
Dtk_KinConnectorPtr getConnector(Dtk_Size_t inPosition)
Returns Connector at position inPosition.
w_str
#define w_str
Definition: dtk_string.hpp:30
type_detk
type_detk
Definition: define.h:21
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:4795
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:1525
Dtk_API::GetCurveLineTypeDefinitionInTable
Dtk_LineTypeDefinitionPtr GetCurveLineTypeDefinitionInTable(const Dtk_ID inId) const
Dtk_ModelDisplay::SectionTypeEnum
SectionTypeEnum
Definition: util_ent_dtk.hpp:1002
Dtk_ToleranceSpecificationContainer::TypeCircularity
@ TypeCircularity
Definition: util_draw_dtk.hpp:6062
Dtk_DumpXml_Dtk_CompositeEntityPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CompositeEntityPtr(FILE *F, const Dtk_CompositeEntityPtr &D)
Definition: util_xml_dtk.cpp:2479
Dtk_ToleranceSpecificationContainer::TypeConcentricity
@ TypeConcentricity
Definition: util_draw_dtk.hpp:6078
Dtk_DumpXml_Dtk_KinematicsCommand
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsCommand(FILE *inFile, const Dtk_KinCommandPtr &inCommand, Dtk_bool simplified)
Definition: util_xml_dtk.cpp:7615
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:906
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:2059
Dtk_DumpXml_Dtk_ReferenceFramePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceFramePtr(FILE *F, const Dtk_ReferenceFramePtr &D)
Definition: util_xml_dtk.cpp:2584
Dtk_ModelDisplay::SectionBody
@ SectionBody
Definition: util_ent_dtk.hpp:1007
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:3697
Dtk_Roughness::ModeWithAngles
@ ModeWithAngles
Definition: util_draw_dtk.hpp:2588
Dtk_KinMechanism
Dtk_KinMechanism represents a kinematic mechanism.
Definition: util_kinematics_dtk.hpp:1618
Dtk_NodeConnector::GetRenderId
Dtk_ID GetRenderId() const
Retrieves the Render Id for ForceRender connectors.
Dtk_Text::GetOuterBoundingBox
const Dtk_Oriented2dBBox & GetOuterBoundingBox() const
Processes the outer bounding box.
DTK_TYPE_TABLE
@ DTK_TYPE_TABLE
Definition: define.h:480
Dtk_Leader::ArrowHead::GetDirections
void GetDirections(Dtk_dir &outRefDir, Dtk_dir &outAxisDir) const
Definition: util_draw_dtk.hpp:2128
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:2582
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:84
Dtk_DumpXml_Dtk_ReferenceBlockPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ReferenceBlockPtr(FILE *F, const Dtk_ReferenceBlockPtr &D)
Definition: util_xml_dtk.cpp:2566
Dtk_KinParameter::hasAttribute
Dtk_bool hasAttribute(Dtk_string inAttributeName)
Test if an attribute name belong at the attribute table.
Dtk_KinJoint::getJoint2
Dtk_KinJointPtr getJoint2()
Returns the second joint associated at the joint.
Dtk_LayerInfosSet::Layer::Status::Visible
@ Visible
DwgDtkReaderModule
@ DwgDtkReaderModule
Definition: dtk_maindoc.hpp:79
Dtk_tab::size
Dtk_Size_t size() const
Returns the size of the array.
Definition: util_stl_dtk.hpp:503
Dtk_DumpXml_Dtk_HyperbolaPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_HyperbolaPtr(FILE *F, const Dtk_HyperbolaPtr &inCurve)
Definition: util_xml_dtk.cpp:5205
Dtk_ToleranceSpecificationContainer::TypePerpendicularity
@ TypePerpendicularity
Definition: util_draw_dtk.hpp:6072
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:50
Dtk_Roughness::ModeRadial
@ ModeRadial
Definition: util_draw_dtk.hpp:2584
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:5021
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:1272
Dtk_Leader::TypeAngular
@ TypeAngular
Definition: util_draw_dtk.hpp:2186
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:7407
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:1515
Dtk_DumpXml_FormatDtk_string
Dtk_string Dtk_DumpXml_FormatDtk_string(const Dtk_string &inString, const XML_StringType inXmlStringType=XMLGenericString)
Definition: util_xml_dtk.cpp:4460
Dtk_mesh_face::get_nbtriangle_strips
Dtk_Size_t get_nbtriangle_strips() const
Get the number of triangle strips kept in the class instance.
Dtk_DumpXml_Dtk_ViewPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ViewPtr(FILE *F, const Dtk_ViewPtr &V, const int &compact)
Definition: util_xml_dtk.cpp:2957
Dtk_DumpXml_FeatGeometry
Dtk_ErrorStatus Dtk_DumpXml_FeatGeometry(FILE *f, const Dtk_feat_geometry *inToWrite, const char *inName)
Definition: util_xml_dtk.cpp:7919
Dtk_KinJoint::getLowerLimit1
double getLowerLimit1()
Returns the lower limit 1.
Dtk_Component::PrototypeComponentType
@ PrototypeComponentType
Definition: dtk_maindoc.hpp:570
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:8484
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:1538
Dtk_DumpXml_Dtk_MeshPtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_MeshPtr(FILE *F, const Dtk_MeshPtr &inMesh)
Definition: util_xml_dtk.cpp:6786
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:8265
DTK_ANCHOR_BOTTOM_RIGHT
@ DTK_ANCHOR_BOTTOM_RIGHT
Definition: util_draw_dtk.hpp:99
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:2374
Dtk_DumpXml_Dtk_PolylinePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_PolylinePtr(FILE *F, const Dtk_PolylinePtr &inCurve)
Definition: util_xml_dtk.cpp:5137
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:1218
Dtk_NodeConnector::SubEntity::GetSubEntityType
type_detk GetSubEntityType() const
Definition: dtk_maindoc.hpp:1234
DTK_ANCHOR_MIDDLE_RIGHT
@ DTK_ANCHOR_MIDDLE_RIGHT
Definition: util_draw_dtk.hpp:96
Dtk_Info::GetRenderInfosId
Dtk_ID GetRenderInfosId() const
Retrieves the Id of RenderInfos of the entity in The Dtk_API table.
Dtk_tab::at
T & at(Dtk_Size_t k)
Definition: util_stl_dtk.hpp:397
dtkNoError
@ dtkNoError
Definition: error_dtk.hpp:149
Dtk_DumpXml_Dtk_ConstraintReferencePtr
Dtk_ErrorStatus Dtk_DumpXml_Dtk_ConstraintReferencePtr(FILE *F, const Dtk_ConstraintReferencePtr &inVal)
Definition: util_xml_dtk.cpp:8535
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:2708
Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration
Dtk_ErrorStatus Dtk_DumpXml_Dtk_KinematicsSpeedAcceleration(FILE *inFile, const Dtk_KinSpeedAccelerationPtr &inSpeedAcceleration)
Definition: util_xml_dtk.cpp:7183
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:7348
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:58
DTK_TYPE_HYPERBOLA
@ DTK_TYPE_HYPERBOLA
Definition: define.h:51
Dtk_ToleranceSpecificationContainer::TypeAngularity
@ TypeAngularity
Definition: util_draw_dtk.hpp:6070
Dtk_RGB
Definition: dtk_rgb.hpp:7
DTK_WITHOUT_HIERARCHY
@ DTK_WITHOUT_HIERARCHY
Definition: util_draw_dtk.hpp:66
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:468
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_mesh_face::get_triangle_strip_indices
const Dtk_tab< Dtk_UInt32 > * get_triangle_strip_indices(Dtk_Size_t inI) const
Get inI-th triangle strip.
DTK_TYPE_ROUGHNESS
@ DTK_TYPE_ROUGHNESS
Definition: define.h:434
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:14
dtkErrorOpenFiles
@ dtkErrorOpenFiles
Definition: error_dtk.hpp:143
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:2392
Dtk_DumpXml_Dtk_CameraProjectionTypeEnum
Dtk_ErrorStatus Dtk_DumpXml_Dtk_CameraProjectionTypeEnum(FILE *F, const Dtk_Camera::ProjectionTypeEnum &inVal)
Definition: util_xml_dtk.cpp:3107
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:7114
DTK_TYPE_WELDING
@ DTK_TYPE_WELDING
Definition: define.h:437
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:7467
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:2650
Dtk_DumpXml_Dtk_Constraint_ConstraintValue
Dtk_ErrorStatus Dtk_DumpXml_Dtk_Constraint_ConstraintValue(FILE *F, const Dtk_Constraint::_ConstraintValue &inVal)
Definition: util_xml_dtk.cpp:8508
UgReaderModule
@ UgReaderModule
Definition: dtk_maindoc.hpp:34
Dtk_ToleranceSpecificationContainer::TypePosition
@ TypePosition
Definition: util_draw_dtk.hpp:6076
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:3062
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:3732
Dtk_ToleranceSpecificationContainer::TypeLineProfile
@ TypeLineProfile
Definition: util_draw_dtk.hpp:6066
Dtk_NodeConnector::SubEntity::GetSubEntityId
Dtk_ID GetSubEntityId() const
Definition: dtk_maindoc.hpp:1233