/*====================================================================*\
FILE	: TestFeats.c
PURPOSE	: Smoke test for all Toolkit ProFeature functions

HISTORY..
DATE		  AUTHOR	MODIFICATIONS
25 Jan 96	  Alistair	$$1 First version.
21 Feb 96 	  Michael	$$2 Added "prodev_menu.h" 
22 Apr 96         Michael       $$3 Changed header scheme
27 May 96         Amin          $$4 ProFeatureTypekeyGet-->ProAppfeatureTypeGet
26 Aug 96 H-01-05 Xuekai        $$5 Modify due to change to ProMdl
16 Sep 96 H-01-09 Xuekai        $$6 Modify due to change in ProFeature.h
18 Sep 96 H-01-09 Xuekai        $$7 include "ProModelitem.h"
24-Sep-96 H-01-10 Xuekai        $$8 Pro[Surface, Curve]=>Opaque
01-Oct-96 H-01-11 Xuekai        $$9 ProSelection=>Opaque
04-Oct-96 H-01-11+ mgs          $$10 ProSelect changes
21-Oct-96 H-01-14 Steve		$$11 Added feat create,redef,treeinfo
04-Oct-96 H-01-14 amin          $$12 included prographics.h
29-Oct-96 H-01-15 amin          $$13 Changed order of ProSelect()
12-Nov-96 H-01-16 amin          $$14 Removed ProFeatdef.h
17-Dec-96 H-01-21 mgs           $$15 Removed AppFeatureTypeGet() call
19-Jan-97 H-01-21 Alexey	$$16 Added items 'Resume'&'Feat Status' to TkFeats
21-Jan-97 H-01-24 Jerry         $$17 Conflict avoidance: changed Feats menu item to -Feats
22-Sep-97 H-03-23 Pavel		$$18 Fixed bugs, added Reorder, Readonly,
				     Insert mode, etc.
24-Sep-97 H-03-24 Pavel         $$19 Removed Status Set, Create, Redefine
                                     Added Group. Feat Info copied from
                                     TestFeatCreate.c
03-Oct-97 H-03-24 Alexey        $$20 Undo last changes to run ptr_mfg_1
17-Oct-97 H-03-27 Pavel         $$21 Replaced Visit functions by UtilCollect
31-Oct-97 H-03-29 Pavel         $$22 Used PreFilter function, 
				     removed FeatstatusSet
25-Nov-97 H-03-31 Pavel         $$23 Added ProSolidFailedFeatsList
12-Dec-97 H-03-32 Alexey	$$24 Fix arguments in ProSolidFailedFeatsList
12-Feb-98 H-03-39 Pavel	        $$25 Test for ProLocalGroupCreate &
				     Pattern Info
30-Nov-98 I-01-27 Alexey        $$26 Correct TEST_CALL_REPORTs. Fix problem 
					with ProGeomitemVisit in the 
					ProTestFeatureAct 
02-Jun-99 I-03-11 mka           $$27 Delete unused variable   
08-Sep-99 I-03-20 aab           $$28  Added test of ProSolidFailedFeatsList
                                    under Resolve Feat menu.
18-Aug-2000 J-01-16 shirish     $$29 Fix for Reordering of supressed features 
				    in ProUtilFeatByNumberGet 
\*====================================================================*/

/*--------------------------------------------------------------------*\
Pro/TOOLKIT includes
\*--------------------------------------------------------------------*/
#include <ProToolkit.h>
#include <ProFeature.h>
#include <ProFeatType.h>
#include <ProGeomitem.h>
#include <ProGroup.h>
#include <ProSelection.h>
#include <ProSolid.h>
#include <ProModelitem.h>
#include <ProMenu.h>
#include <ProMessage.h>
#include <ProSection.h>
#include <ProUtil.h>

/*--------------------------------------------------------------------*\
Application includes
\*--------------------------------------------------------------------*/
#include "TestError.h"
#include "TestFiletypes.h"
#include "UtilColor.h"
#include "UtilFiles.h"
#include "UtilFeats.h"
#include "UtilMessage.h"
#include "UtilTypes.h"
#include "UtilCollect.h"
#include "UtilVisit.h"
#include "TestFeattree.h"
#include "TestSect.h"
#include "UtilMenu.h"

/*--------------------------------------------------------------------*\
Application macros
\*--------------------------------------------------------------------*/

/*--------------------------------------------------------------------*\
Application data types
\*--------------------------------------------------------------------*/
#define FEAT_LIST	1
#define FEAT_INFO	2
#define MODEL_INFO	3
#define	DELETE		1
#define SUPPRESS	2
#define RESUME		3

#define USER_SELECT	0
#define USER_FEAT_NUM	1
#define USER_ALL_FEAT   2
#define USER_CLEAN	3

#define USER_ACTIVATE   0
#define USER_CANCEL	1

#define USER_BEFORE	0
#define USER_AFTER	1

typedef struct testfeatdata
{
    unsigned int action; /* Bit map of FEAT_... */
    void *data;
} ProTestFeatData;
/*--------------------------------------------------------------------*\
Application global/external data
\*--------------------------------------------------------------------*/
static int feature_number = 0;

/*====================================================================*\
    FUNCTION :	ProTestFailedFeatList()
    PURPOSE  :	Action for failed feat list
\*====================================================================*/
ProError ProTestFailedFeatList ()
{
    ProError status;
    ProMdl model;
    int *failed_feats, i, failed_feats_num;
    FILE *fp;
    char fname[PRO_NAME_SIZE] = "failed_feats.txt";
    ProPath w_fname;
    ProMdlType type;
    ProSelection *sel;
    ProModelitem model_item;
    int n_sel;
    
    status = ProMdlCurrentGet (&model);
    TEST_CALL_REPORT( "ProModelCurrentGet()", "ProTestFailedFeatList()",
        status, status != PRO_TK_NO_ERROR );
        
    status = ProMdlTypeGet (model, &type);
    TEST_CALL_REPORT( "ProMdlTypeGet()", "ProTestFailedFeatList()",
        status, status != PRO_TK_NO_ERROR );
        
    if (type == PRO_MDL_ASSEMBLY)
    {
        ProUtilMsgPrint("feat","TEST Select solid");
	
        status = ProSelect("feature", 1, NULL,
            NULL, NULL, NULL, &sel, &n_sel);
        TEST_CALL_REPORT("ProSelect()", "ProTestFailedFeatList()", status,
            status != PRO_TK_NO_ERROR);
        if (status != PRO_TK_NO_ERROR || n_sel < 1)
            return PRO_TK_NO_ERROR;
        
        status = ProSelectionModelitemGet (sel[0], &model_item);
        TEST_CALL_REPORT("ProSelectionModelitemGet()", "ProTestFailedFeatList()", status,
            status != PRO_TK_NO_ERROR);
            
        model = model_item.owner;
    }
    
    status = ProArrayAlloc (0, sizeof (int), 1, (ProArray*)&failed_feats);
    TEST_CALL_REPORT( "ProArrayAlloc()", "ProTestFailedFeatList()",
        status, status != PRO_TK_NO_ERROR );
    status = ProSolidFailedFeatsList ((ProSolid)model, &failed_feats);
    TEST_CALL_REPORT( "ProSolidFailedFeatsList()", "ProTestFailedFeatList()", 
        status, status != PRO_TK_NO_ERROR &&
        status != PRO_TK_E_NOT_FOUND);
        
    if (status == PRO_TK_NO_ERROR)
    {
        fp = fopen (fname, "w");
        
        if (fp != NULL)
        {
            fprintf (fp, "Failed features was found\n");
            fprintf (fp, "Num\t\tID\n");
        }
            
        status = ProArraySizeGet (failed_feats, &failed_feats_num);
        TEST_CALL_REPORT( "ProArraySizeGet()", "ProTestFailedFeatList()", 
            status, status != PRO_TK_NO_ERROR );
        for (i = 0; i < failed_feats_num; i++)
        {
            if (fp != NULL)
                fprintf (fp, "%d\t\t%d\n", i, failed_feats[i]);
        }
        status = ProArrayFree ((ProArray*)&failed_feats);
        TEST_CALL_REPORT( "ProArrayFree()", "ProTestFailedFeatList()", 
            status, status != PRO_TK_NO_ERROR );
            
        if (fp != NULL)
            fclose (fp);
    }
    
    ProStringToWstring (w_fname, fname);
    ProInfoWindowDisplay (w_fname, NULL, NULL);
    
    return PRO_TK_NO_ERROR;
}

