// ReSharper disable MemberCanBePrivate.Global protected void AdjustSelectionAndCaretUponNavigation(Event e) // ReSharper restore MemberCanBePrivate.Global { //Debug.Log("AdjustSelectionAndCaretUponNavigation"); KeyboardEvent ke = (KeyboardEvent) e; // Some unrecognized key stroke was entered, return. if (!NavigationUnitUtil.IsNavigationUnit(ke.KeyCode)) return; NavigationUnit navigationUnit = NavigationUnitUtil.GetNavigationUnit(ke.KeyCode); //Debug.Log("navigationUnit:" + navigationUnit); //Debug.Log("CaretIndex:" + CaretIndex); var proposedNewIndex = Layout.GetNavigationDestinationIndex(CaretIndex, navigationUnit, ArrowKeysWrapFocus); //Debug.Log("proposedNewIndex:" + proposedNewIndex); // Note that the KeyboardEvent is canceled even if the current selected or in focus index // doesn't change because we don't want another component to start handling these // events when the index reaches a limit. if (proposedNewIndex == -1) return; e.PreventDefault(); // Contiguous multi-selection action. Create the new selection // interval. if (_allowMultipleSelection && ke.Shift && null != SelectedIndices) { var startIndex = GetLastSelectedIndex(); var newInterval = new List<int>(); int i; if (startIndex <= proposedNewIndex) { for (i = startIndex; i <= proposedNewIndex; i++) { newInterval.Insert(0, i); } } else { for (i = startIndex; i >= proposedNewIndex; i--) { newInterval.Insert(0, i); } } SetSelectedIndices(newInterval, true); EnsureIndexIsVisible(proposedNewIndex); } // Entering the caret state with the Ctrl key down else if (ke.Control) { var oldCaretIndex = CaretIndex; SetCurrentCaretIndex(proposedNewIndex); var ice = new IndexChangeEvent(IndexChangeEvent.CARET_CHANGE) { OldIndex = oldCaretIndex, NewIndex = CaretIndex }; DispatchEvent(ice); EnsureIndexIsVisible(proposedNewIndex); } // Its just a new selection action, select the new index. else { SetSelectedIndex(proposedNewIndex, true); EnsureIndexIsVisible(proposedNewIndex); } }
// ReSharper disable MemberCanBePrivate.Global protected List<int> CalculateSelectedIndices(int index, bool shiftKey, bool ctrlKey) // ReSharper restore MemberCanBePrivate.Global { int i; List<int> interval = new List<int>(); if (!shiftKey) { if (ctrlKey) { if (!IsEmpty(SelectedIndices)) { // Quick check to see if SelectedIndices had only one selected item // and that item was de-selected if (SelectedIndices.Count == 1 && (SelectedIndices[0] == index)) { // We need to respect requireSelection if (!RequireSelection) return interval; interval.Insert(0, SelectedIndices[0]); return interval; } // Go through and see if the index passed in was in the // selection model. If so, leave it out when constructing // the new interval so it is de-selected. bool found = false; for (i = 0; i < _selectedIndices.Count; i++) { if (_selectedIndices[i] == index) found = true; else if (_selectedIndices[i] != index) interval.Insert(0, _selectedIndices[i]); } if (!found) { // Nothing from the selection model was de-selected. // Instead, the Ctrl key was held down and we're doing a // new add. interval.Insert(0, index); } return interval; } // Ctrl+click with no previously selected items interval.Insert(0, index); return interval; } // A single item was newly selected, add that to the selection interval. interval.Insert(0, index); return interval; } // A contiguous selection action has occurred. Figure out which new // indices to add to the selection interval and return that. var start = (!IsEmpty(SelectedIndices)) ? SelectedIndices[SelectedIndices.Count - 1] : 0; var end = index; if (start < end) { for (i = start; i <= end; i++) { interval.Insert(0, i); } } else { for (i = start; i >= end; i--) { interval.Insert(0, i); } } return interval; }
/// <summary> /// Changes the depth of a single child within the list /// </summary> /// <param name="depthList"></param> /// <param name="child"></param> /// <param name="depth"></param> /// <param name="makeRoom"></param> private static void SetDepth(List<DisplayListMember> depthList, DisplayListMember child, int depth, bool makeRoom) { //Debug.Log("Setting depth: " + depth + " [" + child + "]"); child.Depth = depth; // remove depthList.Remove(child); var index = depthList.FindIndex(delegate(DisplayListMember displayListMember) { return displayListMember.Depth >= depth; }); if (index == -1) // not found, meaning all depths are lower than the supplied one index = depthList.Count; // insert at index depthList.Insert(index, child); var len = depthList.Count; // fix other depths // say depth = 1 // and that we have depths [0, 0, 1, 1, 1, 2, 6, 7] and inserting into the 3rd place (between 0 and 1) // ... [0, 0, *1, 1, 1, 1, 2, 6, 7] ... // we have to get [0, 0, *1, 2, 2, 2, 3, 6, 7] - note that some values are shifted up, but the values of 6, 7 are not because there's no need to //_prevDepth = depth; if (makeRoom) { // needs room? if (depthList.Count == index + 1 || depthList[index + 1].Depth > depth) return; // this is the last item or the next item has a greater depth for (int i = index + 1; i < len; i++) // from 3rd place to the end { depthList[index].Depth += 1; //var item2 = depthList[index]; // 2 //if (item2.Depth != _prevDepth) // _prevDepth = item2.Depth; // _prevDepth = 1 //if (item2.Depth == _prevDepth) // 1 == 1 //{ // item2.Depth = _prevDepth + 1; // item2.Depth = 2 //} } } }