/// <summary> /// Get all the children recursive and flattens it into the given list. /// </summary> /// <param name="parent">The parent.</param> /// <param name="listToFill">The list to fill.</param> private void FlattenChildren(Node parent, ref NodeCollection listToFill) { listToFill.Add(parent); foreach (var child in parent.Children) { this.FlattenChildren(child, ref listToFill); } }
/// <summary> /// walk trough every node recursive , and if a node is a control , then initialize it. /// Use this method to query for any required services, and load any non-graphics resources. /// </summary> /// <param name="rootNode">The node where we start to initialize recursive.</param> private void InitializeRecursive(Node rootNode) { var control = rootNode as Control; if (control != null) { control.Manager = this.Manager; control.Initialize(); } // Update children recursively for (var i = 0; i < rootNode.Children.Count; i++) { this.InitializeRecursive(rootNode.Children[i]); } }
/// <summary> /// Utility function to create a default menu. /// </summary> /// <param name="node">The node.</param> private void ConnectEventToButtons(Node node) { var btn = node as MenuItemButton; if (btn != null) { btn.MouseClicked += this.OnButtonClicked; } foreach (var child in node.Children) { this.ConnectEventToButtons(child); } }
/// <summary>Call the UpdateCall on each node recursively /// Called when the game has determined that game logic needs to be processed. /// This might include the management of the game state, the processing of user input, or the updating of simulation data. /// Use this method with game-specific logic.</summary> /// <param name="time">The time used for updating animated objects thanks to time differences.</param> /// <param name="currentNode">The current Node to update.</param> /// <param name="updateIndex">The update Index , used for height calculations.</param> private void UpdateRecursive(GameTime time, Node currentNode, ref int updateIndex) { // Update node var currentControl = currentNode as Control; if (currentControl != null) { if (currentControl.DrawMeAndMyChildren) { // lazy initialization if (currentControl.IsLoaded == false) { Debug.WriteLine("Loading : " + currentControl.Name); if (currentControl.Manager == null) { currentControl.Manager = this.Manager; } currentControl.LoadContent(); currentControl.IsLoaded = true; } // do the monogame version of update currentControl.Update(time); // Set update index, for height calculations updateIndex++; currentControl.State.UpdateIndex = updateIndex; } } // Update children recursively for (var i = 0; i < currentNode.Children.Count; i++) { if (currentControl != null && currentControl.DrawMeAndMyChildren == false) { if (currentNode.Children[i] is Control) { continue; } } this.UpdateRecursive(time, currentNode.Children[i], ref updateIndex); } }
/// <summary>Tells each control to unload content recursive.</summary> /// <param name="currentNode">The current Node to unload.</param> private void UnloadContentRecursive(Node currentNode) { var currentControl = currentNode as Control; if (currentControl != null) { currentControl.UnloadContent(); } // Update children recursively for (var i = 0; i < currentNode.Children.Count; i++) { this.UnloadContentRecursive(currentNode.Children[i]); } }
/// <summary>Draws each node recursive. But does not draw it is not visible. /// Your code now already knows where the draw and how to draw each control , thanks to your update implementation.</summary> /// <param name="gameTime">The game Time. Used by objects to change what they draw , because time is changed.</param> /// <param name="currentNode">The current Node to draw.</param> // ReSharper disable once UnusedParameter.Local private void DrawRecursive(GameTime gameTime, Node currentNode) { // if current node is drawable var currentControl = currentNode as Control; if (currentControl != null) { // and if "me and my children should be drawn" (like tab-sheets) if (currentControl.DrawMeAndMyChildren) { // and if i should be drawn if (currentControl.Config.Visible) { currentControl.DrawMyData(); } } } // and go recursive for (var i = 0; i < currentNode.Children.Count; i++) { var currentChildNode = currentNode.Children[i]; // if currentControl is not null, then we are a Control. // if currentControl is a Control, then maybe we should not draw her or its children if (currentControl != null && currentControl.DrawMeAndMyChildren == false) { if (currentChildNode is Control) { continue; } } // draw my child this.DrawRecursive(gameTime, currentChildNode); } }
/// <summary> /// Gets the given node by name , by crawling recursive trough the tree. /// </summary> /// <param name="node">The node.</param> /// <param name="treeNodeName">Name of the tree node.</param> /// <returns>The tree-node with given name.</returns> /// <exception cref="System.ArgumentNullException">Node can not be null.</exception> public TreeViewNode GetNodeRecursive(Node node, string treeNodeName) { #if DEBUG if (node == null) { throw new ArgumentNullException("node"); } #endif TreeViewNode nodeToReturn = null; foreach (var child in node.Children) { var treeviewchild = child as TreeViewNode; if (treeviewchild != null) { if (treeviewchild.Name.Equals(treeNodeName)) { nodeToReturn = treeviewchild; break; } } var recursedNode = this.GetNodeRecursive(child, treeNodeName); if (recursedNode != null) { return recursedNode; } } return nodeToReturn; }