protected override void OnKeyUp(KeyEventArgs e)
{
base.OnKeyUp(e);
if (!e.Handled)
{
Key key = e.Key;
switch (key)
{
case Key.Left:
case Key.Right:
case Key.Up:
case Key.Down:
case Key.Add:
case Key.Subtract:
case Key.Space:
IEnumerable <TreeViewExItem> items = TreeViewElementFinder.FindAll(ParentTreeView, false);
TreeViewExItem focusedItem = items.FirstOrDefault(x => x.IsFocused);
if (focusedItem != null)
{
focusedItem.BringIntoView(new Rect(1, 1, 1, 1));
}
break;
}
}
}
private void OnDrop(object sender, DragEventArgs e)
{
TreeViewExItem item = GetTreeViewItemUnderMouse(treeViewEx, e.GetPosition(treeViewEx));
if (item == null || item.DropCommand == null)
{
return;
}
string format = null;
foreach (string f in e.Data.GetFormats())
{
if (item.DropCommand.CanExecute(f))
{
format = f;
break;
}
}
if (format == null)
{
return;
}
item.DropCommand.Execute(e.Data.GetData(format));
}
internal static TreeViewExItem FindNext(TreeViewExItem treeViewItem, bool visibleOnly)
{
// find first child
if (treeViewItem.IsExpanded || !visibleOnly)
{
TreeViewExItem item = GetFirstVirtualizedItem(treeViewItem);
if (item != null)
{
if (item.IsEnabled)
{
if (visibleOnly && !item.IsVisible)
return FindNext(item, visibleOnly);
else
return item;
}
else
{
return FindNext(item, visibleOnly);
}
}
}
// find next sibling
TreeViewExItem sibling = FindNextSiblingRecursive(treeViewItem) as TreeViewExItem;
if (sibling == null)
return null;
if (!visibleOnly || sibling.IsVisible)
return sibling;
return null;
}
internal static TreeViewExItem FindNext(TreeViewExItem treeViewItem, bool ignoreInvisible)
{
// find first child
if (treeViewItem.IsExpanded)
{
TreeViewExItem item = treeViewItem.ItemContainerGenerator.ContainerFromIndex(0) as TreeViewExItem;
if (item != null)
{
if (item.IsEnabled)
{
if (ignoreInvisible && item.Visibility != Windows.Visibility.Visible)
{
return FindNext(item, ignoreInvisible);
}
return item;
}
else
{
return FindNext(item, ignoreInvisible);
}
}
}
// find next sibling
TreeViewExItem sibling = FindNextSiblingRecursive(treeViewItem) as TreeViewExItem;
if (sibling != null && !(ignoreInvisible && sibling.Visibility != Windows.Visibility.Visible))
{
return sibling;
}
return null;
}
public void BringIntoView(object item)
{
UpdateLayout();
TreeViewExItem tvei = GetTreeViewItemFor(item);
tvei.BringIntoView();
}
internal override void OnMouseDown(MouseButtonEventArgs e)
{
base.OnMouseDown(e);
TreeViewExItem item = GetTreeViewItemUnderMouse(e.GetPosition(treeViewEx));
if (item == null)
{
return;
}
if (e.ChangedButton != MouseButton.Left && !(e.ChangedButton == MouseButton.Right && item.ContextMenu != null))
{
return;
}
if (item.IsEditing)
{
return;
}
if (e.ChangedButton == MouseButton.Right && item.ContextMenu != null)
{
return;
}
SelectSingleItem(item);
FocusHelper.Focus(item);
}
/// <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;
}
public void SelectCurrentBySpace()
{
TreeViewExItem item = GetFocusedItem();
SelectSingleItem(item);
FocusHelper.Focus(item);
}
internal static TreeViewExItem FindNext(TreeViewExItem treeViewItem, bool ignoreInvisible)
{
// find first child
if (treeViewItem.IsExpanded)
{
TreeViewExItem item = treeViewItem.ItemContainerGenerator.ContainerFromIndex(0) as TreeViewExItem;
if (item != null)
{
if (item.IsEnabled)
{
if (ignoreInvisible && item.Visibility != Windows.Visibility.Visible)
{
return(FindNext(item, ignoreInvisible));
}
return(item);
}
else
{
return(FindNext(item, ignoreInvisible));
}
}
}
// find next sibling
TreeViewExItem sibling = FindNextSiblingRecursive(treeViewItem) as TreeViewExItem;
if (sibling != null && !(ignoreInvisible && sibling.Visibility != Windows.Visibility.Visible))
{
return(sibling);
}
return(null);
}
internal override void OnMouseDown(MouseButtonEventArgs e)
{
base.OnMouseDown(e);
TreeViewExItem item = GetTreeViewItemUnderMouse(e.GetPosition(treeViewEx));
if (item == null)
{
return;
}
if (e.ChangedButton != MouseButton.Left && !(e.ChangedButton == MouseButton.Right && item.ContextMenu != null))
{
return;
}
if (item.IsEditing)
{
return;
}
// ToggleItem or SelectWithShift
if (IsControlKeyDown || (IsShiftKeyDown))
{
SelectSingleItem(item);
FocusHelper.Focus(item);
return;
}
// begin click
if (selectItem == null)
{
selectItem = item;
selectPosition = e.GetPosition(TreeView);
selectButton = e.ChangedButton;
}
}
private void SelectWithShift(TreeViewExItem item)
{
object firstSelectedItem;
if (lastShiftRoot != null)
{
firstSelectedItem = lastShiftRoot;
}
else
{
if (treeViewEx.SelectedItems.Count > 0)
{
firstSelectedItem = treeViewEx.SelectedItems[0];
}
else
{
firstSelectedItem = null;
}
}
TreeViewExItem shiftRootItem = treeViewEx.GetTreeViewItemsFor(new List <object> {
firstSelectedItem
}).First();
List <object> itemsToSelect = treeViewEx.GetNodesToSelectBetween(shiftRootItem, item).Select(x => x.DataContext).ToList();
List <object> itemsToUnSelect = ((IEnumerable <object>)treeViewEx.SelectedItems).ToList();
ModifySelection(itemsToSelect, itemsToUnSelect);
}
private void SelectWithShift(TreeViewExItem item)
{
object firstSelectedItem;
if (lastShiftRoot != null)
{
firstSelectedItem = lastShiftRoot;
}
else
{
// Get the first item in the SelectedItems that is also bound to the Tree.
firstSelectedItem = treeViewEx.SelectedItems.Cast <object>().FirstOrDefault((x) => { return(treeViewEx.GetTreeViewItemFor(x) != null); });
}
if (firstSelectedItem != null)
{
TreeViewExItem shiftRootItem = treeViewEx.GetTreeViewItemsFor(new List <object> {
firstSelectedItem
}).First();
List <object> itemsToSelect = treeViewEx.GetNodesToSelectBetween(shiftRootItem, item).Select(x => x.DataContext).ToList();
List <object> itemsToUnSelect = treeViewEx.SelectedItems.Cast <object>().ToList();
ModifySelection(itemsToSelect, itemsToUnSelect);
}
else
{ // Fall-back to sigle selection
List <object> itemsToUnSelect = treeViewEx.SelectedItems.Cast <object>().ToList();
if (itemsToUnSelect.Contains(item.DataContext))
{
itemsToUnSelect.Remove(item.DataContext);
}
ModifySelection(item.DataContext, itemsToUnSelect);
}
}
// Synchronizes the value of the child's IsVirtualizing property with that of the parent's
internal static void IsVirtualizingPropagationHelper(DependencyObject parent, DependencyObject element)
{
SynchronizeValue(VirtualizingStackPanel.IsVirtualizingProperty, parent, element);
SynchronizeValue(VirtualizingStackPanel.VirtualizationModeProperty, parent, element);
TreeViewExItem tveItem = element as TreeViewExItem;
//tveItem.IsVirtualizing = (bool)parent.GetValue(VirtualizingStackPanel.IsVirtualizingProperty);
}
private TreeViewExItem GetVisible(TreeViewExItem treeViewExItem)
{
if (treeViewExItem.IsVisible)
{
return(treeViewExItem);
}
return(null);
}
public void StartEditing(TreeViewExItem item)
{
StopEditing(false);
editedItem = item;
editedItem.IsEditingCallbackEnabled = false;
editedItem.IsEditing = true;
editedItem.IsEditingCallbackEnabled = true;
}
private static void InvalidateMeasure(TreeViewExItem child)
{
var itemsPresenter = child.Template.FindName("itemsPresenter", child) as FrameworkElement;
if (itemsPresenter != null)
{
var virtualizingTreePanel = VisualTreeHelper.GetChild(itemsPresenter, 0) as UIElement;
virtualizingTreePanel.InvalidateMeasure();
}
}
internal void StopEditing()
{
if (editedItem == null) return;
Keyboard.Focus(editedItem);
editedItem.IsEditing = false;
FocusHelper.Focus(editedItem);
editedItem = null;
}
public void SelectLast()
{
TreeViewExItem item = TreeViewEx.RecursiveTreeViewItemEnumerable(treeViewEx, false).LastOrDefault();
if (item != null)
{
Select(item);
}
}
private int GetHierarchyLevel()
{
TreeViewExItem treeViewItem = ItemsControl.GetItemsOwner(this) as TreeViewExItem;
if (treeViewItem == null)
{
return(0);
}
return(treeViewItem.hierachyLevel);
}
internal void SelectByRectangle(TreeViewExItem item)
{
if (!treeViewEx.CheckSelectionAllowed(item.DataContext, true))
{
return;
}
treeViewEx.SelectedItems.Add(item.DataContext);
FocusHelper.Focus(item);
item.IsSelected = true;
lastShiftRoot = item.DataContext;
}
private static TreeViewExItem GetFirstVirtualizedItem(TreeViewExItem treeViewItem)
{
for (int i = 0; i < treeViewItem.Items.Count; i++)
{
TreeViewExItem item = treeViewItem.ItemContainerGenerator.ContainerFromIndex(i) as TreeViewExItem;
if (item != null) return item;
}
return null;
}
private void ToggleItem(TreeViewExItem item)
{
if (treeViewEx.SelectedItems.Contains(item.DataContext))
{
ModifySelection(null, item.DataContext);
}
else
{
ModifySelection(item.DataContext, null);
}
}
public void SelectLast()
{
TreeViewExItem item = TreeViewElementFinder.FindLast(treeViewEx, true);
if (item != null)
{
SelectSingleItem(item);
}
FocusHelper.Focus(item);
}
private void ToggleItem(TreeViewExItem item)
{
if (treeViewEx.SelectedItems.Contains(item.DataContext))
{
ModifySelection(null, item.DataContext);
}
else
{
ModifySelection(item.DataContext, null);
}
}
private void AddOrInsertItemToInternalChildren(int itemGeneratorIndex, TreeViewExItem child)
{
if (itemGeneratorIndex >= InternalChildren.Count)
{
base.AddInternalChild(child);
}
else
{
base.InsertInternalChild(itemGeneratorIndex, child);
}
}
internal void StopEditing()
{
if (editedItem == null)
{
return;
}
Keyboard.Focus(editedItem);
editedItem.IsEditing = false;
FocusHelper.Focus(editedItem);
editedItem = null;
}
/// <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);
}
}
private static TreeViewExItem GetFirstVirtualizedItem(TreeViewExItem treeViewItem)
{
for (int i = 0; i < treeViewItem.Items.Count; i++)
{
TreeViewExItem item = treeViewItem.ItemContainerGenerator.ContainerFromIndex(i) as TreeViewExItem;
if (item != null)
{
return(item);
}
}
return(null);
}
internal void UnSelectByRectangle(TreeViewExItem item)
{
if (!treeViewEx.CheckSelectionAllowed(item.DataContext, false))
{
return;
}
treeViewEx.SelectedItems.Remove(item.DataContext);
if (item.DataContext == lastShiftRoot)
{
lastShiftRoot = null;
}
}
/// <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="ignoreInvisible">True if only visible items should be returned.</param>
/// <returns>Returns an enumerable of items.</returns>
internal static IEnumerable <TreeViewExItem> FindAll(TreeViewEx treeView, bool ignoreInvisible)
{
TreeViewExItem currentItem = FindFirst(treeView, ignoreInvisible);
while (currentItem != null)
{
if (GetIsVisible(currentItem))
{
yield return(currentItem);
}
currentItem = FindNext(currentItem, ignoreInvisible);
}
}
public void SelectFromProperty(TreeViewExItem item, bool isSelected)
{
// we do not check if selection is allowed, because selecting on that way is no user action.
// Hopefully the programmer knows what he does...
if (isSelected)
{
treeViewEx.SelectedItems.Add(item.DataContext);
}
else
{
treeViewEx.SelectedItems.Remove(item.DataContext);
}
}
internal IEnumerable <TreeViewExItem> GetNodesToSelectBetween(TreeViewExItem firstNode, TreeViewExItem lastNode)
{
var allNodes = RecursiveTreeViewItemEnumerable(this, false).ToList();
var firstIndex = allNodes.IndexOf(firstNode);
var lastIndex = allNodes.IndexOf(lastNode);
if (firstIndex >= allNodes.Count)
{
throw new InvalidOperationException(
"First node index " + firstIndex + "greater or equal than count " + allNodes.Count + ".");
}
if (lastIndex >= allNodes.Count)
{
throw new InvalidOperationException(
"Last node index " + lastIndex + " greater or equal than count " + allNodes.Count + ".");
}
var nodesToSelect = new List <TreeViewExItem>();
if (lastIndex == firstIndex)
{
return(new List <TreeViewExItem> {
firstNode
});
}
if (lastIndex > firstIndex)
{
for (int i = firstIndex; i <= lastIndex; i++)
{
if (allNodes[i].IsVisible)
{
nodesToSelect.Add(allNodes[i]);
}
}
}
else
{
for (int i = firstIndex; i >= lastIndex; i--)
{
if (allNodes[i].IsVisible)
{
nodesToSelect.Add(allNodes[i]);
}
}
}
return(nodesToSelect);
}
internal TreeViewExItem GetPreviousItem(TreeViewExItem item, List <TreeViewExItem> items)
{
int indexOfCurrent = items.IndexOf(item);
for (int i = indexOfCurrent - 1; i >= 0; i--)
{
if (items[i].IsVisible)
{
return(items[i]);
}
}
return(null);
}
internal TreeViewExItem GetNextItem(TreeViewExItem item, List <TreeViewExItem> items)
{
int indexOfCurrent = items.IndexOf(item);
for (int i = indexOfCurrent + 1; i < items.Count; i++)
{
if (items[i].IsVisible)
{
return(items[i]);
}
}
return(null);
}
private Rect GetPositionOf(TreeViewExItem treeViewItem)
{
FrameworkElement item = (FrameworkElement)treeViewItem.Template.FindName("border", treeViewItem);
if (item == null)
{
throw new InvalidOperationException("Could not get content of item");
}
Point p = item.TransformToAncestor(TreeView).Transform(new Point());
double itemLeft = p.X + TreeView.ScrollViewer.ContentHorizontalOffset;
double itemTop = p.Y + TreeView.ScrollViewer.ContentVerticalOffset;
return(new Rect(itemLeft, itemTop, item.ActualWidth, item.ActualHeight));
}
private Rect GetPositionOf(TreeViewExItem treeViewItem)
{
FrameworkElement item = (FrameworkElement)treeViewItem.Template.FindName("border", treeViewItem);
if (item == null)
{
throw new InvalidOperationException("Could not get content of item");
}
Point p = item.TransformToAncestor(TreeView).Transform(new Point());
double itemLeft = p.X + TreeView.ScrollViewer.ContentHorizontalOffset;
double itemTop = p.Y + TreeView.ScrollViewer.ContentVerticalOffset;
return new Rect(itemLeft, itemTop, item.ActualWidth, item.ActualHeight);
}
internal TreeViewExItem GetPreviousItem(TreeViewExItem item, List<TreeViewExItem> items)
{
int indexOfCurrent = items.IndexOf(item);
for (int i = indexOfCurrent - 1; i >= 0; i--)
{
if (items[i].IsVisible)
{
return items[i];
}
}
return null;
}
internal IEnumerable<TreeViewExItem> GetNodesToSelectBetween(TreeViewExItem firstNode, TreeViewExItem lastNode)
{
var allNodes = TreeViewElementFinder.FindAll(this, false).ToList();
var firstIndex = allNodes.IndexOf(firstNode);
var lastIndex = allNodes.IndexOf(lastNode);
if (firstIndex >= allNodes.Count)
{
throw new InvalidOperationException(
"First node index " + firstIndex + "greater or equal than count " + allNodes.Count + ".");
}
if (lastIndex >= allNodes.Count)
{
throw new InvalidOperationException(
"Last node index " + lastIndex + " greater or equal than count " + allNodes.Count + ".");
}
var nodesToSelect = new List<TreeViewExItem>();
if (lastIndex == firstIndex)
{
return new List<TreeViewExItem> { firstNode };
}
if (lastIndex > firstIndex)
{
for (int i = firstIndex; i <= lastIndex; i++)
{
if (allNodes[i].IsVisible)
{
nodesToSelect.Add(allNodes[i]);
}
}
}
else
{
for (int i = firstIndex; i >= lastIndex; i--)
{
if (allNodes[i].IsVisible)
{
nodesToSelect.Add(allNodes[i]);
}
}
}
return nodesToSelect;
}
internal TreeViewExItem GetNextItem(TreeViewExItem item, List<TreeViewExItem> items)
{
int indexOfCurrent = items.IndexOf(item);
for (int i = indexOfCurrent + 1; i < items.Count; i++)
{
if (items[i].IsVisible)
{
return items[i];
}
}
return null;
}
internal IEnumerable<TreeViewExItem> GetChildren(TreeViewExItem item)
{
if (item == null) yield break;
for (int i = 0; i < item.Items.Count; i++)
{
TreeViewExItem child = item.ItemContainerGenerator.ContainerFromIndex(i) as TreeViewExItem;
if (child != null) yield return child;
}
}
public void SelectFromProperty(TreeViewExItem item, bool isSelected)
{
// we do not check if selection is allowed, because selecting on that way is no user action.
// Hopefully the programmer knows what he does...
if (isSelected)
{
treeViewEx.SelectedItems.Add(item.DataContext);
lastShiftRoot = item.DataContext;
FocusHelper.Focus(item);
}
else
{
treeViewEx.SelectedItems.Remove(item.DataContext);
}
}
private void SelectSingleItem(TreeViewExItem item)
{
if (IsShiftKeyDown && treeViewEx.SelectedItems.Count > 0)
{
SelectWithShift(item);
}
else if (IsControlKeyDown)
{
ToggleItem(item);
}
else
{
List<object> itemsToUnSelect = new List<object>((IEnumerable<object>)treeViewEx.SelectedItems);
if (itemsToUnSelect.Contains(item.DataContext))
{
itemsToUnSelect.Remove(item.DataContext);
}
ModifySelection(item.DataContext, itemsToUnSelect);
}
}
public static void Focus(TreeViewExItem element)
{
// System.Diagnostics.Debug.WriteLine("Focus with helper item: " + element.DataContext);
FocusCore(element);
}
private void AddOrInsertItemToInternalChildren(int itemGeneratorIndex, TreeViewExItem child)
{
if (itemGeneratorIndex >= InternalChildren.Count)
{
base.AddInternalChild(child);
}
else
{
base.InsertInternalChild(itemGeneratorIndex, child);
}
}
public void SelectFromUiAutomation(TreeViewExItem item)
{
SelectSingleItem(item);
FocusHelper.Focus(item);
}
internal void UnSelectByRectangle(TreeViewExItem item)
{
if (!treeViewEx.CheckSelectionAllowed(item.DataContext, false)) return;
treeViewEx.SelectedItems.Remove(item.DataContext);
if (item.DataContext == lastShiftRoot)
{
lastShiftRoot = null;
}
}
private void SelectSingleItem(TreeViewExItem item)
{
// selection with SHIFT is not working in virtualized mode. Thats because the Items are not visible.
// Therefor the children cannot be found/selected.
if (IsShiftKeyDown && treeViewEx.SelectedItems.Count > 0 && !treeViewEx.IsVirtualizing)
{
SelectWithShift(item);
}
else if (IsControlKeyDown)
{
ToggleItem(item);
}
else
{
List<object> itemsToUnSelect = new List<object>((IEnumerable<object>)treeViewEx.SelectedItems);
if (itemsToUnSelect.Contains(item.DataContext))
{
itemsToUnSelect.Remove(item.DataContext);
}
ModifySelection(item.DataContext, itemsToUnSelect);
}
}
private void SelectWithShift(TreeViewExItem item)
{
object firstSelectedItem;
if (lastShiftRoot != null)
{
firstSelectedItem = lastShiftRoot;
}
else
{
if (treeViewEx.SelectedItems.Count > 0)
{
firstSelectedItem = treeViewEx.SelectedItems[0];
}
else
{
firstSelectedItem = null;
}
}
TreeViewExItem shiftRootItem = treeViewEx.GetTreeViewItemsFor(new List<object> { firstSelectedItem }).First();
List<object> itemsToSelect = treeViewEx.GetNodesToSelectBetween(shiftRootItem, item).Select(x => x.DataContext).ToList();
List<object> itemsToUnSelect = ((IEnumerable<object>)treeViewEx.SelectedItems).ToList();
ModifySelection(itemsToSelect, itemsToUnSelect);
}
public void StartEditing(TreeViewExItem item)
{
StopEditing();
editedItem = item;
editedItem.IsEditing = true;
}
private TreeViewExItem GetVisible(TreeViewExItem treeViewExItem)
{
if (treeViewExItem.IsVisible) return treeViewExItem;
return null;
}
private static void InvalidateMeasure(TreeViewExItem child)
{
var itemsPresenter = child.Template.FindName("itemsPresenter", child) as FrameworkElement;
if (itemsPresenter != null)
{
var virtualizingTreePanel = VisualTreeHelper.GetChild(itemsPresenter, 0) as UIElement;
virtualizingTreePanel.InvalidateMeasure();
}
}
public TreeViewExItemAutomationPeer(TreeViewExItem treeViewExItem, TreeViewExAutomationPeer treeViewExAutomationPeer)
{
this.treeViewExItem = treeViewExItem;
this.treeViewExAutomationPeer = treeViewExAutomationPeer;
}
private static bool GetIsVisible(TreeViewExItem currentItem)
{
return currentItem.Visibility == Visibility.Visible;
}
private void Debug(TreeViewExItem item, string message)
{
if (item != null)
{
System.Diagnostics.Debug.Write(String.Format("{0,15}--", item.DataContext));
int indent = GetHierarchyLevel();
for (int i = 0; i < indent; i++)
{
System.Diagnostics.Debug.Write("--");
}
}
else { System.Diagnostics.Debug.Write(" --"); }
System.Diagnostics.Debug.Write(">");
System.Diagnostics.Debug.WriteLine(message);
}
