/// <summary>
/// Creates the message animation.
/// </summary>
/// <param name="edge">The edge.</param>
/// <param name="message">The message.</param>
/// <param name="uimessage">The message control.</param>
/// <param name="step">The step.</param>
/// <returns>The created storyboard for the message animation.</returns>
private static Storyboard CreateMessageAnimation(
NetSimConnection edge,
ConnectionFrameMessage message,
MessageControl uimessage,
NetSimMessageTransmissionStep step)
{
INetSimVisualizableItem receiver;
INetSimVisualizableItem sender;
GetMessageReceiverSender(edge, message, out receiver, out sender);
int middleTop = (edge.EndPointA.Location.Top + edge.EndPointB.Location.Top) / 2;
int middleLeft = (edge.EndPointA.Location.Left + edge.EndPointB.Location.Left) / 2;
if (receiver == null || sender == null)
{
// return empty storyboard
return(new Storyboard());
}
DoubleAnimation animationTop = new DoubleAnimation {
Duration = TimeSpan.FromSeconds(0.5)
};
DoubleAnimation animationLeft = new DoubleAnimation {
Duration = TimeSpan.FromSeconds(0.5)
};
if (step == NetSimMessageTransmissionStep.Sending)
{
animationTop.From = sender.Location.Top;
animationTop.To = middleTop;
animationLeft.From = sender.Location.Left;
animationLeft.To = middleLeft;
}
else
{
animationTop.From = middleTop;
animationTop.To = receiver.Location.Top;
animationLeft.From = middleLeft;
animationLeft.To = receiver.Location.Left;
}
Storyboard board = new Storyboard();
board.Children.Add(animationLeft);
board.Children.Add(animationTop);
Storyboard.SetTarget(animationTop, uimessage);
Storyboard.SetTargetProperty(animationTop, new PropertyPath(Canvas.TopProperty));
Storyboard.SetTarget(animationLeft, uimessage);
Storyboard.SetTargetProperty(animationLeft, new PropertyPath(Canvas.LeftProperty));
return(board);
}
/// <summary>
/// Gets the sender receiver.
/// </summary>
/// <param name="edge">The edge.</param>
/// <param name="message">The message.</param>
/// <param name="receiver">The receiver.</param>
/// <param name="sender">The sender.</param>
private static void GetMessageReceiverSender(
NetSimConnection edge,
ConnectionFrameMessage message,
out INetSimVisualizableItem receiver,
out INetSimVisualizableItem sender)
{
// receiver = (edge.EndPointA.Id.Equals(message.NextReceiver) ? edge.EndPointA : edge.EndPointB) as INetSimVisualizableItem;
receiver =
(edge.EndPointA.Id.Equals(message.Receiver) ? edge.EndPointA : edge.EndPointB) as
INetSimVisualizableItem;
sender = ((receiver == edge.EndPointA) ? edge.EndPointB : edge.EndPointA) as INetSimVisualizableItem;
}
/// <summary>
/// Wraps the message in the connection frame.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="senderEndPoint">The sender end point.</param>
/// <param name="receiverEndPoint">The receiver end point.</param>
/// <returns>The frame wrapped message.</returns>
private ConnectionFrameMessage WrapMessage(
NetSimMessage message,
string senderEndPoint,
string receiverEndPoint)
{
ConnectionFrameMessage frame = new ConnectionFrameMessage
{
InnerMessage = message,
Sender = senderEndPoint,
Receiver = receiverEndPoint,
TransmissionStep = NetSimMessageTransmissionStep.Sending
};
return(frame);
}
/// <summary>
/// Ends the transport messages.
/// </summary>
public void EndTransportMessages()
{
// remove all transmitted message that are done
var doneList =
this.TransmittedMessages.Where(m => m.TransmissionStep == NetSimMessageTransmissionStep.Done).ToList();
doneList.ForEach(m => this.TransmittedMessages.Remove(m));
// mark all already transmitted messages that are in receicing mode as done
this.TransmittedMessages.Where(m => m.TransmissionStep == NetSimMessageTransmissionStep.Receiving)
.ToList()
.ForEach(m => m.TransmissionStep = NetSimMessageTransmissionStep.Done);
// send messages to receiver endpoint
while (this.PendingMessages.Count > 0)
{
ConnectionFrameMessage frame = this.PendingMessages.Dequeue();
if (frame == null)
{
continue;
}
// mark each message as transmission receiving (triggers the receiving animation)
if (frame.TransmissionStep == NetSimMessageTransmissionStep.Sending)
{
frame.TransmissionStep = NetSimMessageTransmissionStep.Receiving;
}
if (this.EndPointA != null && frame.Receiver.Equals(this.EndPointA.Id))
{
this.EndPointA.ReceiveMessage(this.UnWrapMessage(frame));
}
if (this.EndPointB != null && frame.Receiver.Equals(this.EndPointB.Id))
{
this.EndPointB.ReceiveMessage(this.UnWrapMessage(frame));
}
// add received message to transmitted message for visualization
this.TransmittedMessages.Add(frame);
}
this.OnStateUpdated();
}
/// <summary>
/// Unwraps the message from the connection frame.
/// </summary>
/// <param name="frame">The frame.</param>
/// <returns>The unwrapped message.</returns>
private NetSimMessage UnWrapMessage(ConnectionFrameMessage frame)
{
return(frame.InnerMessage);
}
/// <summary>
/// Adds the message.
/// </summary>
/// <param name="edge">The edge.</param>
/// <param name="message">The message.</param>
private void AddMessage(NetSimConnection edge, ConnectionFrameMessage message)
{
INetSimVisualizableItem receiver;
INetSimVisualizableItem sender;
// get message receiver and sender
GetMessageReceiverSender(edge, message, out receiver, out sender);
var uimessage = new MessageControl(message.ShortName)
{
Width = 19,
Height = 19,
Tag = edge,
MessagePath = { Tag = edge }
};
// set message to sender location
int top = sender.Location.Top;
int left = sender.Location.Left;
if (this.IsMessageSendingAnimationDone(message.Id))
{
// calculate middle between A and B
top = (edge.EndPointA.Location.Top + edge.EndPointB.Location.Top) / 2;
left = (edge.EndPointA.Location.Left + edge.EndPointB.Location.Left) / 2;
}
// add meesage to this position
Canvas.SetLeft(uimessage, left);
Canvas.SetTop(uimessage, top);
this.drawCanvas.Children.Add(uimessage);
Storyboard storyBoard = null;
if (message.TransmissionStep == NetSimMessageTransmissionStep.Sending)
{
if (!this.IsMessageSendingAnimationDone(message.Id))
{
storyBoard = CreateMessageAnimation(edge, message, uimessage, NetSimMessageTransmissionStep.Sending);
// messageStates[message.Id] = NetSimMessageTransmissionStep.Sending;
}
}
else
{
if (!this.IsMessageReceivingAnimationDone(message.Id))
{
storyBoard = CreateMessageAnimation(
edge,
message,
uimessage,
NetSimMessageTransmissionStep.Receiving);
// messageStates[message.Id] = NetSimMessageTransmissionStep.Receiving;
}
}
if (storyBoard == null)
{
return;
}
// when the animation has finished - mark animation as done
// note: animation gets created multiple times - but only at last "redraw"
// it has time to finish
storyBoard.Completed += (s, e) => { this.messageStates[message.Id] = message.TransmissionStep; };
uimessage.BeginStoryboard(storyBoard);
// start the animation
storyBoard.Begin();
}
