private void addRuleItemObjectToToolbox(ruleItemBase newRuleItem, ruleItemInfo itemInfo) { TreeNode newTreeItem = new TreeNode((newRuleItem).ruleName()) { Tag = itemInfo }; // check if rule item is already added. // TODO Strong names foreach(TreeNode n in tvToolbox.Nodes) { if (n.Text == (newRuleItem).ruleName()) return; foreach (TreeNode child in n.Nodes) { if (child.Text == (newRuleItem).ruleName()) return; } } string catName; if (itemInfo.itemType == ruleItemType.RuleItem && itemInfo.ruleItemBaseType.IsDefined(typeof(ToolboxRuleCategoryAttribute), false)) { Object[] attrs = itemInfo.ruleItemBaseType.GetCustomAttributes(typeof(ToolboxRuleCategoryAttribute), false); catName = ((ToolboxRuleCategoryAttribute) attrs[0]).name; } else { catName = ""; } if (itemInfo.itemType == ruleItemType.scriptFile) catName = itemInfo.pythonCategory; if (catName != "") { bool foundIt = false; foreach (TreeNode cat in this.tvToolbox.Nodes) { if (cat.Text == catName) { cat.Nodes.Add(newTreeItem); foundIt = true; break; } } if (!foundIt) { TreeNode daddy = new TreeNode(catName); daddy.Nodes.Add(newTreeItem); this.tvToolbox.Nodes.Add(daddy); } } else { this.tvToolbox.Nodes.Add(newTreeItem); } }
public void addRuleItem(ruleItemInfo info, int x, int y) { // Create our rule item ruleItemBase newRuleItem = this._rule.addRuleItem(info); // add a visual widget for it, and then add it to the visible controls ctlRuleItemWidget newCtl = new ctlRuleItemWidget(newRuleItem, this.setTsStatus); newCtl.Location = new Point(x, y); // this._rule.AddctlRuleItemWidgetToGlobalPool(newCtl); newCtl.snapToGrid = this.snapWidgetsToGrid; this.Controls.Add(newCtl); newCtl.BringToFront(); this.itemWidgets.Add(newCtl); }
public ruleItemBase addRuleItem(ruleItemInfo info) { // Make new ruleItem control of this RuleItem type. ruleItemBase newRuleItem; if (info.itemType == ruleItemType.RuleItem) { // .net ruleItems are loaded via reflection. We find the parameterless // constructor, and then call it. ConstructorInfo constr = info.ruleItemBaseType.GetConstructor(new Type[0]); newRuleItem = (ruleItemBase)constr.Invoke(new object[0] { }); } else if (info.itemType == ruleItemType.scriptFile) { // Script items are loaded by their own constructor, as we need information // at runtime. newRuleItem = new ruleItem_script(info.pythonFileName); } else // This should only happen if a ruleItem is loaded of an unsupported // type - ie, never. throw new Exception("Unrecognised file type"); // Initialise the Pins on the control. This will generate a new guid for each pin. // FIXME: It's kind of messy that we have to do this here. newRuleItem.initPins(); AddRuleItemToGlobalPool(newRuleItem); return newRuleItem; }
private void testSerialisationOfRuleWithNamedRuleItem(Type targetType) { ctlRule ruleControl = new ctlRule(); // Make a new rule with one RuleItem, of the specified type, and one lineChain. ruleItemInfo myInfo = new ruleItemInfo(); myInfo.itemType = ruleItemType.RuleItem; myInfo.ruleItemBaseType = targetType; ruleControl.addRuleItem(myInfo); lineChain newChain = new lineChain(); rule targetRule = ruleControl.getRule(); targetRule.AddLineChainToGlobalPool(newChain); newChain.start.X = 10; newChain.start.Y = 20; newChain.end.X = 11; newChain.end.Y = 22; newChain.col = Color.CornflowerBlue; newChain.isdrawnbackwards = true; newChain.midPoints = new List<Point>(); newChain.midPoints.Add(new Point(33, 44)); // serialise it String serialised = ruleControl.serialiseRule(); // Deserialise it! ctlRule deSerRuleControl = new ctlRule(); deSerRuleControl.deserialiseRule(serialised); Assert.IsTrue(deSerRuleControl.getRule().lineChainCount == 1, "Deserialised rule did not have exactly one lineChain"); Assert.IsTrue(deSerRuleControl.getRule().ruleItemCount == 1, "Deserialised rule did not have exactly one ruleItem"); // Ensure that we can get the lineChain by the same GUID as we had before lineChain deSerLineChain = deSerRuleControl.getRule().GetLineChainFromGuid(newChain.serial); // Get the ruleItem. Note that we don't know its GUID yet so we must find it via its iterator. string ruleGuid = null; foreach (string indexer in deSerRuleControl.getRule().ruleItems.Keys) ruleGuid = indexer; Assert.IsNotNull(ruleGuid); rule deserialisedRule = deSerRuleControl.getRule(); Assert.IsInstanceOfType(deserialisedRule.GetRuleItemFromGuid(new ruleItemGuid(ruleGuid)), targetType, "Deserialised rule did not preserve type of its ruleItem"); Assert.IsTrue(deSerLineChain.start.X == 10); Assert.IsTrue(deSerLineChain.start.Y == 20); Assert.IsTrue(deSerLineChain.end.X == 11); Assert.IsTrue(deSerLineChain.end.Y == 22); Assert.IsTrue(deSerLineChain.col.R == Color.CornflowerBlue.R); Assert.IsTrue(deSerLineChain.col.G == Color.CornflowerBlue.G); Assert.IsTrue(deSerLineChain.col.B == Color.CornflowerBlue.B); Assert.IsFalse(deSerLineChain.isDeleted); Assert.IsTrue(deSerLineChain.isdrawnbackwards); Assert.IsTrue(deSerLineChain.midPoints.Count == 1); Assert.IsTrue(deSerLineChain.midPoints[0].X == 33); Assert.IsTrue(deSerLineChain.midPoints[0].Y == 44); }
public void testSerialisationOfRuleWithTwoRuleItemWithPinsConnected() { rule rule = new rule("test"); lineChain line = new lineChain(); ruleItemInfo myInfo = new ruleItemInfo(); myInfo.itemType = ruleItemType.RuleItem; myInfo.ruleItemBaseType = typeof(ruleItem_and); ruleItemBase andItem = rule.addRuleItem(myInfo); ruleItemGuid andGuid = andItem.serial; ruleItemInfo myInfo2 = new ruleItemInfo(); myInfo2.itemType = ruleItemType.RuleItem; myInfo2.ruleItemBaseType = typeof(ruleItem_desktopMessage); ruleItemBase messageItem = rule.addRuleItem(myInfo2); ruleItemGuid messageGuid = messageItem.serial; messageItem.pinInfo["trigger"].parentRuleItem = messageGuid; messageItem.pinInfo["trigger"].connectTo(line.serial,andItem.pinInfo["output1"]); andItem.pinInfo["output1"].connectTo(line.serial, messageItem.pinInfo["trigger"]); andItem.pinInfo["output1"].parentRuleItem = andGuid; rule.AddLineChainToGlobalPool(line); String serialised = rule.serialise(); rule = rule.deserialise(serialised); Assert.AreEqual("test", rule.name); Assert.AreEqual(1, rule.lineChainCount); Assert.AreEqual(2, rule.ruleItems.Count); andItem = rule.ruleItems[andGuid.id.ToString()]; messageItem = rule.ruleItems[messageGuid.id.ToString()]; Assert.IsInstanceOfType(andItem, typeof(ruleItem_and)); Assert.IsInstanceOfType(messageItem, typeof(ruleItem_desktopMessage)); Assert.AreEqual(1, messageItem.pinInfo.Count); Assert.AreEqual(3, andItem.pinInfo.Count); Assert.AreEqual(line.serial.id.ToString(), messageItem.pinInfo["trigger"].parentLineChain.id.ToString()); Assert.AreEqual(line.serial.id.ToString(), andItem.pinInfo["output1"].parentLineChain.id.ToString()); Assert.AreEqual(andItem.pinInfo["output1"].serial.id.ToString(), messageItem.pinInfo["trigger"].linkedTo.id.ToString()); Assert.AreEqual(messageItem.pinInfo["trigger"].serial.id.ToString(), andItem.pinInfo["output1"].linkedTo.id.ToString()); Assert.AreEqual(typeof(pinDataBool), andItem.pinInfo["output1"].valueType); Assert.AreEqual(typeof(pinDataBool), messageItem.pinInfo["trigger"].valueType) ; }
private ruleItemBase makeRuleItem(ruleItemInfo info) { // Make new ruleItem control of this RuleItem type ruleItemBase newRuleItem; if (info.itemType == ruleItemType.RuleItem) { ConstructorInfo constr = info.ruleItemBaseType.GetConstructor(new Type[0]); newRuleItem = (ruleItemBase)constr.Invoke(new object[0] { }); } else if (info.itemType == ruleItemType.scriptFile) { newRuleItem = new ruleItem_script(info.pythonFileName); } else throw new Exception("eh? Unrecognised file type?"); return newRuleItem; }
/// <summary> /// Spawn a new ruleItem of the described type /// </summary> /// <param name="info">Description of the type to create</param> public void addRuleItem(ruleItemInfo info) { this.addRuleItem(info, 0, 0); }
private void populateToolboxFromPythonFile(string filename) { try { ruleItem_script jake = new ruleItem_script(filename); ruleItemInfo itemInfo = new ruleItemInfo { itemType = ruleItemType.scriptFile, pythonFileName = filename, pythonCategory = jake.getCategory() }; this.addRuleItemObjectToToolbox(jake, itemInfo); } catch (Exception e) { // unable to load this file! MessageBox.Show("Unable to load file '" + filename +"', exception message: '" + e.Message + "'"); } }
private void populateToolboxFromAssembly(Assembly loadThis) { foreach (Module myMod in loadThis.GetModules()) // pull modules out of myAss { foreach (Type thisType in myMod.GetTypes()) // pull types out of the modules { if (thisType.IsDefined(typeof(ToolboxAttri),false)) { try { // Instantiate a new object just so we can pluck the name from it ConstructorInfo constr = thisType.GetConstructor(new Type[0]); Object newRuleItem = constr.Invoke(new object[0]); ruleItemInfo itemInfo = new ruleItemInfo(); itemInfo.itemType = ruleItemType.RuleItem; itemInfo.ruleItemBaseType = thisType; this.addRuleItemObjectToToolbox((ruleItemBase) newRuleItem, itemInfo); } catch (Exception e) { // unable to load this file! MessageBox.Show("Unable to load ruleItem '" + thisType.Name + "' from assembly, exception message: '" + e.Message + "'"); } } } } }