PdfWrite.cpp File Reference

Functions
void	ActivatePdfDump (Dtk_bool inDumpPDF)
Dtk_bool	IsPdfDumpActivated ()
void	PdfEndComponent ()
void	PdfEndInstance (Dtk_ID pdfInstID, Dtk_ID childID)
void	PdfEndNode ()
void	PdfEndWrite (const Dtk_string &inInputFile)
Dtk_ID	PdfInitComponent (Dtk_ComponentPtr inComponent)
Dtk_ID	PdfInitInstance (Dtk_ComponentPtr inComponent)
Dtk_ID	PdfInitNode (Dtk_NodePtr inNode)
Dtk_ErrorStatus	PdfInitWrite (const Dtk_string &inInputFileName, const Dtk_string &inOutputFolder)
void	PdfInstanceExistingPrototype (Dtk_ID ComponentIndex)
void	PdfWriteDrawingNode (Dtk_NodePtr inNode)
void	PdfWriteEntity (Dtk_EntityPtr inEntity)
void	PdfWriteMetaData (Dtk_ComponentPtr inComponent)
void	PdfWriteMetaData (Dtk_tab< Dtk_MetaDataPtr > &inTabMetadata)

Variables
Dtk_tab< Dtk_ID >	ComponentProcessed
std::map< Dtk_Node::NodeDataTypeEnum, Dtk_Size_t >	modelInventory
Dtk_tab< Dtk_ID >	PdfComponents
Dtk_bool	toDumpPDF

Function Documentation

ActivatePdfDump()

void ActivatePdfDump

(

Dtk_bool

inDumpPDF

)

{
     toDumpPDF = inDumpPDF;
}

IsPdfDumpActivated()

Dtk_bool IsPdfDumpActivated

(

)

{
     return toDumpPDF;
}

PdfEndComponent()

void PdfEndComponent

(

)

{
     Pdfw::EndNode();
}

PdfEndInstance()

void PdfEndInstance	(	Dtk_ID	pdfInstID,
		Dtk_ID	childID
	)

{
     if ( ComponentProcessed.find(childID) < 0)
     {
          PdfComponents.push_back(pdfInstID);
     }
     Pdfw::EndNode();
}

PdfEndNode()

void PdfEndNode

(

)

{
     Pdfw::EndNode();
}

PdfEndWrite()

void PdfEndWrite

(

const Dtk_string &

inInputFile

)

{
     Dtk_UInt32 artworkIndex = 0;
     Pdfw::Layout::End3DArtwork(artworkIndex);
     CreatePDFLayout(inInputFile, artworkIndex, modelInventory);
     modelInventory.clear();
     Pdfw::Layout::EndPage();
     Pdfw::EndWrite();
}

PdfInitComponent()

Dtk_ID PdfInitComponent

(

Dtk_ComponentPtr

inComponent

)

{
     Dtk_InfoPtr infos = inComponent->GetInfos();
     Dtk_string name = inComponent->Name();
     Dtk_ID pdfID;
     Pdfw::InitNode(name, Dtk_transfo(), infos, pdfID);
     return pdfID;
}

PdfInitInstance()

Dtk_ID PdfInitInstance

(

Dtk_ComponentPtr

inComponent

)

{
     Dtk_ID pdfInstID;
     Dtk_string ComponentName;
     ComponentName = inComponent->Name();//Component name
 
     Dtk_InfoPtr infos = inComponent->GetInfos();
     Dtk_transfo instanceTransfo;
 
     if (inComponent->InstanceName().len() > 0)
          ComponentName += " (" + inComponent->InstanceName() + ")";
 
     instanceTransfo = inComponent->TransformationMatrix();
     Pdfw::InitNode(ComponentName, instanceTransfo, infos, pdfInstID);
     Pdfw::StorePrototype(pdfInstID);
     return pdfInstID;
}

PdfInitNode()

Dtk_ID PdfInitNode

(

Dtk_NodePtr

inNode

)

{
     Dtk_ID pdfID;
     Dtk_string NodeName = inNode->Name();
     Dtk_InfoPtr nodeInfo = inNode->GetInfos();
     Dtk_bool nodeVisi = nodeInfo->GetBlankedStatus() ? DTK_FALSE : DTK_TRUE;
     Pdfw::InitNode(NodeName, Dtk_transfo(), nodeVisi, pdfID);
     if (nodeInfo.IsNotNULL())
          Pdfw::AddNodeRenderInfo(nodeInfo->GetRenderInfos());
     return pdfID;
}

