protected override void Context()
{
_buildingBlockIconRetriever = A.Fake <IBuildingBlockIconRetriever>();
_view = A.Fake <ISimulationExplorerView>();
A.CallTo(() => _view.TreeView).Returns(A.Fake <IUxTreeView>());
_treeNodeFactory = A.Fake <ITreeNodeFactory>();
_contextMenuFactory = A.Fake <ITreeNodeContextMenuFactory>();
_regionResolver = A.Fake <IRegionResolver>();
_buildingBlockInSimulationManager = A.Fake <IBuildingBlockInSimulationManager>();
_buildingBlockTask = A.Fake <IBuildingBlockTask>();
_toolTipNodeCreator = A.Fake <IToolTipPartCreator>();
_projectRetriever = A.Fake <IProjectRetriever>();
_multipleTreeNodeContextMenuFactory = A.Fake <IMultipleTreeNodeContextMenuFactory>();
_parameterAnalysablesInExplorerPresenter = A.Fake <IParameterAnalysablesInExplorerPresenter>();
_simulationFolderNode = new RootNode(RootNodeTypes.SimulationFolder);
_comparisonFolderNode = new RootNode(RootNodeTypes.ComparisonFolder);
_project = new PKSimProject();
_usedObservedData = new UsedObservedData {
Id = "UsedData"
};
_simulation = new IndividualSimulation().WithName("individualSimulation").WithId("individualSimulation");
_populationSimulation = new PopulationSimulation().WithName("populationSimulation").WithId("populationSimulation");
_importedSimulaton = A.Fake <Simulation>().WithName("ImportedSimulation").WithId("ImportedSimulation");
A.CallTo(() => _importedSimulaton.IsImported).Returns(true);
_simulation.Properties = new SimulationProperties();
_simulation.ModelProperties = new ModelProperties();
_simulation.ModelConfiguration = A.Fake <ModelConfiguration>();
_populationSimulation.Properties = new SimulationProperties();
_populationSimulation.ModelProperties = new ModelProperties();
_populationSimulation.ModelConfiguration = A.Fake <ModelConfiguration>();
_classificationPresenter = A.Fake <IClassificationPresenter>();
_project.AddBuildingBlock(_simulation);
_project.AddBuildingBlock(_populationSimulation);
var classifiableIndividualSimulation = new ClassifiableSimulation {
Subject = _simulation
};
var classfiablePopulationSimulation = new ClassifiableSimulation {
Subject = _populationSimulation
};
var classifiableImportSimulation = new ClassifiableSimulation {
Subject = _importedSimulaton
};
_project.AddClassifiable(classifiableIndividualSimulation);
_project.AddClassifiable(classfiablePopulationSimulation);
_individualSimulationNode = new SimulationNode(classifiableIndividualSimulation);
_populationSimulationNode = new SimulationNode(classfiablePopulationSimulation);
_importedSimulationNode = new SimulationNode(classifiableImportSimulation);
_usedObservedDataNode = A.Fake <ITreeNode>();
A.CallTo(() => _treeNodeFactory.CreateFor(classifiableIndividualSimulation)).Returns(_individualSimulationNode);
A.CallTo(() => _treeNodeFactory.CreateFor(classfiablePopulationSimulation)).Returns(_populationSimulationNode);
A.CallTo(() => _treeNodeFactory.CreateFor(classifiableImportSimulation)).Returns(_importedSimulationNode);
A.CallTo(() => _treeNodeFactory.CreateFor(_usedObservedData)).Returns(_usedObservedDataNode);
_project.AddBuildingBlock(_importedSimulaton);
var simulationComparison = A.Fake <ISimulationComparison>().WithId("SimComp_Id");
var classifiableComparison = new ClassifiableComparison {
Subject = simulationComparison
};
_comparisonNode = new ComparisonNode(classifiableComparison);
_project.AddSimulationComparison(simulationComparison);
A.CallTo(() => _treeNodeFactory.CreateFor(classifiableComparison)).Returns(_comparisonNode);
_usedCompoundBuildingBlock = new UsedBuildingBlock("toto", PKSimBuildingBlockType.Compound)
{
Id = "usedBB"
};
_simulation.AddUsedBuildingBlock(_usedCompoundBuildingBlock);
_simulation.AddUsedObservedData(_usedObservedData);
_project.AddClassifiable(classifiableComparison);
_templageCompoundBuildingBlock = A.Fake <IPKSimBuildingBlock>();
_usedBuildingBlockNode = new UsedBuildingBlockInSimulationNode(_simulation, _usedCompoundBuildingBlock, _templageCompoundBuildingBlock);
A.CallTo(() => _treeNodeFactory.CreateFor(_simulation, _usedCompoundBuildingBlock)).Returns(_usedBuildingBlockNode);
A.CallTo(() => _buildingBlockIconRetriever.IconFor(_simulation)).Returns(ApplicationIcons.SimulationGreen);
A.CallTo(() => _buildingBlockIconRetriever.IconFor(_populationSimulation)).Returns(ApplicationIcons.SimulationGreen);
A.CallTo(() => _buildingBlockIconRetriever.IconFor(_usedCompoundBuildingBlock)).Returns(ApplicationIcons.CompoundRed);
A.CallTo(() => _view.TreeView.NodeById(_simulation.Id)).Returns(_individualSimulationNode);
A.CallTo(() => _view.TreeView.NodeById(_usedCompoundBuildingBlock.Id)).Returns(_usedBuildingBlockNode);
A.CallTo(() => _view.TreeView.NodeById(RootNodeTypes.SimulationFolder.Id)).Returns(_simulationFolderNode);
A.CallTo(() => _view.TreeView.NodeById(RootNodeTypes.ComparisonFolder.Id)).Returns(_comparisonFolderNode);
_observedDataInSimulationManager = A.Fake <IObservedDataInSimulationManager>();
sut = new SimulationExplorerPresenter(_view, _treeNodeFactory, _contextMenuFactory, _multipleTreeNodeContextMenuFactory, _buildingBlockIconRetriever,
_regionResolver, _buildingBlockTask, _buildingBlockInSimulationManager, _toolTipNodeCreator, _projectRetriever, _classificationPresenter, _parameterAnalysablesInExplorerPresenter, _observedDataInSimulationManager);
A.CallTo(() => _projectRetriever.CurrentProject).Returns(_project);
}
void ContextCallback(object obj)
{
string clb = obj.ToString();
if (clb.Equals("inputNode"))
{
InputNode inputNode = new InputNode()
{
windowRect = new Rect(mousePos.x, mousePos.y, 200, 150)
};
windows.Add(inputNode);
}
else if (clb.Equals("outputNode"))
{
OutputNode outputNode = new OutputNode()
{
windowRect = new Rect(mousePos.x, mousePos.y, 200, 100)
};
windows.Add(outputNode);
}
else if (clb.Equals("calcNode"))
{
CalcNode calcNode = new CalcNode()
{
windowRect = new Rect(mousePos.x, mousePos.y, 200, 100)
};
windows.Add(calcNode);
}
else if (clb.Equals("compNode"))
{
ComparisonNode compNode = new ComparisonNode()
{
windowRect = new Rect(mousePos.x, mousePos.y, 200, 100)
};
windows.Add(compNode);
}
else if (clb.Equals("makeTransition"))
{
bool clickedOnWindow = false;
int selectIndex = -1;
for (int i = 0; i < windows.Count; i++)
{
if (windows[i].windowRect.Contains(mousePos))
{
selectIndex = i;
clickedOnWindow = true;
break;
}
}
if (clickedOnWindow)
{
selectedNode = windows[selectIndex];
makeTransitionMode = true;
}
}
else if (clb.Equals("deleteNode"))
{
bool clickedOnWindow = false;
int selectIndex = -1;
for (int i = 0; i < windows.Count; i++)
{
if (windows[i].windowRect.Contains(mousePos))
{
selectIndex = i;
clickedOnWindow = true;
break;
}
}
if (clickedOnWindow)
{
BaseNodeOld selNode = windows[selectIndex];
windows.RemoveAt(selectIndex);
foreach (BaseNodeOld n in windows)
{
n.NodeDeleted(selNode);
}
}
}
}
private ComparisonNode NumberComparison()
{
ComparisonNode comparisonNode = new ComparisonNode
{
FilterOperator = FilterOperator.IsEqualTo,
First = new PropertyNode
{
Name = "Age"
},
Second = new NumberNode
{
Value = 10
}
};
return comparisonNode;
}
static void FilterRoot(ComparisonNode node)
{
Filters filters = GetDataAccess().GetFilters();
FilterNode(filters, node);
}
//Is called when a selection from the context menu is made
void ContextCallback(object obj)
{
//make the passed object to a string
string clb = obj.ToString();
//add the node we want
if (clb.Equals("inputNode"))
{
InputNode inputNode = ScriptableObject.CreateInstance <InputNode>();
inputNode.WindowRect = new Rect(mousePos.x, mousePos.y, 200, 80);
windows.Add(inputNode);
}
else if (clb.Equals("outputNode"))
{
OutputNode outputNode = ScriptableObject.CreateInstance <OutputNode>();
outputNode.WindowRect = new Rect(mousePos.x, mousePos.y, 200, 80);
windows.Add(outputNode);
}
else if (clb.Equals("calcNode"))
{
CalcNode calcNode = ScriptableObject.CreateInstance <CalcNode>();
calcNode.WindowRect = new Rect(mousePos.x, mousePos.y, 200, 95);
windows.Add(calcNode);
}
else if (clb.Equals("compNode"))
{
ComparisonNode compNode = ScriptableObject.CreateInstance <ComparisonNode>();
compNode.WindowRect = new Rect(mousePos.x, mousePos.y, 200, 95);
windows.Add(compNode);
}
else if (clb.Equals("numNode"))
{
NumberNode numNode = ScriptableObject.CreateInstance <NumberNode>();
numNode.WindowRect = new Rect(mousePos.x, mousePos.y, 200, 95);
windows.Add(numNode);
}
else if (clb.Equals("goObj"))
{
GameObjectNode goObj = ScriptableObject.CreateInstance <GameObjectNode>();
goObj.WindowRect = new Rect(mousePos.x, mousePos.y, 200, 100);
windows.Add(goObj);
}
else if (clb.Equals("goActive"))
{
GameObjectActive goNode = ScriptableObject.CreateInstance <GameObjectActive>();
goNode.WindowRect = new Rect(mousePos.x, mousePos.y, 200, 80);
windows.Add(goNode);
}
else if (clb.Equals("goDistance"))
{
GameObjectDistance goDistance = ScriptableObject.CreateInstance <GameObjectDistance>();
goDistance.WindowRect = new Rect(mousePos.x, mousePos.y, 200, 80);
windows.Add(goDistance);
}
else if (clb.Equals("timerNode"))
{
TimerNode tNode = ScriptableObject.CreateInstance <TimerNode>();
tNode.WindowRect = new Rect(mousePos.x, mousePos.y, 200, 95);
windows.Add(tNode);
}
else if (clb.Equals("boolNode"))
{
BoolNode bNode = ScriptableObject.CreateInstance <BoolNode>();
bNode.WindowRect = new Rect(mousePos.x, mousePos.y, 120, 75);
windows.Add(bNode);
}
else if (clb.Equals("clearAll"))
{
windows.Clear();
}
else if (clb.Equals("reset"))
{
PanX = PanY = 0;
}
else if (clb.Equals("makeTransition")) //if it's a transition
{
bool clickedOnWindow = false;
int selectedIndex = -1;
//find the window that it was clicked
for (int i = 0; i < windows.Count; i++)
{
if (windows[i].WindowRect.Contains(mousePos))
{
selectedIndex = i;
clickedOnWindow = true;
break;
}
}
//and make it the selected node of the transition
if (clickedOnWindow)
{
selectedNode = windows[selectedIndex];
makeTransitionMode = true;
}
}
else if (clb.Equals("deleteNode")) //if it's a delete node
{
bool clickedOnWindow = false;
int selectedIndex = -1;
//find the selected node
for (int i = 0; i < windows.Count; i++)
{
if (windows[i].WindowRect.Contains(mousePos))
{
selectedIndex = i;
clickedOnWindow = true;
break;
}
}
if (clickedOnWindow)
{
//delete it from our list
BaseNode selNode = windows[selectedIndex];
windows.RemoveAt(selectedIndex);
//then pass it to all our nodes that is deleted
foreach (BaseNode n in windows)
{
n.NodeDeleted(selNode);
}
}
}
//we use else if instead of a switch because:
/*Selecting from a set of multiple cases is faster with if statements than with switch
*/
}
protected override void DoAction(int action)
{
#pragma warning disable 162, 1522
switch (action)
{
case 2: // start -> Program, block, EOF
#line 22 "D:\MINICompiler\kompilator.y"
{
if (syntaxErrorLines.Count != 0)
{
YYAbort();
}
ProgramTree.block = ValueStack[ValueStack.Depth - 2] as BlockNode;
ProgramTree.Line = ValueStack[ValueStack.Depth - 3].Line;
}
#line default
break;
case 3: // block -> OpenBracket, lines, CloseBracket
#line 34 "D:\MINICompiler\kompilator.y"
{
BlockNode node;
if (ValueStack[ValueStack.Depth - 2] is null)
{
node = new BlockNode();
}
else
{
node = new BlockNode(ValueStack[ValueStack.Depth - 2] as BlockNode);
}
node.Line = ValueStack[ValueStack.Depth - 3].Line;
CurrentSemanticValue = node;
}
#line default
break;
case 5: // lines -> lines, instruction
#line 44 "D:\MINICompiler\kompilator.y"
{
BlockNode node;
if (ValueStack[ValueStack.Depth - 2] is null)
{
node = new BlockNode();
}
else
{
node = new BlockNode(ValueStack[ValueStack.Depth - 2] as BlockNode);
}
node.instructions.Add(ValueStack[ValueStack.Depth - 1]);
CurrentSemanticValue = node;
}
#line default
break;
case 6: // lines -> EOF
#line 52 "D:\MINICompiler\kompilator.y"
{
syntaxErrorLines.Add(ProgramTree.LineCount);
YYAbort();
}
#line default
break;
case 11: // instruction -> exp, Semicolon
#line 62 "D:\MINICompiler\kompilator.y"
{
ExpressionNode node = ValueStack[ValueStack.Depth - 2] as ExpressionNode;
node.ShouldReturnValue = false;
}
#line default
break;
case 15: // instruction -> Semicolon
#line 70 "D:\MINICompiler\kompilator.y"
{
syntaxErrorLines.Add(ValueStack[ValueStack.Depth - 1].Line);
}
#line default
break;
case 16: // instruction -> error
#line 74 "D:\MINICompiler\kompilator.y"
{
syntaxErrorLines.Add(ValueStack[ValueStack.Depth - 1].Line);
}
#line default
break;
case 17: // write -> Write, String
#line 80 "D:\MINICompiler\kompilator.y"
{
WriteNode node = new WriteNode(ValueStack[ValueStack.Depth - 2].Line);
node.content = ValueStack[ValueStack.Depth - 1];
CurrentSemanticValue = node;
}
#line default
break;
case 18: // write -> Write, exp
#line 86 "D:\MINICompiler\kompilator.y"
{
WriteNode node = new WriteNode(ValueStack[ValueStack.Depth - 2].Line);
node.content = ValueStack[ValueStack.Depth - 1] as ExpressionNode;
CurrentSemanticValue = node;
}
#line default
break;
case 19: // read -> Read, Variable
#line 93 "D:\MINICompiler\kompilator.y"
{
ReadNode node = new ReadNode(ValueStack[ValueStack.Depth - 2].Line);
node.target = ValueStack[ValueStack.Depth - 1] as VariableNode;
CurrentSemanticValue = node;
}
#line default
break;
case 20: // init -> Int, Variable
#line 100 "D:\MINICompiler\kompilator.y"
{
InitNode node = new InitNode(ValueStack[ValueStack.Depth - 2].Line);
node.variable = ValueStack[ValueStack.Depth - 1] as VariableNode;
node.variable.ValType = ValType.Int;
CurrentSemanticValue = node;
}
#line default
break;
case 21: // init -> Double, Variable
#line 108 "D:\MINICompiler\kompilator.y"
{
InitNode node = new InitNode(ValueStack[ValueStack.Depth - 2].Line);
node.variable = ValueStack[ValueStack.Depth - 1] as VariableNode;
node.variable.ValType = ValType.Double;
CurrentSemanticValue = node;
}
#line default
break;
case 22: // init -> Bool, Variable
#line 115 "D:\MINICompiler\kompilator.y"
{
InitNode node = new InitNode(ValueStack[ValueStack.Depth - 2].Line);
node.variable = ValueStack[ValueStack.Depth - 1] as VariableNode;
node.variable.ValType = ValType.Bool;
CurrentSemanticValue = node;
}
#line default
break;
case 23: // assign -> Variable, Assign, exp
#line 123 "D:\MINICompiler\kompilator.y"
{
AssignNode node = new AssignNode(ValueStack[ValueStack.Depth - 3].Line);
node.left = ValueStack[ValueStack.Depth - 3] as VariableNode;
node.right = ValueStack[ValueStack.Depth - 1];
node.ShouldReturnValue = true;
CurrentSemanticValue = node;
}
#line default
break;
case 24: // exp -> OpenPar, exp, ClosePar
#line 133 "D:\MINICompiler\kompilator.y"
{
ParenthesisNode node = new ParenthesisNode(ValueStack[ValueStack.Depth - 3].Line);
node.content = ValueStack[ValueStack.Depth - 2] as ExpressionNode;
CurrentSemanticValue = node;
}
#line default
break;
case 25: // exp -> exp, Add, exp
#line 139 "D:\MINICompiler\kompilator.y"
{
BinaryOpNode node = ValueStack[ValueStack.Depth - 2] as BinaryOpNode;
CurrentSemanticValue = AssignToBinaryOp(node, ValueStack[ValueStack.Depth - 3] as ExpressionNode, ValueStack[ValueStack.Depth - 1] as ExpressionNode);
}
#line default
break;
case 26: // exp -> exp, Sub, exp
#line 144 "D:\MINICompiler\kompilator.y"
{
BinaryOpNode node = ValueStack[ValueStack.Depth - 2] as BinaryOpNode;
CurrentSemanticValue = AssignToBinaryOp(node, ValueStack[ValueStack.Depth - 3] as ExpressionNode, ValueStack[ValueStack.Depth - 1] as ExpressionNode);
}
#line default
break;
case 27: // exp -> exp, Mult, exp
#line 149 "D:\MINICompiler\kompilator.y"
{
BinaryOpNode node = ValueStack[ValueStack.Depth - 2] as BinaryOpNode;
CurrentSemanticValue = AssignToBinaryOp(node, ValueStack[ValueStack.Depth - 3] as ExpressionNode, ValueStack[ValueStack.Depth - 1] as ExpressionNode);
}
#line default
break;
case 28: // exp -> exp, Div, exp
#line 154 "D:\MINICompiler\kompilator.y"
{
BinaryOpNode node = ValueStack[ValueStack.Depth - 2] as BinaryOpNode;
CurrentSemanticValue = AssignToBinaryOp(node, ValueStack[ValueStack.Depth - 3] as ExpressionNode, ValueStack[ValueStack.Depth - 1] as ExpressionNode);
}
#line default
break;
case 29: // exp -> exp, BitAnd, exp
#line 159 "D:\MINICompiler\kompilator.y"
{
BinaryOpNode node = ValueStack[ValueStack.Depth - 2] as BinaryOpNode;
CurrentSemanticValue = AssignToBinaryOp(node, ValueStack[ValueStack.Depth - 3] as ExpressionNode, ValueStack[ValueStack.Depth - 1] as ExpressionNode);
}
#line default
break;
case 30: // exp -> exp, BitOr, exp
#line 164 "D:\MINICompiler\kompilator.y"
{
BinaryOpNode node = ValueStack[ValueStack.Depth - 2] as BinaryOpNode;
CurrentSemanticValue = AssignToBinaryOp(node, ValueStack[ValueStack.Depth - 3] as ExpressionNode, ValueStack[ValueStack.Depth - 1] as ExpressionNode);
}
#line default
break;
case 32: // exp -> IntCast, exp
#line 170 "D:\MINICompiler\kompilator.y"
{
IntCastNode node = new IntCastNode(ValueStack[ValueStack.Depth - 2].Line);
node.content = ValueStack[ValueStack.Depth - 1] as ExpressionNode;
CurrentSemanticValue = node;
}
#line default
break;
case 33: // exp -> DoubleCast, exp
#line 176 "D:\MINICompiler\kompilator.y"
{
DoubleCastNode node = new DoubleCastNode(ValueStack[ValueStack.Depth - 2].Line);
node.content = ValueStack[ValueStack.Depth - 1] as ExpressionNode;
CurrentSemanticValue = node;
}
#line default
break;
case 37: // exp -> Not, exp
#line 185 "D:\MINICompiler\kompilator.y"
{
NotNode node = new NotNode(ValueStack[ValueStack.Depth - 2].Line);
node.content = ValueStack[ValueStack.Depth - 1] as ExpressionNode;
CurrentSemanticValue = node;
}
#line default
break;
case 38: // exp -> Tilde, exp
#line 191 "D:\MINICompiler\kompilator.y"
{
NegNode node = new NegNode(ValueStack[ValueStack.Depth - 2].Line);
node.content = ValueStack[ValueStack.Depth - 1] as ExpressionNode;
CurrentSemanticValue = node;
}
#line default
break;
case 39: // exp -> Sub, exp
#line 197 "D:\MINICompiler\kompilator.y"
{
MinusNode node = new MinusNode(ValueStack[ValueStack.Depth - 2].Line);
node.content = ValueStack[ValueStack.Depth - 1] as ExpressionNode;
CurrentSemanticValue = node;
}
#line default
break;
case 40: // exp -> exp, And, exp
#line 203 "D:\MINICompiler\kompilator.y"
{
LogicOpNode node = ValueStack[ValueStack.Depth - 2] as LogicOpNode;
node.left = ValueStack[ValueStack.Depth - 3] as ExpressionNode;
node.right = ValueStack[ValueStack.Depth - 1] as ExpressionNode;
CurrentSemanticValue = node;
}
#line default
break;
case 41: // exp -> exp, Or, exp
#line 210 "D:\MINICompiler\kompilator.y"
{
LogicOpNode node = ValueStack[ValueStack.Depth - 2] as LogicOpNode;
node.left = ValueStack[ValueStack.Depth - 3] as ExpressionNode;
node.right = ValueStack[ValueStack.Depth - 1] as ExpressionNode;
CurrentSemanticValue = node;
}
#line default
break;
case 42: // exp -> exp, Comparison, exp
#line 217 "D:\MINICompiler\kompilator.y"
{
ComparisonNode node = ValueStack[ValueStack.Depth - 2] as ComparisonNode;
CurrentSemanticValue = AssignToComparisonOp(node, ValueStack[ValueStack.Depth - 3] as ExpressionNode, ValueStack[ValueStack.Depth - 1] as ExpressionNode);
}
#line default
break;
case 44: // if -> If, OpenPar, exp, ClosePar, instruction
#line 225 "D:\MINICompiler\kompilator.y"
{
IfNode node = new IfNode(ValueStack[ValueStack.Depth - 5].Line);
node.check = ValueStack[ValueStack.Depth - 3] as ExpressionNode;
node.ifBlock = ValueStack[ValueStack.Depth - 1];
CurrentSemanticValue = node;
}
#line default
break;
case 45: // if -> If, OpenPar, exp, ClosePar, instruction, Else, instruction
#line 232 "D:\MINICompiler\kompilator.y"
{
IfNode node = new IfNode(ValueStack[ValueStack.Depth - 7].Line);
node.check = ValueStack[ValueStack.Depth - 5] as ExpressionNode;
node.elseBlock = ValueStack[ValueStack.Depth - 1];
node.ifBlock = ValueStack[ValueStack.Depth - 3];
CurrentSemanticValue = node;
}
#line default
break;
case 46: // while -> While, OpenPar, exp, ClosePar, instruction
#line 241 "D:\MINICompiler\kompilator.y"
{
WhileNode node = new WhileNode(ValueStack[ValueStack.Depth - 5].Line);
node.check = ValueStack[ValueStack.Depth - 3] as ExpressionNode;
node.block = ValueStack[ValueStack.Depth - 1];
CurrentSemanticValue = node;
}
#line default
break;
}
#pragma warning restore 162, 1522
}
public ComparisonNode AssignToComparisonOp(ComparisonNode node, ExpressionNode left, ExpressionNode right)
{
node.left = left;
node.right = right;
return(node);
}
public static BlockNode ProcessTokens(List <ScriptToken> tokens)
{
List <AstTreeNode> blockNodes = new List <AstTreeNode>();
AstTreeNode node = new BlockNode(null);
int count = 0;
StripWhiteSpace(tokens);
while (tokens.Count > 0)
{
count++;
if (count > 1000)
{
break; // Limit to 1000 iterations while in development
}
if (tokens[0].Type == EScriptTokenType.RETURN)
{
tokens.RemoveAt(0); // Last value in block is returned by default
}
ScriptToken scriptToken = tokens[0];
if (scriptToken.Type == EScriptTokenType.NAME)
{
node = new RootScopeMemberNode(
new LiteralNode <string>(scriptToken.Value)
);
tokens.RemoveAt(0);
}
else if (scriptToken.Type == EScriptTokenType.ASSIGN)
{
node = AssignmentNode.Parse(node, scriptToken, tokens);
}
else if (scriptToken.Type == EScriptTokenType.IF)
{
node = IfStatementNode.Parse(node, scriptToken, tokens);
blockNodes.Add(node);
node = null;
}
else if (scriptToken.Type == EScriptTokenType.FOR)
{
node = ForStatementNode.Parse(node, scriptToken, tokens);
blockNodes.Add(node);
node = null;
}
else if (scriptToken.Type == EScriptTokenType.STRING_LITERAL)
{
node = new LiteralNode <string>(scriptToken.Value);
tokens.RemoveAt(0);
}
else if (scriptToken.Type == EScriptTokenType.NUMBER_LITERAL)
{
AstTreeNode _node;
if (scriptToken.Value.Contains("."))
{
_node = new FloatLiteralNode(scriptToken.Value);
}
else
{
_node = new IntegerLiteralNode(scriptToken.Value);
}
node = _node;
tokens.RemoveAt(0);
}
else if (scriptToken.Type == EScriptTokenType.PERIOD)
{
if (tokens[1].Type == EScriptTokenType.NAME)
{
node = new ScopeMemberNode(
node,
new LiteralNode <string>(tokens[1].Value)
);
tokens.RemoveAt(0);
tokens.RemoveAt(0);
}
}
else if (scriptToken.Type == EScriptTokenType.L_BRACKET)
{
if (node.GetType() == typeof(RootScopeMemberNode))
{
// indice
}
else
{
node = ArrayNode.Parse(node, scriptToken, tokens);
}
}
else if (scriptToken.Type == EScriptTokenType.L_PAREN)
{
List <List <ScriptToken> > funcArgs = GetBlockTokens(tokens);
List <AstTreeNode> nodes = new List <AstTreeNode>();
;
foreach (List <ScriptToken> arg in funcArgs)
{
nodes.Add(ProcessTokens(arg));
}
node = new FunctionCallNode(
node, // Previous node should be a NAME
new FunctionArgumentNode(nodes)
);
}
else if (scriptToken.Type == EScriptTokenType.SEMI_COLON)
{
if (node != null)
{
blockNodes.Add(node);
}
node = null;
tokens.RemoveAt(0);
}
else if (ComparisonNode.Matches(tokens))
{
node = ComparisonNode.Parse(node, scriptToken, tokens);
}
else if (ArithmeticNode.Matches(tokens))
{
AstTreeNode _node = ArithmeticNode.Parse(node, scriptToken, tokens);
node = _node;
}
else if (ArithmeticAssignmentNode.Matches(tokens))
{
node = ArithmeticAssignmentNode.Parse(node, scriptToken, tokens);
}
else if (scriptToken.Type == EScriptTokenType.WHITESPACE)
{
tokens.RemoveAt(0);
}
else if (scriptToken.Type == EScriptTokenType.BOOLEAN_LITERAL)
{
node = new BooleanLiteralNode(tokens[0].Value);
tokens.RemoveAt(0);
}
else if (scriptToken.Type == EScriptTokenType.NULL_LITERAL)
{
node = new LiteralNode <object>(null);
tokens.RemoveAt(0);
}
else
{
string code = ScriptTree.ToCode(tokens, 10);
Console.WriteLine($"Syntax Error.Near {code}");
}
}
if (node != null)
{
blockNodes.Add(node);
}
return(new BlockNode(blockNodes));
}
public abstract object Visit(ComparisonNode node);
void ContextCallback(object obj)
{
string clb = obj.ToString();
bool clickedOnWindow = false;
int selectIndex = -1;
for (int i = 0; i < _windows.Count; i++)
{
if (_windows[i].WindowRect.Contains(_mousePos))
{
selectIndex = i;
clickedOnWindow = true;
break;
}
}
switch (clb)
{
case "inputNode":
InputNode inputNode = new InputNode();
inputNode.WindowRect = new Rect(_mousePos.x, _mousePos.y, 200, 150);
_windows.Add(inputNode);
break;
case "outputNode":
OutputNode outputNode = new OutputNode();
outputNode.WindowRect = new Rect(_mousePos.x, _mousePos.y, 200, 100);
_windows.Add(outputNode);
break;
case "calcNode":
CalcNode calcNode = new CalcNode();
calcNode.WindowRect = new Rect(_mousePos.x, _mousePos.y, 200, 150);
_windows.Add(calcNode);
break;
case "compNode":
ComparisonNode compNode = new ComparisonNode();
compNode.WindowRect = new Rect(_mousePos.x, _mousePos.y, 200, 150);
_windows.Add(compNode);
break;
case "makeTransition":
if (clickedOnWindow)
{
_selectedNode = _windows[selectIndex];
_makeTransitionMode = true;
}
break;
case "deleteNode":
if (clickedOnWindow)
{
BaseNode selectedNode = _windows[selectIndex];
_windows.RemoveAt(selectIndex);
foreach (BaseNode baseNode in _windows)
{
baseNode.NodeDeleted(selectedNode);
}
}
break;
}
}
/// <summary>
/// Helper method to transform comparison object to structure understood by Angular control
/// </summary>
/// <param name="comparisonObject">Individual node in the tree</param>
/// <param name="level">Level in the heirarchy to which the object belongs</param>
/// <param name="parentNode">Reference to the parent node of the current object</param>
private void PopulateComparisonData(ComparisonObject comparisonObject, int level, ComparisonNode parentNode)
{
if (comparisonObject != null)
{
ComparisonNode currentNode = new ComparisonNode
{
NodeType = Equals(ComparisonObjectType.DataSource, comparisonObject.ComparisonObjectType) ? "Data Source" : comparisonObject.ComparisonObjectType.ToString(),
SourceName = comparisonObject.SourceObjectName,
TargetName = comparisonObject.TargetObjectName,
SourceInternalName = comparisonObject.SourceObjectInternalName,
TargetInternalName = comparisonObject.TargetObjectInternalName,
SourceObjectDefinition = comparisonObject.SourceObjectDefinition,
TargetObjectDefinition = comparisonObject.TargetObjectDefinition,
ShowNode = true,
Level = level,
MergeAction = comparisonObject.MergeAction.ToString(),
DisableMessage = "",
DropdownDisabled = false
};
if (parentNode != null)
{
currentNode.ParentId = parentNode.Id;
parentNode.ChildNodes.Add(currentNode.Id);
}
switch (comparisonObject.Status)
{
case ComparisonObjectStatus.MissingInTarget:
currentNode.Status = "Missing in Target";
break;
case ComparisonObjectStatus.MissingInSource:
currentNode.Status = "Missing in Source";
break;
case ComparisonObjectStatus.SameDefinition:
currentNode.Status = "Same Definition";
break;
case ComparisonObjectStatus.DifferentDefinitions:
currentNode.Status = "Different Definitions";
break;
default:
break;
}
comparisonList.Add(currentNode);
// Populate helper objects
AngularComposite angularComposite = new AngularComposite(currentNode, comparisonObject);
_directAccessList.Add(currentNode.Id, angularComposite);
// set drop-down to have limited members based on what is available
switch (comparisonObject.MergeAction)
{
case MergeAction.Create:
currentNode.AvailableActions = new List <string> {
"Create", "Skip"
};
if (parentNode != null && string.Equals(parentNode.Status, "Missing in Target") && string.Equals(parentNode.MergeAction, "Skip"))
{
comparisonObject.MergeAction = MergeAction.Skip;
currentNode.MergeAction = MergeAction.Skip.ToString();
currentNode.DropdownDisabled = true;
SetNodeTooltip(angularComposite, true);
}
break;
case MergeAction.Update:
currentNode.AvailableActions = new List <string> {
"Update", "Skip"
};
break;
case MergeAction.Delete:
currentNode.AvailableActions = new List <string> {
"Delete", "Skip"
};
//check if parent is also set to delete, in which case make this cell readonly
if (parentNode != null && string.Equals(parentNode.MergeAction, "Delete"))
{
currentNode.DropdownDisabled = true;
SetNodeTooltip(angularComposite, true);
}
break;
case MergeAction.Skip:
switch (comparisonObject.Status)
{
case ComparisonObjectStatus.MissingInTarget:
currentNode.AvailableActions = new List <string> {
"Create", "Skip"
};
//check if parent is also MissingInTarget and Skip, make this cell readonly
if (parentNode != null && string.Equals(parentNode.Status, "Missing in Target") && string.Equals(parentNode.MergeAction, "Skip"))
{
currentNode.DropdownDisabled = true;
SetNodeTooltip(angularComposite, true);
}
break;
case ComparisonObjectStatus.MissingInSource:
currentNode.AvailableActions = new List <string> {
"Delete", "Skip"
};
break;
case ComparisonObjectStatus.DifferentDefinitions:
currentNode.AvailableActions = new List <string> {
"Update", "Skip"
};
break;
default:
//default covers ComparisonObjectStatus.SameDefinition: which is most common case (above cases are for saved skip selections from file)
currentNode.AvailableActions = new List <string> {
"Skip"
};
currentNode.DropdownDisabled = true;
SetNodeTooltip(angularComposite, true);
break;
}
break;
default:
break;
}
;
// Add child objects if it exists
if (comparisonObject.ChildComparisonObjects != null && comparisonObject.ChildComparisonObjects.Count > 0)
{
foreach (ComparisonObject childComparisonObject in comparisonObject.ChildComparisonObjects)
{
PopulateComparisonData(childComparisonObject, level + 1, currentNode);
}
}
}
}
protected void TreeNodePopulate(object sender, TreeNodeEventArgs e)
{
string val = e.Node.Value;
ComparisonNode cn = DB.GetNodeByName(val);
if (cn == null)
{
Console.WriteLine("ERROR: Did not find the node " + e.Node.Value);
e.Node.ChildNodes.Add(new TreeNode("ERROR: Did not find the node", "Error"));
return;
}
ComparisonNode chain = cn;
int last = val.LastIndexOf('-');
while (last > 0)
{
string parent = val.Substring(0, last);
ComparisonNode node = DB.GetNodeByName(parent, false, false);
if (node == null)
{
break;
}
chain.Parent = node;
chain = node;
last = parent.LastIndexOf('-');
}
foreach (var child in cn.Children)
{
TreeNode tn;
switch (child.Type)
{
case CompType.Namespace:
case CompType.Class:
case CompType.Struct:
case CompType.Interface:
case CompType.Enum:
tn = new TreeNode(GetHtmlForNode(child, true), child.InternalID.ToString());
tn.SelectAction = TreeNodeSelectAction.None;
break;
case CompType.Method:
tn = new TreeNode(GetHtmlForNode(child, false));
AttachComments(tn, child);
switch (cn.Type)
{
case CompType.Property:
tn.NavigateUrl = MakeURL(GetFQN(cn));
break;
default:
tn.NavigateUrl = MakeURL(GetMethodFQN(child));
break;
}
tn.Target = "_blank";
break;
case CompType.Property:
case CompType.Field:
case CompType.Delegate:
case CompType.Event:
bool prop_or_evt = (child.Type == CompType.Property || child.Type == CompType.Event);
tn = new TreeNode(GetHtmlForNode(child, prop_or_evt));
AttachComments(tn, child);
// Fields whose parents are an enum are enum definitions, make the link useful
if (child.Type == CompType.Field && cn.Type == CompType.Enum)
{
tn.NavigateUrl = MakeURL(GetFQN(cn));
}
else
{
tn.NavigateUrl = MakeURL(GetFQN(child));
}
tn.Target = "_blank";
break;
case CompType.Attribute:
tn = new TreeNode(GetHtmlForNode(child, false));
tn.SelectAction = TreeNodeSelectAction.None;
break;
case CompType.Assembly:
/* Should not happen */
throw new Exception("Should not happen");
default:
tn = new TreeNode("Unknown type: " + child.Type.ToString());
break;
}
tn.Value = child.InternalID.ToString();
if (tn.ChildNodes.Count == 0)
{
tn.PopulateOnDemand = child.HasChildren;
}
e.Node.ChildNodes.Add(tn);
}
}
