Through Assemblies

Sample to write a Dtk_MainDoc
Sample to write a Dtk_Component
Sample to write a Dtk_Component type Instance
Sample to write a Dtk_Component type Prototype
Selection Set sample

Sample to write a Dtk_MainDoc

 
#include "datakit.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
 
 
extern Dtk_string inputFileName;
 
Dtk_ErrorStatus WriteComponent(Dtk_ComponentPtr inComponent, const Dtk_transfo &inMatrix = Dtk_transfo());
 
//This function is a sample on how to write document
// Dtk_Document represent Assembly tree of model
Dtk_ErrorStatus WriteDocument(Dtk_MainDocPtr inDocument)
{
    //First we get the root component in the document
    Dtk_ComponentPtr RootComponent = inDocument->RootComponent();
    //if no Error we write the Component
    if (RootComponent.IsNotNULL())
    {
        if (IsPdfDumpActivated())
        {
            PdfInitComponent(RootComponent);
        }
 
          //Go Through the Root Component and children
        WriteComponent(RootComponent);
 
        if (IsPdfDumpActivated())
        {
               PdfEndComponent();
        }
        return dtkNoError;
    }
 
    return dtkErrorNullPointer;
}
 
 

Sample to write a Dtk_Component

 
#include "datakit.h"
#include "WriteComponent.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
 
 
//This function is a sample on how to write component :it is recursive function
// Dtk_Component can be an instance, a prototype and have children
Dtk_ErrorStatus WriteComponent(Dtk_ComponentPtr inComponent, const Dtk_transfo &inMatrix)
{
    Dtk_Size_t i;
 
    //Datakit component are given in MM, if original model had other unit you can get it with GetConceptionUnitScale()
    // UnitFactor = 25.4 for inch 
     double UnitFactor;
     Dtk_ErrorStatus err = inComponent->GetConceptionUnitScale(UnitFactor);
 
    //GetName
    Dtk_string ComponentName = inComponent->Name();
 
    //GetAttributes
    Dtk_InfoPtr attributes = inComponent->GetInfos();
    if (attributes.IsNotNULL())
    {
        int CompoActivationStatus = attributes->GetActivationFlag(); // if CompoActivationStatus == 0 Component and his children aren't visible
        int CompoBlankedStatus = attributes->GetBlankedStatus(); // if CompoBlankedStatus == 1 Component and his children aren't visible
        Dtk_RGB CompoColor = attributes->GetColor(); // if CompoBlankedStatus == 1 Component and his children are using this color 
    }
 
    //You can GetPreview if you want to handle it
    Dtk_PreviewPtr TmpPreview = inComponent->GetPreview();
    if (TmpPreview.IsNotNULL())
    {
        Dtk_Int32 size = TmpPreview->GetStreamSize();
        char *jpgimage = TmpPreview->GetStream();
        Dtk_string Preview_name = "ComponentPreview.jpg";
        FILE *jpg = Preview_name.OpenFile("wb");
        if (jpg)
        {
            fwrite(jpgimage, sizeof(char), size, jpg);
            fclose(jpg);
        }
    }
 
     if (IsXmlDumpActivated())
     {
          XmlInitComponent(inComponent);
     }
 
    //You have 4 types for Component
    Dtk_Component::ComponentTypeEnum type = inComponent->ComponentType();
    switch (type)
    {
        //Instance represent a prototype with a matrix placement
    case Dtk_Component::InstanceComponentType:
    {
        WriteInstance(inComponent, inMatrix);
        break;
    }
    //Prototype (you have to check if you ever read and write it to don't waste time)
    //you can use the method inComponent->GetID() to get Unique ID for Component
    case Dtk_Component::PrototypeComponentType:
    {
        WritePrototype(inComponent, inMatrix);
        break;
    }
    //Catalog Component represent a choice of several possible configuration 
    //(like scene in catiav5, workspace in catiav4, configuration in solidworks)
    //Default is the first child 
    case Dtk_Component::CatalogComponentType:
    {
        Dtk_string name = inComponent->Name();//Component name
 
        Dtk_Size_t numComp = inComponent->GetNumChildren();
        if (numComp > 0)
        {
               if (IsXmlDumpActivated())
               {
                    for (i = 0; i < numComp; i++)
                    {
                         Dtk_ComponentPtr child = inComponent->GetChild(i);
                         XmlInitComponent(child);
                         XmlEndComponent();
                    }
               }
            Dtk_Int32 defaultindex = inComponent->GetDefaultChildInCatalog(); //Get Default child to use
            Dtk_ComponentPtr defaultchoice = inComponent->GetChild(defaultindex);
            if (defaultchoice.IsNotNULL())
            {
                WriteComponent(defaultchoice, inMatrix);
            }
        }
        //if you don't want to use default you have to scan all children and choose the one you want to convert (see their name)
        break;
    }
    //Component containing only children 
    case Dtk_Component::VirtualComponentType:
    {
        Dtk_string name;
        Dtk_Size_t NumChildren;
 
        name = inComponent->Name();//Component name
 
        NumChildren = inComponent->GetNumChildren();
        for (i = 0; i < NumChildren; i++)
        {
            Dtk_ComponentPtr child = inComponent->GetChild(i);
            WriteComponent(child, inMatrix);
        }
        break;
 
    }
    }
     if (IsXmlDumpActivated())
     {
          XmlEndComponent();
     }
    return dtkNoError;
}
 
 
 

