/*====================================================================*\
FILE    : UgMfgMillSeqCreate.c
PURPOSE : Pro/TOOLKIT User Guide Example

HISTORY..
DATE      BUILD   AUTHOR   MODIFICATIONS
04-dec-97 H-02-02 mgs      $$1  Created
\*====================================================================*/
#include <ProToolkit.h>
#include <ProMfg.h>
#include <ProSolid.h>
#include <ProSelection.h>
#include <ProAsmcomppath.h>
#include <ProElement.h>
#include <ProElemId.h>
#include <ProValue.h>
#include <ProFeature.h>
#include <ProUtil.h>
#include <ProTool.h>

#include <TestError.h>
#include <TestMfgNew.h>
#include <UtilString.h>
#include <UtilTree.h>
#include <UtilVisit.h>
#include <TestConsts.h>

extern ProLine msg_fil17;
#define MSG_FIL ProStringToWstring(msg_fil17,"msg_ugmfg.txt")

typedef struct { 
    ProMfg       model;
    int 	 operation;
    ProBoolean   oper_found;
    int          retract_id;
    ProBoolean   retract_found;
    ProSelection csys;
    ProBoolean   csys_found;
} NcseqEnts ;

/*====================================================================*\
Function : UserPlaneGeomIdGet
Purpose  : Get the id of the datum plane feature's geometry
\*====================================================================*/
ProError UserPlaneGeomIdGet  ( 
    ProGeomitem *geom_item,
    ProError     err,
    ProAppData   id )
{
    *(int*) id  = geom_item->id;

    return PRO_TK_NO_ERROR;
}

/*====================================================================*\
Function : UserNcseqEntitiesCollect
Purpose  : Collect worckcell and csys and use them to create an operation
\*====================================================================*/
ProError UserNcseqEntitiesCollect (
    ProFeature    *feature,
    ProError       err,
    ProAppData     entities )
{
    ProError       status;
    ProFeattype    feat_type;
    ProWcellType   wcell_type;
    NcseqEnts     *ncseq_ents = (NcseqEnts*)entities;
    ProSelection   selection;
    wchar_t        w_name[PRO_NAME_SIZE];
    char           name[PRO_NAME_SIZE];
    int            id;

    ProError UserWpieceSelCreate ( ProMfg, int, ProType, ProSelection*);

    status = ProFeatureTypeGet(feature, &feat_type);
    ERROR_CHECK("UserNcseqEntitiesCollect","ProFeatureTypeGet()",status);

    if (status == PRO_TK_NO_ERROR)
    {
	if ( !ncseq_ents->oper_found && feat_type == PRO_FEAT_OPERATION )
	{
		ncseq_ents->operation = feature->id;
		ncseq_ents->oper_found = PRO_B_TRUE;
	}
	else if (!ncseq_ents->retract_found && feat_type == PRO_FEAT_DATUM)
	{
	    status =  ProModelitemNameGet (feature, w_name);
	    ERROR_CHECK("UserNcseqEntitiesCollect","ProModelitemNameGet()",status);

	    ProWstringToString(name, w_name);
	    ERROR_CHECK("UserNcseqEntitiesCollect","ProWstringToString()",0);

	    if (!strcmp(name,"RETRACT_PLANE"))
	    {
		status = ProFeatureGeomitemVisit(feature, PRO_SURFACE, 
		UserPlaneGeomIdGet, NULL, (ProAppData)&ncseq_ents->retract_id);
		ERROR_CHECK("UserNcseqEntitiesCollect","ProFeatureGeomitemVisit()",
								    status);
	       	ncseq_ents->retract_found = PRO_B_TRUE;
	    }
	}
	else if (!ncseq_ents->csys_found && feat_type == PRO_FEAT_CSYS )
	{
	    status = ProFeatureSelectionGet(feature, &(ncseq_ents->csys));
	    ERROR_CHECK("UserNcseqEntitiesCollect","ProFeatureSelectionGet()",
	    								status);
	    status = ProSelectionHighlight(ncseq_ents->csys, PRO_COLOR_WARNING);
	    ERROR_CHECK("UserNcseqEntitiesCollect","ProSelectionHighlight()",
	    								status);
	    ncseq_ents->csys_found = PRO_B_TRUE;
	}
    }

    if ( ncseq_ents->oper_found && ncseq_ents->retract_found && 
	 ncseq_ents->csys_found )
	return PRO_TK_STOP_VISIT;
    else
	return PRO_TK_NO_ERROR;
}