/*====================================================================*\
    FUNCTION :	ProTestResolveFeatMenu()
    PURPOSE  :	Add button to resolve feat menu
\*====================================================================*/
ProError ProTestResolveFeatMenu ()
{
    int menu_id;
    ProError err;
    
    err = ProMenuFileRegister("RESOLVE FEAT","reslvft.mnu", &menu_id);
    TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestResolveFeatMenu()", 
        err, err != PRO_TK_NO_ERROR );
    err = ProMenuAuxfileRegister("RESOLVE FEAT","reslvft.aux", &menu_id);
    TEST_CALL_REPORT( "ProMenuAuxfileRegister()", "ProTestResolveFeatMenu()", 
        err, err != PRO_TK_NO_ERROR );
    err = ProMenubuttonActionSet("RESOLVE FEAT","-FailedFeatsList",
        (ProMenubuttonAction)ProTestFailedFeatList, NULL, 0);
    TEST_CALL_REPORT( "ProMenubuttonActionSet()", "ProTestResolveFeatMenu()", 
        err, err != PRO_TK_NO_ERROR );
        
    return PRO_TK_NO_ERROR;
}

/*====================================================================*\
    FUNCTION :	ProTestGeomitemAct()
    PURPOSE  :	Action function for visiting geometry items
\*====================================================================*/
ProError ProTestGeomitemAct(
    ProGeomitem *item,
    ProError instatus,
    ProAppData appdata)
{
    FILE *fp;
    char item_type[PRO_NAME_SIZE];

    fp = ((ProTestFeatData*)appdata)->data;

/*--------------------------------------------------------------------*\
    Report the type and id
\*--------------------------------------------------------------------*/
    ProUtilObjtypeStr(item->type, item_type);
    fprintf(fp,"    %-15s %2d\n", item_type, item->id);

    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
    FUNCTION :	ProTestFeatureGeom()
    PURPOSE  :	Function for reporting feature geometry items
\*====================================================================*/
int ProTestFeatureGeom(
    ProModelitem *feature,
    FILE *fp)
{
    ProError status;
    ProTestFeatData appdata;
    ProGeomitem	    *geomitems;
    int geomitems_num, i;

    appdata.data = fp;

    fprintf(fp, "Geometry items..\n");
    
    status = ProUtilCollectFeatureGeomitems (feature, PRO_TYPE_UNUSED, &geomitems);
    if (status == PRO_TK_NO_ERROR)
    {
        status = ProArraySizeGet ((ProArray)geomitems, &geomitems_num);
        TEST_CALL_REPORT( "ProArraySizeGet()", "ProTestFeatureGeom()", 
            status, status != PRO_TK_NO_ERROR );
        for (i = 0; i < geomitems_num; i++)
        {
            status = ProTestGeomitemAct (&geomitems[i],
	        PRO_TK_NO_ERROR, (ProAppData)&appdata);
        }
        status = ProArrayFree ((ProArray*)&geomitems);
        TEST_CALL_REPORT( "ProArrayFree()", "ProTestFeatureGeom()", 
            status, status != PRO_TK_NO_ERROR );
    }
    return (0);
}

/*====================================================================*\
    FUNCTION :	ProTestFeatureAct()
    PURPOSE  :	Generalized action function for visiting features
\*====================================================================*/
ProError ProTestFeatureAct(
    ProModelitem *feature,
    ProError instatus,
    ProAppData appdata)
{
    int action;
    FILE *fp;
    ProFeattype ftype;
    char ftype_str[PRO_NAME_SIZE];
    ProError status;
    ProBoolean visible, geomchk, read_on;
    ProFeatStatus stat;

/*--------------------------------------------------------------------*\
    Get the action type and file pointer.
\*--------------------------------------------------------------------*/
    action = ((ProTestFeatData*)appdata)->action;
    fp = ((ProTestFeatData*)appdata)->data;

    feature_number++;

/*--------------------------------------------------------------------*\
    Get the feature type
\*--------------------------------------------------------------------*/
    status = ProFeatureTypeGet(feature, &ftype);
    TEST_CALL_REPORT("ProFeatureTypeGet()", "ProTestFeatureAct()",
				    status, status != PRO_TK_NO_ERROR);
    ProUtilFeattypeStr(ftype, ftype_str);

/*--------------------------------------------------------------------*\
    Get the feature visibility
\*--------------------------------------------------------------------*/
    status = ProFeatureVisibilityGet(feature, &visible);
    TEST_CALL_REPORT("ProFeatureVisibilityGet()", "ProTestFeatureAct()",
					status, status != PRO_TK_NO_ERROR);

    status = ProFeatureHasGeomchks(feature, &geomchk);
    TEST_CALL_REPORT("ProFeatureHasGeomchks()", "ProTestFeatureAct()",
					status, status != PRO_TK_NO_ERROR);

    status = ProFeatureIsReadonly(feature, &read_on);
    TEST_CALL_REPORT("ProFeatureIsReadonly()", "ProTestFeatureAct()",
					status, status != PRO_TK_NO_ERROR);

    if(action == FEAT_LIST)
    {
/*--------------------------------------------------------------------*\
	Report the feature id, type and visibility as a list entry
\*--------------------------------------------------------------------*/
	fprintf(fp, "%-6d%-6d%-20s%-10s%-15s%-10s\n",
			feature_number, feature->id, ftype_str,
			visible == PRO_B_TRUE ? "" : "INTERNAL",
			geomchk == PRO_B_TRUE ? "Has geom cheks" : "",
			read_on == PRO_B_TRUE ? "Yes" : ""
			);
	return(PRO_TK_NO_ERROR);
    }
    else
    {
/*--------------------------------------------------------------------*\
	Report the feature id and type as a header 
\*--------------------------------------------------------------------*/
	fprintf(fp,"--------------------------------------\n");
	if(visible == PRO_B_TRUE)
	    fprintf(fp,"USER FEATURE         %-d\n", feature_number);
	else
	    fprintf(fp,"INTERNAL FEATURE     %-d\n", feature_number);
	fprintf(fp,"INTERNAL ID          %-d\n", feature->id);
	fprintf(fp,"TYPE                 %s\n",  ftype_str);

/*--------------------------------------------------------------------*\
	Report everything else we know about the feature
\*--------------------------------------------------------------------*/
	ProUtilFeatureDump(feature, fp);

/*--------------------------------------------------------------------*\
	Report feature geometry
\*--------------------------------------------------------------------*/
        status = ProFeatureStatusGet(feature, &stat);
        TEST_CALL_REPORT("ProFeatureStatusGet()", "ProTestFeatureAct()",
					status, status != PRO_TK_NO_ERROR);

	if ((ftype!=PRO_FEAT_COMPONENT)&&
            ((stat==PRO_FEAT_ACTIVE)||
             (stat==PRO_FEAT_UNREGENERATED)||
             (stat==PRO_FEAT_INACTIVE))) 
                ProTestFeatureGeom(feature, fp);
    }

    return(PRO_TK_NO_ERROR);
}


/*====================================================================*\
    FUNCTION : ProTestFeatureCreate
    PURPOSE  : Top-level function for creating specific feature types
\*====================================================================*/
int ProTestFeatureCreate(
    ProMdl		model,
    int			dummy )
{
    ProError		status;
    int			menu_id;
    int			action;
    ProFeattype		feat_type;

    ProError ProTestDtmpln();
    ProError ProTestFeatureExtrudeCreate();
    int ProUtilAssign();


    ProMenuFileRegister( "FEAT TYPE", "tkfeattype.mnu", &menu_id );
    ProMenubuttonActionSet("FEAT TYPE","-Dtm Plane",
	(ProMenubuttonAction)ProUtilAssign,
	(ProAppData)&feat_type, PRO_FEAT_DATUM );
    ProMenubuttonActionSet( "FEAT TYPE", "-Protrusion",
	(ProMenubuttonAction)ProUtilAssign,
	(ProAppData)&feat_type, PRO_FEAT_PROTRUSION );
    ProMenubuttonActionSet( "FEAT TYPE", "FEAT TYPE",
	(ProMenubuttonAction)ProMenuHold, NULL, 0 );

    status = ProMenuCreate( PROMENUTYPE_MAIN, "FEAT TYPE", &menu_id );
    if( status == PRO_TK_NO_ERROR )
    {
        ProMenuProcess( "FEATURE CREATION", &action );
    }

    /* Call to specific feature creation function */
    switch( feat_type )
    {
	case PRO_FEAT_DATUM:
	    ProTestDtmpln();
	    break;

	case PRO_FEAT_PROTRUSION:
	    ProTestFeatureExtrudeCreate();
	    break;
    }
	

    return 0;
}


/*====================================================================*\
    FUNCTION :	ProTestFeatureInfo()
    PURPOSE  :	List features in current model.
\*====================================================================*/
int ProTestFeatureInfo(
    ProMdl *p_model,
    int action)
{
    ProError status;
    ProTestFeatData appdata;
    ProSelection *sel;
    int n_sel, cont=1;
    char fname[PRO_NAME_SIZE];
    wchar_t w_fname[PRO_NAME_SIZE];
    FILE *fp;
    ProFeature feature;
    ProInfoWindowLocation   win_location = { 0.0, 0.0 };
    ProInfoWindowSize	    win_size = { 25, 70 };
    ProFeature *features;
    int features_num, i;
    int *failed_feats, failed_feats_num;
    

/*--------------------------------------------------------------------*\
    Get the name of the output file
\*--------------------------------------------------------------------*/
    ProTestQcrName(p_model, FEATURES, fname);

    appdata.action = action;

    feature_number = 0;

    if(action == FEAT_INFO)
    {
/*--------------------------------------------------------------------*\
	Visit selected features
\*--------------------------------------------------------------------*/
	ProUtilMsgPrint("feat","TEST Select feature");
	while(cont)
	{
	    fp = fopen(fname, "w");
	    appdata.data = fp;

/*--------------------------------------------------------------------*\
	    Select a feature
\*--------------------------------------------------------------------*/
	    status = ProSelect("feature", 1, NULL,
				NULL, NULL, NULL, &sel, &n_sel);
	    TEST_CALL_REPORT("ProSelect()", "ProTestFeatureInfo()", status,
					    status != PRO_TK_NO_ERROR);
	    if(status != PRO_TK_NO_ERROR || n_sel < 1)
		break;

/*--------------------------------------------------------------------*\
	    Get the information
\*--------------------------------------------------------------------*/
	    status = ProSelectionModelitemGet(sel[0], (ProFeature *)&feature);
	    TEST_CALL_REPORT("ProSelectionModelitemGet()",
			    "ProTestFeatureInfo()",
			    status, status != PRO_TK_NO_ERROR);

	    ProTestFeatureAct(&feature, PRO_TK_NO_ERROR, &appdata);

	    fclose(fp);

	    status = ProInfoWindowDisplay( ProStringToWstring(w_fname, fname),
					    &win_location, &win_size );
	    TEST_CALL_REPORT( "ProInfoWindowDisplay()", "ProTestFeatureInfo()",
				status, status != PRO_TK_NO_ERROR );
	}
    }
    else
    {
	fp = fopen(fname, "w");
	appdata.data = fp;

	if(action == FEAT_LIST)
	    fprintf(fp,"Num   ID    Type\n\n");

/*--------------------------------------------------------------------*\
	Visit all the features
\*--------------------------------------------------------------------*/
	status = ProArrayAlloc (0, sizeof (int), 1, (ProArray*)&failed_feats);
	TEST_CALL_REPORT( "ProArrayAlloc()", "ProTestFeatureInfo()",
			  status, status != PRO_TK_NO_ERROR );
	status = ProSolidFailedFeatsList ((ProSolid)(*p_model), &failed_feats);
	TEST_CALL_REPORT( "ProSolidFailedFeatsList()", "ProTestFeatureInfo()", 
                status, status != PRO_TK_NO_ERROR &&
                status != PRO_TK_E_NOT_FOUND);
	if (status == PRO_TK_NO_ERROR)
	{
	    fprintf (fp, "Failed features was found\n");
	    status = ProArraySizeGet (failed_feats, &failed_feats_num);
	    TEST_CALL_REPORT( "ProArraySizeGet()", "ProTestFeatureInfo()", 
                status, status != PRO_TK_NO_ERROR );
	    for (i = 0; i < failed_feats_num; i++)
 	    {
	        fprintf (fp,"%d     %d\n", i, failed_feats[i]);
	    }
	    status = ProArrayFree ((ProArray*)&failed_feats);
	    TEST_CALL_REPORT( "ProArrayFree()", "ProTestFeatureInfo()", 
			      status, status != PRO_TK_NO_ERROR );
	}
	
	status = ProUtilCollectSolidFeatures (*p_model, &features);
        if (status == PRO_TK_NO_ERROR)
        {
            status = ProArraySizeGet ((ProArray)features, &features_num);
            TEST_CALL_REPORT( "ProArraySizeGet()", "ProTestFeatureInfo()", 
                status, status != PRO_TK_NO_ERROR );
            for (i = 0; i < features_num; i++)
            {
                status = ProTestFeatureAct (&features[i],
                    PRO_TK_NO_ERROR, (ProAppData)&appdata);
            }
            status = ProArrayFree ((ProArray*)&features);
            TEST_CALL_REPORT( "ProArrayFree()", "ProTestFeatureInfo()", 
                status, status != PRO_TK_NO_ERROR );
        }
					
	fclose(fp);

	status = ProInfoWindowDisplay( ProStringToWstring(w_fname, fname),
					&win_location, &win_size );
	TEST_CALL_REPORT( "ProInfoWindowDisplay()", "ProTestFeatureInfo()",
			    status, status != PRO_TK_NO_ERROR );
    }


    return(0);
}

/*====================================================================*\
    FUNCTION :	ProTestFeatureSectionInfo()
    PURPOSE  :	Info about feature sections
\*====================================================================*/
int ProTestFeatureSectionInfo()
{
    FILE *fp;
    ProSection section;
    ProError err;
    ProPath w_path;

    err = ProUtilSectionFromFeatGet(&section);
    if (err != PRO_TK_NO_ERROR)
	return(-1);

    fp = fopen("section.inf", "w");
    ProStringToWstring(w_path, "section.inf");

    ProUtilSectionInfoGet(fp, section);

    err = ProSectionFree(&section);
    TEST_CALL_REPORT("ProSectionFree()",
		    "ProTestFeatSectionInfo()", err, err != PRO_TK_NO_ERROR );

    fclose(fp);

    err = ProInfoWindowDisplay(w_path, NULL, NULL);
    TEST_CALL_REPORT( "ProInfoWindowDisplay()", 
		    "ProTestFeatSectionInfo()", err, err != PRO_TK_NO_ERROR );

    return (0);
}

/*====================================================================*\
    FUNCTION :	ProTestFeatureKill()
    PURPOSE  :	Commands "Feature Delete" and "Suppress"
\*====================================================================*/
int ProTestFeatureKill(
    ProMdl *model,
    int action)
{
    ProError status;
    int n_sel, n_children, c;
    ProFeatureDeleteOptions delete;
    ProSelection *sel;
    ProPatternStatus pstatus;
    ProFeature children;
    int *children_ids, cont=1;
    ProSelection show;
    ProFeature feature;
    ProAsmcomppath comp_path;

/*--------------------------------------------------------------------*\
    Ask the user to select features
\*--------------------------------------------------------------------*/
    ProUtilMsgPrint("feat","TEST Select feature");
    while(cont)
    {
	status = ProSelect("feature", 1, NULL,
			    NULL, NULL, NULL, &sel, &n_sel);
	TEST_CALL_REPORT("ProSelect()", "ProTestFeatureKill()", status,
					status != PRO_TK_NO_ERROR);
	if(status != PRO_TK_NO_ERROR || n_sel < 1)
	    break;

/*--------------------------------------------------------------------*\
	Check that the selected feature is not a pattern member
\*--------------------------------------------------------------------*/
	status = ProSelectionModelitemGet(sel[0], (ProFeature *)&feature);
	TEST_CALL_REPORT("ProSelectionModelitemGet()", "ProTestFeatureKill()",
			status, status != PRO_TK_NO_ERROR);

	status = ProFeatureParamsDisplay( sel[0], PRO_ALL_PARAMS );
	TEST_CALL_REPORT("ProFeatureParamsDisplay()", "ProTestFeatureKill()",
	    status, status != PRO_TK_NO_ERROR && status != PRO_TK_E_NOT_FOUND);

	status = ProFeaturePatternStatusGet(&feature, &pstatus);
	TEST_CALL_REPORT("ProFeaturePatternStatusGet()",
	    "ProTestFeatureKill()", status, status != PRO_TK_NO_ERROR);
	if (pstatus != PRO_PATTERN_NONE)
	{
	    ProUtilMsgPrint("feat",
		"TEST That feature belongs to a pattern");
	    continue;
	}

/*--------------------------------------------------------------------*\
	Get the list of children of the selected feature
\*--------------------------------------------------------------------*/
	status = ProFeatureChildrenGet(&feature, &children_ids, &n_children);
	TEST_CALL_REPORT("ProFeatureChildrenGet()", "ProTestFeatureKill()",
					status, status != PRO_TK_NO_ERROR);

/*--------------------------------------------------------------------*\
	Highlight them in blue
\*--------------------------------------------------------------------*/
	status = ProSelectionAsmcomppathGet(sel[0], &comp_path);
	TEST_CALL_REPORT("ProSelectionAsmcomppathGet()", "ProTestFeatureKill()",
					status, status != PRO_TK_NO_ERROR);
	for(c=0; c<n_children; c++)
	{
	    status = ProFeatureInit(feature.owner, children_ids[c], &children);
            TEST_CALL_REPORT("ProFeatureInit()", "ProTestFeatureKill()",
                                        status, status != PRO_TK_NO_ERROR);
	    status = ProSelectionAlloc(&comp_path, &children, &show);
	    TEST_CALL_REPORT("ProSelectionAlloc()", "ProTestFeatureKill()",
				status, status != PRO_TK_NO_ERROR);

	    status = ProSelectionHighlight(show, MEDIUM_BLUE);
	    TEST_CALL_REPORT("ProSelectionHighlight()", "ProTestFeatureKill()",
					status, status != PRO_TK_NO_ERROR);
	}

/*--------------------------------------------------------------------*\
	Ask for confirmation to delete/suppress the children
\*--------------------------------------------------------------------*/
	delete = PRO_FEAT_DELETE_CLIP;
	if(n_children > 0)
	{
	    ProUtilMsgPrint("feat",
			"TEST Do you want to %0s the features in blue too? [yes] : ",
			action == DELETE ? "delete" : "suppress");
	    delete = ProUtilYesnoGet("yes");
	}

	if(action == DELETE)
	{
	    status = ProFeatureDelete(feature.owner, &feature.id,
					1, &delete, 1);
	    TEST_CALL_REPORT("ProFeatureDelete()", "ProTestFeatureKill()",
					status, status != PRO_TK_NO_ERROR);
	    status = ProWindowRepaint(-1);
	    TEST_CALL_REPORT("ProWindowRepaint()", "ProTestFeatureKill()",
					status, status != PRO_TK_NO_ERROR);
	}
	else
	{
	    status = ProFeatureSuppress(feature.owner, 
				       &feature.id, 1, &delete, 1);
	    TEST_CALL_REPORT("ProFeatureSuppress()", "ProTestFeatureKill()",
					status, status != PRO_TK_NO_ERROR);
	    status = ProWindowRepaint(-1);
	    TEST_CALL_REPORT("ProWindowRepaint()", "ProTestFeatureKill()",
					status, status != PRO_TK_NO_ERROR);
	}
    }

    status = ProTreetoolRefresh(*model);
    TEST_CALL_REPORT("ProTreetoolRefresh()",
		    "ProTestFeatureKill()", status, status != PRO_TK_NO_ERROR);
    return(0);
}



/*====================================================================*\
    FUNCTION :	proTestFeatureResume()
    PURPOSE  :	Command "Resume"
\*====================================================================*/
int ProTestFeatureResume( ProSolid* p_solid)
{
    ProError	    status;
    int*	    p_feat_id_array;
    ProFeatStatus*  p_status_array;
    int		    n_features;
    int		    n_suppressed;
    int		    i;
    ProFeature	    feature;
    ProBoolean	    is_incomplete;
    ProFeatureResumeOptions resume_options;


    /* Allocate ID and status arrays */
    status = ProArrayAlloc( 0, sizeof(int), 1, (ProArray *)&p_feat_id_array );
    TEST_CALL_REPORT( "ProArrayAlloc()", "ProTestFeatureResume()",
			status, status != PRO_TK_NO_ERROR );
    status = ProArrayAlloc( 0, sizeof(ProFeatStatus), 1, (ProArray *)&p_status_array );
    TEST_CALL_REPORT( "ProArrayAlloc()", "ProTestFeatureResume()",
			status, status != PRO_TK_NO_ERROR );
    if( status != PRO_TK_NO_ERROR )
	return -1;

    /* Get a list of features of the specified solid and their statuses */
    status = ProSolidFeatstatusGet( *p_solid, &p_feat_id_array, &p_status_array, 
	&n_features );
    TEST_CALL_REPORT( "ProSolidFeatstatusGet()", "ProTestFeatureResume()",
			status, status != PRO_TK_NO_ERROR );
    if( status != PRO_TK_NO_ERROR )
	return -1;

    for( i=n_features-1, n_suppressed=0; i>=0; i-- )
    {
	/* Get a handle to the feature */
	status = ProFeatureInit( *p_solid, p_feat_id_array[i], &feature );
	TEST_CALL_REPORT( "ProFeatureInit()", "ProTestFeatureResume()",
			    status, status != PRO_TK_NO_ERROR );

	/* Is feature complete? */
	is_incomplete = PRO_B_FALSE;
	status = ProFeatureIsIncomplete( &feature, &is_incomplete );
	TEST_CALL_REPORT( "ProFeatureIsIncomplete()", "ProTestFeatureResume()",
			    status, status != PRO_TK_NO_ERROR );

	/* Remove incomplete feature from the array */
	if( is_incomplete == PRO_B_TRUE || 
	    p_status_array[i] != PRO_FEAT_SUPPRESSED)
	{
	    status = ProArrayObjectRemove( (ProArray *)&p_feat_id_array, i, 1 );
	    TEST_CALL_REPORT( "ProArrayObjectRemove()", 
				"ProTestFeatureResume()",
				status, status != PRO_TK_NO_ERROR );
	}
	else
	    n_suppressed++;
    }

    /* Resume suppressed features */
    resume_options = PRO_FEAT_RESUME_INCLUDE_PARENTS;
    status = ProFeatureResume( *p_solid, p_feat_id_array, n_suppressed, 
				&resume_options, 1 );
    TEST_CALL_REPORT( "ProFeatureResume()", "ProTestFeatureResume()",
			status, status != PRO_TK_NO_ERROR );

    /* Refresh win */
    status = ProWindowRepaint(-1);
    TEST_CALL_REPORT("ProWindowRepaint()", "ProTestFeatureResume()",
				status, status != PRO_TK_NO_ERROR);

    status = ProTreetoolRefresh((ProMdl)*p_solid);
    TEST_CALL_REPORT("ProTreetoolRefresh()",
		"ProTestFeatureResume()", status, status != PRO_TK_NO_ERROR);

    /* Free pre-allocated */
    status = ProArrayFree( (ProArray *)&p_feat_id_array );
    TEST_CALL_REPORT( "ProArrayFree()", "ProTestFeatureResume()",
			status, status != PRO_TK_NO_ERROR );
    status = ProArrayFree( (ProArray *)&p_status_array );
    TEST_CALL_REPORT( "ProArrayFree()", "ProTestFeatureResume()",
			status, status != PRO_TK_NO_ERROR );
    if( status != PRO_TK_NO_ERROR )
	return -1;


    return 0;
}

/*====================================================================*\
    FUNCTION :	ProUtilFeatByNumberInit()
    PURPOSE  :	Set Read Only status for feature
\*====================================================================*/
ProError ProUtilFeatByNumberInit(
    ProSolid solid,
    int feature_num,
    ProFeature *p_feature)
{
    ProError err, status = PRO_TK_GENERAL_ERROR;
    int *p_feat_id_array, n_features;
    ProFeatStatus *p_status_array;
    int feature_count; 
    int actual_feat_number = 0; 
    ProBoolean feature_found = PRO_B_FALSE;


    /* Allocate ID and err arrays */
    err = ProArrayAlloc( 0, sizeof(int), 1, (ProArray *)&p_feat_id_array );
    TEST_CALL_REPORT( "ProArrayAlloc()", "ProUtilFeatByNumberInit()",
					    err, err != PRO_TK_NO_ERROR);
    if( err != PRO_TK_NO_ERROR )
	return (PRO_TK_GENERAL_ERROR);

    err = ProArrayAlloc( 0, sizeof(ProFeatStatus), 1, 
	(ProArray *)&p_status_array );
    TEST_CALL_REPORT( "ProArrayAlloc()", "ProUtilFeatByNumberInit()",
					    err, err != PRO_TK_NO_ERROR);
    if( err != PRO_TK_NO_ERROR )
	return (PRO_TK_GENERAL_ERROR);

    /* Get a list of features of the specified solid and their erres */
    err = ProSolidFeatstatusGet(solid, &p_feat_id_array, &p_status_array,
	&n_features );
    TEST_CALL_REPORT( "ProSolidFeatstatusGet()", "ProUtilFeatByNumberInit()",
			err, err != PRO_TK_NO_ERROR );

    /* feature_num--; */ 

    if (err == PRO_TK_NO_ERROR && ( n_features > (feature_num-1) ) )
    {
	for ( feature_count = 0;  feature_count < n_features;  feature_count++ ) 
    	{ 
    	if ( p_status_array[feature_count] == PRO_FEAT_ACTIVE ) actual_feat_number++; 
    	if ( actual_feat_number == feature_num ) 
         { 
         feature_found = PRO_B_TRUE; 
         break; 
         } 
    	} 

    if ( feature_found ) 
        { 
        status = ProFeatureInit(solid, p_feat_id_array[feature_count],p_feature); 

        err = ProArrayFree((ProArray*)&p_feat_id_array );
        TEST_CALL_REPORT( "ProArrayFree()", "ProUtilFeatByNumberInit()",
					    err, err != PRO_TK_NO_ERROR);

        err = ProArrayFree((ProArray*)&p_status_array );
        TEST_CALL_REPORT( "ProArrayFree()", "ProUtilFeatByNumberInit()",
					    err, err != PRO_TK_NO_ERROR);
	return ( status ); 
	/* Returns for a successful call from here */ 
        } 
        else 
        { 
        return PRO_TK_E_NOT_FOUND; 

		/* Includes the cases for 
  		1.The input value of the feature_number being greater than the number of
     		ACTIVE features available in the model , but less than the max id 
		*/ 
        } 
    } 
    else 
    { 
    return PRO_TK_BAD_CONTEXT; 
		/* Includes the cases for 
  		1.Non-successful call to ProSolidFeatstatusGet and 
  		2.The input value of the feature number being greater than the number of id's collected 
		*/ 
    }


}


/*====================================================================*\
    FUNCTION :	ProUtilSolidLastFeatGet()
    PURPOSE  :	Set Read Only status for feature
\*====================================================================*/
ProError ProUtilSolidLastFeatGet(
    ProSolid solid,
    int *last_feature)
{
    ProError err, status;
    int *p_feat_id_array, n_features;
    ProFeatStatus *p_status_array;

    /* Allocate ID and err arrays */
    err = ProArrayAlloc( 0, sizeof(int), 1, (ProArray *)&p_feat_id_array );
    TEST_CALL_REPORT( "ProArrayAlloc()", "ProUtilSolidLastFeatGet()",
					    err, err != PRO_TK_NO_ERROR);
    if( err != PRO_TK_NO_ERROR )
	return (PRO_TK_GENERAL_ERROR);

    err = ProArrayAlloc( 0, sizeof(ProFeatStatus), 1, 
	(ProArray *)&p_status_array );
    TEST_CALL_REPORT( "ProArrayAlloc()", "ProUtilSolidLastFeatGet()",
					    err, err != PRO_TK_NO_ERROR);
    if( err != PRO_TK_NO_ERROR )
	return (PRO_TK_GENERAL_ERROR);

    /* Get a list of features of the specified solid and their erres */
    err = ProSolidFeatstatusGet(solid, &p_feat_id_array, &p_status_array,
	&n_features );
    TEST_CALL_REPORT( "ProSolidFeatstatusGet()", "ProUtilSolidLastFeatGet()",
			err, err != PRO_TK_NO_ERROR );

    status = err;

    err = ProArrayFree((ProArray*)&p_feat_id_array );
    TEST_CALL_REPORT( "ProArrayFree()", "ProUtilSolidLastFeatGet()",
					    err, err != PRO_TK_NO_ERROR);
    err = ProArrayFree((ProArray*)&p_status_array );
    TEST_CALL_REPORT( "ProArrayFree()", "ProUtilSolidLastFeatGet()",
					    err, err != PRO_TK_NO_ERROR);

    if (status == PRO_TK_NO_ERROR)
	last_feature[0] = n_features;
    else
	last_feature[0] = 0;

    return(status);
}

/*====================================================================*\
    FUNCTION :	ProTestFeatureReadOnlySet()
    PURPOSE  :	Set Read Only status for feature
\*====================================================================*/
int ProTestFeatureReadOnlySet(
    ProSolid *p_solid,
    int option)
{
    ProError err;
    ProSelection *sel;
    int n_sel, max_feat, irange[2], i, ok=0;
    ProFeature feature;

    switch(option)
    {
	case USER_SELECT:
	    ProUtilMsgPrint("feat","TEST Select feature");
	    err = ProSelect("feature", 1, NULL, NULL, NULL, NULL, &sel, &n_sel);
	    if (err != PRO_TK_NO_ERROR || n_sel != 1)
		break;

	    err = ProSelectionModelitemGet(sel[0], (ProFeature *)&feature);
	    TEST_CALL_REPORT("ProSelectionModelitemGet()",
		"ProTestFeatureReadOnlySet()", err, err != PRO_TK_NO_ERROR);

	    ok = 1;
	    break;
	case USER_FEAT_NUM:
	    err = ProUtilSolidLastFeatGet(p_solid[0], &max_feat);
	    if (err != PRO_TK_NO_ERROR || max_feat <=0)
		break;

	    ProUtilMsgPrint("feat",
		"TEST Enter feature regeneration number (1 - %0d) [QUIT]:",
		&max_feat);
	    irange[0] = 1;
	    irange[1] = max_feat;
	    err = ProMessageIntegerRead(irange, &i);
	    if (err != PRO_TK_NO_ERROR)
		break;

	    err = ProUtilFeatByNumberInit(p_solid[0], i, &feature);
	    if (err != PRO_TK_NO_ERROR)
		break;

	    ok = 1;
	    break;
	case USER_ALL_FEAT:
	    err = ProUtilSolidLastFeatGet(p_solid[0], &max_feat);
	    if (err != PRO_TK_NO_ERROR || max_feat <=0)
		break;

	    err = ProUtilFeatByNumberInit(p_solid[0], max_feat, &feature);
	    if (err != PRO_TK_NO_ERROR)
		break;

	    ok = 1;
	    break;
	case USER_CLEAN:
	    err = ProFeatureReadonlyUnset(p_solid[0]);
	    TEST_CALL_REPORT("ProFeatureReadonlyUnset()",
		"ProTestFeatureReadOnlySet()", err, err != PRO_TK_NO_ERROR);

	    ProUtilMsgPrint("feat", "TEST Read-only setting has been cleaned.");
	    ok = 2;
	    break;
	default:
	    printf("Error: ProTestFeatureReadOnlySet unknown action\n");
	    break;
    }

    if (ok == 1)
    {
	err = ProFeatureReadonlySet(&feature);
	TEST_CALL_REPORT("ProFeatureReadonlySet()",
		"ProTestFeatureReadOnlySet()", err, err != PRO_TK_NO_ERROR);

	ProUtilMsgPrint("feat", 
	    "TEST Features up to and feat ID %0d are now read only.", 
	    &feature.id);
    }

    if (ok > 0)
    {
	err = ProMenuDelete();
	TEST_CALL_REPORT("ProMenuDelete()",
		    "ProTestFeatureReadOnlySet()", err, err != PRO_TK_NO_ERROR);
    }
    return(0);
}

/*====================================================================*\
    FUNCTION :	ProTestFeatureReadOnly()
    PURPOSE  :	Show tkR-only feat menu 
\*====================================================================*/
int ProTestFeatureReadOnly(ProSolid *p_solid)
{
    ProError status;
    int menu_id, action;

    status = ProMenuFileRegister("tkR-only feat", "tkronlyfeat.mnu", &menu_id);
    TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestFeatureReadOnly()", 
				    status, status != PRO_TK_NO_ERROR );

    ProMenubuttonActionSet("tkR-only feat", "Select", 
	(ProMenubuttonAction)ProTestFeatureReadOnlySet, 
	p_solid, USER_SELECT);
    ProMenubuttonActionSet("tkR-only feat", "Feat Num", 
	(ProMenubuttonAction)ProTestFeatureReadOnlySet, 
	p_solid, USER_FEAT_NUM);
    ProMenubuttonActionSet("tkR-only feat", "All Feat", 
	(ProMenubuttonAction)ProTestFeatureReadOnlySet, 
	p_solid, USER_ALL_FEAT);
    ProMenubuttonActionSet("tkR-only feat", "Clean", 
	(ProMenubuttonAction)ProTestFeatureReadOnlySet, 
	p_solid, USER_CLEAN);
    ProMenubuttonActionSet("tkR-only feat", "Done/Return", 
	(ProMenubuttonAction)ProMenuDelete, NULL, 0); 
    ProMenubuttonActionSet("tkR-only feat", "tkR-only feat", 
	(ProMenubuttonAction)ProMenuDelete, NULL, 0); 

    ProMenuPush();
    ProMenuCreate(PROMENUTYPE_MAIN, "tkR-only feat", &menu_id);
    status = ProMenuCommandPush("Select");
    TEST_CALL_REPORT( "ProMenuCommandPush()", "ProTestFeatureReadOnly()", 
				    status, status != PRO_TK_NO_ERROR );
    ProMenuProcess("tkR-only feat", &action);
    ProMenuPop();

    return (0);
}

