/// <summary>
/// 创建唯一
/// </summary>
/// <param name="component"></param>
/// <param name="str"></param>
public static NXObject MakeUnique(NXOpen.Assemblies.Component component, string newFileName)
{
Part workPart = theSession.Parts.Work;
NXOpen.Assemblies.MakeUniquePartBuilder makeUniquePartBuilder1;
makeUniquePartBuilder1 = workPart.AssemblyManager.CreateMakeUniquePartBuilder();
bool added1;
added1 = makeUniquePartBuilder1.SelectedComponents.Add(component);
Tag partTag = theUFSession.Assem.AskPrototypeOfOcc(component.Tag);
try
{
NXOpen.Part part1 = (Part)NXObjectManager.Get(partTag);
part1.SetMakeUniqueName(newFileName);
NXOpen.NXObject nXObject1;
nXObject1 = makeUniquePartBuilder1.Commit();
return(nXObject1);
}
catch (Exception ex)
{
LogMgr.WriteLog("AssmbliesUtils:MakeUnique: " + ex.Message);
return(null);
}
finally
{
makeUniquePartBuilder1.Destroy();
}
}
//------------------------------------------------------------------------------
//Callback Name: apply_cb
//------------------------------------------------------------------------------
public int apply_cb()
{
int errorCode = 0;
try
{
//---- Enter your callback code here -----
Session.UndoMarkId markId = Session.GetSession().SetUndoMark(NXOpen.Session.MarkVisibility.Visible, "删除电极");
ElectrodeModel ele = new ElectrodeModel();
NXOpen.Assemblies.Component eleComp = this.selection_Ele.GetSelectedObjects()[0] as NXOpen.Assemblies.Component;
Part elePart = eleComp.Prototype as Part;
ele.GetModelForPart(elePart);
int ok = theUI.NXMessageBox.Show("删除", NXOpen.NXMessageBox.DialogType.Question, elePart.Name + "电极是否删除");
if (ok == 1)
{
string path = elePart.FullPath;
elePart.Close(NXOpen.BasePart.CloseWholeTree.False, NXOpen.BasePart.CloseModified.UseResponses, null);
AssmbliesUtils.DeleteComponent(eleComp);
LayerUtils.MoveDisplayableObject(ele.EleInfo.EleNumber + 10, LayerUtils.GetAllObjectsOnLayer(ele.EleInfo.EleNumber + 100));
if (File.Exists(path))
{
File.Delete(path);
}
}
}
catch (Exception ex)
{
//---- Enter your exception handling code here -----
errorCode = 1;
theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString());
}
return(errorCode);
}
//------------------------------------------------------------------------------
//Callback Name: apply_cb
//------------------------------------------------------------------------------
public int apply_cb()
{
int errorCode = 0;
try
{
//---- Enter your callback code here -----
NXOpen.Assemblies.Component ct = selection_Work.GetSelectedObjects()[0] as NXOpen.Assemblies.Component;
InterferenceBuilder builder = new InterferenceBuilder(ct.Prototype as Part);
AttributeUtils.AttributeOperation("Interference", true, (ct.Prototype as Part));
if (builder.CreateInterferenceBody())
{
theUI.NXMessageBox.Show("提示", NXMessageBox.DialogType.Error, "电极无过切");
}
else
{
theUI.NXMessageBox.Show("提示", NXMessageBox.DialogType.Error, "电极有过切");
}
// builder.CreateInterferenceFace();
// SewUtils.SewFeatureUF(GetSheetBodyOFPart(workPart));
// DeleteObject.DeleteParms(GetSheetBodyOFPart(workPart).ToArray());
}
catch (Exception ex)
{
//---- Enter your exception handling code here -----
errorCode = 1;
theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString());
}
return(errorCode);
}
public NXOpen.Assemblies.Component[] GetEleHideComp()
{
Part workPart = theSession.Parts.Work;
List <NXOpen.Assemblies.Component> hide = new List <NXOpen.Assemblies.Component>();
Part workpiece = GetWorkpiecePart();
foreach (NXOpen.Assemblies.Component workComp in workPart.ComponentAssembly.RootComponent.GetChildren())
{
workComp.Blank();
foreach (NXOpen.Assemblies.Component ct in workComp.GetChildren())
{
ct.Unblank();
NXOpen.Assemblies.Component[] edm = ct.GetChildren();
if (edm.Length != 0)
{
hide.Add(ct);
foreach (NXOpen.Assemblies.Component workpieceComp in edm)
{
workpieceComp.Unblank();
hide.Add(workpieceComp);
}
}
else
{
hide.Add(ct);
}
}
}
NXOpen.Assemblies.Component eleComp = AssmbliesUtils.GetPartComp(workPart, EleModel.PartTag);
hide.Remove(eleComp);
return(hide.ToArray());
}
//------------------------------------------------------------------------------
//Callback Name: apply_cb
//------------------------------------------------------------------------------
public int apply_cb()
{
int errorCode = 0;
try
{
//---- Enter your callback code here
bool anyPartsModified1;
NXOpen.PartSaveStatus partSaveStatus1;
Session.GetSession().Parts.SaveAll(out anyPartsModified1, out partSaveStatus1);
NXOpen.Assemblies.Component eleComp = this.SeleElePart.GetSelectedObjects()[0] as NXOpen.Assemblies.Component;
string name = eleComp.Name + "-" + this.StrName.Value.ToUpper();
if (!this.EleDuplicationOfName(name))
{
this.StrName.Value = "";
return(0);
}
ElectrodeModel eleModel = new ElectrodeModel();
eleModel.GetModelForPart(eleComp.Prototype as Part);
name = work.WorkpieceDirectoryPath + name + ".prt";
Vector3d movePt = new Vector3d(double_x.Value, double_y.Value, double_z.Value);
NXOpen.Assemblies.Component copyComp = AssmbliesUtils.MoveCompCopyPart(eleComp, movePt, work.WorkMatr);
AssmbliesUtils.MakeUnique(copyComp, name);
ElectrodeInfo newInfo = this.SetEleInfo(eleModel.EleInfo);
newInfo.SetAttribute(copyComp.Prototype as Part);
}
catch (Exception ex)
{
//---- Enter your exception handling code here -----
errorCode = 1;
theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString());
}
return(errorCode);
}
private void AlterEle(NXOpen.Assemblies.Component ct)
{
Part workPart = theSession.Parts.Work;
Part pt = ct.Prototype as Part;
ElectrodeNameInfo newNameInfo = new ElectrodeNameInfo()
{
EleEditionNumber = this.strEleEditionNumber.Value.ToUpper(),
EleName = this.strEleName.Value + this.strEleName1.Value.ToUpper(),
};
newNameInfo.EleNumber = newNameInfo.GetEleNumber(newNameInfo.EleName);
ReplaceElectrode el = new ReplaceElectrode(pt, newNameInfo);
Part newPart = null;
List <string> err = el.AlterEle(out newPart);
if (newPart != null)
{
err.AddRange(el.AlterEleDra());
List <NXObject> objs = AskEleAllInstance(newPart);
if (objs.Count > 0)
{
newNameInfo.SetAttribute(objs.ToArray());
}
}
PartUtils.SetPartDisplay(workPart);
if (err.Count > 0)
{
ClassItem.Print(err.ToArray());
}
}
//------------------------------------------------------------------------------
//Callback Name: apply_cb
//------------------------------------------------------------------------------
public int apply_cb()
{
int errorCode = 0;
try
{
//---- Enter your callback code here -----
Session.UndoMarkId markId;
markId = Session.GetSession().SetUndoMark(NXOpen.Session.MarkVisibility.Visible, "跑位");
WorkModel work = new WorkModel(workPart);
NXOpen.Assemblies.Component eleCt = this.SeleElePart.GetSelectedObjects()[0] as NXOpen.Assemblies.Component;
PositionElectrodeBuilder builder = new PositionElectrodeBuilder(eleCt, work);
if (this.double_x.Value == 0 && this.double_y.Value == 0 && this.double_z.Value == 0)
{
return(1);
}
else
{
Vector3d vec = new Vector3d(this.double_x.Value, this.double_y.Value, this.double_z.Value);
bool isok = builder.PositionBuilder(vec);
if (!isok)
{
theUI.NXMessageBox.Show("错误", NXMessageBox.DialogType.Error, "电极跑位错误！");
}
}
}
catch (Exception ex)
{
//---- Enter your exception handling code here -----
errorCode = 1;
theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString());
}
return(errorCode);
}
//------------------------------------------------------------------------------
//Callback Name: apply_cb
//------------------------------------------------------------------------------
public int apply_cb()
{
int errorCode = 0;
try
{
//---- Enter your callback code here -----
NXOpen.Assemblies.Component workCom = selection_Work.GetSelectedObjects()[0] as NXOpen.Assemblies.Component;
WorkModel work = new WorkModel(workCom.Prototype as Part);
InterferenceElectrodeBuilder builder = new InterferenceElectrodeBuilder(workCom, work);
List <string> err = builder.InterferenceBulider();
if (err.Count != 0)
{
theUI.NXMessageBox.Show("错误", NXMessageBox.DialogType.Error, "错误！");
ClassItem.Print(err.ToArray());
}
else
{
theUI.NXMessageBox.Show("提示", NXMessageBox.DialogType.Error, "电极正确！");
}
AttributeUtils.AttributeOperation("Interference", true, work.PartTag);
}
catch (Exception ex)
{
//---- Enter your exception handling code here -----
errorCode = 1;
theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString());
}
return(errorCode);
}
//------------------------------------------------------------------------------
//Callback Name: apply_cb
//------------------------------------------------------------------------------
public int apply_cb()
{
int errorCode = 0;
try
{
//---- Enter your callback code here -----
NXOpen.Assemblies.Component ct = this.seleComp.GetSelectedObjects()[0] as NXOpen.Assemblies.Component;
Part pt = ct.Prototype as Part;
string type = AttributeUtils.GetAttrForString(pt, "PartType");
if (type.Equals("Electrode", StringComparison.CurrentCultureIgnoreCase))
{
ElectrodeModel model = new ElectrodeModel();
model.GetModelForPart(pt);
ReplacePart.ReplaceElectrode(model, this.strEleName.Value.ToUpper());
}
else
{
ReplacePart.Replace(pt, this.strEleName.Value.ToUpper());
}
bool anyPartsModified;
PartSaveStatus saveStatus;
theSession.Parts.SaveAll(out anyPartsModified, out saveStatus);
}
catch (Exception ex)
{
//---- Enter your exception handling code here -----
errorCode = 1;
theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString());
}
return(errorCode);
}
/// <summary>
/// 获取隐藏
/// </summary>
/// <returns></returns>
public NXOpen.Assemblies.Component[] GetHideComp()
{
List <NXOpen.Assemblies.Component> hides = new List <NXOpen.Assemblies.Component>();
NXOpen.Assemblies.Component workComp = work.PartTag.ComponentAssembly.RootComponent;
foreach (NXOpen.Assemblies.Component ct in workComp.GetChildren())
{
NXOpen.Assemblies.Component[] edm = ct.GetChildren();
if (edm.Length != 0)
{
ct.Unblank();
foreach (NXOpen.Assemblies.Component cp in edm)
{
cp.Unblank();
if (!cp.Name.Equals(this.workpiece.Name))
{
hides.Add(cp);
}
}
}
else
{
hides.Add(ct);
}
}
return(hides.ToArray());
}
/// <summary>
/// 创建Work
/// </summary>
/// <param name="workpiece"></param>
/// <param name="mat"></param>
/// <param name="user"></param>
/// <returns></returns>
private List <string> CreateNewWork(NXOpen.Assemblies.Component ct, WorkpieceModel workpiece, Matrix4 mat, UserModel user)
{
List <string> err = new List <string>();
MoldInfo moldInfo = workpiece.Info.MoldInfo;
int num = asmColl.GetWorkCollection(moldInfo).Work.Count;
WorkInfo workInfo = new WorkInfo(workpiece.Info.MoldInfo, user, num + 1, mat);
EDMModel edm = GetEdm(ct);
if (edm == null)
{
err.Add("获取EDM错误");
return(err);
}
WorkCreateAssmbile create;
if (edm.Info.MoldInfo.Equals(workInfo.MoldInfo))
{
create = new WorkCreateAssmbile(workInfo, edm, asmModel);
}
else
{
EDMModel temp = new EDMModel(new EDMInfo(workInfo.MoldInfo, workInfo.UserModel));
create = new WorkCreateAssmbile(workInfo, temp, asmModel, workpiece);
}
err.AddRange(create.CreatePart(workpiece.WorkpieceDirectoryPath));
err.AddRange(create.LoadAssmbile());
if (err.Count == 0)
{
create.Work.SaveCsys(workPart);
}
return(err);
}
/// <summary>
/// 获取工件实体在装配下的体
/// </summary>
/// <param name="ct"></param>
/// <param name="pt"></param>
/// <returns></returns>
private List <Body> GetCompBodys(NXOpen.Assemblies.Component ct, Part pt)
{
List <Body> bodys = new List <Body>();
if ((ct.Prototype as Part).Equals(pt))
{
foreach (Body by in pt.Bodies.ToArray())
{
Body bo = AssmbliesUtils.GetNXObjectOfOcc(ct.Tag, by.Tag) as Body;
if (bo != null)
{
bodys.Add(bo);
}
}
}
else
{
foreach (NXOpen.Assemblies.Component co in AssmbliesUtils.GetPartComp(ct.Prototype as Part, pt))
{
if (!co.IsSuppressed)
{
foreach (Body by in pt.Bodies.ToArray())
{
Body bo = AssmbliesUtils.GetNXObjectOfOcc(co.Tag, by.Tag) as Body;
if (bo != null)
{
bodys.Add(bo);
}
}
}
}
}
return(bodys);
}
public WorkpieceInfo(Part workpiece, WorkModel work)
{
this.workpiece = workpiece;
this.work = work;
workpieceComp = AssmbliesUtils.GetPartComp(this.work.PartTag, this.workpiece);
this.poin = CreateMinAndMaxPt();
}
/// <summary>
/// 获得选择工件work副本的矩阵
/// </summary>
/// <param name="ct"></param>
/// <returns></returns>
private Matrix4 GetParentWorkMatr(NXOpen.Assemblies.Component ct)
{
NXOpen.Assemblies.Component workComp = ct.Parent.Parent;
WorkModel work = new WorkModel(workComp.Prototype as Part);
return(work.Info.Matr);
}
//------------------------------------------------------------------------------
//Callback Name: apply_cb
//------------------------------------------------------------------------------
public int apply_cb()
{
int errorCode = 0;
try
{
//---- Enter your callback code here -----
NXOpen.Assemblies.Component ct = seleComp.GetSelectedObjects()[0] as NXOpen.Assemblies.Component;
if (ParentAssmblieInfo.IsElectrode(ct))
{
AlterEle(ct);
}
else if (ParentAssmblieInfo.IsWork(ct))
{
AlterWork(ct, user.CreatorUser);
}
else if (ParentAssmblieInfo.IsWorkpiece(ct) || !ParentAssmblieInfo.IsParent(ct))
{
AlterWorkpiece(ct, user.CreatorUser);
}
bool anyPartsModified;
PartSaveStatus saveStatus;
theSession.Parts.SaveAll(out anyPartsModified, out saveStatus);
}
catch (Exception ex)
{
//---- Enter your exception handling code here -----
errorCode = 1;
theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString());
}
return(errorCode);
}
/// <summary>
/// 复制电极
/// </summary>
/// <param name="eleCt"></param>
/// <param name="workPt"></param>
/// <returns></returns>
public List <string> LoadEle(NXOpen.Assemblies.Component eleCt, Part workPt)
{
Matrix3x3 mat;
Point3d setPt;
List <string> err = new List <string>();
eleCt.GetPosition(out setPt, out mat);
ElectrodeSetValueInfo setValue = ElectrodeSetValueInfo.GetAttribute(eleCt);
NXOpen.PartLoadStatus partLoadStatus1 = null;
string partPath = (eleCt.Prototype as Part).FullPath;
try
{
NXOpen.Assemblies.Component copyCt = workPt.ComponentAssembly.AddComponent(partPath, "None", eleCt.Name, setPt, mat, -1, out partLoadStatus1, true);
NXObject obj = AssmbliesUtils.GetOccOfInstance(copyCt.Tag);
bool attOk = setValue.SetAttribute(obj);
AttributeUtils.AttributeOperation("EleComponentCopy", 1, obj);
if (!attOk)
{
err.Add("写入属性错误！");
}
}
catch (NXException ex)
{
err.Add(eleCt.Name + "复制电极错误！ " + ex.Message);
}
return(err);
}
//------------------------------------------------------------------------------
//Callback Name: update_cb
//------------------------------------------------------------------------------
public int update_cb(NXOpen.BlockStyler.UIBlock block)
{
try
{
if (block == seleWork)
{
//---------Enter your code here-----------
if (this.seleWork.GetSelectedObjects().Length > 0)
{
NXOpen.Assemblies.Component seleCt = this.seleWork.GetSelectedObjects()[0] as NXOpen.Assemblies.Component;
group.Show = true;
this.eumWorkName.SetEnumMembers(GetWorkName(seleCt).ToArray());
}
else
{
group.Show = false;
}
}
else if (block == eumWorkName)
{
//---------Enter your code here-----------
}
}
catch (Exception ex)
{
//---- Enter your exception handling code here -----
theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString());
}
return(0);
}
/// <summary>
/// 替换工件
/// </summary>
/// <param name="ct"></param>
private void AlterWorkpiece(NXOpen.Assemblies.Component ct, UserModel user)
{
MoldInfo mold;
if (!ParentAssmblieInfo.IsParent(ct))
{
mold = new MoldInfo()
{
MoldNumber = this.strMoldNumber.Value.ToUpper(),
WorkpieceNumber = this.strWorkpieceNumber.Value.ToUpper(),
EditionNumber = this.strEditionNumber.Value.ToUpper()
};
}
else
{
mold = MoldInfo.GetAttribute(ct);
mold.MoldNumber = this.strMoldNumber.Value;
mold.WorkpieceNumber = this.strWorkpieceNumber.Value;
mold.EditionNumber = this.strEditionNumber.Value;
}
WorkPieceInfo wk = new WorkPieceInfo(mold, user);
string newName = mold.MoldNumber + "-" + mold.WorkpieceNumber + "-" + mold.EditionNumber;
Part pt = ct.Prototype as Part;
ReplaceOther ot = new ReplaceOther(pt, wk);
List <string> err = ot.Alter(newName);
if (err.Count > 0)
{
ClassItem.Print(err.ToArray());
}
}
/// <summary>
/// 移动部件并复制部件
/// </summary>
/// <param name="compObj"></param>
/// <param name="endPt"></param>
/// <param name="mat"></param>
/// <returns></returns>
public static NXOpen.Assemblies.Component MoveCompCopyPart(NXOpen.Assemblies.Component compObj, Vector3d endPt, Matrix4 mat)
{
Part workPart = theSession.Parts.Work;
Matrix4 invers = mat.GetInversMatrix();
invers.ApplyVec(ref endPt);
NXOpen.Positioning.ComponentPositioner componentPositioner1;
componentPositioner1 = workPart.ComponentAssembly.Positioner; //组件定位
componentPositioner1.ClearNetwork(); //删除定位器
NXOpen.Assemblies.Arrangement arrangement1 = (NXOpen.Assemblies.Arrangement)workPart.ComponentAssembly.Arrangements.FindObject("Arrangement 1"); //布局
componentPositioner1.PrimaryArrangement = arrangement1; //主要布局
componentPositioner1.BeginMoveComponent(); //开始移动组件
bool allowInterpartPositioning1;
allowInterpartPositioning1 = theSession.Preferences.Assemblies.InterpartPositioning; //首选项的部件间的定位
NXOpen.Positioning.Network network1;
network1 = componentPositioner1.EstablishNetwork(); //建立
NXOpen.Positioning.ComponentNetwork componentNetwork1 = (NXOpen.Positioning.ComponentNetwork)network1;
componentNetwork1.MoveObjectsState = true; //移动对象状态
NXOpen.Assemblies.Component nullNXOpen_Assemblies_Component = null;
componentNetwork1.DisplayComponent = nullNXOpen_Assemblies_Component; //显示组件
componentNetwork1.NetworkArrangementsMode = NXOpen.Positioning.ComponentNetwork.ArrangementsMode.Existing; //现有安排模式
componentNetwork1.RemoveAllConstraints(); //删除约束
NXOpen.NXObject[] movableObjects1 = new NXOpen.NXObject[1];
movableObjects1[0] = compObj;
NXOpen.Assemblies.Component[] components1 = new NXOpen.Assemblies.Component[1];
components1[0] = compObj;
NXOpen.Assemblies.Component[] newComponents1 = workPart.ComponentAssembly.CopyComponents(components1);
componentNetwork1.SetMovingGroup(newComponents1); //设置移动组件
componentNetwork1.Solve(); //解除约束
bool loaded1;
loaded1 = componentNetwork1.IsReferencedGeometryLoaded(); //参考几何加载
componentNetwork1.BeginDrag(); //操作即将开始
NXOpen.Vector3d translation1 = new NXOpen.Vector3d(endPt.X, endPt.Y, endPt.Z);
componentNetwork1.DragByTranslation(translation1); //移动
componentNetwork1.EndDrag(); //操作结束
componentNetwork1.ResetDisplay(); //返回到模型上
componentNetwork1.ApplyToModel(); //应该到当前模型
componentNetwork1.Solve(); //解除约束
componentPositioner1.ClearNetwork(); //清空
int nErrs1;
nErrs1 = theSession.UpdateManager.AddToDeleteList(componentNetwork1); //更新
componentPositioner1.ClearNetwork();
componentPositioner1.DeleteNonPersistentConstraints();
componentPositioner1.EndMoveComponent();
NXOpen.Assemblies.Arrangement nullNXOpen_Assemblies_Arrangement = null;
componentPositioner1.PrimaryArrangement = nullNXOpen_Assemblies_Arrangement;
return(newComponents1[0]);
}
//------------------------------------------------------------------------------
//Callback Name: apply_cb
//------------------------------------------------------------------------------
public int apply_cb()
{
int errorCode = 0;
try
{
//---- Enter your callback code here -----
NXOpen.Assemblies.Component ct = seleComp.GetSelectedObjects()[0] as NXOpen.Assemblies.Component;
Part workPart = theSession.Parts.Work;
if (ct != null)
{
List <string> err = new List <string>();
bool isBorrow;
if (this.enum0.ValueAsString == "借用电极")
{
isBorrow = true;
}
else
{
isBorrow = false;
}
MoldInfo old = MoldInfo.GetAttribute(ct);
MoldInfo mold = new MoldInfo()
{
MoldNumber = this.MoldNumber.WideValue.ToUpper(),
WorkpieceNumber = this.PartNumber.WideValue.ToUpper(),
ClientName = this.ClientNumber.WideValue.ToUpper(),
EditionNumber = this.EditionNumber.WideValue.ToUpper(),
MoldType = old.MoldType
};
ParentAssmblieInfo info = new ParentAssmblieInfo(mold, user.CreatorUser);
WorkCollection wkColl = asmColl.GetWorkCollection(old);
err.AddRange(AlterWork(wkColl.Work, info));
err.AddRange(AlterEdm(wkColl.EdmModel, info));
err.AddRange(AlterElectrode(wkColl.Electrodes, info, isBorrow));
PartUtils.SetPartDisplay(workPart);
ASMModel asm = new ASMModel(workPart);
if (asm.Info.MoldInfo.Equals(old))
{
err.AddRange(AlterAsm(asm, info));
}
if (err.Count > 0)
{
ClassItem.Print(err.ToArray());
}
}
}
catch (Exception ex)
{
//---- Enter your exception handling code here -----
errorCode = 1;
theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString());
}
return(errorCode);
}
/// <summary>
/// 设置显示部件
/// </summary>
/// <param name="part"></param>
public static void SetPartWork(NXOpen.Assemblies.Component comp)
{
Part workPart = theSession.Parts.Work;
Part displayPart = theSession.Parts.Display;
NXOpen.PartLoadStatus partLoadStatus1;
theSession.Parts.SetWorkComponent(comp, NXOpen.PartCollection.RefsetOption.Entire, NXOpen.PartCollection.WorkComponentOption.Visible, out partLoadStatus1);
workPart = theSession.Parts.Work;
partLoadStatus1.Dispose();
}
/// <summary>
/// 创建part档
/// </summary>
/// <returns></returns>
private NXOpen.Assemblies.Component CreateElePart()
{
NXOpen.Assemblies.Component eleComp = elePart.Create();
if (eleComp != null)
{
PartUtils.SetPartWork(eleComp);
NXOpen.Features.Feature feat = AssmbliesUtils.WaveBodys(this.head.ConditionModel.Bodys.ToArray());
this.waveBodys = (feat as NXOpen.Features.BodyFeature).GetBodies();
}
return(eleComp);
}
//------------------------------------------------------------------------------
//Callback Name: filter_cb
//------------------------------------------------------------------------------
public int filter_cb(NXOpen.BlockStyler.UIBlock block, NXOpen.TaggedObject selectedObject)
{
if (selectedObject is NXOpen.Assemblies.Component)
{
NXOpen.Assemblies.Component ct = selectedObject as NXOpen.Assemblies.Component;
if (EDMModel.IsEDM(ct.Prototype as Part))
{
return(NXOpen.UF.UFConstants.UF_UI_SEL_ACCEPT);
}
}
return(NXOpen.UF.UFConstants.UF_UI_SEL_REJECT);
}
//------------------------------------------------------------------------------
//Callback Name: update_cb
//------------------------------------------------------------------------------
public int update_cb(NXOpen.BlockStyler.UIBlock block)
{
try
{
if (block == seleComp)
{
//---------Enter your code here-----------
TaggedObject[] tt = seleComp.GetSelectedObjects();
if (tt.Length > 0)
{
NXOpen.Assemblies.Component ct = tt[0] as NXOpen.Assemblies.Component;
if (ct != null)
{
SetDisp(ct);
}
}
}
else if (block == strMoldNumber)
{
//---------Enter your code here-----------
}
else if (block == strWorkpieceNumber)
{
//---------Enter your code here-----------
}
else if (block == strEditionNumber)
{
//---------Enter your code here-----------
}
else if (block == strEleName)
{
//---------Enter your code here-----------
}
else if (block == strEleName1)
{
//---------Enter your code here-----------
}
else if (block == strEleEditionNumber)
{
//---------Enter your code here-----------
}
else if (block == intWorkNumber)
{
//---------Enter your code here-----------
}
}
catch (Exception ex)
{
//---- Enter your exception handling code here -----
theUI.NXMessageBox.Show("Block Styler", NXMessageBox.DialogType.Error, ex.ToString());
}
return(0);
}
//------------------------------------------------------------------------------
//Callback Name: filter_cb
//------------------------------------------------------------------------------
public int filter_cb(NXOpen.BlockStyler.UIBlock block, NXOpen.TaggedObject selectedObject)
{
NXOpen.Assemblies.Component ct = selectedObject as NXOpen.Assemblies.Component;
if (ct != null)
{
if (ParentAssmblieInfo.IsElectrode(ct) || ParentAssmblieInfo.IsWorkpiece(ct) || !ParentAssmblieInfo.IsParent(ct) || ParentAssmblieInfo.IsWork(ct))
{
return(NXOpen.UF.UFConstants.UF_UI_SEL_ACCEPT);
}
}
return(NXOpen.UF.UFConstants.UF_UI_SEL_FAILURE);
}
//------------------------------------------------------------------------------
//Callback Name: filter_cb
//------------------------------------------------------------------------------
public int filter_cb(NXOpen.BlockStyler.UIBlock block, NXOpen.TaggedObject selectedObject)
{
NXOpen.Assemblies.Component ct = (selectedObject as NXOpen.Assemblies.Component);
if (ct != null)
{
if (!ParentAssmblieInfo.IsElectrode(ct))
{
return(UFConstants.UF_UI_SEL_REJECT);
}
}
return(NXOpen.UF.UFConstants.UF_UI_SEL_ACCEPT);
}
/// <summary>
/// 更新work零件明细表
/// </summary>
private void AlterWorkDrawing()
{
Part workPart = Session.GetSession().Parts.Work;
UFSession theUFSession = UFSession.GetUFSession();
if (!workPart.Equals(work.PartTag))
{
NXOpen.Assemblies.Component ct = AssmbliesUtils.GetPartComp(workPart, work.PartTag);
PartUtils.SetPartWork(ct);
}
theUFSession.Plist.UpdateAllPlists();
PartUtils.SetPartWork(null);
}
private WorkModel GetWork(NXOpen.Assemblies.Component partCt)
{
try
{
Part workPart = (partCt.Parent.Parent.Prototype) as Part;
return(new WorkModel(workPart));
}
catch (NXException ex)
{
ClassItem.WriteLogFile("获取work错误" + ex.Message);
return(null);
}
}
/// <summary>
/// 获取EDM
/// </summary>
/// <param name="partCt"></param>
/// <returns></returns>
private EDMModel GetEdm(NXOpen.Assemblies.Component partCt)
{
try
{
Part edmPart = (partCt.Parent.Prototype) as Part;
return(new EDMModel(edmPart));
}
catch (NXException ex)
{
ClassItem.WriteLogFile("获取EDM错误" + ex.Message);
return(null);
}
}
/// <summary>
/// 获取工件名
/// </summary>
/// <param name="seleCt"></param>
/// <returns></returns>
private List <string> GetWorkName(NXOpen.Assemblies.Component seleCt)
{
List <string> workName = new List <string>();
foreach (WorkModel wm in asmColl.GetWorks())
{
if (!wm.AssembleName.Equals(seleCt.Name, StringComparison.CurrentCultureIgnoreCase))
{
workName.Add(wm.AssembleName);
}
}
return(workName);
}