/*====================================================================*\
FUNCTION : UserNcsequenceCreate
PURPOSE  : Top level nc-sequence creation function
\*====================================================================*/
int UserNcsequenceCreate ()
{
    ProMdl	  mfg_model;
    ProError      err = PRO_TK_NO_ERROR;
    ProError      status;
    ProSolid      mfg_solid;
    ProAssembly   assembly;
    int            num_sels;
    NcseqEnts      entities;
    ProTool        tool;
    wchar_t  feat_name[PRO_NAME_SIZE], def_wname[PRO_NAME_SIZE];
    wchar_t  temp[PRO_NAME_SIZE];
    char     def_name[] = "DemoMill", str[PRO_LINE_SIZE];


    ProError UserParamToolCreate (ProMfg, ProToolType, wchar_t*,
				double, double, double, ProTool*);
    ProError UserMillingCreate ( ProMfg, ProNcseqType, ProName, int, int,
				ProSelection*, wchar_t*);
 
    status = ProMdlCurrentGet(&mfg_model);
    ERROR_CHECK("UserNcsequenceCreate","ProMdlCurrentGet",status);

/*--------------------------------------------------------------------*\
    Get the manufacturing solid (workpiece)
\*--------------------------------------------------------------------*/
    status = ProMfgSolidGet((ProMfg)mfg_model, &mfg_solid);
    ERROR_CHECK("UserNcsequenceCreate","ProMfgSolidGet",status);

    status = ProMfgAssemGet((ProMfg)mfg_model, &assembly);
    ERROR_CHECK("UserNcsequenceCreate","ProMfgAssemGet",status);
/*--------------------------------------------------------------------*\
    Initialize search state
\*--------------------------------------------------------------------*/
    entities.oper_found = entities.retract_found = PRO_B_FALSE;
    entities.csys_found = PRO_B_FALSE;
    entities.model = (ProMfg)mfg_model;

    status = ProSolidFeatVisit ( mfg_solid, UserNcseqEntitiesCollect,NULL,
					    (ProAppData) &entities ); 
    ERROR_CHECK("UserNcsequenceCreate","ProSolidFeatVisit",status);

#if 0
/*--------------------------------------------------------------------*\
    Hack this in here just now
\*--------------------------------------------------------------------*/
    status = ProMessageDisplay(MSG_FIL, "USER Select a coordinate system: ");
    err = ProSelect("csys", -1, NULL, NULL, NULL, NULL, &selection2, &num_sels);
#endif

    err = UserParamToolCreate((ProMfg)mfg_model, PRO_TOOL_MILL,
	ProStringToWstring(temp,"10mm_flat_mill"), 6.0, 150.0, 0.0, &tool );
    ERROR_CHECK("UserNcsequenceCreate","UserParamToolCreate",err);

/*--------------------------------------------------------------------*\
    If both operation and retract entities were found then create the feature
\*--------------------------------------------------------------------*/
    if (entities.oper_found==PRO_B_TRUE && entities.retract_found==PRO_B_TRUE)
    {
	ProMessageDisplay(MSG_FIL, "USER Enter nc-sequence name: ");
	ProStringToWstring(def_wname, def_name);
        ProUtilStringGet(feat_name, def_wname, PRO_NAME_SIZE);
	
	status = UserMillingCreate((ProMfg)mfg_model,PRO_NCSEQ_CONV_SURF_MILL,
			feat_name, entities.operation, entities.retract_id,
			&(entities.csys), tool.tool_id );
	ERROR_CHECK("UserNcsequenceCreate","UserMillingCreate",status);
    }
    else
    {
       if (entities.retract_found == PRO_B_FALSE)
       {
	fprintf(stderr, "A suitable retract plane was not found\n");
       }
       if (entities.oper_found ==PRO_B_FALSE)
       {
	fprintf(stderr, "A suitable operation was not found\n");
       }
    }
    
    return ((int)status);
}

