/// <summary>
/// Handles a double click event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TimeLineControl_DoubleClick(object sender, EventArgs e)
{
ModelEvent evt = GetEventUnderMouse();
VariableUpdate variableUpdate = evt as VariableUpdate;
if (variableUpdate != null)
{
EditorView.Window form = new EditorView.Window();
TimeLineExpressionableTextChangeHandler handler = new TimeLineExpressionableTextChangeHandler(this,
variableUpdate.Action);
form.setChangeHandler(handler);
GuiUtils.MdiWindow.AddChildWindow(form, DockAreas.Float);
}
Expect expect = evt as Expect;
if (expect != null)
{
EditorView.Window form = new EditorView.Window();
TimeLineExpressionableTextChangeHandler handler = new TimeLineExpressionableTextChangeHandler(this,
expect.Expectation);
form.setChangeHandler(handler);
GuiUtils.MdiWindow.AddChildWindow(form, DockAreas.Float);
}
}
/// <summary>
/// The sub step relative to the mouse position
/// </summary>
/// <returns></returns>
private SubStep SubStepRelatedToMousePosition()
{
SubStep retVal = null;
ModelEvent evt = GetEventUnderMouse();
if (evt != null && evt.Instance != null)
{
retVal = EnclosingFinder <SubStep> .find(evt.Instance as IEnclosed, true);
if (retVal == null)
{
Step step = evt.Instance as Step;
if (step != null && step.SubSteps.Count > 0)
{
retVal = (SubStep)step.SubSteps[step.SubSteps.Count - 1];
}
}
}
if (retVal == null && Steps != null && Steps.Count > 0)
{
Step step = (Step)Steps[Steps.Count - 1];
if (step.SubSteps.Count > 0)
{
retVal = (SubStep)step.SubSteps[step.SubSteps.Count - 1];
}
}
return(retVal);
}
public IActionResult AddUpdateEvent(ModelEvent ME)
{
if (!ModelState.IsValid)
{
TempData["Action"] = Constants.FAILED;
return(View(ME));
}
try
{
if (ME.EventId > 0)
{
ME.DateUpdated = DateTime.Now.Date;
OurdbContext.Event.Update(CopyMEToE(ME));
OurdbContext.SaveChanges();
}
else
{
OurdbContext.Event.Add(CopyMEToE(ME));
OurdbContext.SaveChanges();
}
}
catch (Exception e)
{
TempData["action"] = Constants.FAILED;
}
return(RedirectToAction(nameof(AdministratorController.EventList)));
}
public void ModelEventTest()
{
int p = 123, p2 = 456;
bool wasCalled = false;
ModelEvent msgEvt = new ModelEvent();
msgEvt.handler += () => { wasCalled = true; };
msgEvt.Fire();
Assert.IsTrue(wasCalled);
wasCalled = false;
ModelEvent <int> msgEvtT = new ModelEvent <int>();
msgEvtT.handler += (test) => { Assert.AreEqual(p, test); wasCalled = true; };
msgEvtT.Fire(p);
Assert.IsTrue(wasCalled);
wasCalled = false;
ModelEvent <int, int> msgEvtT2 = new ModelEvent <int, int>();
msgEvtT2.handler += (test, test2) => { Assert.AreEqual(p, test); Assert.AreEqual(p2, test2); wasCalled = true; };
msgEvtT2.Fire(p, p2);
Assert.IsTrue(wasCalled);
}
/// <summary>
/// Добавить стартовое событие
/// </summary>
public static void AddStartEvent(ModelEvent ME)
{
if (EQ.QueueSize == 0)
{
EQ.AddEvent(ME);
}
}
/// <summary>
/// Indicates that an event should be shown
/// </summary>
/// <param name="evt"></param>
/// <returns></returns>
public bool VisibleEvent(ModelEvent evt)
{
bool retVal = true;
// Check event type
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
retVal = retVal && (!(evt is Expect) || Expect);
retVal = retVal && (!(evt is RuleFired) || RuleFired);
// Ignore the following internal events
retVal = retVal && (!(evt is ExpectationStateChange));
retVal = retVal && (!(evt is SubStepActivated));
if (retVal)
{
// Checks the variable update
VariableUpdate variableUpdate = evt as VariableUpdate;
if (variableUpdate != null)
{
if (VariableUpdate)
{
// Do not filter out variables updates for which the rule is not available
// because these updates are related to test steps or external input (using EFS service)
if (variableUpdate.Action.RuleCondition != null)
{
retVal = false;
foreach (Variable variable in Variables)
{
retVal = variableUpdate.Changes.ImpactVariable(variable);
if (retVal)
{
break;
}
}
}
}
else
{
retVal = false;
}
}
else
{
// Check event namespace
if (evt.NameSpace != null)
{
retVal = NameSpaces.Contains(evt.NameSpace);
}
}
}
// Keep messages that match the regular expression
if (!Util.isEmpty(RegExp))
{
Regex regularExpression = new Regex(RegExp);
retVal = retVal || regularExpression.IsMatch(evt.Message);
}
return(retVal);
}
/// <summary>
/// Indicates that an event should be shown
/// </summary>
/// <param name="evt"></param>
/// <returns></returns>
public bool VisibleEvent(ModelEvent evt)
{
bool retVal = true;
// Check event type
retVal = retVal && (!(evt is Expect) || Expect);
retVal = retVal && (!(evt is RuleFired) || RuleFired);
retVal = retVal && (!(evt is VariableUpdate) || VariableUpdate);
// Check event namespace
if (retVal)
{
if (evt.NameSpace != null)
{
retVal = NameSpaces.Contains(evt.NameSpace);
}
}
// Keep messages that match the regular expression
if (!Utils.Utils.isEmpty(RegExp))
{
Regex regularExpression = new Regex(RegExp);
retVal = retVal || regularExpression.IsMatch(evt.Message);
}
// Ignore those internal events
retVal = retVal && (!(evt is ExpectationStateChange));
retVal = retVal && (!(evt is SubStepActivated));
return(retVal);
}
public ModelEvent Clear()
{
var newModel = Create();
// Shall we raise node and relationship removed events ?
return(ModelEvent.Create(newModel));
}
private void OnModelChanged(ModelEvent modelEvent)
{
foreach (var itemChange in modelEvent.ItemEvents)
{
ProcessModelItemEvent(itemChange);
}
}
public IActionResult AddUpdateEvent()
{
ModelEvent E = new ModelEvent();
E.DateCreated = DateTime.Now;
return(View(E));
}
public ModelEvent AddNode(
string name,
ModelNodeStereotype stereotype,
object payload = null,
ModelNodeId?parentNodeId = null)
{
if (payload != null && _payloadToModelNodeMap.ContainsKey(payload))
{
throw new Exception($"The model already contains a node with payload: {payload}");
}
var itemEvents = new List <ModelItemEventBase>();
var newNode = CreateNode(name, stereotype, payload);
var(newGraph, newPayloadToModelNodeMap) = AddNodeCore(newNode, _graph, _payloadToModelNodeMap, itemEvents);
var newPayloadToModelRelationshipMap = _payloadToModelRelationshipMap;
if (parentNodeId.HasValue)
{
var containsRelationship = CreateRelationship(parentNodeId.Value, newNode.Id, ModelRelationshipStereotype.Containment, payload: null);
(newGraph, newPayloadToModelRelationshipMap) = AddRelationshipCore(
containsRelationship,
newGraph,
newPayloadToModelRelationshipMap,
itemEvents);
}
var newModel = CreateInstance(newGraph, newPayloadToModelNodeMap, newPayloadToModelRelationshipMap);
return(ModelEvent.Create(newModel, itemEvents));
}
public ModelEvent AddRelationship(
ModelNodeId sourceId,
ModelNodeId targetId,
ModelRelationshipStereotype stereotype,
object payload = null)
{
if (payload != null && _payloadToModelRelationshipMap.ContainsKey(payload))
{
throw new Exception($"The model already contains a relationship with payload: {payload}");
}
var relationship = CreateRelationship(sourceId, targetId, stereotype, payload);
if (!IsRelationshipValid(relationship))
{
throw new ArgumentException($"{relationship} is invalid.");
}
var itemEvents = new List <ModelItemEventBase>();
var(newGraph, newPayloadToModelRelationshipMap) = AddRelationshipCore(
relationship,
_graph,
_payloadToModelRelationshipMap,
itemEvents);
var newModel = CreateInstance(newGraph, _payloadToModelNodeMap, newPayloadToModelRelationshipMap);
return(ModelEvent.Create(newModel, itemEvents));
}
static void OnMessage(BaseMessage bm)
{
switch (bm.msg)
{
case LocalMsg.OnOpen:
Console.WriteLine("Connection Open");
ApiTest.SetBackground();
//ApiTest.NextExpression();
//ApiTest.RegisterModelEventListener();
//ApiTest.SetPosition();
//ApiTest.StartMotion(0, "tap_head");
//ApiTest.StartMotion(1, "motions/haru_normal_01.mtn");
//ApiTest.ShowTextBubble();
break;
case LocalMsg.OnError:
case LocalMsg.OnClose:
Environment.Exit(0);
break;
case Msg.OnModelEvent:
ModelEvent evt = bm.GetData <ModelEvent>();
if (evt != null)
{
Console.WriteLine(evt.ToString());
}
ApiTest.UnregisterModelEventListener();
break;
case Msg.ShowTextBubble:
Console.WriteLine(string.Format("msgId: {0}, data: {1}", bm.msgId, bm.IntValue));
break;
}
}
public void HandleAsync(ModelEvent <RootFolder> message)
{
if (message.Action == ModelAction.Deleted)
{
var files = GetFilesWithBasePath(message.Model.Path);
DeleteMany(files, DeleteMediaFileReason.Manual);
}
}
/// <summary>
/// The right position of the button
/// </summary>
/// <param name="modelEvent"></param>
/// <returns></returns>
private int EventLeft(ModelEvent modelEvent)
{
int retVal = 0;
retVal = LEGEND_WIDTH + (3 * MARGIN_OFFSET) / 2 + 1 + (int)Math.Round(modelEvent.Time / Runner.Step) * (EventControl.SIZE.Width + BUTTON_MARGIN_SIZE) - HorizontalScroll.Value;
return(retVal);
}
protected virtual void OnEventHandlerGenerated(ModelEvent modelEvent, string methodName)
{
if (this.EventHandlerGenerated == null)
{
return;
}
this.EventHandlerGenerated((object)this, new EventHandlerGeneratedEventArgs(modelEvent, methodName));
}
public IHttpActionResult Post(ModelEvent modelEvent)
{
new AddEventCommand(modelEvent).Handle();
Hub.Clients.All.raiseEvent(modelEvent);
return(Ok());
}
protected internal override void OnInvoke(ModelInstance root, ModelEvent modelEvent)
{
// Marks the instance as pending delete if an owner property is set to null.
if (Property is ModelReferenceProperty && !Property.IsList)
{
root.IsPendingDelete = root.GetReference((ModelReferenceProperty)Property) == null;
}
}
private void OnModelChanged(ModelEvent modelEvent)
{
DiagramService.UpdateModel(modelEvent.NewModel);
foreach (var itemChange in modelEvent.ItemEvents)
{
ProcessModelItemEvent(itemChange);
}
}
public ModelTimeoutParameter(int id, ModelEvent modelEvent, object param1 = null, object param2 = null)
{
this.id = id;
this.modelEvent = modelEvent;
this.param1 = param1;
this.param2 = param2;
lTimeId = 0;
}
public static void TriggerEvent(ModelEventType modelEventType, int row, int column)
{
ModelEvent thisEvent = null;
if (instance.eventDictionary.TryGetValue(modelEventType, out thisEvent))
{
thisEvent.Invoke(row, column);
}
}
public void Handle(ModelEvent <TModel> message)
{
if (message.Action == ModelAction.Deleted || message.Action == ModelAction.Sync)
{
BroadcastResourceChange(message.Action);
}
BroadcastResourceChange(message.Action, message.Model.Id);
}
public ModelEvent RemoveRelationship(ModelRelationshipId relationshipId)
{
var itemEvents = new List <ModelItemEventBase>();
var newGraph = RemoveRelationshipCore(relationshipId, _graph, itemEvents);
var newModel = CreateInstance(newGraph);
return(ModelEvent.Create(newModel, itemEvents));
}
public ModelEvent RemoveRelationship(ModelRelationshipId relationshipId)
{
var itemEvents = new List <ModelItemEventBase>();
var(newGraph, newPayloadToModelRelationshipMap) = RemoveRelationshipCore(relationshipId, _graph, _payloadToModelRelationshipMap, itemEvents);
var newModel = CreateInstance(newGraph, _payloadToModelNodeMap, newPayloadToModelRelationshipMap);
return(ModelEvent.Create(newModel, itemEvents));
}
public ModelEvent UpdateNode(IModelNode updatedNode)
{
var itemEvents = new List <ModelItemEventBase>();
var(newGraph, newPayloadToModelNodeMap) = UpdateNodeCore(updatedNode, _graph, _payloadToModelNodeMap, itemEvents);
var newModel = CreateInstance(newGraph, newPayloadToModelNodeMap, _payloadToModelRelationshipMap);
return(ModelEvent.Create(newModel, itemEvents));
}
public void Handle(ModelEvent <RootFolder> message)
{
if (message.Action == ModelAction.Created && _watchForChanges)
{
StartWatchingPath(message.Model.Path);
}
else if (message.Action == ModelAction.Deleted)
{
StopWatchingPath(message.Model.Path);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="modelEvent"></param>
public EventControl(TimeLineControl controller, ModelEvent modelEvent)
{
Parent = controller;
ModelEvent = modelEvent;
Size = SIZE;
Font = new System.Drawing.Font(FontFamily.GenericMonospace, 5);
SetColor();
SetText();
Click += new EventHandler(EventControl_Click);
}
/// <summary>
/// Merges a <see cref="ModelValueChangeEvent"/> into the current event.
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
protected override bool OnMerge(ModelEvent e)
{
// Ensure the events are for the same value property
if (((ModelValueChangeEvent)e).Property != Property)
{
return(false);
}
NewValue = ((ModelValueChangeEvent)e).NewValue;
return(true);
}
/// <summary>
/// Handles a double click event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void TimeLineControl_DoubleClick(object sender, EventArgs e)
{
ModelEvent evt = GetEventUnderMouse();
VariableUpdate variableUpdate = evt as VariableUpdate;
if (variableUpdate != null)
{
ExplanationPart explain = variableUpdate.Explanation;
ExplainBox explainTextBox = new ExplainBox();
explainTextBox.SetExplanation(explain);
GuiUtils.MdiWindow.AddChildWindow(explainTextBox);
}
RuleFired rulefired = evt as RuleFired;
if (rulefired != null)
{
ExplanationPart explain = rulefired.Explanation;
ExplainBox explainTextBox = new ExplainBox();
explainTextBox.SetExplanation(explain);
GuiUtils.MdiWindow.AddChildWindow(explainTextBox);
}
Expect expect = evt as Expect;
if (expect != null)
{
Expectation expectation = expect.Expectation;
if (expectation != null)
{
ExplanationPart explanation = expect.Explanation;
if (explanation == null)
{
explanation = expectation.Explain;
}
ExplainBox explainTextBox = new ExplainBox();
explainTextBox.SetExplanation(explanation);
GuiUtils.MdiWindow.AddChildWindow(explainTextBox);
}
}
ModelInterpretationFailure modelInterpretationFailure = evt as ModelInterpretationFailure;
if (modelInterpretationFailure != null)
{
ExplainBox explainTextBox = new ExplainBox();
explainTextBox.SetExplanation(modelInterpretationFailure.Explanation);
GuiUtils.MdiWindow.AddChildWindow(explainTextBox);
}
}
/// <summary>
/// Display the tooltip
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DrawArea_MouseHover(object sender, EventArgs e)
{
ModelEvent modelEvent = GetEventUnderMouse();
if (modelEvent != null)
{
ToolTip.SetToolTip(DrawArea, modelEvent.Message);
}
else
{
ToolTip.SetToolTip(DrawArea, null);
}
}
/// <summary>
/// Merges a <see cref="ModelValueChangeEvent"/> into the current event.
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
protected override bool OnMerge(ModelEvent e)
{
// Ensure the events are for the same reference property
if (((ModelReferenceChangeEvent)e).Property != Property)
return false;
NewValue = ((ModelReferenceChangeEvent)e).NewValue;
NewValueId = ((ModelReferenceChangeEvent)e).NewValueId;
return true;
}
