/*
Copyright (c) 2024 PTC Inc. and/or Its Subsidiary Companies. All Rights Reserved.
*/
/*--------------------------------------------------------------------*\
Pro/TOOLKIT includes
\*--------------------------------------------------------------------*/
#include <ProToolkit.h>
#include <ProMdl.h>
#include <ProFeature.h>
#include <ProFeatType.h>
#include <ProArray.h>
#include <ProMenu.h>
#include <ProMessage.h>
#include <ProGraphic.h>
#include <ProSimprep.h>
#include <ProUtil.h>
/*--------------------------------------------------------------------*\
Application includes
\*--------------------------------------------------------------------*/
#include "TestError.h"
#include "UtilMessage.h"
#include "TestRule.h"
/*--------------------------------------------------------------------*\
Macros
\*--------------------------------------------------------------------*/
#define SIZE_GREATER 1
#define SIZE_LESS 2
#define SIZE_ABSOLUTE 3
#define SIZE_RELATIVE 4
#define SIZE_QUIT 5
#define SIZE_DONE 6
/*--------------------------------------------------------------------*\
Data types
\*--------------------------------------------------------------------*/
/*--------------------------------------------------------------------*\
Application global/external data
\*--------------------------------------------------------------------*/
static ProSolid solid;
/*---------------------------------------------------------------------*\
Functions declaration
\*---------------------------------------------------------------------*/
int ProTestRuleSizeDataInit( ProRuleSize*, int );
/*---------------------------------------------------------------------*\
Function: ProTestRules()
Purpose: Create and run TkRules menu to init the structure ProRule.
The use this structure to get a list of components.
Returns: 0 - success; -1 - error. Now ignored.
\*---------------------------------------------------------------------*/
int ProTestRules( AsmcomppathList* p_list )
{
#ifndef PT_PRODUCTS_BUILD
ProError status;
int menu_id; /* The identifier of the created menu */
int menu_action;
ProRule rule;
rule.type = PRO_RULE_NONE;
/* Init AsmcomppathList */
p_list->p_comp_path_list = NULL;
p_list->size = 0;
/* Get current model */
status = ProMdlCurrentGet( (ProMdl *)&solid );
TEST_CALL_REPORT( "ProMdlCurrentGet()", "ProTestRules()",
status, status != PRO_TK_NO_ERROR );
/* Load menu from file */
status = ProMenuFileRegister((char *) "TkRules",(char *) "tkrule.mnu", &menu_id );
TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestRules()",
status, status != PRO_TK_NO_ERROR );
/* Define menu buttons */
ProMenubuttonActionSet( (char *)"TkRules", (char *)"Use Name",
(ProMenubuttonAction)ProTestRuleInitName, &rule, 0 );
ProMenubuttonActionSet( (char *)"TkRules", (char *)"Use Expr",
(ProMenubuttonAction)ProTestRuleInitExpr, &rule, 0 );
ProMenubuttonActionSet( (char *)"TkRules", (char *)"Use Zone",
(ProMenubuttonAction)ProTestRuleInitZone, &rule, 0 );
ProMenubuttonActionSet((char *) "TkRules", (char *)"Use Dist",
(ProMenubuttonAction)ProTestRuleInitDist, &rule, 0 );
ProMenubuttonActionSet( (char *)"TkRules", (char *)"Use Size",
(ProMenubuttonAction)ProTestRuleInitSize, &rule, 0 );
ProMenubuttonActionSet( (char *)"TkRules",(char *) "Use Rep",
(ProMenubuttonAction)ProTestRuleInitRep, NULL, 0 );
ProMenubuttonActionSet( (char *)"TkRules",(char *) "Done/Return",
(ProMenubuttonAction)ProMenuDelete, NULL,0 );
ProMenubuttonActionSet((char *) "TkRules", (char *)"TkRules",
(ProMenubuttonAction)ProMenuDelete, NULL, 0 );
/* Run menu */
status = ProMenuCreate( PROMENUTYPE_MAIN, (char *)"TkRules", &menu_id );
TEST_CALL_REPORT( "ProMenuCreate()", "ProTestRules()",
status, status != PRO_TK_NO_ERROR );
if( status == PRO_TK_NO_ERROR )
{
status = ProMenuProcess((char *) "TkRules", &menu_action );
TEST_CALL_REPORT( "ProMenuProcess()", "ProTestRules()",
status, status != PRO_TK_NO_ERROR );
}
if( rule.type == PRO_RULE_NONE )
return -1;
status = ProRuleEval( solid, &rule,
&(p_list->p_comp_path_list),
&(p_list->size) );
TEST_CALL_REPORT( "ProRuleEval()", "ProTestRules()",
status, status != PRO_TK_NO_ERROR );
/*
if( status != PRO_TK_NO_ERROR )
return -1;
*/
#endif /* #ifndef PT_PRODUCTS_BUILD */
return 0;
}
#ifndef PT_PRODUCTS_BUILD
/*---------------------------------------------------------------------*\
Function: ProTestRuleInitName()
Purpose: On-buton function. Init a rule by name.
Returns: 0 - success; -1 - error. Now ignored.
\*---------------------------------------------------------------------*/
int ProTestRuleInitName( ProRule* p_rule, int int_dummy )
{
ProError status;
ProName w_name;
/* Get name wildcard */
ProUtilMsgPrint( "gen", "TEST %0s", "Enter name wildcard: " );
if( !ProUtilStringGet( w_name, NULL, PRO_NAME_SIZE ) )
return -1;
status = ProRuleInitName( w_name, p_rule );
TEST_CALL_REPORT( "ProRuleInitName()", "ProTestRuleInitName()",
status, status != PRO_TK_NO_ERROR );
if( status != PRO_TK_NO_ERROR )
p_rule->type = PRO_RULE_NONE;
return 0;
}
/*---------------------------------------------------------------------*\
Function: ProTestRuleInitExpr()
Purpose: On-buton function. Init a rule by expression.
Returns: 0 - success; -1 - error. Now ignored.
\*---------------------------------------------------------------------*/
int ProTestRuleInitExpr( ProRule* p_rule, int int_dummy )
{
ProError status;
ProLine w_expression;
ProExpression expressions;
/* Allocate ProExpression object as array of ProLines */
status = ProArrayAlloc( 0, sizeof(ProLine), 1, (ProArray*)&expressions );
TEST_CALL_REPORT( "ProArrayAlloc", "ProTestRuleInitExpression()",
status, status != PRO_TK_NO_ERROR );
do
{
ProUtilMsgPrint( "gen", "TEST %0s", "Enter expression: " );
status = ProMessageStringRead( PRO_LINE_SIZE, w_expression );
TEST_CALL_REPORT( "ProMessageStringRead()",
"ProTestRuleInitExpression()",
status, status != PRO_TK_NO_ERROR );
/* If user enters empty line stop prompting and evaluate expr */
if( status == PRO_TK_GENERAL_ERROR )
{
status = PRO_TK_NO_ERROR;
break;
}
if( status == PRO_TK_NO_ERROR )
{
status = ProArrayObjectAdd( (ProArray*)&expressions,
PRO_VALUE_UNUSED, 1, w_expression );
TEST_CALL_REPORT( "ProArrayObjectAdd",
"ProTestRuleInitExpression()", status,status!=PRO_TK_NO_ERROR);
}
}
while( status == PRO_TK_NO_ERROR );
if( status == PRO_TK_NO_ERROR )
{
status = ProRuleInitExpr( expressions, p_rule );
TEST_CALL_REPORT( "ProRuleInitExpression()",
"ProTestRuleInitExpression()",
status, status != PRO_TK_NO_ERROR );
}
if( status != PRO_TK_NO_ERROR )
p_rule->type = PRO_RULE_NONE;
return 0;
}
/*---------------------------------------------------------------------*\
Function: ProTestRuleInitZone()
Purpose: On-buton function. Init a rule by zone.
Returns: 0 - success; -1 - error. Now ignored.
\*---------------------------------------------------------------------*/
int ProTestRuleInitZone( ProRule* p_rule, int int_dummy )
{
ProError status;
ProSelection* p_selection;
int n_selected;
ProModelitem model_item;
ProFeattype feat_type;
ProUtilMsgPrint( "gen", "TEST %0s", "Select zone" );
/* Select a modelitem */
status = ProSelect( (char *)"feature", 1, NULL, NULL, NULL, NULL,
&p_selection, &n_selected );
TEST_CALL_REPORT( "ProSelect()", "ProTestRuleInitZone()",
status, status != PRO_TK_NO_ERROR );
if( (status != PRO_TK_NO_ERROR) || (n_selected < 1) )
return -1;
/* Get the feature item from a selection object */
status = ProSelectionModelitemGet( p_selection[0], &model_item );
TEST_CALL_REPORT( "ProSelectionModelitemGet()", "ProTestRuleInitZone()",
status, status != PRO_TK_NO_ERROR );
if( (status != PRO_TK_NO_ERROR) || (model_item.type != PRO_FEATURE) )
return -1;
/* Retrieve the type of the specified feature */
status = ProFeatureTypeGet( &model_item, &feat_type );
TEST_CALL_REPORT( "ProFeatureTypeGet()", "ProTestRuleInitZone()",
status, status != PRO_TK_NO_ERROR );
if( (status != PRO_TK_NO_ERROR) || (feat_type != PRO_FEAT_ZONE) )
return -1;
status = ProRuleInitZone( &model_item, p_rule );
TEST_CALL_REPORT( "ProRuleInitZone()", "ProTestRuleInitZone()",
status, status != PRO_TK_NO_ERROR );
if( status != PRO_TK_NO_ERROR )
p_rule->type = PRO_RULE_NONE;
return 0;
}
/*---------------------------------------------------------------------*\
Function: ProTestRuleInitDist()
Purpose: On-buton function. Init a rule by distance.
Returns: 0 - success; -1 - error. Now ignored.
\*---------------------------------------------------------------------*/
int ProTestRuleInitDist( ProRule* p_rule, int int_dummy )
{
ProError status;
ProRuleDist rule_distance;
ProSelection *p_selection;
int n_selected;
ProAsmcomppath comp_path;
ProMatrix transformation;
p_rule->type = PRO_RULE_NONE;
/* Pick the center point by mouse */
ProUtilMsgPrint( "gen", "TEST %0s",
"Specify point, vertex or csys to evaluate distance from" );
status = ProSelect( (char *)"point,csys", 1, NULL, NULL, NULL, NULL,
&p_selection, &n_selected );
TEST_CALL_REPORT( "ProSelect()", "ProTestRuleInitZone()",
status, status != PRO_TK_NO_ERROR );
if( (status != PRO_TK_NO_ERROR) || (n_selected < 1) )
return -1;
status = ProSelectionPoint3dGet( p_selection[0], rule_distance.center );
TEST_CALL_REPORT( "ProSelectionPoint3dGet()", "ProTestRuleInitZone()",
status, status != PRO_TK_NO_ERROR );
status = ProSelectionAsmcomppathGet( p_selection[0], &comp_path );
TEST_CALL_REPORT( "ProSelectionAsmcomppathGet()", "ProTestRuleInitZone()",
status, status != PRO_TK_NO_ERROR );
status = ProAsmcomppathTrfGet( &comp_path, PRO_B_TRUE, transformation );
TEST_CALL_REPORT( "ProAsmcomppathTrfGet()", "ProTestRuleInitZone()",
status, status != PRO_TK_NO_ERROR );
status = ProVectorTrfEval( rule_distance.center, transformation,
rule_distance.center );
TEST_CALL_REPORT( "ProVectorTrfEval()", "ProTestRuleInitZone()",
status, status != PRO_TK_NO_ERROR );
/* Get distance */
ProUtilMsgPrint( "gen", "TEST %0s", "Enter distance: " );
if( !ProUtilDoubleGet( NULL, NULL, &(rule_distance.distance) ) )
return -1;
status = ProRuleInitDist( &rule_distance, p_rule );
TEST_CALL_REPORT( "ProRuleInitDist()", "ProTestRuleInitDist()",
status, status != PRO_TK_NO_ERROR );
if( status != PRO_TK_NO_ERROR )
p_rule->type = PRO_RULE_NONE;
return 0;
}
/*---------------------------------------------------------------------*\
Function: ProTestRuleInitSize()
Purpose: On-buton function. Init a rule by size.
Returns: 0 - success; -1 - error. Now ignored.
\*---------------------------------------------------------------------*/
int ProTestRuleInitSize( ProRule* p_rule, int int_dummy )
{
ProError status;
int menu_id; /* The identifier of the created menu */
int menu_action = SIZE_QUIT;
ProRuleSize rule_size;
char *p_menus[] = { "Set Size", "Set Size2", "DONE QUIT",
"" };
double range[ 2 ];
double *p_range;
double value;
/*---------------------*\
Define Set Size
\*---------------------*/
status = ProMenuFileRegister( (char *)"Set Size", (char *)"tkrulesz.mnu", &menu_id );
TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
ProMenubuttonActionSet( (char *)"Set Size", (char *)"Absolute",
(ProMenubuttonAction)ProTestRuleSizeDataInit,
&rule_size, SIZE_ABSOLUTE );
TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestRuleInitSize",
status , status != PRO_TK_NO_ERROR);
ProMenubuttonActionSet( (char *)"Set Size", (char *)"Relative",
(ProMenubuttonAction)ProTestRuleSizeDataInit,
&rule_size, SIZE_RELATIVE );
TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestRuleInitSize",
status , status != PRO_TK_NO_ERROR);
ProMenubuttonActionSet( (char *)"Set Size", (char *)"Set Size",
(ProMenubuttonAction)ProMenuHold, NULL, 0 );
TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestRuleInitSize",
status , status != PRO_TK_NO_ERROR);
/*---------------------*\
Define Set Size2
\*---------------------*/
status = ProMenuFileRegister( (char *)"Set Size2",(char *) "tkrulesz2.mnu", &menu_id );
TEST_CALL_REPORT( "ProMenuFileRegister()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
ProMenubuttonActionSet( (char *)"Set Size2",(char *) "Greater Than",
(ProMenubuttonAction)ProTestRuleSizeDataInit,
&rule_size, SIZE_GREATER );
TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestRuleInitSize",
status , status != PRO_TK_NO_ERROR);
ProMenubuttonActionSet((char *) "Set Size2", (char *)"Less Than",
(ProMenubuttonAction)ProTestRuleSizeDataInit,
&rule_size, SIZE_LESS );
TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestRuleInitSize",
status , status != PRO_TK_NO_ERROR);
ProMenubuttonActionSet( (char *)"Set Size2", (char *)"Set Size2",
(ProMenubuttonAction)ProMenuHold, NULL, 0 );
TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestRuleInitSize",
status , status != PRO_TK_NO_ERROR);
/*---------------------*\
Define DONE QUIT
\*---------------------*/
status = ProMenuFileRegister( (char *)"DONE QUIT",(char *)"tkdonequit.mnu", &menu_id );
TEST_CALL_REPORT("ProMenuFileRegister()", "ProTestRuleInitSize",
status , status != PRO_TK_NO_ERROR);
status = ProMenubuttonActionSet((char *)"DONE QUIT",(char *)"-Done",
(ProMenubuttonAction)ProTestRuleSizeDataInit, &rule_size, SIZE_DONE );
TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestRuleInitSize",
status , status != PRO_TK_NO_ERROR);
status = ProMenubuttonActionSet((char *)"DONE QUIT",(char *)"-Quit",
(ProMenubuttonAction)ProTestRuleSizeDataInit, &rule_size, SIZE_QUIT );
TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestRuleInitSize",
status , status != PRO_TK_NO_ERROR);
status = ProMenubuttonActionSet((char *)"DONE QUIT",(char *)"DONE QUIT",
(ProMenubuttonAction)ProMenuHold,NULL,0);
TEST_CALL_REPORT("ProMenubuttonActionSet()", "ProTestRuleInitSize",
status , status != PRO_TK_NO_ERROR);
/* Run menu */
status = ProCompoundmenuCreate( p_menus, &menu_id );
TEST_CALL_REPORT( "ProMenuCompoundCreate()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
if( status == PRO_TK_NO_ERROR )
{
menu_action = SIZE_QUIT;
status = ProMenuProcess( (char *)"Set Size", &menu_action );
TEST_CALL_REPORT( "ProMenuProcess()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
}
if( menu_action == SIZE_DONE )
{
if( rule_size.absolute == PRO_B_FALSE )
{
range[0] = 0.0;
range[1] = 1.0;
p_range = range;
}
else
p_range = NULL;
/* Get value */
ProUtilMsgPrint( "gen", "TEST %0s", "Enter value: " );
status = ProMessageDoubleRead( p_range, &value );
TEST_CALL_REPORT( "ProMessageDoubleRead()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
if( status == PRO_TK_NO_ERROR )
{
rule_size.value = value;
status = ProRuleInitSize( &rule_size, p_rule );
TEST_CALL_REPORT( "ProRuleInitSize()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
}
}
else
status = PRO_TK_USER_ABORT;
if( status != PRO_TK_NO_ERROR )
p_rule->type = PRO_RULE_NONE;
return 0;
}
/*---------------------------------------------------------------------*\
Function: ProTestRuleSizeDataInit()
Purpose: On-buton function. Init the structure ProRuleSize.
Returns: 0 - success; -1 - error. Now ignored.
\*---------------------------------------------------------------------*/
int ProTestRuleSizeDataInit( ProRuleSize* p_rule_size, int option )
{
ProError status;
switch( option )
{
case SIZE_ABSOLUTE:
p_rule_size->absolute = PRO_B_TRUE;
break;
case SIZE_RELATIVE:
p_rule_size->absolute = PRO_B_FALSE;
break;
case SIZE_GREATER:
p_rule_size->greater = PRO_B_TRUE;
break;
case SIZE_LESS:
p_rule_size->greater = PRO_B_FALSE;
break;
case SIZE_QUIT:
status = ProMenuDelete();
TEST_CALL_REPORT( "ProMenuDelete()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
status = ProMenuDelete();
TEST_CALL_REPORT( "ProMenuDelete()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
status = ProMenuDeleteWithStatus( SIZE_QUIT );
TEST_CALL_REPORT( "ProMenuDeleteWithStatus()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
break;
case SIZE_DONE:
status = ProMenuDelete();
TEST_CALL_REPORT( "ProMenuDelete()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
status = ProMenuDelete();
TEST_CALL_REPORT( "ProMenuDelete()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
status = ProMenuDeleteWithStatus( SIZE_DONE );
TEST_CALL_REPORT( "ProMenuDeleteWithStatus()", "ProTestRuleInitSize()",
status, status != PRO_TK_NO_ERROR );
break;
default:
break;
}
return 0;
}
/*---------------------------------------------------------------------*\
Function: ProTestRuleInitSize()
Purpose: On-buton function. Init a rule by simp rep.
Returns: 0 - success; -1 - error. Now ignored.
\*---------------------------------------------------------------------*/
int ProTestRuleInitRep( ProRule* p_rule, int int_dummy )
{
ProError status;
ProSimprep simp_rep;
/* Select simp rep in the current model
(model handle is inited in ProTestRules() ) */
status = ProSimprepSelect( solid, &simp_rep );
TEST_CALL_REPORT( "ProSimprepSelect()", "ProTestRuleInitRep()",
status, status != PRO_TK_NO_ERROR );
if( status != PRO_TK_NO_ERROR )
return -1;
status = ProRuleInitRep( &simp_rep, p_rule );
TEST_CALL_REPORT( "ProRuleInitRep()", "ProTestRuleInitRep()",
status, status != PRO_TK_NO_ERROR );
if( status != PRO_TK_NO_ERROR )
p_rule->type = PRO_RULE_NONE;
return 0;
}
/*---------------------------------------------------------------------*\
Function: ProSelectWithRules()
Purpose: On-buton function.
Returns:
PRO_TK_NO_ERROR - Selection was made or user hit "Done".
PRO_TK_USER_ABORT - User hit "Quit".
PRO_TK_PICK_ABOVE - Selection was interrupted by a user's pick on
any button from above menus.
\*---------------------------------------------------------------------*/
ProError ProSelectWithRules( char option[],
int max_count,
ProSelection *p_in_sel, /* Ignored */
ProSelFunctions *sel_func, /* Ignored */
ProSelectionEnv sel_env, /* Ignored */
ProSelAppAction appl_act_data, /* Ignored */
ProSelection **p_sel_array,
int *p_n_sels )
{
ProError status;
AsmcomppathList comp_path_list;
ProMdl model;
ProModelitem model_item;
int i;
/* Init AsmcomppathList */
comp_path_list.p_comp_path_list = NULL;
comp_path_list.size = 0;
if( ProTestRules( &comp_path_list ) == -1 )
return PRO_TK_USER_ABORT;
if( comp_path_list.size < 1 )
return PRO_TK_USER_ABORT;
status = ProArrayAlloc( comp_path_list.size, sizeof(ProSelection), 1,
(ProArray*)p_sel_array );
TEST_CALL_REPORT( "ProArrayAlloc()", "ProSelectWithRules()",
status, status != PRO_TK_NO_ERROR );
*p_n_sels = 0;
for( i=0; i<comp_path_list.size; i++, (*p_n_sels)++ )
{
status = ProAsmcomppathMdlGet( &(comp_path_list.p_comp_path_list[i] ),
&model );
TEST_CALL_REPORT( "ProAsmcomppathMdlGet()", "ProSelectWithRules()",
status, status != PRO_TK_NO_ERROR );
if( status != PRO_TK_NO_ERROR )
return PRO_TK_USER_ABORT;
status = ProMdlToModelitem( model, &model_item );
TEST_CALL_REPORT( "ProMdlToModelitem()", "ProSelectWithRules()",
status, status != PRO_TK_NO_ERROR );
status = ProSelectionAlloc( &(comp_path_list.p_comp_path_list[i]),
&model_item, (*p_sel_array) + i );
TEST_CALL_REPORT( "ProSelectionAlloc()", "ProSelectWithRules()",
status, status != PRO_TK_NO_ERROR);
status = ProSelectionHighlight( (*p_sel_array)[i], PRO_COLOR_ERROR );
TEST_CALL_REPORT( "ProSelectionHighlight()", "ProSelectWithRules()",
status, status == PRO_TK_COMM_ERROR);
}
return PRO_TK_NO_ERROR;
}
#endif /* #ifndef PT_PRODUCTS_BUILD */