internal EdgeController(GraphController graphController)
{
this.graphController = graphController;
edgeCollection = new Dictionary<uint, VisualEdge>();
this.selectedSlots = new List<uint>();
connectingEdge = new VisualEdge(this, EdgeType.ExplicitConnection);
}
public bool CheckEdgeType(uint compId)
{
if (compId == 0 || compId == uint.MaxValue)
{
return(false);
}
VisualEdge edge = GetVisualEdge(compId);
return(edge.EdgeType == EdgeType.ExplicitConnection);
}
internal static IVisualEdge Create(EdgeController edgeController, IStorage storage)
{
if (edgeController == null || storage == null)
{
throw new ArgumentNullException("edgeController, storage");
}
IVisualEdge edge = new VisualEdge(edgeController);
edge.Deserialize(storage);
return(edge);
}
public void TestDeserializeNullException()
{
IStorage storage = null;
GraphController graphController = new GraphController(null);
EdgeController edgeController = new EdgeController(graphController);
IVisualEdge edge = new VisualEdge(edgeController, 0x30000001, 0x30000002, false);
Assert.Throws<ArgumentNullException>(() =>
{
edge.Deserialize(storage);
});
}
public void TestCreate02()
{
IStorage storage = new BinaryStorage();
GraphController graphController = new GraphController(null);
EdgeController edgeController = new EdgeController(graphController);
IVisualEdge edge00 = new VisualEdge(edgeController, 0x30000001, 0x30000002, false);
edge00.Serialize(storage);
storage.Seek(0, SeekOrigin.Begin);
IVisualEdge edge01 = VisualEdge.Create(edgeController, storage);
Assert.AreEqual(edge00.EdgeId, edge01.EdgeId);
Assert.AreEqual(edge00.StartSlotId, edge01.StartSlotId);
Assert.AreEqual(edge00.EndSlotId, edge01.EndSlotId);
}
public void TestRecordEdgeCreationForUndo00()
{
GraphController graphController = new GraphController(null);
UndoRedoRecorder urr = new UndoRedoRecorder(graphController);
EdgeController edgeController = new EdgeController(graphController);
List<IVisualEdge> edgeList = new List<IVisualEdge>();
VisualEdge edge = new VisualEdge(edgeController, EdgeType.ExplicitConnection);
edgeList.Add(edge);
Assert.Throws<InvalidOperationException>(() =>
{
urr.RecordEdgeCreationForUndo(edgeList);
});
}
internal IVisualEdge CreateEdgeFromStorage(IStorage storage)
{
if (!this.IsInUndoRedoCommand)
{
throw new InvalidOperationException("Can only be access for undo/redo");
}
if (null == edgeController)
{
throw new InvalidOperationException("'edgeController' was not created");
}
if (null == storage)
{
throw new ArgumentNullException("storage");
}
return(VisualEdge.Create(this.edgeController, storage));
}
internal void ClearPreviewSelection(uint componentId)
{
selectedEdge = null;
edgeCollection.TryGetValue(componentId, out selectedEdge);
if (selectedEdge != null)
{
selectedEdge.PreviewSelected = selectedEdge.Selected;
selectedEdge.Compose();
}
}
//just remove the edge but no operation on slots
// undo/redo helpers
private void DeleteVisualEdge(VisualEdge edgToDelete)
{
IGraphVisualHost visualHost = graphController.GetVisualHost();
if (null != visualHost)
visualHost.RemoveDrawingVisual(edgToDelete.EdgeId);
edgeCollection.Remove(edgToDelete.EdgeId);
}
private void DrawSingleConnectingEdgeTo(uint startSlotId, Point endPoint, DrawingContext context)
{
Slot startSlot = graphController.GetSlot(startSlotId) as Slot;
Point startPoint = startSlot.GetPosition();
VisualEdge connectingEdge = new VisualEdge(this, EdgeType.ExplicitConnection);
connectingEdge.ComposeConnectingEdge(context, startPoint, endPoint, (startSlot.SlotType != SlotType.Output));
}
internal bool SelectComponent(uint componentId, ModifierKeys modifiers)
{
selectedEdge = null;
edgeCollection.TryGetValue(componentId, out selectedEdge);
if (selectedEdge != null)
{
if (modifiers.HasFlag(ModifierKeys.Control))
selectedEdge.Selected = !selectedEdge.Selected;
else
selectedEdge.Selected = true;
selectedEdge.Compose();
}
return true;
}
internal void ResetParameters()
{
currentlySelectedNodeId = uint.MaxValue;
currentlySelectedSlotId = uint.MaxValue;
currentlySelectedSlotType = SlotType.None;
connectNodeId = uint.MaxValue;
connectSlotId = uint.MaxValue;
connectSlotType = SlotType.None;
reconnectingEdges = new List<uint>();
reconnectingSlots = new List<uint>();
lastConnectedSlotId = uint.MaxValue;
reconnectEdgeId = uint.MaxValue;
connectingEdge = null;
}
internal void AddEdge(VisualEdge edge)
{
edgeCollection.Add(edge.EdgeId, edge);
}
private void DeleteEdge(VisualEdge edgeToDelete)
{
//Assignment Swapping
if (edgeToDelete.EdgeType == EdgeType.ExplicitConnection)
{
VisualNode outputNode = graphController.GetVisualNode(graphController.GetSlot(edgeToDelete.StartSlotId).Owners.Last());
outputNode.HandleRemoveConnection(edgeToDelete.StartSlotId);
VisualNode intputNode = graphController.GetVisualNode(graphController.GetSlot(edgeToDelete.EndSlotId).Owners.Last());
intputNode.HandleRemoveConnection(edgeToDelete.EndSlotId);
}
UndoRedoRecorder urr = graphController.GetUndoRedoRecorder();
List<IVisualEdge> edgesToDelete = new List<IVisualEdge>();
edgesToDelete.Add(edgeToDelete);
urr.RecordEdgeDeletionForUndo(edgesToDelete);
IGraphVisualHost visualHost = graphController.GetVisualHost();
if (null != visualHost)
visualHost.RemoveDrawingVisual(edgeToDelete.EdgeId);
Slot.Disconnect((Slot)graphController.GetSlot(edgeToDelete.StartSlotId), (Slot)graphController.GetSlot(edgeToDelete.EndSlotId));
edgeCollection.Remove(edgeToDelete.EdgeId);
}
private bool FindEdgeToBeReplaced(uint startSlotId, out VisualEdge edgeToBeReplaced)
{
bool findEdgeToBeReplaced;
edgeToBeReplaced = null;
if (connectSlotType == SlotType.Input)
{
this.inputSlotId = startSlotId;
this.outputSlotId = connectSlotId;
}
else
{
this.inputSlotId = connectSlotId;
this.inputSlotId = startSlotId;
}
findEdgeToBeReplaced = FindEdgeToBeReplaced(out edgeToBeReplaced);
return findEdgeToBeReplaced;
}
private VisualEdge RebuildImplicitEdge(Slot outputSlot, Slot inputSlot)
{
this.outputSlotId = outputSlot.SlotId;
this.inputSlotId = inputSlot.SlotId;
var entry = edgeCollection.FirstOrDefault(x => IsAdded(x.Value));
if ((edgeCollection.Count() == 0) || (entry.Value == null))
{
IdGenerator idGenerator = ((GraphController)graphController).GetIdGenerator();
VisualEdge visualEdge = new VisualEdge(this, outputSlot.SlotId, inputSlot.SlotId, true);
edgeCollection.Add(visualEdge.EdgeId, visualEdge);
visualEdge.Dirty = true;
visualEdge.Compose();
return visualEdge;
}
entry.Value.Dirty = true;
entry.Value.Compose();
return entry.Value;
}
private VisualEdge RebuildEdge(uint outputNodeId, uint outputSlotId, int outputSlotIndex, uint inputNodeId, uint inputSlotId, int inputSlotIndex)
{
this.inputSlotId = inputSlotId;
var entry = new KeyValuePair<uint, VisualEdge>();
List<uint> connectingSlots = new List<uint>();
if (graphController.GetSlot(inputSlotId).ConnectingSlots != null)
connectingSlots.AddRange(graphController.GetSlot(inputSlotId).ConnectingSlots);
this.outputSlotId = outputSlotId;
entry = edgeCollection.FirstOrDefault(x => IsAdded(x.Value));
if ((edgeCollection.Count() == 0) || (entry.Value == null))//need to recover edge and drawing
{
IdGenerator idGenerator = ((GraphController)graphController).GetIdGenerator();
VisualEdge visualEdge = new VisualEdge(this, outputSlotId, inputSlotId, false);
edgeCollection.Add(visualEdge.EdgeId, visualEdge);
//addVisual
visualEdge.Dirty = true;
visualEdge.Compose();
return visualEdge;
}
entry.Value.Dirty = true;
entry.Value.Compose();
return entry.Value;
}
private bool IsSelected(VisualEdge visualEdge)
{
return (visualEdge == selectedEdge);
}
private bool IsAdded(VisualEdge visualEdge)
{
return (visualEdge.StartSlotId == outputSlotId) && (visualEdge.EndSlotId == inputSlotId);
}
private bool FindEdgeToBeReplaced(out VisualEdge edgeToBeReplaced)
{
edgeToBeReplaced = null;
List<uint> slotsConnectToInputSlot = new List<uint>();
ISlot inputSlot = graphController.GetSlot(this.inputSlotId);
if (inputSlot != null && inputSlot.ConnectingSlots != null)
slotsConnectToInputSlot.AddRange(inputSlot.ConnectingSlots);
if (slotsConnectToInputSlot.Count() > 0)
{
this.outputSlotId = inputSlot.ConnectingSlots[0];
var pair = edgeCollection.FirstOrDefault(x => IsAdded(x.Value));
edgeToBeReplaced = pair.Value;
}
return (edgeToBeReplaced != null);
}
public void TestDeserilaizeOperationException()
{
IStorage storage = new BinaryStorage();
GraphController graphController = new GraphController(null);
EdgeController edgeController = new EdgeController(graphController);
IVisualEdge edge = new VisualEdge(edgeController, 0x30000001, 0x30000002, false);
storage.WriteUnsignedInteger(FieldCode.EdgeSignature, 12);
storage.Seek(0, SeekOrigin.Begin);
Assert.Throws<InvalidOperationException>(() =>
{
edge.Deserialize(storage);
});
}
internal VisualEdge CreateLinkingEdge(Slot outputSlot, Slot inputSlot)
{
this.outputSlotId = outputSlot.SlotId;
this.inputSlotId = inputSlot.SlotId;
var entry = edgeCollection.FirstOrDefault(x => IsAdded(x.Value));
if ((edgeCollection.Count() != 0) && (entry.Value != null))
return null;
IdGenerator idGenerator = ((GraphController)graphController).GetIdGenerator();
VisualEdge visualEdge = new VisualEdge(this, outputSlot.SlotId, inputSlot.SlotId, false);
Slot.Connect(outputSlot, inputSlot);
edgeCollection.Add(visualEdge.EdgeId, visualEdge);
visualEdge.Dirty = true;
visualEdge.Compose();
//record
UndoRedoRecorder urr = graphController.GetUndoRedoRecorder();
List<IVisualEdge> edgesCreated = new List<IVisualEdge>();
edgesCreated.Add(visualEdge);
urr.RecordEdgeCreationForUndo(edgesCreated);
return visualEdge;
}
internal static IVisualEdge Create(EdgeController edgeController, IStorage storage)
{
if (edgeController == null || storage == null)
throw new ArgumentNullException("edgeController, storage");
IVisualEdge edge = new VisualEdge(edgeController);
edge.Deserialize(storage);
return edge;
}
private VisualEdge AddEdge(uint outputSlotId, uint inputSlotId)
{
UndoRedoRecorder urr = graphController.GetUndoRedoRecorder();
//for edge replace
this.inputSlotId = inputSlotId;
this.outputSlotId = outputSlotId;
if (FindEdgeToBeReplaced(out edgeToBeReplaced))
{
DeleteEdge(edgeToBeReplaced);
}
//add edge
VisualEdge visualEdge = null;
IdGenerator idGenerator = ((GraphController)graphController).GetIdGenerator();
visualEdge = new VisualEdge(this, outputSlotId, inputSlotId, false);
edgeCollection.Add(visualEdge.EdgeId, visualEdge);
//maintain connection
Slot outputSlot = (Slot)graphController.GetSlot(outputSlotId);
Slot inputSlot = (Slot)graphController.GetSlot(inputSlotId);
Slot.Connect(outputSlot, inputSlot);
//addVisual
visualEdge.Dirty = true;
visualEdge.Compose();
//record
List<IVisualEdge> edgesCreated = new List<IVisualEdge>();
edgesCreated.Add(visualEdge);
urr.RecordEdgeCreationForUndo(edgesCreated);
// Assignment Swapping
VisualNode outputNode = graphController.GetVisualNode(graphController.GetSlot(outputSlotId).Owners.Last());
outputNode.HandleNewConnection(outputSlotId);
VisualNode inputNode = graphController.GetVisualNode(graphController.GetSlot(inputSlotId).Owners.Last());
inputNode.HandleNewConnection(inputSlotId);
return visualEdge;
}