/*====================================================================*\
FILE    : TestImportfeat.c
PURPOSE : Test functions for Pro/TOOLKIT ProImportfeat

HISTORY..
DATE      BUILD   AUTHOR      MODIFICATIONS
          h-01-14 Pavel       $$1 Created
22-Jun-97 H-03-15 Pavel       $$2 Updated
 1-Jul-97 H-03-16 Pavel       $$3 Fixed TEST_CALL_REPORT
10-Jul-97 H-03-16 Pavel       $$4 Modified option in ProPartToIntfData
11-Jul-97 H-03-17 Pavel       $$5 Fixed param in ProImportfeatRedefSourceInit
14-Aug-97 H-03-18 Alexey      $$6 Arguments of ProImportfeatItemIdToUserId()
				  are changed in ProImportfeat.h
06-Oct-97 H-03-25 Pavel       $$7 Fix warnings
20-Aug-97 H-03-27 Pavel       $$8 Added datum support
02-Dec-97 H-03-35 Pavel       $$9 added edge creation type
09-Mar-98 H-03-40 Pavel	     $$10 Updated
20-Mar-98 H-03-41+ AEY	     $$11 Set option values for curve_representation and
				  surface_representation in ProTestImportfeat().
01-Jul-98 I-01-13 AKH	     $$12 Added support for PT/Products Toolkit
13-AUg-98 h-03-52 Rodi       $$13 Used ProSurfacedataMemoryFree
                                  ProQuiltdataMemoryFree
                                  ProEdgedataMemoryFree
12-Oct-98 I-01-21 AEY	     $$14 Fixed call ProImportfeatRedefSourceInit().
09-Nov-98 I-01-26 Pavel      $$15 Add menu Surface & curve convertions options.
				Replaced some ProMenu functions by ProUtilMenu 
07-Dec-98 I-01-27 Alexey     $$16 Corrected TEST_CALL_REPORT, fixed calls to
                                  ProDatumdataFree().
14-Dec-98 I-01-28 mka        $$17 Corrected TEST_CALL_REPORT, fixed calls to
                                  ProImportfeatRedefine()
14-Jul-99 I-03-11 Alexey     $$18 For ProTestRedefImpfeat declare impfeatattr
				  as ProImportfeatAttr instead of int
30-Jul-99 I-03-12 Alexey     $$19 To use Add Solid option cut_or_add should
				  be set to 0.
\*====================================================================*/


/*--------------------------------------------------------------------*\
Pro/TOOLKIT includes
\*--------------------------------------------------------------------*/
#include <ProToolkit.h>
#include <ProEdgedata.h>
#include <ProFeatType.h>
#include <ProFeature.h>
#include <ProIntfData.h>
#include <ProImportfeat.h>
#include <ProQuiltdata.h>
#include <ProSolid.h>
#include <ProSurfacedata.h>
#include <ProUtil.h>

/*--------------------------------------------------------------------*\
C System includes
\*--------------------------------------------------------------------*/

/*--------------------------------------------------------------------*\
Application includes
\*--------------------------------------------------------------------*/
#include "TestError.h"
#include "UtilMenu.h"
#include "UtilMessage.h"

#define NEW_PART_NAME "new_impfeat_part"

#define UV_POINTS 1
#define UV_CURVES 2
#define XYZ_CURVE 4

#define JOIN_SURFACES 1
#define MAKE_SOLID    2
#define ADD_SOLID     4

static int  cr_type = UV_POINTS | UV_CURVES | XYZ_CURVE;
static ProImportfeatAttr impfeatattr = { 1, 1, 0 };
static  ProPartConversionOptions opt = { {1, 1, 1}, PRO_PART_CURVES_AS_DEFAULT,
    PRO_PART_SURFACES_AS_DEFAULT }; 

/*====================================================================*\
    FUNCTION :  ProUtilIntfTypeToStr()
    PURPOSE  :  convert ProIntfType to str
\*====================================================================*/
char * ProUtilIntfTypeToStr(ProIntfType type)
{
    int i;
    static struct intf_type_str
    {
   	ProIntfType type;
        char *str;
    } tab[] = {
	  {PRO_INTF_NONE, "PRO_INTF_NONE"},
          {PRO_INTF_NEUTRAL, "PRO_INTF_NEUTRAL"},
	  {PRO_INTF_NEUTRAL_FILE, "PRO_INTF_NEUTRAL_FILE"},
          {PRO_INTF_IGES, "PRO_INTF_IGES"},
          {PRO_INTF_STEP, "PRO_INTF_STEP"},
          {PRO_INTF_VDA, "PRO_INTF_VDA"},
          {PRO_INTF_SET, "PRO_INTF_SET"},
          {PRO_INTF_PDGS, "PRO_INTF_PDGS"},
          {PRO_INTF_CATIA, "PRO_INTF_CATIA"},
          {PRO_INTF_NONE, "UNKNOWN"}
   };

   for (i=0; i<sizeof(tab)/sizeof(tab[0])-1; i++)
   {
    	if (tab[i].type == type)
	    break;
   }
   return (tab[i].str);
}


