/*
Copyright (c) 2019 PTC Inc. and/or Its Subsidiary Companies. All Rights Reserved.
*/
/*=================================================================*\
Pro/Toolkit includes
\*=================================================================*/
#include <ProToolkit.h>
#include <ProObjects.h>
#include <ProMdl.h>
#include <ProMenu.h>
#include <ProDimension.h>
#include <ProSelection.h>
#include <ProGtol.h>
#include <ProFeature.h>
#include <ProMessage.h>
#include <ProWindows.h>
#include <ProAnnotation.h>
#include <ProUtil.h>
/*=================================================================*\
Application includes
\*=================================================================*/
#include "TestError.h"
#include "UtilMessage.h"
#include "UtilMenu.h"
#include "UtilTypes.h"
#include "UtilString.h"
#include "UtilCollect.h"
#include "PTApplsUnicodeUtils.h"
/*=================================================================*\
Application macros
\*=================================================================*/
#define mnLastItem -1
#define mnFirstItem -1
#define TestGtS_Unit 0x20
#define TestGtS_Stat 0x10
#define TestGtS_Diam 0x08
#define TestGtS_Free 0x04
#define TestGtS_All 0x02
#define TestGtS_Tan 0x01
#define YesNoStr(a) (a ? "Yes" : "No")
#define IsMenuDone(a) ((a == mnLastItem)||(a == mnFirstItem))?(PRO_B_FALSE):(PRO_B_TRUE)
/*=================================================================*\
Application global types
\*=================================================================*/
typedef struct test_gtol_symbol {
ProGtolType gtType;
int symbols;
char sel_param[80];
}TestGtolSymbol;
/*=================================================================*\
Application global data
\*=================================================================*/
static ProUtilMenuButtons mnGtolType[] ={
{"GtolType", mnFirstItem, TEST_CALL_PRO_MENU_DELETE},
{"Straightness", PROGTOLTYPE_STRAIGHTNESS, 0},
{"Flatness", PROGTOLTYPE_FLATNESS, 0},
{"Circular", PROGTOLTYPE_CIRCULAR, 0},
{"Cylindrical", PROGTOLTYPE_CYLINDRICAL, 0},
{"Line", PROGTOLTYPE_LINE, 0},
{"Surface", PROGTOLTYPE_SURFACE, 0},
{"Angular", PROGTOLTYPE_ANGULAR, 0},
{"Perpendicular", PROGTOLTYPE_PERPENDICULAR, 0},
{"Parallel", PROGTOLTYPE_PARALLEL, 0},
{"Position", PROGTOLTYPE_POSITION, 0},
{"Concentricity", PROGTOLTYPE_CONCENTRICITY, 0},
{"Symmetry", PROGTOLTYPE_SYMMETRY, 0},
{"Circular Runout", PROGTOLTYPE_CIRCULAR_RUNOUT,0},
{"Total Highway", PROGTOLTYPE_TOTAL_RUNOUT, 0},
{"", mnLastItem,0}};
static ProUtilMenuButtons mnGtolRefItemType[] = {
{"RefItemType", mnFirstItem, TEST_CALL_PRO_MENU_DELETE},
{"edge", PROGTOLRTYPE_EDGE, 0},
{"axis", PROGTOLRTYPE_AXIS, 0},
{"surface", PROGTOLRTYPE_SURF, 0},
{"feature", PROGTOLRTYPE_FEAT, 0},
{"datum", PROGTOLRTYPE_DATUM, 0},
{"", mnLastItem, 0}};
static ProUtilMenuButtons mnGtolPlacementType[]={
{"Placement", mnFirstItem,TEST_CALL_PRO_MENU_DELETE},
{"Datum", PROGTOLPTYPE_DATUM, 0},
{"Dimension", PROGTOLPTYPE_DIMENSION, 0},
{"Dim. Related", PROGTOLPTYPE_DIM_RELATED,0},
{"Free note", PROGTOLPTYPE_FREENOTE, 0},
{"Leaders", PROGTOLPTYPE_LEADERS, 0},
{"Tanleader", PROGTOLPTYPE_TANLEADER, 0},
{"NormLeader", PROGTOLPTYPE_NORMLEADER, 0},
{"Gtol", PROGTOLPTYPE_GTOL, 0},
{"", mnLastItem, 0}};
static ProUtilMenuButtons mnGtolLeaderType[]={
{"Leader Type", mnFirstItem,TEST_CALL_PRO_MENU_DELETE},
{"Arrow head", PROLEADERTYPE_ARROWHEAD, 0},
{"Dot", PROLEADERTYPE_DOT, 0},
{"Fille dot", PROLEADERTYPE_FILLEDDOT, 0},
{"No arrow", PROLEADERTYPE_NOARROW, 0},
{"Slash", PROLEADERTYPE_SLASH, 0},
{"Integral", PROLEADERTYPE_INTEGRAL, 0},
{"Box", PROLEADERTYPE_BOX, 0},
{"Filled box", PROLEADERTYPE_FILLEDBOX, 0},
{"Double arrow",PROLEADERTYPE_DOUBLEARROW,0},
{"", mnLastItem, 0}};
static ProUtilMenuButtons mnGtolMaterialCond[]={
{"Material Cond.", mnFirstItem, TEST_CALL_PRO_MENU_DELETE},
{"UnKnown", PROGTOLMATCOND_UNKNOWN, 0},
{"LMC", PROGTOLMATCOND_LMC, 0},
{"MMC", PROGTOLMATCOND_MMC, 0},
{"RFC", PROGTOLMATCOND_RFS, 0},
{"Default RFS", PROGTOLMATCOND_DEFAULT_RFS, 0},
{"", mnLastItem, 0}};
static ProUtilMenuButtons mnGtolReferenceType[]={
{"Reference type", mnFirstItem, TEST_CALL_PRO_MENU_DELETE},
{"None", PROGTOLREFTYPE_NONE, 0},
{"Primary", PROGTOLREFTYPE_PRIMARY, 0},
{"Secondary", PROGTOLREFTYPE_SECONDARY, 0},
{"Tertiary", PROGTOLREFTYPE_TERTIARY, 0},
{"", mnLastItem, 0}};
static ProUtilMenuButtons mnGtolProjzone[]={
{"Proj. zone", mnFirstItem, TEST_CALL_PRO_MENU_DELETE},
{"None", PROGTOLPROJZONE_NONE, 0},
{"Below", PROGTOLPROJZONE_BELOWGTOL, 0},
{"Inside", PROGTOLPROJZONE_INSIDEGTOL, 0},
{"", mnLastItem, 0}};
static TestGtolSymbol TestGtolSymbolTbl[]={
{PROGTOLTYPE_UNKNOWN,
TestGtS_Stat,
""},
{PROGTOLTYPE_STRAIGHTNESS,
TestGtS_Stat | TestGtS_Diam | TestGtS_Free | TestGtS_Unit,
"surface,axis,edge"},
{PROGTOLTYPE_FLATNESS,
TestGtS_Stat | TestGtS_Free | TestGtS_Unit,
"sldface"},
{PROGTOLTYPE_CIRCULAR,
TestGtS_Stat | TestGtS_Free,
"surface"},
{PROGTOLTYPE_CYLINDRICAL,
TestGtS_Stat | TestGtS_Free,
"surface"},
{PROGTOLTYPE_LINE,
TestGtS_Stat | TestGtS_All | TestGtS_Tan,
"edge"},
{PROGTOLTYPE_SURFACE,
TestGtS_Stat | TestGtS_All | TestGtS_Tan,
"surface"},
{PROGTOLTYPE_ANGULAR,
TestGtS_Stat | TestGtS_Diam | TestGtS_Tan,
"datum,surface,axis"},
{PROGTOLTYPE_PERPENDICULAR,
TestGtS_Stat | TestGtS_Diam | TestGtS_Tan | TestGtS_Unit,
"surface,axis,datum"},
{PROGTOLTYPE_PARALLEL ,
TestGtS_Stat | TestGtS_Diam | TestGtS_Tan | TestGtS_Unit,
"surface,axis"},
{PROGTOLTYPE_POSITION,
TestGtS_Stat | TestGtS_Diam | TestGtS_Free,
"point,axis,datum,csys,feature,edge,curve"},
{PROGTOLTYPE_CONCENTRICITY,
TestGtS_Stat | TestGtS_Diam | TestGtS_Free,
"axis,surface"},
{PROGTOLTYPE_SYMMETRY,
TestGtS_Stat | TestGtS_Free,
"point,axis,datum,csys,feature,edge,curve"},
{PROGTOLTYPE_CIRCULAR_RUNOUT,
TestGtS_Stat,
"surface"},
{PROGTOLTYPE_TOTAL_RUNOUT,
TestGtS_Stat,
"surface"},
{(ProGtolType)-1, -1, ""}};
static char *NumeralStr[]={
"First",
"Second",
"Third"
};
static char *strDatumRef[]={
"primary",
"secondary",
"tertiary"
};
/*====================================================================*\
Function : TestGtolSymInfoGet()
Purpose : return in
\*====================================================================*/
ProError TestGtolSymInfoGet(ProGtolType gtType, TestGtolSymbol *info)
{
int i=0;
if(info == NULL)
return(PRO_TK_BAD_INPUTS);
while(TestGtolSymbolTbl[i].gtType!=-1)
{
if(TestGtolSymbolTbl[i].gtType == gtType)
{
memcpy(info, &TestGtolSymbolTbl[i],sizeof(TestGtolSymbol));
return(PRO_TK_NO_ERROR);
}
i++;
}
return(PRO_TK_E_NOT_FOUND);
}
/*====================================================================*\
Function : TestGtolSymIsEnable()
Purpose : If specified symbol enabled for gtol then return PRO_B_TRUE.
\*====================================================================*/
ProBoolean TestGtolSymIsEnable(ProGtolType gtType, int sym)
{
ProError error;
TestGtolSymbol info;
error = TestGtolSymInfoGet(gtType, &info);
if(error != PRO_TK_NO_ERROR)
return(PRO_B_FALSE);
return(((info.symbols & sym)!=0)?(PRO_B_TRUE):(PRO_B_FALSE));
}
/*====================================================================*\
Function : TestGtolSymSelParam()
Purpose : Return string for ProSelect function.
\*====================================================================*/
char* TestGtolSymSelParam(ProGtolType gtType)
{
static TestGtolSymbol info;
ProError error;
error = TestGtolSymInfoGet(gtType, &info);
if(error != PRO_TK_NO_ERROR)
return(NULL);
return(info.sel_param);
}
/*====================================================================*\
Function : ProArrayObjectAdd()
Purpose : Visit action function. Add visited object to array.
\*====================================================================*/
ProError TestGtolCollectVisit(ProGtol *gtol, ProError status, ProAppData app_data)
{
ProError error;
/*--------------------------------------------------------------------*\
Add visited object to array
\*--------------------------------------------------------------------*/
error = ProArrayObjectAdd((ProArray*)app_data,PRO_VALUE_UNUSED,1,gtol);
TEST_CALL_REPORT ("ProArrayObjectAdd()",
"TestGtolCollectVisit()", error, error != PRO_TK_NO_ERROR);
return(error);
}
/*====================================================================*\
Function : TestGtolCollect()
Purpose : Collect all gtol in the model.
\*====================================================================*/
ProError TestGtolCollect(ProMdl mdl, ProGtol **gtol)
{
ProGtol *tmp_gtol = NULL;
ProError error;
if((gtol==NULL)||(mdl==NULL))
return(PRO_TK_BAD_INPUTS);
/*--------------------------------------------------------------------*\
Alloc memory for gtol array.
\*--------------------------------------------------------------------*/
error = ProArrayAlloc(0, sizeof(ProGtol),1,(ProArray*)&tmp_gtol);
TEST_CALL_REPORT ("ProArrayAlloc()",
"TestGtolCollect()", error, error != PRO_TK_NO_ERROR);
if(error!=PRO_TK_NO_ERROR)
return(error);
/*--------------------------------------------------------------------*\
Visit and add all gtol from the specified model.
\*--------------------------------------------------------------------*/
error = ProMdlGtolVisit(mdl,(ProGtolVisitAction)TestGtolCollectVisit,
(ProGtolFilterAction)PRO_NO_FUNCTION,(ProAppData)&tmp_gtol);
TEST_CALL_REPORT ("ProMdlGtolVisit()",
"TestGtolCollect()", error, error != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
If error then free memory.
\*--------------------------------------------------------------------*/
if(error!=PRO_TK_NO_ERROR)
{
if(tmp_gtol!=NULL)
{
error=ProArrayFree((ProArray*)&tmp_gtol);
TEST_CALL_REPORT ("ProArrayFree()",
"TestGtolCollect()", error, error != PRO_TK_NO_ERROR);
tmp_gtol = NULL;
}
return(error);
}
*gtol = tmp_gtol;
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestGtolPlacementPrn()
Purpose : Print information about gtol placement.
\*====================================================================*/
ProError TestGtolPlacementPrn(FILE *fp, ProGtoldata data)
{
ProGtolleader *leaders;
ProLeaderType lead_type;
int n, i;
ProSelection attachment;
ProCharLine cname;
ProGtol gtol;
ProDimension dimension;
ProGtolPlacementType plcType;
ProError error;
ProPoint3d location;
/*--------------------------------------------------------------------*\
Get gtol placement information
\*--------------------------------------------------------------------*/
error = ProGtoldataPlacementGet(data, &plcType, &dimension,
&leaders, location, >ol);
TEST_CALL_REPORT ("ProGtoldataPlacementGet()",
"TestGtolPlacementPrn()", error, error != PRO_TK_NO_ERROR);
if(error!=PRO_TK_NO_ERROR)
return(error);
ProUtilGtolPlacementTypeStr(plcType, cname);
ProTKFprintf(fp, (char*)"Placement type: %s\n", cname);
if((plcType == PROGTOLPTYPE_DIMENSION)||(plcType == PROGTOLPTYPE_DIM_RELATED))
ProTKFprintf(fp, (char*)"Dimension id: %d\n", dimension.id);
if(plcType == PROGTOLPTYPE_GTOL)
ProTKFprintf(fp, (char*)"Geometric tolerance id: %d\n", gtol.id);
/*--------------------------------------------------------------------*\
Print information about gtol location and leaders if gtol have it.
\*--------------------------------------------------------------------*/
switch (plcType)
{
case PROGTOLPTYPE_LEADERS:
case PROGTOLPTYPE_TANLEADER:
case PROGTOLPTYPE_NORMLEADER:
error = ProArraySizeGet((ProArray)leaders, &n);
if((error==PRO_TK_NO_ERROR)&&(n>0))
for(i=0; i<n; i++)
{
error = ProGtolleaderGet(leaders[i], &lead_type, &attachment);
TEST_CALL_REPORT ("ProGtolleaderGet()",
"TestGtolPlacementPrn()", error, error != PRO_TK_NO_ERROR);
ProUtilLeaderTypeStr(lead_type, cname);
ProTKFprintf(fp,(char*)"Leader type: %s\n", cname);
};
error = ProArrayFree((ProArray*)&leaders);
break;
case PROGTOLPTYPE_DIM_RELATED:
case PROGTOLPTYPE_FREENOTE:
ProTKFprintf(fp, (char*)"Location: (%5.5f, %5.5f, %5.5f)\n",
location[0], location[1], location[2]);
}
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestGtolDatumRefInfo()
Purpose : Print information about gtol references.
\*====================================================================*/
ProError TestGtolDatumRefInfo(FILE *fp, ProGtoldata data)
{
ProGtoldatumref datumRef[3];
ProError error;
ProSelection basic_datum, compound_datum;
ProGtolMaterialCond basic_matcond, compound_matcond;
int i;
ProCharLine cname;
ProModelitem mdl_item;
/*--------------------------------------------------------------------*\
Get the datum references for a gtol.
\*--------------------------------------------------------------------*/
error = ProGtoldataGtoldatumrefGet(data, &datumRef[0],
&datumRef[1], &datumRef[2]);
TEST_CALL_REPORT ("ProGtoldataGtoldatumrefGet()",
"TestGtolDatumRefInfo()", error, error != PRO_TK_NO_ERROR);
if(error!=PRO_TK_NO_ERROR)
return(error);
for(i=0; i<3; i++)
{
/*--------------------------------------------------------------------*\
Get from information datum reference structure.
\*--------------------------------------------------------------------*/
if(datumRef[i]!=NULL)
{
error = ProGtoldatumrefGet(datumRef[i], &basic_datum, &basic_matcond,
&compound_datum, &compound_matcond);
TEST_CALL_REPORT ("ProGtoldatumrefGet()",
"TestGtolDatumRefInfo()", error, error != PRO_TK_NO_ERROR);
if(error!=PRO_TK_NO_ERROR)
continue;
/*--------------------------------------------------------------------*\
Print information about datum reference.
\*--------------------------------------------------------------------*/
ProTKFprintf(fp, (char*)"%s Datum Reference\n", NumeralStr[i]);
if(basic_datum!=NULL)
{
error = ProSelectionModelitemGet(basic_datum, &mdl_item);
TEST_CALL_REPORT ("ProSelectionModelitemGet()",
"TestGtolDatumRefInfo()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_NO_ERROR)
{
ProUtilGtolMaterialCondStr(basic_matcond, cname);
ProTKFprintf(fp, (char*)"\tBasic:\n\t\tDatum id: %d\n\t\tMaterial cond.: %s\n",
mdl_item.id, cname);
}
}
if(compound_datum!=NULL)
{
error = ProSelectionModelitemGet(compound_datum, &mdl_item);
TEST_CALL_REPORT ("ProSelectionModelitemGet()",
"TestGtolDatumRefInfo()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_NO_ERROR)
{
ProUtilGtolMaterialCondStr(compound_matcond, cname);
ProTKFprintf(fp, (char*)"\tCompound:\n\t\tDatum id: %d\n\t\tMaterial cond.: %s\n",
mdl_item.id, cname);
}
}
}
}
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestGtolReferenceInfo()
Purpose : Print information about gtol references.
\*====================================================================*/
ProGtolRefItemType TestGtolReferenceInfo(FILE *fp, ProGtoldata data)
{
ProCharLine cname;
ProSelection ref;
ProGtolRefItemType refType;
ProModelitem mdl_item;
ProError error;
/*--------------------------------------------------------------------*\
Gets the item which the gtol refers to.
\*--------------------------------------------------------------------*/
error = ProGtoldataReferenceGet(data, &refType, &ref);
TEST_CALL_REPORT ("ProGtoldataReferenceGet()",
"TestGtolReferenceInfo()", error, error != PRO_TK_NO_ERROR);
if(error!=PRO_TK_NO_ERROR)
return((ProGtolRefItemType)-1);
ProUtilGtolRefItemTypeStr(refType, cname);
ProTKFprintf(fp,(char*)"Reference type: %s\n",cname);
error = ProSelectionModelitemGet(ref, &mdl_item);
TEST_CALL_REPORT ("ProSelectionModelitemGet()",
"TestGtolReferenceInfo()", error, error != PRO_TK_NO_ERROR);
ProTKFprintf(fp,(char*)"Reference item id: %d\n", mdl_item.id);
return(refType);
}
/*====================================================================*\
Function : TestGtolPrintInfo()
Purpose : Print gtol information.
\*====================================================================*/
ProError TestGtolPrintInfo(FILE* fp, ProGtoldata data)
{
ProGtolType type;
ProCharLine cname, ctype;
ProError error;
ProMdl mdl, owner;
ProBoolean is_composite, overall_tol, perunit_tol,
stat_tol, diam, free_stat, specify_height,
all_around, tangent_plane, outside;
ProGtolProfBoundIndex profile_idx;
double val, overall_value, val_per_unit, zone_height, unit_len;
ProGtolReferenceType r_type;
ProName name;
ProGtolMaterialCond matcond;
ProGtolProjzone projected_zone;
ProMdldata mdl_data;
ProGtolRefItemType refType;
ProMdlName modelName;
ProMdlExtension modelExtension;
/*--------------------------------------------------------------------*\
Gets gtol type
\*--------------------------------------------------------------------*/
error = ProGtoldataTypeGet(data,&type);
TEST_CALL_REPORT ("ProGtoldataTypeGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_NO_ERROR)
{
ProUtilGtolTypeStr(type, cname);
ProTKFprintf(fp,(char*)"Type: %s\n", cname );
}
/*--------------------------------------------------------------------*\
Gets gtol owner
\*--------------------------------------------------------------------*/
error = ProGtoldataOwnerGet(data, &owner);
TEST_CALL_REPORT ("ProGtoldataOwnerGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
error = ProMdlMdlnameGet(owner, modelName);
TEST_CALL_REPORT ("ProMdlMdlnameGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
error = ProMdlExtensionGet(owner, modelExtension);
TEST_CALL_REPORT ("ProMdlExtensionGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
ProWstringToString(ctype, modelExtension);
ProWstringToString(cname, modelName);
ProTKFprintf(fp, (char*)"Owner type: %s; name: %s\n", ctype, cname);
/*--------------------------------------------------------------------*\
Gets the model which defines the origin of ProSelection structures
used to define references inside the gtol.
\*--------------------------------------------------------------------*/
error = ProGtoldataModelGet(data, &mdl);
TEST_CALL_REPORT ("ProGtoldataModelGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
error = ProMdlMdlnameGet(mdl, modelName);
TEST_CALL_REPORT ("ProMdlMdlnameGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
error = ProMdlExtensionGet(mdl, modelExtension);
TEST_CALL_REPORT ("ProMdlExtensionGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
ProWstringToString(ctype, modelExtension);
ProWstringToString(cname, modelName);
ProTKFprintf(fp, (char*)"Model type: %s; name: %s\n", ctype, cname);
/*--------------------------------------------------------------------*\
Gets reference, placement and datom reference info.
\*--------------------------------------------------------------------*/
refType = TestGtolReferenceInfo(fp, data);
if (refType !=PROGTOLRTYPE_DATUM)
{
TestGtolPlacementPrn(fp, data);
}
if(!((type == PROGTOLTYPE_STRAIGHTNESS)||(type == PROGTOLTYPE_FLATNESS)||
(type == PROGTOLTYPE_CIRCULAR) ||(type == PROGTOLTYPE_CYLINDRICAL)))
TestGtolDatumRefInfo(fp, data);
/*--------------------------------------------------------------------*\
Check if gtol is composite then print information about composite.
\*--------------------------------------------------------------------*/
if((type == PROGTOLTYPE_SURFACE)||(type == PROGTOLTYPE_POSITION))
{
error = ProGtoldataCompositeGet(data,
&is_composite, &val, &r_type);
TEST_CALL_REPORT ("ProGtoldataCompositeGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
}
else is_composite = PRO_B_FALSE;
if(is_composite == PRO_B_TRUE)
{
ProUtilGtolReferenceTypeStr(r_type, cname);
ProTKFprintf(fp, (char*)"Gtol is composite: value: %5.5f; ref. type: %s\n",
val, cname);
} else {
ProTKFprintf(fp,(char*)"Gtol is not composite.\n");
}
/*--------------------------------------------------------------------*\
Gets the value of a gtol.
\*--------------------------------------------------------------------*/
error = ProGtoldataValueGet(data,
&overall_tol, &overall_value, name);
TEST_CALL_REPORT ("ProGtoldataValueGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
ProTKFprintf(fp, (char*)"Overall tolerance : %s; value: %5.5f; name: %s\n",
YesNoStr(overall_tol), overall_value, ProWstringToString(cname, name));
/*--------------------------------------------------------------------*\
Get the per unit tolerance of a gtol.
\*--------------------------------------------------------------------*/
error = ProGtoldataPerUnitGet(data,
&perunit_tol, &val_per_unit, &unit_len);
TEST_CALL_REPORT ("ProGtoldataPerUnitGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
Get the material condition of a gtol.
\*--------------------------------------------------------------------*/
error = ProGtoldataMatCondGet(data, &matcond);
TEST_CALL_REPORT ("ProGtoldataMatCondGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_NO_ERROR)
{
ProUtilGtolMaterialCondStr(matcond, cname);
ProTKFprintf(fp, (char*)"The material condition: %s\n", cname);
}
/*--------------------------------------------------------------------*\
Get the material condition of a gtol.
\*--------------------------------------------------------------------*/
error = ProGtoldataStatTolGet(data, &stat_tol);
TEST_CALL_REPORT ("ProGtoldataStatTolGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
if(error==PRO_TK_NO_ERROR)
ProTKFprintf(fp,(char*)"Free state: %s\n", YesNoStr(stat_tol));
/*--------------------------------------------------------------------*\
Get whether a gtol shows the diameter tolerance symbol.
\*--------------------------------------------------------------------*/
error = ProGtoldataDiameterGet(data, &diam);
TEST_CALL_REPORT ("ProGtoldataDiameterGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
ProTKFprintf(fp,(char*)"Diameter: %s\n", YesNoStr(diam));
/*--------------------------------------------------------------------*\
Get whether a gtol shows the free state symbol.
\*--------------------------------------------------------------------*/
error = ProGtoldataFreeStateGet(data, &free_stat);
TEST_CALL_REPORT ("ProGtoldataFreeStateGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
if(error==PRO_TK_NO_ERROR)
ProTKFprintf(fp, (char*)"Free state: %s\n", YesNoStr(free_stat));
/*--------------------------------------------------------------------*\
Gets whether a gtol shows the all around symbol.
\*--------------------------------------------------------------------*/
error = ProGtoldataAllAroundGet(data, &all_around);
TEST_CALL_REPORT ("ProGtoldataAllAroundGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
if(error==PRO_TK_NO_ERROR)
ProTKFprintf(fp, (char*)"All around: %s\n", YesNoStr(all_around));
/*--------------------------------------------------------------------*\
Gets whether a gtol shows the tangent plane symbol.
\*--------------------------------------------------------------------*/
error = ProGtoldataTangentPlaneGet(data, &tangent_plane);
TEST_CALL_REPORT ("ProGtoldataTangentPlaneGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_NO_ERROR)
ProTKFprintf(fp, (char*)"Tangent plane: %s\n", YesNoStr(tangent_plane));
/*--------------------------------------------------------------------*\
Gets the projected tolerance zone for a gtol.
\*--------------------------------------------------------------------*/
if((type == PROGTOLTYPE_ANGULAR)||
(type == PROGTOLTYPE_PERPENDICULAR)||
(type == PROGTOLTYPE_PARALLEL)||
(type == PROGTOLTYPE_POSITION))
{
error = ProGtoldataProjZoneGet(data, &projected_zone,
&specify_height, &zone_height);
TEST_CALL_REPORT ("ProGtoldataProjZoneGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
if(error==PRO_TK_NO_ERROR)
{
ProUtilGtolProjzoneStr(projected_zone, cname);
ProTKFprintf(fp, (char*)"Projected zone type: %s\n", cname);
if(specify_height == PRO_B_TRUE)
ProTKFprintf(fp,(char*)"Projected zone height:%5.5f\n", zone_height);
}
}
/*--------------------------------------------------------------------*\
Gets the profile boundary for a gtol.
\*--------------------------------------------------------------------*/
if ((type == PROGTOLTYPE_LINE)||
(type == PROGTOLTYPE_SURFACE))
{
error = ProGtoldataProfBoundaryGet(data, &profile_idx, &outside);
TEST_CALL_REPORT ("ProGtoldataProfBoundaryGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
if(error==PRO_TK_NO_ERROR)
{
switch (profile_idx)
{
case PROGTOLPROF_BILATERAL_IDX:
{
ProTKFprintf (fp, (char*)"Profile Boundary: bilateral \n");
break;
}
case PROGTOLPROF_UNILATERAL_IDX:
{
ProTKFprintf (fp, (char*)"Profile Boundary: unilateral; outside: %s \n", YesNoStr (outside));
break;
}
case PROGTOLPROF_UNEQUAL_IDX:
{
ProTKFprintf (fp, (char*)"Profile Boundary: unequal \n");
break;
}
default:
break;
}
}
}
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestMdlGtolShow()
Purpose : Show all gtol in the specified model .
\*====================================================================*/
ProError TestMdlGtolShow(ProMdl mdl)
{
ProFeature *features = NULL;
ProError error;
int n, i;
ProSelection sel;
/*--------------------------------------------------------------------*\
Collect all features in the specified model.
\*--------------------------------------------------------------------*/
error = ProUtilCollectSolidFeaturesWithFilter((ProSolid)mdl, (ProFeatureFilterAction)PRO_TK_NO_ERROR, &features);
if((error!=PRO_TK_NO_ERROR)||(features == NULL))
return(PRO_TK_E_NOT_FOUND);
error= ProArraySizeGet((ProArray)features, &n);
TEST_CALL_REPORT ("ProArraySizeGet()",
"TestMdlGtolShow()", error, error != PRO_TK_NO_ERROR);
if((error!=PRO_TK_NO_ERROR)||(n<=0))
return(PRO_TK_E_NOT_FOUND);
/*--------------------------------------------------------------------*\
Show gtol for each feature.
\*--------------------------------------------------------------------*/
for(i=0; i<n; i++)
{
error = ProSelectionAlloc(NULL,(ProModelitem*)&features[i], &sel);
TEST_CALL_REPORT ("ProSelectionAlloc()",
"TestGtolInfoSel()", error, error != PRO_TK_NO_ERROR);
error = ProFeatureParamsDisplay(sel, PRO_GTOL_PARAM);
TEST_CALL_REPORT ("ProFeatureParamsDisplay()",
"TestGtolInfoSel()", error, error != PRO_TK_NO_ERROR);
error = ProSelectionFree(&sel);
TEST_CALL_REPORT ("ProSelectionFree()",
"TestGtolInfoSel()", error, error != PRO_TK_NO_ERROR);
}
/*--------------------------------------------------------------------*\
Free allocated memory.
\*--------------------------------------------------------------------*/
error = ProArrayFree((ProArray*)&features);
TEST_CALL_REPORT ("ProArrayFree()",
"TestGtolInfoSel()", error, error != PRO_TK_NO_ERROR);
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestGtolInfoSel()
Purpose : Show information for selected gtol.
\*====================================================================*/
ProError TestGtolInfoSel(ProMdl model)
{
ProError error;
ProGtol gtol;
int n_sel;
ProGtoldata data;
char file_name[]="Gtol.info";
FILE *fp;
ProName wstr;
ProSelection *sel;
/*--------------------------------------------------------------------*\
Show all gtols in the specified model
\*--------------------------------------------------------------------*/
error = TestMdlGtolShow(model);
if(error!=PRO_TK_NO_ERROR)
return(error);
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select gtol.");
/*--------------------------------------------------------------------*\
Select gtol get information about it, and show this information.
\*--------------------------------------------------------------------*/
error = ProSelect((char*)"gtol", 1,NULL, NULL, NULL, NULL, &sel, &n_sel);
TEST_CALL_REPORT ("ProSelect()",
"TestGtolInfoSel()", error, error != PRO_TK_NO_ERROR);
if((error!=PRO_TK_NO_ERROR)||(n_sel<0))
return(PRO_TK_E_NOT_FOUND);
error = ProSelectionModelitemGet(sel[0],(ProModelitem*)>ol);
TEST_CALL_REPORT ("ProSelectionModelitemGet()",
"TestGtolInfoSel()", error, error != PRO_TK_NO_ERROR);
error = ProGtoldataAlloc(model, &data);
TEST_CALL_REPORT ("ProGtoldataAlloc()",
"TestGtolInfoSel()", error, error != PRO_TK_NO_ERROR);
if((error!=PRO_TK_NO_ERROR)||(data == NULL))
return(error);
if ((fp = PTApplsUnicodeFopen(file_name, "w")) == NULL)
{
ProTKPrintf((char*)"Cannot open output file\n");
return ((ProError)-1);
}
error = ProGtolDataGet(>ol, &data);
TEST_CALL_REPORT ("ProGtolDataGet()",
"TestGtolInfoSel()", error, error != PRO_TK_NO_ERROR);
ProTKFprintf(fp,(char*)"\t\tGeometric Tolerance\n");
TestGtolPrintInfo(fp,data);
fclose(fp);
error = ProGtoldataFree(&data);
TEST_CALL_REPORT ("ProGtoldataFree()",
"TestGtolInfoSel()", error, error != PRO_TK_NO_ERROR);
error = ProInfoWindowDisplay(ProStringToWstring(wstr, file_name), NULL, NULL);
TEST_CALL_REPORT ("ProInfoWindowDisplay()",
"TestGtolInfoSel()", error, error != PRO_TK_NO_ERROR);
return(error);
}
/*====================================================================*\
Function : TestGtolInfoAll()
Purpose : Show information about all gtols in the model.
\*====================================================================*/
ProError TestGtolInfoAll(ProMdl model)
{
ProError error;
ProGtoldata data;
ProGtol *gtol;
int i, n;
char file_name[]="GtolAll.info";
FILE *fp;
ProName wstr;
ProMdldata mdl_data;
ProCharLine cname, ctype;
ProMdlName modelName;
ProMdlExtension modelExtension;
if(model == NULL)
{
error = ProMdlCurrentGet(&model);
TEST_CALL_REPORT ("ProMdlCurrentGet()",
"TestGtolInfoAll()", error, error != PRO_TK_NO_ERROR);
if(error!=PRO_TK_NO_ERROR)
return(error);
}
error = ProMdlMdlnameGet(model, modelName);
TEST_CALL_REPORT ("ProMdlMdlnameGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
error = ProMdlExtensionGet(model, modelExtension);
TEST_CALL_REPORT ("ProMdlExtensionGet()",
"TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
ProWstringToString(ctype, modelExtension);
ProWstringToString(cname, modelName);
/*--------------------------------------------------------------------*\
Collect all gtols from the current model.
\*--------------------------------------------------------------------*/
error = TestGtolCollect(model, >ol);
if(error!=PRO_TK_NO_ERROR)
return(error);
/*--------------------------------------------------------------------*\
Get gtols count.
\*--------------------------------------------------------------------*/
error = ProArraySizeGet((ProArray)gtol, &n);
TEST_CALL_REPORT ("ProArraySizeGet()",
"TestGtolInfoAll()", error, error != PRO_TK_NO_ERROR);
if((error!=PRO_TK_NO_ERROR)||(n<=0))
return(error);
if ((fp = PTApplsUnicodeFopen(file_name, "w")) == NULL)
{
ProTKPrintf((char*)"Cannot open output file\n");
return ((ProError)-1);
}
ProTKFprintf(fp, (char*)"Model Name: %s; Type: %s\n", cname, ctype);
/*--------------------------------------------------------------------*\
Print information about each gtol.
\*--------------------------------------------------------------------*/
for(i=0; i<n; i++)
{
error = ProGtolDataGet(>ol[i], &data);
TEST_CALL_REPORT ("ProGtolDataGet()",
"TestGtolInfoAll()", error, error != PRO_TK_NO_ERROR);
ProTKFprintf(fp,(char*)"%d Geometric Tolerance\n",i);
TestGtolPrintInfo(fp,data);
ProTKFprintf(fp,(char*)"\n");
error = ProGtoldataFree(&data);
TEST_CALL_REPORT ("ProGtoldataFree()",
"TestGtolInfoAll()", error, error != PRO_TK_NO_ERROR);
}
/*--------------------------------------------------------------------*\
Close output file, free memory and show information.
\*--------------------------------------------------------------------*/
fclose(fp);
error = ProArrayFree((ProArray*)>ol);
TEST_CALL_REPORT ("ProArrayFree()",
"TestGtolInfoAll()", error, error != PRO_TK_NO_ERROR);
error = ProInfoWindowDisplay(ProStringToWstring(wstr, file_name), NULL, NULL);
TEST_CALL_REPORT ("ProInfoWindowDisplay()",
"TestGtolInfoAll()", error, error != PRO_TK_NO_ERROR);
return(error);
}
/*====================================================================*\
Function : TestGtolDeleteAll()
Purpose : Delete all gtol from the model.
\*====================================================================*/
ProError TestGtolDeleteAll(ProMdl model)
{
ProError error;
ProGtol *gtol;
int i, n;
/*--------------------------------------------------------------------*\
Collect all gtol in the specified model.
\*--------------------------------------------------------------------*/
error = TestGtolCollect(model, >ol);
if(error!=PRO_TK_NO_ERROR)
return(error);
error = ProArraySizeGet((ProArray)gtol, &n);
TEST_CALL_REPORT ("ProArraySizeGet()",
"TestGtolGet()", error, error != PRO_TK_NO_ERROR);
if((error!=PRO_TK_NO_ERROR)||(n<=0))
return(error);
/*--------------------------------------------------------------------*\
Delete gtols.
\*--------------------------------------------------------------------*/
for(i=0; i<n; i++)
{
error = ProGtolDelete(>ol[i]);
TEST_CALL_REPORT ("ProGtolDelete()",
"TestGtolDeleteAll()", error, error != PRO_TK_NO_ERROR);
}
if(gtol!=NULL)
{
error = ProArrayFree((ProArray*)>ol);
TEST_CALL_REPORT ("ProArrayFree()",
"TestGtolDeleteAll()", error, error != PRO_TK_NO_ERROR);
}
error = ProWindowRepaint(PRO_VALUE_UNUSED);
TEST_CALL_REPORT ("ProWindowRepaint()",
"TestGtolDeleteAll()", error, error != PRO_TK_NO_ERROR);
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestGtolModify()
Purpose : Change gtol value in all gtols.
\*====================================================================*/
ProError TestGtolModify(ProMdl model)
{
ProError error;
ProGtol *gtol;
ProGtoldata *data;
int i, n, ch;
double value, old_value;
ProBoolean tolerance;
ProName wname;
ProGtoldataStatus status;
/*--------------------------------------------------------------------*\
Collect all gtols in the specified model.
\*--------------------------------------------------------------------*/
error = TestGtolCollect(model, >ol);
if(error!=PRO_TK_NO_ERROR)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Gtol is not found.");
return(error);
}
error = ProArraySizeGet((ProArray)gtol, &n);
TEST_CALL_REPORT ("ProArraySizeGet()",
"TestGtolGet()", error, error != PRO_TK_NO_ERROR);
if(n<=0)
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"The current model have't any gtol.");
if((error!=PRO_TK_NO_ERROR)||(n<=0))
return(error);
/*--------------------------------------------------------------------*\
Prompt user to input new gtol value.
\*--------------------------------------------------------------------*/
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Input new gtol value:");
if(ProMessageDoubleRead(NULL, &value)!=PRO_TK_NO_ERROR)
{
error = ProArrayFree((ProArray*)>ol);
TEST_CALL_REPORT ("ProGtoldataFree()",
"TestGtolModify()", error, error != PRO_TK_NO_ERROR);
return(PRO_TK_BAD_INPUTS);
}
error = ProArrayAlloc(n, sizeof(ProGtoldata), 1, (ProArray*)&data);
TEST_CALL_REPORT ("ProArrayAlloc()",
"TestGtolModify()", error, error != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
Change value in the each gtol
\*--------------------------------------------------------------------*/
for(i=0; i<n; i++)
{
error = ProGtolEditInit(>ol[i], &data[i]);
TEST_CALL_REPORT ("ProArrayFree()",
"TestGtolModify()", error, error != PRO_TK_NO_ERROR);
if(error!=PRO_TK_NO_ERROR)
{
data[i] = NULL;
continue;
}
error = ProGtoldataValueGet(data[i], &tolerance, &old_value, wname);
TEST_CALL_REPORT ("ProGtoldataValueGet()",
"TestGtolModify()", error, error != PRO_TK_NO_ERROR);
error = ProGtoldataValueSet(data[i], tolerance, value, wname, &status);
TEST_CALL_REPORT ("ProGtoldataValueSet()",
"TestGtolModify()", error, error != PRO_TK_NO_ERROR);
}
/*--------------------------------------------------------------------*\
Prompt user for confirmation all changes.
\*--------------------------------------------------------------------*/
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Commit all changes ?");
ch = ProUtilYesnoGet((char*)"Yes");
for(i=0; i<n; i++)
{
if(data[i]!=NULL)
{
if(ch == 1)
{
error = ProGtolEditCommit(>ol[i], data[i]);
TEST_CALL_REPORT ("ProGtolEditCommit()",
"TestGtolModify()", error, error != PRO_TK_NO_ERROR);
} else
{
error = ProGtolEditCancel(>ol[i], data[i]);
TEST_CALL_REPORT ("ProGtolEditCancel()",
"TestGtolModify()", error, error != PRO_TK_NO_ERROR);
};
error = ProGtoldataFree(&data[i]);
TEST_CALL_REPORT ("ProGtoldataFree()",
"TestGtolModify()", error, error != PRO_TK_NO_ERROR);
}
}
/*--------------------------------------------------------------------*\
Free allocated memory.
\*--------------------------------------------------------------------*/
error = ProArrayFree((ProArray*)&data);
TEST_CALL_REPORT ("ProArrayFree()",
"TestGtolModify()", error, error != PRO_TK_NO_ERROR);
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestGtolSelType()
Purpose : Menu for select gtol type.
\*====================================================================*/
int TestGtolSelType()
{
int n;
ProError error;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Please select gtol type.");
error = ProUtilMenuIntValueSelect(mnGtolType, &n);
return((error == PRO_TK_NO_ERROR)?(n):error);
}
/*====================================================================*\
Function : TestGtolSelRefItemType()
Purpose : Menu for select gtol type reference type.
\*====================================================================*/
int TestGtolSelRefItemType()
{
int n;
ProError error;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Please choise refernce type.");
error = ProUtilMenuIntValueSelect(mnGtolRefItemType, &n);
return((error == PRO_TK_NO_ERROR)?(n):error);
}
/*====================================================================*\
Function : TestGtolSelPlacementType()
Purpose : Menu for select gtol type placement type.
\*====================================================================*/
int TestGtolSelPlacementType()
{
int n;
ProError error;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Please choise placement type.");
error = ProUtilMenuIntValueSelect(mnGtolPlacementType, &n);
return((error == PRO_TK_NO_ERROR)?(n):error);
}
/*====================================================================*\
Function : TestGtolSelLeaderType()
Purpose : Menu for select gtol type Leader type.
\*====================================================================*/
int TestGtolSelLeaderType()
{
int n;
ProError error;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Please choise leader type.");
error = ProUtilMenuIntValueSelect(mnGtolLeaderType, &n);
return((error == PRO_TK_NO_ERROR)?(n):error);
}
/*====================================================================*\
Function : TestGtolSelMaterialCond()
Purpose : Menu for select material condition.
\*====================================================================*/
int TestGtolSelMaterialCond()
{
int n;
ProError error;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Please choise material condition.");
error = ProUtilMenuIntValueSelect(mnGtolMaterialCond, &n);
return((error == PRO_TK_NO_ERROR)?(n):error);
}
/*====================================================================*\
Function : TestGtolSelReferenceType()
Purpose : Menu for select reference type.
\*====================================================================*/
int TestGtolSelReferenceType()
{
int n;
ProError error;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Please choise reference type.");
error = ProUtilMenuIntValueSelect(mnGtolReferenceType, &n);
return((error == PRO_TK_NO_ERROR)?(n):error);
}
/*====================================================================*\
Function : TestGtolSelProjzone()
Purpose : Menu for select projected zone type.
\*====================================================================*/
int TestGtolSelProjzone()
{
int n;
ProError error;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Please choise projected zone type");
error = ProUtilMenuIntValueSelect(mnGtolProjzone, &n);
return((error == PRO_TK_NO_ERROR)?(n):error);
}
/*====================================================================*\
Function : TestGtolPlacementSet()
Purpose : Set gtol placement.
\*====================================================================*/
ProError TestGtolPlacementSet(ProMdl mdl, ProGtoldata data)
{
ProGtol *gtol = NULL;
ProGtoldataStatus status;
ProGtolPlacementType plc_type;
ProLeaderType ldr_type;
ProPoint3d location;
ProGtolleader *leaders = NULL;
ProSelection *sel;
ProDimension dimension;
ProMouseButton btn;
int i, n_sel, n_leader, n_gtol, n, range[2];
ProBoolean IsComplete = PRO_B_FALSE;
ProError error;
ProGtolRefItemType type;
ProSelection reference;
/*--------------------------------------------------------------------*\
Select gtol placement type.
\*--------------------------------------------------------------------*/
plc_type = (ProGtolPlacementType)TestGtolSelPlacementType();
if(IsMenuDone(plc_type) == PRO_B_FALSE)
return(PRO_TK_BAD_INPUTS);
/*--------------------------------------------------------------------*\
Not applicable if the gtol reference type is PROGTOLRTYPE_DATUM
\*--------------------------------------------------------------------*/
error = ProGtoldataReferenceGet(data, &type, &reference);
TEST_CALL_REPORT ("ProGtoldataReferenceGet()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
if(error != PRO_TK_NO_ERROR)
return(error);
if(type != PROGTOLRTYPE_DATUM)
{
/*--------------------------------------------------------------------*\
Select the dimension to attach to gtol
\*--------------------------------------------------------------------*/
if((plc_type == PROGTOLPTYPE_DIMENSION) ||
(plc_type == PROGTOLPTYPE_DIM_RELATED))
{
error = ProSelect((char*)"dimension",1, NULL, NULL, NULL, NULL, &sel, &n_sel);
TEST_CALL_REPORT ("ProSelect()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
if((error!=PRO_TK_NO_ERROR)||(n_sel<=0))
return(PRO_TK_E_NOT_FOUND);
error = ProSelectionModelitemGet(sel[0],(ProModelitem*)&dimension);
TEST_CALL_REPORT ("ProSelectionModelitemGet()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
}
/*--------------------------------------------------------------------*\
Create ProArray of leader structures. Contains only a single
leader if the type is PROGTOLPTYPE_TANLEADER or PROGTOLPTYPE_NORMLEADER
\*--------------------------------------------------------------------*/
if((plc_type == PROGTOLPTYPE_TANLEADER) ||
(plc_type == PROGTOLPTYPE_NORMLEADER)||
(plc_type == PROGTOLPTYPE_LEADERS))
{
ldr_type = (ProLeaderType)TestGtolSelLeaderType();
if(IsMenuDone(ldr_type) == PRO_B_FALSE)
return(PRO_TK_BAD_INPUTS);
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Please select items for attach");
error = ProSelect((char*)"surface,axis,datum,csys,edge",
(plc_type == PROGTOLPTYPE_LEADERS)?(PRO_VALUE_UNUSED):(1),
NULL, NULL, NULL, NULL, &sel, &n_leader);
TEST_CALL_REPORT ("ProSelect()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
if((error != PRO_TK_NO_ERROR)||(n_leader<=0))
return(PRO_TK_E_NOT_FOUND);
error = ProArrayAlloc(n_leader, sizeof(ProGtolleader),1, (ProArray*)&leaders);
TEST_CALL_REPORT ("ProArrayAlloc()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
if(error != PRO_TK_NO_ERROR)
return(error);
for(i=0; i<n_leader; i++)
{
error = ProGtolleaderAlloc(ldr_type, sel[i], &leaders[i]);
TEST_CALL_REPORT ("ProGtolleaderAlloc()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
}
}
/*--------------------------------------------------------------------*\
Setup location of the gtol label. (for valid placement types)
\*--------------------------------------------------------------------*/
if((plc_type == PROGTOLPTYPE_LEADERS) ||
(plc_type == PROGTOLPTYPE_DIM_RELATED) ||
(plc_type == PROGTOLPTYPE_FREENOTE))
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Please select place location");
error = ProMousePickGet(PRO_LEFT_BUTTON ,&btn ,location);
TEST_CALL_REPORT ("ProMousePickGet()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
if(error != PRO_TK_NO_ERROR)
return(error);
}
/*--------------------------------------------------------------------*\
Select gtol to attach to new gtol.
\*--------------------------------------------------------------------*/
if(plc_type == PROGTOLPTYPE_GTOL)
{
error = TestGtolCollect(mdl, >ol);
if(error!=PRO_TK_NO_ERROR)
return(error);
error = ProArraySizeGet((ProArray)gtol, &n_gtol);
TEST_CALL_REPORT ("ProArraySizeGet()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
if((error!=PRO_TK_NO_ERROR)||(n_gtol<=0))
return(PRO_TK_E_NOT_FOUND);
range[0] = 0; range[1] = n_gtol;
if (ProMessageIntegerRead(range, &n)!=PRO_TK_NO_ERROR)
return(PRO_TK_BAD_INPUTS);
}
/*--------------------------------------------------------------------*\
Setup gtol placement.
\*--------------------------------------------------------------------*/
error = ProGtoldataPlacementSet(data, plc_type, &dimension, leaders,
location, (plc_type == PROGTOLPTYPE_GTOL)?(>ol[n]):(NULL), &status);
TEST_CALL_REPORT ("ProGtoldataPlacementSet()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
IsComplete = ((error == PRO_TK_NO_ERROR)||(PRO_TK_CANT_MODIFY == error))?
(PRO_B_TRUE):(PRO_B_FALSE);
if(plc_type == PROGTOLPTYPE_FREENOTE || plc_type==PROGTOLPTYPE_LEADERS || plc_type==PROGTOLPTYPE_TANLEADER || plc_type==PROGTOLPTYPE_NORMLEADER )
{
ProSelection *planeSels=0;
int numSels=0;
ProVector planeVec = {1.00,1.00,1.00};
ProAnnotationPlane annotPlane;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Please select annotation plane");
error = ProSelect((char*)"datum",1,NULL, NULL, NULL, NULL, &planeSels, &numSels);
TEST_CALL_REPORT ("ProSelect()","TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
if(error != PRO_TK_NO_ERROR)
return error;
error = ProAnnotationplaneCreate(planeSels[0],planeVec,&annotPlane);
TEST_CALL_REPORT ("ProAnnotationplaneCreate()","TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
error = ProGtoldataPlaneSet(data,&annotPlane);
TEST_CALL_REPORT ("ProGtoldataPlaneSet()","TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
}
/*--------------------------------------------------------------------*\
Free memory
\*--------------------------------------------------------------------*/
if((leaders != NULL)&&
((plc_type == PROGTOLPTYPE_TANLEADER) ||
(plc_type == PROGTOLPTYPE_NORMLEADER)||
(plc_type == PROGTOLPTYPE_LEADERS)))
{
for(i=0; i<n_leader; i++)
{
error = ProGtolleaderFree(&leaders[i]);
TEST_CALL_REPORT ("ProGtolleaderFree()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
}
error = ProArrayFree((ProArray*)&leaders);
TEST_CALL_REPORT ("ProArrayFree()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
}
if((plc_type == PROGTOLPTYPE_GTOL)||(gtol!=NULL))
{
error = ProArrayFree((ProArray*)>ol);
TEST_CALL_REPORT ("ProArrayFree()",
"TestGtolPlacementSet()", error, error != PRO_TK_NO_ERROR);
}
} else return(PRO_TK_NO_ERROR);
return((IsComplete == PRO_B_TRUE)?PRO_TK_NO_ERROR:PRO_TK_GENERAL_ERROR);
}
/*====================================================================*\
Function : TestGtoldatumrefSet()
Purpose : Setup datum references for specified gtol.
\*====================================================================*/
ProError TestGtoldatumrefSet(ProGtoldata data)
{
ProError error;
ProSelection *sel_bas, *sel_com;
ProGtolMaterialCond basic_matcond, compound_matcond;
ProGtoldatumref datumref[3];
int i, n1, n2;
ProBoolean IsComplete = PRO_B_FALSE;
ProGtoldataStatus status;
ProCharLine cline;
/*--------------------------------------------------------------------*\
Setup all datum references.
\*--------------------------------------------------------------------*/
for(i=0; i<3; i++)
{
datumref[i] = NULL;
ProTKSprintf(cline,(char*)"Setup %s datum reference(y/n)", strDatumRef[i]);
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", cline);
if (ProUtilYesnoGet((char*)"Yes") != 1)
continue;
/*--------------------------------------------------------------------*\
Setup basic datum
\*--------------------------------------------------------------------*/
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Choise parameters for basic datum.");
basic_matcond = (ProGtolMaterialCond)TestGtolSelMaterialCond();
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select basic datum.");
error = ProSelect((char*)"datum", 1,NULL, NULL, NULL, NULL, &sel_bas, &n1);
TEST_CALL_REPORT ("ProSelect()",
"TestGtoldatumrefSet()", error, error != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
Setup compaund datum.
\*--------------------------------------------------------------------*/
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Choise parameters for compaund datum.");
compound_matcond = (ProGtolMaterialCond)TestGtolSelMaterialCond();
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select compaund datum.");
error = ProSelect((char*)"datum", 1,NULL, NULL, NULL, NULL, &sel_com, &n2);
TEST_CALL_REPORT ("ProSelect()",
"TestGtoldatumrefSet()", error, error != PRO_TK_NO_ERROR);
error = ProGtoldatumrefAlloc((n1<=0)?(NULL):(sel_bas[0]), basic_matcond,
(n2<=0)?(NULL):(sel_com[0]), compound_matcond, &datumref[i]);
TEST_CALL_REPORT ("ProGtoldatumrefAlloc()",
"TestGtoldatumrefSet()", error, error != PRO_TK_NO_ERROR);
}
error = ProGtoldataGtoldatumrefSet(data, datumref[0], datumref[1], datumref[2], &status);
TEST_CALL_REPORT ("ProGtoldataGtoldatumrefSet()",
"TestGtoldatumrefSet()", error, error != PRO_TK_NO_ERROR);
IsComplete = ((error == PRO_TK_NO_ERROR)||(PRO_TK_CANT_MODIFY == error))?
(PRO_B_TRUE):(PRO_B_FALSE);
/*--------------------------------------------------------------------*\
Free memory
\*--------------------------------------------------------------------*/
for(i=0; i<3; i++)
{
if(&datumref[i]!=NULL)
{
error = ProGtoldatumrefFree(&datumref[i]);
TEST_CALL_REPORT ("ProGtoldatumrefFree()",
"TestGtoldatumrefSet()", error, error != PRO_TK_NO_ERROR);
}
}
return((IsComplete == PRO_B_TRUE)?(PRO_TK_NO_ERROR):(PRO_TK_GENERAL_ERROR));
}
/*====================================================================*\
Function : TestGtolCompositeSet()
Purpose : Setup gtol composite property.
\*====================================================================*/
ProError TestGtolCompositeSet(ProGtoldata data)
{
ProGtolReferenceType type;
ProError error;
ProBoolean is_composite = PRO_B_FALSE;
double value = 0;
ProGtoldataStatus status;
/*--------------------------------------------------------------------*\
Prompt user for setup gtol composite property.
\*--------------------------------------------------------------------*/
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Composite tolerance ?(y/n):");
if (ProUtilYesnoGet((char*)"Yes") == 1)
{
is_composite = PRO_B_TRUE;
type = (ProGtolReferenceType)TestGtolSelReferenceType();
if (IsMenuDone(type) == PRO_B_FALSE)
return(PRO_TK_BAD_INPUTS);
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Input composite tolerance value:");
ProMessageDoubleRead(NULL, &value);
}
error = ProGtoldataCompositeSet(data, is_composite, value, type, &status);
TEST_CALL_REPORT ("ProGtoldataCompositeSet()",
"TestGtolReferenceTypeSet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtoldataValueSet()
Purpose : Setup gtol value.
\*====================================================================*/
ProError TestGtoldataValueSet(ProGtoldata data)
{
ProBoolean overall_tolerance = PRO_B_TRUE;
double value = 0;
ProName wname;
ProGtoldataStatus status;
ProError error;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Input overall tolerance value:");
ProMessageDoubleRead(NULL, &value);
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Input overall tolerance name:");
ProMessageStringRead(PRO_NAME_SIZE-1, wname);
/*--------------------------------------------------------------------*\
Call Pro/Toolkit function for setup gtol value.
\*--------------------------------------------------------------------*/
error = ProGtoldataValueSet(data, PRO_B_TRUE, value, wname, &status);
TEST_CALL_REPORT ("ProGtoldataValueSet()",
"TestGtoldataValueSet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtolMatCondSet()
Purpose : Setup gtol material condition.
\*====================================================================*/
ProError TestGtolMatCondSet(ProGtoldata data)
{
ProGtolMaterialCond matcond;
ProGtoldataStatus status;
ProError error;
matcond = (ProGtolMaterialCond)TestGtolSelMaterialCond();
if (IsMenuDone(matcond) == PRO_B_FALSE)
return(PRO_TK_BAD_INPUTS);
error = ProGtoldataMatCondSet(data, matcond, &status);
TEST_CALL_REPORT ("ProGtoldataMatCondSet()",
"TestGtolMatCondSet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtoldataPerUnitSet()
Purpose : Set the per unit tolerance of a gtol.
\*====================================================================*/
ProError TestGtoldataPerUnitSet(ProGtoldata data)
{
ProError error;
ProBoolean perunit_tolerance = PRO_B_FALSE;
double value_per_unit = 0, unit_area_or_length = 0;
ProGtoldataStatus status;
perunit_tolerance = PRO_B_TRUE;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Input per unit tolerance value:");
ProMessageDoubleRead(NULL, &value_per_unit);
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Input unit area, or length:");
ProMessageDoubleRead(NULL, &unit_area_or_length);
error = ProGtoldataPerUnitSet(data, perunit_tolerance, value_per_unit,
unit_area_or_length, &status);
TEST_CALL_REPORT ("ProGtoldataPerUnitSet()",
"TestGtoldataPerUnitSet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtoldataStatTolSet()
Purpose : Set whether a gtol shows the statistical tolerance symbol.
\*====================================================================*/
ProError TestGtoldataStatTolSet(ProGtoldata data)
{
ProBoolean statistic_tolerance;
ProGtoldataStatus status;
ProError error;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Shows the statistical tolerance symbol ? (y/n):");
statistic_tolerance = (ProUtilYesnoGet((char*)"Yes") == 1)?(PRO_B_TRUE):(PRO_B_FALSE);
error = ProGtoldataStatTolSet(data, statistic_tolerance, &status);
TEST_CALL_REPORT ("ProGtoldataStatTolSet()",
"TestGtoldataStatTolSet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtoldataDiameterSet()
Purpose : Set whether a gtol shows the diameter tolerance symbol.
\*====================================================================*/
ProError TestGtoldataDiameterSet(ProGtoldata data)
{
ProError error;
ProBoolean diameter;
ProGtoldataStatus status;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Shows the diameter tolerance symbol ? (y/n):");
diameter = (ProUtilYesnoGet((char*)"Yes") == 1)?(PRO_B_TRUE):(PRO_B_FALSE);
error = ProGtoldataDiameterSet(data, diameter, &status);
TEST_CALL_REPORT ("ProGtoldataDiameterSet()",
"TestGtoldataDiameterSet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtoldataFreeStateSet()
Purpose : Set whether a gtol shows the free state symbol.
\*====================================================================*/
ProError TestGtoldataFreeStateSet(ProGtoldata data)
{
ProError error;
ProBoolean free_state;
ProGtoldataStatus status;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Shows the free state symbol ? (y/n):");
free_state = (ProUtilYesnoGet((char*)"Yes") == 1)?(PRO_B_TRUE):(PRO_B_FALSE);
error = ProGtoldataFreeStateSet(data, free_state, &status);
TEST_CALL_REPORT ("ProGtoldataFreeStateSet()",
"TestGtoldataFreeStateSet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtoldataAllAroundSet()
Purpose : Sets whether a gtol shows the all around symbol.
\*====================================================================*/
ProError TestGtoldataAllAroundSet(ProGtoldata data)
{
ProError error;
ProBoolean all_around;
ProGtoldataStatus status;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Shows the all around symbol ? (y/n):");
all_around = (ProUtilYesnoGet((char*)"Yes") == 1)?(PRO_B_TRUE):(PRO_B_FALSE);
error = ProGtoldataAllAroundSet(data, all_around, &status);
TEST_CALL_REPORT ("ProGtoldataAllAroundSet()",
"TestGtoldataAllAroundSet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtoldataTangentPlaneSet()
Purpose : Sets whether a gtol shows the tangent plane symbol.
\*====================================================================*/
ProError TestGtoldataTangentPlaneSet(ProGtoldata data)
{
ProError error;
ProBoolean tangent_plane;
ProGtoldataStatus status;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Shows the tangent plane symbol ? (y/n):");
tangent_plane = (ProUtilYesnoGet((char*)"Yes") == 1)?(PRO_B_TRUE):(PRO_B_FALSE);
error = ProGtoldataTangentPlaneSet(data, tangent_plane, &status);
TEST_CALL_REPORT ("ProGtoldataTangentPlaneSet()",
"TestGtoldataTangentPlaneSet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtoldataProjZoneSet()
Purpose : Sets the projected tolerance zone for a gtol.
\*====================================================================*/
ProError TestGtoldataProjZoneSet(ProGtoldata data)
{
ProError error;
ProGtoldataStatus status;
ProGtolProjzone projected_zone;
ProBoolean specify_height = PRO_B_FALSE;
double zone_height;
ProGtolType type;
error = ProGtoldataTypeGet(data, &type);
TEST_CALL_REPORT ("ProGtoldataTypeGet()",
"TestGtoldataProjZoneSet()", error, error != PRO_TK_NO_ERROR);
if(error != PRO_TK_NO_ERROR)
return(error);
if (!((type == PROGTOLTYPE_ANGULAR)||
(type == PROGTOLTYPE_PERPENDICULAR) ||
(type == PROGTOLTYPE_PARALLEL) ||
(type == PROGTOLTYPE_POSITION)))
return(PRO_TK_NO_ERROR);
projected_zone = (ProGtolProjzone)TestGtolSelProjzone();
if(IsMenuDone(projected_zone) == PRO_B_FALSE)
return(PRO_TK_BAD_INPUTS);
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Height of the zone is specified ? (y/n):");
if(ProUtilYesnoGet((char*)"Yes") == 1)
{
specify_height = PRO_B_TRUE;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Input per unit tolerance value:");
ProMessageDoubleRead(NULL, &zone_height);
};
error = ProGtoldataProjZoneSet(data, projected_zone, specify_height,
zone_height, &status);
TEST_CALL_REPORT ("ProGtoldataProjZoneSet()",
"TestGtoldataProjZoneSet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtoldataProfBoundarySet()
Purpose : Sets the profile boundary for a gtol.
\*====================================================================*/
ProError TestGtoldataProfBoundarySet(ProGtoldata data)
{
ProError error;
ProGtolProfBoundIndex profile_idx = PROGTOLPROF_BILATERAL_IDX;
ProBoolean outside = PRO_B_FALSE;
ProGtoldataStatus status;
ProGtolType type;
error = ProGtoldataTypeGet(data, &type);
TEST_CALL_REPORT ("ProGtoldataTypeGet()",
"TestGtoldataProfBoundarySet()", error, error != PRO_TK_NO_ERROR);
if(error != PRO_TK_NO_ERROR)
return(error);
if (!((type == PROGTOLTYPE_LINE)||
(type == PROGTOLTYPE_SURFACE)))
return(PRO_TK_NO_ERROR);
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Profile boundary is unilateral ? (y/n):");
profile_idx = (ProUtilYesnoGet((char*)"Yes") == 1) ? (PROGTOLPROF_UNILATERAL_IDX) :
(PROGTOLPROF_BILATERAL_IDX);
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"tolerance refers to the outside of the profile ? (y/n):");
outside = (ProUtilYesnoGet((char*)"Yes") == 1)?(PRO_B_TRUE):(PRO_B_FALSE);
error = ProGtoldataProfBoundarySet(data, profile_idx, outside, &status);
TEST_CALL_REPORT ("ProGtoldataProfBoundarySet()",
"TestGtoldataProfBoundarySet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtoldataReferenceSet()
Purpose : Sets the item which the gtol refers to.
\*====================================================================*/
ProError TestGtoldataReferenceSet(ProGtoldata data)
{
int n_sel;
ProGtoldataStatus status;
ProGtolRefItemType ref_item_type;
ProSelection *sel;
ProError error;
ProCharLine cline;
ProGtolType type;
ProModelitem mdl_item;
error = ProGtoldataTypeGet(data, &type);
TEST_CALL_REPORT ("ProGtoldataTypeGet()",
"TestGtoldataReferenceSet()", error, error != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
Select reference item.
\*--------------------------------------------------------------------*/
ProUtilMsgPrint( (char*)"gen", (char*)"TEST %0s", (char*)"Please select reference item" );
ProTKSprintf(cline,(char*)"%s",TestGtolSymSelParam(type));
error = ProSelect(cline, 1, NULL, NULL, NULL, NULL, &sel, &n_sel);
TEST_CALL_REPORT ("ProSelect()",
"TestGtoldataReferenceSet()", error, error != PRO_TK_NO_ERROR);
ProTKPrintf( (char*)"--------------------------_> %d\n", error );
ProTKPrintf( (char*)"--------------------------_> %s\n", cline );
if((error!=PRO_TK_NO_ERROR)||(n_sel<0))
return(PRO_TK_BAD_INPUTS);
error = ProSelectionModelitemGet(sel[0], &mdl_item);
TEST_CALL_REPORT ("ProSelectionModelitemGet()",
"TestGtoldataReferenceSet()", error, error != PRO_TK_NO_ERROR);
switch (mdl_item.type)
{
case PRO_EDGE :
ref_item_type = PROGTOLRTYPE_EDGE;
break;
case PRO_AXIS :
ref_item_type = PROGTOLRTYPE_AXIS;
break;
case PRO_SURFACE :
ref_item_type = PROGTOLRTYPE_SURF;
break;
case PRO_FEATURE :
ref_item_type = PROGTOLRTYPE_FEAT;
break;
case PRO_DATUM_PLANE :
ref_item_type = PROGTOLRTYPE_DATUM;
break;
default:
return(PRO_TK_BAD_INPUTS);
}
error = ProGtoldataReferenceSet(data, ref_item_type, sel[0], &status);
TEST_CALL_REPORT ("ProGtoldataReferenceSet()",
"TestGtoldataReferenceSet()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_CANT_MODIFY)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't modify this parameter.");
return(PRO_TK_NO_ERROR);
}
return(error);
}
/*====================================================================*\
Function : TestGtolCreate()
Purpose : Create new gtol in the specified model.
\*====================================================================*/
ProError TestGtolCreate(ProMdl mdl)
{
ProGtoldata data;
ProGtol gtol;
ProGtolType type;
ProGtoldataStatus status;
ProBoolean IsComplete=PRO_B_FALSE, is_overall, is_PerUnit;
ProError error;
/*--------------------------------------------------------------------*\
Alloc memory for gtol data.
\*--------------------------------------------------------------------*/
error = ProGtoldataAlloc(mdl, &data);
TEST_CALL_REPORT ("ProGtoldataAlloc()",
"TestGtolCreate()", error, error != PRO_TK_NO_ERROR);
if(error!=PRO_TK_NO_ERROR)
return(error);
while(1==1)
{
/*--------------------------------------------------------------------*\
Choice gtol type.
\*--------------------------------------------------------------------*/
type = (ProGtolType)TestGtolSelType();
if(type<0)
break;
error = ProGtoldataTypeSet(data, type, &status);
TEST_CALL_REPORT ("ProGtoldataTypeSet()",
"TestGtolCreate()", error, error != PRO_TK_NO_ERROR);
if(error!=PRO_TK_NO_ERROR)
break;
/*--------------------------------------------------------------------*\
Sets the model that will contain the gtol.
\*--------------------------------------------------------------------*/
error = ProGtoldataModelSet(data, mdl, &status);
TEST_CALL_REPORT ("ProGtoldataModelSet()",
"TestGtolCreate()", error, error != PRO_TK_NO_ERROR);
if(error!=PRO_TK_NO_ERROR)
break;
/*--------------------------------------------------------------------*\
Sets references.
\*--------------------------------------------------------------------*/
error = TestGtoldataReferenceSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
/*--------------------------------------------------------------------*\
Sets gtol placement.
\*--------------------------------------------------------------------*/
error = TestGtolPlacementSet(mdl, data);
if(error!=PRO_TK_NO_ERROR)
break;
/*--------------------------------------------------------------------*\
Sets gtol datum references.
\*--------------------------------------------------------------------*/
error = TestGtoldatumrefSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
/*--------------------------------------------------------------------*\
Sets gtol value.
\*--------------------------------------------------------------------*/
is_overall = (TestGtolSymIsEnable(type, TestGtS_Unit) == PRO_B_TRUE)?
(PRO_B_FALSE):(PRO_B_TRUE);
if(is_overall == PRO_B_FALSE)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Overall tolerance ?(y/n):");
is_overall = (ProUtilYesnoGet((char*)"Yes") == 1)?(PRO_B_TRUE):(PRO_B_FALSE);
}
if (is_overall == PRO_B_TRUE)
{
error = TestGtoldataValueSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
}
/*--------------------------------------------------------------------*\
Set the per unit tolerance of a gtol.
\*--------------------------------------------------------------------*/
if(TestGtolSymIsEnable(type, TestGtS_Unit) == PRO_B_TRUE)
{
is_PerUnit = (is_overall == PRO_B_FALSE)?(PRO_B_TRUE):(PRO_B_FALSE);
if(is_PerUnit == PRO_B_FALSE)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Per unit tolerance? (y/n):");
is_PerUnit = (ProUtilYesnoGet((char*)"Yes") == 1)?(PRO_B_TRUE):(PRO_B_FALSE);
}
if (is_PerUnit == PRO_B_TRUE)
{
error = TestGtoldataPerUnitSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
}
}
/*--------------------------------------------------------------------*\
Sets gtol composite property.
\*--------------------------------------------------------------------*/
error = TestGtolCompositeSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
#if 0
/*--------------------------------------------------------------------*\
Set the material condition of a gtol.
\*--------------------------------------------------------------------*/
error = TestGtolMatCondSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
#endif
/*--------------------------------------------------------------------*\
Set whether a gtol shows the statistical tolerance symbol.
\*--------------------------------------------------------------------*/
if(TestGtolSymIsEnable(type, TestGtS_Stat) == PRO_B_TRUE)
{
error = TestGtoldataStatTolSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
}
/*--------------------------------------------------------------------*\
Set whether a gtol shows the diameter tolerance symbol.
\*--------------------------------------------------------------------*/
if (TestGtolSymIsEnable(type, TestGtS_Diam) == PRO_B_TRUE)
{
error = TestGtoldataDiameterSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
}
/*--------------------------------------------------------------------*\
Set whether a gtol shows the free state symbol.
\*--------------------------------------------------------------------*/
if (TestGtolSymIsEnable(type, TestGtS_Free) == PRO_B_TRUE)
{
error = TestGtoldataFreeStateSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
}
/*--------------------------------------------------------------------*\
Sets whether a gtol shows the all around symbol.
\*--------------------------------------------------------------------*/
if (TestGtolSymIsEnable(type, TestGtS_All) == PRO_B_TRUE)
{
error = TestGtoldataAllAroundSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
}
/*--------------------------------------------------------------------*\
Sets whether a gtol shows the tangent plane symbol.
\*--------------------------------------------------------------------*/
if (TestGtolSymIsEnable(type, TestGtS_Tan) == PRO_B_TRUE)
{
error = TestGtoldataTangentPlaneSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
}
/*--------------------------------------------------------------------*\
Sets the projected tolerance zone for a gtol.
\*--------------------------------------------------------------------*/
error = TestGtoldataProjZoneSet(data);
if(error!=PRO_TK_NO_ERROR)
break;
/*--------------------------------------------------------------------*\
Sets the profile boundary for a gtol.
\*--------------------------------------------------------------------*/
error = TestGtoldataProfBoundarySet(data);
if(error!=PRO_TK_NO_ERROR)
break;
/*--------------------------------------------------------------------*\
Create new gtol.
\*--------------------------------------------------------------------*/
error = ProGtolCreate(data, >ol);
TEST_CALL_REPORT ("ProGtolCreate()",
"TestGtolCreate()", error, error != PRO_TK_NO_ERROR);
if(error == PRO_TK_NO_ERROR)
IsComplete=PRO_B_TRUE;
break;
}
if(IsComplete == PRO_B_TRUE)
{
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Gtol normal created");
error = ProAnnotationShow((ProAnnotation*)>ol,NULL,NULL);
TEST_CALL_REPORT ("ProAnnotationShow()","TestGtolCreate()", error, error != PRO_TK_NO_ERROR);
}
else
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Can't create gtol.");
/*--------------------------------------------------------------------*\
Free memory.
\*--------------------------------------------------------------------*/
error = ProGtoldataFree(&data);
TEST_CALL_REPORT ("ProGtoldataFree()",
"TestGtolCreate()", error, error != PRO_TK_NO_ERROR);
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestGtolRefSet()
Purpose : Sets a datum plane or axis to be a gtol reference.
\*====================================================================*/
ProError TestGtolRefSet(ProMdl mdl)
{
ProError error;
ProGeomitem geomitem;
ProSelection *sel;
int n_sel;
ProBoolean is_in_dim;
ProDimension in_dim;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select axis or datum");
/*--------------------------------------------------------------------*\
Select datum or axis.
\*--------------------------------------------------------------------*/
error = ProSelect((char*)"datum,axis", 1,NULL, NULL, NULL, NULL, &sel, &n_sel);
TEST_CALL_REPORT ("ProSelect()",
"TestGtolRefSet()", error, error != PRO_TK_NO_ERROR);
if((error!=PRO_TK_NO_ERROR)||(n_sel<0))
return(PRO_TK_E_NOT_FOUND);
error = ProSelectionModelitemGet(sel[0],(ProModelitem*)&geomitem);
TEST_CALL_REPORT ("ProSelectionModelitemGet()",
"TestGtolRefSet()", error, error != PRO_TK_NO_ERROR);
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"In dim tolerance ?(y/n):");
if(ProUtilYesnoGet((char*)"Yes") == 1)
{
/*--------------------------------------------------------------------*\
if "In dim tolerance" then select dimension.
\*--------------------------------------------------------------------*/
is_in_dim = PRO_B_FALSE;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select dimension");
error = ProSelect((char*)"dimension,ref_dim", 1,NULL, NULL, NULL, NULL, &sel, &n_sel);
TEST_CALL_REPORT ("ProSelect()",
"TestGtolRefSet()", error, error != PRO_TK_NO_ERROR);
if((error!=PRO_TK_NO_ERROR)||(n_sel<0))
return(PRO_TK_E_NOT_FOUND);
error = ProSelectionModelitemGet(sel[0],(ProModelitem*)&in_dim);
TEST_CALL_REPORT ("ProSelectionModelitemGet()",
"TestGtolRefSet()", error, error != PRO_TK_NO_ERROR);
} else
{
is_in_dim = PRO_B_TRUE;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Gtol is FREE.");
}
error = ProGeomitemSetdatumSet(&geomitem, NULL);
TEST_CALL_REPORT ("ProGeomitemSetdatumSet()",
"TestGtolRefSet()", error, error != PRO_TK_NO_ERROR);
return(error);
}
/*====================================================================*\
Function : TestGtolRefClear()
Purpose : Clears a datum plane or axis so it is no
longer a gtol reference.
\*====================================================================*/
ProError TestGtolRefClear(ProMdl mdl)
{
ProError error;
ProGeomitem geomitem;
ProSelection *sel;
int n_sel;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select axis or datum");
/*--------------------------------------------------------------------*\
Select target (datum or axis).
\*--------------------------------------------------------------------*/
error = ProSelect((char*)"datum,axis", 1,NULL, NULL, NULL, NULL, &sel, &n_sel);
TEST_CALL_REPORT ("ProSelect()",
"TestGtolRefClear()", error, error != PRO_TK_NO_ERROR);
if((error!=PRO_TK_NO_ERROR)||(n_sel<0))
return(PRO_TK_E_NOT_FOUND);
error = ProSelectionModelitemGet(sel[0],(ProModelitem*)&geomitem);
TEST_CALL_REPORT ("ProSelectionModelitemGet()",
"TestGtolRefClear()", error, error != PRO_TK_NO_ERROR);
error = ProGeomitemSetdatumClear(&geomitem);
TEST_CALL_REPORT ("ProGeomitemSetdatumClear()",
"TestGtolRefClear()", error, error != PRO_TK_NO_ERROR);
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestGtolRefInfo()
Purpose : Shows whether a datum plane or axis is a gtol reference
\*====================================================================*/
ProError TestGtolRefInfo(ProMdl mdl)
{
ProError error;
ProGeomitem geomitem;
ProSelection *sel;
int n_sel;
ProBoolean ref_datum;
ProCharLine cline;
ProGtolsetdatumValue value;
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", (char*)"Select axis or datum");
/*--------------------------------------------------------------------*\
Select target (datum or axis).
\*--------------------------------------------------------------------*/
error = ProSelect((char*)"datum,axis", 1,NULL, NULL, NULL, NULL, &sel, &n_sel);
TEST_CALL_REPORT ("ProSelect()",
"TestGtolRefInfo()", error, error != PRO_TK_NO_ERROR);
if((error!=PRO_TK_NO_ERROR)||(n_sel<0))
return(PRO_TK_E_NOT_FOUND);
error = ProSelectionModelitemGet(sel[0],(ProModelitem*)&geomitem);
TEST_CALL_REPORT ("ProSelectionModelitemGet()",
"TestGtolRefInfo()", error, error != PRO_TK_NO_ERROR);
error = ProGeomitemSetdatumGet(&geomitem, &ref_datum, &value);
TEST_CALL_REPORT ("ProGeomitemIsGtolref()",
"TestGtolRefInfo()", error, error != PRO_TK_NO_ERROR);
if(error != PRO_TK_NO_ERROR)
return(error);
ProTKSprintf(cline, (char*)"Gtol reference: %s; %s", YesNoStr(ref_datum), (value.type == PRO_GTOLREF_IN_GEOM)?("Set Datum"):("Free"));
ProUtilMsgPrint((char*)"gen", (char*)"TEST %0s", cline);
if(value.type == PRO_GTOLREF_IN_GEOM)
{
error = ProSelectionFree((ProSelection*)&value);
TEST_CALL_REPORT ("ProSelectionFree()",
"TestGtolRefInfo()", error, error!= PRO_TK_NO_ERROR);
}
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestGtolInfo()
Purpose : Create menu for choice mode of get information about gtol.
\*====================================================================*/
ProError TestGtolInfo(ProMdl mdl)
{
int menu_id;
/*=================================================================*\
Setup menu actions
\*=================================================================*/
ProMenuFileRegister((char*)"TkGtolInfo",(char*)"tkgtolinfo.mnu",&menu_id);
ProMenubuttonActionSet((char*)"TkGtolInfo",(char*)"-Selected",
(ProMenubuttonAction)TestGtolInfoSel, mdl, 0);
ProMenubuttonActionSet((char*)"TkGtolInfo",(char*)"-All",
(ProMenubuttonAction)TestGtolInfoAll, mdl, 0);
ProMenubuttonActionSet((char*)"TkGtolInfo",(char*)"TkGtolInfo",
(ProMenubuttonAction)ProMenuDelete, mdl, 0);
/*=================================================================*\
Create new menu
\*=================================================================*/
ProMenuCreate(PROMENUTYPE_MAIN, (char*)"TkGtolInfo", NULL);
ProMenuProcess((char*)"", &menu_id);
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestGtolRefMenu()
Purpose : Create menu for change datupm plane or axis property.
\*====================================================================*/
ProError TestGtolRefMenu(ProMdl mdl)
{
int menu_id;
ProError error;
/*=================================================================*\
Setup menu actions
\*=================================================================*/
ProMenuFileRegister((char*)"TkGtolRef",(char*)"tkgtolref.mnu",&menu_id);
ProMenubuttonActionSet((char*)"TkGtolRef",(char*)"-Set",
(ProMenubuttonAction)TestGtolRefSet, mdl, 0);
ProMenubuttonActionSet((char*)"TkGtolRef",(char*)"-Clear",
(ProMenubuttonAction)TestGtolRefClear, mdl, 0);
ProMenubuttonActionSet((char*)"TkGtolRef",(char*)"-Info",
(ProMenubuttonAction)TestGtolRefInfo, mdl, 0);
ProMenubuttonActionSet((char*)"TkGtolRef",(char*)"TkGtolRef",
(ProMenubuttonAction)ProMenuDelete, mdl, 0);
/*=================================================================*\
Create new menu
\*=================================================================*/
ProMenuCreate(PROMENUTYPE_MAIN, (char*)"TkGtolRef", NULL);
ProMenuProcess((char*)"", &menu_id);
return(PRO_TK_NO_ERROR);
}
/*====================================================================*\
Function : TestGtolMainMenu()
Purpose : Create main menu for gtol test and demo.
\*====================================================================*/
ProError TestGtolMainMenu()
{
int menu_id;
ProMdl mdl;
ProError error;
error = ProMdlCurrentGet(&mdl);
TEST_CALL_REPORT ("ProMdlCurrentGet()",
"TestGtolMainMenu()", error, error != PRO_TK_NO_ERROR);
/*=================================================================*\
Setup menu actions
\*=================================================================*/
ProMenuFileRegister((char*)"TkGtol",(char*)"tkgtol.mnu",&menu_id);
ProMenubuttonActionSet((char*)"TkGtol",(char*)"-Add",
(ProMenubuttonAction)TestGtolCreate, mdl, 0);
ProMenubuttonActionSet((char*)"TkGtol",(char*)"-Modify",
(ProMenubuttonAction)TestGtolModify, mdl, 0);
ProMenubuttonActionSet((char*)"TkGtol",(char*)"-Delete all",
(ProMenubuttonAction)TestGtolDeleteAll, mdl, 0);
ProMenubuttonActionSet((char*)"TkGtol",(char*)"-Show all",
(ProMenubuttonAction)TestMdlGtolShow, mdl, 0);
ProMenubuttonActionSet((char*)"TkGtol",(char*)"-Info",
(ProMenubuttonAction)TestGtolInfo, mdl, 0);
ProMenubuttonActionSet((char*)"TkGtol",(char*)"-Reference",
(ProMenubuttonAction)TestGtolRefMenu, mdl, 0);
ProMenubuttonActionSet((char*)"TkGtol",(char*)"TkGtol",
(ProMenubuttonAction)ProMenuDelete, NULL, 0);
/*=================================================================*\
Create new menu
\*=================================================================*/
ProMenuCreate(PROMENUTYPE_MAIN, (char*)"TkGtol", NULL);
ProMenuProcess((char*)"", &menu_id);
return(PRO_TK_NO_ERROR);
}