public void AddOperation(AbstractElectrodeOperation eleOper, AbstractCreateOperation oper, Node node)
{
Node nextNode1 = node.FirstChildNode;
if (nextNode1 == null)
{
eleOper.Oper.Insert(eleOper.Oper.Count, oper);
AddOpeTotree(oper, node, null, png);
return;
}
bool sibling = true;
while (sibling)
{
Node nextNode2;
nextNode2 = nextNode1.NextSiblingNode;
if (nextNode2 == null)
{
sibling = false;
break;
}
else
{
nextNode1 = nextNode2;
}
}
AbstractCreateOperation ao = FindOperationForOperNode(nextNode1, eleOper);
int index = eleOper.Oper.IndexOf(ao);
eleOper.Oper.Insert(index + 1, oper);
AddOpeTotree(oper, node, nextNode1, png);
node.Expand(Node.ExpandOption.Expand); //展开节点
}
public override void SetOperationData(AbstractElectrodeCAM eleCam)
{
Dictionary <double, Face[]> slope = new Dictionary <double, Face[]>();
if (flat && isAll)
{
slope = eleCam.GetAllFaces();
}
else if (flat)
{
slope = eleCam.GetSlopeFaces();
}
else
{
slope = eleCam.GetFlatFaces();
}
slope.OrderBy(a => a.Key);
for (int k = 0; k < slope.Count; k++)
{
if (k == 0)
{
this.Inter = slope.Keys.ToArray()[k];
this.SetFaces(slope[this.Inter]);
}
else
{
AbstractCreateOperation oper = this.CopyOperation(99);
oper.Inter = slope.Keys.ToArray()[k];
(oper as FlowCutCreateOperation).SetFaces(slope[this.Inter]);
}
}
}
/// <summary>
/// 删除操作
/// </summary>
/// <param name="oper"></param>
/// <returns></returns>
public bool Delete(ElectrodeCAMTreeInfo info)
{
if (info.Program is ProgramOperationName)
{
ProgramOperationName temp = info.Program as ProgramOperationName;
if (this.template.Programs.Exists(a => a.Equals(temp)))
{
this.template.DeleteProgram(temp);
GetTreeInfo();
return(true);
}
else
{
return(false);
}
}
if (info.Program is AbstractCreateOperation)
{
AbstractCreateOperation temp = info.Program as AbstractCreateOperation;
if (info.Parent != null && info.Parent.Program is ProgramOperationName)
{
ProgramOperationName tp = info.Parent.Program as ProgramOperationName;
if (tp.Oper.Exists(a => a.Equals(temp)))
{
tp.DeleteOperationNameModel(temp);
GetTreeInfo();
return(true);
}
}
}
return(false);
}
public override void SetOperationData(AbstractElectrodeCAM eleCam)
{
Dictionary <double, Face[]> slope = new Dictionary <double, Face[]>();
if ((steep && isAll) || (!steep && isAll))
{
slope = eleCam.GetAllFaces();
}
else if (steep && !isAll)
{
slope = eleCam.GetSteepFaces();
}
else if (!steep && !isAll)
{
slope = eleCam.GetSlopeFaces();
}
slope.OrderBy(a => a.Key);
for (int k = 0; k < slope.Count; k++)
{
if (k == 0)
{
this.Inter = slope.Keys.ToArray()[k];
this.SetFaces(slope[this.Inter]);
this.SetCutLevel(eleCam.Analysis.BaseFace.BoxMinCorner);
}
else
{
AbstractCreateOperation oper = this.CopyOperation(99);
oper.Inter = slope.Keys.ToArray()[k];
(oper as ZLevelMillingCreateOperation).SetFaces(slope[this.Inter]);
(oper as ZLevelMillingCreateOperation).SetCutLevel(eleCam.Analysis.BaseFace.BoxMinCorner);
}
}
}
/// <summary>
/// 添加刀路
/// </summary>
/// <param name="node">程序Node</param>
/// <param name="eleOper"></param>
/// <param name="oper"></param>
public void AddOperation(AbstractElectrodeOperation eleOper, AbstractCreateOperation oper)
{
Node proNode = FindNodeForProName(oper.NameModel.ProgramName);
Node nextNode1 = proNode.FirstChildNode;
if (nextNode1 == null)
{
eleOper.Oper.Insert(eleOper.Oper.Count, oper);
AddOpeTotree(oper, proNode, null, png);
return;
}
bool sibling = true;
while (sibling)
{
Node nextNode2;
nextNode2 = nextNode1.NextSiblingNode;
if (nextNode2 == null)
{
sibling = false;
break;
}
else
{
nextNode1 = nextNode2;
}
}
AbstractCreateOperation ao = FindOperationForOperNode(nextNode1, eleOper);
int index = eleOper.Oper.IndexOf(ao);
eleOper.Oper.Insert(index + 1, oper);
AddOpeTotree(oper, proNode, nextNode1, png);
}
/// <summary>
/// 拷贝程序
/// </summary>
/// <param name="eleOper"></param>
/// <param name="node"></param>
public void CopyOperation(AbstractElectrodeOperation eleOper, Node node)
{
AbstractCreateOperation ao = FindOperationForOperNode(node, eleOper);
AbstractCreateOperation copy = ao.CopyOperation();
int index = eleOper.Oper.IndexOf(ao);
eleOper.Oper.Insert(index + 1, copy);
AddOpeTotree(copy, node.ParentNode, node, png);
}
/// <summary>
/// 添加刀路名
/// </summary>
/// <param name="model"></param>
public bool AddOperationNameModel(AbstractCreateOperation model, int count)
{
if (model.ToolName.Equals(this.tool, StringComparison.CurrentCultureIgnoreCase))
{
Oper.Insert(count, model);
UpdateProgramName();
return(true);
}
return(false);
}
/// <summary>
/// 移动刀路
/// </summary>
/// <param name="eleOper"></param>
/// <param name="node"></param>
/// <param name="afterNode"></param>
public void MoveOperation(AbstractElectrodeOperation eleOper, Node node, Node afterNode)
{
AbstractCreateOperation ao1 = FindOperationForOperNode(node, eleOper);
AbstractCreateOperation ao2 = FindOperationForOperNode(afterNode, eleOper);
this.AddOpeTotree(ao1, afterNode.ParentNode, afterNode, png);
eleOper.Oper.Remove(ao1);
int index = eleOper.Oper.IndexOf(ao2);
eleOper.Oper.Insert(index + 1, ao1);
this.tree.DeleteNode(node);
}
/// <summary>
/// 把刀路插入到程序组下面
/// </summary>
/// <param name="ao"></param>
/// <param name="pNode"></param>
/// <param name="afterNode"></param>
/// <param name="name"></param>
/// <param name="pngPath"></param>
/// <returns></returns>
private Node AddOpeTotree(AbstractCreateOperation ao, Node pNode, Node afterNode, string pngPath)
{
Node node = this.tree.CreateNode(ao.NameModel.OperName);
this.tree.InsertNode(node, pNode, afterNode, Tree.NodeInsertOption.Last);
node.SetColumnDisplayText(0, ao.NameModel.OperName);
node.DisplayIcon = pngPath + ao.NameModel.PngName;
node.SelectedIcon = pngPath + ao.NameModel.PngName;
node.SetColumnDisplayText(1, ao.NameModel.ToolName);
ao.Node = node;
return(node);
}
/// <summary>
/// 复制
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public object Copy(ElectrodeCAMTreeInfo info)
{
if (info.Program is ProgramOperationName)
{
ProgramOperationName temp = info.Program as ProgramOperationName;
return(new ProgramOperationName(temp.Program));
}
if (info.Program is AbstractCreateOperation)
{
AbstractCreateOperation temp = info.Program as AbstractCreateOperation;
return(temp.CopyOperation(10));
}
return(null);
}
/// <summary>
/// 操作往下移动
/// </summary>
/// <param name="node"></param>
/// <param name="eleOper"></param>
public void MoveDownOperation(Node node, AbstractElectrodeOperation eleOper)
{
Node sibling = node.NextSiblingNode;
if (sibling != null)
{
AbstractCreateOperation ao = FindOperationForOperNode(node, eleOper);
AddOpeTotree(ao, node.ParentNode, sibling, png);
int index = eleOper.Oper.IndexOf(ao);
eleOper.Oper.Remove(ao);
eleOper.Oper.Insert(index - 1, ao);
this.tree.DeleteNode(node);
}
}
/// <summary>
/// 更新刀路
/// </summary>
/// <param name="eleOper"></param>
/// <param name="ao"></param>
public void UpdateOperation(AbstractElectrodeOperation eleOper, AbstractCreateOperation ao)
{
if (ao.NameModel.ProgramName.Equals(ao.Node.ParentNode.GetColumnDisplayText(0)))
{
ao.Node.SetColumnDisplayText(0, ao.NameModel.OperName);
ao.Node.SetColumnDisplayText(1, ao.NameModel.ToolName);
}
else
{
eleOper.Oper.Remove(ao);
this.tree.DeleteNode(ao.Node);
this.AddOperation(eleOper, ao);
}
}
/// <summary>
/// 操作往上移动
/// </summary>
/// <param name="node"></param>
/// <param name="eleOper"></param>
public void MoveUpOperation(Node node, AbstractElectrodeOperation eleOper)
{
Node previous = node.PreviousSiblingNode;
if (previous != null)
{
AbstractCreateOperation ao = FindOperationForOperNode(previous, eleOper);
AddOpeTotree(ao, node.ParentNode, node, png);
int index = eleOper.Oper.IndexOf(ao);
eleOper.Oper.Remove(ao);
eleOper.Oper.Insert(index + 1, ao);
this.tree.DeleteNode(previous);
}
}
/// <summary>
/// 向上移动
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public bool MoveUp(ElectrodeCAMTreeInfo info)
{
if (info.Program is ProgramOperationName)
{
ProgramOperationName temp = info.Program as ProgramOperationName;
int count = this.template.Programs.FindIndex(a => a.Equals(temp));
if (this.template.Programs.Exists(a => a.Equals(temp)))
{
if (count != 0 && count != -1)
{
this.template.DeleteProgram(count);
this.template.AddProgram(temp, count - 1);
GetTreeInfo();
return(true);
}
}
else
{
return(false);
}
}
if (info.Program is AbstractCreateOperation)
{
AbstractCreateOperation temp = info.Program as AbstractCreateOperation;
if (info.Parent != null && info.Parent.Program is ProgramOperationName)
{
ProgramOperationName tp = info.Parent.Program as ProgramOperationName;
int count = tp.Oper.FindIndex(a => a.Equals(temp));
if (tp.Oper.Exists(a => a.Equals(temp)))
{
if (count != 0 && count != -1)
{
tp.DeleteOperationNameModel(temp);
tp.AddOperationNameModel(temp, count - 1);
GetTreeInfo();
return(true);
}
}
}
}
return(false);
}
public override void SetOperationData(AbstractElectrodeCAM eleCam)
{
Dictionary <double, Face[]> plane = eleCam.GetPlaneFaces();
plane.OrderBy(a => a.Key);
for (int k = 0; k < plane.Count; k++)
{
if (k == 0)
{
this.Inter = plane.Keys.ToArray()[k];
this.SetBoundary(plane[this.Inter]);
}
else
{
AbstractCreateOperation oper = this.CopyOperation(99);
oper.Inter = plane.Keys.ToArray()[k];
(oper as FaceMillingCreateOperation).SetBoundary(plane[this.Inter]);
}
}
}
public override void SetOperationData(AbstractElectrodeCAM eleCam)
{
Dictionary <double, BoundaryModel[]> boun = eleCam.GetBaseFaceBoundary();
boun.OrderBy(a => a.Key);
for (int k = 0; k < boun.Count; k++)
{
if (k == 0)
{
this.Inter = boun.Keys.ToArray()[k];
this.SetBoundary(eleCam.Analysis.BaseFace.BoxMinCorner, boun[this.Inter]);
}
else
{
AbstractCreateOperation oper = this.CopyOperation(99);
oper.Inter = boun.Keys.ToArray()[k];
(oper as PlanarMillingCreateOperation).SetBoundary(eleCam.Analysis.BaseFace.BoxMinCorner, boun[this.Inter]);
}
}
}
/// <summary>
/// 添加刀路
/// </summary>
/// <param name="oper"></param>
/// <param name="info"></param>
/// <returns></returns>
public bool AddOperation(AbstractCreateOperation oper, ElectrodeCAMTreeInfo info)
{
if (info.Program is ProgramOperationName)
{
ProgramOperationName temp = info.Program as ProgramOperationName;
return(temp.AddOperationNameModel(oper));
}
if (info.Program is AbstractCreateOperation)
{
AbstractCreateOperation temp = info.Program as AbstractCreateOperation;
if (info.Parent != null && info.Parent.Program is ProgramOperationName)
{
ProgramOperationName tp = info.Parent.Program as ProgramOperationName;
int count = tp.Oper.FindIndex(a => a.Equals(temp));
if (count != -1)
{
return(tp.AddOperationNameModel(oper, count + 1));
}
}
}
return(false);
}
/// <summary>
/// 粘贴
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public bool Stick(ElectrodeCAMTreeInfo info, object obt)
{
if (info.Program is ProgramOperationName)
{
ProgramOperationName temp = info.Program as ProgramOperationName;
if (obt is ProgramOperationName)
{
int count = this.template.Programs.FindIndex(a => a.Equals(temp));
if (count != -1)
{
this.template.AddProgram(obt as ProgramOperationName, count + 1);
return(true);
}
}
else if (obt is AbstractCreateOperation)
{
AbstractCreateOperation tp = obt as AbstractCreateOperation;
tp.SetToolName(temp.ToolName);
return(temp.AddOperationNameModel(tp));
}
}
if (info.Program is AbstractCreateOperation && obt is AbstractCreateOperation)
{
AbstractCreateOperation temp = info.Program as AbstractCreateOperation;
if (info.Parent != null && info.Parent.Program is ProgramOperationName)
{
ProgramOperationName tp = info.Parent.Program as ProgramOperationName;
AbstractCreateOperation ao = obt as AbstractCreateOperation;
int count = tp.Oper.FindIndex(a => a.Equals(temp));
if (count != -1)
{
ao.SetToolName(tp.ToolName);
return(tp.AddOperationNameModel(ao, count + 1));
}
}
}
return(false);
}
/// <summary>
/// 删除刀路
/// </summary>
/// <param name="model"></param>
public void DeleteOperationNameModel(AbstractCreateOperation model)
{
Oper.Remove(model);
UpdateProgramName();
}
public int CompareTo(AbstractCreateOperation other)
{
return(this.site.CompareTo(other.site));
}
/// <summary>
/// 删除刀路
/// </summary>
/// <param name="model"></param>
public void DeleteOperationNameModel(AbstractCreateOperation model)
{
Oper.Remove(model);
}
/// <summary>
/// 添加刀路名
/// </summary>
/// <param name="model"></param>
public void AddOperationNameModel(AbstractCreateOperation model, int count)
{
Oper.IndexOf(model, count);
}
