WriteComponent.hpp File Reference

Go to the source code of this file.

Functions
Dtk_ErrorStatus	WriteComponent (Dtk_ComponentPtr inComponent, const Dtk_transfo &inMatrix=Dtk_transfo())
Dtk_ErrorStatus	WriteDocument (Dtk_MainDocPtr inDocument)
Dtk_ErrorStatus	WriteInstance (Dtk_ComponentPtr inComponent)
void	WritePreview (const Dtk_PreviewPtr &inPreview, const Dtk_string &inName)
void	WritePrototype (Dtk_ComponentPtr inComponent, const Dtk_transfo &inMatrix)

Function Documentation

WriteComponent()

Dtk_ErrorStatus WriteComponent	(	Dtk_ComponentPtr	inComponent,
		const Dtk_transfo &	inMatrix = Dtk_transfo()
	)

{
    // Get the unit scale (e.g., 25.4 for inch) for the component.
    double unitFactor;
    auto error = inComponent->GetConceptionUnitScale(unitFactor);
     DTK_UNUSED( error );
 
    // Get the component name.
    Dtk_string componentName = inComponent->Name();
 
    // Get component attributes (activation, blanked status, color).
    Dtk_InfoPtr componentAttributes = inComponent->GetInfos();
    if (componentAttributes.IsNotNULL())
    {      
          // Get activation flag (1 if activated, 0 otherwise).
          int activationStatus = 1; 
          activationStatus = componentAttributes->GetActivationFlag();
 
          // Get blanked status (0: visible, 1: invisible, 2: construction geometry).
          int blankedStatus = 0;
          blankedStatus = componentAttributes->GetBlankedStatus();
          
          // Get color (RGB values).
          Dtk_RGB color = componentAttributes->GetColor();                 
    }
 
     // Get and write preview image if available.
     Dtk_PreviewPtr preview = inComponent->GetPreview();
     Dtk_string previewName = componentName + L"_";
     previewName.add_int( inComponent->GetID() );
     if( preview.IsNotNULL() )
     {
          WritePreview( preview, previewName );
     }
 
 
    if (IsXmlDumpActivated())
    {
          // initialize XML output for the component if XML export is enabled.
        XmlInitComponent(inComponent);
    }
 
    // Process the component based on its type.
    Dtk_Component::ComponentTypeEnum type = inComponent->ComponentType();
    switch (type)
    {
        // Instance: represents a prototype with a matrix placement.
        case Dtk_Component::InstanceComponentType:
        {
               // Write the component instance
            WriteInstance(inComponent);
            break;
        }
        // Prototype: check if already processed to avoid redundant work.
          // Use inComponent->GetID() to obtain its unique ID.
        case Dtk_Component::PrototypeComponentType:
        {
               // Write the prototype component with the given transformation matrix.
            WritePrototype(inComponent, inMatrix);
            break;
        }
        // Catalog: represents multiple possible configurations (scene, workspace, etc.).
        case Dtk_Component::CatalogComponentType:
        {
               // Get number of children and recursively write each child component.
               Dtk_Size_t numChildren = inComponent->GetNumChildren();
               if (numChildren > 0)
               {
                    // Get default component index in the catalog
                    Dtk_Int32 defaultComponentIndex = inComponent->GetDefaultChildInCatalog();
 
                    // Get activated component indices in the catalog
                    Dtk_tab<Dtk_Int32> activatedComponentIndices = inComponent->GetActivatedChildrenInCatalog();
 
                    // Get number of activated components in the catalog
                    Dtk_Size_t numActivatedComponents = activatedComponentIndices.size();
 
                    if (IsXmlDumpActivated())
                    {
                    // Write all non-activated and non-default children as XML dump entries (to provide a complete component tree)
                         for (Dtk_Size_t i = 0; i < numChildren; i++)
                         {
                              // Skip activated components
                              if( activatedComponentIndices.find( ( Dtk_Int32 )i ) >= 0 )
                              {
                                   continue;
                              }
                              
                              // Skip default component
                              if( defaultComponentIndex == ( Dtk_Int32 )i )
                              {
                                   continue;
                              }
 
                              // Write XML entry for non-activated and non-default child component
                              Dtk_ComponentPtr childComponent = inComponent->GetChild(i);
                              XmlInitComponent(childComponent);
                              XmlEndComponent();
                         }
                    }
 
                    // Write activated components or default component
                    if (numActivatedComponents > 0)
                    {
                         // Write all activated components
                         for ( Dtk_Size_t i = 0; i < numActivatedComponents; i++)
                         {
                              // Write the activated component
                              Dtk_ComponentPtr activatedComponent = inComponent->GetChild(activatedComponentIndices[i]);
                              WriteComponent(activatedComponent, inMatrix);
                         }
                    }
                    else
                    {
                         // Write the default component
                         Dtk_ComponentPtr defaultChildComponent = inComponent->GetChild(defaultComponentIndex);
                         WriteComponent(defaultChildComponent, inMatrix);
                    }
               }
 
            // If necessary, iterate over all children and select the desired one(s) to process based on their name.
               break;
          }
        // Virtual: component containing only children.
        case Dtk_Component::VirtualComponentType:
        {
               // Get number of child components and recursively write each child component.
            Dtk_Size_t numChildComponents = inComponent->GetNumChildren();
            for (Dtk_Size_t i = 0; i < numChildComponents; i++)
            {
                Dtk_ComponentPtr childComponent = inComponent->GetChild(i);
                WriteComponent(childComponent, inMatrix);
            }
            break;
        }
    }
 
    if (IsXmlDumpActivated())
    {
          // Finalize XML output for the component if XML export is enabled.
        XmlEndComponent();
    }
 
    return dtkNoError;
}

