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	WritePrototype (Dtk_ComponentPtr inComponent, const Dtk_transfo &inMatrix)

Function Documentation

WriteComponent()

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

{
    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;
    err = inComponent->GetConceptionUnitScale(UnitFactor);
 
    //GetName
    Dtk_string ComponentName = inComponent->Name();
 
    //GetAttributes
    Dtk_InfoPtr attributes = inComponent->GetInfos();
    if (attributes.IsNotNULL())
    {
        int CompoActivationStatus, CompoBlankedStatus;
        Dtk_RGB CompoColor;
        CompoActivationStatus = attributes->GetActivationFlag(); // if CompoActivationStatus == 0 Component and his children aren't visible
        CompoBlankedStatus = attributes->GetBlankedStatus(); // if CompoBlankedStatus == 1 Component and his children aren't visible
        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);
        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 
            Dtk_tab<Dtk_Int32> activatedindex = inComponent->GetActivatedChildrenInCatalog(); //Activated components in Catalog
            Dtk_Size_t numactivatedchildren = activatedindex.size();
            if (numactivatedchildren > 0)
            {
                for (i = 0; i < numactivatedchildren; i++)
                {
                    Dtk_ComponentPtr activatedchild = inComponent->GetChild(activatedindex[i]);
                    WriteComponent(activatedchild, inMatrix);
                }
            }
            else
            {
                 Dtk_ComponentPtr defaultchild = inComponent->GetChild(defaultindex);
                 WriteComponent(defaultchild, inMatrix);
            }
        }
        //if you don't want to use default or activated component 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;
}

WriteDocument()

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;
}

WriteInstance()

Dtk_ErrorStatus WriteInstance

(

Dtk_ComponentPtr

inComponent

)

{
 
    //Instance represent a prototype with a matrix placement
    Dtk_string PrototypeName, InstanceName;
    PrototypeName = inComponent->Name();//Prototype Component name = prototype->Name()
    InstanceName = inComponent->InstanceName();//Instance 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);
    }
 
    //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;
}

WritePrototype()

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);
        }
 
    }
}