/*===============================================================*\
FUNCTION : ProUtilFeatCreate
PURPOSE : Creates feature in no mode option
returns :
PRO_TK_NO_ERROR - Successfully executed
\*===============================================================*/
ProError ProUtilFeatCreate(ProAsmcomppath *p_comp_path ,ProMdl model,
ProElement pro_e_feature_tree,
ProFeature *feature)
{
ProError status = PRO_TK_GENERAL_ERROR;
ProSelection model_sel;
ProModelitem model_item;
ProErrorlist p_errors;
ProFeatureCreateOptions no_mode_option[1];
int no_opts = 1;
no_mode_option[0] = PRO_FEAT_CR_NO_OPTS;
status = ProMdlToModelitem( model, &model_item );
TEST_CALL_REPORT("ProMdlToModelitem", "ProUtilFeatCreate",
status, status != PRO_TK_NO_ERROR );
status = ProSelectionAlloc (p_comp_path, &model_item, &model_sel);
status = ProFeatureCreate (model_sel, pro_e_feature_tree,
no_mode_option, no_opts, feature, &p_errors);
TEST_CALL_REPORT("ProFeatureCreate", "ProUtilFeatCreate",
status, status != PRO_TK_NO_ERROR );
ProSelectionFree(&model_sel);
return status;
}
// 检查函数
int CSDMdlAttrFeaSystemCheck::CheckAction(void *pData, const CheckRule &checkRule, CheckResult &checkResult)
{
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
if (!IsMdlTypeValid(pMdl, checkRule.dwMdlFilter))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 检查输入值有效性
if (checkRule.arrRuleContent.GetSize() < 1)
{
checkResult.nResultType = CHECK_RESULT_INVALID_INPUT;
return checkResult.nResultType;
}
ProError status;
checkResult.nResultType = CHECK_RESULT_NO_ERROR;
checkResult.arrErrorItems.RemoveAll();
ProModelitem mdlItem;
ProMdlToModelitem(pMdl, &mdlItem);
CString strFeaType, strFeaName;
NameFeaVisitData visitData;
ErrorItem errItem;
CStringArray arrFeatures;
CStringToCStringArray(checkRule.arrRuleContent[0], arrFeatures);
for (int i=0; i<(int)arrFeatures.GetSize(); i++)
{
strFeaType = arrFeatures[i].Left(arrFeatures[i].Find(L"("));
int nCount = arrFeatures[i].Find(L")") - arrFeatures[i].Find(L"(")-1;
strFeaName = arrFeatures[i].Mid(arrFeatures[i].Find(L"(") + 1, nCount);
ParseParaValue(mdlItem, strFeaName, strFeaName);
strFeaName.MakeUpper();
int nFeaType=-1, nSubType=-1;
GetFeatTypeAndSubType(strFeaType, nFeaType, nSubType);
visitData.strCheckContent = strFeaName;
visitData.nFeaType = nFeaType;
visitData.nSubType = nSubType;
status = ProSolidFeatVisit((ProSolid)pMdl,
FeatureNameVisit,
FeatureNameFilter,
&visitData);
if (status != PRO_TK_USER_ABORT)
{
checkResult.nResultType = CHECK_RESULT_INVALID_VALUE;
errItem.nType = visitData.nFeaType;
errItem.strItemName = visitData.strCheckContent;
checkResult.arrErrorItems.Add(errItem);
}
}
return checkResult.nResultType;
}
// 加载包覆对象
void OnLoadSolidActFn()
{
/*if (!QuickCheckValidLicense(SMART_PROFESSIONAL))
return;*/
AFX_MANAGE_STATE(AfxGetStaticModuleState());
DestroyAllDialog();
CancelSelectDialog();
Sleep(50);
// 选择一个本地的待包覆模型
ProPath pathSelModel;
if (ProFileOpen(L"选择待包覆模型", L"*.prt,*.asm,*.stp,*.stl", NULL, NULL, NULL, NULL, pathSelModel) == PRO_TK_NO_ERROR)
{
ProPath pathFolder;
ProName nameModel, nameExt;
int nVersion;
ProFilenameParse(pathSelModel, pathFolder, nameModel, nameExt, &nVersion);
ProMdl pMdlToCoating;
if (CString(nameExt).CompareNoCase(L"stp") == 0 || CString(nameExt).CompareNoCase(L"step") == 0)
{
LoadStep(CString(pathSelModel), pMdlToCoating);
}
else
{
ProMdlLoad(pathSelModel, PRO_MDL_UNUSED, PRO_B_FALSE, &pMdlToCoating);
}
// 创建一个装配体
CString strSolidName;
strSolidName = nameModel;
strSolidName.Format(L"%s_3DCoat", strSolidName);
ProName nameSolid;
wcsncpy_s(nameSolid, PRO_NAME_SIZE, strSolidName, _TRUNCATE);
ProSolid solid;
ProSolidCreate(nameSolid, PRO_ASSEMBLY, &solid);
// 创建默认坐标系
ProError status;
ProElement elemTree = NULL;
ProElementAlloc(PRO_E_FEATURE_TREE, &elemTree);
{
// 特征类型PRO_E_FEATURE_TYPE
ProElement elemType;
status = ProElementAlloc(PRO_E_FEATURE_TYPE, &elemType);
status = ProElemtreeElementAdd(elemTree, NULL, elemType);
ProValueData valdataType;
valdataType.type = PRO_VALUE_TYPE_INT;
valdataType.v.i = PRO_FEAT_CSYS;
ProValue valueType = NULL;
status = ProValueAlloc(&valueType);
status = ProValueDataSet(valueType, &valdataType);
status = ProElementValueSet(elemType, valueType);
}
ProModelitem itemAssmble;
ProMdlToModelitem(ProAssemblyToMdl(solid), &itemAssmble);
ProSelection selAssmble;
ProSelectionAlloc(NULL, &itemAssmble, &selAssmble);
ProErrorlist errorsList;
ProFeatureCreateOptions opts[1] = {PRO_FEAT_CR_NO_OPTS};
ProFeature feat;
status = ProFeatureCreate(selAssmble, elemTree, opts, 1, &feat, &errorsList);
// 将选择的待装配模型装配到装配体下
ProMatrix initPos = {
{1.0, 0.0, 0.0, 0.0},
{0.0, 1.0, 0.0, 0.0},
{0.0, 0.0, 1.0, 0.0},
{0.0, 0.0, 0.0, 1.0}
};
ProAsmcomp comp;
ProAsmcompAssemble(ProAssembly(solid), ProMdlToSolid(pMdlToCoating), initPos, &comp);
ProAsmcompconstraint compConstr;
ProAsmcompconstraintAlloc(&compConstr);
ProAsmcompconstraintTypeSet(compConstr, PRO_ASM_DEF_PLACEMENT);
ProAsmcompconstraint* compConstrs;
ProArrayAlloc (0, sizeof (ProAsmcompconstraint), 1, (ProArray*)&compConstrs);
status = ProArrayObjectAdd ((ProArray*)&compConstrs, -1, 1, &compConstr);
ProAsmcompConstraintsSet(NULL, &comp, compConstrs);
ProMdlDisplay(solid);
int nWnd;
ProWindowCurrentGet(&nWnd);
ProWindowActivate(nWnd);
}
InvalidateDrawing();
ProMessageClear();
}
// 生成包覆体
void OnCreateBodyActFn()
{
/*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;
}
ProMdlType typeMdl;
ProMdlTypeGet(pMdl, &typeMdl);
if (typeMdl != PRO_MDL_ASSEMBLY)
{
MessageBox(NULL, L"该功能仅在装配环境下有效！", L"提示", MB_OK|MB_ICONWARNING);
return;
}
//ExportElemTreeXML();
// 选择一个面组
vector<ProSelection> arrSelQlt;
ShowMessageTip(L"Tips.选择要加厚的包覆面...");
if (SelectObject(arrSelQlt, "dtmqlt"))
{
// 输入整体加厚值
double dThickValue;
ShowMessageTip(L"指定厚度值，不能为0，负值表示向内加厚：");
if (ProMessageDoubleRead(NULL, &dThickValue) == PRO_TK_NO_ERROR)
{
// 创建发布几何
int nPubFeatID = CreatePublishGeom(pMdl, arrSelQlt[0]);
ProName nameAsm;
ProMdlNameGet(pMdl, nameAsm);
CString strNamePart = nameAsm;
ProName namePart;
for (int i=101; ;i++)
{
CString strTemp;
strTemp.Format(L"%s_%d", nameAsm, i);
wcsncpy_s(namePart, PRO_NAME_SIZE, strTemp, _TRUNCATE);
ProMdl pMdlTemp;
if (ProMdlInit(namePart, PRO_MDL_PART, &pMdlTemp) == PRO_TK_E_NOT_FOUND)
break;
}
// 新建一个零件
ProAsmcomp compPart;
ProAsmcompCreateCopy(ProMdlToAssembly(pMdl), namePart, PRO_MDL_PART, NULL, PRO_B_FALSE, &compPart);
//ProSolidRegenerate(pMdl);
ProMdl pMdlPart;
ProAsmcompMdlGet(&compPart, &pMdlPart);
ProModelitem itemAsm;
ProMdlToModelitem(pMdl, &itemAsm);
ProSelection selAsm;
ProSelectionAlloc(NULL, &itemAsm, &selAsm);
ProFeature featPub;
featPub.id = nPubFeatID;
featPub.owner = pMdl;
featPub.type = PRO_FEATURE;
ProSelection selPubFeat;
ProSelectionAlloc(NULL, &featPub, &selPubFeat);
// 创建复制几何
ProModelitem itemCopyQuilt;
CreateCopyGeom(pMdlPart, selAsm, selPubFeat, itemCopyQuilt);
ProSelection selCopyQuilt;
ProSelectionAlloc(NULL, &itemCopyQuilt, &selCopyQuilt);
// 弹出提示：是否要对单个面设置厚度
if (MessageBox(NULL, L"是否要对单个面设置厚度", L"提示", MB_YESNO|MB_ICONQUESTION) == IDYES)
{
ProMdlDisplay(pMdlPart);
int nWndIDPart;
ProMdlWindowGet(pMdlPart, &nWndIDPart);
ProWindowActivate(nWndIDPart);
// 弹出对话框
if (g_pDlgThick != NULL)
{
if (g_pDlgThick->GetSafeHwnd() != NULL)
g_pDlgThick->DestroyWindow();
SAFE_DELETE_POINTER(g_pDlgThick);
}
g_pDlgThick = new CDlgSetThick();
g_pDlgThick->InitSurfData(pMdl, selCopyQuilt, dThickValue);
g_pDlgThick->Create(IDD_DLG_SETTHICK);
g_pDlgThick->ShowWindow(SW_SHOW);
}
else
{
ThickQuilt(pMdlPart, selCopyQuilt, dThickValue);
}
}
}
InvalidateDrawing();
ProMessageClear();
}
// 检查开始，传出检查结果
int CSDMdlAttrMatDensCheck::CheckAction(void *pData, const CheckRule &checkRule, CheckResult &checkResult)
{
// 检查模型句柄有效性
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 检查模型类型有效性
if (!IsMdlTypeValid(pMdl, checkRule.dwMdlFilter))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 检查输入值有效性
if (checkRule.arrRuleContent.GetCount() < 1)
{
checkResult.nResultType = CHECK_RESULT_INVALID_INPUT;
return checkResult.nResultType;
}
// 解析材料和密度对应表
CStringArray arrItems;
CStringToCStringArray(checkRule.arrRuleContent[0], arrItems);
MdlMatDensArray arrMatDens;
for (int i = 0; i < arrItems.GetSize(); i ++)
{
MdlMatDens tempMatDens;
tempMatDens.strMatName = arrItems[i].Left(arrItems[i].Find(L"("));
int nCount = arrItems[i].Find(L")") - arrItems[i].Find(L"(") - 1;
tempMatDens.dDens = _wtof(arrItems[i].Mid(arrItems[i].Find(L"(") + 1, nCount));
arrMatDens.Add(tempMatDens);
}
// 判断是否使用材料关联参数
BOOL bUsePara = FALSE;
CString strParaName;
if (checkRule.arrRuleContent.GetCount() >=2)
{
strParaName = checkRule.arrRuleContent[1];
if (strParaName.CompareNoCase(L"") != 0)
bUsePara = TRUE;
}
ProError status;
ErrorItem errItem;
// 获取当前材料名称、密度值和单位
CString strMatName;
double dScale, dDensity;
if (bUsePara)
{
ProModelitem mdlItem;
ProMdlToModelitem(pMdl, &mdlItem);
if (!GetSDParameter(&mdlItem, strParaName, strMatName, FALSE))
{
checkResult.nResultType = CHECK_RESULT_ITEM_NOT_FOUND;
return CHECK_RESULT_ITEM_NOT_FOUND;
}
ProParameter para;
GetSDParameter(&mdlItem, L"MP_DENSITY", para, NULL);
ProParamvalue paraValue;
ProParameterValueGet(¶, ¶Value);
ProUnititem unit;
ProParameterUnitsGet(¶, &unit);
ProPath expression;
ProUnitExpressionGet(&unit, expression);
dScale = GetConvertFactor(CString(expression));
dDensity = paraValue.value.d_val*dScale;
}
else
{
// 能否获取材料密度
ProMaterial mdlMat;
if (ProMaterialCurrentGet(ProMdlToSolid(pMdl), &mdlMat) != PRO_TK_NO_ERROR)
{
checkResult.nResultType = CHECK_RESULT_ITEM_NOT_FOUND;
return CHECK_RESULT_ITEM_NOT_FOUND;
}
strMatName = mdlMat.matl_name;
/*ProMaterialdata matdata;
ProMaterialDataGet(&mdlMat, &matdata);
double dDensity = matdata.mass_density;*/
ProMaterialItem matItem;
status = ProModelitemByNameInit(pMdl, PRO_RP_MATERIAL, mdlMat.matl_name, &matItem);
ProParamvalue val;
ProUnititem mdlUnit;
if (ProMaterialPropertyGet(&matItem, PRO_MATPROP_MASS_DENSITY, &val, &mdlUnit) != PRO_TK_NO_ERROR)
{
checkResult.nResultType = CHECK_RESULT_UNKNOWN_ERROR;
return CHECK_RESULT_UNKNOWN_ERROR;
}
ProPath expression;
ProUnitExpressionGet(&mdlUnit, expression);
dScale = GetConvertFactor(CString(expression));
dDensity = val.value.d_val*dScale;
}
checkResult.arrErrorItems.RemoveAll();
checkResult.nResultType = CHECK_RESULT_INVALID_VALUE;
errItem.strItemName = strMatName;
checkResult.arrErrorItems.Add(errItem);
errItem.strItemName.Format(L"%g", dDensity);
checkResult.arrErrorItems.Add(errItem);
errItem.strItemName.Format(L"%g", dScale);
checkResult.arrErrorItems.Add(errItem);
for (int i = 0; i< arrMatDens.GetCount(); ++i)
{
// 匹配材料名
if (strMatName.CompareNoCase(arrMatDens[i].strMatName) == 0)
{
errItem.strItemName.Format(L"%g", arrMatDens[i].dDens);
checkResult.arrErrorItems.Add(errItem);
// 检查密度值
if (ISDNEAR(arrMatDens[i].dDens, dDensity))
{
checkResult.nResultType = CHECK_RESULT_NO_ERROR;
}
else
{
checkResult.nResultType = CHECK_RESULT_ERROR_VALUE;
}
return checkResult.nResultType;
}
}
return CHECK_RESULT_INVALID_VALUE;
}
ProError SetParametricParameter(
e_force force,
const std::string &in_model_name,
ProMdl *in_p_model,
const std::string in_ParameterName,
e_CADParameterType in_ParameterType,
const std::string in_ParameterValue)
throw (isis::application_exception)
{
ProError result = PRO_TK_NO_ERROR;
std::stringstream msg("SetParametricParameter: (force) ");
isis_LOG(lg, isis_FILE, isis_INFO) << " SetParametricParameter CADParameter"
<< isis_EOL << " Force " << force
<< isis_EOL << " Model Name " << in_model_name
<< isis_EOL << " Model Handle " << in_p_model
<< isis_EOL << " Type " << in_ParameterType
<< isis_EOL << " Name " << in_ParameterName
<< isis_EOL << " Value " << in_ParameterValue;
if (in_p_model == NULL) {
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << "null model handle";
return PRO_TK_BAD_INPUTS;
}
isis_LOG(lg, isis_FILE, isis_INFO) << "SetParametricParameter : Set up the parameter";
if ( in_ParameterName.size() >= PRO_NAME_SIZE ) {
msg << "Exceeded maximum number of characters : "
<< "Parameter Name: " << in_ParameterName << ", Maximum allowed characters: " << (PRO_NAME_SIZE - 1);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw isis::application_exception("C01001", msg);
}
ProName parameter_key;
ProStringToWstring(parameter_key, const_cast<char *>(in_ParameterName.c_str()) );
ProParamvalue parameter_value;
switch ( in_ParameterType ) {
case CAD_FLOAT:
parameter_value.type = PRO_PARAM_DOUBLE;
parameter_value.value.d_val = atof(in_ParameterValue.c_str());
break;
case CAD_INTEGER:
parameter_value.type = PRO_PARAM_INTEGER;
parameter_value.value.i_val = atoi(in_ParameterValue.c_str());
break;
case CAD_BOOLEAN:
parameter_value.type = PRO_PARAM_BOOLEAN;
parameter_value.value.l_val = isis::String_To_ProBoolean(in_ParameterValue);
break;
case CAD_STRING:
if ( in_ParameterValue.size() > MAX_STRING_PARAMETER_LENGTH )
{
msg << "Erroneous CADParameter string value: "
<< "Parameter: " << CADParameterType_string(in_ParameterType)
<< " Value: " << in_ParameterValue
<< ", Value must be " << MAX_STRING_PARAMETER_LENGTH << " characters or less.";
throw isis::application_exception(msg);
}
parameter_value.type = PRO_PARAM_STRING;
ProStringToWstring(parameter_value.value.s_val, const_cast<char *>(in_ParameterValue.c_str()));
break;
default:
msg << "Erroneous CADParameter Type: "
<< CADParameterType_string(in_ParameterType) << ", Should be FLOAT, INTEGER, or BOOLEAN.";
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw isis::application_exception(msg);
}
ProError status;
isis_LOG(lg, isis_FILE, isis_INFO) << "SetParametricParameter : get the model-item from the model";
ProModelitem model_item;
switch ( status = ProMdlToModelitem( *in_p_model, &model_item ) ) {
case PRO_TK_NO_ERROR:
{
isis_LOG(lg, isis_FILE, isis_INFO) << "The ProMdlToModelitem() was successful.";
break;
}
case PRO_TK_BAD_INPUTS:
{
msg << "ProMdlToModelitem: An argument is NULL, "
<< " model: " << in_p_model
<< " model-item: " << model_item;
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
case PRO_TK_INVALID_PTR:
{
msg << "ProMdlToModelitem: The handle is invalid. ";
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
}
isis_LOG(lg, isis_FILE, isis_INFO) << "SetParametricParameter : set the property";
ProParameter parameter_handle;
switch ( status = ProParameterInit(&model_item, parameter_key, ¶meter_handle) ) {
case PRO_TK_E_NOT_FOUND:
{
switch (force) {
case FORCE_KEY:
break;
case FORCE_VALUE:
{
msg << "key is not bound and should not be forced";
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
case FORCE_NEITHER:
{
msg << "force neither : not yet implemented";
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
}
isis_LOG(lg, isis_FILE, isis_INFO) << "The parameter was not found within the owner, so creating new.";
switch ( status = ProParameterCreate (&model_item, parameter_key, ¶meter_value, ¶meter_handle ) ) {
case PRO_TK_NO_ERROR:
{
isis_LOG(lg, isis_FILE, isis_INFO) << "ProParameterCreate successfully added the parameter.";
result = PRO_TK_E_NOT_FOUND;
break;
}
case PRO_TK_BAD_INPUTS:
{
msg << "One or more of the input arguments to ProParameterCreate() are invalid,"
<< " key: " << parameter_key
<< " param: " << parameter_handle.owner.type;
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
case PRO_TK_BAD_CONTEXT:
{
msg << "The owner is nonexistent.";
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
case PRO_TK_E_FOUND:
{
msg << "The specified parameter already exists.";
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
case PRO_TK_GENERAL_ERROR:
{
msg << "The function could not add the parameter to the database.";
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
}
}
case PRO_TK_NO_ERROR:
{
isis_LOG(lg, isis_FILE, isis_INFO) << "ProParameterInit() successfully initialized the handle.";
switch (force) {
case FORCE_KEY:
case FORCE_VALUE:
break;
case FORCE_NEITHER:
{
msg << "force neither : not yet implemented";
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
}
switch ( status = ProParameterValueSet(¶meter_handle, ¶meter_value) ) {
case PRO_TK_NO_ERROR:
{
isis_LOG(lg, isis_FILE, isis_INFO) << "ProParameterValueSet successfully updated the information.";
result = PRO_TK_NO_ERROR;
break;
}
case PRO_TK_E_NOT_FOUND:
{
msg << "The owner was not found.";
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
case PRO_TK_GENERAL_ERROR:
{
msg << "The parameter was not found, or the function could not perform the action.";
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
}
break;
}
case PRO_TK_BAD_INPUTS:
{
msg << "One or more of the input arguments are invalid,"
<< " key: " << parameter_key
<< " param: " << parameter_handle.owner.type;
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
case PRO_TK_BAD_CONTEXT:
{
msg << "The owner is nonexistent.";
isis::application_exception ex(msg);
isis_LOG(lg, isis_CONSOLE_FILE, isis_ERROR) << msg.str();
throw ex;
}
}
isis_LOG(lg, isis_FILE, isis_INFO) << "SetParametricParameter : COMPLETE";
return result;
} // end ForceParametricParameter
// 检查开始
int CSDMdlAttrParaKeywordCheck::CheckAction(void *pData, const CheckRule &checkRule, CheckResult &checkResult)
{
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
if (!IsMdlTypeValid(pMdl, checkRule.dwMdlFilter))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 模型是否符合过滤器要求
if (!IsFilterValid(checkRule.strRuleName, pMdl))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 检查输入值有效性
if (checkRule.arrRuleContent.GetCount() < 1)
{
checkResult.nResultType = CHECK_RESULT_INVALID_INPUT;
return checkResult.nResultType;
}
//-----------------------------------------------------------------------------------
ProModelitem mdlItem;
ProMdlToModelitem(pMdl, &mdlItem);
checkResult.arrErrorItems.RemoveAll();
// 解析参数
CStringArray arrItems;
CStringToCStringArray(checkRule.arrRuleContent[0], arrItems, L";");
CString strParaName;
CString strKeyword;
BOOL bDesignation;
for (int i = 0; i < arrItems.GetSize(); i ++)
{
strParaName = arrItems[i].Left(arrItems[i].Find(L"("));
int nCount = arrItems[i].Find(L")") - arrItems[i].Find(L"(")-1;
CString strProperty;
strProperty = arrItems[i].Mid(arrItems[i].Find(L"(") + 1, nCount);
CStringArray arrPropertys;
CStringToCStringArray(strProperty, arrPropertys, L",");
strKeyword = arrPropertys[0];
ParseParaValue(mdlItem, strKeyword, strKeyword);
bDesignation = _wtoi(arrPropertys[1]);
ProName paraname;
wcsncpy_s(paraname, PRO_NAME_SIZE, (LPCTSTR)strParaName, _TRUNCATE);
ProParameter para;
// 判断参数是否存在
ErrorItem item;
item.strItemName = strParaName;
item.nID = i;
CString strValue;
if (GetSDParameter(&mdlItem, paraname, para))
{
// 参数存在，得到字符串参数值
ProParamvalue paraValue;
ProParameterValueGet(¶, ¶Value);
if (paraValue.type == PRO_PARAM_STRING)
{
strValue = paraValue.value.s_val;
if (strValue.Find(strKeyword) < 0)
{
item.nType = PARAERROR_VALUE;
checkResult.arrErrorItems.Add(item);
}
else
{
// 检查是否指定
ProBoolean designation;
ProParameterDesignationVerify(¶, &designation);
if (bDesignation != designation)
{
item.nType = PARAERROR_DESIGNATION;
checkResult.arrErrorItems.Add(item);
}
}
}
else // 参数类型不匹配
{
item.nType = PARAERROR_TYPE;
checkResult.arrErrorItems.Add(item);
}
}
else
{
// 参数不存在
item.nType = PARAERROR_NOEXIST;
checkResult.arrErrorItems.Add(item);
}
}
if (checkResult.arrErrorItems.GetCount() > 0)
checkResult.nResultType = CHECK_RESULT_ERROR_VALUE;
else
checkResult.nResultType = CHECK_RESULT_NO_ERROR;
return checkResult.nResultType;
}
// 处理过程
BOOL CSDMdlAttrParaKeywordCheck::DoAction(void *pData, const CheckData &checkData)
{
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
return FALSE;
ProModelitem mdlItem;
ProMdlToModelitem(pMdl, &mdlItem);
CStringArray arrItems;
CStringToCStringArray(checkData.checkRule.arrRuleContent[0], arrItems, L";");
ErrorItemArray arr;
CStringArray arrFailedPara; // 修复失败的参数列表
arr.Copy(checkData.checkResult.arrErrorItems);
for (int i=0, nIndex=0; i<arr.GetCount(); i++)
{
// 获取参数需包含的关键字和是否指定
CString strKeyword;
BOOL bDesignation;
nIndex = arr[i].nID;
int nCount = arrItems[nIndex].Find(L")") - arrItems[nIndex].Find(L"(")-1;
CString strProperty;
strProperty = arrItems[nIndex].Mid(arrItems[nIndex].Find(L"(") + 1, nCount);
CStringArray arrPropertys;
CStringToCStringArray(strProperty, arrPropertys, L",");
strKeyword = arrPropertys[0];
ParseParaValue(mdlItem, strKeyword, strKeyword);
bDesignation = _wtoi(arrPropertys[1]);
// 如果类型不匹配，先删除原参数
if(arr[i].nType == PARAERROR_TYPE)
{
if (!DelSDParameter(&mdlItem, arr[i].strItemName, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
}
else if (arr[i].nType == PARAERROR_DESIGNATION)
{
GetSDParameter(&mdlItem, arr[i].strItemName, strKeyword, FALSE);
}
// 创建参数
if (!SetSDParameter(&mdlItem, arr[i].strItemName, strKeyword, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
// 修改指定关系
ProParameter para;
GetSDParameter(&mdlItem, arr[i].strItemName, para, FALSE);
if (bDesignation)
{
ProParameterDesignationAdd(¶);
}
else
ProParameterDesignationRemove(¶);
}
if (arrFailedPara.GetCount() > 0)
{
CString strResult;
strResult.Format(L"%s等%d个参数修复失败，请手动修复", arrFailedPara[0], arrFailedPara.GetCount());
MessageBox(NULL, strResult, L"提示", MB_OK|MB_ICONINFORMATION);
return FALSE;
}
return TRUE;
}
// 检查开始
int CSDMdlAttrParaSpecifiedValueCheck::CheckAction(void *pData, const CheckRule &checkRule, CheckResult &checkResult)
{
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
if (!IsMdlTypeValid(pMdl, checkRule.dwMdlFilter))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 模型是否符合过滤器要求
if (!IsFilterValid(checkRule.strRuleName, pMdl))
{
checkResult.nResultType = CHECK_RESULT_INVALID_MODEL;
return checkResult.nResultType;
}
// 检查输入值有效性
if (checkRule.arrRuleContent.GetCount() < 1)
{
checkResult.nResultType = CHECK_RESULT_INVALID_INPUT;
return checkResult.nResultType;
}
//-----------------------------------------------------------------------------------
ProModelitem mdlItem;
ProMdlToModelitem(pMdl, &mdlItem);
checkResult.arrErrorItems.RemoveAll();
// 解析参数
CStringArray arrItems;
CStringToCStringArray(checkRule.arrRuleContent[0], arrItems, L";");
CString strParaName;
int nParaType;
CString strParaValue;
BOOL bDesignation;
for (int i = 0; i < arrItems.GetSize(); i ++)
{
strParaName = arrItems[i].Left(arrItems[i].Find(L"("));
int nCount = arrItems[i].Find(L")") - arrItems[i].Find(L"(")-1;
CString strProperty;
strProperty = arrItems[i].Mid(arrItems[i].Find(L"(") + 1, nCount);
CStringArray arrPropertys;
CStringToCStringArray(strProperty, arrPropertys, L",");
nParaType = _wtoi(arrPropertys[0]);
strParaValue = arrPropertys[1];
ParseParaValue(mdlItem, strParaValue, strParaValue);
bDesignation = _wtoi(arrPropertys[2]);
ProName paraname;
wcsncpy_s(paraname, PRO_NAME_SIZE, (LPCTSTR)strParaName, _TRUNCATE);
ProParameter para;
// 判断参数是否存在
ErrorItem item;
item.strItemName = strParaName;
item.nID = i;
if (GetSDParameter(&mdlItem, paraname, para))
{
// 检查参数类型
ProParamvalue proval;
ProParameterValueGet(¶, &proval);
int nType = GetParaType(proval.type);
if (nType != nParaType)
{
item.nType = PARAERROR_TYPE;
checkResult.arrErrorItems.Add(item);
}
else
{
// 检查参数值
if (PARAM_STRING == nParaType)
{
if (strParaValue.Compare(proval.value.s_val) != 0)
{
item.nType = PARAERROR_VALUE;
checkResult.arrErrorItems.Add(item);
continue;
}
}
else if (PARAM_REAL == nParaType)
{
if (!DEQUAL(proval.value.d_val, _wtof(strParaValue)))
{
item.nType = PARAERROR_VALUE;
checkResult.arrErrorItems.Add(item);
continue;
}
}
else if (PARAM_INTEGER == nParaType)
{
if (proval.value.i_val != _wtoi(strParaValue))
{
item.nType = PARAERROR_VALUE;
checkResult.arrErrorItems.Add(item);
continue;
}
}
else if (PARAM_BOOL == nParaType)
{
if (proval.value.l_val != _wtoi(strParaValue))
{
item.nType = PARAERROR_VALUE;
checkResult.arrErrorItems.Add(item);
continue;
}
}
// 检查是否指定
ProBoolean designation;
ProParameterDesignationVerify(¶, &designation);
if (bDesignation != designation)
{
item.nType = PARAERROR_DESIGNATION;
checkResult.arrErrorItems.Add(item);
}
}
}
else
{
item.nType = PARAERROR_NOEXIST;
checkResult.arrErrorItems.Add(item);
}
}
if (checkResult.arrErrorItems.GetCount() > 0)
checkResult.nResultType = CHECK_RESULT_ERROR_VALUE;
else
checkResult.nResultType = CHECK_RESULT_NO_ERROR;
return checkResult.nResultType;
}
// 处理过程
BOOL CSDMdlAttrParaSpecifiedValueCheck::DoAction(void *pData, const CheckData &checkData)
{
ProMdl pMdl = (ProMdl)pData;
if (NULL == pMdl)
return FALSE;
ProModelitem mdlItem;
ProMdlToModelitem(pMdl, &mdlItem);
CStringArray arrItems;
CStringToCStringArray(checkData.checkRule.arrRuleContent[0], arrItems, L";");
ErrorItemArray arr;
CStringArray arrFailedPara; // 修复失败的参数列表
arr.Copy(checkData.checkResult.arrErrorItems);
for (int i=0, nIndex=0; i<arr.GetCount(); i++)
{
// 获取参数类型和是否指定
int nParaType;
BOOL bDesignation;
CString strParaValue;
nIndex = arr[i].nID;
int nCount = arrItems[nIndex].Find(L")") - arrItems[nIndex].Find(L"(")-1;
CString strProperty;
strProperty = arrItems[nIndex].Mid(arrItems[nIndex].Find(L"(") + 1, nCount);
CStringArray arrPropertys;
CStringToCStringArray(strProperty, arrPropertys, L",");
nParaType = _wtoi(arrPropertys[0]);
strParaValue = arrPropertys[1];
ParseParaValue(mdlItem, strParaValue, strParaValue);
bDesignation = _wtoi(arrPropertys[1]);
// 如果类型不匹配，先删除原参数
if(arr[i].nType == PARAERROR_TYPE)
{
if (!DelSDParameter(&mdlItem, arr[i].strItemName, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
}
else if (arr[i].nType == PARAERROR_DESIGNATION)
{
GetSDParameter(&mdlItem, arr[i].strItemName, strParaValue, FALSE);
}
// 创建参数
if (PARAM_STRING == nParaType)
{
if (!SetSDParameter(&mdlItem, arr[i].strItemName, strParaValue, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
}
else if (PARAM_REAL == nParaType)
{
double dVal = _wtof(strParaValue);
if (!SetSDParameter(&mdlItem, arr[i].strItemName, dVal, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
}
else if (PARAM_INTEGER == nParaType)
{
int nVal = _wtoi(strParaValue);
if (!SetSDParameter(&mdlItem, arr[i].strItemName, nVal, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
}
else if (PARAM_BOOL == nParaType)
{
ProBoolean bVal;
if (_wtoi(strParaValue) == 0)
bVal = PRO_B_FALSE;
else
bVal = PRO_B_TRUE;
if (!SetSDParameter(&mdlItem, arr[i].strItemName, bVal, FALSE))
{
arrFailedPara.Add(arr[i].strItemName);
continue;
}
}
// 修改指定关系
ProName paraname;
wcsncpy_s(paraname, PRO_NAME_SIZE, (LPCTSTR)arr[i].strItemName, _TRUNCATE);
ProParameter para;
if (GetSDParameter(&mdlItem, paraname, para))
{
if (bDesignation)
{
ProParameterDesignationAdd(¶);
}
else
ProParameterDesignationRemove(¶);
}
}
if (arrFailedPara.GetCount() > 0)
{
CString strResult;
strResult.Format(L"%s等%d个参数修复失败，请手动修复", arrFailedPara[0], arrFailedPara.GetCount());
MessageBox(NULL, strResult, L"提示", MB_OK|MB_ICONINFORMATION);
return FALSE;
}
return TRUE;
}
