private void AddItemToSelection(MSTreeViewItem newItem) { if (!_selectedItems.Contains(newItem)) { _selectedItems.Add(newItem); } }
void PrevGreaterThan(ItemCollection collection, MSTreeViewItem item) { int index = collection.IndexOf(item.DataContext); if (index < 0) { return; } int prev_item = _selectedItems.IndexOf(item) - 1; if (prev_item < 0) { return; } int prev = collection.IndexOf(_selectedItems[prev_item].DataContext); if (prev < 0) { return; } if (prev > index) { _selectedItems.Remove(item); _selectedItems.Insert(prev_item, item); PrevGreaterThan(collection, item); } }
/* * public MSTreeViewItem GetItemFromData(int i) * { * return (MSTreeViewItem)(this.ItemContainerGenerator.ContainerFromIndex(i)); * } */ private MSTreeViewItem HasSidlingItem(MSTreeViewItem item) { MSTreeViewItem parent = item.GetParentTreeViewItem(); if (parent == null) { return(null); } MSTreeViewItem sidling = null; foreach (var obj in parent.Items) { //object i = GetItemFromData(parent.Items.IndexOf(obj)); // if (obj == null) // continue; MSTreeViewItem i = parent.GetChildItemFromData(obj); if (i != item && i.IsSelected) { sidling = i; break; } } return(sidling); }
/// <summary> /// Recursively select all children. /// </summary> public void SelectAllExpandedChildren() { if (Items != null && Items.Count > 0) { if (this.IsExpanded) { foreach (var item in Items) { if (item is MSTreeViewItem) { ((MSTreeViewItem)item).SelectAllExpandedChildren(); } else { MSTreeViewItem tvItem = this.ItemContainerGenerator.ContainerFromItem(item) as MSTreeViewItem; if (tvItem != null) { tvItem.SelectAllExpandedChildren(); } } } } } if (!this.IsSelected) { this.IsSelected = true; ParentMultipleSelectionTreeView.OnSelectionChanges(this); } }
private void RemoveItemFromSelection(MSTreeViewItem newItem) { if (_selectedItems.Contains(newItem)) { _selectedItems.Remove(newItem); } }
/// <summary> /// Get the node depth. /// </summary> /// <returns>The int indicating the node depth.</returns> public int GetDepth() { MSTreeViewItem parent = this; while (parent.ParentMultipleSelectionTreeViewItem != null) { return(parent.ParentMultipleSelectionTreeViewItem.GetDepth() + 1); } return(0); }
/// <summary> /// Retrieve the last displayed child node of the given one. /// </summary> /// <param name="item">The node starting with you want to retrieve the last visible node.</param> /// <returns>The last child node that is displayed, or the node itself in case it is not expanded.</returns> public MSTreeViewItem GetLastVisibleChildNodeOf(MSTreeViewItem item) { MSTreeViewItem lastVisibleNode = item; // Retrieving last child of last expanded node while (lastVisibleNode != null && lastVisibleNode.Items.Count > 0 && lastVisibleNode.IsExpanded) { lastVisibleNode = lastVisibleNode.ItemContainerGenerator.ContainerFromIndex(lastVisibleNode.Items.Count - 1) as MSTreeViewItem; } return(lastVisibleNode); }
private void ManageSingleSelection(MSTreeViewItem viewItem) { bool isViewItemMultipleSelected = viewItem.IsSelected; UnselectAll(); if (isViewItemMultipleSelected) { viewItem.IsSelected = isViewItemMultipleSelected; AddItemToSelection(viewItem); } }
private void ManageCtrlSelection(MSTreeViewItem viewItem) { bool isViewItemMultipleSelected = viewItem.IsSelected; if (isViewItemMultipleSelected) { AddItemToSelection(viewItem); } else if (!isViewItemMultipleSelected) { RemoveItemFromSelection(viewItem); } }
/// <summary> /// Manage keyboard shift select /// </summary> /// <param name="viewItem"></param> private void ManageShiftSelection(MSTreeViewItem viewItem) { bool isViewItemMultipleSelected = viewItem.IsSelected; if (!isViewItemMultipleSelected) { return; } MSTreeViewItem sidling = HasSidlingItem(viewItem); if (sidling == null) { return; } SelectBetween(viewItem, sidling); }
internal void OnSelectionChanges(MSTreeViewItem viewItem) { MSTreeViewItem newItem = viewItem; if (newItem == null) { return; } bool isNewItemMultipleSelected = viewItem.IsSelected; if (isNewItemMultipleSelected) { AddItemToSelection(viewItem); } else { RemoveItemFromSelection(viewItem); } }
//dep /// <summary> /// ... TODO ... /// </summary> /// <param name="item1"></param> /// <param name="item2"></param> /// <returns></returns> private bool IsItem1ListedBeforeItem2(MSTreeViewItem item1, MSTreeViewItem item2) { /* * // Perform a Backword search (up) * if (item1.ParentMultipleSelectionTreeViewItem != null) // item1 has a brother! * { * ItemCollection brothers = item1.ParentMultipleSelectionTreeViewItem.Items; * int indexOfItem1 = brothers.IndexOf(item1); * int indexOfItem2 = brothers.IndexOf(item2); * if (indexOfItem2 >= 0) //item1 and item2 are brothers * { * return indexOfItem1 < indexOfItem2 ? true : false; * } * * * } */ return(true); }
public void SelectAllExpandedItems() { if (Items != null && Items.Count > 0) { foreach (var item in Items) { if (item is MSTreeViewItem) { ((MSTreeViewItem)item).SelectAllExpandedChildren(); } else { MSTreeViewItem tvItem = this.ItemContainerGenerator.ContainerFromItem(item) as MSTreeViewItem; if (tvItem != null) { tvItem.SelectAllExpandedChildren(); } } } } }
/// <summary> /// Retrieve the subsequent node that is at the same level. /// </summary> /// <param name="item">The node starting with you want to retrieve the subsequent one.</param> /// <returns>Null if there is no subsequent node at the same level.</returns> public MSTreeViewItem GetNextNodeAtSameLevel(MSTreeViewItem item) { if (item == null) { return(null); } MSTreeViewItem nextNodeAtSameLevel = null; ItemsControl parentControl = item.ParentItemsControl; if (parentControl != null) { int index = parentControl.ItemContainerGenerator.IndexFromContainer(item); if (index != parentControl.Items.Count - 1) // if this is not the last item { nextNodeAtSameLevel = parentControl.ItemContainerGenerator.ContainerFromIndex(index + 1) as MSTreeViewItem; } } return(nextNodeAtSameLevel); }
private void SelectBetween(MSTreeViewItem item1, MSTreeViewItem item2) { //if (item1.Parent != item2.Parent) // return; MSTreeViewItem parent = item1.GetParentTreeViewItem(); int index_1 = parent.Items.IndexOf(item1.DataContext); int index_2 = parent.Items.IndexOf(item2.DataContext); if (index_1 < index_2) { for (int i = index_1; i < index_2; i++) { MSTreeViewItem item = parent.GetChildItemFromData(parent.Items[i]); if (item == null) { continue; } item.Select(); } } if (index_1 > index_2) { for (int i = index_1; i > index_2; i--) { MSTreeViewItem item = parent.GetChildItemFromData(parent.Items[i]); if (item == null) { continue; } item.Select(); } } SortSelectedItems(parent.Items); }
internal void OnViewItemMouseDown(MSTreeViewItem viewItem) { MSTreeViewItem newItem = viewItem; if (newItem == null) { return; } switch (this.SelectionMode) { case SelectionModalities.MultipleSelectionOnly: ManageCtrlSelection(newItem); break; case SelectionModalities.SingleSelectionOnly: ManageSingleSelection(newItem); break; case SelectionModalities.KeyboardModifiersMode: if (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift)) { ManageShiftSelection(newItem); } else if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)) { ManageCtrlSelection(newItem); } else { ManageSingleSelection(newItem); } break; } _lastClickedItem = viewItem.IsSelected ? viewItem : null; }
/// <summary> /// ... TODO ... /// </summary> /// <param name="fromItem"></param> /// <param name="toItem"></param> private void SelectRange(MSTreeViewItem fromItem, MSTreeViewItem toItem) { }
protected override void OnKeyDown(KeyEventArgs e) { try { MSTreeViewItem itemToSelect = null; if (e.Key == Key.Left) { this.IsExpanded = false; } else if (e.Key == Key.Right) { this.IsExpanded = true; } else if (e.Key == Key.Up) { // In this case we need to select the last child of the last expandend node of // - the previous at the same level (if this index node is NOT 0) // - the parent node (if this index node is 0) int currentNodeIndex = this.ParentItemsControl.ItemContainerGenerator.IndexFromContainer(this); if (currentNodeIndex == 0) { itemToSelect = this.ParentMultipleSelectionTreeViewItem; } else { MSTreeViewItem tmp = null; tmp = GetPreviousNodeAtSameLevel(this); itemToSelect = GetLastVisibleChildNodeOf(tmp); } } else if (e.Key == Key.Down) { // In this case we need to select: // - the first child node (if this node is expanded) // - the next at the same level (if this not the last child) // - the next at the same level of the parent node (if this is the last child) if (this.IsExpanded && this.Items.Count > 0) { // Select first Child itemToSelect = this.ItemContainerGenerator.ContainerFromIndex(0) as MSTreeViewItem; } else { itemToSelect = GetNextNodeAtSameLevel(this); if (itemToSelect == null) // current node has no subsequent node at the same level { MSTreeViewItem tmp = this.ParentMultipleSelectionTreeViewItem; while (itemToSelect == null && tmp != null) // searhing for the first parent that has a subsequent node at the same level { itemToSelect = GetNextNodeAtSameLevel(tmp); tmp = tmp.ParentMultipleSelectionTreeViewItem; } } } } if (itemToSelect != null) { itemToSelect.Focus(); itemToSelect.IsSelected = true; ParentMultipleSelectionTreeView.OnViewItemMouseDown(itemToSelect); } } catch (Exception) { /* Silently ignore */ } // Don't bubble up the event. (I'm sure you know difference between Bubble and Tunnel events in WPF...) e.Handled = true; }