// 导出至STL
void OnExportSTLActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
// 第1步：检查当前模型环境
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
// 选取面组
vector<ProSelection> arrSelQlt;
if (SelectObject(arrSelQlt, "dtmqlt"))
{
ProName mdlName;
ProMdlNameGet(pMdl, mdlName);
CString strMdlName(mdlName);
ProFileName filename;
wcsncpy_s(filename, PRO_FILE_NAME_SIZE, strMdlName, _TRUNCATE);
// 选择保存位置
ProPath stlpath;
if (ProFileSave(NULL, L"*.stl", NULL, NULL, NULL, filename, stlpath) == PRO_TK_NO_ERROR)
{
CString strStlPath(stlpath);
ProGeomitem qltitem;
ProSelectionModelitemGet(arrSelQlt[0], &qltitem);
ProQuilt quilt;
ProGeomitemToQuilt(&qltitem, &quilt);
vector<ProSurface> arrSurfs;
ProQuiltSurfaceVisit(quilt, QuiltSurfacesGetAction, NULL, &arrSurfs);
vector<ProGeomitem> arrSurfsItems;
for (int i=0; i<(int)arrSurfs.size(); i++)
{
ProGeomitem srfitem;
ProSurfaceToGeomitem(ProMdlToSolid(pMdl), arrSurfs[i], &srfitem);
arrSurfsItems.push_back(srfitem);
}
if (ExportStl(arrSurfsItems, strStlPath, 0.5, 1.0))
{
MessageBox(NULL, L"导出stl成功", L"提示", MB_OK);
}
else
MessageBox(NULL, L"导出stl失败", L"提示", MB_OK|MB_ICONWARNING);
}
}
InvalidateDrawing();
ProMessageClear();
}
// 单侧放量
void OnOffsetSingleActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
// 选择面
vector<ProSelection> arrSelQlt;
ShowMessageTip(L"Tips.选择要偏移的面...");
if (SelectObject(arrSelQlt, "surface"))
{
// 输入偏离值
double dOffset;
ShowMessageTip(L"输入偏移量，不能为0，但可以为负值：");
if (ProMessageDoubleRead(NULL, &dOffset) == PRO_TK_NO_ERROR)
{
// 判断面的方向
ProModelitem itemSurf;
ProSelectionModelitemGet(arrSelQlt[0], &itemSurf);
ProSurface surf;
ProGeomitemToSurface(&itemSurf, &surf);
ProGeomitemdata* psrfdata;
ProSurfaceDataGet(surf, &psrfdata);
if (psrfdata->data.p_surface_data->orient == PRO_SURF_ORIENT_IN)
dOffset = dOffset*(-1);
ProGeomitemdataFree(&psrfdata);
// 创建偏移特征
int nOffsetID = OffsetSurfaceWithSide(pMdl, arrSelQlt[0], dOffset);
if (nOffsetID > 0)
{
// 修改面颜色
ProFeature feat;
feat.id = nOffsetID;
feat.type = PRO_FEATURE;
feat.owner = pMdl;
vector<ProModelitem> arrQuilts;
ProFeatureGeomitemVisit(&feat, PRO_QUILT, FeatureGeomsGetAction, NULL, &arrQuilts);
for (int i=0; i<arrQuilts.size(); i++)
SetSurfColor(arrQuilts[i], 255, 215, 0);
}
}
}
InvalidateDrawing();
ProMessageClear();
}
// 整体放量
void OnOffsetGeneralActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
// 第1步：检查当前模型环境
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
// 第2步：选择要偏移的面
vector<ProSelection> arrSelSrf;
ShowMessageTip(L"Tips.选择要偏移的面...");
if (SelectObject(arrSelSrf, "dtmqlt"))
{
// 第3步：输入偏离值
double dOffset;
ShowMessageTip(L"输入偏移量，不能为0，但可以为负值：");
if (ProMessageDoubleRead(NULL, &dOffset) == PRO_TK_NO_ERROR)
{
// 第4步：创建偏移特征
ProModelitem itemQuilt;
int nOffsetID = OffsetQuilt(pMdl, arrSelSrf[0], dOffset, itemQuilt);
if (nOffsetID > 0)
{
SetSurfColor(itemQuilt, 255, 215, 0);
// 第5步：隐藏原包覆面
ProModelitem itemQuiltSel;
ProSelectionModelitemGet(arrSelSrf[0], &itemQuiltSel);
ProModelitemHide(&itemQuiltSel);
}
else
{
MessageBox(NULL, L"放量失败，详见模型特征树！", L"提示", MB_OK);
}
}
}
InvalidateDrawing();
ProMessageClear();
}
// 草绘裁剪
void OnTrimBySketchActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
ProError status;
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
// 选择草绘
vector<ProSelection> arrSel;
ShowMessageTip(L"Tips.选择草绘特征...");
while (SelectObject(arrSel, "feature"))
{
// 检查是否为草绘曲线
ProFeature featSketch;
status = ProSelectionModelitemGet(arrSel[0], &featSketch);
ProFeattype featType;
status = ProFeatureTypeGet(&featSketch, &featType);
if (featType == PRO_FEAT_CURVE)
{
ProAsmcomppath acomppath;
ProSelectionAsmcomppathGet(arrSel[0], &acomppath);
ProSelection selQuilt; // 待裁剪的平面
BOOL bGetQuilt = FALSE;
// 获取草绘曲线所在的平面
ProElement elemTreeCurve = NULL;
ProFeatureElemtreeExtract(&featSketch, NULL, PRO_FEAT_EXTRACT_NO_OPTS, &elemTreeCurve);
ProElempathItem pathItemType[1];
pathItemType[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItemType[0].path_item.elem_id = PRO_E_CURVE_TYPE;
ProElempath elemPathCurveType;
ProElempathAlloc(&elemPathCurveType);
ProElempathDataSet(elemPathCurveType, pathItemType, 1);
ProElement elemType;
status = ProElemtreeElementGet(elemTreeCurve, elemPathCurveType, &elemType);
if (status == PRO_TK_NO_ERROR)
{
ProValue valType;
status = ProElementValueGet(elemType, &valType);
ProValueData valdataType;
status = ProValueDataGet(valType, &valdataType);
if (valdataType.v.i == PRO_CURVE_TYPE_SKETCHED)
{
// 确定为草绘曲线，进而获取草绘平面
ProElempathItem pathItemSketchPlane[3];
pathItemSketchPlane[0].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItemSketchPlane[0].path_item.elem_id = PRO_E_STD_SECTION;
pathItemSketchPlane[1].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItemSketchPlane[1].path_item.elem_id = PRO_E_STD_SEC_SETUP_PLANE;
pathItemSketchPlane[2].type = PRO_ELEM_PATH_ITEM_TYPE_ID;
pathItemSketchPlane[2].path_item.elem_id = PRO_E_STD_SEC_PLANE;
ProElempath elemPathPlane;
ProElempathAlloc(&elemPathPlane);
ProElempathDataSet(elemPathPlane, pathItemSketchPlane, 3);
ProElement elemPlane;
status = ProElemtreeElementGet(elemTreeCurve, elemPathPlane, &elemPlane);
if (status == PRO_TK_NO_ERROR)
{
ProValue valPlane;
status = ProElementValueGet(elemPlane, &valPlane);
ProValueData valdataPlane;
status = ProValueDataGet(valPlane, &valdataPlane);
ProGeomitem itemSurf;
ProSelectionModelitemGet(valdataPlane.v.r, &itemSurf);
ProSurface surf;
ProGeomitemToSurface(&itemSurf, &surf);
// 获取面所在面组
ProQuilt quilt;
status = ProSurfaceQuiltGet(ProMdlToSolid(pMdl), surf, &quilt);
if (status == PRO_TK_NO_ERROR)
{
ProGeomitem itemQuilt;
status = ProQuiltToGeomitem(ProMdlToSolid(pMdl), quilt, &itemQuilt);
status = ProSelectionAlloc(&acomppath, &itemQuilt, &selQuilt);
bGetQuilt = TRUE;
}
}
}
}
if (!bGetQuilt)
{
ShowMessageTip(L"Tips.草绘的放置面非可裁剪面，请手动选择需裁剪的面...");
// 手动选取待裁剪的面
vector<ProSelection> arrSelSrf;
if (SelectObject(arrSelSrf, "dtmqlt"))
{
ProSelectionCopy(arrSelSrf[0], &selQuilt);
}
else
{
break;
}
}
// 遍历特征，获取特征中的全部复合曲线
vector<ProGeomitem> arrItemCurves;
status = ProFeatureGeomitemVisit(&featSketch, PRO_CURVE, FeatureGeomsGetAction, NULL, &arrItemCurves);
vector<int> arrFeatID;
for (int i=0; i<arrItemCurves.size(); i++)
{
ProCurve curve;
status = ProGeomitemToCurve(&arrItemCurves[i], &curve);
// 检查是否为复合曲线
ProEnttype curveType;
status = ProCurveTypeGet(curve, &curveType);
if (curveType == PRO_ENT_CMP_CRV)
{
// 进行裁剪
ProSelection selCurve;
status = ProSelectionAlloc(&acomppath, &arrItemCurves[i], &selCurve);
int nFeatID = TrimQuiltByCurve(pMdl, selQuilt, selCurve, PRO_EDGE_SAME_DIRECTION);
if (nFeatID > 0)
{
// 创建成功，记录特征ID
arrFeatID.push_back(nFeatID);
// 第8步：提示是否反向或继续修剪
CDlgConfirm dlg;
while (1)
{
int nResult = (int)dlg.DoModal();
if (nResult == IDOK)
{
break;
}
else if (nResult == IDRETRY)
{
// 修改裁剪方向
ProFeature feat;
feat.id = nFeatID;
feat.type = PRO_FEATURE;
feat.owner = pMdl;
ReverseTrimDirection(feat);
}
else
{
InvalidateDrawing();
ProMessageClear();
return;
}
}
}
}
}
// 合并成组
CreateFeatGroup(pMdl, arrFeatID, L"包覆面_裁剪");
break;
}
else
{
//
MessageBox(NULL, L"所选特征非草绘特征，请重新选择！", L"提示", MB_OK);
}
}
InvalidateDrawing();
ProMessageClear();
}
// 环边裁剪
void OnTrimByEdgeActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
// 第1步：检查当前模型环境
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
// 第2步：选择要裁剪的面
ShowMessageTip(L"Tips.选择需要裁剪的面...");
vector<ProSelection> arrSelSrf;
ProSelection selSrf = NULL;
while (SelectObject(arrSelSrf, "dtmqlt"))
{
ProSelectionCopy(arrSelSrf[0], &selSrf);
// 第3步：暂时隐藏选择的面，选取完成后恢复显示
ProModelitem itemQuilt;
ProSelectionModelitemGet(arrSelSrf[0], &itemQuilt);
ProModelitemHide(&itemQuilt);
// 第4步：选择面上的环（先选取环的一条边）
int nEdgeDir = PRO_EDGE_SAME_DIRECTION;
ProSelection *pArrSelInit = NULL;
ProArrayAlloc(0, sizeof(ProSelection), 1, (ProArray*)&pArrSelInit);
vector<ProSelection> arrSelEdge;
while (SelectObject(arrSelEdge, "sldedge"))
{
// 第5步：获取边所在环的全部边
vector<ProSelection> arrSelContourEdges;
if (GetContourByEdge(arrSelEdge[0], arrSelContourEdges, nEdgeDir))
{
for (int i=0; i<arrSelContourEdges.size(); i++)
{
ProArrayObjectAdd((ProArray*)&pArrSelInit, 0, 1, &arrSelContourEdges[i]);
}
break;
}
else
{
int nMsgResult = MessageBox(NULL, L"选取的边不是完整环的组成边，是否手动选取？\n是：手动选取；否：重新选取; 取消：退出", L"提示", MB_YESNOCANCEL|MB_ICONWARNING);
if (nMsgResult == IDYES) // 手动选择
{
ProArrayObjectAdd((ProArray*)&pArrSelInit, 0, 1, &arrSelEdge[0]);
break;
}
else if (nMsgResult == IDCANCEL) // 退出
{
ProModelitemUnhide(&itemQuilt);
InvalidateDrawing();
return;
}
}
}
// 第6步：自动选中对应完整环的全部边
arrSelEdge.clear();
if (SelectObject(arrSelEdge, "edge", MAX_SELECTION, pArrSelInit))
{
// 判断面的方向
/*ProQuilt quilt;
BOOL bSurfDirOut = FALSE;
ProGeomitemToQuilt(&itemQuilt, &quilt);
vector<ProSurface> arrSurfaces;
ProQuiltSurfaceVisit(quilt, QuiltSurfacesGetAction, NULL, &arrSurfaces);
ProGeomitemdata* psrfdata;
ProSurfaceDataGet(arrSurfaces[0], &psrfdata);
if (psrfdata->data.p_surface_data->orient == PRO_SURF_ORIENT_OUT)
bSurfDirOut = TRUE;
ProGeomitemdataFree(&psrfdata);*/
// 第7步：修剪曲面
int nFeatID = TrimQuiltByEdgeGroup(pMdl, selSrf, arrSelEdge, nEdgeDir);
ProModelitemUnhide(&itemQuilt);
SAFE_DELETE_PROARRAY(pArrSelInit);
if (nFeatID > 0)
{
// 第8步：提示是否反向或继续修剪
CDlgConfirm dlg;
while (1)
{
int nResult = (int)dlg.DoModal();
if (nResult == IDOK)
{
break;
}
else if (nResult == IDRETRY)
{
// 修改裁剪方向
ProFeature feat;
feat.id = nFeatID;
feat.type = PRO_FEATURE;
feat.owner = pMdl;
ReverseTrimDirection(feat);
}
else
{
InvalidateDrawing();
ProMessageClear();
return;
}
}
}
else if (MessageBox(NULL, L"裁剪失败，详见模型特征树。是否继续？", L"提示", MB_YESNO) == IDNO)
{
break;
}
}
else
{
// 恢复显示
ProModelitemUnhide(&itemQuilt);
break;
}
}
InvalidateDrawing();
ProMessageClear();
}
// 表面清理
void OnCleanActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
// 第1步：检查当前模型环境
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
// 第2步：选择参考
ShowMessageTip(L"Tips.选择几何平面进行清理，可多选...");
vector<ProSelection> arrSelSrf;
vector<ProModelitem> arrItemSrf;
while (SelectObject(arrSelSrf, "surface", MAX_SELECTION))
{
BOOL bError = FALSE;
// 第3步：创建基准面
for (int i=0; i<(int)arrSelSrf.size(); i++)
{
ProModelitem itemSurf;
ProSelectionModelitemGet(arrSelSrf[i], &itemSurf);
ProModelitem itemPlane;
int nDatumFeatID = CreateDatumPlane(pMdl, arrSelSrf[i], itemPlane);
if (nDatumFeatID > 0)
{
arrItemSrf.push_back(itemPlane);
}
}
// 第4步：创建实体化特征
for (int i=0; i<(int)arrItemSrf.size(); i++)
{
ProSelection selPlane;
ProSelectionAlloc(NULL, &arrItemSrf[i], &selPlane);
if (CreateSolidify(pMdl, selPlane) < 0)
{
bError = TRUE;
}
SAFE_DELETE_SELECTION(selPlane);
}
arrSelSrf.clear();
arrItemSrf.clear();
// 第5步：显示处理结果
if (bError && MessageBox(NULL, L"部分特征创建失败，详见模型特征树。是否继续？", L"提示", MB_YESNO) == IDNO)
{
break;
}
}
InvalidateDrawing();
ProMessageClear();
}
// 底面切除
void OnBottomCutActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
ProError status;
// 第1步：检查当前模型环境
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
// 第2步：选择参考
ShowMessageTip(L"Tips.选择拼接后的包覆面进行切除...");
vector<ProSelection> arrSelQlt;
ProSelection selQlt = NULL;
if (SelectObject(arrSelQlt, "dtmqlt"))
{
status = ProSelectionCopy(arrSelQlt[0], &selQlt);
// 第3步：暂时隐藏选择的面，选取完成后恢复显示
ProModelitem itemQuilt;
status = ProSelectionModelitemGet(arrSelQlt[0], &itemQuilt);
status = ProModelitemHide(&itemQuilt);
// 第4步：选择底面
ShowMessageTip(L"Tips.选择需要平齐的底面...");
vector<ProSelection> arrSelSrf;
if (SelectObject(arrSelSrf, "surface"))
{
status = ProModelitemUnhide(&itemQuilt);
// 第5步：以底面为参照创建基准面
ProModelitem itemPlane;
int nDatumFeatID = CreateDatumPlane(pMdl, arrSelSrf[0], itemPlane);
if (nDatumFeatID > 0)
{
ProSelection selRef;
status = ProSelectionAlloc(NULL, &itemPlane, &selRef);
int nFeatID = TrimSurfaceBySurf(pMdl, selQlt, selRef, 1);
if (nFeatID > 0)
{
// 第8步：提示是否反向或继续修剪
CDlgConfirm dlg;
while (1)
{
int nResult = (int)dlg.DoModal();
if (nResult == IDRETRY)
{
// 修改裁剪方向
ProFeature feat;
feat.id = nFeatID;
feat.type = PRO_FEATURE;
feat.owner = pMdl;
ReverseTrimDirection(feat);
}
else
{
break;
}
}
}
else
{
MessageBox(NULL, L"切除失败，详见模型特征树！", L"提示", MB_OK);
}
}
}
else
status = ProModelitemUnhide(&itemQuilt);
}
InvalidateDrawing();
ProMessageClear();
}
// 拼接（智能选取）
void OnMergeAutoActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
ProMdl pMdl = GetCurrentMdl();
if (pMdl == NULL)
{
MessageBox(NULL, L"当前环境未发现模型！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
ProError status;
// 选取一个包覆面
ShowMessageTip(L"Tips.选择需要拼接的包覆面...");
vector<ProSelection> arrSelQuilts;
if (SelectObject(arrSelQuilts, "dtmqlt"))
{
ProModelitem itemQuiltStart;
status = ProSelectionModelitemGet(arrSelQuilts[0], &itemQuiltStart);
ProQuilt quiltStart;
status = ProGeomitemToQuilt(&itemQuiltStart, &quiltStart);
vector<ProQuilt> arrQuiltMerge;
arrQuiltMerge.push_back(quiltStart);
// 获取全部Quilt
vector<ProQuilt> arrQuilt;
status = ProSolidQuiltVisit(ProMdlToSolid(pMdl), SolidQuiltsGetAction, NULL, &arrQuilt);
ProQuilt quiltCurr;
for (int i=0; i<arrQuiltMerge.size(); i++)
{
quiltCurr = arrQuiltMerge[i];
for (int j=0; j<arrQuilt.size(); )
{
if (quiltCurr == arrQuilt[j])
{
// 剔除自身
arrQuilt.erase(arrQuilt.begin()+j);
continue;
}
if (CheckTwoQuiltNeighbor(pMdl, quiltCurr, arrQuilt[j]))
{
arrQuiltMerge.push_back(arrQuilt[j]);
arrQuilt.erase(arrQuilt.begin()+j);
continue;
}
j++;
}
}
vector<ProSelection> arrSelMergeQuilt;
for (int i=0; i<arrQuiltMerge.size(); i++)
{
ProModelitem itemQuilt;
ProQuiltToGeomitem(ProMdlToSolid(pMdl), arrQuiltMerge[i], &itemQuilt);
ProSelection selQuilt = NULL;
ProSelectionAlloc(NULL, &itemQuilt, &selQuilt);
arrSelMergeQuilt.push_back(selQuilt);
}
ProFeature featMerge;
MergeQuilts(pMdl, arrSelMergeQuilt, PRO_SRF_MRG_INTSCT, featMerge);
}
InvalidateDrawing();
ProMessageClear();
}
/*====================================================================*\
FUNCTION : ProUtilFeatureDump()
PURPOSE : To write a decription of a feature to a text file
\*====================================================================*/
void ProUtilFeatureDump(
ProModelitem *feature,
FILE *fp)
{
ProError status;
ProSolid owner;
ProAsmcomppath path;
ProModelitem modelitem;
int n_children, c, n_parents, p;
ProPatternStatus pstatus;
ProGrppatternStatus gpstatus;
ProFeatStatus fstatus;
ProGroupStatus gstatus;
ProSelection selection;
char model_name[PRO_NAME_SIZE], model_type[PRO_NAME_SIZE];
int m;
ProFeattype ftype;
char ftype_str[PRO_NAME_SIZE];
int *children_ids, *parents_ids;
ProBoolean is_nc_seq;
ProWVerstamp stamp;
char* p_stamp_string;
/*--------------------------------------------------------------------*\
Check the feature owner
\*--------------------------------------------------------------------*/
status = ProModelitemMdlGet(feature, (ProMdl *) &owner);
TEST_CALL_REPORT("ProModelitemMdlGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
ProUtilModelnameGet((ProMdl*)&owner, model_name, model_type);
ProTKFprintf(fp,"Owner : %s.%s\n", model_name, model_type);
/*--------------------------------------------------------------------*\
Check the feature owner
\*--------------------------------------------------------------------*/
status = ProFeatureSolidGet(feature, &owner);
TEST_CALL_REPORT("ProFeatureSolidGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
ProUtilModelnameGet((ProMdl*)&owner, model_name, model_type);
ProTKFprintf(fp,"Sld Owner : %s.%s\n", model_name, model_type);
/*--------------------------------------------------------------------*\
Get the list of children of the selected feature
\*--------------------------------------------------------------------*/
status = ProFeatureChildrenGet(feature, &children_ids, &n_children);
TEST_CALL_REPORT("ProFeatureChildrenGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
ProTKFprintf(fp, "Children : ");
for(c=0; c<n_children; c++)
ProTKFprintf(fp,"%d ", children_ids[c]);
ProTKFprintf(fp,"\n");
/*--------------------------------------------------------------------*\
Get the list of parents of the selected feature
\*--------------------------------------------------------------------*/
status = ProFeatureParentsGet(feature, &parents_ids, &n_parents);
TEST_CALL_REPORT("ProFeatureParentsGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
ProTKFprintf(fp, "Parents : ");
for(p=0; p<n_parents; p++)
ProTKFprintf(fp,"%d ", parents_ids[p]);
ProTKFprintf(fp,"\n");
/*--------------------------------------------------------------------*\
Get the version stamp of the specified feature
\*--------------------------------------------------------------------*/
status = ProVerstampAlloc( &stamp );
TEST_CALL_REPORT("ProVerstampAlloc()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
status = ProFeatureVerstampGet( feature, &stamp );
TEST_CALL_REPORT("ProFeatureVerstampGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
status = ProVerstampStringGet( stamp, &p_stamp_string );
TEST_CALL_REPORT("ProVerstampStringGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
ProTKFprintf( fp,"Version stamp: %s\n", p_stamp_string );
status = ProVerstampStringFree( &p_stamp_string );
TEST_CALL_REPORT("ProVerstampStringFree()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
status = ProVerstampFree( &stamp );
TEST_CALL_REPORT("ProVerstampFree()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
Get the feature status
\*--------------------------------------------------------------------*/
status = ProFeatureStatusGet(feature, &fstatus);
TEST_CALL_REPORT("ProFeatureStatusGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
ProTKFprintf(fp, "FEATURE STATUS ");
switch(fstatus)
{
case PRO_FEAT_INVALID:
ProTKFprintf(fp, "Invalid\n");
break;
case PRO_FEAT_ACTIVE:
ProTKFprintf(fp, "Active\n");
break;
case PRO_FEAT_INACTIVE:
ProTKFprintf(fp, "Inactive\n");
break;
case PRO_FEAT_FAMTAB_SUPPRESSED:
ProTKFprintf(fp, "Famtab suppressed\n");
break;
case PRO_FEAT_SIMP_REP_SUPPRESSED:
ProTKFprintf(fp,"Simprep suppressed\n");
break;
case PRO_FEAT_PROG_SUPPRESSED:
ProTKFprintf(fp,"Pro/PROGRAM suppressed\n");
break;
case PRO_FEAT_SUPPRESSED:
ProTKFprintf(fp, "Suppressed\n");
break;
case PRO_FEAT_UNREGENERATED:
ProTKFprintf(fp, "Unregenerated\n");
break;
default:
ProTKFprintf(fp, "**UNKNOWN**\n");
break;
}
/*--------------------------------------------------------------------*\
Get the group status of the feature
\*--------------------------------------------------------------------*/
status = ProFeatureGroupStatusGet( feature, &gstatus );
TEST_CALL_REPORT("ProFeatureGroupStatusGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
ProTKFprintf(fp, "GROUP STATUS ");
switch(gstatus)
{
case PRO_GROUP_INVALID:
ProTKFprintf(fp, "Invalid\n");
break;
case PRO_GROUP_NONE:
ProTKFprintf(fp, "None\n");
break;
case PRO_GROUP_MEMBER:
ProTKFprintf(fp, "Group member\n");
break;
default:
ProTKFprintf(fp, "**UNKNOWN**\n");
break;
}
/*--------------------------------------------------------------------*\
Get the pattern status of the feature
\*--------------------------------------------------------------------*/
status = ProFeaturePatternStatusGet(feature, &pstatus);
TEST_CALL_REPORT("ProFeaturePatternStatusGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
status = ProFeatureGrppatternStatusGet(feature, &gpstatus);
TEST_CALL_REPORT("ProFeatureGrppatternStatusGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
ProTKFprintf(fp, "PATTERN STATUS ");
switch(pstatus)
{
case PRO_PATTERN_LEADER:
ProTKFprintf(fp, "Leader of a feature pattern\n");
break;
case PRO_PATTERN_MEMBER:
ProTKFprintf(fp, "Member of a feature pattern\n");
break;
default:
break;
}
switch(gpstatus)
{
case PRO_GRP_PATTERN_LEADER:
ProTKFprintf(fp, "Leader of a group pattern\n");
break;
case PRO_GRP_PATTERN_MEMBER:
ProTKFprintf(fp, "Member of a group pattern\n");
break;
case PRO_GRP_PATTERN_NONE:
if (pstatus == PRO_PATTERN_NONE)
ProTKFprintf(fp, "Not a pattern member\n");
break;
default:
break;
}
/*--------------------------------------------------------------------*\
Get elements info.
\*--------------------------------------------------------------------*/
ProUtilFeatureElementsDump( feature, fp);
/*--------------------------------------------------------------------*\
Find whether the feature is an NC sequence
\*--------------------------------------------------------------------*/
status = ProFeatureIsNcseq(feature, &is_nc_seq);
if ( is_nc_seq == PRO_B_TRUE )
ProTKFprintf(fp, "Feature is an NC Sequence\n");
TEST_CALL_REPORT("ProFeatureIsNcseq()", "ProUtilFeatureDump()",
PRO_TK_NO_ERROR, status != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
Find out whether the feature is created in an assembly
\*--------------------------------------------------------------------*/
status = ProFeatureSelectionGet(feature, &selection);
TEST_CALL_REPORT("ProFeatureSelectionGet()", "ProUtilFeatureDump()",
status, ((status != PRO_TK_NO_ERROR) &&
(status != PRO_TK_BAD_CONTEXT) &&
(status != PRO_TK_E_NOT_FOUND)));
if(!(status == PRO_TK_BAD_CONTEXT))
if(status == PRO_TK_E_NOT_FOUND)
{
ProTKFprintf(fp,"ASSEMBLY REFERENCES :\n");
ProTKFprintf(fp," (Assembly is not in session)\n");
}
else if(status == PRO_TK_NO_ERROR)
{
ProTKFprintf(fp,"ASSEMBLY REFERENCES :\n");
status = ProSelectionAsmcomppathGet(selection, &path);
TEST_CALL_REPORT("ProSelectionAsmcomppathGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
status = ProSelectionModelitemGet(selection, &modelitem);
TEST_CALL_REPORT("ProSelectionModelitemGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
/*--------------------------------------------------------------------*\
Assembly name
\*--------------------------------------------------------------------*/
ProUtilModelnameGet((ProMdl*)&path.owner, model_name, model_type);
ProTKFprintf(fp," Owning model : %s.%s\n", model_name, model_type);
/*--------------------------------------------------------------------*\
Feature id and type
\*--------------------------------------------------------------------*/
status = ProFeatureTypeGet(&modelitem, &ftype);
TEST_CALL_REPORT("ProFeatureTypeGet()", "ProUtilFeatureDump()",
status, status != PRO_TK_NO_ERROR);
ProUtilFeattypeStr(ftype, ftype_str);
ProTKFprintf(fp," Feature : %d, type %s\n", modelitem.id, ftype_str);
/*--------------------------------------------------------------------*\
Component id table
\*--------------------------------------------------------------------*/
if (path.table_num > 0)
{
ProTKFprintf(fp," comp_id_table ");
for(m=0; m<path.table_num; m++)
ProTKFprintf(fp,"%d", path.comp_id_table[m]);
ProTKFprintf(fp, "\n");
}
}
}
