Exemplo n.º 1
0
        public void RebuildList(bool overrideIncludeRoot = false)
        {
            this.RemoveAllHandlers();

            // Build the list from scratch - add the rootItem and its handlers, and then all the children if any.
            this.excludedRootItem = null;
            this.itemList.Clear();
            ObservableTreeNode rootItem = _rootNode;

            if (rootItem != null)
            {
                this.AddHandlers(rootItem);

                if (this.includeRoot && !overrideIncludeRoot)
                {
                    this.itemList.Add(rootItem);
                }
                else
                {
                    this.excludedRootItem = rootItem;
                }

                // if not including the root, always expand
                if (rootItem.IsExpanded || !this.includeRoot)
                {
                    // if we're including the root in the list, we want to start
                    // inserting children after it (so index 1, root is in 0);
                    // if no root, start adding children at the beginning of the list
                    int index = this.includeRoot ? 1 : 0;
                    this.InsertChildrenInList(rootItem, ref index);
                }
            }
        }
Exemplo n.º 2
0
        private void SetRootNode(VariableViewModel evaluation)
        {
            _rootNode = new ObservableTreeNode(
                new VariableNode(_settings, evaluation),
                Comparer <ITreeNode> .Create(Comparison));

            RootTreeGrid.ItemsSource = new TreeNodeCollection(_rootNode).ItemList;
        }
Exemplo n.º 3
0
        public TreeNodeCollection(
            ObservableTreeNode rootNode,
            bool includeRoot = false)
        {
            _rootNode         = rootNode;
            this.itemList     = new ObservableCollection <ObservableTreeNode>();
            this.readonlyList = new ReadOnlyObservableCollection <ObservableTreeNode>(this.itemList);
            this.includeRoot  = includeRoot;
            this.RebuildList();

            // Expand root node always
            _rootNode.IsExpanded = true;
        }
Exemplo n.º 4
0
        private void RemoveChildrenFromList(ObservableTreeNode parentItem)
        {
            int startIndex = this.itemList.IndexOf(parentItem) + 1;
            int endIndex   = startIndex;

            while (endIndex < this.itemList.Count && this.itemList[endIndex].Depth > parentItem.Depth)
            {
                ++endIndex;
            }
            for (int i = endIndex - 1; i >= startIndex; --i)
            {
                this.RemoveHandlers(this.itemList[i]);
                this.itemList.RemoveAt(i);
            }
        }
Exemplo n.º 5
0
 private void InsertChildrenInList(ObservableTreeNode parentItem, ref int index)
 {
     foreach (var childItem in parentItem.Children)
     {
         if (childItem.IsVisible)
         {
             this.AddHandlers(childItem);
             this.itemList.Insert(index, childItem);
             index++;
             if (childItem.IsExpanded)
             {
                 this.InsertChildrenInList(childItem, ref index);
             }
         }
     }
 }
Exemplo n.º 6
0
        /// <summary>
        /// add a direct child node
        /// </summary>
        /// <param name="newItem">a node to be added</param>
        public void AddChild(ObservableTreeNode newItem)
        {
            if (newItem == null || newItem.Parent != null)
            {
                throw new ArgumentException("Null tree node or a tree with non-null Parent can't be added as a child");
            }

            newItem.Parent = this;

            int insertionIndex = this.Children.BinarySearch(newItem, _comparer);

            if (insertionIndex < 0)
            {
                // BinarySearch returns bitwise complement if not found
                insertionIndex = ~insertionIndex;
            }
            Children.Insert(insertionIndex, newItem);
        }
Exemplo n.º 7
0
        /// <remarks>
        /// Assumes new data (update) and current Children are sorted in same order
        /// </remarks>
        private void UpdateChildren(IReadOnlyList <ITreeNode> update)
        {
            // special case of no update
            if (update == null || update.Count == 0)
            {
                RemoveChildren();
                return;
            }

            var sortedUpdate = update.ToList();

            sortedUpdate.Sort(_modelComparer);

            int srcIndex    = 0;
            int updateIndex = 0;

            while (srcIndex < Children.Count)
            {
                int sameUpdateIndex = -1;
                for (int u = updateIndex; u < sortedUpdate.Count; u++)
                {
                    if (Children[srcIndex].Model.CanUpdateTo(sortedUpdate[u]))
                    {
                        sameUpdateIndex = u;
                        break;
                    }
                }

                if (sameUpdateIndex != -1)
                {
                    int insertIndex = srcIndex;
                    for (int i = updateIndex; i < sameUpdateIndex; i++)
                    {
                        var newItem = new ObservableTreeNode(sortedUpdate[i], _modelComparer);
                        newItem.Parent = this;

                        Children.Insert(insertIndex++, newItem);
                        srcIndex++;
                    }

                    Children[srcIndex].Model = sortedUpdate[sameUpdateIndex];
                    srcIndex++;

                    updateIndex = sameUpdateIndex + 1;
                }
                else
                {
                    RemoveChild(srcIndex);
                }
            }

            if (updateIndex < sortedUpdate.Count)
            {
                Debug.Assert(srcIndex == Children.Count);

                int insertIndex = srcIndex;
                for (int i = updateIndex; i < sortedUpdate.Count; i++)
                {
                    var newItem = new ObservableTreeNode(sortedUpdate[i], _modelComparer);
                    newItem.Parent = this;

                    Children.Insert(insertIndex++, newItem);
                }
            }
        }
Exemplo n.º 8
0
 /// <summary>
 /// remove a direct child node, and all children, of course
 /// </summary>
 /// <param name="index">direct child index</param>
 public void RemoveChild(ObservableTreeNode child)
 {
     child.RemoveChildren();
     Children.Remove(child);
     child.Parent = null;
 }
Exemplo n.º 9
0
 private void RemoveHandlers(ObservableTreeNode treeItem)
 {
     treeItem.PropertyChanged            -= VirtualizingTreeItem_PropertyChanged;
     treeItem.Children.CollectionChanged -= VirtualizingTreeItem_ChildrenCollectionChanged;
 }