public void SelectFirst()
{
TreeViewExItem item = TreeViewElementFinder.FindFirst(treeViewEx, true);
if (item != null)
{
SelectSingleItem(item);
}
FocusHelper.Focus(item);
}
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;
}
public void FocusItem(object item, bool bringIntoView = false)
{
MultiSelectTreeViewItem node = GetTreeViewItemsFor(new List <object> {
item
}).FirstOrDefault();
if (node != null)
{
FocusHelper.Focus(node, bringIntoView);
}
}
internal void StopEditing()
{
if (editedItem == null)
{
return;
}
Keyboard.Focus(editedItem);
editedItem.IsEditing = false;
FocusHelper.Focus(editedItem);
editedItem = null;
}
public bool Deselect(MultiSelectTreeViewItem item, bool bringIntoView = false)
{
var e = new PreviewSelectionChangedEventArgs(false, item.DataContext);
OnPreviewSelectionChanged(e);
if (e.CancelAny)
{
return(false);
}
treeView.SelectedItems.Remove(item.DataContext);
FocusHelper.Focus(item, bringIntoView);
return(true);
}
public bool Select(MultiSelectTreeViewItem item)
{
if (treeView.SelectedItems.Count == 1 &&
treeView.SelectedItems[0] == item.DataContext)
{
// Requested to select the single already-selected item. Don't change the selection.
FocusHelper.Focus(item, true);
return(true);
}
else
{
return(SelectCore(item));
}
}
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);
}
}
public void UnSelect(TreeViewExItem item)
{
if (!treeViewEx.CheckSelectionAllowed(item.DataContext, false))
{
return;
}
treeViewEx.SelectedItems.Remove(item.DataContext);
item.IsSelected = false;
if (item.DataContext == lastShiftRoot)
{
lastShiftRoot = null;
}
FocusHelper.Focus(item);
}
internal override void OnMouseUp(MouseButtonEventArgs e)
{
base.OnMouseUp(e);
// click
if (selectItem != null && e.ChangedButton == selectButton)
{
// select item
SelectSingleItem(selectItem);
FocusHelper.Focus(selectItem);
// end click
selectItem = null;
}
}
internal void StopEditing(bool raiseEvent)
{
if (editedItem == null)
{
return;
}
Keyboard.Focus(editedItem);
editedItem.IsEditingCallbackEnabled = false;
editedItem.IsEditing = false;
editedItem.IsEditingCallbackEnabled = true;
FocusHelper.Focus(editedItem);
if (raiseEvent)
{
editedItem.RaiseOnEdited();
}
editedItem = null;
}
public void SelectNextFromKey()
{
TreeViewExItem item = GetFocusedItem();
item = TreeViewElementFinder.FindNext(item, true);
if (item == null)
{
return;
}
// if ctrl is pressed just focus it, so it can be selected by space. Otherwise select it.
if (!IsControlKeyDown)
{
SelectSingleItem(item);
}
FocusHelper.Focus(item);
}
private bool SelectFromKey(MultiSelectTreeViewItem item)
{
if (item == null)
{
return(false);
}
// If Ctrl is pressed just focus it, so it can be selected by Space. Otherwise select it.
if (IsControlKeyDown)
{
FocusHelper.Focus(item, true);
return(true);
}
else
{
return(SelectCore(item));
}
}
public void SelectPreviousFromKey()
{
List <TreeViewExItem> items = TreeViewElementFinder.FindAll(treeViewEx, true).ToList();
TreeViewExItem item = GetFocusedItem();
item = treeViewEx.GetPreviousItem(item, items);
if (item == null)
{
return;
}
// if ctrl is pressed just focus it, so it can be selected by space. Otherwise select it.
if (!IsControlKeyDown)
{
SelectSingleItem(item);
}
FocusHelper.Focus(item);
}
internal override void OnMouseDown(MouseButtonEventArgs e)
{
base.OnMouseDown(e);
if (e.ChangedButton != MouseButton.Left)
{
return;
}
TreeViewExItem item = GetTreeViewItemUnderMouse(e.GetPosition(treeViewEx));
if (item == null || item.IsEditing)
{
return;
}
SelectSingleItem(item);
FocusHelper.Focus(item);
}
public bool SelectCurrentBySpace()
{
var item = GetFocusedItem();
var e = new PreviewSelectionChangedEventArgs(true, item.DataContext);
OnPreviewSelectionChanged(e);
if (e.CancelAny)
{
FocusHelper.Focus(item, true);
return(false);
}
item.IsSelected = true;
if (!treeView.SelectedItems.Contains(item.DataContext))
{
treeView.SelectedItems.Add(item.DataContext);
}
FocusHelper.Focus(item, true);
return(true);
}
internal override void OnMouseUp(MouseButtonEventArgs e)
{
base.OnMouseUp(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;
}
SelectSingleItem(item);
FocusHelper.Focus(item);
}
public void SelectPreviousFromKey()
{
List <TreeViewExItem> items = TreeViewEx.RecursiveTreeViewItemEnumerable(treeViewEx, true).ToList();
TreeViewExItem item;
TreeViewExItem focusedItem = GetFocusedItem();
item = treeViewEx.GetPreviousItem(focusedItem, items);
if (item == null)
{
return;
}
// if ctrl is pressed just focus it, so it can be selected by space. Otherwise select it.
if (IsControlKeyDown)
{
FocusHelper.Focus(item);
}
else
{
SelectCore(item);
}
}
public bool Select(MultiSelectTreeViewItem item)
{
if (IsControlKeyDown)
{
if (treeView.SelectedItems.Contains(item.DataContext))
{
return(Deselect(item, true));
}
else
{
var e = new PreviewSelectionChangedEventArgs(true, item.DataContext);
OnPreviewSelectionChanged(e);
if (e.CancelAny)
{
FocusHelper.Focus(item, true);
return(false);
}
return(SelectCore(item));
}
}
else
{
if (treeView.SelectedItems.Count == 1 &&
treeView.SelectedItems[0] == item.DataContext)
{
// Requested to select the single already-selected item. Don't change the selection.
FocusHelper.Focus(item, true);
lastShiftRoot = item.DataContext;
return(true);
}
else
{
return(SelectCore(item));
}
}
}
public bool SelectCurrentBySpace()
{
// Another item was focused by Ctrl+Arrow key
var item = GetFocusedItem();
if (treeView.SelectedItems.Contains(item.DataContext))
{
// With Ctrl key, toggle this item selection (deselect now).
// Without Ctrl key, always select it (is already selected).
if (IsControlKeyDown)
{
if (!Deselect(item, true))
{
return(false);
}
item.IsSelected = false;
}
}
else
{
var e = new PreviewSelectionChangedEventArgs(true, item.DataContext);
OnPreviewSelectionChanged(e);
if (e.CancelAny)
{
FocusHelper.Focus(item, true);
return(false);
}
item.IsSelected = true;
if (!treeView.SelectedItems.Contains(item.DataContext))
{
treeView.SelectedItems.Add(item.DataContext);
}
}
FocusHelper.Focus(item, true);
return(true);
}
public bool SelectCore(MultiSelectTreeViewItem item)
{
if (IsControlKeyDown)
{
if (!treeView.SelectedItems.Contains(item.DataContext))
{
treeView.SelectedItems.Add(item.DataContext);
}
lastShiftRoot = item.DataContext;
}
else if (IsShiftKeyDown && treeView.SelectedItems.Count > 0)
{
object firstSelectedItem = lastShiftRoot ?? treeView.SelectedItems.First();
MultiSelectTreeViewItem shiftRootItem = treeView.GetTreeViewItemsFor(new List <object> {
firstSelectedItem
}).First();
var newSelection = treeView.GetNodesToSelectBetween(shiftRootItem, item).Select(n => n.DataContext).ToList();
// Make a copy of the list because we're modifying it while enumerating it
var selectedItems = new object[treeView.SelectedItems.Count];
treeView.SelectedItems.CopyTo(selectedItems, 0);
// Remove all items no longer selected
foreach (var selItem in selectedItems.Where(i => !newSelection.Contains(i)))
{
var e = new PreviewSelectionChangedEventArgs(false, selItem);
OnPreviewSelectionChanged(e);
if (e.CancelAll)
{
FocusHelper.Focus(item);
return(false);
}
if (!e.CancelThis)
{
treeView.SelectedItems.Remove(selItem);
}
}
// Add new selected items
foreach (var newItem in newSelection.Where(i => !selectedItems.Contains(i)))
{
var e = new PreviewSelectionChangedEventArgs(true, newItem);
OnPreviewSelectionChanged(e);
if (e.CancelAll)
{
FocusHelper.Focus(item, true);
return(false);
}
if (!e.CancelThis)
{
treeView.SelectedItems.Add(newItem);
}
}
}
else
{
if (treeView.SelectedItems.Count > 0)
{
foreach (var selItem in new ArrayList(treeView.SelectedItems))
{
var e2 = new PreviewSelectionChangedEventArgs(false, selItem);
OnPreviewSelectionChanged(e2);
if (e2.CancelAll)
{
FocusHelper.Focus(item);
lastShiftRoot = item.DataContext;
return(false);
}
if (!e2.CancelThis)
{
treeView.SelectedItems.Remove(selItem);
}
}
}
var e = new PreviewSelectionChangedEventArgs(true, item.DataContext);
OnPreviewSelectionChanged(e);
if (e.CancelAny)
{
FocusHelper.Focus(item, true);
lastShiftRoot = item.DataContext;
return(false);
}
treeView.SelectedItems.Add(item.DataContext);
lastShiftRoot = item.DataContext;
}
FocusHelper.Focus(item, true);
return(true);
}
protected override void OnKeyDown(KeyEventArgs e)
{
base.OnKeyDown(e);
if (!e.Handled)
{
Key key = e.Key;
switch (key)
{
case Key.Left:
if (IsExpanded)
{
IsExpanded = false;
}
e.Handled = true;
break;
case Key.Right:
if (CanExpand)
{
IsExpanded = true;
}
e.Handled = true;
break;
case Key.Up:
ParentTreeView.Selection.SelectPreviousFromKey();
e.Handled = true;
break;
case Key.Down:
ParentTreeView.Selection.SelectNextFromKey();
e.Handled = true;
break;
case Key.Add:
if (CanExpandOnInput && !IsExpanded)
{
IsExpanded = true;
}
e.Handled = true;
break;
case Key.Subtract:
if (CanExpandOnInput && IsExpanded)
{
IsExpanded = false;
}
e.Handled = true;
break;
case Key.F2:
if (ContentTemplateEdit != null && IsFocused && IsEditable)
{
IsEditing = true;
}
e.Handled = true;
break;
case Key.Escape:
StopEditing();
e.Handled = true;
break;
case Key.Return:
FocusHelper.Focus(this);
IsEditing = false;
e.Handled = true;
break;
case Key.Space:
ParentTreeView.Selection.SelectCurrentBySpace();
e.Handled = true;
break;
case Key.Home:
ParentTreeView.Selection.SelectFirst();
e.Handled = true;
break;
case Key.End:
ParentTreeView.Selection.SelectLast();
e.Handled = true;
break;
}
}
}
private void StopEditing()
{
FocusHelper.Focus(this, true);
IsEditing = false;
}
protected override void OnKeyDown(KeyEventArgs e)
{
base.OnKeyDown(e);
if (!e.Handled)
{
Key key = e.Key;
switch (key)
{
case Key.Left:
if (IsExpanded)
{
IsExpanded = false;
}
else
{
ParentTreeView.Selection.SelectParentFromKey();
}
e.Handled = true;
break;
case Key.Right:
if (CanExpand)
{
if (!IsExpanded)
{
IsExpanded = true;
}
else
{
ParentTreeView.Selection.SelectNextFromKey();
}
}
e.Handled = true;
break;
case Key.Up:
ParentTreeView.Selection.SelectPreviousFromKey();
e.Handled = true;
break;
case Key.Down:
ParentTreeView.Selection.SelectNextFromKey();
e.Handled = true;
break;
case Key.Home:
ParentTreeView.Selection.SelectFirstFromKey();
e.Handled = true;
break;
case Key.End:
ParentTreeView.Selection.SelectLastFromKey();
e.Handled = true;
break;
case Key.PageUp:
ParentTreeView.Selection.SelectPageUpFromKey();
e.Handled = true;
break;
case Key.PageDown:
ParentTreeView.Selection.SelectPageDownFromKey();
e.Handled = true;
break;
case Key.A:
if (e.KeyboardDevice.Modifiers == ModifierKeys.Control)
{
ParentTreeView.Selection.SelectAllFromKey();
e.Handled = true;
}
break;
case Key.Add:
if (CanExpandOnInput && !IsExpanded)
{
IsExpanded = true;
}
e.Handled = true;
break;
case Key.Multiply:
if (CanExpandOnInput && !IsExpanded)
{
IsExpanded = true;
ParentTreeView.RecursiveExpand(this);
}
e.Handled = true;
break;
case Key.Subtract:
if (CanExpandOnInput && IsExpanded)
{
IsExpanded = false;
}
e.Handled = true;
break;
case Key.F2:
if (ParentTreeView.AllowEditItems && ContentTemplateEdit != null && IsFocused && IsEditable)
{
IsEditing = true;
e.Handled = true;
}
break;
case Key.Escape:
StopEditing();
e.Handled = true;
break;
case Key.Return:
FocusHelper.Focus(this, true);
IsEditing = false;
e.Handled = true;
break;
case Key.Space:
ParentTreeView.Selection.SelectCurrentBySpace();
e.Handled = true;
break;
}
}
}
public void SelectFromUiAutomation(TreeViewExItem item)
{
SelectSingleItem(item);
FocusHelper.Focus(item);
}
private void OnMouseMove(object sender, MouseEventArgs e)
{
if (mouseDown)
{
if (DateTime.UtcNow > lastScrollTime.AddMilliseconds(100))
{
Point currentPointWin = Mouse.GetPosition(scrollViewer);
if (currentPointWin.Y < 16)
{
scrollViewer.LineUp();
scrollViewer.UpdateLayout();
lastScrollTime = DateTime.UtcNow;
}
if (currentPointWin.Y > scrollViewer.ActualHeight - 16)
{
scrollViewer.LineDown();
scrollViewer.UpdateLayout();
lastScrollTime = DateTime.UtcNow;
}
}
Point currentPoint = Mouse.GetPosition(content);
double width = currentPoint.X - startPoint.X + 1;
double height = currentPoint.Y - startPoint.Y + 1;
double left = startPoint.X;
double top = startPoint.Y;
if (isFirstMove)
{
if (Math.Abs(width) <= SystemParameters.MinimumHorizontalDragDistance &&
Math.Abs(height) <= SystemParameters.MinimumVerticalDragDistance)
{
return;
}
isFirstMove = false;
if (!SelectionMultiple.IsControlKeyDown)
{
if (!treeView.ClearSelectionByRectangle())
{
EndAction();
return;
}
}
}
// Debug.WriteLine(string.Format("Drawing: {0};{1};{2};{3}",startPoint.X,startPoint.Y,width,height));
if (width < 1)
{
width = Math.Abs(width - 1) + 1;
left = startPoint.X - width + 1;
}
if (height < 1)
{
height = Math.Abs(height - 1) + 1;
top = startPoint.Y - height + 1;
}
border.Width = width;
Canvas.SetLeft(border, left);
border.Height = height;
Canvas.SetTop(border, top);
border.Visibility = Visibility.Visible;
double right = left + width - 1;
double bottom = top + height - 1;
// Debug.WriteLine(string.Format("left:{1};right:{2};top:{3};bottom:{4}", null, left, right, top, bottom));
SelectionMultiple selection = (SelectionMultiple)treeView.Selection;
bool foundFocusItem = false;
foreach (var item in items)
{
FrameworkElement itemContent = (FrameworkElement)item.Template.FindName("PART_Header", item);
if (itemContent == null)
{
continue;
}
Point p = ((FrameworkElement)itemContent.Parent).TransformToAncestor(content).Transform(new Point());
double itemLeft = p.X;
double itemRight = p.X + itemContent.ActualWidth - 1;
double itemTop = p.Y;
double itemBottom = p.Y + itemContent.ActualHeight - 1;
// Debug.WriteLine(string.Format("element:{0};itemleft:{1};itemright:{2};itemtop:{3};itembottom:{4}",item.DataContext,itemLeft,itemRight,itemTop,itemBottom));
// Compute the current input states for determining the new selection state of the item
bool intersect = !(itemLeft > right || itemRight <left || itemTop> bottom || itemBottom < top);
bool initialSelected = initialSelection != null && initialSelection.Contains(item.DataContext);
bool ctrl = SelectionMultiple.IsControlKeyDown;
// Decision matrix:
// If the Ctrl key is pressed, each intersected item will be toggled from its initial selection.
// Without the Ctrl key, each intersected item is selected, others are deselected.
//
// newSelected
// ─────────┬───────────────────────
// │ intersect
// │ 0 │ 1
// ├───────────┴───────────
// │ initial
// │ 0 │ 1 │ 0 │ 1
// ─────────┼─────┼─────┼─────┼─────
// ctrl 0 │ 0 │ 0 │ 1 │ 1 = intersect
// ─────────┼─────┼─────┼─────┼─────
// 1 │ 0 │ 1 │ 1 │ 0 = intersect XOR initial
//
bool newSelected = intersect ^ (initialSelected && ctrl);
// The new selection state for this item has been determined. Apply it.
if (newSelected)
{
// The item shall be selected
if (!treeView.SelectedItems.Contains(item.DataContext))
{
// The item is not currently selected. Try to select it.
if (!selection.SelectByRectangle(item))
{
if (selection.LastCancelAll)
{
EndAction();
return;
}
}
}
}
else
{
// The item shall be deselected
if (treeView.SelectedItems.Contains(item.DataContext))
{
// The item is currently selected. Try to deselect it.
if (!selection.DeselectByRectangle(item))
{
if (selection.LastCancelAll)
{
EndAction();
return;
}
}
}
}
// Always focus and bring into view the item under the mouse cursor
if (!foundFocusItem &&
currentPoint.X >= itemLeft && currentPoint.X <= itemRight &&
currentPoint.Y >= itemTop && currentPoint.Y <= itemBottom)
{
FocusHelper.Focus(item, true);
scrollViewer.UpdateLayout();
foundFocusItem = true;
}
}
if (e != null)
{
e.Handled = true;
}
}
}
private void SelectCore(TreeViewExItem item)
{
if (IsControlKeyDown)
{
if (!treeViewEx.CheckSelectionAllowed(item.DataContext, true))
{
return;
}
if (treeViewEx.SelectedItems.Contains(item.DataContext))
{
throw new InvalidOperationException("The item must not be contained.");
}
treeViewEx.SelectedItems.Add(item.DataContext);
item.IsSelected = true;
lastShiftRoot = item.DataContext;
}
else if (IsShiftKeyDown && treeViewEx.SelectedItems.Count > 0)
{
object firstSelectedItem = lastShiftRoot ?? treeViewEx.SelectedItems.First();
TreeViewExItem shiftRootItem = treeViewEx.GetTreeViewItemsFor(new List <object> {
firstSelectedItem
}).First();
IEnumerable <object> items = treeViewEx.GetNodesToSelectBetween(shiftRootItem, item).Select(x => x.DataContext);
IEnumerable <object> itemsToSelect = GetItemsNotInCollection((IEnumerable <object>)treeViewEx.SelectedItems, items);
IEnumerable <object> itemsToUnSelect = GetItemsNotInCollection(items, (IEnumerable <object>)treeViewEx.SelectedItems);
if (!treeViewEx.CheckSelectionAllowed(itemsToSelect, itemsToUnSelect))
{
return;
}
treeViewEx.SelectedItems.Clear();
foreach (var node in TreeViewEx.RecursiveTreeViewItemEnumerable(treeViewEx, false))
{
if (items.Contains(node.DataContext))
{
treeViewEx.SelectedItems.Add(node.DataContext);
node.IsSelected = true;
}
else
{
node.IsSelected = false;
}
}
}
else
{
if (!treeViewEx.CheckSelectionAllowed(item.DataContext, true))
{
return;
}
// check if selection is already item, otherwise set it
if (!(treeViewEx.SelectedItems.Count == 1 && treeViewEx.SelectedItems[0] == item.DataContext))
{
foreach (var treeViewItem in TreeViewEx.RecursiveTreeViewItemEnumerable(treeViewEx, false))
{
treeViewItem.IsSelected = false;
}
treeViewEx.SelectedItems.Clear();
treeViewEx.SelectedItems.Add(item.DataContext);
}
lastShiftRoot = item.DataContext;
}
FocusHelper.Focus(item);
}
