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; }
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); } }
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); }
// 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); }
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; }
public static void Focus(TreeViewEx element) { //System.Diagnostics.Debug.WriteLine("Focus Tree with helper"); FocusCore(element); }
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); }