/*====================================================================*\
    FUNCTION :	ProTestFeatureInsertModeSet
    PURPOSE  :	Set/Cancel Insert mode
\*====================================================================*/
int ProTestFeatureInsertModeSet(
    ProSolid *p_solid,
    int option)
{
    ProError err;
    ProSelection *sel;
    int n_sel, max_feat, feat_num, ok = 0;
    ProBoolean resume;
    ProFeature feature;

    switch (option)
    {
	case USER_ACTIVATE:
	    do
	    {
	    ProUtilMsgPrint("feat", "Test Select a feature to insert after.");
	    err = ProSelect("feature", 1, NULL, NULL, NULL, NULL, &sel, &n_sel);
	    if (err != PRO_TK_NO_ERROR || n_sel != 1)
		break;

	    err = ProSelectionModelitemGet(sel[0], (ProFeature *)&feature);
	    TEST_CALL_REPORT("ProSelectionModelitemGet()",
		"ProTestFeatureInsertModeSet()", err, err != PRO_TK_NO_ERROR);
	    
	    err = ProUtilSolidLastFeatGet(p_solid[0], &max_feat);
	    if (err != PRO_TK_NO_ERROR || max_feat <=0)
		break;

	    err = ProFeatureNumberGet(&feature, &feat_num);
	    TEST_CALL_REPORT("ProFeatureNumberGet()",
		"ProTestFeatureInsertModeSet()", err, err != PRO_TK_NO_ERROR);

	    if (err != PRO_TK_NO_ERROR)
		break;

	    if (feat_num == max_feat)
	    {
		ProUtilMsgPrint("feat", "Test Can not select last feature.");
		continue;
	    }

	    err = ProFeatureInsertModeActivate(&feature);
	    TEST_CALL_REPORT("ProFeatureInsertModeActivate()",
		"ProTestFeatureInsertModeSet()", err, err != PRO_TK_NO_ERROR);

	    ok = 1;
	    } while (ok ==0);
	    break;
	case USER_CANCEL:
	    ProUtilMsgPrint("feat", "TEST Resume features that were "
		"suppressed when activating insert mode? [Y]:");
	    resume = (ProBoolean)ProUtilYesnoGet("yes");

	    err = ProInsertModeCancel(p_solid[0], resume);
	    TEST_CALL_REPORT("ProInsertModeCancel()",
		"ProTestFeatureInsertModeSet()", err, err != PRO_TK_NO_ERROR);

	    ProUtilMsgPrint("feat", "TEST Insert mode has been canceled.");
	    ok = 1;
	    break;
    }

    if (ok == 1)
    {
	err = ProTreetoolRefresh((ProMdl)*p_solid);
	TEST_CALL_REPORT("ProTreetoolRefresh()",
	    "ProTestFeatureInsertModeSet()", err, err != PRO_TK_NO_ERROR);

	ProMenuDelete();
    }
    return (0);
}