WriteDocument()

Dtk_ErrorStatus WriteDocument

(

Dtk_MainDocPtr

inDocument

)

{
     if( IsXmlDumpActivated() )
     {
          XmlInitMainDoc( inDocument );
     }
     // Retrieve the root component from the document.
    Dtk_ComponentPtr rootComponent = inDocument->RootComponent();
 
    // If the root component is valid, process it and its children.
    if (rootComponent.IsNotNULL())
    {
          // Initialize PDF output for the root component if PDF export is enabled.
        if (IsPdfDumpActivated())
        {
            PdfInitComponent(rootComponent);
        }
 
        // Recursively process the root component and its children.
        WriteComponent(rootComponent);
 
        // Finalize PDF output for the root component if PDF export is enabled.
        if (IsPdfDumpActivated())
        {
               // Finalize PDF output for the root component if PDF export is enabled.
            PdfEndComponent();
        }
    }
     if( IsXmlDumpActivated() )
     {
          XmlEndMainDoc( inDocument );
     }
 
 
    // Return error if the document is invalid.
     if( rootComponent.IsNULL() )
          return dtkErrorNullPointer;
     else
          return dtkNoError;
}

WriteInstance()

Dtk_ErrorStatus WriteInstance

(

Dtk_ComponentPtr

inComponent

)

{
     // Get the prototype name.
    Dtk_string prototypeName = inComponent->Name();
 
     // Get the instance name.
    Dtk_string instanceName = inComponent->InstanceName(); 
 
    // Get the prototype component (first child of instance) and its transformation matrix.
    Dtk_ComponentPtr prototype = inComponent->GetChild(0);
    Dtk_transfo matrix = inComponent->TransformationMatrix();
 
     // Get the ID of the prototype component.
    Dtk_ID childID = prototype->GetID();
 
     // Initialize PDF instance ID.
     Dtk_ID pdfInstanceID = 0;
 
     // Initialize PDF output for the instance if PDF export is enabled.
    if (IsPdfDumpActivated())
    {
        pdfInstanceID = PdfInitInstance(inComponent);
    }
 
    // Write the prototype component.
    // Note: The transformation matrix can be passed if needed for further processing.
    WriteComponent(prototype, Dtk_transfo());
 
    // Finalize PDF output for the instance if PDF export is enabled.
    if (IsPdfDumpActivated())
    {
        PdfEndInstance(pdfInstanceID, childID);
    }
 
    // Track the processed component by its ID to avoid redundant processing.
    if (ProcessedComponents.find(childID) < 0)
    {
        ProcessedComponents.push_back(childID);
    }
 
    return dtkNoError;
}

WritePreview()

void WritePreview	(	const Dtk_PreviewPtr &	inPreview,
		const Dtk_string &	inName
	)

