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);
}