/*====================================================================*\
    FUNCTION :	ProTestFeatureInsertMode
    PURPOSE  :	Show TkIns Mode Menu
\*====================================================================*/
int ProTestFeatureInsertMode(
    ProSolid *p_solid)
{
    ProError status;
    int menu_id, action;
    ProBoolean bool;

    status = ProMenuFileRegister("tkinsert mode", "tkinsertmode.mnu", &menu_id);
    TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestFeatureInsertMode()", 
				    status, status != PRO_TK_NO_ERROR );

    ProMenubuttonActionSet("tkinsert mode", "Activate", 
	(ProMenubuttonAction)ProTestFeatureInsertModeSet, 
	p_solid, USER_ACTIVATE);
    ProMenubuttonActionSet("tkinsert mode", "Cancel", 
	(ProMenubuttonAction)ProTestFeatureInsertModeSet, 
	p_solid, USER_CANCEL);
    ProMenubuttonActionSet("tkinsert mode", "Return", 
	(ProMenubuttonAction)ProMenuDelete, NULL, 0); 
    ProMenubuttonActionSet("tkinsert mode", "tkinsert mode", 
	(ProMenubuttonAction)ProMenuDelete, NULL, 0); 

    status = ProInsertModeIsActive(p_solid[0], &bool);
    TEST_CALL_REPORT( "ProInsertModeIsActive()", "ProTestFeatureInsertMode()", 
				    status, status != PRO_TK_NO_ERROR );

    ProMenuPush();
    ProMenuCreate(PROMENUTYPE_MAIN, "tkinsert mode", &menu_id);
    if (bool == PRO_B_FALSE)
    {
	status = ProMenubuttonActivate("tkinsert mode", "Activate");
	TEST_CALL_REPORT("ProMenubuttonActivate()",
	    "ProTestFeatureInsertMode()", status, status != PRO_TK_NO_ERROR );
	status = ProMenubuttonDeactivate("tkinsert mode", "Cancel");
	TEST_CALL_REPORT("ProMenubuttonDeactivate()",
	    "ProTestFeatureInsertMode()", status, status != PRO_TK_NO_ERROR );
    }
    else
    {
	status = ProMenubuttonActivate("tkinsert mode", "Cancel");
	TEST_CALL_REPORT("ProMenubuttonActivate()",
	    "ProTestFeatureInsertMode()", status, status != PRO_TK_NO_ERROR );
	status = ProMenubuttonDeactivate("tkinsert mode", "Activate");
	TEST_CALL_REPORT("ProMenubuttonDeactivate()",
	    "ProTestFeatureInsertMode()", status, status != PRO_TK_NO_ERROR );
    }
    ProMenuProcess("tkinsert mode", &action);
    ProMenuPop();

    return (0);
}

