/// <summary>
/// 检查是否更新事件结点
/// </summary>
/// <param name="graphElement">当前图元</param>
/// <param name="eventNode">事件结点</param>
/// <returns>是否需要更新</returns>
protected virtual bool CheckCanBindEventNode(GraphElement graphElement, EventGraphElement eventNode)
{
bool avail = true;
GraphManager graphManager = data as GraphManager;
DataManager dataManager = graphManager.CurrentFlowChartManager.CurrentDataManager;
IComparable com1;
IComparable com2;
if (graphElement is SlotContainer) // 插槽容器
{
SlotContainer slotContainer = graphElement as SlotContainer;
if (slotContainer.EventNode != null && slotContainer.EventNode != eventNode)
{
com1 = dataManager.GetData(slotContainer.EventNode) as IComparable;
com2 = dataManager.GetData(eventNode) as IComparable;
avail = (com1.CompareTo(com2) == 0);
}
}
else if (graphElement is ConnectorContainer) // 连接线
{
ConnectorContainer line = graphElement as ConnectorContainer;
if (line.EventNode != null && line.EventNode != eventNode)
{
com1 = dataManager.GetData(line.EventNode) as IComparable;
com2 = dataManager.GetData(eventNode) as IComparable;
avail = (com1.CompareTo(com2) == 0);
}
}
return(avail);
}
/// <summary>
/// 获取连入的图元链表
/// </summary>
/// <param name="graphElement">当前图元</param>
/// <returns>连入的图元链表</returns>
public List <GraphElement> GetPreviousGraphElements(GraphElement graphElement)
{
List <GraphElement> list = new List <GraphElement>();
if (graphElement is SlotContainer) // 当前图元是插槽容器
{
SlotContainer slotContaienr = graphElement as SlotContainer;
foreach (SlotGraphElement slot in slotContaienr.GetInSlotList())
{
if (slot.Binded)
{
list.Add(slot.BindingConnector.Line);
}
}
}
else if (graphElement is ConnectorContainer) // 当前图元是连接线控制点容器
{
ConnectorContainer line = graphElement as ConnectorContainer;
if (line.InSlotContainer != null)
{
list.Add(line.InSlotContainer);
}
}
return(list);
}
/// <summary>
/// 添加连接线到区域
/// </summary>
/// <param name="line">添加连接线到区域</param>
public void Add(ConnectorContainer line)
{
if (!connectorContainers.Contains(line))
{
connectorContainers.Add(line);
}
}
/// <summary>
/// 检查连接线是否有效
/// </summary>
/// <param name="flowChartManager">绘图管理器</param>
/// <returns>连接线是否有效</returns>
private bool CheckLineAvail(FlowChartManager flowChartManager)
{
bool avail = true;
ConnectorContainer invalidLine = null;
DocumentManager documentManager = DocumentManager.GetDocumentManager();
foreach (ConnectorContainer line in flowChartManager.CurrentGraphManager.ConnectorContainerList)
{
if (line.InSlotContainer == null || line.OutSlotContainer == null) // 连接线两端必须连接上结点
{
avail = false;
invalidLine = line;
documentManager.PrintText(string.Format("ID为{0}的连接线没有正确连接！", line.ID));
break;
}
}
if (!avail) // 流程图无效
{
MessageBox.Show("绘图中有不完整的连接，请确认所有的连接是否正确！", "流程图有效性检查",
MessageBoxButtons.OK, MessageBoxIcon.Information);
// 显示细节
List <GraphElement> list = new List <GraphElement>();
list.Add(invalidLine);
flowChartManager.CurrentGraphManager.SelectGraphElements(list);
}
return(avail);
}
protected GraphSetting graphSetting; // 绘图参数配置对象
/// <summary>
/// 构造函数
/// </summary>
/// <param name="line">连接线控制点所属的连接线</param>
/// <param name="location">连接点的位置</param>
/// <param name="size">连接线的大小</param>
public ConnectorGraphElement(ConnectorContainer line, Point location, Size size)
: base(location)
{
this.line = line;
this.location = location;
this.elementSize = size;
}
/// <summary>
/// 解除连接图元
/// </summary>
/// <param name="flowChartManager">绘图管理器</param>
/// <param name="logicData">逻辑数据</param>
/// <returns>是否操作成功</returns>
protected override bool LogicDisconnect(FlowChartManager flowChartManager, object logicData)
{
DataManager dataManager = flowChartManager.CurrentDataManager;
object[] args = logicData as object[];
SlotGraphElement slot = args[0] as SlotGraphElement;
ConnectorGraphElement connector = args[1] as ConnectorGraphElement;
ConnectorContainer line = connector.Line;
SlotContainer slotContainer = slot.SlotContainer;
List <GraphElement> list = new List <GraphElement>(); // 记录遍历的图元的链表
if (connector.IsHeadPoint) // 移出连接线的头结点
{
ReBindEventNode(dataManager, list, slotContainer, false); // 重新绑定当前图元与其连出图元的事件结点
}
else // 移出连接线的尾结点
{
SlotContainer outSlotContainer = connector.Line.OutSlotContainer;
if (outSlotContainer != null)
{
ReBindEventNode(dataManager, list, connector.Line, false); // 重新绑定当前图元与其连出图元的事件结点
}
}
return(true);
}
public static void ConfigureServices(IServiceCollection services)
{
ConnectorContainer.ConfigureServices(services);
services.AddTransient <IApiMapper, ApiMapper>();
services.AddTransient <IItemsManager, ItemsManager>();
services.AddTransient <ITrackerParser, TrackerParser>();
services.AddTransient <ITrackerManager, TrackerManager>();
}
/// <summary>
/// 将连接线从区域中删除
/// </summary>
/// <param name="line">当前连接线</param>
private void DeleteFromRegion(ConnectorContainer line)
{
foreach (RegionData regionData in regionDataList)
{
regionData.Remove(line);
}
backupRegionData.Remove(line);
}
/// <summary>
/// 连接图元
/// </summary>
/// <param name="flowChartManager">绘图管理器</param>
/// <param name="logicData">逻辑数据</param>
/// <returns>是否操作成功</returns>
protected virtual bool LogicConnect(FlowChartManager flowChartManager, object logicData)
{
object[] data = logicData as object[];
SlotGraphElement slot = data[0] as SlotGraphElement;
ConnectorGraphElement connector = data[1] as ConnectorGraphElement;
ConnectorContainer line = connector.Line;
if ((line.InSlotContainer != null && line.OutSlotContainer != null) || connector.Selected) // 连接线控制点处于被选中状态
{
flowChartManager.CurrentGraphManager.EditDataElement(line);
}
return(true);
}
/// <summary>
/// 获取连接的图元
/// </summary>
/// <returns>连接的图元</returns>
public GraphElement GetConnectedOutGraphElement()
{
GraphElement graphElement = null;
foreach (SlotGraphElement slot in outSlotList)
{
if (slot.Binded)
{
ConnectorContainer line = slot.BindingConnector.Line;
graphElement = line.OutSlotContainer;
}
}
return(graphElement);
}
/// <summary>
/// 检查图元是否能够编辑
/// </summary>
/// <param name="graphElement">当前图元</param>
/// <returns>图元是否能够编辑</returns>
private bool CheckGraphElementEditable(GraphElement graphElement)
{
bool result = true;
if (graphElement is ConnectorContainer)
{
ConnectorContainer line = graphElement as ConnectorContainer;
if (line.InSlotContainer != null && !(line.InSlotContainer is ConditionGraphElement))
{
result = false;
}
}
return(result);
}
/// <summary>
/// 创建并连接连接线
/// </summary>
/// <param name="flowChartManager">绘图管理器</param>
/// <param name="logicData">逻辑数据</param>
/// <returns>是否操作成功</returns>
protected virtual bool LogicCreateAndConnectLine(FlowChartManager flowChartManager, object logicData)
{
GraphManager graphManager = flowChartManager.CurrentGraphManager;
object[] args = logicData as object[];
int id = graphManager.AllocateGraphElementID();
SlotGraphElement outSlot = args[0] as SlotGraphElement;
SlotGraphElement inSlot = args[1] as SlotGraphElement;
ConnectorContainer line = CreateLine(outSlot.Location, inSlot.Location, id);
flowChartManager.CurrentGraphManager.SelectGraphElement(line, false);
return(true);
}
/// <summary>
/// 创建连接线
/// </summary>
/// <param name="flowChartManager">绘图管理器</param>
/// <param name="logicData">逻辑数据</param>
/// <returns>是否操作成功</returns>
protected virtual bool LogicCreateLine(FlowChartManager flowChartManager, object logicData)
{
GraphManager graphManager = flowChartManager.CurrentGraphManager;
object[] args = logicData as object[];
int id = graphManager.AllocateGraphElementID();
SlotGraphElement slot = args[0] as SlotGraphElement;
Point p = (Point)args[1];
ConnectorContainer line = CreateLine(slot.Location, p, id);
slot.Bind(line.TailConnector);
flowChartManager.CurrentGraphManager.SelectGraphElement(line, false);
return(true);
}
/// <summary>
/// 设置图元是否可用
/// </summary>
/// <param name="list">遍历过的图元链表</param>
/// <param name="graphElement">当前图元</param>
/// <param name="eventNode">事件结点</param>
/// <param name="enable">图元是否可用</param>
protected virtual void ReBindEventNode(List <GraphElement> list, GraphElement graphElement, EventGraphElement eventNode, bool enable)
{
if (!list.Contains(graphElement)) // 还没有遍历过当前图元
{
GraphManager graphManager = data as GraphManager;
DataManager dataManager = graphManager.CurrentFlowChartManager.CurrentDataManager;
if (graphElement is SlotContainer) // 该图元是插槽容器
{
SlotContainer slotContainer = graphElement as SlotContainer;
if (!enable && slotContainer.EventNode != null && dataManager.IsConnect(slotContainer.EventNode, slotContainer)) // 不需要更新当前图元的事件结点
{
}
else
{
list.Add(slotContainer);
slotContainer.Enable = enable;
slotContainer.EventNode = eventNode;
foreach (GraphElement g in dataManager.GetNextGraphElements(graphElement))
{
ReBindEventNode(list, g, eventNode, enable);
}
}
}
else if (graphElement is ConnectorContainer) // 该图元是连接线控制点容器
{
ConnectorContainer line = graphElement as ConnectorContainer;
if (!enable && line.EventNode != null && dataManager.IsConnect(line.EventNode, line)) // 不需要更新当前图元的事件结点
{
}
else
{
list.Add(line);
line.Enable = enable;
line.EventNode = eventNode;
foreach (GraphElement g in dataManager.GetNextGraphElements(graphElement))
{
ReBindEventNode(list, g, eventNode, enable);
}
}
}
}
}
/// <summary>
/// 检查是否连接有事件结点
/// </summary>
/// <param name="line">当前连接线</param>
/// <returns>是否连接有事件结点</returns>
public bool IsConnectEventNode(ConnectorContainer line)
{
bool result = false;
if (line.RequireEvent) // 需要入口事件
{
if (GetEventList(line).Count > 0)
{
result = true;
}
}
else
{
result = true;
}
return(result);
}
/// <summary>
/// 将连接线加入区域中
/// </summary>
/// <param name="line">当前连接线</param>
private void AddToRegion(ConnectorContainer line)
{
bool added = false;
foreach (RegionData regionData in regionDataList)
{
if (regionData.IsInRegion(line.InvalidRectangle))
{
regionData.Add(line);
added = true;
}
}
if (!added)
{
backupRegionData.Add(line);
}
}
/// <summary>
/// 执行命令
/// </summary>
/// <param name="o">当前对象</param>
/// <returns>是否执行成功</returns>
public override bool Execute(object o)
{
bool success = true;
Helper helper = Helper.GetHelper();
object[] args = o as object[];
SlotGraphElement outSlot = args[0] as SlotGraphElement;
SlotGraphElement inSlot = args[1] as SlotGraphElement;
// 保存命令执行前的数据
if (firstCommand) // 只有第一条命令保存执行前的数据
{
SaveBeforeExecute(flowChartManager.GetArguments());
}
// 执行逻辑操作
LogicBaseManager logicManager = helper.GetLogicManager(flowChartManager.CurrentChartMode);
logicManager.DoLogicOperation(flowChartManager, LogicType.CreateAndConnectLine, o);
ConnectorContainer line = graphManager.SelectedGraphElement as ConnectorContainer;
outSlot.Bind(line.GetConnectorList()[0]);
inSlot.Bind(line.GetConnectorList()[1]);
graphManager.ConnectorContainerList.Add(line);
graphManager.SelectGraphElement(line, false);
description = "创建并连接图元 " + outSlot.SlotContainer.Name + " - " + inSlot.SlotContainer.Name;
dataManager.AddDataElement(line);
graphManager.ReconstructCanvasGraphElementList();
// 执行逻辑操作
object[] logicData = new object[] { outSlot, outSlot.BindingConnector };
logicManager.DoLogicOperation(flowChartManager, LogicType.Connect, logicData);
if (success) // 保存命令执行后的数据
{
flowChartManager.ContentChanged = true;
SaveAfterExecute(flowChartManager.GetArguments());
}
return(success);
}
/// <summary>
/// 获取有接口选项的连接线
/// </summary>
/// <param name="infoString">接口选项</param>
/// <returns>连接线</returns>
public ConnectorContainer GetConnectedLine(string infoString)
{
ConnectorContainer line = null;
foreach (SlotGraphElement slot in outSlotList)
{
if (slot.Binded)
{
ConnectorContainer connectorContainer = slot.BindingConnector.Line;
if (connectorContainer.Text == infoString)
{
line = connectorContainer;
break;
}
}
}
return(line);
}
/// <summary>
/// 删除图元之后的操作
/// </summary>
/// <param name="flowChartManager">绘图管理器</param>
/// <param name="logicData">逻辑数据</param>
/// <returns>是否操作成功</returns>
protected override bool LogicAfterDelete(FlowChartManager flowChartManager, object logicData)
{
DataManager dataManager = flowChartManager.CurrentDataManager;
List <GraphElement> graphElementList = logicData as List <GraphElement>;
foreach (GraphElement graphElement in graphElementList)
{
List <GraphElement> list = new List <GraphElement>(); // 记录遍历过图元的链表
ReBindEventNode(dataManager, list, graphElement, false); // 重新设定事件结点及图元是否可用
ConnectorContainer line = graphElement as ConnectorContainer;
if (line != null)
{
// 连接线恢复可见状态
line.Moving = false;
line.Visible = true;
}
}
return(true);
}
/// <summary>
/// 获取兄弟连接线的数据
/// </summary>
/// <param name="graphElement">当前图元</param>
/// <returns>兄弟连接线的数据</returns>
public Hashtable GetNeighborData(GraphElement graphElement)
{
Hashtable table = new Hashtable();
if (graphElement is ConnectorContainer)
{
ConnectorContainer line = graphElement as ConnectorContainer;
if (line.InSlotContainer != null)
{
List <GraphElement> list = GetNextGraphElements(line.InSlotContainer, false);
foreach (GraphElement g in list)
{
if (g != graphElement)
{
table[g.ID.ToString()] = GetDataElement(g);
}
}
}
}
return(table);
}
/// <summary>
/// 执行命令
/// </summary>
/// <param name="o">当前对象</param>
/// <returns>是否执行成功</returns>
public override bool Execute(object o)
{
bool success = true;
Helper helper = Helper.GetHelper();
SlotGraphElement slot = o as SlotGraphElement;
// 保存命令执行前的数据
if (firstCommand) // 只有第一条命令保存执行前的数据
{
SaveBeforeExecute(flowChartManager.GetArguments());
}
ConnectorGraphElement connector = slot.BindingConnector;
ConnectorContainer line = connector.Line;
SlotContainer slotContainer = slot.SlotContainer;
description = "解除连接图元 " + slotContainer.Name;
slot.UnBind();
if (slot.CanDelete && (slot.IsInSlot || slot.SlotContainer.OutSlotCount > 1)) // 插槽可以删除
{
slotContainer.RemoveSlot(slot);
}
// 执行逻辑操作
LogicBaseManager logicManager = helper.GetLogicManager(flowChartManager.CurrentChartMode);
object[] logicData = new object[] { slot, connector };
logicManager.DoLogicOperation(flowChartManager, LogicType.Disconnect, logicData);
if (success) // 保存命令执行后的数据
{
flowChartManager.ContentChanged = true;
SaveAfterExecute(flowChartManager.GetArguments());
}
return(success);
}
/// <summary>
/// 获取连接线对应的事件结点数据链表
/// </summary>
/// <param name="connectorContainer">当前连接线</param>
/// <returns>连接线对应的事件结点数据链表</returns>
public List <DataElement> GetEventList(ConnectorContainer line)
{
List <DataElement> list = new List <DataElement>();
SlotContainer slotContainer = line.InSlotContainer;
if (slotContainer != null)
{
List <SlotContainer> slotContainerList = GetAllPreviousSlotContainers(slotContainer);
foreach (SlotContainer s in slotContainerList)
{
if (s is EventGraphElement)
{
DataElement dataElement = graphTable[s] as DataElement;
if (dataElement != null)
{
list.Add(dataElement);
}
}
}
}
return(list);
}
/// <summary>
/// 更新连接线所在的区域
/// </summary>
/// <param name="line">当前连接线</param>
private void ChangeRegion(ConnectorContainer line)
{
bool added = false; // 是否已经添加到区域中
foreach (RegionData regionData in regionDataList)
{
if (regionData.Contains(line) && !regionData.IsInRegion(line.InvalidRectangle))
{
regionData.Remove(line);
}
if (!regionData.Contains(line) && regionData.IsInRegion(line.InvalidRectangle))
{
regionData.Add(line);
added = true;
}
}
if (!added)
{
backupRegionData.Add(line);
}
}
/// <summary>
/// 删除图元
/// </summary>
/// <param name="graphElement">要删除的图元</param>
/// <return>是否删除成功</return>
protected bool DeleteGraphElement(GraphElement graphElement)
{
GraphManager graphManager = data as GraphManager;
DataManager dataManager = graphManager.CurrentFlowChartManager.CurrentDataManager;
List <GraphElement> list = new List <GraphElement>(); // 记录遍历过图元的链表
bool deleteSuccess = false; // 是否删除成功
if (graphElement is SlotContainer) // 要删除的图元是插槽容器
{
SlotContainer slotContainer = graphElement as SlotContainer;
ReBindEventNode(list, slotContainer, null, false); // 重新设定事件结点及图元是否可用
foreach (SlotGraphElement slot in slotContainer.GetSlotList())
{
if (slot.Binded) // 解除绑定连接线控制点
{
if (slot.IsOutSlot && slotContainer is ConditionGraphElement) // 对条件结点连出的线要进行有效性检查
{
ConnectorContainer line = slot.BindingConnector.Line;
if (line.Text == "×")
{
line.Invalid = false;
line.ShowText = false;
}
}
slot.UnBind();
}
}
graphManager.SlotContainerList.Remove(slotContainer); // 从插槽容器索引链表中删除
deleteSuccess = true;
}
else if (graphElement is ConnectorContainer) // 要删除的图元是连接线控制点容器
{
ConnectorContainer connectorContainer = graphElement as ConnectorContainer;
SlotContainer inSlotContainer = connectorContainer.InSlotContainer;
if (inSlotContainer != null)
{
connectorContainer.UnbindInSlotContainer();
}
ReBindEventNode(list, connectorContainer, null, false); // 重新设定事件结点及图元是否可用
SlotContainer outSlotContainer = connectorContainer.OutSlotContainer;
if (outSlotContainer != null)
{
connectorContainer.UnbindOutSlotContainer();
}
if (inSlotContainer is ConditionGraphElement) // 对条件结点连出的线要进行有效性检查
{
dataManager.CheckLineValid(inSlotContainer);
}
graphManager.ConnectorContainerList.Remove(connectorContainer); // 从连接线控制点索引容器中删除
deleteSuccess = true;
}
else if (graphElement is ConnectorGraphElement) // 要删除的图元是连接线控制点
{
ConnectorGraphElement connector = graphElement as ConnectorGraphElement;
if (connector.IsHeadPoint || connector.IsTailPoint) // 不允许删除头结点和尾结点
{
MessageBox.Show("不能删除头连接线控制点和尾连接线控制点！", "图元删除", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
connector.Line.RemoveConnector(connector);
deleteSuccess = true;
}
}
else if (graphElement is SlotGraphElement) // 要删除的图元是插槽
{
SlotGraphElement slot = graphElement as SlotGraphElement;
if (slot.CanDelete && (slot.IsInSlot || slot.SlotContainer.OutSlotCount > 1)) // 插槽可以删除
{
SlotContainer slotContainer = slot.SlotContainer;
slotContainer.RemoveSlot(slot);
deleteSuccess = true;
}
else
{
MessageBox.Show("该插槽不能删除", "图元删除", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
else if (graphElement is RemarkGraphElement) // 要删除的图元是注释结点
{
RemarkGraphElement remarkGraphElement = graphElement as RemarkGraphElement;
SlotContainer slotContainer = remarkGraphElement.Owner as SlotContainer;
slotContainer.RemarkNode = null;
remarkGraphElement.Owner = null;
remarkGraphElement = null;
deleteSuccess = true;
}
if (deleteSuccess) // 释放图元所占的资源
{
dataManager.DeleteData(graphElement);
graphElement.Release();
}
return(deleteSuccess);
}
/// <summary>
/// 编辑图元
/// </summary>
/// <param name="flowChartManager">绘图管理器</param>
/// <param name="logicData">逻辑数据</param>
/// <returns>是否操作成功</returns>
protected virtual bool LogicEdit(FlowChartManager flowChartManager, object logicData)
{
bool executeResult = true;
GraphManager graphManager = flowChartManager.CurrentGraphManager;
DataManager dataManager = flowChartManager.CurrentDataManager;
DocumentManager documentManager = DocumentManager.GetDocumentManager();
GraphElement graphElement = logicData as GraphElement;
DataElement dataElement = dataManager.GetDataElement(graphElement);
object data = dataManager.GetData(graphElement);
Hashtable information = new Hashtable();
information["data"] = data;
information["prev_data"] = dataManager.GetPreviousData(graphElement);
information["next_data"] = dataManager.GetNextData(graphElement);
information["neighbor_data"] = dataManager.GetNeighborData(graphElement);
information["globe_args"] = dataManager.GlobeArgs;
information["flowchart_name"] = flowChartManager.Name;
information["map_name"] = flowChartManager.MapName;
information["client_dir"] = Helper.GetHelper().OutputDir;
dataElement.PrintInformation = new DataElement.PrintInfo(documentManager.PrintText);
try
{
executeResult = dataElement.EditData(information);
}
catch (Exception ex)
{
executeResult = false;
MessageBox.Show("当前图元由于以下原因无法编辑：\n\n" + ex.Message, "图元编辑",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
if (executeResult) // 保存图元数据
{
Hashtable previousDataTable = information["prev_data"] as Hashtable;
Hashtable nextDataTable = information["next_data"] as Hashtable;
GraphElement currentGraphElement;
DataElement editDataElement;
// 检查是否需要更新图元和数据元的数据
foreach (string id in previousDataTable.Keys)
{
editDataElement = previousDataTable[id] as DataElement;
if (editDataElement != null && editDataElement.Data == null)
{
currentGraphElement = dataManager.FindGraphElementByID(int.Parse(id));
currentGraphElement.Text = editDataElement.Text;
currentGraphElement.TooltipText = editDataElement.TooltipText;
currentGraphElement.ShowText = false;
}
}
foreach (string id in nextDataTable.Keys)
{
editDataElement = nextDataTable[id] as DataElement;
if (editDataElement != null && editDataElement.Data == null)
{
currentGraphElement = dataManager.FindGraphElementByID(int.Parse(id));
currentGraphElement.Text = editDataElement.Text;
currentGraphElement.TooltipText = editDataElement.TooltipText;
currentGraphElement.ShowText = false;
}
}
graphElement.TooltipText = dataElement.TooltipText;
graphElement.Text = dataElement.Text;
if (string.IsNullOrEmpty(dataElement.Text))
{
graphElement.ShowText = false;
}
else
{
graphElement.ShowText = true;
}
// 调整文本
if (graphElement is SlotContainer)
{
SlotContainer slotContainer = graphElement as SlotContainer;
slotContainer.AdjustText();
// 根据文本内容调整插槽容器的大小
slotContainer.AdjustElementSize();
}
else if (graphElement is ConnectorContainer)
{
ConnectorContainer line = graphElement as ConnectorContainer;
line.AdjustText();
}
}
return(executeResult);
}
/// <summary>
/// 删除图元
/// </summary>
/// <param name="graphElement">要删除的图元</param>
/// <return>是否删除成功</return>
protected bool DeleteGraphElement(GraphElement graphElement)
{
Helper helper = Helper.GetHelper();
GraphManager graphManager = data as GraphManager;
FlowChartManager flowChartManager = graphManager.CurrentFlowChartManager;
DataManager dataManager = flowChartManager.CurrentDataManager;
bool deleteSuccess = false; // 是否删除成功
// 执行逻辑操作
LogicBaseManager logicManager = helper.GetLogicManager(flowChartManager.CurrentChartMode);
logicManager.DoLogicOperation(flowChartManager, LogicType.BeforeDelete, graphElement);
if (graphElement is SlotContainer) // 要删除的图元是插槽容器
{
SlotContainer slotContainer = graphElement as SlotContainer;
List <GraphElement> graphElementList = new List <GraphElement>();
// 解除绑定连接线控制点
foreach (ConnectorContainer line in slotContainer.GetConnectedLine())
{
graphElementList.Add(line);
}
slotContainer.UnBind();
// 执行逻辑操作
logicManager.DoLogicOperation(flowChartManager, LogicType.AfterDelete, graphElementList);
graphManager.SlotContainerList.Remove(slotContainer); // 从插槽容器索引链表中删除
deleteSuccess = true;
}
else if (graphElement is ConnectorContainer) // 要删除的图元是连接线控制点容器
{
ConnectorContainer connectorContainer = graphElement as ConnectorContainer;
List <GraphElement> graphElementList = new List <GraphElement>();
SlotContainer inSlotContainer = connectorContainer.InSlotContainer;
if (inSlotContainer != null)
{
connectorContainer.UnbindInSlotContainer();
}
SlotContainer outSlotContainer = connectorContainer.OutSlotContainer;
if (outSlotContainer != null)
{
graphElementList.Add(outSlotContainer);
connectorContainer.UnbindOutSlotContainer();
}
// 执行逻辑操作
logicManager.DoLogicOperation(flowChartManager, LogicType.AfterDelete, graphElementList);
graphManager.ConnectorContainerList.Remove(connectorContainer); // 从连接线控制点索引容器中删除
deleteSuccess = true;
}
else if (graphElement is ConnectorGraphElement) // 要删除的图元是连接线控制点
{
ConnectorGraphElement connector = graphElement as ConnectorGraphElement;
ConnectorContainer connectorContainer = connector.Line;
List <GraphElement> graphElementList = new List <GraphElement>();
SlotContainer inSlotContainer = connectorContainer.InSlotContainer;
if (inSlotContainer != null)
{
connectorContainer.UnbindInSlotContainer();
}
SlotContainer outSlotContainer = connectorContainer.OutSlotContainer;
if (outSlotContainer != null)
{
graphElementList.Add(outSlotContainer);
connectorContainer.UnbindOutSlotContainer();
}
// 执行逻辑操作
logicManager.DoLogicOperation(flowChartManager, LogicType.AfterDelete, graphElementList);
graphManager.ConnectorContainerList.Remove(connectorContainer); // 从连接线控制点索引容器中删除
deleteSuccess = true;
}
else if (graphElement is SlotGraphElement) // 要删除的图元是插槽
{
SlotGraphElement slot = graphElement as SlotGraphElement;
if (slot.CanDelete && (slot.IsInSlot || slot.SlotContainer.OutSlotCount > 1)) // 插槽可以删除
{
SlotContainer slotContainer = slot.SlotContainer;
slotContainer.RemoveSlot(slot);
deleteSuccess = true;
}
else
{
MessageBox.Show("该插槽不能删除", "图元删除", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
else if (graphElement is RemarkGraphElement) // 要删除的图元是注释结点
{
RemarkGraphElement remarkGraphElement = graphElement as RemarkGraphElement;
SlotContainer slotContainer = remarkGraphElement.Owner as SlotContainer;
slotContainer.RemarkNode = null;
remarkGraphElement.Owner = null;
remarkGraphElement = null;
deleteSuccess = true;
}
if (deleteSuccess) // 释放图元所占的资源
{
dataManager.DeleteData(graphElement);
graphElement.Release();
}
return(deleteSuccess);
}
/// <summary>
/// 执行命令
/// </summary>
/// <param name="o">命令的参数</param>
/// <returns>是否执行成功</returns>
public override bool Execute(object o)
{
bool success = true;
List <GraphElement> list = new List <GraphElement>();
// 保存命令执行前的数据
if (firstCommand) // 只有第一条命令保存执行前的数据
{
SaveBeforeExecute(flowChartManager.GetArguments());
}
if (graphManager.SelectedGraphElementList.Count > 0) // 剪切多个图元
{
List <GraphElement> graphElementList = graphManager.SelectedGraphElementList;
description = "剪切图元组";
foreach (GraphElement graphElement in graphElementList)
{
if (graphElement is SlotContainer) // 图元是插槽容器
{
SlotContainer slotContainer = graphElement as SlotContainer;
foreach (SlotGraphElement slot in slotContainer.GetSlotList())
{
if (slot.Binded && !graphElementList.Contains(slot.BindingConnector.Line))
{
slot.UnBind();
}
}
graphManager.SlotContainerList.Remove(slotContainer);
}
else if (graphElement is ConnectorContainer) // 图元是连接线
{
ConnectorContainer line = graphElement as ConnectorContainer;
List <SlotGraphElement> deleteSlotList = new List <SlotGraphElement>();
if (line.InSlotContainer != null && !graphElementList.Contains(line.InSlotContainer))
{
line.UnbindInSlotContainer();
}
graphManager.ConnectorContainerList.Remove(line);
}
list.Add(graphElement);
}
}
else // 剪切单个图元
{
GraphElement graphElement = graphManager.SelectedGraphElement;
description = "剪切图元 " + graphElement.Name;
if (graphElement is SlotContainer) // 图元是插槽容器
{
SlotContainer slotContainer = graphElement as SlotContainer;
slotContainer.UnBind();
graphManager.SlotContainerList.Remove(slotContainer);
}
else if (graphElement is ConnectorContainer) // 图元是连接线
{
ConnectorContainer line = graphElement as ConnectorContainer;
if (line.InSlotContainer != null)
{
line.UnbindInSlotContainer();
}
if (line.OutSlotContainer != null)
{
line.UnbindOutSlotContainer();
}
graphManager.ConnectorContainerList.Remove(line);
}
list.Add(graphElement);
}
Hashtable cutTable = new Hashtable();
foreach (GraphElement g in list)
{
cutTable[g] = dataManager.GetData(g);
}
documentManager.CopyTable = cutTable;
if (success) // 保存命令执行后的数据
{
flowChartManager.ContentChanged = true;
SaveAfterExecute(flowChartManager.GetArguments());
}
return(success);
}
/// <summary>
/// 获取连出的图元链表
/// </summary>
/// <param name="graphElement">当前图元</param>
/// <param name="hasInnerChart">是否处理子绘图</param>
/// <returns>连出的图元链表</returns>
public List <GraphElement> GetNextGraphElements(GraphElement graphElement, bool dealInnerChart)
{
List <GraphElement> list = new List <GraphElement>();
if (graphElement is SlotContainer) // 当前图元是插槽容器
{
SlotContainer slotContainer = graphElement as SlotContainer;
foreach (SlotGraphElement slot in slotContainer.GetOutSlotList())
{
if (slot.Binded)
{
list.Add(slot.BindingConnector.Line);
}
}
}
else if (graphElement is ConnectorContainer) // 当前图元是连接线控制点容器
{
ConnectorContainer line = graphElement as ConnectorContainer;
if (line.OutSlotContainer != null)
{
if (dealInnerChart)
{
SlotContainer slotContainer = line.OutSlotContainer;
if (slotContainer is InnerChart)
{
SlotGraphElement slot = slotContainer.GetBindedInSlot(line);
InnerChartEditor innerChartEditor = GetDataElement(slotContainer) as InnerChartEditor;
if (slot != null)
{
InterfaceGraphElement interfaceNode = innerChartEditor.GetInterfaceNode(slot.Tag.ToString());
if (interfaceNode != null)
{
GraphElement connectedGraphElement = interfaceNode.GetConnectedOutGraphElement();
if (connectedGraphElement != null)
{
list.Add(connectedGraphElement);
}
}
}
}
else if (slotContainer is InterfaceGraphElement)
{
InnerChart innerChart = FindGraphElementByID(int.Parse(slotContainer.Tag as string)) as InnerChart;
foreach (SlotGraphElement slot in innerChart.GetOutSlotList())
{
if (slot.Binded)
{
ConnectorContainer connectedLine = slot.BindingConnector.Line;
string lineData = GetData(connectedLine) as string;
if (!string.IsNullOrEmpty(lineData))
{
string[] dataArray = lineData.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (dataArray[0] == slotContainer.ID.ToString())
{
list.AddRange(GetNextGraphElements(slot.BindingConnector.Line, true));
break;
}
}
/*
* if (!string.IsNullOrEmpty(connectedLine.Text))
* {
* string[] dataArray = connectedLine.Text.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
*
* if (dataArray[0] == slotContainer.ID.ToString())
* {
* list.AddRange(GetNextGraphElements(slot.BindingConnector.Line, true));
* break;
* }
* }
*/
}
}
/*
* foreach (SlotGraphElement slot in innerChart.GetOutSlotList())
* {
* if (slot.Tag.ToString() == slotContainer.ID.ToString())
* {
* slotGraphElement = slot;
* break;
* }
* }
*
* if (slotGraphElement != null)
* {
* if (slotGraphElement.Binded)
* {
* list.AddRange(GetNextGraphElements(slotGraphElement.BindingConnector.Line, true));
* }
* }
*/
}
else
{
list.Add(slotContainer);
}
}
else
{
list.Add(line.OutSlotContainer);
}
}
}
return(list);
}
/// <summary>
/// 检查区域中是否包含当前连接线
/// </summary>
/// <param name="line">当前连接线</param>
/// <returns>区域中是否包含当前连接线</returns>
public bool Contains(ConnectorContainer line)
{
bool result = connectorContainers.Contains(line);
return(result);
}
/// <summary>
/// 删除区域中的连接线
/// </summary>
/// <param name="line">当前连接线</param>
public void Remove(ConnectorContainer line)
{
connectorContainers.Remove(line);
}