/*++++++++++++++UG_CODE_SAMPLE_STARTS_HERE++++++++++++++++++++++++++++*/

/*====================================================================*\
Function : UserMillingCreate
Purpose  : Create a milling feature using element tree
\*====================================================================*/
ProError UserMillingCreate (
    ProMfg        mfg_model,
    ProNcseqType  ncseq_type,
    ProName       feat_name,
    int           oper_id, 
    int           retract_id,
    ProSelection *mach_csys,
    wchar_t      *tool_name )
{
    ProError       err  = PRO_TK_NO_ERROR;
    ProElement     ncseq_elem      = (ProElement)NULL; /* Individual element */
    ProElement     ncseq_elem_tree = (ProElement)NULL; /* Entire tree        */
    ProValueData   value_data;
    ProValue       value        = (ProValue)NULL;
    ProErrorlist   errors;
    ProSelection   selection;
    ProFeature     ncseq_feature;
    ProFeatureCreateOptions fd_opts[] = {PRO_FEAT_CR_DEFINE_MISS_ELEMS };
    int            i = 0;

    ProError UserWpieceSelCreate ( ProMfg, int, ProType, ProSelection*);
    ProError UserMfgParamsSet(ProElement*);
    ProError UserMfgSurfacesAdd(ProElement*);

    static ElemTable  ncseq_elem_table[] =  {
                { PRO_E_FEATURE_TYPE,  PRO_VALUE_TYPE_INT       },
                { PRO_E_NCSEQ_TYPE,    PRO_VALUE_TYPE_INT       },
                { PRO_E_OPERATION,     PRO_VALUE_TYPE_INT       },
                { PRO_E_RETRACT,       PRO_VALUE_TYPE_INT       },
                { PRO_E_CSYS,          PRO_VALUE_TYPE_SELECTION },
                { PRO_E_MFG_PARAMS,    ARRAY                    },
                { PRO_E_SURFACES,      COMPLEX                  },
                { PRO_E_TOOL,          PRO_VALUE_TYPE_WSTRING   },
                { PRO_E_FEAT_NAME,     PRO_VALUE_TYPE_WSTRING   }};
		
    int            ncseq_elem_type_size = sizeof(ncseq_elem_table)/
						sizeof(ElemTable);
    
/*--------------------------------------------------------------------*\
    Allocate feature tree element
\*--------------------------------------------------------------------*/
    err = ProElementAlloc(PRO_E_FEATURE_TREE, &ncseq_elem_tree);
    ERROR_CHECK("UserNcsequenceCreate","ProElementAlloc()", err);
    
    for (i=0 ; i < ncseq_elem_type_size; i++)
    {

/*--------------------------------------------------------------------*\
        Allocate sequence element
\*--------------------------------------------------------------------*/
	err = ProElementAlloc(ncseq_elem_table[i].elem_type, &ncseq_elem);
	ERROR_CHECK("UserNcsequenceCreate","ProElementAlloc()", err);

	switch (ncseq_elem_table[i].elem_type)
	{
	    case PRO_E_FEATURE_TYPE :
		value_data.v.i = PRO_FEAT_MILL;
		break;
	    case PRO_E_NCSEQ_TYPE :
		value_data.v.i = ncseq_type ;
		break;
	    case PRO_E_OPERATION :
		value_data.v.i = oper_id ;
		break;
	    case PRO_E_RETRACT :
		value_data.v.i = retract_id ;
		break;
	    case PRO_E_MFG_PARAMS:
	        err = UserMfgParamsSet(&ncseq_elem);
		break;
	    case PRO_E_CSYS:
	        err = ProSelectionCopy(*mach_csys, &(value_data.v.r));
		break;
	    case PRO_E_SURFACES:
		err = UserMfgSurfacesAdd(&ncseq_elem);
		break;
	    case PRO_E_FEAT_NAME:
		value_data.v.w = (wchar_t*) malloc (sizeof(ProName));
		if (value_data.v.w)
		   ProUtilWstrcpy(value_data.v.w,feat_name);
		else
		    err = PRO_TK_BAD_INPUTS;
		break;
	    case PRO_E_TOOL:
		value_data.v.w = (wchar_t*) malloc (sizeof(ProName));
		if (value_data.v.w)
		   ProUtilWstrcpy(value_data.v.w,(wchar_t*)tool_name);
		else
		    err = PRO_TK_BAD_INPUTS;
		break;
	    default:
		fprintf(stderr, "Error setting element type\n");
		return PRO_TK_GENERAL_ERROR;
		break;
	}
	
/*--------------------------------------------------------------------*\
        If element is simple add it its value to the element
\*--------------------------------------------------------------------*/
    	if ( ncseq_elem_table[i].val_type != ARRAY &&
	     ncseq_elem_table[i].val_type != COMPLEX )
	{
	    value_data.type = ncseq_elem_table[i].val_type;
	    
	    err = ProValueAlloc ( &value );

	    if (err == PRO_TK_NO_ERROR)
	    {
		err = ProValueDataSet (value, &value_data);
		ERROR_CHECK("UserNcsequenceCreate", "ProValueDataSet()", err);
	    }

	    if ( err == PRO_TK_NO_ERROR )
	    {
		err = ProElementValueSet ( ncseq_elem, value );
		ERROR_CHECK("UserNcsequenceCreate", "ProElementValueSet()", err);
	    }
	}

/*--------------------------------------------------------------------*\
        Add the element to the feature tree
\*--------------------------------------------------------------------*/
	if ( err == PRO_TK_NO_ERROR )
	{
	    err = ProElemtreeElementAdd (ncseq_elem_tree, NULL, ncseq_elem );
	    ERROR_CHECK("UserNcsequenceCreate", "ProElemtreeElementAdd()", err);
	}

    }

    ProUtilElementtreePrint(ncseq_elem_tree, PRO_TEST_INFO_WINDOW, NULL );

/*--------------------------------------------------------------------*\
    Create the nc-sequence feature in the workpiece
\*--------------------------------------------------------------------*/
    if (err == PRO_TK_NO_ERROR )
	err = UserWpieceSelCreate (mfg_model, PRO_TK_NOT_USED, 
					      PRO_TK_NOT_USED, &selection);
    
    if (err == PRO_TK_NO_ERROR)
    {
        err = ProFeatureCreate(selection, ncseq_elem_tree,fd_opts,1,
                                                &ncseq_feature, &errors);
	ERROR_CHECK("UserNcsequenceCreate", "ProFeatureCreate()", err);

        if (err != PRO_TK_NO_ERROR)
	{
	    fprintf(stderr, "Error in element %d\n", 
	    		errors.error_list[0].err_item_id);
	}
    }

/*--------------------------------------------------------------------*\
    Free the feature tree
\*--------------------------------------------------------------------*/
    err = ProElementFree(&ncseq_elem_tree);
    ERROR_CHECK("UserNcsequenceCreate", "ProElementFree()", err);

    return ((int)err);
}

/*++++++++++++++UG_CODE_SAMPLE_ENDS_HERE++++++++++++++++++++++++++++++*/

#undef MSG_FIL