/// <summary>
/// Connects the end.
/// When connecting the end, it also updates information in the experiment model data.
/// </summary>
/// <param name='end'>
/// End.
/// </param>
public override void ConnectEnd(MonoHotDraw.Connectors.IConnector end)
{
base.ConnectEnd(end);
if (end != null)
{
IComponentControl startComponentControl = StartConnector.Owner as IComponentControl;
IComponentControl endComponentControl = end.Owner as IComponentControl;
if (endComponentControl != null && startComponentControl != null)
{
//get access to owner experiment
IEditableExperiment ownerExperiment = endComponentControl.ExperimentNode.Owner as IEditableExperiment;
if (ownerExperiment != null)
{
ExperimentNodeConnection nodeConnection = ownerExperiment.AddConnection(startComponentControl.ExperimentNode, endComponentControl.ExperimentNode);
OnConnectionCompleted(nodeConnection);
m_experimentNodeConnection = nodeConnection;
// SPRINT 2: TLAB-129
CommentNode comment = nodeConnection.Source as CommentNode;
if (comment != null)
{
isSourceComment = true;
}
// END SPRINT 2: TLAB-129
}
}
}
}
public void DrawEdge(ExperimentNodeConnection edge, bool editable)
{
ExperimentNode source = edge.Source;
ExperimentNode target = edge.Target;
BasicNodeControl sourceControl, targetControl;
if(m_nodeControlFactory.TryGetNodeControl(source, out sourceControl) &&
m_nodeControlFactory.TryGetNodeControl(target, out targetControl))
{
NodeConnectionControl connection = m_nodeConnectionControlFactory.CreateNewNodeConnectionControl(sourceControl, targetControl);
connection.ConnectStart(sourceControl.ConnectorAt(source.Data.X, source.Data.Y));
connection.ConnectEnd(targetControl.ConnectorAt(target.Data.X, target.Data.Y));
connection.UpdateConnection();
// HERZUM SPRINT 2.4 TLAB-157
if (connection.ExperimentNodeConnection != null && connection.ExperimentNodeConnection.Source != null && connection.ExperimentNodeConnection.Target != null)
// END HERZUM SPRINT 2.4 TLAB-157
// HERZUM SPRINT 2.3: TLAB-160
if ((connection.ExperimentNodeConnection.Source is ExperimentDecisionNode && connection.ExperimentNodeConnection.Target is ScopeNode)||
(connection.ExperimentNodeConnection.Target is ExitDecisionNode))
connection.IsEditable = false;
else
// END HERZUM SPRINT 2.3: TLAB-160
connection.IsEditable = editable;
m_experimentCanvasWidget.ExperimentCanvas.View.Drawing.Add(connection);
m_experimentCanvasWidget.ExperimentCanvas.View.ClearSelection();
}
}
// HERZUM SPRINT 3.0: TLAB-176
private bool IncludeChallenge(CompositeComponentGraph experiment)
{
if (experiment == null)
{
return(false);
}
foreach (ExperimentNode node in experiment.Vertices)
{
ChallengeMetadata ch_meta = node.Data.Metadata as ChallengeMetadata;
if (ch_meta != null)
{
// HERZUM SPRINT 3.0: TLAB-176
ExperimentNodeConnection firstInEdge = experiment.InEdge(node, 0);
ExperimentNodeConnection firstOutEdge = experiment.OutEdge(node, 0);
if (firstInEdge != null && firstInEdge.Source != null && firstOutEdge != null && firstOutEdge.Target != null)
{
experiment.AddEdge(new ExperimentNodeConnection(Guid.NewGuid().ToString(), firstInEdge.Source, firstOutEdge.Target));
}
// END HERZUM SPRINT 3.0: TLAB-176
experiment.RemoveVertex(node);
return(true);
}
CompositeComponentBaseMetadata meta = node.Data.Metadata as CompositeComponentBaseMetadata;
if (meta != null)
{
return(IncludeChallenge(meta.ComponentGraph));
}
}
return(false);
}
public void AddNewConnectionTwice()
{
IExperiment experiment = ExperimentManager.New();
experiment.ExperimentInfo.FilePath = "C:\\somefakelocation\\mockExperiment.teml";
ComponentMetadataDefinition def1 = new ComponentMetadataDefinition(Guid.NewGuid().ToString(), System.IO.Path.Combine(AppContext.BaseTestDirectory, "Test.dll"), "IDontExist");
ExperimentNode node1 = ((IEditableExperiment)experiment).AddComponentFromDefinition(def1, -5, 5);
ComponentMetadataDefinition def2 = new ComponentMetadataDefinition(Guid.NewGuid().ToString(), System.IO.Path.Combine(AppContext.BaseTestDirectory, "Test2.dll"), "IDontExistEither");
ExperimentNode node2 = ((IEditableExperiment)experiment).AddComponentFromDefinition(def2, -5, 5);
Assert.AreEqual(0, experiment.EdgeCount);
ExperimentNodeConnection newEdge = ((IEditableExperiment)experiment).AddConnection(node1, node2);
Assert.IsNotNull(newEdge);
Assert.AreEqual(1, experiment.EdgeCount);
//add the same connection once again
ExperimentNodeConnection newEdge2 = ((IEditableExperiment)experiment).AddConnection(node1, node2);
Assert.IsNotNull(newEdge2);
Assert.AreEqual(newEdge, newEdge2);
// the amount of edges should still be the same
Assert.AreEqual(1, experiment.EdgeCount);
}
public void RemoveConnection()
{
IExperiment experiment = ExperimentManager.New();
experiment.ExperimentInfo.FilePath = "C:\\somefakelocation\\mockExperiment.teml";
ComponentMetadataDefinition def1 = new ComponentMetadataDefinition(Guid.NewGuid().ToString(), System.IO.Path.Combine(AppContext.BaseTestDirectory, "Test.dll"), "IDontExist");
ExperimentNode node1 = ((IEditableExperiment)experiment).AddComponentFromDefinition(def1, -5, 5);
ComponentMetadataDefinition def2 = new ComponentMetadataDefinition(Guid.NewGuid().ToString(), System.IO.Path.Combine(AppContext.BaseTestDirectory, "Test2.dll"), "IDontExistEither");
ExperimentNode node2 = ((IEditableExperiment)experiment).AddComponentFromDefinition(def2, -5, 5);
Assert.AreEqual(0, experiment.EdgeCount);
ExperimentNodeConnection newEdge = ((IEditableExperiment)experiment).AddConnection(node1, node2);
Assert.IsNotNull(newEdge);
Assert.AreEqual(1, experiment.EdgeCount);
experiment.ResetModifiedFlag();
Assert.AreEqual(4, experiment.VertexCount);
((IEditableExperiment)experiment).RemoveConnection(newEdge);
// Verify that the edge was existed and the number of vertices was unaffected.
Assert.AreEqual(0, experiment.EdgeCount);
Assert.AreEqual(4, experiment.VertexCount);
Assert.IsTrue(experiment.IsModified);
}
private void OnConnectionCompleted(ExperimentNodeConnection nodeConnection)
{
if (ConnectionCompleted != null)
{
ConnectionCompleted(this, new ConnectionCompletedEventArgs(nodeConnection));
}
}
/// <summary>
/// Creates the route point on edge.
/// </summary>
/// <param name="e">The <see cref="System.Windows.Input.MouseButtonEventArgs"/> instance containing the event data.</param>
/// <param name="hitEdge">The hit edge.</param>
private void CreateRoutePointOnEdge(MouseButtonEventArgs e, GraphSharp.Controls.EdgeControl hitEdge)
{
ExperimentNodeConnection connection = (ExperimentNodeConnection)hitEdge.Edge;
Point canvasPoint = e.GetPosition(GraphLayout);
RoutePoint finalPoint = new RoutePoint(canvasPoint.X, canvasPoint.Y);
connection.RoutePoints.Add(finalPoint);
}
public void AddNewConnectionCannotTargetStartNode()
{
IExperiment experiment = ExperimentManager.New();
experiment.ExperimentInfo.FilePath = "C:\\somefakelocation\\mockExperiment.teml";
ComponentMetadataDefinition def2 = new ComponentMetadataDefinition(Guid.NewGuid().ToString(), System.IO.Path.Combine(AppContext.BaseTestDirectory, "Test.dll"), "IDontExist");
ExperimentNode node2 = ((IEditableExperiment)experiment).AddComponentFromDefinition(def2, -5, 5);
ExperimentNodeConnection newEdge = ((IEditableExperiment)experiment).AddConnection(node2, experiment.StartNode);
}
/// <summary>
/// When edge is removed in model experiment,
/// the edge control must be also removed from the view to keep view and model synced.
/// </summary>
/// <param name='edge'>
/// Edge.
/// </param>
private void OnEdgeRemoved(ExperimentNodeConnection nodeConnection)
{
NodeConnectionControl connectionControl;
if (m_applicationContext.NodeConnectionControlFactory.TryGetConnectionControl(nodeConnection, out connectionControl))
{
m_experimentCanvasWidget.ExperimentCanvas.View.RemoveFromSelection(connectionControl);
m_experimentCanvasWidget.ExperimentCanvas.View.Remove(connectionControl);
m_applicationContext.NodeConnectionControlFactory.RemoveFromLookup(nodeConnection);
}
}
public void AddNewConnectionNullNode2()
{
IExperiment experiment = ExperimentManager.New();
experiment.ExperimentInfo.FilePath = "C:\\somefakelocation\\mockExperiment.teml";
ComponentMetadataDefinition def1 = new ComponentMetadataDefinition(Guid.NewGuid().ToString(), System.IO.Path.Combine(AppContext.BaseTestDirectory, "Test.dll"), "IDontExist");
ExperimentNode node2 = ((IEditableExperiment)experiment).AddComponentFromDefinition(def1, -5, 5);
Assert.AreEqual(0, experiment.EdgeCount);
ExperimentNodeConnection newEdge = ((IEditableExperiment)experiment).AddConnection(null, node2);
Assert.IsNotNull(newEdge);
Assert.AreEqual(1, experiment.EdgeCount);
}
/// <summary>
/// Determines whether the edge can be redirected
/// </summary>
/// <param name="edge">The edge.</param>
/// <returns>
/// <c>true</c> if this instance [can redirect link] the specified current edge; otherwise, <c>false</c>.
/// </returns>
private bool CanRedirectLink(GraphSharp.Controls.EdgeControl edge)
{
bool canRedirect = false;
if (edge != null)
{
ExperimentNodeConnection connection = edge.Edge as ExperimentNodeConnection;
if (connection != null && connection.IsFixed == false)
{
canRedirect = true;
}
}
return(canRedirect);
}
public void DrawEdge(ExperimentNodeConnection edge, bool editable)
{
ExperimentNode source = edge.Source;
ExperimentNode target = edge.Target;
BasicNodeControl sourceControl, targetControl;
if(m_nodeControlFactory.TryGetNodeControl(source, out sourceControl) &&
m_nodeControlFactory.TryGetNodeControl(target, out targetControl))
{
NodeConnectionControl connection = m_nodeConnectionControlFactory.CreateNewNodeConnectionControl(sourceControl, targetControl);
connection.ConnectStart(sourceControl.ConnectorAt(source.Data.X, source.Data.Y));
connection.ConnectEnd(targetControl.ConnectorAt(target.Data.X, target.Data.Y));
connection.UpdateConnection();
connection.IsEditable = editable;
m_experimentCanvasWidget.ExperimentCanvas.View.Drawing.Add(connection);
m_experimentCanvasWidget.ExperimentCanvas.View.ClearSelection();
}
}
private void DrawEdge(ExperimentNodeConnection edge)
{
ExperimentNode source = edge.Source;
ExperimentNode target = edge.Target;
BasicNodeControl sourceControl, targetControl;
if (m_applicationContext.NodeControlFactory.TryGetNodeControl(source, out sourceControl) &&
m_applicationContext.NodeControlFactory.TryGetNodeControl(target, out targetControl))
{
NodeConnectionControl connection = m_applicationContext.NodeConnectionControlFactory.CreateNewNodeConnectionControl(sourceControl, targetControl);
connection.ConnectStart(sourceControl.ConnectorAt(source.Data.X, source.Data.Y));
connection.ConnectEnd(targetControl.ConnectorAt(target.Data.X, target.Data.Y));
connection.UpdateConnection();
m_experimentCanvasWidget.ExperimentCanvas.View.Drawing.Add(connection);
m_experimentCanvasWidget.ExperimentCanvas.View.ClearSelection();
m_experimentCanvasWidget.ExperimentCanvas.View.AddToSelection(connection);
}
}
/// <summary>
/// Connects the end.
/// When connecting the end, it also updates information in the experiment model data.
/// </summary>
/// <param name='end'>
/// End.
/// </param>
public override void ConnectEnd(MonoHotDraw.Connectors.IConnector end)
{
base.ConnectEnd(end);
if (end != null)
{
IComponentControl startComponentControl = StartConnector.Owner as IComponentControl;
IComponentControl endComponentControl = end.Owner as IComponentControl;
if (endComponentControl != null && startComponentControl != null)
{
//get access to owner experiment
IEditableExperiment ownerExperiment = endComponentControl.ExperimentNode.Owner as IEditableExperiment;
if (ownerExperiment != null)
{
ExperimentNodeConnection nodeConnection = ownerExperiment.AddConnection(startComponentControl.ExperimentNode, endComponentControl.ExperimentNode);
OnConnectionCompleted(nodeConnection);
m_experimentNodeConnection = nodeConnection;
}
}
}
}
public void AddNewConnection()
{
IExperiment experiment = ExperimentManager.New();
experiment.ExperimentInfo.FilePath = "C:\\somefakelocation\\mockExperiment.teml";
ComponentMetadataDefinition def1 = new ComponentMetadataDefinition(Guid.NewGuid().ToString(), System.IO.Path.Combine(AppContext.BaseTestDirectory, "Test.dll"), "IDontExist");
ExperimentNode node1 = ((IEditableExperiment)experiment).AddComponentFromDefinition(def1, -5, 5);
ComponentMetadataDefinition def2 = new ComponentMetadataDefinition(Guid.NewGuid().ToString(), System.IO.Path.Combine(AppContext.BaseTestDirectory, "Test2.dll"), "IDontExistEither");
ExperimentNode node2 = ((IEditableExperiment)experiment).AddComponentFromDefinition(def2, -5, 5);
// We know already that experiments are modified after adding components, but we
// want to make sure that they're modified after adding a connection too, so lets clear the modification flag first.
experiment.ResetModifiedFlag();
Assert.IsFalse(experiment.IsModified);
Assert.AreEqual(0, experiment.EdgeCount);
ExperimentNodeConnection newEdge = ((IEditableExperiment)experiment).AddConnection(node1, node2);
Assert.IsNotNull(newEdge);
Assert.AreEqual(1, experiment.EdgeCount);
Assert.IsTrue(experiment.IsModified);
}
public void DrawEdge(ExperimentNodeConnection edge, bool editable)
{
ExperimentNode source = edge.Source;
ExperimentNode target = edge.Target;
BasicNodeControl sourceControl, targetControl;
if (m_nodeControlFactory.TryGetNodeControl(source, out sourceControl) &&
m_nodeControlFactory.TryGetNodeControl(target, out targetControl))
{
NodeConnectionControl connection = m_nodeConnectionControlFactory.CreateNewNodeConnectionControl(sourceControl, targetControl);
connection.ConnectStart(sourceControl.ConnectorAt(source.Data.X, source.Data.Y));
connection.ConnectEnd(targetControl.ConnectorAt(target.Data.X, target.Data.Y));
connection.UpdateConnection();
// HERZUM SPRINT 2.4 TLAB-157
if (connection.ExperimentNodeConnection != null && connection.ExperimentNodeConnection.Source != null && connection.ExperimentNodeConnection.Target != null)
{
// END HERZUM SPRINT 2.4 TLAB-157
// HERZUM SPRINT 2.3: TLAB-160
if ((connection.ExperimentNodeConnection.Source is ExperimentDecisionNode && connection.ExperimentNodeConnection.Target is ScopeNode) ||
(connection.ExperimentNodeConnection.Target is ExitDecisionNode))
{
connection.IsEditable = false;
}
else
{
// END HERZUM SPRINT 2.3: TLAB-160
connection.IsEditable = editable;
}
}
m_experimentCanvasWidget.ExperimentCanvas.View.Drawing.Add(connection);
m_experimentCanvasWidget.ExperimentCanvas.View.ClearSelection();
}
}
/// <summary>
/// Executes drop
/// </summary>
/// <param name="param">The param.</param>
private void DropFunc(object param)
{
if (IsExperimentRunning == false)
{
TraceLab.UI.WPF.EventArgs.GraphDragEventArgs args = param as TraceLab.UI.WPF.EventArgs.GraphDragEventArgs;
TraceLab.UI.WPF.EventArgs.DropLinkEventArgs linkArgs = param as TraceLab.UI.WPF.EventArgs.DropLinkEventArgs;
if (args != null)
{
MetadataDefinition metadataDefinition = args.DragArguments.Data.GetData("ComponentDefinition") as MetadataDefinition;
if (metadataDefinition != null)
{
System.Windows.Point pos = args.Position;
AddComponentFromDefinition(metadataDefinition, pos.X, pos.Y);
}
}
else if (linkArgs != null)
{
ExperimentNodeConnection edge = (ExperimentNodeConnection)linkArgs.ExistingEdge;
// If we're NOT removing an edge, OR the new edge will be different than the old edge.
if (linkArgs.ExistingEdge == null || (edge.Source == linkArgs.Source && edge.Target != linkArgs.Target))
{
if (linkArgs.ExistingEdge != null)
{
RemoveConnection(edge);
}
if (linkArgs.Source != null && linkArgs.Target != null)
{
AddConnection((ExperimentNode)linkArgs.Source, (ExperimentNode)linkArgs.Target);
}
}
}
}
}
public ConnectionCompletedEventArgs(ExperimentNodeConnection nodeConnection)
{
ExperimentNodeConnection = nodeConnection;
}
/// <summary>
/// Removes the given connection from the m_experiment.
/// </summary>
/// <param name="edge">The edge to remove</param>
/// <exception cref="System.InvalidOperationException">Thrown if the ViewModel is in a bad state that it cannot recover from</exception>
public void RemoveConnection(ExperimentNodeConnection edge)
{
m_experiment.RemoveConnection(edge);
}
public bool RemoveFromLookup(ExperimentNodeConnection nodeConnection)
{
return(m_mapEdgesToControls.Remove(nodeConnection));
}
public bool TryGetConnectionControl(ExperimentNodeConnection nodeConnection, out NodeConnectionControl connectionControl)
{
return(m_mapEdgesToControls.TryGetValue(nodeConnection, out connectionControl));
}
/// <summary>
/// Called when edge is removed from experiment.
/// When edge is removed the experiment should be set to be modified.
/// </summary>
/// <param name="args">The args.</param>
protected override void OnEdgeRemoved(ExperimentNodeConnection args)
{
base.OnEdgeRemoved(args);
m_isModified = true;
IsModified = true;
args.PropertyChanged -= ExperimentNodeConnection_PropertyChanged;
}
/// <summary>
/// Constructs experiment node connection from given xml xpath navigator to the edge.
/// </summary>
/// <param name="reader">The reader with edge root.</param>
/// <returns>experiment node connection</returns>
public ExperimentNodeConnection EdgeFactory(XPathNavigator reader)
{
string id = reader.GetAttribute("id", String.Empty);
string source = reader.GetAttribute("source", String.Empty);
string target = reader.GetAttribute("target", String.Empty);
//try read is fixed attribute
string isFixedAttrib = reader.GetAttribute("isFixed", String.Empty);
bool isFixed;
if (!Boolean.TryParse(isFixedAttrib, out isFixed)) isFixed = false;
//try read is visible attribute
string isVisibleAttrib = reader.GetAttribute("isVisible", String.Empty);
bool isVisible;
if (!Boolean.TryParse(isVisibleAttrib, out isVisible)) isVisible = true;
//validate
if (m_vertices.ContainsKey(source) == false || m_vertices.ContainsKey(target) == false)
{
throw new TraceLab.Core.Exceptions.ExperimentLoadException("The experiment is corrupted and could not be loaded. Experiment xml contains edge that refers to non-existing nodes.");
}
ExperimentNode sourceVert = m_vertices[source];
ExperimentNode targetVert = m_vertices[target];
ExperimentNodeConnection edge = new ExperimentNodeConnection(id, sourceVert, targetVert, isFixed, isVisible);
edge.IsModified = false;
m_edges[id] = edge;
//read in route points from xml
edge.RoutePoints.ReadXml(reader.ReadSubtree());
//perform fixes for scopes
ScopeNodeHelper.TryFixScopeDecisionEntryAndExitNodes(sourceVert, targetVert);
return edge;
}
/// <summary>
/// Removes the given connection from the m_experiment.
/// </summary>
/// <param name="edge">The edge to remove</param>
/// <exception cref="System.InvalidOperationException">Thrown if the ViewModel is in a bad state that it cannot recover from</exception>
public void RemoveConnection(ExperimentNodeConnection edge)
{
m_experiment.RemoveConnection(edge);
}
/// <summary>
/// Called when edge is added to experiment.
/// When edge is added the experiment should be set to be modified.
/// It also attaches listener to edge changes. So it can also set modify flag when edge changes.
/// </summary>
/// <param name="args">The args.</param>
protected override void OnEdgeAdded(ExperimentNodeConnection args)
{
base.OnEdgeAdded(args);
m_isModified = true;
IsModified = true;
//listen to modification of the edge
args.PropertyChanged += ExperimentNodeConnection_PropertyChanged;
}
public bool RemoveFromLookup(ExperimentNodeConnection nodeConnection)
{
return m_mapEdgesToControls.Remove(nodeConnection);
}
/// <summary>
/// When edge is removed in model experiment,
/// the edge control must be also removed from the view to keep view and model synced.
/// </summary>
/// <param name='edge'>
/// Edge.
/// </param>
private void OnEdgeRemoved(ExperimentNodeConnection nodeConnection)
{
NodeConnectionControl connectionControl;
if(m_applicationContext.NodeConnectionControlFactory.TryGetConnectionControl(nodeConnection, out connectionControl))
{
m_experimentCanvasWidget.ExperimentCanvas.View.RemoveFromSelection(connectionControl);
m_experimentCanvasWidget.ExperimentCanvas.View.Remove(connectionControl);
m_applicationContext.NodeConnectionControlFactory.RemoveFromLookup(nodeConnection);
}
}
public bool TryGetConnectionControl(ExperimentNodeConnection nodeConnection, out NodeConnectionControl connectionControl)
{
return m_mapEdgesToControls.TryGetValue(nodeConnection, out connectionControl);
}
public bool TryGetEdge(ExperimentNode source, ExperimentNode target, out ExperimentNodeConnection edge)
{
return(m_experiment.TryGetEdge(source, target, out edge));
}
public bool ContainsEdge(ExperimentNodeConnection edge)
{
return(m_experiment.ContainsEdge(edge));
}
/// <summary>
/// Constructs the graph from selected nodes of the given experiment graph.
/// </summary>
/// <param name="graph">The graph.</param>
/// <returns></returns>
public static CompositeComponentGraph ConstructGraphFromSelectedNodes(BaseExperiment originalExperiment)
{
var compositeComponentGraph = new CompositeComponentGraph();
// Clone experiment info.
compositeComponentGraph.ExperimentInfo = new ExperimentInfo();
AssureCompleteDecisionSelection(originalExperiment);
//keep lookup from original node to its clone for later edge reproduction
Dictionary<ExperimentNode, ExperimentNode> clonedNodeLookup = new Dictionary<ExperimentNode, ExperimentNode>();
// Clone vertices that are selected and add them to the composite component graph
foreach (ExperimentNode node in originalExperiment.Vertices)
{
if (node.IsSelected)
{
var clonedNode = node.Clone();
clonedNodeLookup[node] = clonedNode;
compositeComponentGraph.SetLogLevelSettings(clonedNode, compositeComponentGraph.Settings);
compositeComponentGraph.AddVertex(clonedNode);
if (clonedNode.ID == "Start" && compositeComponentGraph.StartNode == null)
{
compositeComponentGraph.StartNode = (ExperimentStartNode)clonedNode;
}
else if (clonedNode.ID == "End" && compositeComponentGraph.EndNode == null)
{
compositeComponentGraph.EndNode = (ExperimentEndNode)clonedNode;
}
}
}
// Clone edges
foreach (ExperimentNodeConnection connection in originalExperiment.Edges)
{
ExperimentNode cloneSourceNode, cloneTargetNode;
//add edges only if both source and target nodes has been found in clones lookup
bool foundSourceNode = clonedNodeLookup.TryGetValue(connection.Source, out cloneSourceNode);
bool foundTargetNode = clonedNodeLookup.TryGetValue(connection.Target, out cloneTargetNode);
if (foundSourceNode && foundTargetNode)
{
ExperimentNodeConnection clonedConnection = new ExperimentNodeConnection(connection.ID, cloneSourceNode, cloneTargetNode, connection.IsFixed, connection.IsVisible);
//copy also all route points
clonedConnection.RoutePoints.CopyPointsFrom(connection.RoutePoints);
compositeComponentGraph.AddEdge(clonedConnection);
//perform fixes for scopes
ScopeNodeHelper.TryFixScopeDecisionEntryAndExitNodes(cloneSourceNode, cloneTargetNode);
}
}
ConnectNodesToStartAndEndNode(compositeComponentGraph);
//move graph closer to the origin point
TraceLab.Core.Utilities.ExperimentHelper.MoveGraphCloserToOriginPoint(compositeComponentGraph, 200, 200);
if (originalExperiment.References != null)
{
if (!TraceLabSDK.RuntimeInfo.IsRunInMono)
{
compositeComponentGraph.References = new ObservableCollection<TraceLabSDK.PackageSystem.IPackageReference>(originalExperiment.References);
}
else
{
// Mono currently has not implemented constructor of ObservableCollection(IEnumerable<T> collection)
// thus we have to add references manually
compositeComponentGraph.References = new ObservableCollection<TraceLabSDK.PackageSystem.IPackageReference>();
foreach (TraceLabSDK.PackageSystem.IPackageReference reference in originalExperiment.References)
{
compositeComponentGraph.References.Add(reference);
}
}
}
compositeComponentGraph.OwnerNode = null;
return compositeComponentGraph;
}
private void OnConnectionCompleted(ExperimentNodeConnection nodeConnection)
{
if(ConnectionCompleted != null)
{
ConnectionCompleted(this, new ConnectionCompletedEventArgs(nodeConnection));
}
}
public ConnectionCompletedEventArgs(ExperimentNodeConnection nodeConnection)
{
ExperimentNodeConnection = nodeConnection;
}
public bool TryGetEdge(ExperimentNode source, ExperimentNode target, out ExperimentNodeConnection edge)
{
return m_experiment.TryGetEdge(source, target, out edge);
}
/// <summary>
/// Writes the edge attributes.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="flow">The flow.</param>
public void WriteEdgeAttributes(XmlWriter writer, ExperimentNodeConnection flow)
{
WriteXmlAttributesAndElements(writer, flow);
}
public bool ContainsEdge(ExperimentNodeConnection edge)
{
return m_experiment.ContainsEdge(edge);
}
