void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target)
        {
            switch (connectionId)
            {
            case 1:
                this.window = ((BindingWithControllerSample.MainWindow)(target));
                return;

            case 2:
                this.lblUndoStack = ((System.Windows.Controls.Label)(target));
                return;

            case 3:
                this.lblRedoStack = ((System.Windows.Controls.Label)(target));
                return;

            case 4:
                this.leftTree = ((tainicom.TreeViewEx.TreeViewEx)(target));
                return;

            case 5:
                this.rightTree = ((tainicom.TreeViewEx.TreeViewEx)(target));
                return;
            }
            this._contentLoaded = true;
        }
Beispiel #2
0
        void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target)
        {
            switch (connectionId)
            {
            case 1:
                this.@this = ((TreeViewEx.VirtualizationSample.MainWindow)(target));
                return;

            case 2:

            #line 16 "..\..\MainWindow.xaml"
                ((System.Windows.Controls.Button)(target)).Click += new System.Windows.RoutedEventHandler(this.OnLoad);

            #line default
            #line hidden
                return;

            case 3:

            #line 17 "..\..\MainWindow.xaml"
                ((System.Windows.Controls.Button)(target)).Click += new System.Windows.RoutedEventHandler(this.OnClear);

            #line default
            #line hidden
                return;

            case 4:
                this.tree = ((tainicom.TreeViewEx.TreeViewEx)(target));
                return;
            }
            this._contentLoaded = true;
        }
        /// <summary>
        /// Returns all items in tree recursively. If virtualization is enabled, only realized items are returned.
        /// </summary>
        /// <param name="treeView">The tree.</param>
        /// <param name="visibleOnly">True if only visible items should be returned.</param>
        /// <returns>Returns an enumerable of items.</returns>
        internal static IEnumerable <TreeViewExItem> FindAll(TreeViewEx treeView, bool visibleOnly)
        {
            TreeViewExItem currentItem = FindFirst(treeView, visibleOnly);

            while (currentItem != null)
            {
                if (!visibleOnly || currentItem.IsVisible)
                {
                    yield return(currentItem);
                }
                currentItem = FindNext(currentItem, visibleOnly);
            }
        }
Beispiel #4
0
        void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target)
        {
            switch (connectionId)
            {
            case 1:
                this.leftTree = ((tainicom.TreeViewEx.TreeViewEx)(target));

            #line 67 "..\..\MainWindow.xaml"
                this.leftTree.KeyDown += new System.Windows.Input.KeyEventHandler(this.leftTree_KeyDown);

            #line default
            #line hidden
                return;
            }
            this._contentLoaded = true;
        }
        /// <summary>
        /// Returns the last item. If tree is virtualized, it is the last realized item.
        /// </summary>
        /// <param name="treeView">The tree.</param>
        /// <returns>Returns a TreeViewExItem.</returns>
        internal static TreeViewExItem FindLast(TreeViewEx treeView, bool visibleOnly)
        {
            for (int i = treeView.Items.Count - 1; i >= 0; i--)
            {
                var item = treeView.ItemContainerGenerator.ContainerFromIndex(i) as TreeViewExItem;
                if (item == null)
                {
                    continue;
                }
                if (!visibleOnly || item.IsVisible)
                {
                    return(item);
                }
            }

            return(null);
        }
Beispiel #6
0
        // Be sure to call the base class constructor.
        public BorderSelectionAdorner(TreeViewEx treeViewEx)
            : base(treeViewEx)
        {
            this.treeViewEx = treeViewEx;
            this.border     = new Border {
                BorderThickness = new Thickness(1), CornerRadius = new CornerRadius(1), Opacity = 0.5
            };

            Binding brushBinding = new Binding("BorderBrushSelectionRectangle");

            brushBinding.Source = treeViewEx;
            border.SetBinding(Border.BorderBrushProperty, brushBinding);
            Binding backgroundBinding = new Binding("BackgroundSelectionRectangle");

            backgroundBinding.Source = treeViewEx;
            border.SetBinding(Border.BackgroundProperty, backgroundBinding);

            layer = AdornerLayer.GetAdornerLayer(treeViewEx);
            layer.Add(this);
        }
        public void Dispose()
        {
            if (treeView != null)
            {
                treeView.MouseDown -= OnMouseDown;
                treeView.MouseMove -= OnMouseMove;
                treeView.MouseUp   -= OnMouseUp;
                treeView.ScrollViewer.ScrollChanged -= OnScrollChanged;

                treeView = null;
            }

            if (inputSubscribers != null)
            {
                inputSubscribers.Clear();
                inputSubscribers = null;
            }

            GC.SuppressFinalize(this);
        }
