protected override void OnAction(BaseNode node, NodeAction action) { switch (action) { case NodeAction.New: FileFolderNode fileFolder = node as FileFolderNode; if (fileFolder != null) { MessageBox.Show(string.Format("New File in group \"{0}\" In Library {1}", fileFolder.Name, fileFolder.GetRoot<LibraryNode>().Name)); } else { MessageBox.Show(string.Format("New Library with default group \"{0}\"", node.GetRootNodeName<GroupsNode>())); } break; case NodeAction.Exclude: case NodeAction.Remove: LibraryNode library = node as LibraryNode; if (library != null) { MessageBox.Show(string.Format("Remove Library {0} from Inventory", library.Name)); } BuildFileNode file = node as BuildFileNode; if (file != null) { MessageBox.Show(string.Format("{0} BuildFile {1} from library {2} from group {3}", action, file.Name, file.GetRoot<LibraryNode>().Name, file.GetRoot<FileFolderNode>().Name)); } break; default: base.OnAction(node, action); break; } }
public override void Add(BaseNode child) { base.Add(child); while(children.Count > 1) { children.RemoveAt(0); } }
public void InitializeConnection(BaseNode _node, DataDirection _direction, VarType _varType, int _num) { node = _node; dataDirection = _direction; varType = _varType; num = _num; }
public void OnProjectChanged(string path, string[] filter) { this.treeViewExplorer.BeginUpdate(); this._model = new TreeModel(); BaseNode rootNode = new BaseNode("UDK"); this._model.Nodes.Add(rootNode); try { PopulateTree(path, rootNode, filter); } catch (Exception e) { ExceptionMessageBox msgBox = new ExceptionMessageBox(e); msgBox.ShowDialog(); } this.treeViewExplorer.Model = _model; this.treeViewExplorer.EndUpdate(); foreach (TreeNodeAdv node in this.treeViewExplorer.Root.Children) { node.Expand(); } }
protected virtual void OnAction(BaseNode node, NodeAction action) { BaseContentInventoryNode contentNode = node as BaseContentInventoryNode; if (contentNode != null) { this.OnWrapperActionEvent(contentNode.Content, action); } }
public override bool CaptureMovedNode(BaseNode node) { this.Children.Add(node); this.Save(); return true; }
public override bool CanCapture(BaseNode node) { if (node.NodeType != Dict.NodeType.WorkFlow && node.NodeType != Dict.NodeType.WorkFlowSet) { return false; } return true; }
public override void Add(BaseNode.BaseNode childNode) { var joinChildNode = (JoinNode) childNode; var parentNode = (JoinNode) ParentNode; if (parentNode.JoinWithParentBy == JoinType.LeftOuterJoin) { joinChildNode.JoinWithParentBy = JoinType.LeftOuterJoin; } base.Add(joinChildNode); }
public void ShowNode(TreeNode treeNode, BaseNode sender) { if (_nodes.Last().Node != null && treeNode.Id == _nodes.Last().Node.Id) return; int idx = _nodes.IndexOf(sender); if (sender != _nodes.Last()) { _nodes.RemoveRange(idx + 1, _nodes.Count - idx - 1); } if (treeNode.IsDirectory) { try{ var node = NodeView.Create(new CGRect(View.Frame.Width, 0, width, View.Frame.Height), this, treeNode.Path, _balkKleur); node.Layer.ZPosition = 10; _nodes.Add(node); Add(node); AnimateViews(); } catch (Exception ex){ Insights.Report(ex); DialogHelper.ShowErrorDialog("Fout", "Er is een fout opgetreden bij het openen van de map.\n" + "Ververs de huidige map en probeer het a.u.b. nogmaals."); } } else { string filePath = string.Empty; InvokeOnMainThread(() => DialogHelper.ShowProgressDialog("Bestand downloaden", "Bezig met het downloaden van een bestand", () => filePath = DataLayer.Instance.GetFilePathSync(treeNode.Path), ()=> { try{ var item = WebItemView.Create(new CGRect(View.Frame.Width, 0, width, View.Frame.Height), this, treeNode, filePath, _balkKleur); item.Layer.ZPosition = 10; _nodes.Add(item); Add(item); AnimateViews(); } catch (Exception ex){ Insights.Report(ex); DialogHelper.ShowErrorDialog("Fout", "Er is een fout opgetreden bij het openen van het bestand." + "\nVervers a.u.b. de map en probeer het opnieuw."); } }) ); } }
public override void CaptureIO(BaseNode node) { if (node.NodeType == Dict.NodeType.WorkFlow) { var wf = node as WorkFlowNode; var oldFile = wf.FullName; var fullName = System.IO.Path.Combine(this.Path, System.IO.Path.GetFileName(wf.FullName)); System.IO.File.Move(oldFile, fullName); } else if (node.NodeType == Dict.NodeType.WorkFlowSet) { var folder = node as FolderNode; var oldFolder = folder.Path; var path = System.IO.Path.Combine(this.Path, folder.Name); System.IO.Directory.Move(oldFolder, path); } }
protected override void OnAction(BaseNode node, NodeAction action) { switch (action) { case NodeAction.New: MessageBox.Show(string.Format("New Library Category with default group \"{0}\"", node.GetRootNodeName<GroupsNode>())); break; case NodeAction.Remove: LibraryCategoryNode libcat = node as LibraryCategoryNode; if (libcat != null) { MessageBox.Show(string.Format("Remove Library Category {0} from Inventory", libcat.Name)); } break; default: base.OnAction(node, action); break; } }
protected override void OnAction(BaseNode node, NodeAction action) { switch (action) { case NodeAction.New: MessageBox.Show(string.Format("New Feature with default group \"{0}\"", node.GetRootNodeName<GroupsNode>())); break; case NodeAction.Remove: FeatureNode feature = node as FeatureNode; if (feature != null) { MessageBox.Show(string.Format("Remove Feature {0} from Inventory", feature.Name)); } break; default: base.OnAction(node, action); break; } }
private List<Object3D> TestConvNode(BaseNode node, float[,] transformation) { List<Object3D> objects = new List<Object3D>(); if (node is TransformNode) { objects.AddRange(WrapTransform((TransformNode)node, transformation)); return objects; } if (node is NavigationInfoNode) { return objects; } if (node is DirectionalLightNode) { return objects; } if (node is ShapeNode) { objects.Add(TestConvShape((ShapeNode)node)); return objects; } return objects; }
protected override void OnAction(BaseNode node, NodeAction action) { switch (action) { case NodeAction.Manage: using (PKStudio.Dialogs.ManageProjectWizard.ManageProjectWizard mManageProjectComponentsWizard = new Dialogs.ManageProjectWizard.ManageProjectWizard()) { ProjectNode PN = node.GetRoot<ProjectNode>(); SolutionNode SN = node.GetRoot<SolutionNode>(); if ((PN != null) && (SN != null)) { mManageProjectComponentsWizard.SetProject(SN.TypedContent, PN.TypedContent); mManageProjectComponentsWizard.ShowDialog(this); } } break; case NodeAction.New: SolutionNode solution = node as SolutionNode; if (solution != null) { //MessageBox.Show(string.Format("Add Project in Solution {0}", solution.Name)); using (PKStudio.Dialogs.ManageProjectWizard.NewProjectWizard mNewProjectWizard = new Dialogs.ManageProjectWizard.NewProjectWizard(solution.TypedContent)) { mNewProjectWizard.ShowDialog(this); } } break; case NodeAction.Remove: ProjectNode project = node as ProjectNode; if (project != null) { MessageBox.Show(string.Format("Remove Project {0} from Solution", project.Name)); } break; default: base.OnAction(node, action); break; } }
public override void Init(Reactor reactor) { base.Init(reactor); if (reactable != null) { #region Edited by PanDenat reactor.AddComponentsIfMissing(reactable); #endregion var root = (React.Root)React.JsonSerializer.Decode(reactable.json); root.PreProcess(gameObject, reactor); importedChild = root.children[0]; #region Log if null if (importedChild == null) { Debug.LogWarning("Imported root: " + root + " \n\n" + "Imported reactable: " + reactable + "\n\n" + "Imported reactable behaviours: " + reactable.behaviourTypes + "\n\n" + "Reactor: " + reactor); Debug.Log(reactable.json); } #endregion } else Debug.LogError("[Import Reactable Node] no reactable to import!\n Reactor.reactable = " + reactor.reactable); }
//process output and input of vars and lists public void PassArgument(BaseNode from, BaseNode to, VarType fromType, VarType outType) { switch (fromType) { case VarType.FloatVar: IOutputVar<float> fromInterface = from as IOutputVar<float>; IInputVar<float> toInterface = to as IInputVar<float>; if(fromInterface != null && toInterface != null){ toInterface.inputVar = fromInterface.outputVar; } break; case VarType.IdWeightVar: IOutputVar<IdWeight> fromIdWeight = from as IOutputVar<IdWeight>; IInputVar<IdWeight> toIdWeight = to as IInputVar<IdWeight>; if(fromIdWeight != null && toIdWeight != null){ toIdWeight.inputVar = fromIdWeight.outputVar; } break; default: break; } }
private IEnumerator<NodeResult> NodeTask(BaseNode endChild = null) { foreach (var child in ActiveChildren()) { if (child == endChild) break; var task = child.GetNodeTask(); while (task.MoveNext()) { var t = task.Current; if (t == NodeResult.Continue) { yield return t; var newTask = NodeTask(child); while (newTask.MoveNext()) { if (newTask.Current == NodeResult.Success) continue; yield return newTask.Current; } } else if (t == NodeResult.Failure) { yield return t; yield break; } else if (t == NodeResult.Success) { break; } } } yield return NodeResult.Success; }
public override void Insert(int index, BaseNode child) { Add (child); }
/// <summary> /// 初期化 /// </summary> /// <param name="node">rootNode</param> public void Initialize(BaseNode node) { _rootNode = node; }
public Pair(XmlNode xmlNode, BaseNode baseNode) { this.xmlNode = xmlNode; this.baseNode = baseNode; }
public SetSelectedNodeArgs(BaseNode Node) { this.Node = Node; this.Result = true; }
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node) { var module = context.Body.Method.Module; if (!string.IsNullOrEmpty(value)) { int x, y; var thickness = value.Split(','); foreach (var thick in thickness) { if (null != NodeILExtensions.GetDPValueSubFix(thick)) { return(null); } } if (int.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) && int.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y)) { return(GenerateIL(module, x, y)); } } throw new XamlParseException($"Cannot convert \"{value}\" into Position2D", node); }
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node) { var module = context.Body.Method.Module; var thickness = value.Split(','); foreach (var thick in thickness) { if (null != NodeILExtensions.GetDPValueSubFix(thick)) { return(null); } } if (3 == thickness.Length) { double x, y, z; if (double.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) && double.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y) && double.TryParse(thickness[2], NumberStyles.Number, CultureInfo.InvariantCulture, out z)) { return(GenerateIL(module, x, y, z)); } } else if (2 == thickness.Length) { double x, y; if (double.TryParse(thickness[0], NumberStyles.Number, CultureInfo.InvariantCulture, out x) && double.TryParse(thickness[1], NumberStyles.Number, CultureInfo.InvariantCulture, out y)) { return(GenerateIL(module, x, y, 0)); } } else if (1 == thickness.Length) { if (value.Contains(".")) { string[] parts = value.Split('.'); if (parts.Length == 2 && (parts[0].Trim() == "ParentOrigin" || parts[0].Trim() == "PivotPoint")) { string position = parts[parts.Length - 1].Trim(); return(ConvertToPoint(position, context, node)); } } else { return(ConvertToPoint(value, context, node)); } } throw new XamlParseException($"Cannot convert \"{value}\" into Position", node); }
public void NewNode(BaseNode node) { m_currentNode = node; m_nodeEvaluator.Evaluate(node, true); }
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node) { var module = context.Body.Method.Module; do { if (string.IsNullOrEmpty(value)) { break; } value = value.Trim(); var parts = value.Split('.'); if (parts.Length == 1 || (parts.Length == 2 && parts [0] == "LayoutOptions")) { var options = parts [parts.Length - 1]; var fieldReference = module.ImportFieldReference(("System.Maui.Core", "System.Maui", "LayoutOptions"), fieldName: options, isStatic: true); if (fieldReference != null) { yield return(Instruction.Create(OpCodes.Ldsfld, fieldReference)); yield break; } } } while (false); throw new XamlParseException(String.Format("Cannot convert \"{0}\" into {1}", value, typeof(LayoutOptions)), node); }
public void LoadNode(BaseNode node) { m_currentNode = node; m_nodeEvaluator.Evaluate(m_currentNode, false); }
public void NewPage(int pageNumber) { m_sceneNodes = m_currentScene.GetNodes(pageNumber); m_currentNode = m_sceneNodes[0]; }
public void JumpToNode(BaseNode node) { m_currentNode = node; m_nodeEvaluator.Evaluate(m_currentNode, true); }
private void addBlockNodes(XmlNodeList list, BaseNode lastNode, BaseNode parentNode) { foreach (XmlNode node in list) { BaseNode newNode = null; if (node.Name.Equals("End")) { newNode = endNode; } else if (node.Name.Equals("Start")) { newNode = startNode; } else if (node.Name.Equals("Assign")) { newNode = new AssignNode(); } else if (node.Name.Equals("Declare")) { newNode = new DeclareNode(); } else if (node.Name.Equals("Input")) { newNode = new InputNode(); } else if (node.Name.Equals("Output")) { newNode = new OutputNode(); } else if (node.Name.Equals("If")) { newNode = new IfNode(); setAttributes(node, newNode); addBlockNodes(node.FirstChild.ChildNodes, ((DecisionNode)newNode).TrueNode, newNode); } else if (node.Name.Equals("IfElse")) { newNode = new IfElseNode(); setAttributes(node, newNode); addBlockNodes(node.FirstChild.ChildNodes, ((IfElseNode)newNode).TrueNode, newNode); addBlockNodes(node.LastChild.ChildNodes, ((IfElseNode)newNode).FalseNode, newNode); } else if (node.Name.Equals("While")) { newNode = new WhileNode(); setAttributes(node, newNode); addBlockNodes(node.FirstChild.ChildNodes, ((DecisionNode)newNode).TrueNode, newNode); } else if (node.Name.Equals("DoWhile")) { newNode = new DoNode(); setAttributes(node, newNode); addBlockNodes(node.FirstChild.ChildNodes, ((DecisionNode)newNode).TrueNode, newNode); } else if (node.Name.Equals("For")) { newNode = new ForNode(); setAttributes(node, newNode); addBlockNodes(node.FirstChild.ChildNodes, ((DecisionNode)newNode).TrueNode, newNode); } else { showErrorMessage("Error not valid file"); } if (!(node.Name.Equals("Start") || node.Name.Equals("End"))) { BaseNode oldNode = lastNode.OutConnector.EndNode; lastNode.OutConnector.EndNode = newNode; newNode.OutConnector.EndNode = oldNode; newNode.addToModel(); newNode.ParentNode = parentNode; } lastNode = newNode; blockNodes.Add(new Pair(node, newNode)); setAttributes(node, newNode); } }
private static void setAttributes(XmlNode node, BaseNode newNode) { string statment = node.Attributes["Statment"]?.InnerText; statment = escapesToRegular(node.Attributes["Statment"]?.InnerText); string location = node.Attributes["Location"]?.InnerText; string[] true_end_location = node.Attributes["True_End_Location"]?.InnerText.Split(','); string[] false_end_location = node.Attributes["False_End_Location"]?.InnerText.Split(','); string[] mid_location = node.Attributes["Mid_Location"]?.InnerText.Split(','); newNode.Statement = statment; if (location != null) { string[] points = location.Split(','); newNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(points[0]), (float)Double.Parse(points[1])); } if (newNode is IfElseNode) { IfElseNode ifElseNode = (IfElseNode)newNode; ifElseNode.BackNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(true_end_location[0]), (float)Double.Parse(true_end_location[1])); ifElseNode.BackfalseNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(false_end_location[0]), (float)Double.Parse(false_end_location[1])); ifElseNode.MiddleNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(mid_location[0]), (float)Double.Parse(mid_location[1])); } else if (newNode is IfNode) { IfNode ifNode = (IfNode)newNode; ifNode.BackNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(true_end_location[0]), (float)Double.Parse(true_end_location[1])); ifNode.MiddleNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(mid_location[0]), (float)Double.Parse(mid_location[1])); } else if (newNode is DecisionNode) { DecisionNode decisionNode = (DecisionNode)newNode; decisionNode.BackNode.NodeLocation = new System.Drawing.PointF((float)Double.Parse(true_end_location[0]), (float)Double.Parse(true_end_location[1])); if (newNode is ForNode) { ForNode forNode = newNode as ForNode; forNode.Var = node.Attributes["Variable"].InnerText; forNode.Direction = node.Attributes["Direction"].InnerText; forNode.StartVal = node.Attributes["StartVal"].InnerText; forNode.EndVal = node.Attributes["EndVal"].InnerText; forNode.StepBy = node.Attributes["StepBy"].InnerText; } } else if (newNode is DeclareNode) { string variable_name = node.Attributes["Variable_Name"].InnerText; string variable_type = node.Attributes["Variable_Type"].InnerText; string single = node.Attributes["Single_Variable"].InnerText; string size = node.Attributes["Size"].InnerText; DeclareNode declareNode = (DeclareNode)newNode; declareNode._Var.VarName = variable_name; declareNode._Var.Size = Int32.Parse(size); declareNode._Var.Single = Boolean.Parse(single); switch (variable_type) { case "INTEGER": declareNode._Var.VarType = DeclareNode.Variable.Data_Type.INTEGER; break; case "REAL": declareNode._Var.VarType = DeclareNode.Variable.Data_Type.REAL; break; case "BOOLEAN": declareNode._Var.VarType = DeclareNode.Variable.Data_Type.BOOLEAN; break; case "STRING": declareNode._Var.VarType = DeclareNode.Variable.Data_Type.STRING; break; } } }
public override void Add(BaseNode child, BaseNode after) { Add (child); }
// Adds a node to its list public void AddNode(BaseNode node) => childNodes.Add(node);
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node) { var module = context.Body.Method.Module; if (string.IsNullOrWhiteSpace(value)) { yield return(Create(Ldnull)); yield break; } yield return(Create(Ldstr, value)); yield return(Create(Ldc_I4_0)); //UriKind.RelativeOrAbsolute yield return(Create(Newobj, module.ImportCtorReference(("System", "System", "Uri"), parameterTypes: new[] {
void OnTriggerEnter(Collider other) { BaseNode.ExecuteNode(node); }
private IEnumerable <Instruction> ConvertToPoint(string value, ILContext context, BaseNode node) { var module = context.Body.Method.Module; switch (value) { case "Top": return(GenerateIL(module, 0.0)); case "Bottom": return(GenerateIL(module, 1.0)); case "Left": return(GenerateIL(module, 0.0)); case "Right": return(GenerateIL(module, 1.0)); case "Middle": return(GenerateIL(module, 0.5)); case "TopLeft": return(GenerateIL(module, 0.0, 0.0, 0.5)); case "TopCenter": return(GenerateIL(module, 0.5, 0.0, 0.5)); case "TopRight": return(GenerateIL(module, 1.0, 0.0, 0.5)); case "CenterLeft": return(GenerateIL(module, 0.0, 0.5, 0.5)); case "Center": return(GenerateIL(module, 0.5, 0.5, 0.5)); case "CenterRight": return(GenerateIL(module, 1.0, 0.5, 0.5)); case "BottomLeft": return(GenerateIL(module, 0.0, 1.0, 0.5)); case "BottomCenter": return(GenerateIL(module, 0.5, 1.0, 0.5)); case "BottomRight": return(GenerateIL(module, 1.0, 1.0, 0.5)); } throw new XamlParseException($"Cannot convert \"{value}\" into Position", node); }
private bool OnSetSelectedNode(object sender, BaseNode component) { SetSelectedNodeArgs args = new SetSelectedNodeArgs(component); if (this.SetSelectedNodeEvent != null) { this.SetSelectedNodeEvent(sender, args); } return args.Result; }
private void NodesChanged_Handler(BaseNode sender) { classes.ForEach(c => c.UpdateOffsets()); }
public ThenComponent(BaseNode node) { _node = node; }
///<summary> ///Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other. ///</summary> ///<returns> ///Value Condition Less than zerox is less than y.Zerox equals y.Greater than zerox is greater than y. ///</returns> ///<param name="y">The second object to compare.</param> ///<param name="x">The first object to compare.</param> public override int Compare(BaseNode.BaseNode x, BaseNode.BaseNode y) { const int hash = 100000000; int xHash = x.EntityType.GetHashCode(); xHash += ((JoinNode) x).JoinWithParentBy == JoinType.InnerJoin ? 0 : hash; int yHash = y.EntityType.GetHashCode(); yHash += ((JoinNode) y).JoinWithParentBy == JoinType.InnerJoin ? 0 : hash; return xHash - yHash; }
private void PopulateTree(string dir, BaseNode root, string[] filter) { DirectoryInfo directory = new DirectoryInfo(dir); foreach (DirectoryInfo d in directory.GetDirectories()) { FolderNode node = new FolderNode(d.Name); node.Folder = d; PopulateTree(d.FullName, node, filter); root.Nodes.Add(node); } foreach (FileInfo f in directory.GetFiles()) { if (filter.Contains(f.Extension)) { FileNode node = new FileNode(f.Name); node.File = f; root.Nodes.Add(node); } } }
protected virtual void OnAction(BaseNode node, NodeAction action) { if (this.NodeActionEvent != null) { this.NodeActionEvent(node, new NodeEventArgs(action)); } }
public IEnumerable <Instruction> ProvideValue(VariableDefinitionReference vardefref, ModuleDefinition module, BaseNode node, ILContext context) { INode valueNode = null; if (!((IElementNode)node).Properties.TryGetValue(new XmlName("", "Value"), out valueNode) && ((IElementNode)node).CollectionItems.Count == 1) { valueNode = ((IElementNode)node).CollectionItems[0]; } if (valueNode == null) { throw new XamlParseException("Missing Value for Setter", (IXmlLineInfo)node); } //if it's an elementNode, there's probably no need to convert it if (valueNode is IElementNode) { yield break; } var value = ((string)((ValueNode)valueNode).Value); var bpNode = ((ValueNode)((IElementNode)node).Properties[new XmlName("", "Property")]); var bpRef = (new BindablePropertyConverter()).GetBindablePropertyFieldReference((string)bpNode.Value, module, bpNode); TypeReference _; var setValueRef = module.ImportReference(module.ImportReference(typeof(Setter)).GetProperty(p => p.Name == "Value", out _).SetMethod); //push the setter yield return(Instruction.Create(OpCodes.Ldloc, vardefref.VariableDefinition)); //push the value foreach (var instruction in ((ValueNode)valueNode).PushConvertedValue(context, bpRef, valueNode.PushServiceProvider(context, bpRef: bpRef), boxValueTypes: true, unboxValueTypes: false)) { yield return(instruction); } //set the value yield return(Instruction.Create(OpCodes.Callvirt, setValueRef)); }
void OnGUI() { Event e = Event.current; mousePos = e.mousePosition; if (e.button == 1 && !makeTransitionMode) { if (e.type == EventType.MouseDown) { 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) { GenericMenu menu = new GenericMenu(); menu.AddItem(new GUIContent("Add Conversation Node"), false, ContextCallback, "conversationNode"); //menu.AddItem(new GUIContent("Add Input Node"), false, ContextCallback, "inputNode"); //menu.AddItem(new GUIContent("Add Output Node"), false, ContextCallback, "outputNode"); //menu.AddItem(new GUIContent("Add Calculation Node"), false, ContextCallback, "calcNode"); //menu.AddItem(new GUIContent("Add Comparison Node"), false, ContextCallback, "compNode"); menu.ShowAsContext(); e.Use(); } else { /* * GenericMenu menu = new GenericMenu(); * menu.AddItem(new GUIContent("Make Transition"), false, ContextCallback, "makeTransition"); * menu.AddSeparator(""); * menu.AddItem(new GUIContent("Delete Node"), false, ContextCallback, "deleteNode"); * * menu.ShowAsContext(); */ e.Use(); } } } /* * else if(e.button == 0 && e.type == EventType.MouseDown && makeTransitionMode) { * * 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 && !windows[selectIndex].Equals(selectednode)) { * * windows[selectIndex].SetInput((BaseInputNode) selectednode, mousePos); * makeTransitionMode = false; * selectednode = null; * * } * * if (!clickedOnWindow) { * makeTransitionMode = false; * selectednode = null; * } * * e.Use (); * * } * * else if(e.button == 0 && e.type == EventType.MouseDown && !makeTransitionMode) { * * 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) { * * BaseInputNode nodeToChange = windows[selectIndex].ClickedOnInput(mousePos); * * if(nodeToChange != null) { * * selectednode = nodeToChange; * makeTransitionMode = true; * * } * * } * * } * * if(makeTransitionMode && selectednode != null) { * * Rect mouseRect = new Rect(e.mousePosition.x, e.mousePosition.y, 10, 10); * * DrawNodeCurve(selectednode.windowRect, mouseRect); * * Repaint(); * * }*/ //GUI.BeginGroup (scrollPosition); foreach (BaseNode n in windows) { if (n != null) { n.DrawCurves(); } } BeginWindows(); for (int i = 0; i < windows.Count; ++i) { BaseNode win = windows [i]; if (win) { windows [i].windowRect = GUI.Window(i, windows [i].windowRect, DrawNodeWindow, windows [i].windowTitle); } } EndWindows(); //GUI.EndGroup (); }
public override Attachment CreateStartCondition(BaseNode owner) { return(Attachment.Create(typeof(PluginBehaviac.Events.StartCondition), owner as Node)); }
IEnumerator GenerateScreenshots() { var t = Resources.Load <Texture>("DocumentationGraph");//.FirstOrDefault(g => { Debug.Log(g); return g is MixtureGraph;}) as MixtureGraph; MixtureGraph docGraph = AssetDatabase.LoadAllAssetsAtPath(AssetDatabase.GetAssetPath(t)).FirstOrDefault(g => g is MixtureGraph) as MixtureGraph; // Setup doc graph properties: docGraph.scale = Vector3.one; docGraph.position = new Vector3(0, toolbarHeight, 0); docGraph.nodes.RemoveAll(n => !(n is OutputNode)); // yield return null; var window = EditorWindow.CreateWindow <MixtureGraphWindow>(); window.Show(); window.Focus(); window.minSize = new Vector2(1024, 1024); window.maxSize = new Vector2(1024, 1024); var nodeViews = new List <BaseNodeView>(); foreach (var node in NodeProvider.GetNodeMenuEntries()) { if (node.Key.Contains("Experimental")) { continue; } // Skip non-mixture nodes: if (!node.Value.FullName.Contains("Mixture")) { continue; } // We'll suport loops after if (node.Value == typeof(ForeachStart) || node.Value == typeof(ForStart)) { continue; } window.InitializeGraph(docGraph); var graphView = window.view; var newNode = BaseNode.CreateFromType(node.Value, new Vector2(0, toolbarHeight)); var nodeView = graphView.AddNode(newNode); nodeViews.Add(nodeView); graphView.Add(nodeView); SetupNodeIfNeeded(nodeView); graphView.MarkDirtyRepaint(); graphView.UpdateViewTransform(new Vector3(0, 0, 0), Vector3.one * graphView.scale); graphView.Focus(); yield return(new WaitForEndOfFrame()); if (window == null) { yield break; } TakeAndSaveNodeScreenshot(window, nodeView); GenerateNodeMarkdownDoc(nodeView); graphView.RemoveNodeView(nodeView); graphView.graph.RemoveNode(nodeView.nodeTarget); graphView.MarkDirtyRepaint(); yield return(new WaitForEndOfFrame()); } nodeViews.Sort((n1, n2) => n1.nodeTarget.name.CompareTo(n2.nodeTarget.name)); GenerateNodeIndexFiles(nodeViews); foreach (var node in docGraph.nodes.ToList()) { if (!(node is OutputNode)) { docGraph.RemoveNode(node); } } window.Close(); }
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node) { var module = context.Body.Method.Module; Color ret = ConvertFromInvariantString(value); if (null == ret) { throw new XamlParseException($"Cannot convert \"{value}\" into {typeof(Color)}", node); } return(GenerateIL(module, ret.r, ret.g, ret.b, ret.a)); }
private void InitRenderingScene() { if (!d3DImage.IsFrontBufferAvailable) return; factory = new SceneGraphFactory(); wpfRenderer = factory.CreateRenderTargetA8R8G8B8Asset(); ///////////////////////////////////////////////////////////// cameraAsset = factory.CreateCamera(); cameraAsset.Perspective(34.0 , (double)RESOLUTION_X / (double)RESOLUTION_Y, Z_NEAR, 0.0); targetRenderer = factory.CreateRenderTargetAsset(); clearTargetBuffer = factory.CreateClearBuffer(); targetRenderer.SetRoot(clearTargetBuffer); clearLayerBuffer = factory.CreateClearBuffer(); wpfRenderer.SetRoot(clearLayerBuffer); TextureLayerNode targetTextureLayer = factory.CreateTextureLayer(targetRenderer); targetTextureLayer.MakeParent(clearLayerBuffer); effectAssetMesh = factory.CreateEffect("Position.DirectX9.obj.fx"); effectAssetMesh.SetValue("Time", 1); ObjMeshAsset objMeshAsset = factory.CreateObjMesh("bigguy_g.obj"); drawMockNode = factory.CreateDrawMock(); drawMockNode.SetMesh(objMeshAsset); drawmockTransformNodeFirst = factory.CreateTransform(); drawmockTransformNodeSecond = factory.CreateTransform(); drawmockTransformNodeFirst.MakeParent(clearTargetBuffer); drawmockTransformNodeSecond.MakeParent(drawmockTransformNodeFirst); drawMockNode.MakeParent(drawmockTransformNodeSecond); /////////////////////////////////////////////// cudaRenderer = factory.CreateCudaRaytraceRenderAsset(); TextureLayerNode cudaTextureLayer = factory.CreateTextureLayer(cudaRenderer); cudaRenderer.SetRoot(drawMockNode); cudaTextureLayer.MakeParent(clearLayerBuffer); cudaRenderer.SetTextureTarget(4, factory.CreateTextureAsset(targetRenderer)); //////////////////////////////////// effectAssetLayer = factory.CreateEffect("TextureLayerWpf.DirectX9.fx"); // set the back buffer using the new scene pointer sceneIntPtr = (IntPtr)wpfRenderer.GetDirect3D9Surface(0); d3DImage.Lock(); d3DImage.SetBackBuffer(D3DResourceType.IDirect3DSurface9, sceneIntPtr); d3DImage.Unlock(); // leverage the Rendering event of WPF's composition target to // update the custom D3D scene CompositionTarget.Rendering += OnRendering; }
public static ICypherFluentQuery MatchQuerry(this ICypherFluentQuery cypher, string varialbeName, BaseNode node) { if (node is Person) { return(cypher.MatchQuerry(varialbeName, (Person)node)); } if (node is Commit) { return(cypher.MatchQuerry(varialbeName, (Commit)node)); } if (node is File) { return(cypher.MatchQuerry(varialbeName, (File)node)); } if (node is AstElement) { return(cypher.MatchQuerry(varialbeName, (AstElement)node)); } if (node is AstElementDeleted) { return(cypher.MatchQuerry(varialbeName, (AstElementDeleted)node)); } string matchClause = "(" + varialbeName + ":" + node.GetType().Name + ")"; if (node.Id > 0) { return(cypher.Match(matchClause).Where(varialbeName + ".Id=" + node.Id)); } throw new NotImplementedException("Needs a specialices MatchQuery for " + node.GetType().Name); }
public void appendChild(BaseNode node) { children.AppendValue(node); node.Parent = this; }
protected override bool CanBeAdoptedBy(BaseNode parent) { return(base.CanBeAdoptedBy(parent) && (parent is Behavior) && (parent.IsFSM || (parent.Children.Count == 0)) && (parent.FSMNodes.Count == 0)); }
public static TypeReference GetTypeReference(string xmlType, ModuleDefinition module, BaseNode node) { var split = xmlType.Split(':'); if (split.Length > 2) { throw new XamlParseException($"Type \"{xmlType}\" is invalid", node as IXmlLineInfo); } string prefix, name; if (split.Length == 2) { prefix = split[0]; name = split[1]; } else { prefix = ""; name = split[0]; } var namespaceuri = node.NamespaceResolver.LookupNamespace(prefix) ?? ""; return(GetTypeReference(new XmlType(namespaceuri, name, null), module, node as IXmlLineInfo)); }
/// <summary> /// Gets the surface at the given point in the world /// </summary> /// <param name="model"></param> /// <param name="baseNode"></param> /// <param name="start"></param> /// <param name="end"></param> /// <returns></returns> public static Face SurfaceAtPoint(Model model, BaseNode baseNode, in Vector3 start, in Vector3 end)
public static void AddQueryableItems(SchemaTree tree, BaseNode node, ContextMenuStrip menu, string memberStem, IEnumerable<string> columnNames) { EventHandler onClick = null; EventHandler handler2 = null; EventHandler handler3 = null; EventHandler handler4 = null; string compQueryBase; bool isVBDefault = UserOptions.Instance.IsVBDefault; QueryLanguage exprLanguage = isVBDefault ? QueryLanguage.VBExpression : QueryLanguage.Expression; string take100Query = memberStem + ".Take (100)"; menu.Items.Add(take100Query, null, (sender, e) => tree.OnNewQuery(new NewQueryArgs(take100Query, new QueryLanguage?(exprLanguage), !memberStem.Contains("...")))); string takeQuery = memberStem + ".Take (" + (UserOptions.Instance.ResultsInGrids ? "1000" : "...") + ")"; menu.Items.Add(takeQuery, null, (sender, e) => tree.OnNewQuery(new NewQueryArgs(takeQuery, new QueryLanguage?(exprLanguage), UserOptions.Instance.ResultsInGrids && !memberStem.Contains("...")))); if (UserOptions.Instance.ResultsInGrids) { string takeBigQuery = memberStem + ".Take (50000)"; menu.Items.Add(takeBigQuery, null, (sender, e) => tree.OnNewQuery(new NewQueryArgs(takeBigQuery, new QueryLanguage?(exprLanguage), !memberStem.Contains("...")))); } string countQuery = memberStem + ".Count()"; menu.Items.Add(countQuery, null, (sender, e) => tree.OnNewQuery(new NewQueryArgs(countQuery, new QueryLanguage?(exprLanguage), !memberStem.Contains("...")))); string iterationVar = memberStem.Substring(0, 1).ToLowerInvariant(); if (!isVBDefault) { string whereQuery = memberStem + ".Where (" + iterationVar + " => "; menu.Items.Add(whereQuery + "...)", null, delegate (object sender, EventArgs e) { NewQueryArgs args = new NewQueryArgs(whereQuery + iterationVar + (memberStem.Contains("...") ? "" : ".…)"), new QueryLanguage?(exprLanguage)) { ListMembers = true }; tree.OnNewQuery(args); }); } if (isVBDefault) { compQueryBase = "From " + iterationVar + " In " + memberStem + " _\nWhere ... _\nSelect "; } else { compQueryBase = "from " + iterationVar + " in " + memberStem + "\nwhere ... \nselect "; } string simpleCompQuery = compQueryBase + iterationVar; menu.Items.Add(simpleCompQuery.Replace("\n", " "), null, delegate (object sender, EventArgs e) { NewQueryArgs args = new NewQueryArgs(simpleCompQuery, new QueryLanguage?(exprLanguage)) { ListMembers = true }; tree.OnNewQuery(args); }); simpleCompQuery = simpleCompQuery.Replace("here ...", "here " + (memberStem.Contains("...") ? "" : (iterationVar + ".…"))); string str = compQueryBase + "new { <all columns> }"; if (!(!columnNames.Any<string>() || isVBDefault)) { menu.Items.Add(str.Replace("\n", " "), null, delegate (object sender, EventArgs e) { StringBuilder builder = new StringBuilder(compQueryBase.Replace("here ...", "here " + (memberStem.Contains("...") ? "" : (iterationVar + ".…"))) + "new\n{\n"); foreach (string str in columnNames) { if (!string.IsNullOrEmpty(str)) { bool flag; string s = (flag = str.Contains("(")) ? Regex.Match(str, @"^\w+", RegexOptions.CultureInvariant).Value : str; string str3 = (!char.IsLower(s, 0) || !CSharpQueryCompiler.IsKeyword(s)) ? "" : "@"; builder.Append("\t"); if (flag) { builder.Append(str3 + s + " = " + iterationVar + "." + str + ",\n"); } else { builder.Append(iterationVar + "." + str3 + str + ",\n"); } } } builder.Remove(builder.Length - 2, 2); builder.Append("\n}"); NewQueryArgs args = new NewQueryArgs(builder.ToString(), new QueryLanguage?(exprLanguage)) { ListMembers = true }; tree.OnNewQuery(args); }); } if (!UserOptions.Instance.ResultsInGrids) { menu.Items.Add("-"); if (onClick == null) { onClick = delegate (object sender, EventArgs e) { NewQueryArgs args = new NewQueryArgs(memberStem + ".Take(100)", new QueryLanguage?(exprLanguage), !memberStem.Contains("...")) { IntoGrids = true }; tree.OnNewQuery(args); }; } menu.Items.Add("Explore top 100 rows in grid", null, onClick); if (handler2 == null) { handler2 = delegate (object sender, EventArgs e) { NewQueryArgs args = new NewQueryArgs(memberStem + ".Take(1000)", new QueryLanguage?(exprLanguage), !memberStem.Contains("...")) { IntoGrids = true }; tree.OnNewQuery(args); }; } menu.Items.Add("Explore top 1000 rows in grid", null, handler2); if (handler3 == null) { handler3 = delegate (object sender, EventArgs e) { NewQueryArgs args = new NewQueryArgs(memberStem + ".Take(50000)", new QueryLanguage?(exprLanguage), !memberStem.Contains("...")) { IntoGrids = true }; tree.OnNewQuery(args); }; } menu.Items.Add("Explore top 50,000 rows in grid", null, handler3); if (handler4 == null) { handler4 = delegate (object sender, EventArgs e) { NewQueryArgs args = new NewQueryArgs(simpleCompQuery, new QueryLanguage?(exprLanguage)) { IntoGrids = true, ListMembers = true }; tree.OnNewQuery(args); }; } menu.Items.Add("Execute LINQ query into data grid", null, handler4); } }
public void SetModel(ITreeModel model, bool expandRoot) { if (_treeView.Model == null) { expandRoot = true; } string selectedTreePath = null; Dictionary <string, bool> collapsing = new Dictionary <string, bool>(); if (this.SelectedNode != null) { selectedTreePath = this.SelectedNode.TreePath; } if (expandRoot == false) { foreach (TreeNodeAdv node in _treeView.AllNodes) { BaseNode tag = node.Tag as BaseNode; if (tag != null) { try { if (node.IsLeaf == false) { collapsing.Add(tag.TreePath, node.IsExpanded); } } catch { } } } } _treeView.Model = model; if (expandRoot) { ExpandRootNode(); } else { TreeNodeAdv selectedNode = null; _treeView.SuspendLayout(); foreach (TreeNodeAdv node in _treeView.AllNodes) { BaseNode tag = node.Tag as BaseNode; if (tag != null) { if (selectedTreePath != null) { if (selectedTreePath == tag.TreePath) { selectedNode = node; } } bool isExpanded; if (collapsing.TryGetValue(tag.TreePath, out isExpanded)) { node.IsExpanded = isExpanded; } } } if (selectedNode != null) { _treeView.SelectedNode = selectedNode; } else { ExpandRootNode(); } _treeView.ResumeLayout(); } }
//process output and input lists of vars and lists (List<T> and List<List<T>>) // the function unboxes the interface of output variables in the output node(outNode) and the interface of input variables // in the input node (inNode). OutType and inType indicate the type of the interface. OutNum and inNum indicates the place // of output and input T and List<T> in case of output or input variables interface is of kind List<T> or List<List<T>> // respectively. public void PassArgument(BaseNode outNode, BaseNode inNode, VarType outType, VarType inType, int outNum, int inNum) { switch (outType) { case VarType.IdWeightList: IOutputList<IdWeight> outIdWeightList = outNode as IOutputList<IdWeight>; IInputList<IdWeight> inIdWeightList = inNode as IInputList<IdWeight>; IInputMultyList<IdWeight> inIdWeightMultyList = inNode as IInputMultyList<IdWeight>; // 1 list out - 1 list in if(inType == VarType.IdWeightList){ if(outIdWeightList != null && inIdWeightList != null){ inIdWeightList.inputList = outIdWeightList.outputList; } } // 1 list out - n lists in if(inType == VarType.IdWeightNestedList){ if(outIdWeightList != null && inIdWeightMultyList != null){ inIdWeightMultyList.inputLists[inNum] = outIdWeightList.outputList; } } break; case VarType.IdWeightNestedList: IOutputMultyList<IdWeight> outIdWeightMultyList = inNode as IOutputMultyList<IdWeight>; inIdWeightList = inNode as IInputList<IdWeight>; inIdWeightMultyList = inNode as IInputMultyList<IdWeight>; // n list out - 1 list in if(inType == VarType.IdWeightList){ if(outIdWeightMultyList != null && inIdWeightList != null){ inIdWeightList.inputList = outIdWeightMultyList.outputLists[outNum]; } } // n list out - n lists in if(inType == VarType.IdWeightNestedList){ if(outIdWeightMultyList != null && inIdWeightMultyList != null){ inIdWeightMultyList.inputLists[inNum] = outIdWeightMultyList.outputLists[outNum]; } } break; default: break; } }
private void _SearchFiles(List<FileInfo> files, BaseNode node, string text) { FileNode fileNode = node as FileNode; FileInfo f = fileNode != null ? fileNode.File as FileInfo : null; if (f != null && f.FullName.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0) { files.Add(f); } foreach (BaseNode child in node.Nodes) { _SearchFiles(files, child, text); } }
public IEnumerable <Instruction> ConvertFromString(string value, ILContext context, BaseNode node) { var module = context.Body.Method.Module; if (IsNullOrEmpty(value)) { throw new XamlParseException($"Cannot convert \"{value}\" into {typeof(Binding)}", node); } var bindingCtor = module.ImportReferenceCached(typeof(Binding)).ResolveCached().Methods.FirstOrDefault(md => md.IsConstructor && md.Parameters.Count == 6); var bindingCtorRef = module.ImportReference(bindingCtor); yield return(Instruction.Create(OpCodes.Ldstr, value)); yield return(Instruction.Create(OpCodes.Ldc_I4, (int)BindingMode.Default)); yield return(Instruction.Create(OpCodes.Ldnull)); yield return(Instruction.Create(OpCodes.Ldnull)); yield return(Instruction.Create(OpCodes.Ldnull)); yield return(Instruction.Create(OpCodes.Ldnull)); yield return(Instruction.Create(OpCodes.Newobj, bindingCtorRef)); }
void TEST_ADD_CODE( ByteCodes btcodes , BaseNode[] nodes ) { for( int i=0;i<nodes.Length;i++){ FunctionNode sn = nodes[ i ] as FunctionNode; if( sn != this && nodes[ i ].enabled ){ Debug.Log( "node:" + nodes[ i ].name ); nodes[ i ].ToByteCode( btcodes ); } // else{ // Debug.Log( "the Node is Me !" ); // } } btcodes.Add( Opcode.STOP ); }
private async Task <bool> InsertNode(BaseNode <T> node, int rowIterator, int columnIterator) { var bubbleButton = new Button() { Style = BubbleStyle(), FontSize = InternalFontSize, Text = node.Data.Description, TextColor = InternalTextColor, HeightRequest = 100, WidthRequest = 100, BorderColor = InternalBorderColor, BorderWidth = InternalBorderWidth, BorderRadius = InternalBorderRadius, BackgroundColor = InternalBackgroundColor, Image = InternalImageSource, ContentLayout = InternalContentLayout, Command = new Command(() => { if (!SelectionModeEnabled) { CurrentSearchFilterNode = node; } else { ((BubbleTree <T>)BindingContext).SelectedItem = node.Data; OnPropertyChanged(nameof(BubbleTree <T> .SelectedItem)); Navigation.PopAsync(); } }) }; if (node is RootNode <T> ) { bubbleButton.FontSize = RootFontSize; bubbleButton.TextColor = RootTextColor; bubbleButton.BorderColor = RootBorderColor; bubbleButton.BorderWidth = RootBorderWidth; bubbleButton.BorderRadius = RootBorderRadius; bubbleButton.BackgroundColor = RootBackgroundColor; bubbleButton.Image = RootImageSource; bubbleButton.ContentLayout = RootContentLayout; } else if (node is LeafNode <T> ) { bubbleButton.FontSize = LeafFontSize; bubbleButton.TextColor = LeafTextColor; bubbleButton.BorderColor = LeafBorderColor; bubbleButton.BorderWidth = LeafBorderWidth; bubbleButton.BorderRadius = LeafBorderRadius; bubbleButton.BackgroundColor = LeafBackgroundColor; bubbleButton.Image = LeafImageSource; bubbleButton.ContentLayout = LeafContentLayout; bubbleButton.Command = new Command(() => { ((BubbleTree <T>)BindingContext).SelectedItem = node.Data; OnPropertyChanged(nameof(BubbleTree <T> .SelectedItem)); Navigation.PopAsync(); }); } BubbleContainer.Children.Add(new Bubble <BaseNode <T>, T>(node, bubbleButton), columnIterator, rowIterator); return(true); }