/// <summary>
/// Sets the value of a specific variable
/// </summary>
/// <param name="variableName"></param>
/// <param name="value"></param>
public void SetVariableValue(string variableName, Value value)
{
EfsAccess.WaitOne();
try
{
if (Runner != null)
{
IVariable variable = EfsSystem.Instance.FindByFullName(variableName) as IVariable;
if (variable != null)
{
Util.DontNotify(() =>
{
Runner.CacheImpact = new CacheImpact();
SyntheticVariableUpdateAction action = new SyntheticVariableUpdateAction(variable,
value.ConvertBack(variable.Type));
VariableUpdate variableUpdate = new VariableUpdate(action, null, null);
Runner.EventTimeLine.AddModelEvent(variableUpdate, true);
Runner.ClearCaches();
});
}
else
{
throw new FaultException <EFSServiceFault> (
new EFSServiceFault("Cannot find variable " + variableName),
new FaultReason(new FaultReasonText("Cannot find variable " + variableName)));
}
}
}
finally
{
EfsAccess.ReleaseMutex();
}
}
/// <summary>
/// Saves the dictionary according to its filename
/// </summary>
public void Save()
{
Util.DontNotify(() =>
{
if (Watcher != null)
{
Watcher.StopWatching();
}
Updater updater = new Updater(true);
updater.visit(this);
VersionedWriter writer = new VersionedWriter(FilePath);
unParse(writer, false);
writer.Close();
updater = new Updater(false);
updater.visit(this);
if (Watcher != null)
{
Watcher.StartWatching();
}
foreach (DeleteFilesHandler file in FilesToDelete)
{
file.DeleteFile();
}
FilesToDelete.Clear();
});
}
/// <summary>
/// Provides the value of an expression
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public Value GetExpressionValue(string expression)
{
Value retVal = null;
EfsAccess.WaitOne();
try
{
Expression expressionTree = new Parser().Expression(EfsSystem.Instance.Dictionaries[0],
expression);
if (expressionTree != null)
{
Util.DontNotify(() =>
{
retVal =
ConvertOut(expressionTree.GetExpressionValue(new InterpretationContext(), null));
});
}
}
catch (Exception)
{
// TODO
}
finally
{
EfsAccess.ReleaseMutex();
}
return(retVal);
}
/// <summary>
/// Creates a default element
/// </summary>
/// <param name="enclosingCollection"></param>
/// <returns></returns>
public static Parameter CreateDefault(ICollection enclosingCollection)
{
Parameter retVal = (Parameter)acceptor.getFactory().createParameter();
Util.DontNotify(() => { retVal.Name = "Parameter" + GetElementNumber(enclosingCollection); });
return(retVal);
}
/// <summary>
/// Sets the default values for the element provided as parameter
/// </summary>
/// <param name="model"></param>
public void SetDefaultValue <T>(T model)
where T : IXmlBBase
{
// We are creating a new element, notification about changes in that element
// are not necessary.
Util.DontNotify(() =>
{
// ReSharper disable once ConvertToLambdaExpression
dispatch(model);
});
}
/// <summary>
/// Step once
/// </summary>
public void StepOnce()
{
Util.DontNotify(() =>
{
CheckRunner();
if (EfsSystem.Runner != null)
{
EfsSystem.Runner.StepOnce();
EfsSystem.Instance.Context.HandleEndOfCycle();
}
});
}
/// <summary>
/// Checks the model for unused element
/// </summary>
public void CheckDeadModel()
{
Util.DontNotify(() =>
{
// Rebuilds everything
EFSSystem.Compiler.Compile_Synchronous(EFSSystem.ShouldRebuild);
EFSSystem.ShouldRebuild = false;
// Check dead model
UsageChecker visitor = new UsageChecker(this);
visitor.visit(this, true);
});
}
/// <summary>
/// Update the information stored in the position handler according to the test case
/// </summary>
protected override void UpdatePositionHandler()
{
Util.DontNotify(() =>
{
PositionHandler.CleanPositions();
if ((TestCase != null) || SubSequence != null)
{
double currentTime = 0.0;
foreach (Step step in Steps)
{
if (step.SubSteps.Count > 0)
{
foreach (SubStep subStep in step.SubSteps)
{
PositionSubStep(currentTime, subStep);
currentTime += 1;
}
}
else
{
StepActivation stepActivated = new StepActivation(step)
{
Time = currentTime
};
PositionHandler.RegisterEvent(stepActivated);
currentTime += 1;
}
}
}
else if (Translation != null)
{
double currentTime = 0.0;
if (Translation.SubSteps.Count > 0)
{
foreach (SubStep subStep in Translation.SubSteps)
{
PositionSubStep(currentTime, subStep);
currentTime += 1;
}
}
}
});
base.UpdatePositionHandler();
}
/// <summary>
/// Checks the rules stored in the dictionary
/// </summary>
public void CheckRules()
{
Util.DontNotify(() =>
{
try
{
// Rebuilds everything
EFSSystem.Compiler.Compile_Synchronous(EFSSystem.ShouldRebuild);
EFSSystem.ShouldRebuild = false;
// Check rules
RuleCheckerVisitor visitor = new RuleCheckerVisitor(this);
visitor.visit(this, true);
}
catch (Exception)
{
}
});
}
/// <summary>
/// Duplicates the model element and avoid duplicated GUID
/// </summary>
/// <returns></returns>
public ModelElement Duplicate()
{
ModelElement retVal = null;
Util.DontNotify(() =>
{
XmlBStringContext ctxt = new XmlBStringContext(ToXMLString());
try
{
retVal = acceptor.accept(ctxt) as ModelElement;
RegererateGuidVisitor visitor = new RegererateGuidVisitor();
visitor.visit(retVal, true);
}
catch (Exception)
{
}
});
return(retVal);
}
/// <summary>
/// Refreshes the model of the tree view
/// </summary>
/// <param name="modifiedElement">The element that has been modified</param>
public void RefreshModel(IModelElement modifiedElement)
{
BaseTreeNode selected = Selected;
Util.DontNotify(() =>
{
try
{
SuspendLayout();
// Ensure the root nodes are correct
List <BaseTreeNode> rootNodes = BuildModel();
if (rootNodes.Count != Nodes.Count)
{
Nodes.Clear();
foreach (BaseTreeNode node in rootNodes)
{
Nodes.Add(node);
}
}
// Refresh the selected node
foreach (BaseTreeNode node in Nodes)
{
if (modifiedElement == null || (node.Model != null && node.Model.IsParent(modifiedElement)))
{
node.BuildOrRefreshSubNodes(modifiedElement);
}
}
if (selected != null)
{
Select(selected.Model);
}
}
finally
{
ResumeLayout(true);
}
});
}
/// <summary>
/// Do not raise errors while execution the action
/// </summary>
/// <param name="silent">Indicates that the action should be silent</param>
/// <param name="action"></param>
public static void DontRaiseError(bool silent, SilentAction action)
{
// Heuristic :
// Do not notify changes in the model when we are not interested
// in the errors raised while performing the action
Util.DontNotify(() =>
{
if (silent)
{
try
{
SilentCount += 1;
if (SilentCount == 1)
{
BeSilent = true;
action();
}
else
{
action();
}
}
finally
{
SilentCount -= 1;
if (SilentCount == 0)
{
BeSilent = false;
}
}
}
else
{
action();
}
});
}
/// <summary>
/// Applies a specific statement on the model
/// </summary>
/// <param name="statementText"></param>
public void ApplyStatement(string statementText)
{
EfsAccess.WaitOne();
try
{
if (Runner != null)
{
const bool silent = true;
using (Parser parser = new Parser())
{
Statement statement = parser.Statement(EfsSystem.Instance.Dictionaries[0],
statementText, silent);
if (statement != null)
{
Util.DontNotify(() =>
{
Runner.CacheImpact = new CacheImpact();
Action action = (Action)acceptor.getFactory().createAction();
action.ExpressionText = statementText;
VariableUpdate variableUpdate = new VariableUpdate(action, null, null);
Runner.EventTimeLine.AddModelEvent(variableUpdate, true);
Runner.ClearCaches();
});
}
}
}
}
catch (Exception)
{
// TODO
}
finally
{
EfsAccess.ReleaseMutex();
}
}
/// <summary>
/// Handles the move event, which, in case of an arrow is selected to be modified,
/// </summary>
/// <param name="sender"></param>
/// <param name="mouseEventArgs"></param>
private void HandleMouseMove(object sender, MouseEventArgs mouseEventArgs)
{
GraphicElement element = ElementForLocation(mouseEventArgs.Location, null);
if (element != null)
{
element.HandleMouseMove(sender, mouseEventArgs);
}
if (_changingArrow != null && _chaningArrowAction != ChangeAction.None)
{
BoxControl <TEnclosing, TBoxModel, TArrowModel> box = BoxForLocation(mouseEventArgs.Location, null);
if (box != null)
{
switch (_chaningArrowAction)
{
case ChangeAction.InitialBox:
if (_changingArrow.TypedModel.Source != box.Model)
{
_changingArrow.SetInitialBox(box.TypedModel);
}
break;
case ChangeAction.TargetBox:
if (_changingArrow.TypedModel.Target != box.Model)
{
if (_changingArrow.TypedModel.Source != null)
{
_changingArrow.SetTargetBox(box.TypedModel);
}
}
break;
}
}
}
if (_movingBox != null)
{
Point mouseMoveLocation = mouseEventArgs.Location;
int deltaX = mouseMoveLocation.X - _moveStartLocation.X;
int deltaY = mouseMoveLocation.Y - _moveStartLocation.Y;
if (Math.Abs(deltaX) > 5 || Math.Abs(deltaY) > 5)
{
IModelElement model = _movingBox.TypedModel;
if (model != null && !_movingBoxHasMoved)
{
Context.SelectionCriteria criteria = GuiUtils.SelectionCriteriaBasedOnMouseEvent(mouseEventArgs);
EfsSystem.Instance.Context.SelectElement(model, this, criteria);
_movingBoxHasMoved = true;
}
Util.DontNotify(() =>
{
int newX = _positionBeforeMove.X + deltaX;
int newY = _positionBeforeMove.Y + deltaY;
SetBoxPosition(_movingBox, newX, newY);
UpdatePositions();
});
}
}
}
/// <summary>
/// Performs a single cycle
/// </summary>
public void Cycle()
{
EfsAccess.WaitOne();
try
{
DateTime now = DateTime.Now;
// Close inactive connections
foreach (ConnectionStatus status in Connections)
{
TimeSpan delta = now - status.LastCycleRequest;
if (delta > MaxDelta && !status.Suspended)
{
status.Active = false;
}
}
// Launches the runner when all active client have selected their next step
while (CheckLaunch())
{
LastStep = NextStep(LastStep);
if (Runner != null)
{
try
{
if (!AllListeners)
{
Util.DontNotify(() =>
{
Runner.ExecuteOnePriority(convertStep2Priority(LastStep));
if (LastStep == Step.CleanUp)
{
EfsSystem.Instance.Context.HandleEndOfCycle();
ClearFunctionCaches();
}
});
}
}
catch (Exception)
{
// Ignore
}
}
while (PendingClients(LastStep))
{
// Let the processes waiting for the end of this step run
StepAccess[LastStep].ReleaseMutex();
EfsAccess.ReleaseMutex();
// Let the other processes wake up
Thread.Sleep(1);
// Wait until all processes for this step have executed their work
StepAccess[LastStep].WaitOne();
EfsAccess.WaitOne();
}
}
}
catch (Exception)
{
}
finally
{
EfsAccess.ReleaseMutex();
}
}
/// <summary>
/// Displays the graph
/// </summary>
/// <returns></returns>
public void Display()
{
Util.DontNotify(() =>
{
GraphVisualiser.Reset();
String name = null;
// Computes the expected end to display
double expectedEndX = 0;
Dictionary <Function, Graph> graphs = new Dictionary <Function, Graph>();
foreach (Function function in Functions)
{
InterpretationContext context = new InterpretationContext(function);
if (function.FormalParameters.Count == 1)
{
Parameter parameter = (Parameter)function.FormalParameters[0];
Graph graph = function.CreateGraph(context, parameter, null);
if (graph != null)
{
expectedEndX = Math.Max(expectedEndX, graph.ExpectedEndX());
graphs.Add(function, graph);
}
}
}
double expectedEndY = 0;
Dictionary <Function, Surface> surfaces = new Dictionary <Function, Surface>();
foreach (Function function in Functions)
{
InterpretationContext context = new InterpretationContext(function);
if (function.FormalParameters.Count == 2)
{
Surface surface = function.CreateSurface(context, null);
if (surface != null)
{
expectedEndX = Math.Max(expectedEndX, surface.ExpectedEndX());
expectedEndY = Math.Max(expectedEndY, surface.ExpectedEndY());
surfaces.Add(function, surface);
}
}
}
try
{
int maxX = Int32.Parse(Tb_MaxX.Text);
expectedEndX = Math.Min(expectedEndX, maxX);
}
catch (Exception)
{
}
// Creates the graphs
foreach (KeyValuePair <Function, Graph> pair in graphs)
{
Function function = pair.Key;
Graph graph = pair.Value;
if (function != null && graph != null)
{
EfsProfileFunction efsProfileFunction = new EfsProfileFunction(graph);
if (function.Name.Contains("Gradient"))
{
GraphVisualiser.AddGraph(new EfsGradientProfileGraph(GraphVisualiser, efsProfileFunction,
function.FullName));
}
else
{
GraphVisualiser.AddGraph(new EfsProfileFunctionGraph(GraphVisualiser, efsProfileFunction,
function.FullName));
}
if (name == null)
{
name = function.Name;
}
}
}
// Creates the surfaces
foreach (KeyValuePair <Function, Surface> pair in surfaces)
{
Function function = pair.Key;
Surface surface = pair.Value;
if (surface != null)
{
EfsSurfaceFunction efsSurfaceFunction = new EfsSurfaceFunction(surface);
GraphVisualiser.AddGraph(new EfsSurfaceFunctionGraph(GraphVisualiser, efsSurfaceFunction,
function.FullName));
if (name == null)
{
name = function.Name;
}
}
}
Train train = new Train(GraphVisualiser);
train.InitializeTrain(TrainPosition.GetDistance(), TrainPosition.GetSpeed(), TrainPosition.GetUnderReadingAmount(), TrainPosition.GetOverReadingAmount());
GraphVisualiser.AddGraph(train);
GraphVisualiser.Annotations.Add(train.TrainLineAnnotation);
GraphVisualiser.Annotations.Add(train.TrainAnnotation);
if (name != null)
{
try
{
double val = double.Parse(Tb_MinX.Text);
GraphVisualiser.SetMinX(val);
}
catch (Exception)
{
}
try
{
double val = double.Parse(Tb_MaxX.Text);
GraphVisualiser.SetMaxX(val);
}
catch (Exception)
{
}
if (Cb_AutoYSize.Checked)
{
GraphVisualiser.SetMaxY(double.NaN);
}
else
{
double height;
if (double.TryParse(Tb_MaxY.Text, out height))
{
GraphVisualiser.SetMaxY(height);
}
else
{
GraphVisualiser.SetMaxY(double.NaN);
}
}
GraphVisualiser.SetMinY2(double.NaN);
GraphVisualiser.SetMaxY2(double.NaN);
double top, bottom;
if (double.TryParse(Tb_MinGrad.Text, out bottom))
{
GraphVisualiser.SetMinY2(bottom);
}
if (double.TryParse(Tb_MaxGrad.Text, out top))
{
GraphVisualiser.SetMaxY2(top);
}
GraphVisualiser.DrawGraphs(expectedEndX);
}
});
}
