/*
	Copyright (c) 2019 PTC Inc. and/or Its Subsidiary Companies. All Rights Reserved.
*/

#include <ProToolkit.h>
#include <ProObjects.h>
#include <ProRound.h>
#include <ProElement.h>
#include <ProCrvcollection.h>
#include <ProMdl.h>
#include <ProGeomitem.h>
#include <ProSelbuffer.h>
#include <ProFeature.h>
#include <ProUtil.h>
#include <ProVariantFeat.h>
#include <ProAnnotationFeat.h>
#include <ProAnnotationElem.h>

#include <PTAFExamples.h>

/*====================================================================*\
    FUNCTION :	 TestPTAFExCreateRoundFeatureAccess()
    PURPOSE  :   Enable access to the Round Feature from AE button	
\*====================================================================*/
uiCmdAccessState TestPTAFExCreateRoundFeatureAccess(uiCmdAccessMode access_mode)
{
  ProMdl mdl;
  ProMdlType mdltype;
  ProAnnotationElem annotelem;
  int featType = -1;
  ProSelection *sel=NULL;

/*---------------------------------------------------------------------*\
Test to See if the current model is a Part / Assembly
where annotation features exist
\*---------------------------------------------------------------------*/
  status = ProMdlCurrentGet(&mdl);
  if (status != PRO_TK_NO_ERROR) return (ACCESS_UNAVAILABLE);

  ProMdlTypeGet(mdl, &mdltype); 
  if ((mdltype != PRO_MDL_PART) && (mdltype != PRO_MDL_ASSEMBLY))
    return (ACCESS_UNAVAILABLE);

/*---------------------------------------------------------------------*\
Test to see if the Selection buffer if empty
Get the Annotation Element from the Selection buffer
\*---------------------------------------------------------------------*/
  status = PTAFExTestforSelectionsInBuffer();

  PT_TEST_LOG_SUCC("PTAFExTestforSelectionsInBuffer ");


  if (status != PRO_TK_NO_ERROR) return (ACCESS_UNAVAILABLE);

/*---------------------------------------------------------------------*\
User gets the ProSelection from the selection buffer
\*---------------------------------------------------------------------*/
  status = ProSelbufferSelectionsGet(&sel);
  PT_TEST_LOG_SUCC("PTAFExCreateRoundfromAE::ProSelbufferSelectionsGet ");

/*---------------------------------------------------------------------*\
Get ModelItem from the ProSelection
\*---------------------------------------------------------------------*/
  status = ProSelectionModelitemGet(sel[0], &annotelem);
  PT_TEST_LOG_SUCC("PTAFExCreateRoundfromAE::ProSelectionModelitemGet ");

  ProSelectionarrayFree (sel);

/*---------------------------------------------------------------------*\
Make sure Modelitem is an AE
\*---------------------------------------------------------------------*/
  if (annotelem.type != PRO_ANNOTATION_ELEM) return ACCESS_UNAVAILABLE;

/*---------------------------------------------------------------------*\
Get the feature type to be created
\*---------------------------------------------------------------------*/
  status = PTAFExGetFeatureType(&annotelem, &featType);

  if (featType == PTAFEX_PRO_FEAT_ROUND) return (ACCESS_AVAILABLE);
  else return (ACCESS_UNAVAILABLE);
}