/*====================================================================*\
    FUNCTION :	ProUtilSortedIntArrayObjectAdd
    PURPOSE  :	Add int value to sorted array of int
\*====================================================================*/
ProError ProUtilSortedIntArrayObjectAdd(
    int **p_array,
    int new_value)
{
    ProError err;
    int i, size;

    err = ProArraySizeGet((ProArray)p_array[0], &size);
    TEST_CALL_REPORT("ProArraySizeGet()",
	    "ProUtilSortedIntArrayObjectAdd()", err, err != PRO_TK_NO_ERROR );

    for (i=0; i<size && new_value>p_array[0][i]; i++);
    if (i>=size || new_value<p_array[0][i])
    {
	err = ProArrayObjectAdd((ProArray*)p_array, i, 1, &new_value);
	TEST_CALL_REPORT("ProArrayObjectAdd()",
	    "ProUtilSortedIntArrayObjectAdd()", err, err != PRO_TK_NO_ERROR );
    }

    return (err);
}

/*====================================================================*\
    FUNCTION :	ProUtilReorderPreFilter
    PURPOSE  :	filter function to reorder feats
\*====================================================================*/
ProError ProUtilReorderPreFilter(
    ProSelection sel,
    Pro3dPnt	pnt,
    ProMatrix trans,
    char *option,
    int level,
    ProAppData	appdata)
{
    ProSolid *p_solid = (ProSolid*)appdata;
    ProName w_name;
    ProError err;
    ProModelitem modelitem;

    TEST_CALL_REPORT("ProSelectionPreFilter()", 
					   "ProUtilReorderPreFilter()", 0, 0);

    err = ProSelectionModelitemGet(sel, &modelitem);
    TEST_CALL_REPORT("ProSelectionModelitemGet()",
		"ProUtilReorderPreFilter()", err, err != PRO_TK_NO_ERROR );
    if (modelitem.owner != (ProMdl)p_solid[0])
    {
	err = ProMdlNameGet(modelitem.owner, w_name);
	TEST_CALL_REPORT("ProSelectionModelitemGet()",
		"ProUtilReorderPreFilter()", err, err != PRO_TK_NO_ERROR );
	ProUtilMsgPrint("feat", "Test Select from %0w please.", w_name);
	return (PRO_TK_CONTINUE);
    }

    return (PRO_TK_NO_ERROR);
}

