/*====================================================================*\
FILE    : UtilMfgNew.c
PURPOSE : Utility functions for new mfg tests

HISTORY..
DATE      BUILD    AUTHOR      MODIFICATIONS		
12-Nov-96 H-01-16  mgs         $$1 Created
19-Nov-96 H-01-17  Igor        $$2 Added holes and surfaces mfg functions
19-Nov-96 H-01-17  mgs         $$3 Fixed bug in ProUtilMfgobjAction()
19-Nov-96 H-01-18  amin        $$4 ProMdl =-> ProMdlType
03-Dec-96 H-01-19  mgs         $$5 Fixed error log spelling mistake
20-Jan-97 H-01-24  Igor        $$6 Added some utility fncts
22-Jan-97 H-01-24  Jerry       $$7 Added prototype
27-Jan-97 H-01-25  Igor        $$8 fixed bug
15-Sep-97 H-03-22  Pavel       $$9 Replace Pro/D on Pro/T
06-Oct-97 H-03-25  Pavel       $$10 Fix warning
27-Oct-97 H-03-28  Pavel       $$11 Added NcseqElemHoleset functions calls
03-Nov-97 H-03-29  Pavel       $$12 Add ProSelectionPostSelact
20-Feb-98 H-03-40  Akula       $$13 fixed to correct working with asm mfg
28-Aug-98 I-01-18  Akula       $$14 Added a code to test new mfg funcs
02-Dec-98 I-01-27  agsh        $$15 Correct TEST_CALL_REPORTs
31-May-99 I-03-11  mka         $$16 Remove unused variable.
\*====================================================================*/

/*--------------------------------------------------------------------*\
Pro/Toolkit  includes
\*--------------------------------------------------------------------*/
#include <ProToolkit.h>
#include <ProElement.h>
#include <ProFeature.h>
#include <ProSelection.h>
#include <ProNcseq.h>
#include <ProNcseqElem.h>
#include <ProMenu.h>
#include <ProPecktable.h>

/*--------------------------------------------------------------------*\
Application includes
\*--------------------------------------------------------------------*/
#include "MfgMenu.h"
#include "TestConsts.h"
#include "UtilString.h"
#include "UtilGeom.h"
#include "TestError.h"
#include "UtilTree.h"
#include "TestMfgNew.h"
#include "UtilMfgNew.h"
#include "UtilMenu.h"
#include "UtilMessage.h"

#define BLIND_SURFACE 0
#define BLIND_ENTER   1

#define DRILL_STANDART	0
#define DRILL_DEEP	1
#define DRILL_CSINK	2

typedef struct
{
    int n_ranges;
    struct
    {
        double  low_dia, high_dia;
        int     n_pecks;
        double  peck_depth_ratios[5];
        double  feed_rates[5];
    }ranges[2];
}PecktableData;

/*--------------------------------------------------------------------*\
Function prototypes
\*--------------------------------------------------------------------*/
static ValueType parse_string( const char *s, char *out);


/*====================================================================*\
FUNCTION : ProUtilMfgobjAction
PURPOSE  : List features of specified type and call the supplied
           function for each feature type
\*====================================================================*/
ProError ProUtilMfgobjAction ( 
    MfgMenuChoice *obj_action, 
    int            obj_type,
    int            max_sels,
    MfgActionFunc  func,
    ProAppData     app_data,
    int            int_val)
{
    wchar_t **menu_items, **selected;
    wchar_t   wtitle[PRO_NAME_SIZE], item_name[PRO_NAME_SIZE];
    char      title[] = "TK_MFG_FEATS", obj_name[PRO_NAME_SIZE];
    int       i,j, num_selected, num_objs;
    ProError status = PRO_TK_NO_ERROR;
    ProModelitem   *mdl_item = NULL;
    ProTool        *tool_item = NULL;
     
/*--------------------------------------------------------------------*\
    Initial input checking
\*--------------------------------------------------------------------*/
    if (obj_action == NULL || obj_action->mfgobj_list == NULL || 
					func == (MfgActionFunc) NULL )
	status = PRO_TK_BAD_INPUTS;
    
    if (status == PRO_TK_NO_ERROR)
    {
	switch ( obj_type )
	{
	    case MFGOBJ_WKCELL:
	        num_objs = obj_action->mfgobj_list->n_wcell;
		mdl_item = obj_action->mfgobj_list->wcell;
		break;
	    case MFGOBJ_OPER:
	        num_objs = obj_action->mfgobj_list->n_oper;
		mdl_item = obj_action->mfgobj_list->oper;
		break;
	    case MFGOBJ_NC_SEQ:
	        num_objs = obj_action->mfgobj_list->n_nc_seq;
		mdl_item = obj_action->mfgobj_list->nc_seq;
		break;
	    case MFGOBJ_FIXTURE:
	        num_objs = obj_action->mfgobj_list->n_fixture;
		mdl_item = obj_action->mfgobj_list->fixture;
		break;
	    case MFGOBJ_TOOL:
	        num_objs = obj_action->mfgobj_list->n_tool;
		tool_item = obj_action->mfgobj_list->tool;
		break;
	    default :
		status = PRO_TK_BAD_INPUTS;
	}
    }

    if (status != PRO_TK_NO_ERROR)
	return status;

    fprintf(stderr, " Number of objects = %d \n", num_objs );
    fprintf(stderr, " Modelitem ptr     = %x \n", mdl_item );


/*--------------------------------------------------------------------*\
    Allocate space for strings array ( add one item for empty string )
\*--------------------------------------------------------------------*/
    menu_items = (wchar_t **) calloc ( num_objs + 1, sizeof(wchar_t *));
    
    if ( menu_items == NULL)
	status = PRO_TK_GENERAL_ERROR;

    for ( i = 0; i < num_objs && status == PRO_TK_NO_ERROR ; i++)
    {
	menu_items[i] = (wchar_t*) calloc (PRO_NAME_SIZE,sizeof(wchar_t));
	if ( menu_items[i] == NULL)
	    status = PRO_TK_GENERAL_ERROR;

        if ( status == PRO_TK_NO_ERROR)
	{
	    if (tool_item != NULL)
	    {
		ProUtilWstrcpy( menu_items[i], (wchar_t*) tool_item[i].tool_id); 
	    }
	    else
	    {
		status = ProModelitemNameGet ( &(mdl_item[i]), menu_items[i]);
		TEST_CALL_REPORT("ProModelitemNameGet()",
			         "ProUtilMfgobjAction()",
				  status, status != PRO_TK_NO_ERROR );
	    }
	}
    }

    for (i= 0 ; i < num_objs ; i++)
    {
	ProWstringToString(obj_name, menu_items[i]);
        fprintf(stderr,"Menu item [%d] = %s\n", i, obj_name); 
    }

    if (status == PRO_TK_NO_ERROR)
    {
/*--------------------------------------------------------------------*\
	Add a blank line
\*--------------------------------------------------------------------*/
        menu_items[num_objs] = (wchar_t*) calloc (1, sizeof(wchar_t));
	ProStringToWstring(menu_items[num_objs],"");

/*--------------------------------------------------------------------*\
	Get selections
\*--------------------------------------------------------------------*/
	status = ProMenuStringsSelect(ProStringToWstring(wtitle,title),
		    menu_items, max_sels, NULL, &selected, &num_selected);  
	TEST_CALL_REPORT("ProMenuStringsSelect()", "ProUtilMfgobjAction()",
					status, status != PRO_TK_NO_ERROR );
    }
    
/*--------------------------------------------------------------------*\
    Call func for each of the features selected
\*--------------------------------------------------------------------*/
    if ( status == PRO_TK_NO_ERROR && num_selected > 0 )
    {
	for ( i = 0; status == PRO_TK_NO_ERROR &&  i < num_selected; i++)
	{

	    for ( j = 0; j < num_objs; j++)
	    {
	    
		if (tool_item != NULL)
		{
		    ProUtilWstrcpy( item_name, tool_item[j].tool_id);
		}
		else
		{
		    status = ProModelitemNameGet ( &(mdl_item[j]), item_name);
		    TEST_CALL_REPORT("ProModelitemNameGet()",
					"ProUtilMfgobjAction()",
					status, status != PRO_TK_NO_ERROR );
		}

		if (!ProUtilWstrCmp ( item_name, selected[i] ))
		{
		    if ( tool_item != NULL)
		    {
			status = func((ProAppData) &(tool_item[j]), 
							app_data, int_val);
		    }
		    else
		    {
			status = func((ProAppData) &(mdl_item[j]), 
							app_data, int_val);
		    }
		    break;
		}
	    }
	}
    }
    
    for (i= 0 ; i < num_objs + 1; i++)
    {
	free(menu_items[i]);
    }

    free(menu_items);

    return status;
}