/*====================================================================*\
    FUNCTION :	 PTAFExCreateRoundfromAE()
    PURPOSE  :   Callback to create Round feature from AE	
\*====================================================================*/
ProError PTAFExCreateRoundfromAE()
{
  ProSelection *sel=NULL, ref_sel;
  ProAnnotationElem annotelem;
  int feature_type = -1;
  double radius = -1;
  ProAnnotationReference *references=NULL;
  int num_refs = 0, i;
  ProGeomitem edge;
  ProFeature feat;
  ProFeattype feat_type;
  ProCrvcollinstr curv_coll_instr;
  ProCollection curv_coll;
  ProAsmcomppath path;
  ProMdlType type;
  ProFeature inh_feat;
  ProReference edge_ref;

  inh_feat.owner = NULL;

/*---------------------------------------------------------------------*\
User gets the ProSelection from the selection buffer
\*---------------------------------------------------------------------*/
  status = ProSelbufferSelectionsGet(&sel);
  PT_TEST_LOG_SUCC("PTAFExCreateRoundfromAE::ProSelbufferSelectionsGet ");

/*---------------------------------------------------------------------*\
Get ModelItem from the ProSelection
\*---------------------------------------------------------------------*/
  status = ProSelectionModelitemGet(sel[0], &annotelem);
  PT_TEST_LOG_SUCC("PTAFExCreateRoundfromAE::ProSelectionModelitemGet ");


/*---------------------------------------------------------------------*\
If the selected modelitem owner is not the same as the component path
owner, and the component path owner is a part, the selection was
from an inheritance feature.
\*---------------------------------------------------------------------*/
  status = ProSelectionAsmcomppathGet (sel[0], &path);
  
  if (status == PRO_TK_NO_ERROR)
    {
      status = ProMdlTypeGet (path.owner, &type);
      if (type == PRO_MDL_PART)
	{
/*---------------------------------------------------------------------*\
Save the inheritance feature information.
\*---------------------------------------------------------------------*/
	  inh_feat.owner = path.owner;
	  inh_feat.id = path.comp_id_table [0];
	  inh_feat.type = PRO_FEATURE;
	}
    }
      
/*---------------------------------------------------------------------*\
Make sure Modelitem is an AE
\*---------------------------------------------------------------------*/
  if (annotelem.type != PRO_ANNOTATION_ELEM) return PRO_TK_NO_ERROR;

/*---------------------------------------------------------------------*\
If an AE, check for "round" parameter
\*---------------------------------------------------------------------*/
  status = PTAFExGetFeatureType(&annotelem, &feature_type);
 
  if (status == PRO_TK_NO_ERROR) {
/*---------------------------------------------------------------------*\
If the AE does not contain a round feature type parameter, quit function
\*---------------------------------------------------------------------*/
    if (feature_type != PTAFEX_PRO_FEAT_ROUND) return PRO_TK_NO_ERROR;
		
/*---------------------------------------------------------------------*\
If the AE contains parameter "round", get the value.
\*---------------------------------------------------------------------*/
    status = PTAFExGetFeatureValue(&annotelem, &radius);

/*---------------------------------------------------------------------*\
Allocate a new Curve Collection for use as the round reference
\*---------------------------------------------------------------------*/
    status = ProCrvcollectionAlloc( &curv_coll );

/*---------------------------------------------------------------------*\
Convert the references for the annotation to feature references
\*---------------------------------------------------------------------*/
    status = ProAnnotationelemReferencesCollect(&annotelem, 
						PRO_ANNOTATION_REF_ALL, 
						PRO_ANNOT_REF_FROM_ANNOTATION,
						&references);

    status = ProArraySizeGet((ProArray*)references, &num_refs);
    
    for (i=0; i<num_refs; i++) {
      ProAnnotationRefType my_ref_type = references[i].type; 
      
      if ( my_ref_type != PRO_ANNOT_REF_SINGLE )
	continue; 
      
/*---------------------------------------------------------------------*\
Create the Selection from the ProReference
\*---------------------------------------------------------------------*/
      status = ProReferenceToSelection(references[i].object.reference, &ref_sel);

/*---------------------------------------------------------------------*\
Get the Geomitem from the ProSelection
\*---------------------------------------------------------------------*/
      status = ProSelectionModelitemGet(ref_sel, (ProModelitem*)&edge);

/*---------------------------------------------------------------------*\
If not an Edge, ignore the reference for chamfer creation
\*---------------------------------------------------------------------*/
      if (edge.type == PRO_EDGE) {
		
	status = ProGeomitemFeatureGet(&edge, &feat);
	status = ProFeatureTypeGet(&feat, &feat_type);

/*---------------------------------------------------------------------*\
If the annotation element was from an inheritance feature, we need to 
convert the references to references in the top-level model.
\*---------------------------------------------------------------------*/
	if (inh_feat.owner != NULL)
	  {
	    ProGeomitem new_edge;

	    status = ProDatasharingfeatCopiedgeomitemFind (&inh_feat,
							   NULL,
							   &edge,
							   &new_edge);
	    PT_TEST_LOG_SUCC ("ProDatasharingfeatCopiedgeomitemFind()");

	    ProReferenceAlloc (&edge_ref);
	    ProReferenceSet (edge_ref, NULL, &new_edge);
	  }
	else
	  ProSelectionToReference (ref_sel, &edge_ref);
	    
	ProSelectionFree (&ref_sel);
	
/*---------------------------------------------------------------------*\
If the edge belongs to a Hole, it may be 1/2 of a tangent edge circling
the top of the hole.  Make this assumption, and create the reference chain
for the chamfer as a tangent chain.  Otherwise, use just this one edge 
as the reference chain.
\*---------------------------------------------------------------------*/
	if(feat_type == PRO_FEAT_HOLE) status = ProCrvcollinstrAlloc(PRO_CURVCOLL_TAN_INSTR, &curv_coll_instr);
	else status = ProCrvcollinstrAlloc(PRO_CURVCOLL_ADD_ONE_INSTR, &curv_coll_instr);

/*---------------------------------------------------------------------*\
Add the reference to the Instruction
\*---------------------------------------------------------------------*/
	status = ProCrvcollinstrReferenceAdd(curv_coll_instr, edge_ref);
	ProReferenceFree (edge_ref);
				
/*---------------------------------------------------------------------*\
Add the instruction to the curve collection
\*---------------------------------------------------------------------*/
	status = ProCrvcollectionInstructionAdd( curv_coll, curv_coll_instr );
      }  
    }


/*---------------------------------------------------------------------*\
Create the Round feature based on the attributes
\*---------------------------------------------------------------------*/

    if (inh_feat.owner == NULL)
      status = ProMdlCurrentGet( &curr_mdl);
    else
      curr_mdl = inh_feat.owner;
    status = PTAFExRoundCreate(curr_mdl, radius, curv_coll);

    ProAnnotationreferencearrayFree (references);
    ProCollectionFree (&curv_coll);
  }

  ProSelectionarrayFree (sel);

  return PRO_TK_NO_ERROR;
}

