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); }