/*====================================================================*\
FUNCTION : ProUtilElementBuild
PURPOSE  : Given a value type and a value return the element
\*====================================================================*/
ProError ProUtilElementBuild (
    ProValueDataType data_type,
    void            *data,
    ProElement      *element)
{
    ProError status = PRO_TK_NO_ERROR;
    ProValue value;
    ProValueData value_data;
    ProSelection *s;
    int *i;
    double *d;
    char *c;
    wchar_t *w;

    value_data.type = data_type;

    switch (data_type)
    {
	case PRO_VALUE_TYPE_INT:
	    i = (int*) data;
            value_data.v.i = *i;
	    break;
	case PRO_VALUE_TYPE_DOUBLE:
	    d = (double*) data;
            value_data.v.d = *d;
	    break;
	case PRO_VALUE_TYPE_STRING:
            value_data.v.s = (char*) calloc (1, sizeof(ProCharName)); 
	    if (value_data.v.s)
	    {
		c = (char*) data;
		strcpy(value_data.v.s, c);
	    }
	    else
		status = PRO_TK_OUT_OF_MEMORY;
	    break;
	case PRO_VALUE_TYPE_WSTRING:
            value_data.v.w = (wchar_t*) calloc (1, sizeof(ProLine)); 
	    if (value_data.v.w)
	    {
		w = (wchar_t*) data;    
		ProUtilWstrcpy(value_data.v.w, w);
	    }
	    else
		status = PRO_TK_OUT_OF_MEMORY;
	    break;
	case PRO_VALUE_TYPE_SELECTION:
	    s = (ProSelection*) data;
	    status = ProSelectionCopy(*s, &(value_data.v.r));
	    TEST_CALL_REPORT("ProSelectionCopy()","ProUtilElementBuild()",
				    status, (status != PRO_TK_NO_ERROR));
	    break;
        default:
	    break;
    }

    if (status == PRO_TK_NO_ERROR)
    {
	status = ProValueAlloc ( &value );
	TEST_CALL_REPORT("ProValueAlloc()", "ProUtilElementBuild()",
			    status, (status != PRO_TK_NO_ERROR));
    }


    if (status == PRO_TK_NO_ERROR)
    {
	status = ProValueDataSet (value, &value_data);
	TEST_CALL_REPORT("ProValueDataSet()", "ProUtilElementBuild()",
					status, (status != PRO_TK_NO_ERROR));
    }

    if ( status == PRO_TK_NO_ERROR )
    {
	status = ProElementValueSet ( *element, value );
	TEST_CALL_REPORT("ProElementValueSet()","ProUtilElementBuild()",
			    status, (status != PRO_TK_NO_ERROR));
    }

    return status;
}

/*====================================================================*\
FUNCTION : ProTestWcParamSetup
PURPOSE  : Set a couple of wc parameters
\*====================================================================*/
ProError ProTestWcParamSetup( ProElement *wc_elem )
{
    ProError status = PRO_TK_NO_ERROR;
    ProElement wc_param, name_elem, value_elem;
    ParamTable wc_params[] = {{"CELL_MAX_SPINDLE", 1800.0 },
                              {"TOOL_CHANGE_TIME", 1.0    },
              	              {"CELL_MAX_FEED",    300.0  }};
    int wc_param_size = sizeof(wc_params)/sizeof(ParamTable), i;

    for (i = 0; i < wc_param_size; i++)
    {
	status = ProElementAlloc(PRO_E_MFG_PARAM, &wc_param);

        if (status == PRO_TK_NO_ERROR)
	    status = ProElementAlloc(PRO_E_MFG_PARAM_NAME, &name_elem);
	
        if (status == PRO_TK_NO_ERROR)
	{
	    status = ProUtilElementBuild(PRO_VALUE_TYPE_STRING, 
	    			wc_params[i].param_name, &name_elem); 
	}

        if (status == PRO_TK_NO_ERROR)
	    status = ProElementAlloc(PRO_E_MFG_PARAMVAL, &value_elem);

        if (status == PRO_TK_NO_ERROR)
	    status = ProUtilElementBuild(PRO_VALUE_TYPE_DOUBLE,
	    			&(wc_params[i].paramval), &value_elem);
	
        if (status == PRO_TK_NO_ERROR)
            status = ProElemtreeElementAdd(wc_param, NULL, name_elem);
	    
        if (status == PRO_TK_NO_ERROR)
            status = ProElemtreeElementAdd(wc_param, NULL, value_elem);
	
        if (status == PRO_TK_NO_ERROR)
	    status = ProElemtreeElementAdd(*wc_elem, NULL, wc_param);
    }

    return status;
}

