WriteDocument.cpp File Reference

Functions
Dtk_ErrorStatus	WriteComponent (Dtk_ComponentPtr inComponent, const Dtk_transfo &inMatrix=Dtk_transfo())
Dtk_ErrorStatus	WriteDocument (Dtk_MainDocPtr inDocument)

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;
    inComponent->GetConceptionUnitScale(unitFactor);
 
    // 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 save preview image if available.
    Dtk_PreviewPtr preview = inComponent->GetPreview();
    if (preview.IsNotNULL())
    {
        Dtk_Int32 size = preview->GetStreamSize();
        char *jpgImage = preview->GetStream();
        Dtk_string previewName = "ComponentPreview.jpg";
        FILE *jpg = previewName.OpenFile("wb");
        if (jpg)
        {
               // Write JPEG image data to file.
               fwrite(jpgImage, sizeof(char), size, jpg);
            fclose(jpg);
        }
    }
 
    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

)

{
    // 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();
        }
        return dtkNoError;
    }
 
    // Return error if the document is invalid.
    return dtkErrorNullPointer;
}