lili/Hoops_Exchange
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
019570564b1c08fe3ddba152104880d8c75df3ab
Hoops_Exchange/publish/publishsource/DemoDataModel/DemoDataModel.cpp
ninja c06fe95a1e Add publish
2025-12-15 22:10:55 +08:00

1149 lines
48 KiB
C++
Raw Blame History

/***********************************************************************************************************************
*
* Copyright (c) 2010 - 2022 by Tech Soft 3D, Inc.
* The information contained herein is confidential and proprietary to Tech Soft 3D, Inc., and considered a trade secret
* as defined under civil and criminal statutes. Tech Soft 3D shall pursue its civil and criminal remedies in the event
* of unauthorized use or misappropriation of its trade secrets. Use of this information by anyone other than authorized
* employees of Tech Soft 3D, Inc. is granted only under a written non-disclosure agreement, expressly prescribing the
* scope and manner of such use.
*
***********************************************************************************************************************/
/**
\file DemoDataModel.cpp
Demonstrates how to create a table in which the table data is linked to the model data.
***********************************************************************************************************************/
#define INITIALIZE_A3D_API
#define HOOPS_PRODUCT_PUBLISH_ADVANCED
#include <A3DSDKIncludes.h>
#include "../common.hpp"
#include "../CommonInit.h"
#include <sstream>
#include <ostream>
#include <iostream>
#include <vector>
// default sample arguments:
// in visual c++: the current directory is set through properties to $OutDir, which is $(Platform)\$(Configuration)
// in linux: the current directory is supposed to be the same as this cpp file
#ifdef _MSC_VER
# define IN_3DFILE_1 SAMPLES_DATA_DIRECTORY"\\prc\\Crank-Instructions.prc"
# define IN_3DFILE_2 SAMPLES_DATA_DIRECTORY"\\prc\\pmi_Sample.prc"
# define IN_3DFILE_3 SAMPLES_DATA_DIRECTORY"\\prc\\_micro engine.prc"
# define PDF_TEMPLATE_1 SAMPLES_DATA_DIRECTORY"\\pdf_templates\\DemoDataModelTemplate.pdf"
# define PDF_TEMPLATE_2 SAMPLES_DATA_DIRECTORY"\\pdf_templates\\DemoDataModelTemplate-Views.pdf"
# define PDF_TEMPLATE_3 SAMPLES_DATA_DIRECTORY"\\pdf_templates\\DemoDataModelTemplate-BOM.pdf"
# define ICONS_PATH SAMPLES_DATA_DIRECTORY"\\images\\"
# define ICON_CAROUSEL_PREV SAMPLES_DATA_DIRECTORY"\\images\\carouselprevrot.bmp"
# define ICON_CAROUSEL_NEXT SAMPLES_DATA_DIRECTORY"\\images\\carouselnextrot.bmp"
# define POSTER_PATH SAMPLES_DATA_DIRECTORY"\\images\\pleaseactivate.bmp"
# define OUT_FILE SAMPLES_PUBLISH_GALLERY_DIRECTORY"\\sample_DemoDataModel.pdf"
#else
# define IN_3DFILE_1 SAMPLES_DATA_DIRECTORY"/prc/Crank-Instructions.prc"
# define IN_3DFILE_2 SAMPLES_DATA_DIRECTORY"/prc/pmi_Sample.prc"
# define IN_3DFILE_3 SAMPLES_DATA_DIRECTORY"/prc/_micro engine.prc"
# define PDF_TEMPLATE_1 SAMPLES_DATA_DIRECTORY"/pdf_templates/DemoDataModelTemplate.pdf"
# define PDF_TEMPLATE_2 SAMPLES_DATA_DIRECTORY"/pdf_templates/DemoDataModelTemplate-Views.pdf"
# define PDF_TEMPLATE_3 SAMPLES_DATA_DIRECTORY"/pdf_templates/DemoDataModelTemplate-BOM.pdf"
# define ICONS_PATH SAMPLES_DATA_DIRECTORY"/images/"
# define ICON_CAROUSEL_PREV SAMPLES_DATA_DIRECTORY"/images/carouselprevrot.bmp"
# define ICON_CAROUSEL_NEXT SAMPLES_DATA_DIRECTORY"/images/carouselnextrot.bmp"
# define POSTER_PATH SAMPLES_DATA_DIRECTORY"/images/pleaseactivate.bmp"
# define OUT_FILE SAMPLES_PUBLISH_GALLERY_DIRECTORY"/sample_DemoDataModel.pdf"
#endif
const size_t MAXSZFILENAME = 4096;
// rgb colors
#define COL_RED 1.0, 0.0, 0.0
A3DVoid mallocAndSetString(const A3DUTF8Char* srcString, A3DUTF8Char*& destString);
// tools functions
A3DStatus PageGetTextField(A3DPDFPage* pPage, const std::string& sFieldId, A3DPDFTextField** ppField);
A3DStatus PageGetButtonField(A3DPDFPage* pPage, const std::string& sFieldId, A3DPDFButton** ppField);
A3DStatus PageGetListBoxField(A3DPDFPage* pPage, const std::string& sFieldId, A3DPDFListBox** ppField);
// fill data functions sample 1
A3DStatus CreateTable_Sple1_Statics(A3DPDFDocument* pDoc, A3DPDFDataTable*& pDataTable_Statics);
A3DStatus CreateTable_Sple1_3DModel_Bom(A3DPDFDocument* pDoc, A3DAsmModelFile* pModelFile, A3DRWParamsPrcWriteHelper* pPRCWriteHelper,
const std::string& sPathIcons,
int& iKeyNode3dUID, int& iKeyNode3dName, int& iKeyNode3dInstance,
int& iKeyBomNumArt, int& iKeyBomNamePart, int& iKeyBomQty, int& iKeyBomMaterial, int& iKeyBomIcon,
A3DPDFDataTable*& pDataTable3D, A3DPDFDataTable*& pDataTableBom,
A3DPDFDataTable* pDataTableManufacturers);
A3DStatus CreateTable_Sple1_CBFILTER(A3DPDFDocument* pDoc, A3DPDFDataTable*& pDataTable);
A3DStatus CreateTable_Sple1_Manufacturers(A3DPDFDocument* pDoc, A3DPDFDataTable*& pDataTable);
A3DStatus CreateRelationship_Sple1_CBFILTER_To_Bom(A3DPDFDocument* pDoc, A3DPDFDataTable* pDataTable_Source, A3DPDFDataTable* pDataTable_Target);
// fill data functions sample 2
A3DStatus CreateTable_Sple2_Statics(A3DPDFDocument* pDoc, A3DPDFDataTable*& pDataTable_Statics);
A3DStatus CreateTable_Sple2_ViewNames(A3DPDFDocument* pDoc, A3DPDFDataTable*& pDataTable);
A3DStatus CreateTable_Sple2_3DModel(A3DPDFDocument* pDoc, A3DAsmModelFile* pModelFile, A3DRWParamsPrcWriteHelper* pPRCWriteHelper,
int& iKeyNode3dUID, int& iKeyPmiName, int& iKeyPmiType, int& iKeyPmiValue, int& iKeyPmiTol,
A3DPDFDataTable*& pDataTable3D, A3DPDFDataTable*& pDataTable_Pmis);
//A3DStatus createTable_Sple2_3DViews(A3DPDF3DArtwork* p3DArtwork, A3DPDFDocument* pDoc, A3DPDFDataTable3DViews*& pDataTable);
A3DStatus CreateTable_Sple2_3DViews_WithCarousel(A3DPDFDocument* pDoc, A3DPDF3DArtwork* p3DArtwork, A3DAsmModelFile* pModelFile,
A3DPDFDataTable3DViews*& pDataTable);
A3DStatus CreateRelationship_Sple2_ViewNames_To_Views(A3DPDFDocument* pDoc, A3DPDFDataTable* pDataTable_Source, A3DPDFDataTable* pDataTable_Target);
A3DStatus CreateRelationship_Sple2_View_To_Pmis(A3DPDFDocument* pDoc, A3DPDFDataTable* pDataTable_Source, A3DPDFDataTable* pDataTable_Target);
//A3DStatus createRelationship_Sple2_Pmis_To_3D(A3DPDFDocument* pDoc, A3DPDFDataTable* pDataTable_Source, A3DPDFDataTable* pDataTable_Target);
// fill data functions sample 3
A3DStatus CreateTable_Sple3_Statics(A3DPDFDocument* pDoc, A3DPDFDataTable*& pDataTable_Statics);
A3DStatus CreateTable_Sple3_3DModel_Bom(A3DPDFDocument* pDoc, A3DAsmModelFile* pModelFile, A3DRWParamsPrcWriteHelper* pPRCWriteHelper,
const std::string& sPathIcons,
int& iKeyNode3dUID, int& iKeyNode3dInstance,
int& iKeyBomNumArt, int& iKeyBomNamePart, int& iKeyBomQty, int& iKeyBomIcon,
A3DPDFDataTable*& pDataTable3D, A3DPDFDataTable*& pDataTableBom);
//######################################################################################################################
// writes a text line on the page
A3DStatus WriteTextString(A3DPDFDocument* pDoc, A3DPDFPage* pPage, A3DPDFEFontName eFontName, A3DInt32 iFontSize,
A3DDouble dR, A3DDouble dG, A3DDouble dB, const A3DUTF8Char* pcTextString,
A3DInt32 iPosX, A3DInt32 iPosY)
{
A3DStatus iRet = A3D_SUCCESS;
A3DPDFTextData sTextData;
A3D_INITIALIZE_DATA(A3DPDFTextData, sTextData);
sTextData.m_eFontName = eFontName;
sTextData.m_iFontSize = iFontSize;
sTextData.m_sColor.m_dRed = dR;
sTextData.m_sColor.m_dGreen = dG;
sTextData.m_sColor.m_dBlue = dB;
sTextData.m_pcTextString = const_cast<A3DUTF8Char*>(pcTextString);
A3DPDFText* pText = NULL;
CHECK_RET(A3DPDFTextCreate(pDoc, &sTextData, &pText));
CHECK_RET(A3DPDFPageInsertText(pPage, pText, iPosX, iPosY)); // posX, posY from the bottom left
return iRet;
}
//######################################################################################################################
A3DStatus Create3DAnnot(A3DPDFDocument* pDoc,
const A3DUTF8Char* pcFileName,
A3DPDFImage* pPoster,
const A3DUTF8Char* pcInjsfile,
A3DPDF3DArtwork** pp3DArtwork,
A3DPDF3DAnnot** pp3DAnnot,
A3DRWParamsPrcWriteHelper** ppA3DRWParamsPrcWriteHelper,
A3DAsmModelFile** ppModelFile)
{
A3DStatus iRet = A3D_SUCCESS;
*pp3DAnnot = NULL;
*ppModelFile = NULL;
A3DPDF3DStream* pStream = NULL;
char tempfilename[1024];
// Publish 6.0 - Particularity when the input 3D model is stored in a PDF file. The functions to read the 3D data from the PDF
// are not the same as for other formats.
if(strstr(pcFileName, ".pdf") != NULL)
{
A3DStream3DPDFData* pStream3DPDFData;
A3DInt32 iNumStreams;
iRet = A3DGet3DPDFStreams(pcFileName, &pStream3DPDFData, &iNumStreams);
if(iRet!=A3D_SUCCESS || iNumStreams == 0)
return A3D_ERROR;
// a real use case might parse every streams in the input file. Here we just take the first one (pStream3DPDFData[0]).
// even an input PRC file must be read in memory and mapped into modelfile data structures
if(pStream3DPDFData[0].m_bIsPrc)
{
iRet = A3DAsmModelFileLoadFromPrcStream(pStream3DPDFData[0].m_acStream, pStream3DPDFData[0].m_uiStreamSize, NULL, ppModelFile);
if(iRet!=A3D_SUCCESS)
{
A3DGet3DPDFStreams(NULL, &pStream3DPDFData, &iNumStreams); // to clean up the array of stream data
return iRet;
}
}
// a U3D stream must first be stored as a physical file ; then 2 situations occur:
// 1. read and LOAD the physical file into a modelfile using the common A3DAsmModelFileLoadFromFile function, then transform the modelfile into a stream
// OR
// 2. read the physical file into a binary stream (not loaded into a modelfile) using A3DPDF3DStreamCreateFromFile function
// In this sample we illustrate the workflow 2.
else
{
sprintf(tempfilename, "%s.u3d", OUT_FILE);
FILE * pFile=NULL;
#ifdef _MSC_VER
errno_t ret = fopen_s(&pFile, tempfilename , "wb");
if(ret == 0 && pFile)
#else
pFile = fopen(tempfilename , "wb");
if(pFile)
#endif
{
fwrite(pStream3DPDFData[0].m_acStream, 1, pStream3DPDFData[0].m_uiStreamSize, pFile);
fclose(pFile);
}
// physical file to stream
CHECK_RET(A3DPDF3DStreamCreateFromFile(pDoc, tempfilename, false, &pStream));
// !!! the file will have to be disposed of afterwards
remove(tempfilename);
}
A3DGet3DPDFStreams(NULL, &pStream3DPDFData, &iNumStreams); // to clean up the array of stream data
}
// Load the physical file in a ModelFile data structure if not already done
if(pStream == NULL && *ppModelFile == NULL)
{
// reading the input CAD file; the file can be disposed of afterwards.
A3DRWParamsLoadData sReadParam;
A3D_INITIALIZE_DATA(A3DRWParamsLoadData, sReadParam);
sReadParam.m_sGeneral.m_bReadSolids = true;
sReadParam.m_sGeneral.m_bReadSurfaces = true;
sReadParam.m_sGeneral.m_bReadWireframes = true;
sReadParam.m_sGeneral.m_bReadPmis = true;
sReadParam.m_sGeneral.m_bReadAttributes = true;
sReadParam.m_sGeneral.m_bReadHiddenObjects = false;
sReadParam.m_sGeneral.m_bReadConstructionAndReferences = false;
sReadParam.m_sGeneral.m_bReadActiveFilter = true;
sReadParam.m_sGeneral.m_eReadingMode2D3D = kA3DRead_3D;
sReadParam.m_sGeneral.m_eReadGeomTessMode = kA3DReadGeomAndTess;
sReadParam.m_sGeneral.m_eDefaultUnit = kA3DUnitUnknown;
sReadParam.m_sPmi.m_bAlwaysSubstituteFont = false;
sReadParam.m_sPmi.m_pcSubstitutionFont = const_cast<A3DUTF8Char*>("Myriad CAD");
sReadParam.m_sTessellation.m_eTessellationLevelOfDetail = kA3DTessLODMedium;
sReadParam.m_sMultiEntries.m_bLoadDefault = true;
sReadParam.m_sAssembly.m_bUseRootDirectory = true;
CHECK_RET(A3DAsmModelFileLoadFromFile(pcFileName, &sReadParam, ppModelFile));
}
if(*ppModelFile != NULL)
{
// whatever the input format, we store it as PRC in the output PDF
// creating the PRC stream from the model file that is going to be inserted into the PDF file
A3DRWParamsExportPrcData sParamsExportData;
A3D_INITIALIZE_DATA(A3DRWParamsExportPrcData, sParamsExportData);
CHECK_RET(A3DPDF3DStreamCreateFromModelFileAsPRC(pDoc, *ppModelFile, &sParamsExportData, &pStream, ppA3DRWParamsPrcWriteHelper));
}
if(pStream != NULL)
{
// creating the 3D artwork
*pp3DArtwork = NULL;
A3DPDF3DArtworkData2 s3DArtworkData;
A3D_INITIALIZE_DATA(A3DPDF3DArtworkData2, s3DArtworkData);
s3DArtworkData.m_pStream = pStream;
s3DArtworkData.m_pcJavaScriptFileName = const_cast<A3DUTF8Char*>(pcInjsfile);
s3DArtworkData.m_bActivatePMICrossHighlight = true;
s3DArtworkData.m_bAddPMISemanticInformation = true;
s3DArtworkData.m_sDisplaySectionData.m_bAddSectionCaps = true;
CHECK_RET(A3DPDF3DArtworkCreate2(pDoc, &s3DArtworkData, pp3DArtwork));
A3DPDF3DAnnotData sAnnotData;
A3D_INITIALIZE_DATA(A3DPDF3DAnnotData, sAnnotData);
sAnnotData.m_bOpenModelTree = false;
sAnnotData.m_bShowToolbar = false;
sAnnotData.m_eLighting = kA3DPDFLightCADOptimized;
sAnnotData.m_eRenderingStyle = kA3DPDFRenderingSolid;
sAnnotData.m_sBackgroundColor.m_dRed = 0.25;
sAnnotData.m_sBackgroundColor.m_dGreen = 0.25;
sAnnotData.m_sBackgroundColor.m_dBlue = 0.25;
sAnnotData.m_bTransparentBackground = false;
sAnnotData.m_eActivateWhen = kA3DPDFActivPageOpened;
sAnnotData.m_eDesactivateWhen = kA3DPDFActivPageClosed;
sAnnotData.m_iAppearanceBorderWidth = 0;
sAnnotData.m_pPosterImage = pPoster; // default poster automatically generated
sAnnotData.m_p3DArtwork = *pp3DArtwork;
CHECK_RET(A3DPDF3DAnnotCreate(pDoc, &sAnnotData, pp3DAnnot));
}
return iRet;
}
A3DStatus AddViewCarousel(A3DPDFDocument* pDoc, A3DPDFPage* pPage,
int iLeftCarou,
int iBottomCarou,
int iHeigthCarousel,
int iWidthCarouButtonPrevNext,
int iWidthCarouButton,
int iHorizMargin,
std::vector<std::string>& aViewCarouselButPrevNext,
std::vector<std::string>& aViewCarouselButtons,
A3DPDF3DViewCarousel** ppViewCarousel)
{
A3DStatus iRet = A3D_SUCCESS;
// --- buttons for carousel
A3DPDFRectData sPos;
A3D_INITIALIZE_DATA(A3DPDFRectData, sPos);
std::string sFieldId;
// buttons views all act the same and have same attributes
A3DUTF8Char* ppButtonsNamesPrevNext[2];
A3DPDFButton* ppButtonsPrevNext[2];
A3DUTF8Char** ppButtonsNames = (A3DUTF8Char**) malloc(aViewCarouselButtons.size() * A3DUns32(sizeof(A3DUTF8Char*)));
A3DPDFButton** ppButtonsViews = (A3DPDFButton**) malloc(aViewCarouselButtons.size() * A3DUns32(sizeof(A3DPDFButton*)));
A3DPDFButtonData sButtonViewsData;
A3D_INITIALIZE_DATA(A3DPDFButtonData, sButtonViewsData);
//sButtonViewsData.m_eFormField = kA3DPDFVisible;
sButtonViewsData.m_pcFontName = const_cast<A3DUTF8Char*>("Helv");
sButtonViewsData.m_iFontSize = 8;
sButtonViewsData.m_bHasFillColor = false;
sButtonViewsData.m_bHasBorder = false;
sButtonViewsData.m_eThicknessBorder = kA3DPDFThin;
sButtonViewsData.m_eLineStyleBorder = kA3DPDFSolid;
sButtonViewsData.m_eLayoutTextIcon = kA3DPDFIconTopLabelBottom;
sButtonViewsData.m_eHighlightingMode = kA3DPDFLinkHighlightOutline;
for (size_t i=0 ; i<aViewCarouselButtons.size() ; i++)
{
// button view i
mallocAndSetString(
aViewCarouselButtons[i].c_str(),// src
ppButtonsNames[i]); // dest
sButtonViewsData.m_pcName = ppButtonsNames[i];
CHECK_RET(A3DPDFButtonCreate(pDoc, &sButtonViewsData, &ppButtonsViews[i]));
}
// buttons scrolls both act the same and have same attributes
A3DPDFButtonData sButtonsScrollData;
A3D_INITIALIZE_DATA(A3DPDFButtonData, sButtonsScrollData);
sButtonsScrollData.m_bHasFillColor = false;
sButtonsScrollData.m_bHasBorder = false;
sButtonsScrollData.m_eThicknessBorder = kA3DPDFThin;
sButtonsScrollData.m_eLineStyleBorder = kA3DPDFSolid;
sButtonsScrollData.m_eLayoutTextIcon = kA3DPDFIconOnly;
sButtonsScrollData.m_eHighlightingMode = kA3DPDFLinkHighlightOutline;
// button scroll up (previous)
// create image object from file for button icon
A3DPDFImage* pImagePrev;
CHECK_RET(A3DPDFImageCreateFromFile(pDoc, ICON_CAROUSEL_PREV, kA3DPDFImageFormatUnknown, &pImagePrev));
sButtonsScrollData.m_pImage = pImagePrev;
// button name
mallocAndSetString(
aViewCarouselButPrevNext[0].c_str(),// src
ppButtonsNamesPrevNext[0]); // dest
sButtonsScrollData.m_pcName = ppButtonsNamesPrevNext[0];
CHECK_RET(A3DPDFButtonCreate(pDoc, &sButtonsScrollData, &ppButtonsPrevNext[0]));
// button scroll down (next)
// create image object from file for button icon
A3DPDFImage* pImageNext;
CHECK_RET(A3DPDFImageCreateFromFile(pDoc, ICON_CAROUSEL_NEXT, kA3DPDFImageFormatUnknown, &pImageNext));
sButtonsScrollData.m_pImage = pImageNext;
// button name
mallocAndSetString(
aViewCarouselButPrevNext[1].c_str(),// src
ppButtonsNamesPrevNext[1]); // dest
sButtonsScrollData.m_pcName = ppButtonsNamesPrevNext[1];
CHECK_RET(A3DPDFButtonCreate(pDoc, &sButtonsScrollData, &ppButtonsPrevNext[1]));
// buttons insertions
// coordinates are from bottom left of the page
int iTopCarou = iBottomCarou+iHeigthCarousel;
sPos.m_iLeft = iLeftCarou; // lower left x
sPos.m_iBottom = iBottomCarou; // lower left y
sPos.m_iRight = sPos.m_iLeft+iWidthCarouButtonPrevNext; // upper right x
sPos.m_iTop = iTopCarou; // upper right y
CHECK_RET(A3DPDFPageInsertButton(pPage, ppButtonsPrevNext[0], &sPos));
for (size_t i=0 ; i<aViewCarouselButtons.size() ; i++)
{
sPos.m_iLeft = sPos.m_iRight+iHorizMargin; // lower left x
sPos.m_iBottom = iBottomCarou; // lower left y
sPos.m_iRight = sPos.m_iLeft+iWidthCarouButton; // upper right x
sPos.m_iTop = iTopCarou; // upper right y
CHECK_RET(A3DPDFPageInsertButton(pPage, ppButtonsViews[i], &sPos));
}
sPos.m_iLeft = sPos.m_iRight+iHorizMargin; // lower left x
sPos.m_iBottom = iBottomCarou; // lower left y
sPos.m_iRight = sPos.m_iLeft+iWidthCarouButtonPrevNext; // upper right x
sPos.m_iTop = iTopCarou; // upper right y
CHECK_RET(A3DPDFPageInsertButton(pPage, ppButtonsPrevNext[1], &sPos));
// --- view carousel
A3DPDF3DViewCarouselData sViewCarouselData;
A3D_INITIALIZE_DATA(A3DPDF3DViewCarouselData, sViewCarouselData);
sViewCarouselData.m_iNbButtons = (int)aViewCarouselButtons.size();
sViewCarouselData.m_ppcButtonsNames = ppButtonsNames;
sViewCarouselData.m_pcPreviousButtonName = ppButtonsNamesPrevNext[0];
sViewCarouselData.m_pcNextButtonName = ppButtonsNamesPrevNext[1];
sViewCarouselData.m_eScrollDirection = kA3DPDFHorizontal;
sViewCarouselData.m_iScrollStep = 1;
CHECK_RET(A3DPDF3DViewCarouselCreate(pDoc, &sViewCarouselData, ppViewCarousel));
CHECK_RET(A3DPDFPageInsert3DViewCarousel(pPage, *ppViewCarousel));
// draw a border + background color, if required
if (*ppViewCarousel!=NULL)
{
A3DPDFGraphicRectangleData sGraphRectData;
A3D_INITIALIZE_DATA(A3DPDFGraphicRectangleData, sGraphRectData);
sGraphRectData.m_dWidth=1;
// border line color
sGraphRectData.m_sLineColor.m_dBlue=0.;
sGraphRectData.m_sLineColor.m_dGreen=0.;
sGraphRectData.m_sLineColor.m_dRed=0.;
/*
// background color
A3DPDFRgbColorData sFillColorData;
sGraphRectData.m_pFillColor = &sFillColorData;
sGraphRectData.m_pFillColor->m_dBlue=0.9;
sGraphRectData.m_pFillColor->m_dGreen=0.9;
sGraphRectData.m_pFillColor->m_dRed=0.9;
*/
CHECK_RET(A3DPDFWidgetGetPosition(*ppViewCarousel, &sGraphRectData.m_sRectangleData));
sGraphRectData.m_sRectangleData.m_dBottom --;
sGraphRectData.m_sRectangleData.m_dTop ++;
A3DPDFPageDrawRectangle(pPage, &sGraphRectData);
}
// cleanup
for (size_t i=0 ; i<aViewCarouselButtons.size() ; i++)
{
free(ppButtonsNames[i]);
}
free(ppButtonsNames);
free(ppButtonsViews);
free(ppButtonsNamesPrevNext[0]);
free(ppButtonsNamesPrevNext[1]);
return iRet;
}
//######################################################################################################################
// Define a slide table
A3DStatus AddScrollTable(A3DPDFDocument* pDoc, A3DPDFPage* pPage,
int iPosLeft, int iPosTop, int iSliderWidth,
int iNbRowsInFrame,
int iHeightRowHeader, // in points
int iHeightRows, // in points
std::vector<int>& aiWidthCols, // in points
std::vector<std::string>& aRowHeader,
std::vector<A3DPDFEColumnType>& aeColumnTypes,
A3DPDFScrollTable** ppScrollTable)
{
A3DStatus iRet = A3D_SUCCESS;
A3DPDFScrollTableData sScrollTableData;
A3D_INITIALIZE_DATA(A3DPDFScrollTableData, sScrollTableData);
sScrollTableData.m_iGridNbRows = iNbRowsInFrame;
sScrollTableData.m_iGridNbCols = (int)aiWidthCols.size();
sScrollTableData.m_iGridHeightCells = iHeightRows;
sScrollTableData.m_piGridWidthCells = (A3DInt32 *)malloc(sScrollTableData.m_iGridNbCols*sizeof(A3DInt32));
for (size_t ic=0; ic<aiWidthCols.size(); ic++)
sScrollTableData.m_piGridWidthCells[ic]=aiWidthCols[ic];
sScrollTableData.m_peColumnTypes = (A3DPDFEColumnType *)malloc(sScrollTableData.m_iGridNbCols * sizeof(A3DPDFEColumnType));
for (size_t ic = 0; ic<aeColumnTypes.size(); ic++)
sScrollTableData.m_peColumnTypes[ic] = aeColumnTypes[ic];
sScrollTableData.m_iSliderWidth = iSliderWidth;
// optional to define custom format
// comment these lines to get default format
A3DPDFTextFieldData sCellFormatData;
A3D_INITIALIZE_DATA(A3DPDFTextFieldData, sCellFormatData);
sCellFormatData.m_pcFontName = const_cast<A3DUTF8Char*>("Helv");
sCellFormatData.m_iFontSize = 10;
sCellFormatData.m_sTextColor.m_dRed = 0.0; // black
sCellFormatData.m_sTextColor.m_dGreen = 0.0;
sCellFormatData.m_sTextColor.m_dBlue = 0.0;
sCellFormatData.m_eTextAlignment = kA3DPDFLeft;
sScrollTableData.m_pCellFormat = &sCellFormatData;
/* optional to define custom row highlight color
// comment these lines to get default highlight color
A3DPDFRgbColorData sHighlightColorData;
A3D_INITIALIZE_DATA(A3DPDFRgbColorData, sHighlightColorData);
sHighlightColorData.m_dRed = 100./255.;
sHighlightColorData.m_dGreen = 200./255.;
sHighlightColorData.m_dBlue = 100./255.;
sScrollTableData.m_pHighlightColor = &sHighlightColorData;
*/
CHECK_RET(A3DPDFScrollTableCreate(pDoc, &sScrollTableData, ppScrollTable));
CHECK_RET(A3DPDFPageInsertScrollTable(pPage, *ppScrollTable, iPosLeft, iPosTop-iHeightRowHeader));
// --- create header as text fields: create it after table to use the ST name created
A3DUTF8Char* pcSTName = NULL;
CHECK_RET(A3DPDFWidgetGetName(*ppScrollTable, &pcSTName));
A3DPDFTextFieldData sTextFieldData;
A3D_INITIALIZE_DATA(A3DPDFTextFieldData, sTextFieldData);
sTextFieldData.m_pcFontName = const_cast<A3DUTF8Char*>("HeBo");
sTextFieldData.m_iFontSize = 10;
sTextFieldData.m_sTextColor.m_dRed = 0; // black
sTextFieldData.m_sTextColor.m_dGreen = 0;
sTextFieldData.m_sTextColor.m_dBlue = 0;
sTextFieldData.m_eTextAlignment = kA3DPDFLeft;
A3DPDFRectData sPos;
A3D_INITIALIZE_DATA(A3DPDFRectData, sPos);
sPos.m_iLeft = iPosLeft; // lower left x
sPos.m_iBottom = iPosTop-iHeightRowHeader; // lower left y
sPos.m_iRight = iPosLeft; // upper right x
sPos.m_iTop = iPosTop; // upper right y
for(size_t ic = 0; ic < aRowHeader.size() ; ic++)
{
A3DPDFTextField* pText = NULL;
A3DUTF8Char tmpname[1024];
sprintf(tmpname, "%s_Header%d", pcSTName, (int)ic);
sTextFieldData.m_pcName = tmpname;
sTextFieldData.m_pcDefaultValue = const_cast<A3DUTF8Char*>(aRowHeader[ic].c_str());
iRet = A3DPDFTextFieldCreate(pDoc, &sTextFieldData, &pText);
// coordinates are from bottom left of the page
sPos.m_iLeft = sPos.m_iRight; // lower left x
sPos.m_iRight = sPos.m_iLeft + aiWidthCols[ic]; // upper right x
if ((A3DInt32)ic==sScrollTableData.m_iGridNbCols-1) // last column goes above the slider
sPos.m_iRight += iSliderWidth;
CHECK_RET(A3DPDFPageInsertTextField(pPage, pText, &sPos));
}
A3DPDFWidgetGetName(nullptr, &pcSTName);
// clean
if (sScrollTableData.m_piGridWidthCells!=NULL)
free( sScrollTableData.m_piGridWidthCells);
if (sScrollTableData.m_peColumnTypes != NULL)
free(sScrollTableData.m_peColumnTypes);
return A3D_SUCCESS;
}
A3DStatus stBuildDocument(A3DPDFDocument* pDoc)
{
A3DStatus iRet = A3D_SUCCESS;
A3DPDFPage* pPage = NULL;
int indexpage = 0;
std::string sSuffixFields;
// populating the document metadata
A3DPDFDocumentInformationData sInformationData;
A3D_INITIALIZE_DATA(A3DPDFDocumentInformationData, sInformationData);
sInformationData.m_pcTitle = const_cast<A3DUTF8Char*>("HOOPS Publish Functionalities");
sInformationData.m_pcCreator = const_cast<A3DUTF8Char*>("HOOPS Publish Sample Application");
sInformationData.m_pcSubject = const_cast<A3DUTF8Char*>("This sample demoes the data model functionality of HOOPS Publish");
sInformationData.m_pcAuthor = const_cast<A3DUTF8Char*>("Tech Soft 3D");
CHECK_RET(A3DPDFDocumentSetInformation(pDoc, &sInformationData));
// creating a poster image to be used as a poster for 3D.
A3DPDFImage* pBlankImage = NULL;
A3DPDFImageCreateFromFile(pDoc, POSTER_PATH, kA3DPDFImageFormatUnknown, &pBlankImage);
// create page idx+1 from template file. we force the fields renaming to avoid duplicated names.
sSuffixFields = "uuid0";
CHECK_RET(A3DPDFDocumentAppendPageFromPDFFileAndSuffixFields(pDoc, PDF_TEMPLATE_1, sSuffixFields.c_str(), &pPage));
if(pPage != NULL)
{
// --- create and fill Fields to map to DataModel
A3DPDF3DAnnot* p3DAnnot = NULL;
A3DPDF3DArtwork* p3DArtwork = NULL;
A3DAsmModelFile* pModelFile = NULL;
// To get unique IDs, we need a A3DRWParamsPrcWriteHelper.
// A3DPDF3DStreamCreateFromModelFileAsPRC builds this object.
A3DRWParamsPrcWriteHelper* pPRCWriteHelper = NULL;
iRet = Create3DAnnot(pDoc, IN_3DFILE_1, pBlankImage, NULL, &p3DArtwork, &p3DAnnot, &pPRCWriteHelper, &pModelFile);
if(p3DAnnot != NULL && p3DArtwork != NULL && pModelFile != NULL)
{
// populating the field with the 3D annotation
CHECK_RET(A3DPDFPageFieldSet3DAnnot(pPage, std::string("DF_3DWindow_" + sSuffixFields).c_str(), p3DAnnot));
// get widget for list nodes
A3DPDF3DNodeScene* p3DNodeScene = NULL;
CHECK_RET(A3DPDF3DAnnotGet3DNodeScene( p3DAnnot, &p3DNodeScene));
// create Scroll table on the page
A3DPDFScrollTable* pScrollTableBom = NULL;
std::vector<int> aiWidthCols; // in points
aiWidthCols.push_back(30);
aiWidthCols.push_back(170);
aiWidthCols.push_back(30);
aiWidthCols.push_back(60);
aiWidthCols.push_back(50);
std::vector<std::string> aRowHeader;
aRowHeader.push_back("No");
aRowHeader.push_back("NAME PART");
aRowHeader.push_back("QTY");
aRowHeader.push_back("MATERIAL");
aRowHeader.push_back("SNAPSHOT");
std::vector<A3DPDFEColumnType> aeTypes;
aeTypes.push_back(kA3DPDFTextContent);
aeTypes.push_back(kA3DPDFTextContent);
aeTypes.push_back(kA3DPDFTextContent);
aeTypes.push_back(kA3DPDFTextContent);
aeTypes.push_back(kA3DPDFImageContent);
CHECK_RET(AddScrollTable(pDoc, pPage,
20, 632, // iPosLeft, iPosTop
15, //iSliderWidth
4, // iNbRowsInFrame
20, // iHeightRowHeader - in points
40, // iHeightRows - in points
aiWidthCols, // in points
aRowHeader,
aeTypes,
&pScrollTableBom));
// get existing widgets on template page
A3DPDFTextField* pTextTitle = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Title_" + sSuffixFields).c_str(), &pTextTitle));
A3DPDFTextField* pTextDate = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Date_" + sSuffixFields).c_str(), &pTextDate));
A3DPDFTextField* pTextCreatedBy = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_CreatedBy_" + sSuffixFields).c_str(), &pTextCreatedBy));
A3DPDFTextField* pTextInstance = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_InstanceNode_" + sSuffixFields).c_str(), &pTextInstance));
A3DPDFTextField* pTextColNumArt = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Col0_" + sSuffixFields).c_str(), &pTextColNumArt));
A3DPDFTextField* pTextColNamePart = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Col1_" + sSuffixFields).c_str(), &pTextColNamePart));
A3DPDFListBox* pListManufacturers = NULL;
CHECK_RET(PageGetListBoxField(pPage, std::string("DF_ManufacturersList_" + sSuffixFields).c_str(), &pListManufacturers));
A3DPDFTextField* pTextManufDetails = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_ManufacturerDetails_" + sSuffixFields).c_str(), &pTextManufDetails));
A3DPDFDataFilter* pDropDownListFilter = NULL;
CHECK_RET(A3DPDFPageGetDataFilterFromDropDownListField(pPage, std::string("DF_FilterList_" + sSuffixFields).c_str(), &pDropDownListFilter));
// DATAMODEL
// --- creation Tables and relationships
// TABLE Statics
A3DPDFDataTable* pDataTable_Statics = NULL;
CHECK_RET(CreateTable_Sple1_Statics(pDoc, pDataTable_Statics));
// TABLE CBFILTER
A3DPDFDataTable* pDataTable_CBFILTER = NULL;
CHECK_RET(CreateTable_Sple1_CBFILTER(pDoc, pDataTable_CBFILTER));
// TABLE Manufacturers
A3DPDFDataTable* pDataTable_Manufacturers = NULL;
CHECK_RET(CreateTable_Sple1_Manufacturers(pDoc, pDataTable_Manufacturers));
// TABLE 3D MODEL + TABLE BOM + RELATIONSHIPs
A3DPDFDataTable* pDataTable_3D = NULL;
A3DPDFDataTable* pDataTable_Bom = NULL;
int iKeyNode3dUID, iKeyNode3dName, iKeyNode3dInstance;
int iKeyBomNumArt, iKeyBomNamePart, iKeyBomQty, iKeyBomMaterial, iKeyBomIcon;
CHECK_RET(CreateTable_Sple1_3DModel_Bom(pDoc, pModelFile, pPRCWriteHelper,
ICONS_PATH,
iKeyNode3dUID, iKeyNode3dName, iKeyNode3dInstance,
iKeyBomNumArt, iKeyBomNamePart, iKeyBomQty, iKeyBomMaterial, iKeyBomIcon,
pDataTable_3D, pDataTable_Bom, pDataTable_Manufacturers));
// RELATIONSHIP CBCBFILTER_To_Bom
CHECK_RET(CreateRelationship_Sple1_CBFILTER_To_Bom(pDoc, pDataTable_CBFILTER, pDataTable_Bom));
// --- binding to widgets
// --- Widgets binding for Table Static
CHECK_RET(A3DPDFTextFieldBindToTable(pTextTitle, pDataTable_Statics, 0));
CHECK_RET(A3DPDFTextFieldBindToTable(pTextDate, pDataTable_Statics, 1));
CHECK_RET(A3DPDFTextFieldBindToTable(pTextCreatedBy, pDataTable_Statics, 2));
// --- Widgets binding for init Filter
const A3DInt32 piMapColumns_CBFILTER[] = { 0 } ; const int iSzColCBFILTER = 1;
CHECK_RET(A3DPDFDataFilterWidgetBindToTable(pDropDownListFilter, pDataTable_CBFILTER, iSzColCBFILTER, piMapColumns_CBFILTER,
"Filter All" ));
// pcValueNoFilterApplied: if defined, a first specific row is added in the widget: select this row -> unapply all filters
// if pcValueNoFilterApplied is NULL: a filter is always applied (there is no 'nofilter' state ; default is row0)
// --- Widgets binding for Table 3D
CHECK_RET(A3DPDF3DNodeSceneBindToTable(p3DNodeScene, pDataTable_3D, iKeyNode3dUID));// A3DPDF3DNodeScene maps only 1 col : the one with uuid node names
CHECK_RET(A3DPDFTextFieldBindToTable(pTextInstance, pDataTable_3D, iKeyNode3dInstance));
// --- Widgets binding for Table BOM
const A3DInt32 piMapColumns_Bom[] = { iKeyBomNumArt, iKeyBomNamePart, iKeyBomQty, iKeyBomMaterial, iKeyBomIcon };
CHECK_RET(A3DPDFScrollTableBindToTable(pScrollTableBom, pDataTable_Bom, sizeof(piMapColumns_Bom)/sizeof(A3DInt32), piMapColumns_Bom ));
CHECK_RET(A3DPDFTextFieldBindToTable(pTextColNumArt, pDataTable_Bom, iKeyBomNumArt));
CHECK_RET(A3DPDFTextFieldBindToTable(pTextColNamePart, pDataTable_Bom, iKeyBomNamePart));
// --- Widgets binding for Table Manufacturers
CHECK_RET(A3DPDFListBoxBindToTable(pListManufacturers, pDataTable_Manufacturers, 0));
CHECK_RET(A3DPDFTextFieldBindToTable(pTextManufDetails, pDataTable_Manufacturers, 3));
// --- Define interactions between widgets
// if Bom is populated coming from a selection in filter dropdown list, only resulting elements of the filter are displayed in Bom
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( pDropDownListFilter, pScrollTableBom, kA3DPDFDataIsolate ));
// Select a BOM item -> only associated Manufacturers are displayed in Manufacturers list
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( pScrollTableBom, pListManufacturers, kA3DPDFDataIsolate ));
// selection of a row in Bom -> 2 column values are displayed in 2 text field
CHECK_RET(A3DPDFWidgetSetTargetBehaviour(pScrollTableBom, pTextColNumArt, kA3DPDFDataIsolate));
CHECK_RET(A3DPDFWidgetSetTargetBehaviour(pScrollTableBom, pTextColNamePart, kA3DPDFDataIsolate));
// selection of a row in Bom -> the associated elements of widget (=3d nodes) are highlighted
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( pScrollTableBom, p3DNodeScene, kA3DPDFDataHighlight ));
// select a node in 3D annot -> the elements of BOM (=scroll table rows) are selected (i.e. acts as if the user clicked on the BOM row)
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( p3DNodeScene, pScrollTableBom, kA3DPDFDataSelect ));
// TextInstance is populated coming from a selection in 3D
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( p3DNodeScene, pTextInstance, kA3DPDFDataIsolate ));
// selection of a row in Manufacturers list box -> 1 column value is displayed in text field
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( pListManufacturers, pTextManufDetails, kA3DPDFDataIsolate ));
// cleanup 3D modelfile
CHECK_RET(A3DAsmModelFileDelete(pModelFile));
// Free the A3DRWParamsPrcWriteHelper object at the end
if (pPRCWriteHelper != NULL)
A3DRWParamsPrcWriteHelperFree(pPRCWriteHelper);
}
indexpage++;
}
// create page idx+1 from template file. we force the fields renaming to avoid duplicated names.
sSuffixFields = "uuid1";
CHECK_RET(A3DPDFDocumentAppendPageFromPDFFileAndSuffixFields(pDoc, PDF_TEMPLATE_2, sSuffixFields.c_str(), &pPage));
if(pPage != NULL)
{
// --- create and fill Fields to map to DataModel
A3DPDF3DAnnot* p3DAnnot = NULL;
A3DPDF3DArtwork* p3DArtwork = NULL;
A3DAsmModelFile* pModelFile = NULL;
// To get unique IDs, we need a A3DRWParamsPrcWriteHelper.
// A3DPDF3DStreamCreateFromModelFileAsPRC builds this object.
A3DRWParamsPrcWriteHelper* pPRCWriteHelper = NULL;
iRet = Create3DAnnot(pDoc, IN_3DFILE_2, pBlankImage, NULL, &p3DArtwork, &p3DAnnot, &pPRCWriteHelper, &pModelFile);
if(p3DAnnot != NULL && p3DArtwork != NULL && pModelFile != NULL)
{
// populating the field with the 3D annotation
CHECK_RET(A3DPDFPageFieldSet3DAnnot(pPage, std::string("DF_3DWindow_" + sSuffixFields).c_str(), p3DAnnot));
// get widget for list nodes
A3DPDF3DNodeScene* p3DNodeScene = NULL;
CHECK_RET(A3DPDF3DAnnotGet3DNodeScene( p3DAnnot, &p3DNodeScene));
// get widget for list views
A3DPDF3DViewList* p3DViewList = NULL;
CHECK_RET(A3DPDF3DAnnotGet3DViewList( p3DAnnot, &p3DViewList));
// create view carousel on the page
A3DPDF3DViewCarousel* pViewCarousel = NULL;
std::vector<std::string> aViewCarouselButPrevNext;
aViewCarouselButPrevNext.push_back(std::string("ButScrollViewsPrev_" + sSuffixFields));
aViewCarouselButPrevNext.push_back(std::string("ButScrollViewsNext_" + sSuffixFields));
std::vector<std::string> aViewCarouselButtons;
for (int i=0 ; i<3 ; i++)
{
char acButName[256];
sprintf ( acButName, "ButViewCarousel%d_", i );
aViewCarouselButtons.push_back(std::string(acButName + sSuffixFields));
}
CHECK_RET(AddViewCarousel(pDoc, pPage,
30, // iLeftCarou
340, // iBottomCarou
108, // iHeigthCarousel
22, // iWidthCarouButtonPrevNext
145, // iWidthCarouButton
2, // iHorizMargin
aViewCarouselButPrevNext, aViewCarouselButtons,
&pViewCarousel));
// create Scroll table on the page
A3DPDFScrollTable* pScrollTablePmis = NULL;
std::vector<int> aiWidthCols; // in points
aiWidthCols.push_back(100);
aiWidthCols.push_back(100);
aiWidthCols.push_back(100);
aiWidthCols.push_back(100);
std::vector<std::string> aRowHeader;
aRowHeader.push_back("PMI Name");
aRowHeader.push_back("Type");
aRowHeader.push_back("Value");
aRowHeader.push_back("Tolerance");
std::vector<A3DPDFEColumnType> aeTypes;
aeTypes.push_back(kA3DPDFTextContent);
aeTypes.push_back(kA3DPDFTextContent);
aeTypes.push_back(kA3DPDFTextContent);
aeTypes.push_back(kA3DPDFTextContent);
CHECK_RET(AddScrollTable(pDoc, pPage,
20, 270, // iPosLeft, iPosTop
15, //iSliderWidth
8, // iNbRowsInFrame
20, // iHeightRowHeader - in points
20, // iHeightRows - in points
aiWidthCols, // in points
aRowHeader,
aeTypes,
&pScrollTablePmis));
// get existing widgets on template page
A3DPDFListBox* pListViewNames = NULL;
CHECK_RET(PageGetListBoxField(pPage, std::string("DF_Steps_" + sSuffixFields).c_str(), &pListViewNames));
A3DPDFTextField* pTextTitle = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Title_" + sSuffixFields).c_str(), &pTextTitle));
A3DPDFTextField* pTextDate = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Date_" + sSuffixFields).c_str(), &pTextDate));
A3DPDFTextField* pTextCreatedBy = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_CreatedBy_" + sSuffixFields).c_str(), &pTextCreatedBy));
A3DPDFTextField* pTextCol0 = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Col0_" + sSuffixFields).c_str(), &pTextCol0));
A3DPDFTextField* pTextCol1 = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Col1_" + sSuffixFields).c_str(), &pTextCol1));
// DATAMODEL
// --- creation Tables and relationships
// TABLE Statics
A3DPDFDataTable* pDataTable_Statics = NULL;
CHECK_RET(CreateTable_Sple2_Statics(pDoc, pDataTable_Statics));
// TABLE ViewNames
A3DPDFDataTable* pDataTable_ViewNames = NULL;
CHECK_RET(CreateTable_Sple2_ViewNames(pDoc, pDataTable_ViewNames));
// TABLE 3D MODEL
A3DPDFDataTable* pDataTable_3D = NULL;
A3DPDFDataTable* pDataTable_Pmis = NULL;
int iKeyNode3dUID, iKeyPmiName, iKeyPmiType, iKeyPmiValue, iKeyPmiTol;
CHECK_RET(CreateTable_Sple2_3DModel(pDoc, pModelFile, pPRCWriteHelper,
iKeyNode3dUID, iKeyPmiName, iKeyPmiType, iKeyPmiValue, iKeyPmiTol,
pDataTable_3D, pDataTable_Pmis));
// TABLE 3D VIEWS
A3DPDFDataTable3DViews* pDataTable_3DViews = NULL;
CHECK_RET(CreateTable_Sple2_3DViews_WithCarousel(pDoc, p3DArtwork, pModelFile, pDataTable_3DViews));
// RELATIONSHIP ViewNames_To_Views
CHECK_RET(CreateRelationship_Sple2_ViewNames_To_Views(pDoc, pDataTable_ViewNames, pDataTable_3DViews));
// RELATIONSHIP Views_To_Pmis
CHECK_RET(CreateRelationship_Sple2_View_To_Pmis(pDoc, pDataTable_3DViews, pDataTable_Pmis));
// RELATIONSHIP Pmis_To_3D
//CHECK_RET(createRelationship_Sple2_Pmis_To_3D(pDoc, pDataTable_Pmis, pDataTable_3D));
// --- binding to widgets
// --- Widgets binding for Table ViewNames
CHECK_RET(A3DPDFListBoxBindToTable(pListViewNames, pDataTable_ViewNames, 0));
// --- Widgets binding for Table Static
CHECK_RET(A3DPDFTextFieldBindToTable(pTextTitle, pDataTable_Statics, 0));
CHECK_RET(A3DPDFTextFieldBindToTable(pTextDate, pDataTable_Statics, 1));
CHECK_RET(A3DPDFTextFieldBindToTable(pTextCreatedBy, pDataTable_Statics, 2));
// --- Widgets binding for Table 3D
CHECK_RET(A3DPDF3DNodeSceneBindToTable(p3DNodeScene, pDataTable_3D, iKeyNode3dUID));// A3DPDF3DNodeScene maps only 1 col : the one with uuid node names
// --- Widgets binding for Table 3D Views
// UI of 3D annot list views
CHECK_RET(A3DPDF3DViewListBindToTable(p3DViewList, pDataTable_3DViews));
// Carousel widget binding
CHECK_RET(A3DPDF3DViewCarouselBindToTable(pViewCarousel, pDataTable_3DViews));
// widgets binding to map columns
CHECK_RET(A3DPDFTextFieldBindToTable(pTextCol0, pDataTable_3DViews, 1));// col 1 is for view name
CHECK_RET(A3DPDFTextFieldBindToTable(pTextCol1, pDataTable_3DViews, 4));// col 4 is first additional column
// --- Widgets binding for Table PMIs
const A3DInt32 piMapColumnsPmis[] = { iKeyPmiName, iKeyPmiType, iKeyPmiValue, iKeyPmiTol };
CHECK_RET(A3DPDFScrollTableBindToTable(pScrollTablePmis, pDataTable_Pmis, sizeof(piMapColumnsPmis)/sizeof(A3DInt32), piMapColumnsPmis ));
// --- Define interactions between widgets
// selection of a row in list ViewNames -> the associated elements of widget (=3d view) is selected
CHECK_RET(A3DPDFWidgetSetTargetBehaviour(pListViewNames, p3DViewList, kA3DPDFDataSelect));
// and conversely so that we can see the item selected in the listbox if the selction is done by view list or caroussel
CHECK_RET(A3DPDFWidgetSetTargetBehaviour(p3DViewList, pListViewNames, kA3DPDFDataSelect));
// selection of a row in Pmis -> the associated elements of widget (=3d nodes) are selected
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( pScrollTablePmis, p3DNodeScene, kA3DPDFDataSelect ));
//... and conversely, select a node in 3d -> associated element in scroll table is highlighted
CHECK_RET(A3DPDFWidgetSetTargetBehaviour(p3DNodeScene, pScrollTablePmis, kA3DPDFDataHighlight));
// select a view in 3D annot view list -> the elements of PMIs are filtered
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( p3DViewList, pScrollTablePmis, kA3DPDFDataIsolate ));
// select a view in 3D annot view list -> the elements of texts for columns are filtered
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( p3DViewList, pTextCol0, kA3DPDFDataIsolate ));
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( p3DViewList, pTextCol1, kA3DPDFDataIsolate ));
// select a view in 3D annot view list -> the carousel is selected
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( p3DViewList, pViewCarousel, kA3DPDFDataSelect ));
// select a view in carousel -> the 3D annot view list is selected
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( pViewCarousel, p3DViewList, kA3DPDFDataSelect ));
// activate a specific view when the file is opened + all actions on cascading widgets
// NULL should be specified on the widget source to select a row at init time
CHECK_RET(A3DPDFWidgetSetTargetBehaviour(NULL, p3DViewList, kA3DPDFDataSelect));
// This forces the selection on table at init time
CHECK_RET(A3DPDFDataTableSetInitIndex(pDataTable_3DViews, 1));
// cleanup 3D modelfile
CHECK_RET(A3DAsmModelFileDelete(pModelFile));
// Free the A3DRWParamsPrcWriteHelper object at the end
if (pPRCWriteHelper != NULL)
A3DRWParamsPrcWriteHelperFree(pPRCWriteHelper);
}
indexpage++;
}
// create page idx+1 from template file. we force the fields renaming to avoid duplicated names.
sSuffixFields = "uuid2";
CHECK_RET(A3DPDFDocumentAppendPageFromPDFFileAndSuffixFields(pDoc, PDF_TEMPLATE_3, sSuffixFields.c_str(), &pPage));
if(pPage != NULL)
{
// --- create and fill Fields to map to DataModel
A3DPDF3DAnnot* p3DAnnot = NULL;
A3DPDF3DArtwork* p3DArtwork = NULL;
A3DAsmModelFile* pModelFile = NULL;
// To get unique IDs, we need a A3DRWParamsPrcWriteHelper.
// A3DPDF3DStreamCreateFromModelFileAsPRC builds this object.
A3DRWParamsPrcWriteHelper* pPRCWriteHelper = NULL;
iRet = Create3DAnnot(pDoc, IN_3DFILE_3, pBlankImage, NULL, &p3DArtwork, &p3DAnnot, &pPRCWriteHelper, &pModelFile);
if(p3DAnnot != NULL && p3DArtwork != NULL && pModelFile != NULL)
{
// populating the field with the 3D annotation
CHECK_RET(A3DPDFPageFieldSet3DAnnot(pPage, std::string("DF_3DWindow_" + sSuffixFields).c_str(), p3DAnnot));
// get widget for list nodes
A3DPDF3DNodeScene* p3DNodeScene = NULL;
CHECK_RET(A3DPDF3DAnnotGet3DNodeScene( p3DAnnot, &p3DNodeScene));
// create Scroll table on the page
A3DPDFScrollTable* pScrollTableBom = NULL;
std::vector<int> aiWidthCols; // in points
aiWidthCols.push_back(130);
aiWidthCols.push_back(160);
aiWidthCols.push_back(30);
std::vector<std::string> aRowHeader;
aRowHeader.push_back("No. ARTICLE");
aRowHeader.push_back("NAME PART");
aRowHeader.push_back("QTY");
std::vector<A3DPDFEColumnType> aeTypes;
aeTypes.push_back(kA3DPDFTextContent);
aeTypes.push_back(kA3DPDFTextContent);
aeTypes.push_back(kA3DPDFTextContent);
CHECK_RET(AddScrollTable(pDoc, pPage,
20, 632, // iPosLeft, iPosTop
15, //iSliderWidth
4, // iNbRowsInFrame
20, // iHeightRowHeader - in points
20, // iHeightRows - in points
aiWidthCols, // in points
aRowHeader,
aeTypes,
&pScrollTableBom));
// get existing widgets on template page
A3DPDFTextField* pTextTitle = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Title_" + sSuffixFields).c_str(), &pTextTitle));
A3DPDFTextField* pTextDate = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Date_" + sSuffixFields).c_str(), &pTextDate));
A3DPDFTextField* pTextCreatedBy = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_CreatedBy_" + sSuffixFields).c_str(), &pTextCreatedBy));
A3DPDFTextField* pTextInstance = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_InstanceNode_" + sSuffixFields).c_str(), &pTextInstance));
A3DPDFTextField* pTextCol0 = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Col0_" + sSuffixFields).c_str(), &pTextCol0));
A3DPDFTextField* pTextCol1 = NULL;
CHECK_RET(PageGetTextField(pPage, std::string("DF_Col1_" + sSuffixFields).c_str(), &pTextCol1));
A3DPDFButton* pButIcon = NULL;
CHECK_RET(PageGetButtonField(pPage, std::string("DF_Image_" + sSuffixFields).c_str(), &pButIcon));
// DATAMODEL
// --- creation Tables and relationships
// TABLE Statics
A3DPDFDataTable* pDataTable_Statics = NULL;
CHECK_RET(CreateTable_Sple3_Statics(pDoc, pDataTable_Statics));
// TABLE 3D MODEL + TABLE BOM + RELATIONSHIPs
A3DPDFDataTable* pDataTable_3D = NULL;
A3DPDFDataTable* pDataTable_Bom = NULL;
int iKeyNode3dUID, iKeyNode3dInstance;
int iKeyBomNumArt, iKeyBomNamePart, iKeyBomQty, iKeyBomIcon;
CHECK_RET(CreateTable_Sple3_3DModel_Bom(pDoc, pModelFile, pPRCWriteHelper,
ICONS_PATH,
iKeyNode3dUID, iKeyNode3dInstance, iKeyBomNumArt, iKeyBomNamePart, iKeyBomQty, iKeyBomIcon,
pDataTable_3D, pDataTable_Bom));
// --- binding to widgets
// --- Widgets binding for Table Static
CHECK_RET(A3DPDFTextFieldBindToTable(pTextTitle, pDataTable_Statics, 0));
CHECK_RET(A3DPDFTextFieldBindToTable(pTextDate, pDataTable_Statics, 1));
CHECK_RET(A3DPDFTextFieldBindToTable(pTextCreatedBy, pDataTable_Statics, 2));
// --- Widgets binding for Table 3D
CHECK_RET(A3DPDF3DNodeSceneBindToTable(p3DNodeScene, pDataTable_3D, iKeyNode3dUID));// A3DPDF3DNodeScene maps only 1 col : the one with uuid node names
CHECK_RET(A3DPDFTextFieldBindToTable(pTextInstance, pDataTable_3D, iKeyNode3dInstance));
// --- Widgets binding for Table BOM
const A3DInt32 piMapColumns_Bom[] = { iKeyBomNumArt, iKeyBomNamePart, iKeyBomQty };
CHECK_RET(A3DPDFScrollTableBindToTable(pScrollTableBom, pDataTable_Bom, sizeof(piMapColumns_Bom)/sizeof(A3DInt32), piMapColumns_Bom ));
CHECK_RET(A3DPDFTextFieldBindToTable(pTextCol0, pDataTable_Bom, iKeyBomNumArt));
CHECK_RET(A3DPDFTextFieldBindToTable(pTextCol1, pDataTable_Bom, iKeyBomNamePart));
const A3DInt32 piMapColumns_But[] = { iKeyBomIcon };
CHECK_RET(A3DPDFButtonBindToTable(pButIcon, pDataTable_Bom, sizeof(piMapColumns_But) / sizeof(A3DInt32), piMapColumns_But));
// --- Define interactions between widgets
// selection of a row in Bom -> 2 column values are displayed in 2 text field
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( pScrollTableBom, pTextCol0, kA3DPDFDataIsolate ));
CHECK_RET(A3DPDFWidgetSetTargetBehaviour(pScrollTableBom, pTextCol1, kA3DPDFDataIsolate));
CHECK_RET(A3DPDFWidgetSetTargetBehaviour(pScrollTableBom, pButIcon, kA3DPDFDataIsolate));
// selection of a row in Bom -> the associated elements of widget (=3d nodes) are highlighted
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( pScrollTableBom, p3DNodeScene, kA3DPDFDataHighlight ));
// select a node in 3D annot -> the elements of BOM (=scroll table rows) are selected (i.e. acts as if the user clicked on the BOM row)
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( p3DNodeScene, pScrollTableBom, kA3DPDFDataSelect ));
// TextInstance is populated coming from a selection in 3D
CHECK_RET(A3DPDFWidgetSetTargetBehaviour( p3DNodeScene, pTextInstance, kA3DPDFDataIsolate ));
// cleanup 3D modelfile
CHECK_RET(A3DAsmModelFileDelete(pModelFile));
// Free the A3DRWParamsPrcWriteHelper object at the end
if (pPRCWriteHelper != NULL)
A3DRWParamsPrcWriteHelperFree(pPRCWriteHelper);
}
indexpage++;
}
// end document
CHECK_RET(A3DPDFDocumentSaveEx(pDoc, kA3DPDFSaveFull|kA3DPDFSaveOptimized, OUT_FILE));
return iRet;
}
A3DStatus BuildPDFDocument()
{
A3DStatus iRet = A3D_SUCCESS;
// creating a document
A3DPDFDocument* pDoc = NULL;
iRet = A3DPDFDocumentCreateEmpty(&pDoc);
if(pDoc != NULL)
{
iRet = stBuildDocument(pDoc);
if (iRet!= A3D_SUCCESS)
std::cout << "Error building document ; Error number=" << iRet << std::endl;
// need to always close the doc to clean data
int iRetClose = A3DPDFDocumentClose(pDoc);
if (iRetClose!= A3D_SUCCESS)
std::cout << "Cannot close document ; Error number=" << iRetClose << std::endl;
}
else
std::cout << "Cannot build document ; Error number=" << iRet << std::endl;
return iRet;
}
//######################################################################################################################
// Main function
#ifdef _MSC_VER
int wmain(A3DInt32, A3DUniChar**)
#else
int main(int, A3DUTF8Char**)
#endif
{
#ifndef _MSC_VER
setenv("LC_NUMERIC", "en_US.UTF-8", 1); // Locally force locale
#endif
// init A3DLIB library - automatically handled init/terminate
A3DSDKHOOPSPublishLoader sHoopsPublishLoader(_T(HOOPS_BINARY_DIRECTORY));
CHECK_RET(sHoopsPublishLoader.m_eSDKStatus);
CHECK_RET(A3DDllSetCallbacksMemory(CheckMalloc, CheckFree));
// init HOOPS Publish related PDF library - automatically handled init/terminate
// do it only only once during the life of the application
CHECK_RET(sHoopsPublishLoader.InitPDFLib());
// launch PDF treatment
A3DStatus iRet = BuildPDFDocument();
if (iRet != A3D_SUCCESS)
return iRet;
// Check memory allocations
return (int)ListLeaks();
}
Reference in New Issue View Git Blame Copy Permalink