/*====================================================================*\
  FUNCTION :   PTAFExRoundCreate()
  PURPOSE  :   Create a chamfer using element tree.  Based on 
              UserEdgeRoundCreate() in UgEdgeRoundCreate.c (pt_userguide)
\*====================================================================*/
int PTAFExRoundCreate(ProMdl model, double radius, ProCollection curv_coll) 
{
  ProElement pro_e_feature_tree;
  ProElement pro_e_feature_type;
  ProElement pro_e_rndch_sets;
  ProElement pro_e_rndch_set;
  ProElement pro_e_rndch_dimensional_schema;
  ProElement pro_e_rndch_chamfer_shape;
  ProElement pro_e_rndch_shape_options;
  ProElement pro_e_rndch_variable_radius;
  ProElement pro_e_rndch_compound_conic;
  ProElement pro_e_rndch_conic_type;
  ProElement pro_e_rndch_conic_value;
  ProElement pro_e_rndch_conic_dep_opt;
  ProElement pro_e_rndch_references;
  ProElement pro_e_rndch_reference_type;
  ProElement pro_e_std_curve_collection_appl;  
  ProElement pro_e_rndch_compound_spine;
  ProElement pro_e_rndch_ball_spine;
  ProElement pro_e_rndch_compound_ext_options;
  ProElement pro_e_rndch_auto_blend;
  ProElement pro_e_rndch_radii;
  ProElement pro_e_rndch_radius;
  ProElement pro_e_rndch_leg1;
  ProElement pro_e_rndch_leg_type;
  ProElement pro_e_rndch_leg_value;
  ProElement pro_e_rndch_leg2;
  ProElement pro_e_rndch_attach_type;
  ProElement pro_e_rndch_transitions;
  
  status = ProElementAlloc ( PRO_E_FEATURE_TREE, &pro_e_feature_tree ); 
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  
  status = ProElementAlloc ( PRO_E_FEATURE_TYPE, &pro_e_feature_type );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_feature_type, 913 );
  status = ProElemtreeElementAdd ( pro_e_feature_tree, NULL, pro_e_feature_type );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_SETS, &pro_e_rndch_sets );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElemtreeElementAdd ( pro_e_feature_tree, NULL, pro_e_rndch_sets  );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_SET, &pro_e_rndch_set );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElemtreeElementAdd ( pro_e_rndch_sets, NULL, pro_e_rndch_set  );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_DIMENSIONAL_SCHEMA, &pro_e_rndch_dimensional_schema );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_dimensional_schema, 0 );
  status = ProElemtreeElementAdd ( pro_e_rndch_set, NULL, pro_e_rndch_dimensional_schema );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_CHAMFER_SHAPE, &pro_e_rndch_chamfer_shape );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_chamfer_shape, 0 );
  status = ProElemtreeElementAdd ( pro_e_rndch_set, NULL, pro_e_rndch_chamfer_shape );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_SHAPE_OPTIONS, &pro_e_rndch_shape_options );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_shape_options, 0 );
  status = ProElemtreeElementAdd ( pro_e_rndch_set, NULL, pro_e_rndch_shape_options );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_VARIABLE_RADIUS, &pro_e_rndch_variable_radius );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_variable_radius, 0 );
  status = ProElemtreeElementAdd ( pro_e_rndch_set, NULL, pro_e_rndch_variable_radius );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_COMPOUND_CONIC, &pro_e_rndch_compound_conic );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElemtreeElementAdd ( pro_e_rndch_set, NULL, pro_e_rndch_compound_conic  );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_CONIC_TYPE, &pro_e_rndch_conic_type );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_conic_type, 2 );
  status = ProElemtreeElementAdd ( pro_e_rndch_compound_conic, NULL, pro_e_rndch_conic_type );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_CONIC_VALUE, &pro_e_rndch_conic_value );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementDoubleSet (  pro_e_rndch_conic_value, 0.000000 );
  status = ProElemtreeElementAdd ( pro_e_rndch_compound_conic, NULL, pro_e_rndch_conic_value );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_CONIC_DEP_OPT, &pro_e_rndch_conic_dep_opt );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_conic_dep_opt, 0 );
  status = ProElemtreeElementAdd ( pro_e_rndch_compound_conic, NULL, pro_e_rndch_conic_dep_opt );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_REFERENCES, &pro_e_rndch_references );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElemtreeElementAdd ( pro_e_rndch_set, NULL, pro_e_rndch_references  );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_REFERENCE_TYPE, &pro_e_rndch_reference_type );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_reference_type, 1 );
  status = ProElemtreeElementAdd ( pro_e_rndch_references, NULL, pro_e_rndch_reference_type );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_STD_CURVE_COLLECTION_APPL, &pro_e_std_curve_collection_appl );
  
  status = ProElementCollectionSet( pro_e_std_curve_collection_appl, curv_coll );
  PT_TEST_LOG_SUCC( " ProElementCollectionSet " );
  status = ProElemtreeElementAdd ( pro_e_rndch_references, NULL, pro_e_std_curve_collection_appl );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_COMPOUND_SPINE, &pro_e_rndch_compound_spine );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElemtreeElementAdd ( pro_e_rndch_set, NULL, pro_e_rndch_compound_spine  );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_BALL_SPINE, &pro_e_rndch_ball_spine );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_ball_spine, 0 );
  status = ProElemtreeElementAdd ( pro_e_rndch_compound_spine, NULL, pro_e_rndch_ball_spine );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_STD_CURVE_COLLECTION_APPL, &pro_e_std_curve_collection_appl );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  
  status = ProElementAlloc ( PRO_E_RNDCH_COMPOUND_EXT_OPTIONS, &pro_e_rndch_compound_ext_options );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElemtreeElementAdd ( pro_e_rndch_set, NULL, pro_e_rndch_compound_ext_options  );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_AUTO_BLEND, &pro_e_rndch_auto_blend );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_auto_blend, 0 );
  status = ProElemtreeElementAdd ( pro_e_rndch_compound_ext_options, NULL, pro_e_rndch_auto_blend );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_RADII, &pro_e_rndch_radii );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElemtreeElementAdd ( pro_e_rndch_set, NULL, pro_e_rndch_radii  );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_RADIUS, &pro_e_rndch_radius );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElemtreeElementAdd ( pro_e_rndch_radii, NULL, pro_e_rndch_radius  );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_LEG1, &pro_e_rndch_leg1 );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElemtreeElementAdd ( pro_e_rndch_radius, NULL, pro_e_rndch_leg1  );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_LEG_TYPE, &pro_e_rndch_leg_type );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_leg_type, 1 );
  status = ProElemtreeElementAdd ( pro_e_rndch_leg1, NULL, pro_e_rndch_leg_type );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_LEG_VALUE, &pro_e_rndch_leg_value );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  
  status = ProElementDoubleSet (  pro_e_rndch_leg_value, radius);
  
  status = ProElemtreeElementAdd ( pro_e_rndch_leg1, NULL, pro_e_rndch_leg_value );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_LEG2, &pro_e_rndch_leg2 );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElemtreeElementAdd ( pro_e_rndch_radius, NULL, pro_e_rndch_leg2  );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_LEG_TYPE, &pro_e_rndch_leg_type );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_leg_type, 0 );
  status = ProElemtreeElementAdd ( pro_e_rndch_leg2, NULL, pro_e_rndch_leg_type );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_LEG_VALUE, &pro_e_rndch_leg_value );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementDoubleSet (  pro_e_rndch_leg_value, 0.000000 );
  status = ProElemtreeElementAdd ( pro_e_rndch_leg2, NULL, pro_e_rndch_leg_value );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_STD_CURVE_COLLECTION_APPL, &pro_e_std_curve_collection_appl );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  
  status = ProElementAlloc ( PRO_E_RNDCH_ATTACH_TYPE, &pro_e_rndch_attach_type );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElementIntegerSet ( pro_e_rndch_attach_type, 0 );
  status = ProElemtreeElementAdd ( pro_e_feature_tree, NULL, pro_e_rndch_attach_type );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = ProElementAlloc ( PRO_E_RNDCH_TRANSITIONS, &pro_e_rndch_transitions );
  PT_TEST_LOG_SUCC( " ProElementAlloc " );
  status = ProElemtreeElementAdd ( pro_e_feature_tree, NULL, pro_e_rndch_transitions  );
  PT_TEST_LOG_SUCC( " ProElemtreeElementAdd" );
  
  status = PTTestFeatureCreate_low ( model, pro_e_feature_tree  ); 
  PT_TEST_LOG_SUCC (" PTTestFeatureCreate_low"); 

  return status;
}