PdfInitWrite()

Dtk_ErrorStatus PdfInitWrite	(	const Dtk_string &	inInputFileName,
		const Dtk_string &	inOutputFolder
	)

{// Initialize writing
     Dtk_ErrorStatus stErrorPdf;
     Dtk_string outputPDFFile;
     Pdfw::WriteOptions options;
 
     // Pdf options :
     // We choose between PRC or U3D 3D format
     options.WritePRC = DTK_TRUE;
     // We will generate our own layout
     options.Layout.CreateAutomaticLayout = DTK_FALSE;
#ifndef Linux
     // We choose the font to use
     options.Layout.TTF_Font = "C:/Windows/Fonts/arial.ttf";
     options.Layout.RasterizeTexts = DTK_FALSE;
#endif
     // We handle line thickness
     options.Layout.WriteLineThickness = DTK_TRUE;
     // We set a transparent background
     options.TransparentBackground = DTK_TRUE;
 
     outputPDFFile = inInputFileName + "_dtk.pdf";
     if (inOutputFolder.len() > 0)
          outputPDFFile = inOutputFolder + inInputFileName.filename() +inInputFileName.extension() + "_dtk.pdf";
     // Initializing the writer
     stErrorPdf = Pdfw::InitWrite(outputPDFFile, "", NULL, options);
 
     if (stErrorPdf == dtkNoError)
          cout << "Creating Pdf file... " << outputPDFFile.c_str() << endl;
     else
          cout << "Warning : Pdf Write failed : " << dtkTypeError(stErrorPdf).c_str() << endl;
 
 
 
     //**************************************************************************************************************//
     //layout
     //**************************************************************************************************************//
     // Page creation
     Pdfw::Layout::InitPage();
     // Size of Page 
     Pdfw::Layout::SetCurrentPageSize(Pdfw::Layout::SIZE_A5, Pdfw::Layout::LANDSCAPE);
 
     // PDF 3D Artwork initialization
     Pdfw::Layout::Init3DArtwork(inInputFileName.filename());
 
     modelInventory.clear();
     return stErrorPdf;
}

PdfInstanceExistingPrototype()

void PdfInstanceExistingPrototype

(

Dtk_ID

ComponentIndex

)

{
     Pdfw::ReinstanciatePrototype(PdfComponents[ComponentIndex]);
}

PdfWriteDrawingNode()

void PdfWriteDrawingNode

(

Dtk_NodePtr

inNode

)

{
     Dtk_DrawingPtr TmpDrawing = inNode->GetDtk_DrawingPtr();
 
     //Count Drawing
     modelInventory[Dtk_Node::DrawingType]++;
}

PdfWriteEntity()

void PdfWriteEntity

(

Dtk_EntityPtr

inEntity

)

{
     Pdfw::WriteEntity(inEntity);
     if (inEntity->get_type_detk() == DTK_TYPE_BODY)
          modelInventory[Dtk_Node::BodyType]++;
     if (inEntity->get_type_detk() == DTK_TYPE_MESH)
          modelInventory[Dtk_Node::MeshType]++;
     if (inEntity->get_type_detk() == DTK_TYPE_FDT)
          modelInventory[Dtk_Node::FdtType]++;
}

PdfWriteMetaData() [1/2]

void PdfWriteMetaData

(

Dtk_ComponentPtr

inComponent

)

{
     Dtk_Size_t i,NumMetaData;
     NumMetaData = inComponent->GetNumMetaData();
     if (NumMetaData)
     {
          Dtk_tab<Dtk_MetaDataPtr> tabMetadata;
          for (i = 0; i < NumMetaData; i++)
          {
               tabMetadata.push_back(inComponent->GetMetaData(i));
          }
          Pdfw::AddNodeMetadata(tabMetadata);
     }
} 

PdfWriteMetaData() [2/2]

void PdfWriteMetaData

(

Dtk_tab< Dtk_MetaDataPtr > &

inTabMetadata

)

{
     Pdfw::AddNodeMetadata(inTabMetadata);   
}

Variable Documentation

ComponentProcessed

Dtk_tab<Dtk_ID> ComponentProcessed

extern

modelInventory

std::map<Dtk_Node::NodeDataTypeEnum, Dtk_Size_t> modelInventory

PdfComponents

Dtk_tab<Dtk_ID> PdfComponents

toDumpPDF

Dtk_bool toDumpPDF