public BoolOP(VariableBlock leftBlock, VariableBlock rightBlock, string output, BoolOPTypes opType, string id, bool canBeScheduled) :
base(false, null, new List <string>() { leftBlock?.OutputVariable, rightBlock?.OutputVariable }, output, id, canBeScheduled)
{
this.OPType = opType;
this.LeftBlock = leftBlock;
this.RightBlock = rightBlock;
}
public SetArrayNumber(VariableBlock indexBlock, VariableBlock numberBlock, string arrayName, string id, bool canBeScheduled) :
base(true, null, new List <string>() { indexBlock?.OutputVariable, numberBlock?.OutputVariable }, arrayName, id, canBeScheduled)
{
this.ArrayName = arrayName;
this.IndexBlock = indexBlock;
this.NumberBlock = numberBlock;
}
public Conditional Copy(DFG <Block> dfg, Dictionary <DFG <Block>, DFG <Block> > knownDFGCopys)
{
VariableBlock copyDeciding = null;
if (DecidingBlock != null)
{
copyDeciding = (VariableBlock)dfg.Nodes.Single(x => DecidingBlock.OutputVariable == x.value.OutputVariable).value;
}
DFG <Block> copyGuarded = null;
if (GuardedDFG != null && knownDFGCopys.ContainsKey(GuardedDFG))
{
copyGuarded = knownDFGCopys[GuardedDFG];
}
else if (GuardedDFG != null)
{
copyGuarded = GuardedDFG.Copy();
knownDFGCopys.Add(GuardedDFG, copyGuarded);
}
DFG <Block> copyNext = null;
if (NextDFG != null && knownDFGCopys.ContainsKey(NextDFG))
{
copyNext = knownDFGCopys[NextDFG];
}
else if (NextDFG != null)
{
copyNext = NextDFG.Copy();
knownDFGCopys.Add(NextDFG, copyNext);
}
return(new Conditional(copyDeciding, copyGuarded, copyNext));
}
// Constructor
public EventBlock(GCommand command)
{
// Initialize Component
InitializeComponent();
StackContentText.Text = command.FriendlyName;
_GCommand = command;
_GEvent = new GEvent(_GCommand);
// Initialize Hole List
HoleList.Add(NextConnectHole);
for (int i = 0; i < _GEvent.Arguments?.Count; i++)
{
VariableBlock variableBlock = BlockUtils.CreateVariableBlock(_GEvent.Arguments[i].Name, command.Optionals[i].FriendlyName);
BaseBlock baseBlock = variableBlock as BaseBlock;
baseBlock.MouseLeftButtonDown += BaseBlock_MouseLeftButtonDown;
AllowVariableList.Add(variableBlock);
ParameterBox.Children.Add(baseBlock);
}
// Initialize Block
InitializeBlock();
}
public While(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
string mode = node.GetNodeWithAttributeValue(WHILE_MODE_FIELD_NAME).InnerText;
if (mode != SUPPORTED_MODE)
{
parserInfo.ParseExceptions.Add(new ParseException(id, "While block only supports while mode."));
}
XmlNode conditionalNode = node.GetInnerBlockNode(CONDITIONAL_BLOCK_FIELD_NAME, parserInfo, new MissingBlockException(id, "While block is missing its conditional block."));
VariableBlock decidingBlock = null;
if (conditionalNode != null)
{
decidingBlock = (VariableBlock)XmlParser.ParseAndAddNodeToDFG(conditionalNode, dfg, parserInfo);
}
XmlNode guardedNode = node.GetInnerBlockNode(DO_BLOCK_FIELD_NAME, parserInfo, new MissingBlockException(id, "While block is missing blocks to execute."));
if (guardedNode != null)
{
DFG <Block> guardedDFG = XmlParser.ParseDFG(guardedNode, parserInfo);
DFG <Block> nextDFG = XmlParser.ParseNextDFG(node, parserInfo);
this.Cond = new Conditional(decidingBlock, guardedDFG, nextDFG);
}
}
private static VariableBlock ParseVariableBlock(ref XPathNodeIterator xPathIter)
{
VariableBlock variableBlock =
new VariableBlock();
System.Globalization.CultureInfo CultureInfo =
new System.Globalization.CultureInfo(xPathIter.Current.GetAttribute("cultureinfo", xPathIter.Current.NamespaceURI));
if (xPathIter.Current.MoveToFirstChild())
{
XPathNodeIterator xPathIter_V = xPathIter.Clone();
if (xPathIter_V.Current.MoveToFirstChild())
{
do
{
variableBlock.Add(
xPathIter_V.Current.GetAttribute("key", xPathIter_V.Current.NamespaceURI),
Convert.ChangeType(
xPathIter_V.Current.Value.ToString(CultureInfo),
Service.LoadTypeFromDomain(
AppDomain.CurrentDomain,
xPathIter_V.Current.GetAttribute("type", xPathIter_V.Current.NamespaceURI)
)
)
);
} while (xPathIter_V.Current.MoveToNext());
}
}
return(variableBlock);
}
public override Block TrueCopy(DFG <Block> dfg)
{
VariableBlock indexCopy = (VariableBlock)IndexBlock.TrueCopy(dfg);
dfg.AddNode(indexCopy);
return(new GetArrayNumber(indexCopy, ArrayName, OutputVariable, BlockID, CanBeScheduled));
}
public override Block TrueCopy(DFG <Block> dfg)
{
VariableBlock operandCopy = (VariableBlock)OperandBlock.TrueCopy(dfg);
dfg.AddNode(operandCopy);
return(new SetNumberVariable(operandCopy, OutputVariable, BlockID));
}
public override Block TrueCopy(DFG <Block> dfg)
{
VariableBlock arrayLengthCopy = (VariableBlock)ArrayLengthBlock.TrueCopy(dfg);
dfg.AddNode(arrayLengthCopy);
return(new NumberArray(ArrayName, arrayLengthCopy, BlockID));
}
public override Block TrueCopy(DFG <Block> dfg)
{
VariableBlock numberCopy = (VariableBlock)NumberBlock.TrueCopy(dfg);
dfg.AddNode(numberCopy);
return(new RoundOP(numberCopy, OutputVariable, RoundType, BlockID, CanBeScheduled));
}
public override FluidInput TrueCopy(DFG <Block> dfg)
{
VariableBlock indexCopy = (VariableBlock)IndexBlock.TrueCopy(dfg);
dfg.AddNode(indexCopy);
return(new GetArrayFluid(indexCopy, ArrayName, ID, AmountInML, UseAllFluid));
}
public override Block TrueCopy(DFG <Block> dfg)
{
VariableBlock indexCopy = (VariableBlock)IndexBlock.TrueCopy(dfg);
dfg.AddNode(indexCopy);
return(new SetArrayFluid(indexCopy, ArrayName, InputFluids.Copy(dfg), BlockID));
}
public override Block TrueCopy(DFG <Block> dfg)
{
VariableBlock leftCopy = (VariableBlock)LeftBlock.TrueCopy(dfg);
VariableBlock rightCopy = (VariableBlock)RightBlock.TrueCopy(dfg);
dfg.AddNode(leftCopy);
dfg.AddNode(rightCopy);
return(new BoolOP(leftCopy, rightCopy, OutputVariable, OPType, BlockID, CanBeScheduled));
}
public string GetValueAndApplyVariables(VariableBlock variableBlock)
{
if (!this.value.StartsWith("@"))
{
return(this.value);
}
variableBlock.TryGetValue(this.value.Substring(1), out string variableValue);
return(variableValue);
}
public static Block Parse(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo, bool canBeScheduled)
{
string id = ParseTools.ParseID(node);
RoundOPTypes roundType = StringToRoundOPType(id, ParseTools.ParseString(node, OPTypeFieldName));
VariableBlock numberBlock = ParseTools.ParseBlock <VariableBlock>(node, dfg, parserInfo, id, NUMBER_FIELD_NAME,
new MissingBlockException(id, "Number defining block is missing."));
dfg.AddNode(numberBlock);
return(new RoundOP(numberBlock, parserInfo.GetUniqueAnonymousName(), roundType, id, canBeScheduled));
}
public void SelectWithVariables()
{
IWinformThemeElement variables = new VariableBlock(new[] { new Property("colorOfSky", "Blue") });
IWinformThemeElement selector = new SelectorBlock("Form", new[] { new Property("BackColor", "@colorOfSky") });
var theme = new Theme(new[] { variables, selector });
var form = new TestForm {
BackColor = Color.Black
};
theme.ApplyTheme(form);
Assert.Equal(Color.Blue, form.BackColor);
}
public static Block Parse(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo, bool canBeScheduled)
{
string id = ParseTools.ParseID(node);
string arrayName = ParseTools.ParseString(node, ARRAY_NAME_FIELD_NAME);
parserInfo.CheckVariable(id, VariableType.NUMBER_ARRAY, arrayName);
VariableBlock indexBlock = ParseTools.ParseBlock <VariableBlock>(node, dfg, parserInfo, id, INDEX_FIELD_NAME,
new MissingBlockException(id, "Missing block which define the index into the array."));
dfg.AddNode(indexBlock);
return(new GetArrayNumber(indexBlock, arrayName, parserInfo.GetUniqueAnonymousName(), id, canBeScheduled));
}
public void TestCopyGetArrayNumberBlock()
{
VariableBlock[] blocks = new VariableBlock[2];
blocks[0] = new Constant(10, "a", "", false);
blocks[1] = new GetArrayNumber(blocks[0], "cake", "b", "", true);
int[][] dependencyGraph = new int[][]
{
new int[] { },
new int[] { 0 }
};
CheckCopyMultiBlock(blocks[1], blocks, dependencyGraph);
}
public static Block Parse(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
string arrayName = ParseTools.ParseString(node, ARRAY_NAME_FIELD_NAME);
parserInfo.AddVariable(id, VariableType.NUMBER_ARRAY, arrayName);
VariableBlock arrayLengthBlock = ParseTools.ParseBlock <VariableBlock>(node, dfg, parserInfo, id, ARRAY_LENGTH_FIELD_NAME,
new MissingBlockException(id, "Missing block which define the length of the array."));
dfg.AddNode(arrayLengthBlock);
return(new NumberArray(arrayName, arrayLengthBlock, id));
}
public static Block Parse(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
string output = ParseTools.ParseString(node, VARIABLE_FIELD_NAME);
parserInfo.AddVariable(id, VariableType.NUMBER, output);
VariableBlock operandBlock = ParseTools.ParseBlock <VariableBlock>(node, dfg, parserInfo, id, INPUT_VARIABLE_FIELD_NAME,
new MissingBlockException(id, "Missing block to define the variables value."));
dfg.AddNode(operandBlock);
return(new SetNumberVariable(operandBlock, output, id));
}
public void TestCopyRoundOPBlock()
{
VariableBlock[] blocks = new VariableBlock[2];
blocks[0] = new Constant(10, "a", "", false);
blocks[1] = new RoundOP(blocks[0], "cake", RoundOPTypes.ROUND, "", false);
int[][] dependencyGraph = new int[][]
{
new int[] { },
new int[] { 0 }
};
CheckCopyMultiBlock(blocks[1], blocks, dependencyGraph);
}
public void TestCopyFluidArrayBlock()
{
VariableBlock[] blocks = new VariableBlock[2];
blocks[0] = new Constant(10, "a", "", false);
blocks[1] = new FluidArray("cake", blocks[0], "");
int[][] dependencyGraph = new int[][]
{
new int[] { },
new int[] { 0 }
};
CheckCopyMultiBlock(blocks[1], blocks, dependencyGraph);
}
private InlineProgramInfo GetInlineProgramInfo(XmlNode node, ParserInfo parserInfo)
{
string id = node.GetAttributeValue(Block.ID_FIELD_NAME);
XmlNode mutatorNode = node.TryGetNodeWithName("mutation");
string inputCountString = mutatorNode.TryGetAttributeValue(INPUT_COUNT_ATTRIBUTE_NAME);
string outputCountString = mutatorNode.TryGetAttributeValue(OUTPUT_COUNT_ATTRIBUTE_NAME);
string variableCountString = mutatorNode.TryGetAttributeValue(VARIABLE_COUNT_ATTRIBUTE_NAME);
int inputCount = int.Parse(inputCountString ?? "0");
int outputCunt = int.Parse(outputCountString ?? "0");
int variableCount = int.Parse(variableCountString ?? "0");
if (inputCount != Inputs.Length ||
outputCunt != Outputs.Length ||
variableCount != VariableImports.Length)
{
throw new InternalParseException($"Actual argument count doesn't match expected argument count when loading the program: {ProgramName}");
}
DFG <Block> dfg = new DFG <Block>();
InlineProgramInfo info = new InlineProgramInfo();
for (int i = 0; i < Inputs.Length; i++)
{
XmlNode inputNode = node.GetInnerBlockNode(GetInputFieldName(i), parserInfo, new MissingBlockException(id, $"Input {Inputs[i]} is missing a fluid block."));
if (inputNode != null)
{
FluidInput input = XmlParser.ParseFluidInput(inputNode, dfg, parserInfo);
info.InputsFromTo.Add(Inputs[i], input);
}
}
for (int i = 0; i < Outputs.Length; i++)
{
string toName = node.GetNodeWithAttributeValue(GetOutputFieldName(i)).InnerText;
info.OutputsFromTo.Add(Outputs[i], toName);
}
for (int i = 0; i < VariableImports.Length; i++)
{
XmlNode variableNode = node.GetInnerBlockNode(GetVariableFieldName(i), parserInfo, new MissingBlockException(id, ""));
if (variableNode != null)
{
VariableBlock varBlock = (VariableBlock)XmlParser.ParseBlock(variableNode, dfg, parserInfo, false, false);
info.VariablesFromTo.Add(VariableImports[i], varBlock);
}
}
return(info);
}
public static Block Parse(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo, bool canBeScheduled)
{
string id = ParseTools.ParseID(node);
BoolOPTypes opType = BoolOP.StringToBoolOPType(id, ParseTools.ParseString(node, OPTypeFieldName));
VariableBlock leftBoolBlock = ParseTools.ParseBlock <VariableBlock>(node, dfg, parserInfo, id, LeftBoolFieldName,
new MissingBlockException(id, "Left side of boolean operator is missing a block."));
VariableBlock rightBoolBlock = ParseTools.ParseBlock <VariableBlock>(node, dfg, parserInfo, id, RightBoolFieldName,
new MissingBlockException(id, "Right side of boolean operator is missing a block."));
dfg.AddNode(leftBoolBlock);
dfg.AddNode(rightBoolBlock);
return(new BoolOP(leftBoolBlock, rightBoolBlock, parserInfo.GetUniqueAnonymousName(), opType, id, canBeScheduled));
}
public void TestCopyArithOPBlock()
{
VariableBlock[] blocks = new VariableBlock[3];
blocks[0] = new Constant(10, "a", "", false);
blocks[1] = new Constant(3, "b", "", false);
blocks[2] = new ArithOP(blocks[0], blocks[1], "cake", ArithOPTypes.DIV, "", false);
int[][] dependencyGraph = new int[][]
{
new int[] { },
new int[] { },
new int[] { 0, 1 }
};
CheckCopyMultiBlock(blocks[2], blocks, dependencyGraph);
}
private void UpdateVariables <T>(VariableBlock varBlock, CommandExecutor <T> executor)
{
(string variableName, float value) = varBlock.ExecuteBlock(Variables, executor, FluidVariableLocations);
if (float.IsInfinity(value) || float.IsNaN(value))
{
throw new InvalidNumberException(varBlock.BlockID, value);
}
if (!Variables.ContainsKey(variableName))
{
Variables.Add(variableName, value);
NewVariablesCreatedInThisScope.Add(variableName);
}
else
{
Variables[variableName] = value;
}
}
public static Block Parse(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo, bool canBeScheduled)
{
string id = ParseTools.ParseID(node);
string arrayName = ParseTools.ParseString(node, ARRAY_NAME_FIELD_NAME);
parserInfo.CheckVariable(id, VariableType.NUMBER_ARRAY, arrayName);
VariableBlock indexBlock = ParseTools.ParseBlock <VariableBlock>(node, dfg, parserInfo, id, INDEX_FIELD_NAME,
new MissingBlockException(id, "Missing block to define the variables value."));
VariableBlock numberInput = ParseTools.ParseBlock <VariableBlock>(node, dfg, parserInfo, id, INPUT_NUMBER_FIELD_NAME,
new MissingBlockException(id, "Mixer is missing input fluid block."));
dfg.AddNode(indexBlock);
dfg.AddNode(numberInput);
return(new SetArrayNumber(indexBlock, numberInput, arrayName, id, canBeScheduled));
}
public If(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo)
{
string id = ParseTools.ParseID(node);
List <Conditional> conditionals = new List <Conditional>();
int IfBlocksCount = 1;
bool hasElse = false;
XmlNode mutatorNode = node.TryGetNodeWithName("mutation");
if (mutatorNode != null)
{
string elseifAttrib = mutatorNode.TryGetAttributeValue("elseif");
if (elseifAttrib != null)
{
IfBlocksCount += int.Parse(elseifAttrib);
}
hasElse = mutatorNode.TryGetAttributeValue("else") != null;
}
DFG <Block> nextDFG = null;
for (int ifCounter = 0; ifCounter < IfBlocksCount; ifCounter++)
{
string exceptionStart = $"{ (ifCounter == 0 ? "If" : "Else if") } statement { (ifCounter == 0 ? String.Empty : $"Number {ifCounter}")}";
VariableBlock decidingBlock = null;
XmlNode ifNode = node.GetInnerBlockNode(GetIfFieldName(ifCounter), parserInfo, new MissingBlockException(id, $"{exceptionStart} is missing its conditional block."));
if (ifNode != null)
{
decidingBlock = (VariableBlock)XmlParser.ParseAndAddNodeToDFG(ifNode, dfg, parserInfo);
}
XmlNode guardedDFGNode = node.GetInnerBlockNode(GetDoFieldName(ifCounter), parserInfo, new MissingBlockException(id, $"{exceptionStart} is missing blocks to execute."));
if (guardedDFGNode != null)
{
DFG <Block> guardedDFG = XmlParser.ParseDFG(guardedDFGNode, parserInfo);
nextDFG = nextDFG ?? XmlParser.ParseNextDFG(node, parserInfo);
conditionals.Add(new Conditional(decidingBlock, guardedDFG, nextDFG));
}
}
public static FluidInput Parse(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo, bool doVariableCheck = true)
{
string id = ParseTools.ParseID(node);
string arrayName = ParseTools.ParseString(node, ARRAY_NAME_FIELD_NAME);
if (doVariableCheck)
{
parserInfo.CheckVariable(id, VariableType.FLUID_ARRAY, arrayName);
}
float amountInML = ParseTools.ParseFloat(node, parserInfo, id, FLUID_AMOUNT_FIELD_NAME);
bool useAllFluid = FluidInput.StringToBool(ParseTools.ParseString(node, USE_ALL_FLUID_FIELD_NAME));
VariableBlock indexBlock = ParseTools.ParseBlock <VariableBlock>(node, dfg, parserInfo, id, INDEX_FIELD_NAME,
new MissingBlockException(id, "Missing block which define the index into the array."));
dfg.AddNode(indexBlock);
return(new GetArrayFluid(indexBlock, arrayName, id, amountInML, useAllFluid));
}
public void ThemeWithInlude()
{
IWinformThemeElement variables = new VariableBlock(new[] { new Property("colorOfSky", "Blue") });
IWinformThemeElement selector = new SelectorBlock("Form", new[] { new Property("BackColor", "@colorOfSky") });
var theme = new Theme(new[] { variables, selector });
var theme2 = new Theme(new[] { new SelectorBlock("Button", new[] { new Property("BackColor", "Yellow") }) });
theme.IncludeThemes.Add(theme2);
var form = new TestForm {
BackColor = Color.Black
};
form.button1.BackColor = Color.Black;
form.button2.BackColor = Color.Black;
theme.ApplyTheme(form);
Assert.Equal(Color.Blue, form.BackColor);
Assert.Equal(Color.Yellow, form.button1.BackColor);
Assert.Equal(Color.Yellow, form.button2.BackColor);
}