Sample to write a Dtk_Component type Instance

 
#include "datakit.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
#include "WriteComponent.hpp"
 
 
 
 
extern Dtk_tab<Dtk_ID>  ComponentProcessed;
 
//This function is a sample on how to write component :it is recursive function
// Dtk_Component can be an instance, a prototype and have children
Dtk_ErrorStatus WriteInstance(Dtk_ComponentPtr inComponent, const Dtk_transfo &inMatrix)
{
 
    //Instance represent a prototype with a matrix placement
    Dtk_string ComponentName;
    ComponentName = inComponent->Name();//Component name
    Dtk_ComponentPtr prototype = inComponent->GetChild(0);
    Dtk_transfo matrix = inComponent->TransformationMatrix();
    Dtk_ID pdfInstID = 0;
    Dtk_ID childID = inComponent->GetChild(0)->GetID();
 
    if (IsPdfDumpActivated())
    {
          pdfInstID = PdfInitInstance(inComponent);
    }
 
     
    //Dtk_transfo newMatrix = inMatrix * matrix;
 
    //you have to write matrix and instance the prototype
    WriteComponent(prototype, Dtk_transfo());
    
 
 
    if (IsPdfDumpActivated())
    {
          PdfEndInstance(pdfInstID, childID);
    }
 
    if (ComponentProcessed.find(childID) < 0)
    {
        ComponentProcessed.push_back(childID);
    }
 
    return dtkNoError;
}
 

Sample to write a Dtk_Component type Prototype

 
#include "datakit.h"
#include "../../WritingSample/PdfWrite/PdfWrite.hpp"
#include "../../WritingSample/XmlWrite/XmlWrite.hpp"
#include "../ThroughData/WriteNode.hpp"
#include "WriteComponent.hpp"
 
 
 
//To Flatten Assemblies
Dtk_transfo CurrentMatrix = Dtk_transfo();
Dtk_tab<Dtk_ID>  ComponentProcessed;
 
void WritePrototype(Dtk_ComponentPtr inComponent, const Dtk_transfo &inMatrix)
{
    Dtk_Size_t i;
    Dtk_ID ComponentID = inComponent->GetID();
    Dtk_Int32 ComponentIndex;
    ComponentIndex = ComponentProcessed.find(ComponentID);
 
    if (ComponentIndex == -1)
    {
        Dtk_NodePtr RootNode;
        Dtk_API *inAPI = Dtk_API::GetAPI();
 
        //it can also contain some instances
        Dtk_Size_t NumChildren = inComponent->GetNumChildren();
        for (i = 0; i < NumChildren; i++)
        {
            Dtk_ComponentPtr child = inComponent->GetChild(i);
            WriteComponent(child, inMatrix);
        }
 
        //Get the Construction tree for this prototype
        Dtk_ErrorStatus err;
        if (inComponent->ComponentAvailability() == Dtk_Component::ComponentMissing)
            err = dtkErrorFileNotExist;
        else
            err = inAPI->ReadComponent(inComponent, RootNode);
 
        //a RootNode=  NULL with err == dtkNoError means that component is empty
        if (err == dtkNoError && RootNode.IsNotNULL())
        {
            // Set matrix to apply to all node if you flat assemblies
            CurrentMatrix = inMatrix;
 
               //Go Through the Root Node and children
            WriteNode(RootNode);
 
               if (IsXmlDumpActivated())
               {
                    XmlWriteGlobalDataSet(inComponent->GetGlobalDataSet());
 
                    Dtk_Size_t NumMetaData;
                    NumMetaData = inComponent->GetNumMetaData();
                    if (NumMetaData)
                    {
                         for (i = 0; i < NumMetaData; i++)
                         {
                              XmlWriteMetaData( inComponent->GetMetaData(i));
                         }
                    }
               }
        }
 
        if (IsPdfDumpActivated())
        {
               PdfWriteMetaData(inComponent);
        }
 
        //We close the opened Component and free his construction tree
        err = inAPI->EndComponent(inComponent);
 
    }
    else
    {
        //Get the prototype you ever write
        //The Component has a unique ID given by GetID to help to map it with your Write ID
        if (IsPdfDumpActivated())
        {
               PdfInstanceExistingPrototype(ComponentIndex);
        }
 
    }
}