/*====================================================================*\
Function: ProTestCreateSelection
Purpose : Creates a selection structure used in feature creation
\*====================================================================*/
ProError  ProTestCreateSelection(
    int item_id, 
    ProType item_type, 
    ProSelection *p_selection)
{
    ProError status;
    ProMfg mfg_model;
    ProSolid mfg_solid;
    ProAsmcomppath comp_path;
    ProModelitem wkpiece_item;

    ProType type;
 
    status = PRO_TK_NO_ERROR;
 
    status = ProTestGetModels( &mfg_model, &mfg_solid, &comp_path);
    ProMdlTypeGet(mfg_model, (ProMdlType *) &type);
    printf("Mfg solid type (%d)\n", type);

    status = ProModelitemInit( mfg_solid, item_id, item_type, &wkpiece_item );
    TEST_CALL_REPORT("ProModelitemInit()",
	"ProTestCreateWkcell()", status,
	(status != PRO_TK_NO_ERROR));

    status = ProSelectionAlloc(&comp_path, &wkpiece_item, p_selection);
	
    TEST_CALL_REPORT("ProSelectionAlloc()",
		"ProTestCreateSelection()", status,
		(status != PRO_TK_NO_ERROR));

    return ( status );
}

/*====================================================================*\
FUNCTION   : ProTestGetModels
PURPOSE    : Retrieves structures for mfg_model, solid and component path
PT_KEYWORD : retrieve, model, component path
PT_SEEALSO : ProAsmcompTypeGet, ProMdlCurrentGet
\*====================================================================*/
ProError ProTestGetModels(
    ProMfg *p_mfg_model, 
    ProSolid *p_mfg_solid, 
    ProAsmcomppath *p_comp_path)
{ 
    ProError status;
    ProMdlType mfg_model_type;

    status = ProMdlCurrentGet((ProMdl *)p_mfg_model);
    TEST_CALL_REPORT("ProMdlCurrentGet()",
                "ProTestGetModels()", status,
                (status != PRO_TK_NO_ERROR));

    ProMdlTypeGet(*p_mfg_model, &mfg_model_type);
    if ( mfg_model_type == PRO_MFG )
    {
	if (status == PRO_TK_NO_ERROR )
	{
	    status = ProMfgSolidGet(*p_mfg_model, p_mfg_solid);
            TEST_CALL_REPORT("ProMfgSolidGet()",
                "ProTestGetModels()", status,
                (status != PRO_TK_NO_ERROR));

	    if (status == PRO_TK_NO_ERROR)
	    {
		status= ProMfgFeatureOwnerGet(*p_mfg_model, p_comp_path);
                TEST_CALL_REPORT("ProMfgFeatureOwnerGet()",
               		 "ProTestGetModels()", status,
               		 (status != PRO_TK_NO_ERROR));
	    }
	}
    }    
    else
    {
	status = PRO_TK_BAD_CONTEXT;
    }

  return(status);
}

/*====================================================================*\
FUNCTION : ProTestDepTypeAction
PURPOSE  : Action function for Depth type menu
\*====================================================================*/
int ProTestDepTypeAction(
    void* p_dummy, 
    int action )
{
    ProError status;
    status = ProMenuDeleteWithStatus (action);
    return (status);
}

