private void LoadAccounts() { var nodes = _accountDirectory.GetRootNodes(); var root = new List <TreeNodeViewModel>(); foreach (var node in nodes) { var vm = node switch { CosmosAccount account => (TreeNodeViewModel)_viewModelFactory.CreateAccountNode( account, _accountContextFactory.Create(account), null), CosmosAccountFolder folder => (TreeNodeViewModel)_viewModelFactory.CreateAccountFolderNode(folder, null), _ => throw new Exception("Invalid node type") }; root.Add(vm); } foreach (var c in root.OrderByDescending(n => n is AccountFolderNodeViewModel) .ThenBy(c => c.Text)) { RootNodes.Add(c); } }
protected override void GenerateTree(object obj) { NewReleaseItem newReleaseItem = (NewReleaseItem) obj; NewReleaseHierarchyNode root = new NewReleaseHierarchyNode(newReleaseItem, this); RootNodes.Add(root); NodeDictionary.Add(root.NewReleaseItem.Album.Name, root); }
/// <summary> /// Adds a map frame as a root node, and links an event handler to update /// when the mapframe triggers an ItemChanged event. /// </summary> /// <param name="mapFrame"></param> public void AddMapFrame(IFrame mapFrame) { mapFrame.IsSelected = true; if (!RootNodes.Contains(mapFrame)) { OnIncludeMapFrame(mapFrame); } RootNodes.Add(mapFrame); RefreshNodes(); }
private void OnRemoveEdge(GraphEdge <T> edge) { edge.Sink.IncomingEdges.Remove(edge); edge.Source.OutgoingEdges.Remove(edge); if (edge.Sink.IsRootNode) { RootNodes.Add(edge.Sink); } if (edge.Source.IsLeafNode) { LeafNodes.Add(edge.Source); } }
private void PopulateTree() { try { var node = new MyNode {Number = 0}; if (_dispatcher.CheckAccess()) RootNodes.Add(node); else _dispatcher.Invoke(() => RootNodes.Add(node)); FillNodeRecursively(node, 1); } catch (Exception e) { Console.WriteLine(e); } }
/// <summary> /// Creates the chain. /// </summary> /// <param name="nodes">The nodes.</param> /// <exception cref="NotSupportedException"></exception> protected void CreateChain(Tree nodes) { foreach (var treeRoot in nodes.Roots) { switch (treeRoot) { case ConstantNode constantElement when treeRoot.Next is FieldNode fieldElement: { if (!(fieldElement.Next is PropertyNode propertyElement)) { continue; } var root = new RootPropertyObserverNode( propertyElement.PropertyInfo, this.OnAction, fieldElement.FieldInfo.GetValue(constantElement.Value)); Looptree(propertyElement, root); RootNodes.Add(root); break; } case ConstantNode constantElement: { if (!(treeRoot.Next is PropertyNode propertyElement)) { continue; } var root = new RootPropertyObserverNode( propertyElement.PropertyInfo, this.OnAction, (INotifyPropertyChanged)constantElement.Value); Looptree(propertyElement, root); RootNodes.Add(root); break; } default: throw new NotSupportedException($"{treeRoot}"); } } }
/// <summary> /// Generates the tree from the root artist. /// </summary> /// <param name="artist"></param> protected override void GenerateTree(object obj) { Artist artist = (Artist)obj; if (NodeDictionary.ContainsKey(artist.Name)) { return; } ArtistViewModel rootViewModel = new ArtistViewModel(artist); ArtistHierarchyNode root = new ArtistHierarchyNode(rootViewModel, this, null, 0); RootNodes.Add(root); NodeDictionary.Add(artist.Name, root); ArtistGroup relatedArtistList = Client.GetRelatedArtists(artist.ID); //First determine which artists are new; add those. List <Artist> newArtists = new List <Artist>(); int nodesAdded = 0; foreach (Artist relatedArtist in relatedArtistList.Artists) { if (NodeDictionary.ContainsKey(relatedArtist.Name)) { continue; } if (nodesAdded < AddChildrenLimit) { newArtists.Add(relatedArtist); ArtistViewModel artistViewModel = new ArtistViewModel(relatedArtist); ArtistHierarchyNode relatedArtistNode = new ArtistHierarchyNode(artistViewModel, this, root, 1); root.Children.Add(relatedArtistNode); NodeDictionary.Add(relatedArtist.Name, relatedArtistNode); nodesAdded++; } else { break; } } }
public Tree_Model() { var n = new LV1 { Value = "A", }; n.Children.Add(new LV2() { Value = "B" }); RootNodes.Add(n); RootNodes.Add(n); RootNodes.Add(n); RootNodes.Add(n); RootNodes.Add(n); }
private void LoadAccounts() { var nodes = _accountDirectory.GetRootNodes(); foreach (var node in nodes) { var vm = node switch { CosmosAccount account => (TreeNodeViewModel)_viewModelFactory.CreateAccountNode( account, _accountContextFactory.Create(account), null), CosmosAccountFolder folder => (TreeNodeViewModel)_viewModelFactory.CreateAccountFolderNode(folder, null), _ => throw new Exception("Invalid node type") }; RootNodes.Add(vm); } }
public bool Add(ITerm <Value> Term, Dictionary <long, RiskItemCharacteristicIDAttributes> CoverageIdAttrMap, Dictionary <string, HashSet <long> > ResolvedSchedule, bool CheckForPerRisk = true) { Subject NodeIdentity = Term.GetSubject(); bool IsAddSuccessful = true; if (NodeIdentity == null) { NodeIdentity = EMPTYSUBJECTCONSTRAINT; } TermCollection TermCollection = (IdentityMap.ContainsKey(NodeIdentity) ? IdentityMap[NodeIdentity].GetContent() : new TermCollection(NodeIdentity)); // Switching off the following check intentionally, in order to allow redundant terms //if (TermCollection.Contains(Term)) // throw new ArgumentException("A term node with the same identity (i.e. subject) already contains this term in its collection!"); IsAddSuccessful = TermCollection.Add(Term); if (IsAddSuccessful && !IdentityMap.ContainsKey(NodeIdentity)) { TermNode _TermNode = new TermNode(TermCollection); IsAddSuccessful &= base.Add(_TermNode); if (IsAddSuccessful) { IdentityMap.Add(NodeIdentity, _TermNode); // A newly added term node (i.e. with no parent or child links) is both a root and a leaf, trivially. IsAddSuccessful &= RootNodes.Add(_TermNode); ExecutionState.RegisterModificationInGraphTopology(); } } return(IsAddSuccessful); }
public void Add(TreeNode item) { RootNodes.Add(item); }
public FeaturesTree(UnitProgressionData progression) { Dictionary <BlueprintScriptableObject, FeatureNode> normalNodes = new(); List <FeatureNode> parametrizedNodes = new(); //Main.Log($"prog: {progression}"); // get nodes (features / race) foreach (var feature in progression.Features.Enumerable) { var name = feature.Name; if (name == null || name.Length == 0) { name = feature.Blueprint.name; } //Main.Log($"feature: {name}"); var source = feature.m_Source; //Main.Log($"source: {source}"); if (feature.Blueprint is BlueprintParametrizedFeature) { parametrizedNodes.Add(new FeatureNode(name, feature.SourceLevel, feature.Blueprint, source)); } else { normalNodes.Add(feature.Blueprint, new FeatureNode(name, feature.SourceLevel, feature.Blueprint, source)); } } // get nodes (classes) foreach (var characterClass in progression.Classes.Select(item => item.CharacterClass)) { normalNodes.Add(characterClass, new FeatureNode(characterClass.Name, 0, characterClass, null)); } // set source selection var selectionNodes = normalNodes.Values .Where(item => item.Blueprint is BlueprintFeatureSelection).ToList(); for (var level = 0; level <= 100; level++) { foreach (var selection in selectionNodes) { foreach (var feature in progression.GetSelections(selection.Blueprint as BlueprintFeatureSelection, level)) { FeatureNode node = default; if (feature is BlueprintParametrizedFeature) { node = parametrizedNodes .FirstOrDefault(item => item.Source != null && item.Source == selection.Source); } if (node != null || normalNodes.TryGetValue(feature, out node)) { node.Source = selection.Blueprint; node.Level = level; } else { // missing child normalNodes.Add(feature, new FeatureNode(string.Empty, level, feature, selection.Blueprint) { IsMissing = true }); } } } } // build tree foreach (var node in normalNodes.Values.Concat(parametrizedNodes).ToList()) { if (node.Source == null) { RootNodes.Add(node); } else if (normalNodes.TryGetValue(node.Source, out var parent)) { parent.ChildNodes.Add(node); } else { // missing parent parent = new FeatureNode(string.Empty, 0, node.Source, null) { IsMissing = true }; parent.ChildNodes.Add(node); normalNodes.Add(parent.Blueprint, parent); RootNodes.Add(parent); } } }
public void AddRoot(MapNode fromNode, MapNode toNode) { if (toNode.Parent != null || !fromNode.Neighbours.Contains(toNode) || RootNodes.Contains(toNode)) { return; } RootNodes.Add(toNode); RootCost = this.CalculateRootCost(); if (fromNode.Children.Count > 0) { RootLines.Add(new List <Vector3>() { fromNode.WorldPosition, toNode.WorldPosition }); } else { var line = RootLines.FirstOrDefault(x => x.Last().Equals(fromNode.WorldPosition)); line.Add(toNode.WorldPosition); var lineStart = line.FirstOrDefault(); // Check for a switch if (lineStart.magnitude > 1) { // Get lines var connectedLines = RootLines.Where(x => x.Contains(lineStart) && x != line).ToList(); foreach (var connectedLine in connectedLines) { // Get the index of var indexOf = connectedLine.IndexOf(lineStart); var remainingLength = connectedLine.Count - indexOf; var remainingLine = connectedLine.Where(x => connectedLine.IndexOf(x) >= indexOf).ToList(); if (indexOf == 0) { continue; } if (line.Count > remainingLength) { // Do the switch connectedLine.RemoveAll(x => connectedLine.IndexOf(x) >= indexOf); connectedLine.AddRange(line); RootLines.Remove(line); RootLines.Add(remainingLine); break; } } } } toNode.Parent = fromNode; fromNode.Children.Add(toNode); toNode.OnConnectionsUpdated?.Invoke(); fromNode.OnConnectionsUpdated?.Invoke(); OnRootNodesUpdated?.Invoke(); }
private void OnAddNode(GraphNode <T> node) { RootNodes.Add(node); LeafNodes.Add(node); }
/// <summary> /// Creates the chain. /// </summary> /// <param name="parameter1">The parameter1.</param> /// <param name="parameter2">The parameter2.</param> /// <param name="nodes">The nodes.</param> /// <exception cref="NotSupportedException"></exception> private void CreateChain(TParameter1 parameter1, TParameter2 parameter2, ITree nodes) { foreach (var treeRoot in nodes.Roots) { switch (treeRoot) { case ParameterNode parameterElement: { if (!(parameterElement.Next is PropertyNode propertyElement)) { continue; } var parameterGetter = ExpressionGetter.CreateParameterGetter( parameterElement, propertyExpression); var root = new RootPropertyObserverNode( propertyElement.PropertyInfo, this.OnAction, (INotifyPropertyChanged)parameterGetter(parameter1, parameter2)); Looptree(propertyElement, root); RootNodes.Add(root); break; } case ConstantNode constantElement when treeRoot.Next is FieldNode fieldElement: { if (!(fieldElement.Next is PropertyNode propertyElement)) { continue; } var root = new RootPropertyObserverNode( propertyElement.PropertyInfo, this.OnAction, (INotifyPropertyChanged)fieldElement.FieldInfo.GetValue(constantElement.Value)); Looptree(propertyElement, root); RootNodes.Add(root); break; } case ConstantNode constantElement: { if (!(treeRoot.Next is PropertyNode propertyElement)) { continue; } var root = new RootPropertyObserverNode( propertyElement.PropertyInfo, this.OnAction, (INotifyPropertyChanged)constantElement.Value); Looptree(propertyElement, root); RootNodes.Add(root); break; } default: throw new NotSupportedException(); } } }