ProError BatchPlot::ReadDirectory(wchar_t *w_directory, wchar_t *w_filter, std::vector<Model> &list)
{
ProError status;
ProPath *w_file_names;
ProPath *w_directories;
int n_count;
status = ProArrayAlloc(0, sizeof(ProPath), 1,(ProArray*)&w_file_names);
status = ProArrayAlloc(0, sizeof(ProPath), 1,(ProArray*)&w_directories);
status = ProFilesList(w_directory, w_filter, PRO_FILE_LIST_LATEST_SORTED, &w_file_names, &w_directories);
status = ProArraySizeGet(w_file_names, &n_count);
for(int i=0; i<n_count; i++)
{
Model m(w_file_names[i]);
list.push_back(m);
}
status = ProArraySizeGet(w_directories, &n_count);
for(int i=0; i<n_count; i++)
{
status = BatchPlot::ReadDirectory(w_directories[i], w_filter, list);
}
ProArrayFree((ProArray *) &w_file_names);
ProArrayFree((ProArray *) &w_directories);
return PRO_TK_NO_ERROR;
}
// 处理过程
BOOL CSDMdlSpecAsmImplicitCheck::DoAction(void *pData, const CheckData &checkData)
{
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
return FALSE;
int nCount = (int)checkData.checkResult.arrErrorItems.GetCount();
ProModelitem mdlitem;
mdlitem.owner = pMdl;
mdlitem.type = PRO_FEATURE;
int* parrFeatID = NULL;
ProFeatureResumeOptions* parrOpt = NULL;
ProArrayAlloc(0, sizeof(int), 1, (ProArray*)&parrFeatID);
ProArrayAlloc(0, sizeof(ProFeatureResumeOptions), 1, (ProArray*)&parrOpt);
int nID = -1;
ProFeatureResumeOptions opt = PRO_FEAT_RESUME_NO_OPTS;
for (int i=0; i<nCount; i++)
{
nID = checkData.checkResult.arrErrorItems[i].nID;
ProArrayObjectAdd((ProArray*)&parrFeatID, PRO_VALUE_UNUSED, 1, &nID);
ProArrayObjectAdd((ProArray*)&parrOpt, PRO_VALUE_UNUSED, 1, &opt);
}
ProFeatureResume(ProMdlToSolid(pMdl), parrFeatID, nCount, parrOpt, nCount);
ProArrayFree((ProArray *)&parrFeatID);
ProArrayFree((ProArray *)&parrOpt);
return TRUE;
}
ProError BatchPlot::GetWorkspaceItems(std::vector<Gui::Model> &list)
{
ProError status;
ProFileListOpt option = PRO_FILE_LIST_LATEST_SORTED;
wchar_t *w_server_alias;
wchar_t *w_workspace_name;
ProPath *w_file_names;
ProPath *w_folder_names;
ProPath w_path;
ProPath w_filter;
status = BatchPlot::GetFileFilter(true, true, w_filter);
status = ProServerActiveGet(&w_server_alias);
if (status != PRO_TK_NO_ERROR)
{
Mirim::MsgBox::Show(L"Server Alias", L"Could not find Active PDMLink Server");
return PRO_TK_E_NOT_FOUND;
}
status = ProServerWorkspaceGet(w_server_alias, &w_workspace_name);
if (status != PRO_TK_NO_ERROR)
{
Mirim::MsgBox::Show(L"Workspace", L"Could not find Active Workspace.");
return PRO_TK_E_NOT_FOUND;
}
wsprintf(w_path, L"wtws://%s/%s", w_server_alias, w_workspace_name);
status = ProArrayAlloc(0, sizeof(ProPath), 1,(ProArray*)&w_file_names);
status = ProArrayAlloc(0, sizeof(ProPath), 1,(ProArray*)&w_folder_names);
status = ProFilesList(w_path, w_filter, option, &w_file_names, &w_folder_names);
int n_count = -1;
status = ProArraySizeGet(w_file_names, &n_count);
for(int i=0; i<n_count; i++)
{
Model m(w_file_names[i]);
list.push_back(m);
}
status = ProWstringFree(w_server_alias);
status = ProWstringFree(w_workspace_name);
status = ProArrayFree((ProArray *) &w_file_names);
status = ProArrayFree((ProArray *) &w_folder_names);
return PRO_TK_NO_ERROR;
}
ProError CSDMdlSpecAsmConstraintsCheck::AssMdlVisitAction(ProFeature *pFea, ProError status, ProAppData pData)
{
UNUSED_ALWAYS(status);
AsmConsVisitData &visitData = *((AsmConsVisitData *)pData);
ProMdl pMdl = NULL;
ProAsmcompMdlGet(pFea, &pMdl);
if (NULL == pMdl)
return PRO_TK_NO_ERROR;
ProBoolean bUnConstrained;
ProAsmcompIsUnderconstrained(pFea, &bUnConstrained);
if (bUnConstrained == PRO_B_TRUE)
{
visitData.nResultType = CHECK_RESULT_INVALID_VALUE;
visitData.arrErrorIDs.Add(pFea->id);
}
else
{
ProAsmcompconstraint* pArrCons = NULL;
if (ProAsmcompConstraintsGet(pFea, &pArrCons) == PRO_TK_E_NOT_FOUND)
{
visitData.nResultType = CHECK_RESULT_INVALID_VALUE;
visitData.arrErrorIDs.Add(pFea->id);
}
else
{
ProArrayFree((ProArray*)&pArrCons);
}
}
return PRO_TK_NO_ERROR;
}
ProError BatchPlot::GetDiskItems(wchar_t *w_directory, bool recursive, std::vector<Gui::Model> &list)
{
ProError status;
ProLine w_filter;
ProPath *w_file_names;
ProPath *w_directories;
int n_count;
if (_waccess(w_directory, 00) == -1)
{
Mirim::MsgBox::Show(L"PMP", L"Select valid folder");
return PRO_TK_NO_ERROR;
}
status = BatchPlot::GetFileFilter(true, true, w_filter);
if (status != PRO_TK_NO_ERROR)
{
Mirim::MsgBox::Show(L"PMP", L"Select file type");
return status;
}
status = ProArrayAlloc(0, sizeof(ProPath), 1,(ProArray*)&w_file_names);
status = ProArrayAlloc(0, sizeof(ProPath), 1,(ProArray*)&w_directories);
status = ProFilesList(w_directory, w_filter, PRO_FILE_LIST_LATEST_SORTED, &w_file_names, &w_directories);
status = ProArraySizeGet(w_file_names, &n_count);
for(int i=0; i<n_count; i++)
{
Model m(w_file_names[i]);
list.push_back(m);
}
if (!recursive) return PRO_TK_NO_ERROR;
status = ProArraySizeGet(w_directories, &n_count);
for(int i=0; i<n_count; i++)
{
status = BatchPlot::ReadDirectory(w_directories[i], w_filter, list);
}
ProArrayFree((ProArray *) &w_file_names);
ProArrayFree((ProArray *) &w_directories);
return PRO_TK_NO_ERROR;
}
/*============================================================================*\
Function: ProUtilMenuStringsFree
Purpose: Free memory allocated by ..Alloc, ..StrAdd, ..WstrAdd
\*============================================================================*/
ProError ProUtilMenuStringsFree(
wchar_t ***w_ptr)
{
ProError err;
int i, n_str;
wchar_t **w_p = *w_ptr;
err = ProArraySizeGet((ProArray)w_p, &n_str);
for (i=n_str-2; i>0; i--)
free(w_p[i]);
err = ProArrayFree((ProArray*)w_ptr);
return (err);
}
ProError CSDMdlSpecAsmRefCheck::AsmMdlVisitAction(ProFeature *pFea, ProError status, ProAppData pData)
{
UNUSED_ALWAYS(status);
AsmRefVisitData &visitData = *((AsmRefVisitData *)pData);
ProAsmcompconstraint* pArrCons = NULL;
if (ProAsmcompConstraintsGet(pFea, &pArrCons) == PRO_TK_NO_ERROR)
{
int nCount;
ProArraySizeGet(pArrCons, &nCount);
for (int i=0; i<nCount; i++)
{
ProAsmcompConstrType type;
ProAsmcompconstraintTypeGet(pArrCons[i], &type);
if (type != PRO_ASM_CSYS)
{
ProMdl pMdl = NULL;
ProAsmcompMdlGet(pFea, &pMdl);
ProName name;
ProMdlNameGet(pMdl, name);
visitData.nResultType = CHECK_RESULT_INVALID_VALUE;
visitData.arrMdlNames.Add(CString(name));
visitData.arrErrorIDs.Add(pFea->id);
break;
}
}
ProArrayFree((ProArray*)&pArrCons);
}
else
{
ProMdl pMdl = NULL;
ProAsmcompMdlGet(pFea, &pMdl);
ProName name;
ProMdlNameGet(pMdl, name);
visitData.nResultType = CHECK_RESULT_INVALID_VALUE;
visitData.arrMdlNames.Add(CString(name));
visitData.arrErrorIDs.Add(pFea->id);
}
return PRO_TK_NO_ERROR;
}
/*============================================================================*\
Function: ProUtilMenuStringManySelect
Purpose: Select many string from menu with submenu Select All/Unsell All
\*============================================================================*/
ProError ProUtilMenuStringManySelect(
char *menu_name, /* In : Menu name */
wchar_t **w_menu_buttons, /* In : Menu buttons */
int **output_array, /* Out: ProArray of numbers of selected
strings, use ProArrayFree to free
memory */
int *p_n_sel) /* Out: Number of selected components */
{
int i, n_but, n_sel, menu_id, action;
ProError err, ret_status = PRO_TK_USER_ABORT;
int *toggle_array;
MenuToggleInfo toggle_info;
ProCharName name;
wchar_t **w_menus;
for(n_but=0; w_menu_buttons[n_but][0] != '\0'; n_but++);
err = ProArrayAlloc(n_but, sizeof(int), 1, (ProArray*)&toggle_array);
toggle_info.w_menu_buttons = w_menu_buttons;
toggle_info.button_status = toggle_array;
toggle_info.n_buttons = n_but;
toggle_info.menu_name = menu_name;
err = ProMenuFromStringsRegister ( menu_name, NULL,
w_menu_buttons, NULL, NULL, &menu_id);
for (i=0; i<n_but; i++)
{
toggle_array[i] = 0;
ProWstringToString(name, w_menu_buttons[i]);
err = ProMenubuttonActionSet(menu_name, name,
(ProMenubuttonAction)ProUtilMenuToggleOne, &toggle_info, i);
}
err = ProMenubuttonActionSet(menu_name, menu_name,
(ProMenubuttonAction)ProMenuDelete, NULL, 0);
err = ProMenuModeSet(menu_name, PROMENUMODE_DATA);
err = ProMenuDatamodeSet(menu_name, PRO_B_TRUE );
err = ProMenuCreate(PROMENUTYPE_MAIN, menu_name, &menu_id);
err = ProUtilMenuStringsAlloc(&w_menus);
err = ProUtilMenuStringsStrAdd(&w_menus, (char *)"Select All");
err = ProUtilMenuStringsStrAdd(&w_menus, (char *)"Unsel All");
err = ProUtilMenuStringsStrAdd(&w_menus, (char *)"Done Sel");
err = ProUtilMenuStringsStrAdd(&w_menus, (char *)"Quit Sel");
ProMenuFromStringsRegister ( (char *)"TkMenuUtilSelect", NULL, w_menus,
NULL, NULL, &menu_id);
err = ProMenubuttonActionSet((char *)"TkMenuUtilSelect", (char *)"Select All",
(ProMenubuttonAction)ProUtilMenuToggleDone, &toggle_info, SELECT_ALL);
err = ProMenubuttonActionSet((char *)"TkMenuUtilSelect", (char *)"Unsel All",
(ProMenubuttonAction)ProUtilMenuToggleDone, &toggle_info, UNSEL_ALL);
err = ProMenubuttonActionSet((char *)"TkMenuUtilSelect", (char *)"Done Sel",
(ProMenubuttonAction)ProUtilMenuToggleDone, &toggle_info, DONE_SEL);
err = ProMenubuttonActionSet((char *)"TkMenuUtilSelect", (char *)"Quit Sel",
(ProMenubuttonAction)ProUtilMenuToggleDone, &toggle_info, QUIT_SEL);
err = ProMenubuttonActionSet((char *)"TkMenuUtilSelect", (char *)"TkMenuUtilSelect",
(ProMenubuttonAction)ProUtilMenuToggleDone, &toggle_info, QUIT_SEL);
err = ProMenuCreate(PROMENUTYPE_SUB, (char *)"TkMenuUtilSelect", &menu_id);
err = ProMenuProcess((char *)"TkMenuUtilSelect", &action);
if(err == PRO_TK_NO_ERROR && action == DONE_SEL)
{
err = ProArrayAlloc(0, sizeof(int), 1, (ProArray*)output_array);
n_sel = 0;
for (i=0; i<n_but; i++)
if (toggle_array[i])
{
ProArrayObjectAdd((ProArray*)output_array, PRO_VALUE_UNUSED,
1, &i);
n_sel++;
}
if (n_sel>0)
{
*p_n_sel = n_sel;
ret_status = PRO_TK_NO_ERROR;
}
else
err = ProArrayFree((ProArray*)output_array);
}
err = ProArrayFree((ProArray*)&toggle_array);
return (ret_status);
}
/*====================================================================*\
FUNCTION : ProUtilElemPrint()
PURPOSE : Visit function.
\*====================================================================*/
ProError ProUtilElemPrint(
ProElement elem_tree,
ProElement elem,
ProElempath elem_path,
FeatureElemPrintData* p_data )
{
ProError status;
ProElemId elem_id;
int dimension_id = -1;
ProBoolean is_visible;
ProBoolean is_incomplete;
ProBoolean is_compound;
ProBoolean is_array;
ProBoolean is_multival;
ProValue* p_values;
ProValue value;
int array_size;
ProValueData value_data;
char value_data_str[ 48 ];
int i;
ProBoolean flag = PRO_B_TRUE;
status = ProElementIdGet( elem, &elem_id );
TEST_CALL_REPORT("ProElementIdGet()",
"ProUtilElemPrint()",
PRO_TK_NO_ERROR, status != PRO_TK_NO_ERROR);
ProTKFprintf( p_data->fp, "Element ID: %d\n", elem_id );
status = ProFeatureElemIsVisible( p_data->p_feature, elem_path,
&is_visible );
#if 0
TEST_CALL_REPORT("ProFeatureElemIsVisible()",
"ProUtilElemPrint()", status,
status != PRO_TK_NO_ERROR );
#else
/* This function return PRO_TK_E_NOT_FOUND for Element FEATURE_TYPE,
from feature PRO_FEAT_DATUM_QUILT (it's a bug)*/
TEST_CALL_REPORT("ProFeatureElemIsVisible()",
"ProUtilElemPrint()", status,
0);
#endif
status = ProFeatureElemIsIncomplete( p_data->p_feature, elem_path,
&is_incomplete );
#if 0
/* spr 751801 */
TEST_CALL_REPORT( "ProFeatureElemIsIncomplete()", "ProUtilElemPrint()", status, status != PRO_TK_NO_ERROR);
#else
TEST_CALL_REPORT( "ProFeatureElemIsIncomplete()", "ProUtilElemPrint()", status, 0 );
#endif
status = ProElementIsCompound( elem, NULL, &is_compound );
TEST_CALL_REPORT("ProElementIsCompound()", "ProUtilElemPrint()",
status, status != PRO_TK_NO_ERROR);
status = ProElementIsArray(elem, NULL, &is_array );
TEST_CALL_REPORT("ProElementIsArray()", "ProUtilElemPrint()",
status, status != PRO_TK_NO_ERROR);
ProTKFprintf( p_data->fp, is_visible == PRO_B_TRUE ? "\tVisible\n" : "\tInvisible\n" );
ProTKFprintf( p_data->fp, is_incomplete == PRO_B_TRUE ? "\tIncomplete\n" :
"\tComplete\n" );
ProTKFprintf( p_data->fp, is_compound == PRO_B_TRUE ? "\tCompound\n" :
(is_array == PRO_B_TRUE ? "\tArray\n" :
"\tNeither compound nor array\n"));
if( is_compound == PRO_B_TRUE || is_array == PRO_B_TRUE)
return PRO_TK_NO_ERROR;
status = ProFeatureElemDimensionIdGet( p_data->p_feature, elem_path,
&dimension_id );
TEST_CALL_REPORT("ProFeatureElemDimensionIdGet()",
"ProUtilElemPrint()",
status, (status != PRO_TK_NO_ERROR)&&
(status != PRO_TK_E_NOT_FOUND));
if (status != PRO_TK_E_NOT_FOUND)
ProTKFprintf( p_data->fp, "\tDimension ID: %d\n", dimension_id );
else
ProTKFprintf( p_data->fp, "\tThis element does not contain dimension\n");
status = ProArrayAlloc( 0, sizeof(ProValue), 1, (ProArray*)&p_values );
TEST_CALL_REPORT( "ProArrayAlloc()", "ProUtilElemPrint()",
status, status != PRO_TK_NO_ERROR );
status = ProElementIsMultival(elem, NULL, &is_multival);
TEST_CALL_REPORT( "ProElementIsMultival",
"ProUtilElemPrint", status, status != PRO_TK_NO_ERROR);
if (is_multival == PRO_B_TRUE)
{
status = ProFeatureElemValuesGet( p_data->p_feature,
elem_path, &p_values );
#if 0
TEST_CALL_REPORT( "ProFeatureElemValuesGet()", "ProUtilElemPrint()",
status,
status != PRO_TK_NO_ERROR );
#else
/* ProFeatureElemValuesGet() - returns PRO_TK_E_NOT_FOUND in the PIPE mode
for Element PRO_E_STD_EDGE_CHAMF_EDGES.(bugminsk1347)*/
TEST_CALL_REPORT( "ProFeatureElemValuesGet()", "ProUtilElemPrint()",
status,
0 );
#endif
}
else
{
status = ProElementValueGet(elem, &value);
TEST_CALL_REPORT( "ProElementValueGet", "ProUtilElemPrint",
status, status != PRO_TK_NO_ERROR);
status = ProArrayObjectAdd((ProArray*)&p_values, PRO_VALUE_UNUSED,
1, &value);
TEST_CALL_REPORT( "ProArrayObjectAdd", "ProUtilElemPrint",
status, status != PRO_TK_NO_ERROR);
}
if (p_values!=NULL){
array_size = 0;
status = ProArraySizeGet( (ProArray)p_values, &array_size );
TEST_CALL_REPORT( "ProArraySizeGet()", "ProUtilElemPrint()",
status, status != PRO_TK_NO_ERROR );
ProTKFprintf( p_data->fp, "\t%s\n",(i=1)?"Value:":"Values:" );
for( i=0; i<array_size; i++ )
{
/*To avoid PRO_E_SKETCHER and PRO_E_PATTERN, following condition is set*/
if(( elem_id == 458) || (elem_id == 27))
flag = PRO_B_FALSE;
if(flag == PRO_B_TRUE)
{
status = ProValueDataGet( p_values[i], &value_data );
TEST_CALL_REPORT( "ProValueDataGet()", "ProUtilElemPrint()",
status, status != PRO_TK_NO_ERROR );
switch( value_data.type )
{
case PRO_VALUE_TYPE_INT:
ProTKSprintf( value_data_str, "%d", value_data.v.i );
break;
case PRO_VALUE_TYPE_DOUBLE:
ProTKSprintf( value_data_str, "%f", value_data.v.d );
break;
case PRO_VALUE_TYPE_POINTER:
ProTKSprintf( value_data_str, "Pointer=*", value_data.v.p );
break;
case PRO_VALUE_TYPE_STRING:
if ( value_data.v.s !=NULL)
ProTKSprintf( value_data_str, "%s", value_data.v.s );
else
ProTKSprintf( value_data_str,"<NULL>" );
break;
case PRO_VALUE_TYPE_WSTRING:
/* NOTE - NULL is possible in some element trees
(for example, for the element PRO_E_STD_FEATURE_NAME
where NULL means that feature has the default name) */
if ( value_data.v.w !=NULL)
ProWstringToString( value_data_str, value_data.v.w );
else
ProTKSprintf( value_data_str,"<NULL>" );
break;
case PRO_VALUE_TYPE_SELECTION:
ProTKSprintf( value_data_str, "Selection" );
break;
case PRO_VALUE_TYPE_TRANSFORM:
ProTKSprintf( value_data_str, "Transformation" );
break;
default:
ProTKSprintf( value_data_str, "**UNKNOWN**\n" );
}
ProTKFprintf( p_data->fp, "\t%s\n", value_data_str );
}
}
status = ProArrayFree( (ProArray*)&p_values );
TEST_CALL_REPORT( "ProArrayFree()", "ProUtilFeatureElementsDump()",
status, status != PRO_TK_NO_ERROR );
}
return PRO_TK_NO_ERROR;
}