Beispiel #8
0
        private static void OnSelectedItemsPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            TreeViewEx treeView = (TreeViewEx)d;

            if (e.OldValue != null)
            {
                INotifyCollectionChanged collection = e.OldValue as INotifyCollectionChanged;
                if (collection != null)
                {
                    collection.CollectionChanged -= treeView.OnSelectedItemsChanged;
                }
            }

            if (e.NewValue != null)
            {
                INotifyCollectionChanged collection = e.NewValue as INotifyCollectionChanged;
                if (collection != null)
                {
                    collection.CollectionChanged += treeView.OnSelectedItemsChanged;
                }
            }
        }
        void System.Windows.Markup.IComponentConnector.Connect(int connectionId, object target)
        {
            switch (connectionId)
            {
            case 1:

            #line 9 "..\..\MainWindow.xaml"
                ((System.Windows.Controls.Grid)(target)).PreviewMouseRightButtonDown += new System.Windows.Input.MouseButtonEventHandler(this.Grid_PreviewMouseRightButtonDown);

            #line default
            #line hidden
                return;

            case 2:
                this.treeviewEx = ((tainicom.TreeViewEx.TreeViewEx)(target));

            #line 20 "..\..\MainWindow.xaml"
                this.treeviewEx.OnSelecting += new System.EventHandler <tainicom.TreeViewEx.SelectionChangedCancelEventArgs>(this.treeviewEx_OnSelecting);

            #line default
            #line hidden
                return;

            case 4:
                this.treeview = ((System.Windows.Controls.TreeView)(target));
                return;

            case 5:

            #line 53 "..\..\MainWindow.xaml"
                ((System.Windows.Controls.Button)(target)).Click += new System.Windows.RoutedEventHandler(this.Button_Click);

            #line default
            #line hidden
                return;
            }
            this._contentLoaded = true;
        }
 public BorderSelectionLogic(TreeViewEx treeView, IEnumerable <TreeViewExItem> items)
 {
     this.items = items;
     TreeView   = treeView;
 }
Beispiel #11
0
 public static void Focus(TreeViewEx element)
 {
     //System.Diagnostics.Debug.WriteLine("Focus Tree with helper");
     FocusCore(element);
 }