/*====================================================================*\
    FUNCTION :	ProTestFeatureReorder
    PURPOSE  :	Reorder features
\*====================================================================*/
int ProTestFeatureReorder(
    ProSolid *p_solid)
{    
    ProError err;
    int *feat_arr = NULL, n_sel, stop = 0, i, ok=0;
    int feat_num, *p_feat_id_array = NULL;
    ProSelection *sel;
    ProModelitem modelitem;
    ProSelFunctions filter;
    ProFeatStatus *p_status_array = NULL;

    ProUtilMsgPrint("feat", "Test Select features to reorder. Multiple features"
	" must be in consecutive order.");

    memset(&filter, '\0', sizeof(filter));
    filter.pre_filter = ProUtilReorderPreFilter;
    filter.app_data = (ProAppData)p_solid;

    do
    {

    err = ProSelect("feature", -1, NULL, &filter, NULL, NULL, &sel, &n_sel);
    if (err != PRO_TK_NO_ERROR)
	break;

    /* Sort features array by number */
    ProArrayAlloc(0, sizeof(int), 1, (ProArray*)&feat_arr);
    for (i=0; i<n_sel; i++)
    {
	err = ProSelectionModelitemGet(sel[i], &modelitem);
	TEST_CALL_REPORT("ProSelectionModelitemGet()",
	    "ProTestFeatureReorder()", err, err != PRO_TK_NO_ERROR);

	err = ProFeatureNumberGet((ProFeature*)&modelitem, &feat_num);
	if (err != PRO_TK_NO_ERROR)
	    continue;    

	ProUtilSortedIntArrayObjectAdd(&feat_arr, feat_num);
    }
    
    ProUtilMsgPrint("feat", "Test Select a feature to insert after.");
    err = ProSelect("feature", 1, NULL, &filter, NULL, NULL, &sel, &n_sel);
    if (err != PRO_TK_NO_ERROR || n_sel != 1)
	break;

    err = ProSelectionModelitemGet(sel[0], &modelitem);
    TEST_CALL_REPORT("ProSelectionModelitemGet()",
		    "ProTestFeatureReorder()", err, err != PRO_TK_NO_ERROR);

    err = ProFeatureNumberGet((ProFeature*)&modelitem, &feat_num);
    if (err != PRO_TK_NO_ERROR)
	break;    

    feat_num++;
    ProArraySizeGet((ProArray)feat_arr, &n_sel);

    /* Show possibility to reorder features in two modes */
    err = ProArrayAlloc( 0, sizeof(int), 1, (ProArray *)&p_feat_id_array );
    TEST_CALL_REPORT("ProArrayAlloc()",
		"ProTestFeatureReorder()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	break;

    for (i=0; i<n_sel; i++)
    {
	err = ProUtilFeatByNumberInit(p_solid[0], feat_arr[i],
	    (ProFeature*)&modelitem);
    	TEST_CALL_REPORT("ProUtilFeatByNumberInit()",
		"ProTestFeatureReorder()", err, err != PRO_TK_NO_ERROR);

	ProArrayObjectAdd((ProArray*)&p_feat_id_array, PRO_VALUE_UNUSED,
	    1, &modelitem.id);
    }

    err = ProFeatureReorder(p_solid[0], p_feat_id_array, n_sel, feat_num);
    TEST_CALL_REPORT("ProFeatureReorder()",
		"ProTestFeatureReorder()", err, err != PRO_TK_NO_ERROR);
    
    if (err != PRO_TK_NO_ERROR)
	break;

    ok =1;

    } while (stop);
    
    if (feat_arr != NULL)
    {
	err = ProArrayFree((ProArray*)&feat_arr);
	TEST_CALL_REPORT( "ProArrayFree()",
		    "ProTestFeatureReorder()", err, err != PRO_TK_NO_ERROR);
    }
    if (p_feat_id_array != NULL)
    {
	err = ProArrayFree((ProArray*)&p_feat_id_array);
	TEST_CALL_REPORT( "ProArrayFree()",
		    "ProTestFeatureReorder()", err, err != PRO_TK_NO_ERROR);
    }
    if (p_status_array != NULL)
    {
	err = ProArrayFree((ProArray*)&p_status_array);
	TEST_CALL_REPORT( "ProArrayFree()",
		    "ProTestFeatureReorder()", err, err != PRO_TK_NO_ERROR);
    }
    if (ok == 1)
    {
	err = ProTreetoolRefresh((ProMdl)*p_solid);
	TEST_CALL_REPORT("ProTreetoolRefresh()",
		    "ProTestFeatureReorder()", err, err != PRO_TK_NO_ERROR);
    }
    return (0);
}

/*====================================================================*\
FUNCTION : ProTestFeatTreeInfoGet
PURPOSE  : The main function for getting the feature tree definition
\*====================================================================*/
int ProTestFeatTreeInfoGet()
{
    ProError err;
    ProFeature feature;
    ProElement elemtree;
    ProSelection *p_sel;
    int n_sel;

    ProUtilMsgPrint("feat", "TEST Select feature");    
    
    err = ProSelect("feature", 1, NULL, NULL, NULL, NULL, &p_sel, &n_sel);
    if (err != PRO_TK_NO_ERROR)
	return (0);

    err = ProSelectionModelitemGet(p_sel[0], (ProModelitem *)&feature);
    TEST_CALL_REPORT("ProSelectionModelitemGet()",
		    "ProTestFeatTreeInfoGet", err , err != PRO_TK_NO_ERROR);

    err = ProFeatureElemtreeCreate(&feature, &elemtree );
    TEST_CALL_REPORT("ProFeatureElemtreeCreate()","ProTestFeatTreeInfoGet",
                            err , err != PRO_TK_NO_ERROR);

    if(err == PRO_TK_INVALID_TYPE)
      ProUtilMsgPrint("gen","TEST %0s",
			    "Elem Tree isn't supported for this feature");
    else if(err != PRO_TK_NO_ERROR)
	    ProUtilMsgPrint("gen","TEST %0s","Error getting the elem tree");
      else
         ProUtilShowTreeInInfo(elemtree);
 
    return(PRO_TK_NO_ERROR);
}

/*====================================================================*\
FUNCTION : ProTestLocalGroupCreate
PURPOSE  : Function to test local group
\*====================================================================*/
int ProTestLocalGroupCreate(    
    ProSolid *p_solid)
{
    ProError err;
    ProName  w_name;
    int *feat_arr = NULL, n_sel, stop = 0, i, *p_feat_id_array, feat_num;
    ProSelection *sel;
    ProModelitem modelitem;
    ProGroup group;

    ProUtilMsgPrint("feat", "Test Enter group name [QUIT]:");
    if (ProMessageStringRead(PRO_NAME_SIZE, w_name) != PRO_TK_NO_ERROR)
	return (-1);

    ProUtilMsgPrint("feat", "Test Select features to form a group.");

    do
    {

    err = ProSelect("feature", -1, NULL, NULL, NULL, NULL, &sel, &n_sel);
    if (err != PRO_TK_NO_ERROR)
	break;

    /* Sort features array by number */
    ProArrayAlloc(0, sizeof(int), 1, (ProArray*)&feat_arr);
    for (i=0; i<n_sel; i++)
    {
	err = ProSelectionModelitemGet(sel[i], &modelitem);
	TEST_CALL_REPORT("ProSelectionModelitemGet()",
		    "ProTestLocalGroupCreate()", err, err != PRO_TK_NO_ERROR);

	err = ProFeatureNumberGet((ProFeature*)&modelitem, &feat_num);
	if (err != PRO_TK_NO_ERROR)
	    continue;    

	ProUtilSortedIntArrayObjectAdd(&feat_arr, feat_num);
    }

    err = ProArraySizeGet((ProArray)feat_arr, &n_sel);
    TEST_CALL_REPORT("ProArraySizeGet()",
		    "ProTestLocalGroupCreate()", err, err != PRO_TK_NO_ERROR);
    
    err = ProArrayAlloc( 0, sizeof(int), 1, (ProArray *)&p_feat_id_array );
    TEST_CALL_REPORT("ProArrayAlloc()",
		    "ProTestLocalGroupCreate()", err, err != PRO_TK_NO_ERROR);
    if (err != PRO_TK_NO_ERROR)
	break;

    for (i=0; i<n_sel; i++)
    {
	err = ProUtilFeatByNumberInit(p_solid[0], feat_arr[i],
	    (ProFeature*)&modelitem);

	ProArrayObjectAdd((ProArray*)&p_feat_id_array, PRO_VALUE_UNUSED,
	    1, &modelitem.id);
    }

    err = ProLocalGroupCreate(modelitem.owner, p_feat_id_array, n_sel, w_name,
	&group);
    TEST_CALL_REPORT("ProLocalGroupCreate()",
		"ProTestLocalGroupCreate()", err, err != PRO_TK_NO_ERROR);
    
    err = ProArrayFree((ProArray*)&feat_arr);
    TEST_CALL_REPORT("ProArrayFree()",
		    "ProTestLocalGroupCreate()", err, err != PRO_TK_NO_ERROR);

    err = ProArrayFree((ProArray*)&p_feat_id_array);
    TEST_CALL_REPORT("ProArrayFree()",
		    "ProTestLocalGroupCreate()", err, err != PRO_TK_NO_ERROR);

    } while (stop);
    
    err = ProTreetoolRefresh(modelitem.owner);
    TEST_CALL_REPORT("ProTreetoolRefresh()",
		    "ProTestLocalGroupCreate()", err, err != PRO_TK_NO_ERROR);
    ProMenuDelete();
    return (0);
}



/*====================================================================*\
FUNCTION : ProUtilFeatPatternClass
PURPOSE  : Return the pattern class the feature belongs to
\*====================================================================*/
ProError ProUtilFeatPatternClass(
    ProFeature *feature,
    ProPatternClass *pat_class)
{
    ProGrppatternStatus grpat_status;
    ProPatternStatus	pat_status;
    ProError err;
    
    err = ProFeaturePatternStatusGet(feature, &pat_status);
    TEST_CALL_REPORT("ProFeaturePatternStatusGet()",
		"ProUtilFeatPatternClass()", err , err != PRO_TK_NO_ERROR);

    err = ProFeatureGrppatternStatusGet(feature, &grpat_status);
    TEST_CALL_REPORT("ProFeatureGrppatternStatusGet()",
		"ProUtilFeatPatternClass()", err , err != PRO_TK_NO_ERROR);

    if (pat_status == PRO_PATTERN_LEADER || pat_status == PRO_PATTERN_MEMBER)
    {
	if (grpat_status == PRO_GRP_PATTERN_LEADER || 
	    grpat_status == PRO_GRP_PATTERN_MEMBER)
	{
	    /* Both Patterns Possible */
	    err = ProMenuFileRegister("tkpat type", "tkpattype.mnu", NULL);
	    err = ProMenubuttonActionSet("tkpat type", "Pattern",
		ProUtilMenubuttonDeleteWithStatus, NULL, PRO_FEAT_PATTERN);
	    err = ProMenubuttonActionSet("tkpat type", "Group Pattern",
		ProUtilMenubuttonDeleteWithStatus, NULL, PRO_GROUP_PATTERN);
	    err = ProMenubuttonActionSet("tkpat type", "tkpat type",
		(ProMenubuttonAction)ProMenuHold, NULL, 0);

	    err = ProMenuCreate(PROMENUTYPE_MAIN, "tkpattype", NULL);
	    err = ProMenuProcess("tkpattype", (int*)pat_class);
	} 
	else
	    pat_class[0] = PRO_FEAT_PATTERN;  
    }
    else
    {
	if (grpat_status == PRO_GRP_PATTERN_LEADER || 
	    grpat_status == PRO_GRP_PATTERN_MEMBER)
	    pat_class[0] = PRO_GROUP_PATTERN;  
	else
	    return (PRO_TK_E_NOT_FOUND);
    }
    return (PRO_TK_NO_ERROR);
}


/*====================================================================*\
FUNCTION : ProTestPattern
PURPOSE  : Function to test pattern functions
\*====================================================================*/
int ProTestPattern(    
    ProSolid *p_solid)
{
    ProError err;
    ProFeature feature;
    ProPatternClass pat_class;
    ProPattern pattern;
    ProElement elemtree;
    ProSelection *p_sel;
    int n_sel;

    ProUtilMsgPrint("feat", "TEST Select feature");    
    
    err = ProSelect("feature", 1, NULL, NULL, NULL, NULL, &p_sel, &n_sel);
    if (err != PRO_TK_NO_ERROR || n_sel != 1)
	return (0);
    err = ProSelectionModelitemGet(p_sel[0],
                          (ProModelitem *)&feature);
    TEST_CALL_REPORT("ProSelectionModelitemGet()",
		"ProTestPatternTreeInfoGet", err , err != PRO_TK_NO_ERROR);


    err = ProUtilFeatPatternClass(&feature, &pat_class);
    if (err != PRO_TK_NO_ERROR)
    {
	ProUtilMsgPrint("gen","TEST %0s",
	    "This feature does not belong to the pattern.");
    }
    else
    {
        /* Get the leader feature */
        err = ProFeaturePatternGet( &feature, pat_class, &pattern );
        TEST_CALL_REPORT("ProFeaturePatternGet()",
                "ProTestPattern", err , err != PRO_TK_NO_ERROR);
        err = ProPatternLeaderGet( &pattern, &feature );
        TEST_CALL_REPORT("ProPatternLeaderGet",
                "ProTestPattern", err , err != PRO_TK_NO_ERROR);

        err = ProPatternElemtreeCreate(&feature, pat_class, &elemtree );
        TEST_CALL_REPORT("ProPatternElemtreeCreate()",
                "ProTestPattern", err , err != PRO_TK_NO_ERROR);
	
	if(err != PRO_TK_NO_ERROR)
	    ProUtilMsgPrint("feat", "TEST %0s", "Error getting the elem tree");
	else
	{
	    ProUtilShowTreeInInfo(elemtree);

	    err = ProElementFree(&elemtree);
	    TEST_CALL_REPORT("ProElementFree()",
                "ProTestPattern", err , err != PRO_TK_NO_ERROR);
	}
    }

    return(PRO_TK_NO_ERROR);
}



/*====================================================================*\
    FUNCTION :	ProTestFeatures()
    PURPOSE  :	Test code for features
\*====================================================================*/
int ProTestFeatures(
    ProMdl *model)
{
    ProError		status;
    int			menu_id;    /* The identifier of the created menu */
    int			action;

    /* Load menu from file */
    status = ProMenuFileRegister( "TkFeats", "tkfeats.mnu", &menu_id );
    TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestFeatures()", 
			status, status != PRO_TK_NO_ERROR );

    ProMenubuttonActionSet( "TkFeats", "-Create",
        (ProMenubuttonAction)ProTestFeatureCreate, model, 0 );
    ProMenubuttonActionSet( "TkFeats", "-Tree Info", 
	(ProMenubuttonAction)ProTestFeatTreeInfoGet, model, 0 );
    ProMenubuttonActionSet( "TkFeats", "-Model Info", 
	(ProMenubuttonAction)ProTestFeatureInfo, model, MODEL_INFO );
    ProMenubuttonActionSet( "TkFeats", "-Feat Info", 
	(ProMenubuttonAction)ProTestFeatureInfo, model, FEAT_INFO );
    ProMenubuttonActionSet( "TkFeats", "-Feat List", 
	(ProMenubuttonAction)ProTestFeatureInfo, model, FEAT_LIST );
    ProMenubuttonActionSet( "TkFeats", "-Sect Info",
	(ProMenubuttonAction)ProTestFeatureSectionInfo, model, 0 );
    ProMenubuttonActionSet( "TkFeats", "-Delete", 
	(ProMenubuttonAction)ProTestFeatureKill, model, DELETE );
    ProMenubuttonActionSet( "TkFeats", "-Pattern", 
	(ProMenubuttonAction)ProTestPattern, model, 0);
    ProMenubuttonActionSet( "TkFeats", "-Group", 
	(ProMenubuttonAction)ProTestLocalGroupCreate, model, 0 );
    ProMenubuttonActionSet( "TkFeats", "-Suppress", 
	(ProMenubuttonAction)ProTestFeatureKill, model, SUPPRESS );
    ProMenubuttonActionSet( "TkFeats", "-Resume", 
	(ProMenubuttonAction)ProTestFeatureResume, model, RESUME );
    ProMenubuttonActionSet( "TkFeats", "-Reorder", 
	(ProMenubuttonAction)ProTestFeatureReorder, model, 0);
    ProMenubuttonActionSet( "TkFeats", "-Read Only", 
	(ProMenubuttonAction)ProTestFeatureReadOnly, model, 0);
    ProMenubuttonActionSet( "TkFeats", "-Insert mode", 
	(ProMenubuttonAction)ProTestFeatureInsertMode, model, 0);
    ProMenubuttonActionSet( "TkFeats", "-Done TkFeats", 
	(ProMenubuttonAction)ProMenuDelete, NULL, 0 );
    ProMenubuttonActionSet( "TkFeats", "TkFeats", 
	(ProMenubuttonAction)ProMenuDelete, NULL, 0 );

    /* Run menu TkFeats */
    status = ProMenuCreate( PROMENUTYPE_MAIN, "TkFeats", &menu_id );
    TEST_CALL_REPORT( "ProMenuCreate()", "ProTestFeatures()", 
			status, status != PRO_TK_NO_ERROR );
    if( status == PRO_TK_NO_ERROR )
    {
	status = ProMenuProcess( "TkFeats", &action );
	TEST_CALL_REPORT( "ProMenuProcess()", "ProTestFeatures()", 
			    status, status != PRO_TK_NO_ERROR );
    }

    return(0);
}

#undef FEAT_LIST
#undef FEAT_INFO
#undef MODEL_INFO
#undef	DELETE
#undef SUPPRESS
#undef RESUME

#undef USER_SELECT
#undef USER_FEAT_NUM
#undef USER_ALL_FEAT
#undef USER_CLEAN

#undef USER_ACTIVATE
#undef USER_CANCEL

#undef USER_BEFORE
#undef USER_AFTER