public ComponentNode CreateAndInsertComponent(int componentId, int childIndex)
{
var componentElement = new ComponentNode(componentId);
InsertLogicalChild(componentElement, childIndex);
return(componentElement);
}
private void DoProcess(object state)
{
Thread.Sleep(100);
AsyncNodeResult result = (AsyncNodeResult)state;
try
{
if (result.StartNode == null)
{
return;
}
WorkflowSolver solver = new WorkflowSolver();
ComponentNode next = solver.SolveComplexComponentTree(result.ComponentList,
result.StartNode,
result.Batch.ExtraInfo,
result.JobCallback,
result.Batch,
result.Group,
result.Job);
result.NextNode = next;
}
catch (Exception ex)
{
result.Exception = ex;
//throw;
}
finally
{
OnCompleted(result);
}
}
public void GetClosest(DispensaryGrid grid, Vector3 startPos, ComponentNode originalTargetNode, List <ComponentNode> closed)
{
float currentDist = 1000;
ComponentNode currentClosestNode = new ComponentNode();
foreach (ComponentNode node in closed)
{
if (node.walkable)
{
float newdist = Vector3.Distance(node.worldPosition, originalTargetNode.worldPosition);
if (newdist < currentDist)
{
currentDist = newdist;
currentClosestNode = node;
}
}
}
if (!currentClosestNode.isNull)
{
if (grid != null)
{
StartFindPath(grid, startPos, currentClosestNode.worldPosition);
}
else
{
print("Grid was null");
}
}
}
private void CreateOrEditNode(IssoPoint2D pt1)
{
// РЕДАКТИРОВАНИЕ УЗЛА
// Сначала найдём ближайший к pt1 компонент и точку на нём -
// Если pt1 далека от какого-либо компонента, не делаем ничего
// Если эта точка далека от существующего узла компонента, то
// Создаём новый узел, разделяя компонент на две части
IssoPoint2D pt2;
ComponentBasic comp = modelVM.GetComponent(pt1, out pt2);
// Если эта точка близка к началу или концу линейного компонента - выбираем начало или конец
// Если нет - разбиваем компонент на две части
if (comp?.CompType == ComponentTypes.ctLinear)
{
modelVM.SplitLinearAt((ComponentLinear)comp, pt2);
EditedComp = new ComponentNode(pt2);
RModel.CompsList.Add(EditedComp);
OnComponentSelected?.Invoke(EditedComp, null);
}
if (comp?.CompType == ComponentTypes.ctNode)
{
EditedComp = comp;
OnComponentSelected?.Invoke(EditedComp, null);
}
}
public override void BeforeCloseOnNext()
{
Params.Solution.Projects.Clear();
foreach (BaseNode BN in _treeView.AllNodes)
{
ComponentNode CN = BN as ComponentNode;
if (CN == null)
{
continue;
}
if (!CN.Checked)
{
continue;
}
else
{
string str = @"$(SPOCLIENT)\Solutions\" + Params.Solution.Name + @"\";
ProjectWrapper Template = FindProjectTemplate(CN.TypedContent);
MFProject tmpProj = new MFProject();
Template.InnerObject.CopyTo(tmpProj, Params.Solution.Name);
if (tmpProj != null)
{
tmpProj.ProjectPath = str + Path.GetFileName(tmpProj.Directory) + @"\" + Path.GetFileName(tmpProj.ProjectPath);
tmpProj.SettingsFile = str + Params.Solution.Name + ".settings";
Params.Solution.Projects.Add(ProjectWrapper.Wrap <ProjectWrapper>(tmpProj));
}
}
}
this.OnShowNextBtn(true);
}
public override void OnBodyGUI()
{
if (target == null)
{
return;
}
NodeEditorGUILayout.PortField(((ComponentNode <T>)target).objectInput);
ComponentNode <T> node = ((ComponentNode <T>)target);
if (Event.current.type != EventType.MouseUp)
{
if (node.component != null && node.serializedObject != null)
{
for (int idx = 0; idx < node.properties.Length; idx++)
{
if (node.__isInput[idx])
{
NodeEditorGUILayout.PortField(node.__input[idx]);
}
if (node.__isShown[idx] && ((node.__isInput[idx] || !node.__input[idx].IsConnected) || (node.__isOutput[idx] || !node.__output[idx].IsConnected)))
{
EditorGUILayout.PropertyField(node.properties[idx], true);
}
if (node.__isOutput[idx])
{
NodeEditorGUILayout.PortField(node.__output[idx]);
}
}
node.serializedObject.ApplyModifiedProperties();
}
}
}
private static IEnumerable <ComponentNode> ExcuteComplexStartNode(List <ComponentNode> paramList,
ComponentNode startNode,
ICollection <ExtraProcessInfo> extraProcessInfos,
INotificationCallback callback,
ProcessBatch batch,
ProcessGroup group,
ProcessJob job)
{
Guid zero = new Guid();
IEnumerable <ComponentNode> childParams = from p in paramList where (p.ParentIdList.FirstOrDefault(pl => pl == startNode.Id) != zero) select p;
IExecuteStartupComponent component = ProcessObjectLocator.LocateStartComponentProcess(startNode.CompopnentExcutionName);
if (component != null)
{
//do waht ever client initiation here
IResultForNextNode obj = component.ExecuteStartupComponent(batch, group, job, extraProcessInfos,
paramList, startNode, callback);
//since startup node takes raw file usually open it
foreach (var param in paramList)
{
//set iRaw Data to each ComponentParameters
param.StartupResult = obj;
param.TreeExecutionTag = startNode.TreeExecutionTag;
param.ParentComponentResults = new List <IResultForNextNode>();
param.ParentComponentResults.Add(obj);
param.ProcessedParentCount = 0;
}
}
return(childParams);
}
public List <ComponentNode> GetCrossSection(int units, ComponentNode node)
{
ComponentSubGrid grid = GetSubGrid(node.subGridIndex);
List <ComponentNode> neighbours = new List <ComponentNode> ();
for (int x = -units; x <= units; x++)
{
for (int y = -units; y <= units; y++)
{
if (x == 0 && y == 0)
{
continue;
}
int checkX = node.gridX + x;
int checkY = node.gridY + y;
if (checkX >= 0 && checkX < grid.gridSizeX && checkY >= 0 && checkY < grid.gridSizeY)
{
neighbours.Add(grid.grid[checkX, checkY]);
}
}
}
return(neighbours);
}
//判断cNode与cmp当中的各个构件的连接关系，是否gNode与selectedNode各个节点也满足
private bool LinesMatched(Models.Component cmp, ComponentNode cNode, Stack <DynamicNode> selectedNode, DynamicNode dNode)
{
for (int i = 0; i < cmp.NodeNum; i++)
{
var curCNode = cmp.CmpTopoNet.NodeArray[i];//当前的构件节点
if (curCNode == cNode)
{
break;
//continue;
}
var curDNode = selectedNode.Reverse().ToList()[curCNode.NodeId]; //当前的动态节点
//GTX连接判断
var cGTXLine = cmp.CmpTopoNet.GTXLinks[cNode.NodeId, curCNode.NodeId];
var dGtxLine = _topoNet.GTXLinks[dNode.SNode.UrlId, curDNode.SNode.UrlId];
if (!LineMatched(cGTXLine, dGtxLine))
{
return(false);
}
//LVDS连接判断
var cLVDSLine = cmp.CmpTopoNet.LVDSLinks[cNode.NodeId, curCNode.NodeId];
var dLVDSLine = _topoNet.LVDSLinks[dNode.SNode.UrlId, curDNode.SNode.UrlId];
if (!LineMatched(cLVDSLine, dLVDSLine))
{
return(false);
}
}
return(true);
}
private void CreateNewLinear(IssoPoint2D pt1)
{
// НОВЫЙ ЛИНЕЙНЫЙ КОМПОНЕНТ
// Компонент идёт в паре с двумя узлами.
// Первый узел - в точке, указанной пользователем (pt1)
// Если в этой точке уже есть другой узел, то берём его как начало элемента
// Если тут нет узла - создаём его, и берём как стартовый
// Если пользователь указал точку, лежащую на линейном компоненте - создаём в этом месте
// узел, разделяя компонент на две части, и берём его как стартовый
ComponentNode node = modelVM.GetNodeAtPoint(pt1);
if (node == null)
{
IssoPoint2D pt2;
ComponentBasic b = modelVM.GetComponent(pt1, out pt2);
if (b?.CompType == ComponentTypes.ctLinear)
{
modelVM.SplitLinearAt((ComponentLinear)b, pt2);
node = modelVM.GetNodeAtPoint(pt2);
}
node = new ComponentNode(pt1);
}
pt1.X += 0.1f;
EditedComp = new ComponentLinear(node, new ComponentNode(pt1), RModel);
EditorAction = EditorActions.NewLinearLastPoint;
}
public ExecutionNode BuildNode()
{
if (!OptionSet)
{
throw new InvalidOperationException();
}
ExecutionNode node;
if (ActivityType != null)
{
throw new NotImplementedException("Projection in the graph of a reference type not supported");
}
else if (ProxyActivity != null)
{
node = new ComponentNode(ProxyActivity);
}
else if (ActivityBranchBuilder != null)
{
node = ActivityBranchBuilder.BuildNode();
}
else
{
node = new BuilderNode(Name, Decision != null, false, false, Metadata);
}
return(node);
}
private void ApplySnap(ComponentLinear linear, IssoPoint2D pt1)
{
ComponentNode node = modelVM.GetNodeAtPoint(pt1);
if (node != null)
{
linear.End = node.Location;
}
else
{
// Используем выравнивание. Если угол близок к 0, 90, 180, 270 и т.п. - выравниваем.
float a = IssoBind.OrthoAngle(linear.AngleD);
if ((a == 0) || (a == 180))
{
linear.EndNode.MoveTo(new IssoPoint2D()
{
X = pt1.X, Y = linear.Start.Y
});
}
if ((a == 90) || (a == 270) || (a == -90))
{
linear.EndNode.MoveTo(new IssoPoint2D()
{
Y = pt1.Y, X = linear.Start.X
});
}
}
}
private void AddNewLinear()
{
// Добавляем элемент в модель
// Если в модели уже были узлы начала и конца этого нового элемента
// то новые узлы не добавляем. В противном случае - добавляем и узлы
if (EditedComp?.CompType == ComponentTypes.ctLinear)
{
ComponentLinear lin = (ComponentLinear)EditedComp;
ComponentNode node1 = modelVM.GetNodeAtPoint(lin.Start);
ComponentNode node2 = modelVM.GetNodeAtPoint(lin.End);
if (node1 == null)
{
RModel.CompsList.Add(lin.StartNode);
node1 = lin.StartNode;
}
if (node2 == null)
{
RModel.CompsList.Add(lin.EndNode);
node2 = lin.EndNode;
}
EditedComp = new ComponentLinear(node1, node2, RModel);
RModel.EnableChangeTracking();
RModel.CompsList.Add(EditedComp);
RModel.DisableChangeTracking();
}
}
public ComponentNode GetOrCreateComponentLink(Guid endpointId, IProductElementViewModel serviceViewModel, IProductElementViewModel componentViewModel, IProductElementViewModel viewModel)
{
// Find undeployed component
var undeployedComponentNode = FindComponent(EmptyEndpointNode.NodeId,
serviceViewModel.Data.Id,
componentViewModel.Data.Id);
if (undeployedComponentNode != null)
{
this.DeleteNode(undeployedComponentNode);
}
// Create New Component Link
var componentNode = FindComponent(endpointId,
serviceViewModel.Data.Id,
componentViewModel.Data.Id);
if (componentNode == null)
{
var serviceNode = GetOrCreateServiceNode(endpointId,
serviceViewModel);
componentNode = new ComponentNode(componentViewModel,
serviceNode,
viewModel);
AddNode(componentNode);
}
return(componentNode);
}
private ComponentNode GetLoadStartNode(IssoPoint2D pt1, ComponentTypes loadType)
{
// Если пользователь указал узел, то создаём силу, приложенную в этом узле
ComponentNode node = modelVM.GetNodeAtPoint(pt1);
if ((node == null) || (!modelVM.CloseEnough(pt1, node.Location)))
{
ComponentBasic lin = modelVM.GetComponent(pt1, out IssoPoint2D pt2);
// Если же он указал линейный компонент, то создаём узел в ближайшей точке к указанной
// точке компонента, а уже в нём - силу
if (lin?.CompType == ComponentTypes.ctLinear)
{
if (loadType == ComponentTypes.ctForce)
{
if (lin?.CompType == ComponentTypes.ctLinear)
{
modelVM.SplitLinearAt((ComponentLinear)lin, pt1);
}
node = modelVM.GetNodeAtPoint(pt1);
}
else
{
node = new ComponentNode(pt2);
}
}
else
{
node = null;
}
}
return(node);
}
internal bool DeleteSelectedObject()
{
ComponentBasic b = GetSelectedComponent();
if (b.CompType == ComponentTypes.ctLinear)
{
ComponentNode n1 = ((ComponentLinear)b).StartNode;
ComponentNode n2 = ((ComponentLinear)b).EndNode;
// Выясним, есть ли ещё компоненты, соединённые с этими узлами
// Если нет - удаляем и узлы
if (RModel.NodeSingle(n1))
{
RModel.CompsList.Remove(n1);
}
if (RModel.NodeSingle(n2))
{
RModel.CompsList.Remove(n2);
}
}
if (b.CompType == ComponentTypes.ctNode)
{
// При удалении узла возникают ситуации
// 1. Удаление крайнего узла. В этом случае требуется подтверждение на удаление,
// поскольку удаляться должен и заканчивающийся в этом узле линейный компонент
// 2. Удаление узла, в котором сходятся несколько элементов
// 2.1. Если элементов два - сращиваем элементы в один
// То есть, фактически удаляем один из них - тот, на котором нет распределённой нагрузки
// а оставшийся улиняем до конца удалённого элемента
// 2.2 TODO: В общем, слишком муторно, отложу на потом.
}
RModel.CompsList.Remove(b);
editedComp = null;
Invalidate();
return(true);
}
public GraphDataFlowBlockNode([NotNull] GraphMethodRoot methodRoot) : base(methodRoot)
{
StrongConnectivityNode = new ComponentNode <GraphDataFlowBlockNode>(this);
((IComponentNodeItem <GraphDataFlowBlockNode>) this).SubscribeToStrongConnectivityNodePropertyChanged();
RefreshText();
}
public override ModelBase CreateObjectByName(string objectName)
{
Component component = new Component();
string xmlPathDir = Path.Combine(PathManager.GetComponentPath(), objectName);
string xmlPath = string.Format("{0}.xml", xmlPathDir);
if (!File.Exists(xmlPath))
{
MessageBox.Show("CreateObject_Component:没有该Component对应的XML文件！");
return(null);
}
XDocument xd = XDocument.Load(xmlPath);
//根元素的Attribute
XElement rt = xd.Element("Component");
component.Name = rt.Attribute("Name").Value;
component.InitTopo(int.Parse(rt.Attribute("NodeNum").Value));
var nodesElement = rt.Element("Nodes");
foreach (var e in nodesElement.Elements())
{
var nodeId = int.Parse(e.Attribute("NodeNum").Value);
var nodeType = (EndType)(Enum.Parse(typeof(EndType), e.Attribute("NodeType").Value));
var nodeName = e.Attribute("NodeName").Value;
var nodeObject = Component_GenNodeObj(nodeType, string.Format(@"{0}\{1}.xml", xmlPathDir, nodeName));
var cmpNode = new ComponentNode(nodeId, nodeObject);
component.CmpTopoNet.SetNodeValue(nodeId, cmpNode);
}
var linksElement = rt.Element("Links");
var ethLinksElement = linksElement.Element("EthLinks");
foreach (var eLine in ethLinksElement.Elements())
{
component.CmpTopoNet.SetLinkValue(Component_TransXmlLink(eLine));
}
var rioLinksElement = linksElement.Element("RioLinks");
foreach (var eLine in rioLinksElement.Elements())
{
component.CmpTopoNet.SetLinkValue(Component_TransXmlLink(eLine));
}
var gtxLinksElement = linksElement.Element("GTXLinks");
foreach (var eLine in gtxLinksElement.Elements())
{
component.CmpTopoNet.SetLinkValue(Component_TransXmlLink(eLine));
}
var lvdsLinksElement = linksElement.Element("LVDSLinks");
foreach (var eLine in lvdsLinksElement.Elements())
{
component.CmpTopoNet.SetLinkValue(Component_TransXmlLink(eLine));
}
return(component);
}
public void Init()
{
virtualStudioWithArrangement = new VirtualStudioWithArrangement();
var placeholder = new PlaceholderStudioComponent();
virtualStudioWithArrangement.ComponentRepository.AddPlaceholder(placeholder);
componentNode = virtualStudioWithArrangement.AddComponent(placeholder, new Position2D(0, 0));
}
public GraphDataFlowReturnNode(GraphMethodRoot methodRoot, [CanBeNull] ExpressionBase expression) : base(
methodRoot, expression)
{
StrongConnectivityNode = new ComponentNode <GraphDataFlowReturnNode>(this);
((IComponentNodeItem <GraphDataFlowReturnNode>) this).SubscribeToStrongConnectivityNodePropertyChanged();
RefreshText();
}
private static ComponentNode ExcuteComplexComponentNode(List <ComponentNode> paramList,
ComponentNode thisNode,
INotificationCallback callback,
ProcessBatch batch,
ProcessGroup group,
ProcessJob job)
{
ComponentNode nextNode = null;
if (thisNode.CompNodeValidation == NodeValidationType.Group)
{
return(thisNode);
}
Debug.WriteLine(thisNode.ComponentName);
thisNode.ProcessedParentCount++;
if (thisNode.ProcessedParentCount != thisNode.ParentIdList.Count)
{
// _excutableInWait.Add(thisNode);
return(null);
}
Guid zero = new Guid();
var childrenParams = (from p in paramList
where (p.ParentIdList.FirstOrDefault(pl => pl == thisNode.Id) != zero)
select p).ToList();
// IEnumerable<ComponentNode> childrenParams = from p in paramList where p.ParentId == thisNode.Id select p;
//IExcuteComponent component = ProcessObjectLocator.LocateComponentProcess(thisNode.CompopnentExcutionName);
Type tp = ProcessRunTimeLocator.GetExecutableType(thisNode.CompopnentExcutionName);
if (tp == null)
{
return(null);
}
IExcuteComponent component = (IExcuteComponent)Activator.CreateInstance(tp);
if (component != null)
{
IResultForNextNode ret = component.ExcuteThermoComponent(paramList, thisNode, callback, batch, group, job);
if (ret != null)
{
ret.ThisNodeId = thisNode.Id;
foreach (var param in childrenParams)
{
param.ParentComponentResults.Add(ret);
}
}
}
thisNode.ParentComponentResults.Clear();
//_excutableInWait.Remove(thisNode);
thisNode.ProcessedParentCount = 0;
foreach (var childrenParam in childrenParams)
{
nextNode = ExcuteComplexComponentNode(paramList, childrenParam, callback, batch, group, job);
}
return(nextNode);
}
private static void DrawRollerSupport(ComponentNode c, ModelViewSurface surface, SKCanvas canvas, bool isInt)
{
SKPath roller = DefaultRoller();
SKMatrix rotate;
roller.Transform(TRMatrix(c, surface, out rotate));
roller.Transform(rotate);
canvas.DrawPath(roller, GetPaint(c));
}
private static void DrawPinSupport(ComponentNode c, ModelViewSurface surface, SKCanvas canvas, bool isInt)
{
SKPath pin = DefaultPin();
SKMatrix rotate;
pin.Transform(TRMatrix(c, surface, out rotate));
pin.Transform(rotate);
canvas.DrawPath(pin, GetPaint(c));
}
void CheckBoxStateChanged(object sender, TreePathEventArgs e)
{
ComponentNode node = e.Path.LastNode as ComponentNode;
if (node != null)
{
RecursiveCheckComponent(node.TypedContent);
}
}
private void SerializeComponent(ComponentNode component)
{
Write("[Component ( ");
Write(component.ComponentId.ToString(CultureInfo.InvariantCulture));
WriteLine(" )]");
_depth++;
SerializeChildren(component);
_depth--;
}
protected override bool OnCheckBoxVisible(ComponentNode node)
{
switch (node.TypedContent.ComponentType)
{
case ComponentTypeWrapper.Feature:
return(true);
}
return(false);
}
protected override bool OnCheckBoxVisible(ComponentNode node)
{
switch (node.TypedContent.ComponentType)
{
case ComponentTypeWrapper.Feature:
return true;
}
return false;
}
public static ComponentNodeDto ToDto(this ComponentNode componentNode)
{
return(new ComponentNodeDto
{
Component = componentNode.Component.ToDto(),
X = componentNode.Position.X,
Y = componentNode.Position.Y
});
}
void IsCheckBoxVisible(object sender, NodeControlValueEventArgs e)
{
e.Value = false;
ComponentNode node = e.Node.Tag as ComponentNode;
if (node != null)
{
e.Value = OnCheckBoxVisible(node);
}
}
private void UpdateComponent(RenderBatch batch, int componentId, ArrayBuilderSegment <RenderTreeEdit> edits)
{
if (!Components.TryGetValue(componentId, out var component))
{
component = new ComponentNode(componentId);
Components.Add(componentId, component);
}
ApplyEdits(batch, component, 0, edits);
}
protected override bool OnCheckBoxVisible(ComponentNode node)
{
switch (node.TypedContent.ComponentType)
{
//case ComponentTypeWrapper.LibraryCategory:
case ComponentTypeWrapper.Library:
return(true);
}
return(false);
}
protected override bool OnCheckBoxVisible(ComponentNode node)
{
switch (node.TypedContent.ComponentType)
{
//case ComponentTypeWrapper.LibraryCategory:
case ComponentTypeWrapper.Library:
return true;
}
return false;
}
protected ComponentNode ScanComponent(Component cmp)
{
if (cmp == null) return null;
if (!this.buttonShowComponents.Checked) return null;
ComponentNode thisNode = new ComponentNode(cmp);
return thisNode;
}
protected virtual bool OnCheckBoxVisible(ComponentNode node)
{
return true;
}