/*====================================================================*\
    FUNCTION :  ProUtilImportfeatInfoPrint()
    PURPOSE  :  write import feat info to file 
\*====================================================================*/
ProError ProUtilImportfeatInfoPrint(
    ProFeature *import_feat)	/* In: import feat */
{
    ProError err;
    FILE *fp;
    int cont=1, i, j, *p_item_id, n_map, n_uid=0, n_iid=0;
    int	*p_user_id;
    ProImportfeatData if_data;
    char fname[PRO_PATH_SIZE];
    ProImportfeatIdMap *p_id_map, id_map;

    fp = fopen("impfeat_part.txt", "w");

    do 
    {
    fprintf(fp, "Import feature info:\n");

    err = ProImportfeatDataGet(import_feat, &if_data);
    TEST_CALL_REPORT("ProImportfeatDataGet()",
	    	"ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);

    if (err != PRO_TK_NO_ERROR)
	break;

    fprintf(fp,"Interface type: %s\n",ProUtilIntfTypeToStr(if_data.intf_type)); 
    ProWstringToString(fname, if_data.filename);
    fprintf(fp, "Filename: %s\n", fname);
    fprintf(fp, "Attributes: %x\n\n", if_data.attr);

 
    err = ProImportfeatIdArrayCreate(import_feat, &p_id_map);
    TEST_CALL_REPORT("ProImportfeatIdArrayCreate()",
	    	"ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);

    if (err != PRO_TK_NO_ERROR)
	break;

    err = ProImportfeatIdArrayMapCount(p_id_map, &n_map);
    TEST_CALL_REPORT("ProImportfeatIdArrayMapCount()",
	    	"ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);

    fprintf(fp, "Map N   Type   UserId ItemId UId->IId                      "
	"IId->UId\n");
    for (i=0; i<n_map; i++)
    {
    	err = ProImportfeatIdArrayMapGet(p_id_map, i, &id_map);
    	TEST_CALL_REPORT("ProImportfeatIdArrayMapGet()",
	    	"ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);
       
	err = ProArrayAlloc(0, sizeof(p_item_id[0]), 1, (ProArray*)&p_item_id);
    	TEST_CALL_REPORT("ProArrayAlloc()",
	    	"ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);

	err = ProImportfeatUserIdToItemId(import_feat, id_map.user_id,
	    id_map.item_type, &p_item_id);
    	TEST_CALL_REPORT("ProImportfeatUserIdToItemId()",
	    	"ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);

	err = ProArraySizeGet((ProArray*)p_item_id, &n_iid);
    	TEST_CALL_REPORT("ProArraySizeGet()",
	    	"ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);

	err = ProArrayAlloc( 0, sizeof(int), 1, (ProArray*)&p_user_id );
	TEST_CALL_REPORT("ProArrayAlloc()",
		"ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR)
	    break;

	err = ProImportfeatItemIdToUserId(import_feat, id_map.item_id,
	    id_map.item_type, &p_user_id);
    	TEST_CALL_REPORT("ProImportfeatItemIdToUserId()",
	    	"ProUtilImportfeatInfoPrint()", 
		err, err != PRO_TK_NO_ERROR && err != PRO_TK_NOT_IMPLEMENTED );

	err = ProArraySizeGet((ProArray*)p_user_id, &n_uid);
    	TEST_CALL_REPORT("ProArraySizeGet()",
	    	"ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);

        fprintf(fp, "%5d  %5d  %5d  %5d", i, id_map.item_type, id_map.item_id,
	    id_map.user_id);

	for (j=0; j<n_iid || j<5; j++)
	    if (j<n_iid)
       		fprintf(fp, " %5d", p_item_id[j]);
	    else
       		fprintf(fp, "      ");
	for (j=0; j<n_uid; j++)
       	    fprintf(fp, "%5d", p_user_id[j]);

	fprintf(fp, "\n");

	err = ProArrayFree( (ProArray*)&p_item_id );
	TEST_CALL_REPORT("ProArrayFree()",
		    "ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);

	err = ProArrayFree( (ProArray*)&p_user_id );
	TEST_CALL_REPORT("ProArrayFree()",
		    "ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);

    }

    err = ProImportfeatIdArrayFree(p_id_map);
    TEST_CALL_REPORT("ProImportfeatIdArrayFree()",
	    	"ProUtilImportfeatInfoPrint()", err, err != PRO_TK_NO_ERROR);

    } while (!cont);

    fclose(fp);
    return (err);   
}

/*====================================================================*\
    FUNCTION :  ProUtilIntfDataCopy()
    PURPOSE  :  copy all data using different functions
\*====================================================================*/
ProError ProUtilIntfDataCopy(
    ProIntfData **p_i_data) 	/* In, Out: intf data */
{
    ProIntfData *out_data = NULL;
    ProError err;
    int stop=0, num_surf, s, num_quilt, q, num_edge, e, d, num_datum;
    ProSurfacedata *p_surf_data;
    ProQuiltdata *p_quilt_data;
    ProEdgedata *p_edge_data;
    ProDatumdata *p_datum_data=NULL;
    double acc;
    ProAccuracytype acc_type;
    ProOutline xyz_outline;

    err = ProIntfDataAlloc(&out_data);
    TEST_CALL_REPORT("ProIntfDataAlloc()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
 
    do
    {
	err = ProIntfDataSurfaceCount(*p_i_data, &num_surf);
    	TEST_CALL_REPORT("ProIntfDataSurfaceCount()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR)
	    break;
	
	for (s=0; s<num_surf; s++)
	{
	    err = ProIntfDataSurfaceGet(*p_i_data, s, &p_surf_data);
    	    TEST_CALL_REPORT("ProIntfDataSurfaceGet()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	
	    err = ProUtilSurfacedataCopy(&p_surf_data);

	    err = ProIntfDataSurfaceAppend(out_data, p_surf_data);
    	    TEST_CALL_REPORT("ProIntfDataSurfaceAppend()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);

	    err = ProSurfacedataMemoryFree(p_surf_data);
    	    TEST_CALL_REPORT("ProSurfacedataMemoryFree()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	}

	err = ProIntfDataQuiltCount(*p_i_data, &num_quilt);
    	TEST_CALL_REPORT("ProIntfDataQuiltCount()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR)
	    break;
	
	for (q=0; q<num_quilt; q++)
	{
	    err = ProIntfDataQuiltGet(*p_i_data, q, &p_quilt_data);
    	    TEST_CALL_REPORT("ProIntfDataQuiltGet()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);

	    err = ProUtilQuiltdataCopy(&p_quilt_data);

	    err = ProIntfDataQuiltAppend(out_data, p_quilt_data);
    	    TEST_CALL_REPORT("ProIntfDataQuiltAppend()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);

	    err = ProQuiltdataMemoryFree(p_quilt_data);
    	    TEST_CALL_REPORT("ProQuiltdataMemoryFree()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	}

	err = ProIntfDataEdgeCount(*p_i_data, &num_edge);
    	TEST_CALL_REPORT("ProIntfDataEdgeCount()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR)
	    break;
	
	for (e=0; e<num_edge; e++)
	{
	    err = ProIntfDataEdgeGet(*p_i_data, e, &p_edge_data);
    	    TEST_CALL_REPORT("ProIntfDataEdgeGet()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	
	    err = ProUtilEdgedataCopy(&p_edge_data);

	    err = ProIntfDataEdgeAppend(out_data, p_edge_data);
    	    TEST_CALL_REPORT("ProIntfDataEdgeAppend()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);

	    err = ProEdgedataMemoryFree(p_edge_data);
    	    TEST_CALL_REPORT("ProEdgedataMemoryFree()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	}
	err = ProIntfDataDatumCount(*p_i_data, &num_datum);
    	TEST_CALL_REPORT("ProIntfDataDatumCount()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR)
	    break;

	err = ProDatumdataAlloc( &p_datum_data );
	TEST_CALL_REPORT("ProDatumdataAlloc()", "ProUtilIntfDataCopy()", 
		err, err != PRO_TK_NO_ERROR);

	for (d=0; d<num_datum; d++)
	{
	    err = ProIntfDataDatumGet(*p_i_data, d, &p_datum_data);
    	    TEST_CALL_REPORT("ProIntfDataDatumGet()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	
	    err = ProUtilDatumdataCopy(&p_datum_data);

	    if (err == PRO_TK_NO_ERROR)
	    {

	    err = ProIntfDataDatumAppend(out_data, p_datum_data);
    	    TEST_CALL_REPORT("ProIntfDataDatumAppend()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);

	    }
	}
        

	err = ProDatumdataFree(p_datum_data);
	    TEST_CALL_REPORT("ProDatumdataFree()",
	        "ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);

	err = ProIntfDataAccuracytypeGet(*p_i_data, &acc_type);
    	TEST_CALL_REPORT("ProIntfDataAccuracytypeGet()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);

	err = ProIntfDataAccuracytypeSet(out_data, acc_type);
    	TEST_CALL_REPORT("ProIntfDataAccuracytypeSet()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);

	err = ProIntfDataAccuracyGet(*p_i_data, &acc);
    	TEST_CALL_REPORT("ProIntfDataAccuracyGet()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	
	err = ProIntfDataAccuracySet(out_data, acc);
    	TEST_CALL_REPORT("ProIntfDataAccuracySet()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);

	err = ProIntfDataOutlineGet(*p_i_data, xyz_outline);
    	TEST_CALL_REPORT("ProIntfDataOutlineGet()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);

	err = ProIntfDataOutlineSet(out_data, xyz_outline);
    	TEST_CALL_REPORT("ProIntfDataOutlineSet()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
    } while (stop);

    if (err == PRO_TK_NO_ERROR)
    {

memset(*p_i_data, '\0', sizeof(ProIntfData));

        err = ProIntfDataFree(*p_i_data);
        TEST_CALL_REPORT("ProIntfDataFree()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);

	p_i_data[0] = out_data;
	return (PRO_TK_NO_ERROR);
    }
    else
    {
        err = ProIntfDataFree(out_data);
        TEST_CALL_REPORT("ProIntfDataFree()",
		    	"ProUtilIntfDataCopy()", err, err != PRO_TK_NO_ERROR);
	return (PRO_TK_GENERAL_ERROR);
    }
}

/*====================================================================*\
    FUNCTION :  ProTestEdgeCreationTypeGet()
    PURPOSE  :  returns creation type
\*====================================================================*/
void ProTestEdgeCreationTypeGet (int *creation_type)
{
    *creation_type = cr_type;
}

/*====================================================================*\
    FUNCTION :  ProTestEdgeMenuAction()
    PURPOSE  :  action function for edge creation type menu
\*====================================================================*/
int ProTestEdgeMenuAction (ProAppData data, int action)
{
    int *cr_type = data;
    *cr_type ^= action;
    return (0);
}

/*====================================================================*\
    FUNCTION :  ProUtilSurfaceMenuAction()
    PURPOSE  :  action function for edge creation type menu
\*====================================================================*/
int ProUtilSurfaceMenuAction(
    ProAppData data, int action)
{
    *(int*)data = action;
    return (0);
}

/*====================================================================*\
    FUNCTION :  ProTestSelectEdgeCreationType()
    PURPOSE  :  Selects edge creation type
\*====================================================================*/
void ProTestSelectEdgeCreationType (
    ProPartConversionOptions *p_opts)
{
    ProError status;
    int menu_id, action, cr_type;
    static char *cmpnd_menu[] = 
        {"TkEdgeCreat", "TkSurfCreat", "TkCurvCreat", "DONE",""};
    
    status = ProMenuFileRegister( "TkEdgeCreat", "tkedgecreat.mnu", 
	&menu_id );
    TEST_CALL_REPORT( "ProMenuFileRegister()", 
        "ProTestSelectEdgeCreationType()",
    	status,  status != PRO_TK_NO_ERROR );

    ProMenubuttonActionSet( "TkEdgeCreat", "UV points",
        (ProMenubuttonAction)ProTestEdgeMenuAction, 
        (ProAppData)&cr_type, UV_POINTS );
    ProMenubuttonActionSet( "TkEdgeCreat", "UV curves",
        (ProMenubuttonAction)ProTestEdgeMenuAction, 
        (ProAppData)&cr_type, UV_CURVES );
    ProMenubuttonActionSet( "TkEdgeCreat", "XYZ curve",
        (ProMenubuttonAction)ProTestEdgeMenuAction, 
        (ProAppData)&cr_type, XYZ_CURVE);
    ProMenubuttonActionSet( "TkEdgeCreat", "TkEdgeCreat",
    	(ProMenubuttonAction)ProMenuHold, NULL,  0 );
    	
    status = ProMenuFileRegister( "TkSurfCreat", "tksurfcreat.mnu", 
	&menu_id );
    ProMenubuttonActionSet( "TkSurfCreat", "Default Surf",
        (ProMenubuttonAction)ProUtilSurfaceMenuAction, 
        (ProAppData)&p_opts->surface_representation, 
        PRO_PART_SURFACES_AS_DEFAULT );
    ProMenubuttonActionSet( "TkSurfCreat", "Spl as BSpl",
        (ProMenubuttonAction)ProUtilSurfaceMenuAction, 
        (ProAppData)&p_opts->surface_representation, 
        PRO_PART_SPL_SURFACES_AS_BSPL_SURFACES );
    ProMenubuttonActionSet( "TkSurfCreat", "Srf as BSpl",
        (ProMenubuttonAction)ProUtilSurfaceMenuAction, 
        (ProAppData)&p_opts->surface_representation, 
        PRO_PART_SURFACES_AS_BSPL_SURFACES );
    ProMenubuttonActionSet( "TkSurfCreat", "TkSurfCreat",
    	(ProMenubuttonAction)ProMenuHold, NULL,  0 );

    status = ProMenuFileRegister( "TkCurvCreat", "tkcurvcreat.mnu", 
	&menu_id );
    ProMenubuttonActionSet( "TkCurvCreat", "Default Curve",
        (ProMenubuttonAction)ProUtilSurfaceMenuAction, 
        (ProAppData)&p_opts->curve_representation, 
        PRO_PART_CURVES_AS_DEFAULT );
    ProMenubuttonActionSet( "TkCurvCreat", "Spl as BSpl",
        (ProMenubuttonAction)ProUtilSurfaceMenuAction, 
        (ProAppData)&p_opts->curve_representation, 
        PRO_PART_SPLINES_AS_BSPLINES );
    ProMenubuttonActionSet( "TkCurvCreat", "Curve as BSpl",
        (ProMenubuttonAction)ProUtilSurfaceMenuAction, 
        (ProAppData)&p_opts->curve_representation, 
        PRO_PART_CURVES_AS_BSPLINES );
    ProMenubuttonActionSet( "TkCurvCreat", "TkCurvCreat",
    	(ProMenubuttonAction)ProMenuHold, NULL,  0 );
        
  
    status = ProMenuModeSet ("TkEdgeCreat", PROMENUMODE_DATA);
    TEST_CALL_REPORT( "ProMenuModeSet()", "ProTestSelectEdgeCreationType()",
        status,  status != PRO_TK_NO_ERROR );
    status = ProMenuDatamodeSet ("TkEdgeCreat", PRO_B_TRUE);
    TEST_CALL_REPORT( "ProMenuDatamodeSet()", "ProTestSelectEdgeCreationType()",
        status,  status != PRO_TK_NO_ERROR );
    
    status = ProMenuFileRegister("DONE","tketdone.mnu", &menu_id);
    TEST_CALL_REPORT("ProMenuFileRegister()", "ProTestSelectEdgeCreationType()",
				    status , status != PRO_TK_NO_ERROR);
    status = ProMenubuttonActionSet("DONE","-Done",
        (ProMenubuttonAction)ProUtilMenuKill, NULL, 4);
    
    status = ProMenubuttonActionSet("DONE","DONE",
			    (ProMenubuttonAction)ProMenuHold,NULL,0);

    status = ProCompoundmenuCreate(cmpnd_menu, &menu_id);
    TEST_CALL_REPORT("ProCompoundmenuCreate()", 
        "ProTestSelectEdgeCreationType()",
	status , status != PRO_TK_NO_ERROR);

    cr_type = 0;
    if (opt.edge_representation.uv_points) 
        cr_type |= UV_POINTS;
    if (opt.edge_representation.uv_curves)
     cr_type |= UV_CURVES;
    if (opt.edge_representation.xyz_curve)
        cr_type |= XYZ_CURVE;

    ProUtilMenubuttonHighlight ("TkEdgeCreat", "UV points", cr_type& UV_POINTS);
    ProUtilMenubuttonHighlight ("TkEdgeCreat", "UV curves", cr_type& UV_CURVES);
    ProUtilMenubuttonHighlight ("TkEdgeCreat", "XYZ curve", cr_type& XYZ_CURVE);
    ProUtilMenubuttonHighlight ("TkSurfCreat", "Default Surf", 1);
    ProUtilMenubuttonHighlight ("TkCurvCreat", "Default Curve", 1);
    
    if( status == PRO_TK_NO_ERROR )
    {
    	status = ProMenuProcess( "TkEdgeCreat", &action );
    	TEST_CALL_REPORT( "ProMenuProcess()", "ProTestSelectEdgeCreationType()",
            status,  status != PRO_TK_NO_ERROR );
    }

    opt.edge_representation.uv_points = (cr_type & UV_POINTS) && 1;
    opt.edge_representation.uv_curves = (cr_type & UV_CURVES) && 1;
    opt.edge_representation.xyz_curve = (cr_type & XYZ_CURVE) && 1;
}

/*====================================================================*\
    FUNCTION :  ProTestImportfeat()
    PURPOSE  :  Commands for testing import feature in Pro/TOOLKIT
\*====================================================================*/
void ProTestSelectIntfType(
    ProIntfType *type)
{
     ProError err;
    int action;    
    static ProUtilMenuButtons intf_type[] = { 
        {"TkIntfType", 0, TEST_CALL_PRO_MENU_DELETE},
        {"Neutral", PRO_INTF_NEUTRAL, 0},
        {"Neutral File", PRO_INTF_NEUTRAL_FILE, 0},
        {"Iges File", PRO_INTF_IGES, 0},
        {"Step File", PRO_INTF_STEP, 0},
        {"Vda File", PRO_INTF_VDA, 0},
        {"Set File", PRO_INTF_SET, 0},
        {"PDGS File", PRO_INTF_PDGS, 0},
        {"CATIA File",PRO_INTF_CATIA , 0},
        {"",0,0}
    };
    err = ProUtilMenuIntValueSelect(intf_type, &action);
    if (err != PRO_TK_NO_ERROR)
	*type = PRO_INTF_NONE;
    else
	*type = (ProIntfType)action;
}

/*====================================================================*\
    FUNCTION :  ProTestImportfeat()
    PURPOSE  :  Commands for testing import feature in Pro/TOOLKIT
\*====================================================================*/
int ProTestImportfeat(ProMdl *mdl)
{

    ProError err;
    ProIntfType intf_type;
    ProIntfDataSourceType intfdatasrc_type;    
    ProPart part = *mdl, new_part;
    ProIntfDataSource id_source;
    ProIntfData *id_data = NULL;
    int cont = 1, w_id;
    ProName w_name, w_file_name;
    ProFeature feat;
    ProImportfeatRedefSource redef_source;
    ProImportfeatRedefSourceType redefsourcetype;    
    char part_name[PRO_NAME_SIZE];
    void *vp;
    
    ProTestSelectIntfType(&intf_type);
    if (intf_type == PRO_INTF_NONE)
	return (0);

    if (intf_type == PRO_INTF_NEUTRAL)
    {
	
	ProTestSelectEdgeCreationType (&opt);
    }


    ProUtilMsgPrint("gen", "TEST %0s", "Enter new part name.");
    ProStringToWstring(w_name, NEW_PART_NAME);
    

    ProUtilStringGet(w_name, w_name, PRO_NAME_SIZE);
    err = ProSolidCreate(w_name, PRO_PART, &new_part);
    TEST_CALL_REPORT("ProSolidCreate()",
		    	"ProTestImportfeat()", err, err != PRO_TK_NO_ERROR);


    do
    {
    intfdatasrc_type = ProIntfTypeToIntfDataSourceType(intf_type);
    TEST_CALL_REPORT(" ProIntfTypeToIntfDataSourceType()",
		     "ProTestImportfeat()", 0, 0);
    
    if (intfdatasrc_type == PRO_INTF_DATA_SOURCE_NONE)
	break;

    if (intfdatasrc_type == PRO_INTF_DATA_SOURCE_FILE)
    {
	ProUtilMsgPrint("gen", "TEST %0s", "Enter the import file name.");
	if (ProUtilStringGet(w_file_name, NULL, PRO_NAME_SIZE) == 0)
	    break;
	vp = (void*)w_file_name;	
    }
    else
    {    
	err = ProIntfDataAlloc(&id_data);
	TEST_CALL_REPORT("ProIntfDataAlloc()",
		    	"ProTestImportfeat()", err, err != PRO_TK_NO_ERROR);
	
 	err = ProPartToProIntfData(part, &opt, id_data);
	TEST_CALL_REPORT("ProPartToProIntfData()",
		    	"ProTestImportfeat()", err, err != PRO_TK_NO_ERROR);
	if (err != PRO_TK_NO_ERROR)
	    break;

	err = ProUtilIntfDataCopy(&id_data); 
	if (err != PRO_TK_NO_ERROR)
	    break;
	vp = (void*)id_data;	
    }
    
    err = ProIntfDataSourceInit( intf_type, vp, &id_source);
    TEST_CALL_REPORT("ProIntfDataSourceInit()",
		    	"ProTestImportfeat()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	break;

    err = ProImportfeatCreate(new_part, &id_source, NULL, NULL, &feat);
    TEST_CALL_REPORT("ProImportfeatCreate()",
		    	"ProTestImportfeat()", err, err != PRO_TK_NO_ERROR);
	
    if (err != PRO_TK_NO_ERROR)
	break;

#ifndef PT_PRODUCTS_BUILD
    err = ProObjectwindowCreate(w_name, PRO_PART, &w_id);
    TEST_CALL_REPORT("ProObjectwindowCreate()",
		    	"ProTestImportfeat()", err, err != PRO_TK_NO_ERROR);

    err = ProMdlDisplay((ProMdl)new_part);
    TEST_CALL_REPORT("ProMdlDisplay()",
		    	"ProTestImportfeat()", err, err != PRO_TK_NO_ERROR);
 
    err = ProWindowActivate(w_id);
    TEST_CALL_REPORT("ProWindowActivate()",
		    	"ProTestImportfeat()", err, err != PRO_TK_NO_ERROR);

#endif
    if (id_data != NULL)
    {
	
	err = ProImportfeatRedefSourceInit(PRO_IMPORT_FEAT_REDEF_SUBSTITUTE,
	   (void*)&id_source, &redef_source);
	TEST_CALL_REPORT("ProImportfeatRedefSourceInit()",
		    	"ProTestImportfeat()", err, err != PRO_TK_NO_ERROR);

	redefsourcetype = ProImportfeatRedefSourceTypeGet(
	    PRO_IMPORT_FEAT_REDEF_SUBSTITUTE);
	TEST_CALL_REPORT("ProImportfeatRedefSourceTypeGet()",
		    	"ProTestImportfeat()", 0, 0);
	
	
	err = ProImportfeatRedefine(&feat, &redef_source); 
	TEST_CALL_REPORT("ProImportfeatRedefine()",
		    	"ProTestImportfeat()", err, 
                        (err != PRO_TK_NO_ERROR)&&
                        (err != PRO_TK_NOT_IMPLEMENTED));

    }
    ProUtilImportfeatInfoPrint(&feat);
    
    } while (!cont);

    if (id_data != NULL)
    {
	err = ProIntfDataFree(id_data);
	TEST_CALL_REPORT("ProIntfDataFree()",
			 "ProTestImportfeat()", err, err != PRO_TK_NO_ERROR);
    }
    
    return (0);
}


/*====================================================================*\
    FUNCTION :  ProUtilImportfeatFilter()
    PURPOSE  :  Allows to collect only import features
\*====================================================================*/
ProError ProUtilImportfeatFilter(
    ProFeature *p_feature)
{
    ProError err;
    ProFeattype feattype;
    
    err = ProFeatureTypeGet(p_feature, &feattype);
    TEST_CALL_REPORT( " ProFeatureTypeGet()", 
        " ProUtilImportfeatFilter()", err,  err != PRO_TK_NO_ERROR );
    return (err == PRO_TK_NO_ERROR && feattype == PRO_FEAT_IMPORT ?
	    PRO_TK_NO_ERROR : PRO_TK_CONTINUE);
}


int ProTestImpfeatAttrMenuAction( ProAppData data, int action )
{
    ProImportfeatAttr	*p_attrs = (ProImportfeatAttr*)data;

    switch( action )
    {
	case JOIN_SURFACES:
	    p_attrs->join_surfaces = p_attrs->join_surfaces ? 0 : 1;
	    break;

	case MAKE_SOLID:
	    p_attrs->attempt_make_solid = p_attrs->attempt_make_solid ? 0 : 1;
	    break;

	case ADD_SOLID:
	    p_attrs->cut_or_add = p_attrs->cut_or_add ? 0 : 1;
	    break;
    }

    return 0;
}


/*====================================================================*\
    FUNCTION :  ProTestRedefImpfeat()
    PURPOSE  :  Commands for testing import feature in Pro/TOOLKIT
\*====================================================================*/
int ProTestRedefImpfeat(ProMdl *mdl)
{
    ProError err;
    ProFeature *p_feats;
    ProImportfeatRedefSource redef_source;
    int menu_id, action;    
    static char *cmpnd_menu[] = {"TkImpfeatAttr","DONE",""};


    err = ProUtilCollectSolidFeaturesWithFilter((ProSolid)*mdl,
	(ProFeatureFilterAction)ProUtilImportfeatFilter, &p_feats);
    if (err != PRO_TK_NO_ERROR)
    {
	ProUtilMsgPrint("gen", "TEST %0s", "No Import feats found.");
	return (0);
    }
    
    err = ProMenuFileRegister( "TkImpfeatAttr", "tkimpfeatattr.mnu", 
	&menu_id );
    TEST_CALL_REPORT( "ProMenuFileRegister()", 
        "ProTestRedefImpfeate()", err,  err != PRO_TK_NO_ERROR );

    ProMenubuttonActionSet( "TkImpfeatAttr", "TkImpfeatAttr",
			    (ProMenubuttonAction)ProMenuDelete, NULL, 0);
    ProMenubuttonActionSet( "TkImpfeatAttr", "Join Surfaces",
        (ProMenubuttonAction)ProTestImpfeatAttrMenuAction, 
        (ProAppData)&impfeatattr, JOIN_SURFACES );
    ProMenubuttonActionSet( "TkImpfeatAttr", "Make Solid",
        (ProMenubuttonAction)ProTestImpfeatAttrMenuAction, 
        (ProAppData)&impfeatattr, MAKE_SOLID);
    ProMenubuttonActionSet( "TkImpfeatAttr", "Add Solid",
        (ProMenubuttonAction)ProTestImpfeatAttrMenuAction, 
        (ProAppData)&impfeatattr, ADD_SOLID);

    
    err = ProMenuModeSet ("TkImpfeatAttr", PROMENUMODE_DATA);
    TEST_CALL_REPORT( "ProMenuModeSet()", 
        "ProTestRedefImpfeate()", err,  err != PRO_TK_NO_ERROR );
    err = ProMenuDatamodeSet ("TkImpfeatAttr", PRO_B_TRUE);
    TEST_CALL_REPORT( "ProMenuDatamodeSet()",
	"ProTestRedefImpfeat()", err,  err != PRO_TK_NO_ERROR );
    
    err = ProMenuFileRegister("DONE","tketdone.mnu", &menu_id);
    err = ProMenubuttonActionSet("DONE","-Done",
        (ProMenubuttonAction)ProUtilMenuKill, NULL, 2);    
    err = ProMenubuttonActionSet("DONE","DONE",
			    (ProMenubuttonAction)ProMenuHold,NULL,0);

    err = ProCompoundmenuCreate(cmpnd_menu, &menu_id);
    TEST_CALL_REPORT("ProCompoundmenuCreate()",
        "ProTestRedefImpfeat()", err,  err != PRO_TK_NO_ERROR );

    ProUtilMenubuttonHighlight ("TkImpfeatAttr", "Join Surfaces",
				impfeatattr.join_surfaces);
    ProUtilMenubuttonHighlight ("TkImpfeatAttr", "Make Solid",
				impfeatattr.attempt_make_solid);
    ProUtilMenubuttonHighlight ("TkImpfeatAttr", "Add Solid",
				impfeatattr.cut_or_add);

    err = ProMenuProcess( "TkImpfeatAttr", &action );
    TEST_CALL_REPORT( "ProMenuProcess()",
        "ProTestRedefImpfeat()", err,  err != PRO_TK_NO_ERROR );

    err = ProImportfeatRedefSourceInit(PRO_IMPORT_FEAT_REDEF_CHANGE_ATTR,
	   (void*)&impfeatattr, &redef_source);
    TEST_CALL_REPORT("ProImportfeatRedefSourceInit()",
        "ProTestRedefImpfeat()", err,  err != PRO_TK_NO_ERROR );

    err = ProImportfeatRedefine(p_feats, &redef_source); 
    TEST_CALL_REPORT("ProImportfeatRedefine()",
        "ProTestRedefImpfeat()", err,  (err != PRO_TK_NO_ERROR)&&
                                       (err !=PRO_TK_NOT_IMPLEMENTED));

    err = ProArrayFree((ProArray*)&p_feats);
    TEST_CALL_REPORT("ProArrayFree()",
        "ProTestRedefImpfeat()", err,  err != PRO_TK_NO_ERROR );

    return (0);    
}