{
     if( inPreview.IsNULL() )
          return;
 
     Dtk_Int32 size = inPreview->GetStreamSize();
     char* imageData = inPreview->GetStream();
 
     if( size <= 0 || imageData == nullptr )
          return;
 
     Dtk_string previewExt;
 
     switch( inPreview->GetType() )
     {
          case PREVIEW_TYPE_DETK_JPG:
               previewExt = "jpg";
               break;
          case PREVIEW_TYPE_DETK_BMP:
               previewExt = "bmp";
               break;
          case PREVIEW_TYPE_DETK_PNG:
               previewExt = "png";
               break;
          case PREVIEW_TYPE_DETK_CGM:
               previewExt = "cgm";
               break;
          case PREVIEW_TYPE_DETK_GIF:
               previewExt = "gif";
               break;
          case PREVIEW_TYPE_DETK_TIFF:
               previewExt = "tiff";
               break;
          case PREVIEW_TYPE_DETK_ICO:
               previewExt = "ico";
               break;
          case PREVIEW_TYPE_DETK_EMF:
               previewExt = "emf";
               break;
          case PREVIEW_TYPE_DETK_UNKNOWN:
          default:
               previewExt = "jpg"; // Default to jpg if type is unknown
               break;
     }
 
     Dtk_string previewName = inName + "_Preview." + previewExt;
     FILE* previewPtr = previewName.OpenFile( "wb" );
     if( previewPtr )
     {
          fwrite( imageData, sizeof( char ), size, previewPtr );
          fclose( previewPtr );
          //std::cout << "Writing Preview " << previewName.c_str() << std::endl;
     }
}

WritePrototype()

void WritePrototype	(	Dtk_ComponentPtr	inComponent,
		const Dtk_transfo &	inMatrix
	)

{
     // Get the component ID.
    Dtk_ID componentID = inComponent->GetID();
 
     // Check if the component has already been processed.
     // Only process the prototype if it hasn't been processed yet.
    Dtk_Int32 componentIndex = ProcessedComponents.find(componentID);
    if (componentIndex == -1)
    {
        Dtk_NodePtr rootNode;
 
          // Get the Datakit API instance.
        Dtk_API *myAPI = Dtk_API::GetAPI();
 
        // Recursively process all child components (instances, sub-assemblies, etc.).
        Dtk_Size_t numChildComponents = inComponent->GetNumChildren();
        for ( Dtk_Size_t i = 0; i < numChildComponents; i++)
        {
               // Get current child component.
            Dtk_ComponentPtr childComponent = inComponent->GetChild(i);
 
               // Recursively write the child component with the current transformation matrix.
            WriteComponent(childComponent, inMatrix);
        }
 
        // Read the construction tree for this prototype.
        Dtk_ErrorStatus errorStatus;
          if( inComponent->IsAvailabilityFlaggedAs(Dtk_Component::ComponentMissing) )
          {
               errorStatus = dtkErrorFileNotExist;
          }
          else
          {
               // Read the construction tree of the component; rootNode will point to the tree's root on success.
               errorStatus = myAPI->ReadComponent( inComponent, rootNode );
          }
 
        // If the construction tree is valid, process it.
        // A rootNode == NULL with err == dtkNoError means the component is empty.
        if (errorStatus == dtkNoError && rootNode.IsNotNULL())
        {
            // Set the current matrix for flattening assemblies.
            CurrentMatrix = inMatrix;
 
            // Recursively process the root node and its children.
            WriteNode(rootNode);
 
            // Write global data set and metadata to XML if XML export is enabled.
            if (IsXmlDumpActivated())
            {
                XmlWriteGlobalDataSet(inComponent->GetGlobalDataSet());
 
                Dtk_Size_t numMetaData = inComponent->GetNumMetaData();
                if (numMetaData)
                {
                    for ( Dtk_Size_t i = 0; i < numMetaData; i++)
                    {
                        XmlWriteMetaData(inComponent->GetMetaData(i));
                    }
                }
            }
        }
 
        // Write metadata to PDF if PDF export is enabled.
        if (IsPdfDumpActivated())
        {
            PdfWriteMetaData(inComponent);
        }
 
        // Finalize and free resources for the component.
        errorStatus = myAPI->EndComponent(inComponent);
    }
    else
    {
        // If the prototype has already been processed, handle the PDF instance case.
        // Use the unique ID returned by GetID() to map the component to your write ID.
        if (IsPdfDumpActivated())
        {
            PdfInstanceExistingPrototype(componentIndex);
        }
    }
}