/*====================================================================*\
FUNCTION : ProTestSelectionPostSelact
PURPOSE  : Selection post selaction
\*====================================================================*/
ProError ProTestSelectionPostSelact(
         Pro3dPnt point,
         ProSelection selection,
         ProAppData app_data)
{
    TEST_CALL_REPORT ("ProSelectionPostSelact()", 
        "ProTestSelectionPostSelact()",
        PRO_TK_NO_ERROR, 0);
    return (PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProUtilNcseqElemMillsurfSet
PURPOSE  : Add milling surface to the element (PRO_E_SURFACES).
\*====================================================================*/
ProError ProUtilNcseqElemMillsurfSet (
    ProElement *surfaces )
{
    ProError err;
	int mill_srf_id;
	ProBoolean  flip;

	static ProUtilMenuButtons set_flip[] = {
	{"TkSetFlip", 0, TEST_CALL_PRO_MENU_DELETE},
	{"Flip", PRO_B_TRUE, 0 },
	{"Natural", PRO_B_FALSE, 0 },
	{"",0,0}
    };

	if (ProUtilIntGet(NULL, NULL, &mill_srf_id) == 0)
	{
		return PRO_TK_MSG_USER_QUIT;
	}

	err = ProUtilMenuIntValueSelect(set_flip, (int *)&flip);
	
	if (err != PRO_TK_NO_ERROR)
	     return (PRO_TK_MSG_USER_QUIT);

	err =  ProNcseqElemMillsurfSet (*surfaces, flip, mill_srf_id);
	TEST_CALL_REPORT("ProNcseqElemMillsurfSet()",
			 "ProUtilNcseqElemMillsurfSet()", err,
                          (err != PRO_TK_NO_ERROR));
	return PRO_TK_NO_ERROR;
}

/*====================================================================*\
FUNCTION : ProUtilNcseqElemVolumeSet
PURPOSE  : Add a volume to the element (PRO_E_SURFACES, PRO_E_VOLUME).
\*====================================================================*/
ProError ProUtilNcseqVolumeSet (
    ProElement *surfaces )
{
    ProError err;
	int volume_id;


	if (ProUtilIntGet(NULL, NULL, &volume_id) == 0)
	{
		return PRO_TK_MSG_USER_QUIT;
	}

	err =  ProNcseqElemVolumeSet (*surfaces, volume_id  );
	TEST_CALL_REPORT("ProNcseqElemVolumeSet()",
			 "ProUtilNcseqVolumeSet()", err,
                          (err != PRO_TK_NO_ERROR));
	return PRO_TK_NO_ERROR;
}

/*====================================================================*\
FUNCTION : ProUtilNcseqElemWindowSet
PURPOSE  : Add a window to the element (PRO_E_MACH_WINDOW).
\*====================================================================*/
ProError ProUtilNcseqWindowSet (
    ProElement *mach_wnd )
{
    ProError err;
	int wind_id;


	if (ProUtilIntGet(NULL, NULL, &wind_id) == 0)
	{
		return PRO_TK_MSG_USER_QUIT;
	}

	err =  ProNcseqElemWindowSet (*mach_wnd, wind_id  );
	TEST_CALL_REPORT("ProNcseqElemWindowSet()",
			 "ProUtilNcseqWindowSet()", err,
                          (err != PRO_TK_NO_ERROR));
	return PRO_TK_NO_ERROR;
}

/*====================================================================*\
FUNCTION : ProUtilNcseqStartEndPntSet
PURPOSE  : Adds start or end pont to the element (PRO_E_START, PRO_E_END).
\*====================================================================*/
ProError ProUtilNcseqStartEndPntSet (
    ProElement *start_end )
{
    ProError err;
    ProMachHead    head;
    ProSelection * point;
    int n_sel;
    ProElemId start_or_end;

/*----------------------------------------------------------------------*\
  select a point
\*----------------------------------------------------------------------*/

   err = ProSelect("point", 1, NULL, NULL, NULL, NULL,
	    &point, &n_sel);
   TEST_CALL_REPORT("ProSelect()", 
	    "ProUtilNcseqStartEndPntSet()", err, err != PRO_TK_NO_ERROR);
   if (err != PRO_TK_NO_ERROR)
	    return (PRO_TK_MSG_USER_QUIT);
/*----------------------------------------------------------------------*\
  select a head
\*----------------------------------------------------------------------*/
   
   
	if (ProUtilIntGet(NULL, NULL, (int*)&head) == 0)
	{
		return PRO_TK_MSG_USER_QUIT;
	}

	err = ProElementIdGet (*start_end, &start_or_end);
	TEST_CALL_REPORT("ProElementIdGet()",
			 "ProUtilNcseqStartEndPntSet()", err,
                          (err != PRO_TK_NO_ERROR));
	if (start_or_end == PRO_E_START)
	{
		err = ProNcseqElemStartPntSet (*start_end,
			head, point[0]);
		TEST_CALL_REPORT("ProNcseqElemStartPntSet()",
			 "ProUtilNcseqStartEndPntSet()", err,
                          (err != PRO_TK_NO_ERROR));
		return PRO_TK_NO_ERROR;
	}

	if (start_or_end == PRO_E_END)
	{
		err = ProNcseqElemEndPntSet (*start_end,
			head, point[0]);
		TEST_CALL_REPORT("ProNcseqElemEndPntSet()",
			 "ProUtilNcseqStartEndPntSet()", err,
                          (err != PRO_TK_NO_ERROR));
		return PRO_TK_NO_ERROR;
	}

		
	return PRO_TK_BAD_INPUTS;
}	

/*====================================================================*\
FUNCTION : ProUtilNcseqElemSurfacesAdd
PURPOSE  : Add surfaces to element
NOTE     : Surfaces must be added using the api function
\*====================================================================*/
ProError ProUtilNcseqElemSurfacesAdd (
    ProElement *surfaces )
{
    ProError      status;
    ProSelection *selection;
    int           num_selected, i, action, menu_id;
    ProModelitem  modelitem;
    
    status = ProSelect("surface", -1, NULL, NULL, NULL, NULL, 
				    &selection, &num_selected);
    TEST_CALL_REPORT("ProSelect()", "ProUtilNcseqElemSurfacesAdd()", 
    				status, status != PRO_TK_NO_ERROR);
	
	if (num_selected == 0 && status == PRO_TK_NO_ERROR)
	{
		 status = ProUtilNcseqElemMillsurfSet(surfaces);
		 if (status == PRO_TK_MSG_USER_QUIT)
			 status = ProUtilNcseqVolumeSet(surfaces);
		 return status;
	}

    for (i=0; i<num_selected; i++)
    {
	status = ProNcseqElemSurfaceAdd(*surfaces, selection[i]);
	TEST_CALL_REPORT("ProNcseqElemSurfaceAdd()",
			 "ProUtilNcseqElemSurfacesAdd()", status,
                          (status != PRO_TK_NO_ERROR));
        
        status = ProSelectionModelitemGet (selection[i], &modelitem);
        TEST_CALL_REPORT( "ProSelectionModelitemGet()", 
            "ProUtilNcseqElemSurfacesAdd()", 
	    status, status != PRO_TK_NO_ERROR );

        status = ProMenuFileRegister( "TkDirect", "tkdepdirect.mnu", &menu_id );
        TEST_CALL_REPORT( "ProMenuFileRegister()", 
            "ProUtilNcseqElemSurfacesAdd()", 
	    status, status != PRO_TK_NO_ERROR );

        /* Define menu buttons */
        ProMenubuttonActionSet( "TkDirect", "Natural",
            (ProMenubuttonAction)ProTestDepTypeAction, NULL, PRO_B_FALSE);
        ProMenubuttonActionSet( "TkDirect", "Flip",
            (ProMenubuttonAction)ProTestDepTypeAction, NULL, PRO_B_TRUE);
        ProMenubuttonActionSet( "TkDirect", "TkDirect", 
            (ProMenubuttonAction)ProMenuDelete, NULL, 0 );
        status = ProMenuCreate( PROMENUTYPE_MAIN, "TkDirect", &menu_id );
        TEST_CALL_REPORT( "ProMenuCreate()", "ProUtilNcseqElemSurfacesAdd()", 
			status, status != PRO_TK_NO_ERROR );
        if( status == PRO_TK_NO_ERROR )
        {
            status = ProMenuProcess( "TkDirect", &action );
            TEST_CALL_REPORT( "ProMenuProcess()", "ProUtilNcseqElemSurfacesAdd()", 
	        status, status != PRO_TK_NO_ERROR );
        }
        status = ProNcseqElemSurfaceflipSet (*surfaces, action);
        TEST_CALL_REPORT("ProNcseqElemSurfaceflipSet()",
			 "ProUtilNcseqElemSurfacesAdd()", status,
                          (status != PRO_TK_NO_ERROR));
    }

    return status;
}


/*====================================================================*\
FUNCTION : ProTestPecktabledataSet
PURPOSE  : Fills ProPecktableData structure
\*====================================================================*/
ProError ProTestPecktabledataSet(ProPecktableData *p_pecktable_data)
{
    int i, j, n_ranges = 0;
    FILE *fp;
    float peck_depth_ratios; 
    float feed_rates;
    int ranges_size[50];
    char cstr[80];
    float low_dia, high_dia;
    
    if ((fp = fopen ("pecktable.pec", "rt")) == NULL)
        return (PRO_TK_GENERAL_ERROR);

    ranges_size[n_ranges] = 0;  
    for (i = 0; fgets (cstr, PRO_PATH_SIZE, fp) != NULL; i++)
    {
         if (cstr[0] == '\0')
             break;
         sscanf (cstr, "%f %f %f %f", &low_dia, &high_dia,
             &peck_depth_ratios, &feed_rates);
         if (low_dia > 0.0)
         {
             ranges_size[n_ranges] = 0;
             n_ranges++;            
         }
         ranges_size[n_ranges-1]++;
    }
    
    fclose (fp);

    p_pecktable_data->n_ranges = n_ranges;
    p_pecktable_data->ranges = (ProPecktableRange*)calloc (
        n_ranges, sizeof (ProPecktableRange));
    
    
    if ((fp = fopen ("pecktable.pec", "rt")) == NULL)
        return (PRO_TK_GENERAL_ERROR);
      
    for (i = 0, j = 0; fgets (cstr, PRO_PATH_SIZE, fp) != NULL; i++)
    {
         sscanf (cstr, "%f %f %f %f", &low_dia, &high_dia,
             &peck_depth_ratios, &feed_rates);
         if (low_dia > 0.0 && high_dia > 0.0)
         {
             p_pecktable_data->ranges[j].n_pecks = ranges_size[j];
             p_pecktable_data->ranges[j].low_dia = low_dia;
             p_pecktable_data->ranges[j].high_dia = high_dia;
             p_pecktable_data->ranges[j].peck_depth_ratios = 
                 (double*)calloc (ranges_size[j], sizeof (double));
             p_pecktable_data->ranges[j].feed_rates = 
                 (double*)calloc (ranges_size[j], sizeof (double));
             j++;
             i = 0;
         }
         p_pecktable_data->ranges[j-1].peck_depth_ratios[i] = 
             peck_depth_ratios;
         p_pecktable_data->ranges[j-1].feed_rates[i] = 
             feed_rates;
    }
    
    fclose (fp);
       
    return (PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProUtilNcseqElemHolesAdd
PURPOSE  : Add holes to element
NOTE     : Holes must be added using the api function
\*====================================================================*/
ProError ProUtilNcseqElemHolesAdd (
    ProElement *holes )
{
    ProError status;
    int      set_nmb, num_selected, i;
    ProSelection *p_selection, *start_sels;
    int menu_id, action, blind_action, drill_action;
    double depth, csink;
    ProMfgType type;
    ProMfg mfg_model;
    ProPecktable peck_table;
    ProPecktableData pecktable_data;
    
        status = ProMdlCurrentGet ((ProMdl*)&mfg_model);
        TEST_CALL_REPORT("ProMdlCurrentGet()",
            "ProTestCreateHoleMkNCseq()", status,
            (status != PRO_TK_NO_ERROR));
    
        status = ProMenuFileRegister( "TkDrillType", "tkdrilltype.mnu", &menu_id );
        TEST_CALL_REPORT( "ProMenuFileRegister()", 
            "ProTestCreateHoleMkNCseq()", 
	    status, status != PRO_TK_NO_ERROR );

        /* Define menu buttons */
        ProMenubuttonActionSet( "TkDrillType", "Standart",
            (ProMenubuttonAction)ProTestDepTypeAction, NULL, DRILL_STANDART);
        ProMenubuttonActionSet( "TkDrillType", "Deep",
            (ProMenubuttonAction)ProTestDepTypeAction, NULL, DRILL_DEEP);
        ProMenubuttonActionSet( "TkDrillType", "Countersink",
            (ProMenubuttonAction)ProTestDepTypeAction, NULL, DRILL_CSINK);
        ProMenubuttonActionSet( "TkDrillType", "TkDrillType", 
            (ProMenubuttonAction)ProMenuDelete, NULL, 0 );
        status = ProMenuCreate( PROMENUTYPE_MAIN, "TkDrillType", &menu_id );
        TEST_CALL_REPORT( "ProMenuCreate()", "ProTestCreateHoleMkNCseq()", 
			status, status != PRO_TK_NO_ERROR );
        if( status == PRO_TK_NO_ERROR )
        {
            status = ProMenuProcess( "TkDrillType", &drill_action );
            TEST_CALL_REPORT( "ProMenuProcess()", "ProTestCreateHoleMkNCseq()", 
	        status, status != PRO_TK_NO_ERROR );
        }
        if (drill_action == DRILL_DEEP)
        {
            if (ProTestPecktabledataSet (&pecktable_data) == PRO_TK_NO_ERROR)
            {
                status = ProPecktableCreate ((ProPecktableData*)
                    &pecktable_data, &peck_table);
                TEST_CALL_REPORT( "ProPecktableCreate()", 
                    "ProTestCreateHoleMkNCseq()", 
                    status, status != PRO_TK_NO_ERROR );
                status = ProMfgPecktableSet (mfg_model, 
                    (ProConstPecktable)peck_table);
                TEST_CALL_REPORT( "ProMfgPecktableSet()", 
                    "ProTestCreateHoleMkNCseq()", 
                    status, status != PRO_TK_NO_ERROR );
                status = ProPecktableFree (peck_table);
                TEST_CALL_REPORT( "ProPecktableFree()", 
                    "ProTestCreateHoleMkNCseq()", 
                    status, status != PRO_TK_NO_ERROR );
            }
        }
  
        status = ProNcseqElemHolesetAdd( *holes, &set_nmb);
        TEST_CALL_REPORT("ProNcseqElemHolesetAdd()",
                             "ProTestCreateHoleMkNCseq()", status,
                             (status != PRO_TK_NO_ERROR));

        status = ProSelect("axis", -1,
                      NULL, NULL, NULL, NULL, &p_selection, &num_selected);
        TEST_CALL_REPORT("ProSelect()", "ProTestCreateHoleMkNCseq()", status,
                        status != PRO_TK_NO_ERROR);
        for (i=0; i<num_selected; i++)
        {
            status = ProNcseqElemHolesetAxisAdd( *holes,
                                      set_nmb, p_selection[i]);
            TEST_CALL_REPORT("ProNcseqElemHolesetAxisAdd()",
                             "ProTestCreateHoleMkNCseq()", status,
                             (status != PRO_TK_NO_ERROR));
        }

	   
	
/*--------------------------------------------------------------------*\
        Set the holeset depth type (can be _BLIND, _THRU_ALL or _AUTO)
\*--------------------------------------------------------------------*/
        status = ProMenuFileRegister( "TkDepType", "tkdeptype.mnu", &menu_id );
        TEST_CALL_REPORT( "ProMenuFileRegister()", 
            "ProTestCreateHoleMkNCseq()", 
	    status, status != PRO_TK_NO_ERROR );

        /* Define menu buttons */
        ProMenubuttonActionSet( "TkDepType", "Blind",
            (ProMenubuttonAction)ProTestDepTypeAction, NULL, PRO_DRILL_BLIND);
        ProMenubuttonActionSet( "TkDepType", "Thru all",
            (ProMenubuttonAction)ProTestDepTypeAction, NULL, PRO_DRILL_THRU_ALL);
        ProMenubuttonActionSet( "TkDepType", "Auto",
            (ProMenubuttonAction)ProTestDepTypeAction, NULL, PRO_DRILL_AUTO);
        ProMenubuttonActionSet( "TkDepType", "TkDepType", 
            (ProMenubuttonAction)ProMenuDelete, NULL, 0 );
        status = ProMenuCreate( PROMENUTYPE_MAIN, "TkDepType", &menu_id );
        TEST_CALL_REPORT( "ProMenuCreate()", "ProTestCreateHoleMkNCseq()", 
			status, status != PRO_TK_NO_ERROR );
        if( status == PRO_TK_NO_ERROR )
        {
            status = ProMenuProcess( "TkDepType", &action );
            TEST_CALL_REPORT( "ProMenuProcess()", "ProTestCreateHoleMkNCseq()", 
	        status, status != PRO_TK_NO_ERROR );
        } 
        else
            action = PRO_DRILL_AUTO;
            
        status = ProNcseqElemHolesetDepthTypeSet( *holes, set_nmb, action);
        TEST_CALL_REPORT("ProNcseqElemHolesetDepthTypeSet()",
                             "ProTestCreateHoleMkNCseq()", status,
                             (status != PRO_TK_NO_ERROR));
        
        if (action == PRO_DRILL_BLIND ||
            drill_action == DRILL_CSINK)
        {
            ProUtilMsgPrint ("gen", "TEST %0s", 
                "Select start surface or datum plane");
            status = ProSelect("surface,datum", 1,
                      NULL, NULL, NULL, NULL, &start_sels, &num_selected);
            TEST_CALL_REPORT("ProSelect()", "ProTestCreateHoleMkNCseq()", 
                status, status != PRO_TK_NO_ERROR);
            if (status != PRO_TK_NO_ERROR || num_selected != 1)
                return (0);
            status = ProNcseqElemHolesetStartSet (*holes, 
                set_nmb, start_sels[0]);
            TEST_CALL_REPORT("ProNcseqElemHolesetStartSet()",
                             "ProTestCreateHoleMkNCseq()", status,
                             (status != PRO_TK_NO_ERROR));
        }
        
        if (action == PRO_DRILL_BLIND)
        {
            status = ProMenuFileRegister( "TkDepBlind", "tkdepblind.mnu", &menu_id );
            TEST_CALL_REPORT( "ProMenuFileRegister()", 
                "ProTestCreateHoleMkNCseq()", 
                status, status != PRO_TK_NO_ERROR );

            /* Define menu buttons */
            ProMenubuttonActionSet( "TkDepBlind", "Surface",
                (ProMenubuttonAction)ProTestDepTypeAction, NULL, 
                BLIND_SURFACE);
            ProMenubuttonActionSet( "TkDepBlind", "Enter",
                (ProMenubuttonAction)ProTestDepTypeAction, NULL, 
                BLIND_ENTER);
            ProMenubuttonActionSet( "TkDepBlind", "TkDepBlind", 
                (ProMenubuttonAction)ProMenuDelete, NULL, 0 );
            status = ProMenuCreate( PROMENUTYPE_MAIN, "TkDepBlind", &menu_id );
            TEST_CALL_REPORT( "ProMenuCreate()", "ProTestCreateHoleMkNCseq()", 
			status, status != PRO_TK_NO_ERROR );
            if( status == PRO_TK_NO_ERROR )
            {
                status = ProMenuProcess( "TkDepBlind", &blind_action );
                TEST_CALL_REPORT( "ProMenuProcess()", 
                    "ProTestCreateHoleMkNCseq()", 
	            status, status != PRO_TK_NO_ERROR );
            }             
            if (blind_action == BLIND_ENTER)
            {
                ProUtilMsgPrint ("gen", "TEST %0s", 
                    "Enter drill depth [0.0]:");
                status = ProMessageDoubleRead (NULL, &depth);
                TEST_CALL_REPORT("ProMessageDoubleRead()",
                             "ProTestCreateHoleMkNCseq()", status,
                             (status != PRO_TK_NO_ERROR));
                if (status != PRO_TK_NO_ERROR)
                   depth = 0.0;
                status = ProNcseqElemHolesetDepthSet (*holes, set_nmb, depth);
                TEST_CALL_REPORT("ProNcseqElemHolesetDepthSet()",
                             "ProTestCreateHoleMkNCseq()", status,
                             (status != PRO_TK_NO_ERROR));
            }
            else
            {
                ProUtilMsgPrint ("gen", "TEST %0s", 
                    "Select end surface or datum plane");
                status = ProSelect("surface,datum", 1,
                    NULL, NULL, NULL, NULL, &start_sels, &num_selected);
                TEST_CALL_REPORT("ProSelect()", "ProTestCreateHoleMkNCseq()", 
                    status, status != PRO_TK_NO_ERROR);
                if (status != PRO_TK_NO_ERROR || num_selected != 1)
                    return (0);
                status = ProNcseqElemHolesetEndSet (*holes, 
                    set_nmb, start_sels[0]);
                TEST_CALL_REPORT("ProNcseqElemHolesetEndSet()",
                             "ProTestCreateHoleMkNCseq()", status,
                             (status != PRO_TK_NO_ERROR));
            }
        }
        else
        {            
            status = ProMfgTypeGet (mfg_model, &type);
            TEST_CALL_REPORT("ProMfgTypeGet()",
                "ProTestCreateHoleMkNCseq()", status,
                (status != PRO_TK_NO_ERROR));
            printf ("Current type %d\n", type);
            printf ("ASSM %d, PART %d", PRO_MFGTYPE_MACH_ASSEM, PRO_MFGTYPE_MACH_PART);
            if (type == PRO_MFGTYPE_MACH_ASSEM)
            {
                ProUtilMsgPrint ("gen", "TEST %0s", 
                    "Select drill parts");
                status = ProSelect("part", -1,
                    NULL, NULL, NULL, NULL, &start_sels, &num_selected);
                TEST_CALL_REPORT("ProSelect()", "ProTestCreateHoleMkNCseq()", 
                    status, status != PRO_TK_NO_ERROR);
                if (status != PRO_TK_NO_ERROR || num_selected != 1)
                    return (0);
                for (i = 0; i < num_selected; i++)
                {
                    status = ProNcseqElemHolesetDrillpartAdd (*holes, set_nmb,
                        start_sels[i]);
                    TEST_CALL_REPORT("ProNcseqElemHolesetDrillpartAdd()", "ProTestCreateHoleMkNCseq()", 
                        status, status != PRO_TK_NO_ERROR);
                }
            }
        }
        
        if (action == PRO_DRILL_BLIND ||
            action == PRO_DRILL_AUTO)
        {
/*--------------------------------------------------------------------*\
            Set the depth type (can be _BY_TIP or _BY_SHOULDER)
\*--------------------------------------------------------------------*/
            status = ProMenuFileRegister( "TkDepBySet", "tkdepbyset.mnu", &menu_id );
            TEST_CALL_REPORT( "ProMenuFileRegister()", 
                "ProTestCreateHoleMkNCseq()", 
                status, status != PRO_TK_NO_ERROR );

            /* Define menu buttons */
            ProMenubuttonActionSet( "TkDepBySet", "By Shoulder",
                (ProMenubuttonAction)ProTestDepTypeAction, NULL, 
                PRO_DRILL_BY_SHOULDER);
            ProMenubuttonActionSet( "TkDepBySet", "By Tip",
                (ProMenubuttonAction)ProTestDepTypeAction, NULL, 
                PRO_DRILL_BY_TIP);
            ProMenubuttonActionSet( "TkDepBySet", "TkDepBySet", 
                (ProMenubuttonAction)ProMenuDelete, NULL, 0 );
            status = ProMenuCreate( PROMENUTYPE_MAIN, "TkDepBySet", &menu_id );
            TEST_CALL_REPORT( "ProMenuCreate()", "ProTestCreateHoleMkNCseq()", 
			status, status != PRO_TK_NO_ERROR );
            if( status == PRO_TK_NO_ERROR )
            {
                status = ProMenuProcess( "TkDepBySet", &action );
                TEST_CALL_REPORT( "ProMenuProcess()", 
                    "ProTestCreateHoleMkNCseq()", 
	            status, status != PRO_TK_NO_ERROR );
            }
            status = ProNcseqElemHolesetDepthBySet( *holes, set_nmb, action);
            TEST_CALL_REPORT("ProNcseqElemHolesetDepthBySet()",
                             "ProTestCreateHoleMkNCseq()", status,
                             (status != PRO_TK_NO_ERROR));
        }
                         
        status = ProMenuFileRegister( "TkDirect", "tkdepdirect.mnu", &menu_id );
        TEST_CALL_REPORT( "ProMenuFileRegister()", 
            "ProTestCreateHoleMkNCseq()", 
	    status, status != PRO_TK_NO_ERROR );

        /* Define menu buttons */
        ProMenubuttonActionSet( "TkDirect", "Natural",
            (ProMenubuttonAction)ProTestDepTypeAction, NULL, PRO_HS_DIR_NATURAL);
        ProMenubuttonActionSet( "TkDirect", "Flip",
            (ProMenubuttonAction)ProTestDepTypeAction, NULL, PRO_HS_DIR_FLIP);
        ProMenubuttonActionSet( "TkDirect", "TkDirect", 
            (ProMenubuttonAction)ProMenuDelete, NULL, 0 );
        status = ProMenuCreate( PROMENUTYPE_MAIN, "TkDirect", &menu_id );
        TEST_CALL_REPORT( "ProMenuCreate()", "ProTestCreateHoleMkNCseq()", 
			status, status != PRO_TK_NO_ERROR );
        if( status == PRO_TK_NO_ERROR )
        {
            status = ProMenuProcess( "TkDirect", &action );
            TEST_CALL_REPORT( "ProMenuProcess()", "ProTestCreateHoleMkNCseq()", 
	        status, status != PRO_TK_NO_ERROR );
        }                     
        status = ProNcseqElemHolesetDirectionSet (*holes, set_nmb, action);
        TEST_CALL_REPORT("ProNcseqElemHolesetDirectionSet()",
                             "ProTestCreateHoleMkNCseq()", status,
                             (status != PRO_TK_NO_ERROR));
        if (drill_action == DRILL_CSINK)
        {
            ProUtilMsgPrint ("gen", "TEST %0s", 
                "Enter countersink diameter [QUIT]:");
            status = ProMessageDoubleRead (NULL, &csink);
            TEST_CALL_REPORT("ProMessageDoubleRead()",
                             "ProTestCreateHoleMkNCseq()", status,
                             (status != PRO_TK_NO_ERROR));
            if (status == PRO_TK_NO_ERROR)
            {
                status = ProNcseqElemHolesetCsinkdiamSet (*holes, set_nmb, csink);
                TEST_CALL_REPORT("ProNcseqElemHolesetCsinkdiamSet()",
                             "ProTestCreateHoleMkNCseq()", status,
                             (status != PRO_TK_NO_ERROR));
            }
        }
        return status;
}


/*====================================================================*\
FUNCTION : ProUtilParamFileRead()
PURPOSE  : Read in a file of parameters output an filled elem structure
\*====================================================================*/
ProError ProUtilParamFileRead(
    char *file_name,
    ParamFileType param_type,
    void *p_elem)
{
    ProParamvalue temp_val;
    ProError status;
    char param_name[PARAM_FIELD_WIDTH];
    char param_value[PARAM_FIELD_WIDTH];
    char name[PARAM_FIELD_WIDTH];
    char value[PARAM_FIELD_WIDTH];
    wchar_t wvalue[PARAM_FIELD_WIDTH];
    FILE *fp;
    int ivalue, line_number = 0;
    double dvalue;
    ValueType type;
    int cont = 1;

/*--------------------------------------------------------------------*\
    Open Manufacturing parameters file
\*--------------------------------------------------------------------*/
    if ( (fp = fopen(file_name,"r") ) == NULL)
        return (PRO_TK_BAD_INPUTS);

/*--------------------------------------------------------------------*\
    Read in parameters line by line
\*--------------------------------------------------------------------*/
    while(cont)
    {
        line_number++;

        if ( (fgets(param_name,  PARAM_FIELD_WIDTH, fp)) == NULL)
        {
            fclose(fp);
            return (PRO_TK_NO_ERROR);
        }
        parse_string(param_name, name);

        fgets(param_value, PARAM_FIELD_WIDTH, fp);
        type = parse_string(param_value, value);

        switch (type)
        {
            case ERROR:
                fprintf(stderr, "Error parsing param file: line %d\n",
                                                           line_number);
                fclose(fp);
                return(PRO_TK_BAD_INPUTS);
            case EMPTY:
                break;
            case STRING:
                ProStringToWstring(wvalue, value);
                status = ProParamvalueSet(&temp_val,&wvalue,PRO_PARAM_STRING);
                TEST_CALL_REPORT("ProParamvalueSet()",
                    "ProUtilParamFileRead()", status,
                        (status != PRO_TK_NO_ERROR));
                break;
            case INT:
                ivalue = atoi(param_value);
                status = ProParamvalueSet(&temp_val,&ivalue,PRO_PARAM_INTEGER);
                TEST_CALL_REPORT("ProParamvalueSet()",
                    "ProUtilParamFileRead()", status,
                        (status != PRO_TK_NO_ERROR));
                break;
            case DOUBLE:
                dvalue = (double) atof(param_value);
                status = ProParamvalueSet(&temp_val,&dvalue,PRO_PARAM_DOUBLE);
                TEST_CALL_REPORT("ProParamvalueSet()",
                    "ProUtilParamFileRead()", status,
                        (status != PRO_TK_NO_ERROR));
                break;
            }

        if ((type != ERROR ) && ( type != EMPTY))
        {
/*--------------------------------------------------------------------*\
            Now add the parameter to the correct element type
\*--------------------------------------------------------------------*/
            switch(param_type)
            {
                case MACHINE:
                    /* Add code to create a value object, set its
                       data and add to the element. */
                    break;

                case TOOL:
                    status =
                        ProToolElemParamAdd((ProToolElem)(p_elem),
                                                           &temp_val, name);
                    TEST_CALL_REPORT("ProToolElemParamAdd()",
                        "ProUtilParamFileRead()", status,
                        (status != PRO_TK_NO_ERROR));
                    break;
            }
        }
    }

    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestToolPathDisplay()
PURPOSE  : query the user for the Nc sequence and display its tool path
\*====================================================================*/
ProError ProTestNcseqToolPathDisplay()
{
    ProMfg mfg_model;
    ProAsmcomppath comp_path;
    ProSolid mfg_solid;
    ProNcseq* p_sel_ncseq;
    ProError status;

    status = ProTestGetModels( &mfg_model, &mfg_solid, &comp_path);

    p_sel_ncseq = ProUtilNcseqChoose( &mfg_solid);

    if (p_sel_ncseq != NULL)
     {
       status = ProNcseqToolpathDisplay(p_sel_ncseq);
       TEST_CALL_REPORT("ProNcseqToolpathDisplay()",
                        "ProTestToolPathDisplay()", status,
                        (status != PRO_TK_NO_ERROR));
     }
    else
       ProUtilMsgPrint("gen", "TEST %0s","No NCsequences available");

    return (0);
}

/*====================================================================*\
FUNCTION : parse_string()
PURPOSE  : return type and removes leading and trailing whitespace
\*====================================================================*/
static ValueType parse_string(
    const char *s,
    char *out)
{
    int is_number = 0;
    ValueType type = ERROR;

    while( *s == ' ') s++;

    if ( *s == '-' && !isalnum(*(s+1)))
    {
        out = '\0';
        return (EMPTY);
    }

    if (isdigit(*s))
        is_number = 1;

    if (isalpha(*s))
        type = STRING;

    for (; isprint(*s) && *s != ' ' && *s != '\n' ; s++,out++)
    {
        if (is_number && *s == '.')
            type = DOUBLE;
        *out = *s;
    }
    *out = '\0';

    if (type == DOUBLE)
        return (DOUBLE);

    if (is_number)
        return (INT);
    else
                return type;
}

ProError ProUtilSectionRetr(ProSection *section);
/*====================================================================*\
FUNCTION : ProTestToolPathDisplay()
PURPOSE  : query the user for the Nc sequence and display its tool path
\*====================================================================*/
ProError ProUtilStockBoundSketchAdd (
    ProElement *stk_bnd_sk_elem )
{
    ProError status;
    ProSection sec;
    ProValueData vd;
    ProValue vl;

    status = ProUtilSectionRetr(&sec);
    if (status != PRO_TK_NO_ERROR)
	return status;
    vd.type = PRO_VALUE_TYPE_POINTER;
    vd.v.p = sec;
    status = ProValueDataSet (vl, &vd);
    TEST_CALL_REPORT("ProValueDataSet()",
                        "ProUtilStockBoundSketchAdd()", status,
                        (status != PRO_TK_NO_ERROR));
    status = ProElementValueSet (*stk_bnd_sk_elem, vl);
    TEST_CALL_REPORT("ProElementValueSet()",
                        "ProUtilStockBoundSketchAdd()", status,
                        (status != PRO_TK_NO_ERROR));
    return status;
}