/*===========================================================================*\
FILE :   TestGtol.c
PURPOSE: gtol - demo & test

HISTORY:
DATE               AUTHOR      MODIFICATIONS
13-Mar-99 J-01-04   akh         $$1    Created
07-Dec-00 J-01-23   JCN         $$2    Don't print composite information if 
                                         not SURFACE or POSITION 
                                       Gtol.info -> GtolAll.info 
\*===========================================================================*/

/*=================================================================*\
    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 <ProUtil.h>

/*=================================================================*\
    Application includes
\*=================================================================*/
#include "TestError.h"
#include "UtilMessage.h"
#include "UtilMenu.h"
#include "UtilTypes.h"
#include "UtilString.h"
#include "UtilCollect.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"},
    {-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, 
        PRO_TK_NO_ERROR,(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, &gtol);
        
    TEST_CALL_REPORT ("ProGtoldataPlacementGet()",
        "TestGtolPlacementPrn()", error, error != PRO_TK_NO_ERROR);
        
    if(error!=PRO_TK_NO_ERROR)    
        return(error);
        
    ProUtilGtolPlacementTypeStr(plcType, cname);
    
    fprintf(fp, "Placement type: %s\n", cname);   
    if((plcType == PROGTOLPTYPE_DIMENSION)||(plcType == PROGTOLPTYPE_DIM_RELATED))
        fprintf(fp, "Dimension id: %d\n", dimension.id);
        
    if(plcType == PROGTOLPTYPE_GTOL)        
        fprintf(fp, "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);
                fprintf(fp,"Leader type: %s\n", cname);
            };
            error = ProArrayFree((ProArray*)&leaders);
            
        case PROGTOLPTYPE_DIM_RELATED:
        case PROGTOLPTYPE_FREENOTE:
        fprintf(fp, "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.
\*--------------------------------------------------------------------*/
            fprintf(fp, "%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);
                    fprintf(fp, "\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);                    
                    fprintf(fp, "\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(-1);
        
    ProUtilGtolRefItemTypeStr(refType, cname);
    fprintf(fp,"Reference type: %s\n",cname);
    
    error = ProSelectionModelitemGet(ref, &mdl_item);
    TEST_CALL_REPORT ("ProSelectionModelitemGet()",
            "TestGtolReferenceInfo()", error, error != PRO_TK_NO_ERROR);
    
    fprintf(fp,"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, unilateral, outside;               
    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; 
/*--------------------------------------------------------------------*\
    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);
        fprintf(fp,"Type: %s\n", cname );
    }
    
/*--------------------------------------------------------------------*\
    Gets gtol owner
\*--------------------------------------------------------------------*/
    error = ProGtoldataOwnerGet(data, &owner);
    TEST_CALL_REPORT ("ProGtoldataOwnerGet()",
            "TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
    
    error = ProMdlDataGet(owner, &mdl_data);         
    TEST_CALL_REPORT ("ProMdlDataGet()",
            "TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
    
    ProWstringToString(ctype, mdl_data.type);
    ProWstringToString(cname, mdl_data.name)
    ;    
    fprintf(fp, "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 = ProMdlDataGet(mdl, &mdl_data);
    TEST_CALL_REPORT ("ProMdlDataGet()",
            "TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
    
    fprintf(fp, "Model type: %s; name: %s\n",
        ProWstringToString(ctype, mdl_data.type), ProWstringToString(cname, mdl_data.name));

/*--------------------------------------------------------------------*\
    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);
        fprintf(fp, "Gtol is composite: value: %5.5f; ref. type: %s\n",
             val, cname);
    } else {
        fprintf(fp,"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);
     
    fprintf(fp, "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);                
        fprintf(fp, "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)    
        fprintf(fp,"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);
    fprintf(fp,"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)
        fprintf(fp, "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)
        fprintf(fp, "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)
        fprintf(fp, "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);
            fprintf(fp, "Projected zone type: %s\n", cname);
            if(specify_height == PRO_B_TRUE)
                fprintf(fp,"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, &unilateral, &outside);
        TEST_CALL_REPORT ("ProGtoldataProfBoundaryGet()",
            "TestGtolPrintInfo()", error, error != PRO_TK_NO_ERROR);
    
        if(error==PRO_TK_NO_ERROR)
            fprintf(fp, "unilateral: %s; outside: %s\n", 
                YesNoStr(unilateral), YesNoStr(outside));
    }        
                         
    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, 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("gen", "TEST %0s", "Select gtol.");

/*--------------------------------------------------------------------*\
    Select gtol get information about it, and show this information.
\*--------------------------------------------------------------------*/
    error = ProSelect("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*)&gtol);
    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 = fopen(file_name, "w")) == NULL)
    {
	printf("Cannot open output file\n");
	return (-1);
    }

    error = ProGtolDataGet(&gtol, &data);
    TEST_CALL_REPORT ("ProGtolDataGet()",
            "TestGtolInfoSel()", error, error != PRO_TK_NO_ERROR);
    
    fprintf(fp,"\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;

    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 = ProMdlDataGet(model, &mdl_data);            
    TEST_CALL_REPORT ("ProMdlDataGet()",
            "TestGtolInfoAll()", error, error != PRO_TK_NO_ERROR);

/*--------------------------------------------------------------------*\
    Collect all gtols from the current model.
\*--------------------------------------------------------------------*/
    error = TestGtolCollect(model, &gtol);
    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);
        
    error = ProGtoldataAlloc(model, &data);
    TEST_CALL_REPORT ("ProGtoldataAlloc()",
            "TestGtolInfoAll()", error, error != PRO_TK_NO_ERROR);
            
    if((error!=PRO_TK_NO_ERROR)||(data == NULL))
        return(error);

    if ((fp = fopen(file_name, "w")) == NULL)
    {
	printf("Cannot open output file\n");
	return (-1);
    }
    
    fprintf(fp, "Model Name: %s; Type: %s\n", 
        ProWstringToString(cname, mdl_data.name), ProWstringToString(ctype, mdl_data.type));
        
/*--------------------------------------------------------------------*\
    Print information about each gtol.
\*--------------------------------------------------------------------*/
    for(i=0; i<n; i++)
    {
        error = ProGtolDataGet(&gtol[i], &data);
        TEST_CALL_REPORT ("ProGtolDataGet()",
            "TestGtolInfoAll()", error, error != PRO_TK_NO_ERROR);

        fprintf(fp,"%d Geometric Tolerance\n",i);
        TestGtolPrintInfo(fp,data);
        fprintf(fp,"\n");
    }

/*--------------------------------------------------------------------*\
    Close output file, free memory and show information.
\*--------------------------------------------------------------------*/
    fclose(fp);

    error = ProGtoldataFree(&data);
    TEST_CALL_REPORT ("ProGtoldataFree()",
            "TestGtolInfoAll()", error, error != PRO_TK_NO_ERROR);

    error = ProArrayFree((ProArray)&gtol);
    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, &gtol);
    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(&gtol[i]);
        TEST_CALL_REPORT ("ProGtolDelete()",
            "TestGtolDeleteAll()", error, error != PRO_TK_NO_ERROR);
    }

    if(gtol!=NULL)
    {
        error = ProArrayFree((ProArray)&gtol);
        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, &gtol);
    if(error!=PRO_TK_NO_ERROR)
    {
        ProUtilMsgPrint("gen", "TEST %0s", "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("gen", "TEST %0s", "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("gen", "TEST %0s", "Input new gtol value:");
    
    if(ProMessageDoubleRead(NULL, &value)!=PRO_TK_NO_ERROR)
    {
        error = ProArrayFree((ProArray*)&gtol);
        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(&gtol[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("gen", "TEST %0s", "Commit all changes ?");
    ch = ProUtilYesnoGet("Yes");

    for(i=0; i<n; i++)
    {
        if(data[i]!=NULL)
        {
            if(ch == 1)
            {
                error = ProGtolEditCommit(&gtol[i], data[i]);
                TEST_CALL_REPORT ("ProGtolEditCommit()",
                    "TestGtolModify()", error, error != PRO_TK_NO_ERROR);
            } else 
            {
                error = ProGtolEditCancel(&gtol[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("gen", "TEST %0s", "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("gen", "TEST %0s", "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("gen", "TEST %0s", "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("gen", "TEST %0s", "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("gen", "TEST %0s", "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("gen", "TEST %0s", "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("gen", "TEST %0s", "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 = 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("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 = TestGtolSelLeaderType();
            
            if(IsMenuDone(ldr_type) == PRO_B_FALSE)
                return(PRO_TK_BAD_INPUTS);
                
            ProUtilMsgPrint("gen", "TEST %0s", "Please select items for attach");
            
            error = ProSelect("axis,datum,csys,feature,edge,surface", 
              (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("gen", "TEST %0s", "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, &gtol);
            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)?(&gtol[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);                          

/*--------------------------------------------------------------------*\
    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*)&gtol);
            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;
        sprintf(cline,"Setup %s datum reference(y/n)", strDatumRef[i]);
        ProUtilMsgPrint("gen", "TEST %0s", cline);    
        if (ProUtilYesnoGet("Yes") != 1)
            continue; 

/*--------------------------------------------------------------------*\
    Setup basic datum
\*--------------------------------------------------------------------*/
        ProUtilMsgPrint("gen", "TEST %0s", "Choise parameters for basic datum.");
        basic_matcond = TestGtolSelMaterialCond();
        
        ProUtilMsgPrint("gen", "TEST %0s", "Select basic datum.");
        error = ProSelect("datum", 1,NULL, NULL, NULL, NULL, &sel_bas, &n1); 
        TEST_CALL_REPORT ("ProSelect()",
            "TestGtoldatumrefSet()", error, error != PRO_TK_NO_ERROR);    
            
/*--------------------------------------------------------------------*\
    Setup compaund datum.
\*--------------------------------------------------------------------*/
        ProUtilMsgPrint("gen", "TEST %0s", "Choise parameters for compaund datum.");    
        compound_matcond = TestGtolSelMaterialCond();
        
        ProUtilMsgPrint("gen", "TEST %0s", "Select compaund datum.");        
        error = ProSelect("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("gen", "TEST %0s", "Composite tolerance ?(y/n):");    

    if (ProUtilYesnoGet("Yes") == 1)
    {
        is_composite = PRO_B_TRUE;
        type = TestGtolSelReferenceType();
        if (IsMenuDone(type) == PRO_B_FALSE)
            return(PRO_TK_BAD_INPUTS);
        
        ProUtilMsgPrint("gen", "TEST %0s", "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("gen", "TEST %0s", "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("gen", "TEST %0s", "Input overall tolerance value:");    
    ProMessageDoubleRead(NULL, &value);
        
    ProUtilMsgPrint("gen", "TEST %0s", "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("gen", "TEST %0s", "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 = 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("gen", "TEST %0s", "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("gen", "TEST %0s", "Input per unit tolerance value:");    
    ProMessageDoubleRead(NULL, &value_per_unit);
        
    ProUtilMsgPrint("gen", "TEST %0s", "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("gen", "TEST %0s", "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("gen", "TEST %0s", "Shows the statistical tolerance symbol ? (y/n):");    

    statistic_tolerance = (ProUtilYesnoGet("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("gen", "TEST %0s", "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("gen", "TEST %0s", "Shows the diameter tolerance symbol ? (y/n):");    
    diameter = (ProUtilYesnoGet("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("gen", "TEST %0s", "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("gen", "TEST %0s", "Shows the free state symbol ? (y/n):");    
    free_state = (ProUtilYesnoGet("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("gen", "TEST %0s", "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("gen", "TEST %0s", "Shows the all around symbol ? (y/n):");    
    all_around = (ProUtilYesnoGet("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("gen", "TEST %0s", "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("gen", "TEST %0s", "Shows the tangent plane symbol ? (y/n):");    
    tangent_plane = (ProUtilYesnoGet("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("gen", "TEST %0s", "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 = TestGtolSelProjzone();
    
    if(IsMenuDone(projected_zone) == PRO_B_FALSE)
        return(PRO_TK_BAD_INPUTS); 
        
    ProUtilMsgPrint("gen", "TEST %0s", "Height of the zone is specified ? (y/n):");    
    if(ProUtilYesnoGet("Yes") == 1)
    {
        specify_height = PRO_B_TRUE;
        ProUtilMsgPrint("gen", "TEST %0s", "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("gen", "TEST %0s", "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;
    ProBoolean unilateral = PRO_B_FALSE;
    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("gen", "TEST %0s", "Profile boundary is unilateral ? (y/n):");    
    unilateral = (ProUtilYesnoGet("Yes") == 1)?(PRO_B_TRUE):(PRO_B_FALSE);

    ProUtilMsgPrint("gen", "TEST %0s", "tolerance refers to the outside of the profile ? (y/n):");    
    outside = (ProUtilYesnoGet("Yes") == 1)?(PRO_B_TRUE):(PRO_B_FALSE);
    
    error = ProGtoldataProfBoundarySet(data, unilateral, outside, &status);
    TEST_CALL_REPORT ("ProGtoldataProfBoundarySet()",
        "TestGtoldataProfBoundarySet()", error, error != PRO_TK_NO_ERROR);    

    if(error == PRO_TK_CANT_MODIFY)
    {
        ProUtilMsgPrint("gen", "TEST %0s", "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, i;
    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( "gen", "TEST %0s", "Please select reference item" );    
    
    sprintf(cline,"%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); 
               
printf( "--------------------------_> %d\n", error );
printf( "--------------------------_> %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("gen", "TEST %0s", "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 = 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("gen", "TEST %0s", "Overall tolerance ?(y/n):");    
            is_overall = (ProUtilYesnoGet("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("gen", "TEST %0s", "Per unit tolerance? (y/n):");    
                is_PerUnit = (ProUtilYesnoGet("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, &gtol);
        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("gen", "TEST %0s", "Gtol normal created");    
    else
        ProUtilMsgPrint("gen", "TEST %0s", "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("gen", "TEST %0s", "Select axis or datum");    

/*--------------------------------------------------------------------*\
    Select datum or axis.
\*--------------------------------------------------------------------*/
    error = ProSelect("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("gen", "TEST %0s", "In dim tolerance ?(y/n):");    
    
    if(ProUtilYesnoGet("Yes") == 1)
    { 
/*--------------------------------------------------------------------*\
    if "In dim tolerance" then select dimension.
\*--------------------------------------------------------------------*/
        is_in_dim = PRO_B_FALSE;
        ProUtilMsgPrint("gen", "TEST %0s", "Select dimension");    
    
        error = ProSelect("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("gen", "TEST %0s", "Gtol is FREE.");    
    }            
    
    error = ProGeomitemGtolrefSet(&geomitem,(is_in_dim == PRO_B_TRUE)?(&in_dim):(NULL));
    TEST_CALL_REPORT ("ProGeomitemGtolrefSet()",
        "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("gen", "TEST %0s", "Select axis or datum");    

/*--------------------------------------------------------------------*\
    Select target (datum or axis).
\*--------------------------------------------------------------------*/
    error = ProSelect("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 = ProGeomitemGtolrefClear(&geomitem);
    TEST_CALL_REPORT ("ProGeomitemGtolrefClear()",
        "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, is_in_dim;
    ProCharLine cline; 
    ProDimension in_dim; 

    ProUtilMsgPrint("gen", "TEST %0s", "Select axis or datum");    

/*--------------------------------------------------------------------*\
    Select target (datum or axis).
\*--------------------------------------------------------------------*/
    error = ProSelect("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 = ProGeomitemIsGtolref(&geomitem, &ref_datum, &is_in_dim, &in_dim);
    TEST_CALL_REPORT ("ProGeomitemIsGtolref()",
        "TestGtolRefInfo()", error, error != PRO_TK_NO_ERROR);    
    
    if(error != PRO_TK_NO_ERROR)
        return(error);
            
    sprintf(cline, "Gtol reference: %s; %s", 
        YesNoStr(ref_datum), (is_in_dim == PRO_B_TRUE)?("In dim"):("Free"));
        
    ProUtilMsgPrint("gen", "TEST %0s", cline);    
        
    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("TkGtolInfo","tkgtolinfo.mnu",&menu_id);
    ProMenubuttonActionSet("TkGtolInfo","-Selected",
        (ProMenubuttonAction)TestGtolInfoSel, mdl,  0);

    ProMenubuttonActionSet("TkGtolInfo","-All",
        (ProMenubuttonAction)TestGtolInfoAll, mdl,  0);

    ProMenubuttonActionSet("TkGtolInfo","TkGtolInfo",
        (ProMenubuttonAction)ProMenuDelete, mdl,  0);
        
/*=================================================================*\
    Create new menu
\*=================================================================*/
    ProMenuCreate(PROMENUTYPE_MAIN, "TkGtolInfo", NULL);
    ProMenuProcess("", &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("TkGtolRef","tkgtolref.mnu",&menu_id);
    ProMenubuttonActionSet("TkGtolRef","-Set",
        (ProMenubuttonAction)TestGtolRefSet, mdl,  0);

    ProMenubuttonActionSet("TkGtolRef","-Clear",
        (ProMenubuttonAction)TestGtolRefClear, mdl,  0);

    ProMenubuttonActionSet("TkGtolRef","-Info",
        (ProMenubuttonAction)TestGtolRefInfo, mdl,  0);

    ProMenubuttonActionSet("TkGtolRef","TkGtolRef",
        (ProMenubuttonAction)ProMenuDelete, mdl,  0);
        
/*=================================================================*\
    Create new menu
\*=================================================================*/
    ProMenuCreate(PROMENUTYPE_MAIN, "TkGtolRef", NULL);
    ProMenuProcess("", &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("TkGtol","tkgtol.mnu",&menu_id);
    ProMenubuttonActionSet("TkGtol","-Add",
        (ProMenubuttonAction)TestGtolCreate, mdl,  0);

    ProMenubuttonActionSet("TkGtol","-Modify",
        (ProMenubuttonAction)TestGtolModify, mdl,  0);

    ProMenubuttonActionSet("TkGtol","-Delete all",
        (ProMenubuttonAction)TestGtolDeleteAll, mdl,  0);

    ProMenubuttonActionSet("TkGtol","-Show all",
        (ProMenubuttonAction)TestMdlGtolShow, mdl,  0);

    ProMenubuttonActionSet("TkGtol","-Info",
        (ProMenubuttonAction)TestGtolInfo, mdl,  0);
        
    ProMenubuttonActionSet("TkGtol","-Reference",
        (ProMenubuttonAction)TestGtolRefMenu, mdl,  0);

    ProMenubuttonActionSet("TkGtol","TkGtol",
	(ProMenubuttonAction)ProMenuDelete, NULL,  0);

/*=================================================================*\
    Create new menu
\*=================================================================*/
    ProMenuCreate(PROMENUTYPE_MAIN, "TkGtol", NULL);
    ProMenuProcess("", &menu_id);
    
    return(PRO_TK_NO_ERROR);
}