Beispiel #12
0
        public SelectionMultiple(TreeViewEx treeViewEx)
        {
            this.treeViewEx = treeViewEx;

            BorderSelectionLogic = new BorderSelectionLogic(treeViewEx, TreeViewElementFinder.FindAll(treeViewEx, false));
        }
 public IsEditingManager(TreeViewEx treeview)
 {
     this.treeview = treeview;
 }
 private void RegisterHeight(TreeViewEx tree, int level, double size)
 {
     cachedSizes.AddOrChange(0, size);
     tree.cachedSizes.AddOrChange(level, size);
 }
        /// <summary>
        /// Measure the children
        /// </summary>
        /// <param name="availableSize">Size available</param>
        /// <returns>Size desired</returns>
        protected override Size MeasureOverride(Size availableSize)
        {
            if (ScrollOwner != null)
            {
                if (ScrollOwner.ScrollableWidth < HorizontalOffset)
                {
                    SetHorizontalOffset(ScrollOwner.ScrollableWidth);
                }
                if (ScrollOwner.ScrollableHeight < VerticalOffset)
                {
                    SetVerticalOffset(ScrollOwner.ScrollableHeight);
                }
            }

            // We need to access InternalChildren before the generator to work around a bug
            UIElementCollection     children     = InternalChildren;
            IItemContainerGenerator generator    = ItemContainerGenerator;
            ItemsControl            itemsControl = ItemsControl.GetItemsOwner(this);
            TreeViewExItem          treeViewItem = itemsControl as TreeViewExItem;
            TreeViewEx treeView = itemsControl as TreeViewEx ?? treeViewItem.ParentTreeView;

            Debug(treeViewItem, "Measuring");
            double maxWidth             = 0;
            double currentYinItemSystem = 0;

            if (treeView.IsVirtualizing)
            {
                // never forget: virtualization of a tree is an approximation. there are some use cases which theoretically work and others
                // we try to get it working by estimations. See GetCachedOrEstimatedHeight for more infos.

                int itemCount             = itemsControl.Items.Count;
                int firstVisibleItemIndex = 0;
                int lastVisibleItemIndex  = itemCount;

                double itemTop;
                if (treeViewItem != null)
                {
                    itemTop = treeViewItem.itemTopInTreeSystem + GetHeightOfHeader(itemsControl);
                }
                else
                {
                    // get the area where items have to be visualized. This is from top to bottom of the visible space in tree system.
                    // We add a little of offset. It seems like it improves estimation of heights.
                    double predictionOffset = 50;
                    double top = VerticalOffset - predictionOffset;
                    if (top < 0)
                    {
                        top = 0;
                    }
                    treeView.realizationSpace.Top    = top;
                    treeView.realizationSpace.Bottom = VerticalOffset + availableSize.Height + predictionOffset;

                    itemTop = GetHeightOfHeader(itemsControl);
                }

                int         itemGeneratorIndex    = 0;
                bool        isPreviousItemVisible = false;
                IDisposable generatorRun          = null;
                currentYinItemSystem = 0;
                int childHierarchyLevel = 0;
                if (treeViewItem != null)
                {
                    childHierarchyLevel = treeViewItem.hierachyLevel + 1;
                }
                try
                {
                    // iterate child items
                    for (int i = 0; i < itemCount; i++)
                    {
                        double       estimatedHeight = GetCachedOrEstimatedHeight(treeView, childHierarchyLevel);
                        VerticalArea childSpace      = new VerticalArea();
                        childSpace.Top    = itemTop + currentYinItemSystem;
                        childSpace.Bottom = childSpace.Top + estimatedHeight;

                        // check if item is possibly visible or could become visible if someone changes expanding of siblings
                        bool isVisibleItem = treeView.realizationSpace.IsWithin(childSpace);

                        if (isVisibleItem)
                        {
                            // we have found a visible item, lets check if its the first visible item.
                            if (!isPreviousItemVisible)
                            {
                                // we found a visible item, lets initialize the visible item section of the loop
                                isPreviousItemVisible = true;
                                firstVisibleItemIndex = i;
                                GeneratorPosition startPos = generator.GeneratorPositionFromIndex(i);
                                itemGeneratorIndex = (startPos.Offset == 0) ? startPos.Index : startPos.Index + 1;
                                generatorRun       = generator.StartAt(startPos, GeneratorDirection.Forward, true);
                            }
                            else
                            {
                                itemGeneratorIndex++;
                            }

                            // Get or create the child
                            bool           newlyRealized;
                            TreeViewExItem child = generator.GenerateNext(out newlyRealized) as TreeViewExItem;
                            Debug(treeViewItem, "Found visible child: " + child.DataContext);

                            if (newlyRealized)
                            {
                                // Figure out if we need to insert the child at the end or somewhere in the middle
                                AddOrInsertItemToInternalChildren(itemGeneratorIndex, child);
                                child.ParentTreeView = treeView;
                                generator.PrepareItemContainer(child);
                            }
                            else
                            {
                                // The child has already been created, let's be sure it's in the right spot
                                if (child != children[itemGeneratorIndex])
                                {
                                    throw new InvalidOperationException("Wrong child was generated");
                                }
                            }

                            if (treeViewItem != null)
                            {
                                child.itemTopInTreeSystem = currentYinItemSystem + itemTop;
                                child.hierachyLevel       = treeViewItem.hierachyLevel + 1;
                            }
                            else
                            {
                                child.itemTopInTreeSystem = currentYinItemSystem;
                                child.hierachyLevel       = 1;
                            }

                            InvalidateMeasure(child);
                            child.Measure(new Size(double.MaxValue, double.MaxValue));

                            // add real height to cache
                            double heightOfChild = child.DesiredSize.Height;
                            RegisterHeight(treeView, childHierarchyLevel, heightOfChild);
                            currentYinItemSystem += child.DesiredSize.Height;
                            // save the maximum needed width
                            maxWidth = Math.Max(maxWidth, child.DesiredSize.Width);
                        }
                        else
                        {
                            //Debug(treeViewItem, "Found invisible child: " + i);
                            if (isPreviousItemVisible)
                            {
                                // set last visible index. this is important, to cleanup not anymore used items
                                lastVisibleItemIndex  = i;
                                isPreviousItemVisible = false;
                            }

                            // dispose generator run. if we do it after the whole loop, we run in multithreading issues
                            if (generatorRun != null)
                            {
                                generatorRun.Dispose();
                                generatorRun = null;
                            }

                            currentYinItemSystem += GetCachedOrEstimatedHeight(treeView, childHierarchyLevel);
                        }
                        //Debug(treeViewItem, "Current y for " + i + ": " + currentYinItemSystem);
                    }
                }
                finally
                {
                    //just for safety
                    if (generatorRun != null)
                    {
                        generatorRun.Dispose();
                        generatorRun = null;
                    }
                }

                //Debug("Cleaning all items but " + firstVisibleItemIndex + " to " + lastVisibleItemIndex + " for element " + itemsControl.DataContext);
                CleanUpItems(firstVisibleItemIndex, lastVisibleItemIndex);
            }
            else
            {
                //Debug("Virtualization is OFF.");
                GeneratorPosition startPos = generator.GeneratorPositionFromIndex(0);
                using (generator.StartAt(startPos, GeneratorDirection.Forward, true))
                {
                    for (int i = (startPos.Offset == 0) ? startPos.Index : startPos.Index + 1; i < itemsControl.Items.Count; i++)
                    {
                        // Get or create the child
                        bool           newlyRealized;
                        TreeViewExItem child = generator.GenerateNext(out newlyRealized) as TreeViewExItem;
                        if (newlyRealized)
                        {
                            // Figure out if we need to insert the child at the end or somewhere in the middle
                            AddOrInsertItemToInternalChildren(i, child);
                            child.ParentTreeView = treeView ?? treeViewItem.ParentTreeView;
                            generator.PrepareItemContainer(child);
                        }

                        child.Measure(new Size(double.MaxValue, double.MaxValue));
                        // now get the real height
                        double height = child.DesiredSize.Height;
                        // add real height to current position
                        currentYinItemSystem += height;
                        // save the maximum needed width
                        maxWidth = Math.Max(maxWidth, child.DesiredSize.Width);
                    }
                }
            }

            if (double.IsPositiveInfinity(maxWidth) || double.IsPositiveInfinity(currentYinItemSystem))
            {
                throw new InvalidOperationException("???");
            }

            Extent   = new Size(maxWidth, currentYinItemSystem);
            Viewport = availableSize;
            Debug(treeViewItem, "Desired height: " + Extent.Height);
            return(Extent);
        }
        /// <summary>
        /// Arrange the children
        /// </summary>
        /// <param name="finalSize">Size available</param>
        /// <returns>Size used</returns>
        protected override Size ArrangeOverride(Size finalSize)
        {
            ItemsControl            itemsControl = ItemsControl.GetItemsOwner(this);
            TreeViewExItem          treeViewItem = itemsControl as TreeViewExItem;
            TreeViewEx              treeView     = itemsControl as TreeViewEx ?? treeViewItem.ParentTreeView;
            IItemContainerGenerator generator    = this.ItemContainerGenerator;

            //Extent = finalSize;
            bool   foundVisibleItem = false;;
            double currentY         = 0;

            if (treeView.IsVirtualizing)
            {
                //Debug("Arrange-" + itemsControl.DataContext);
                for (int i = 0; i < itemsControl.Items.Count; i++)
                {
                    TreeViewExItem child = itemsControl.ItemContainerGenerator.ContainerFromIndex(i) as TreeViewExItem;
                    int            childHierarchyLevel = 0;
                    if (child != null)
                    {
                        childHierarchyLevel = child.hierachyLevel;
                    }

                    if (foundVisibleItem)
                    {
                        if (child == null)
                        {
                            // other items are not visible / virtualized
                            break;
                        }
                    }
                    else
                    {
                        if (child != null)
                        {
                            // found first visible item
                            foundVisibleItem = true;
                        }
                    }

                    if (child != null)
                    {
                        child.Arrange(new Rect(-HorizontalOffset, currentY - VerticalOffset, finalSize.Width, child.DesiredSize.Height));
                        currentY += child.ActualHeight;
                    }
                    else
                    {
                        currentY += GetCachedOrEstimatedHeight(treeView, childHierarchyLevel);
                    }
                }
            }
            else
            {
                for (int i = 0; i < itemsControl.Items.Count; i++)
                {
                    UIElement child = itemsControl.ItemContainerGenerator.ContainerFromIndex(i) as UIElement;

                    if (child != null)
                    {
                        child.Arrange(new Rect(-HorizontalOffset, currentY - VerticalOffset, finalSize.Width, child.DesiredSize.Height));
                    }
                    currentY += child.DesiredSize.Height;
                }
            }

            return(finalSize);
        }