Esempio n. 1
0
            public int Compare(SelectionCellRangeWithItemsWrapper item)
            {
                if (m_target == item)
                {
                    return(0);
                }

                var xri = m_target.Value;
                var yri = item.Value;

                int compare;

                compare = ItemComparer.Compare(xri.ItemRange, yri.ItemRange);
                if (compare != 0)
                {
                    Debug.Assert(((compare < 0) && ItemRangeComparer.Compare(xri.ItemRange, item) <= 0) ||
                                 ((compare > 0) && ItemRangeComparer.Compare(xri.ItemRange, item) >= 0));

                    return(compare);
                }

                Debug.Assert(ItemRangeComparer.Compare(xri.ItemRange, item) == 0);

                compare = ItemComparer.Compare(xri.CellRange.ColumnRange, yri.CellRange.ColumnRange);
                if (compare != 0)
                {
                    return(compare);
                }

                Debug.Assert(xri.CellRange == yri.CellRange);

                return(m_target.Index - item.Index);
            }
Esempio n. 2
0
            internal ItemComparer(SelectionCellRangeWithItemsWrapper target)
            {
                if (target == null)
                {
                    throw new ArgumentNullException("target");
                }

                if (SelectedCellsStorage.IsEmpty(target.Value))
                {
                    throw new ArgumentException("The selection range must not be empty.", "target");
                }

                m_target = target;
            }
Esempio n. 3
0
        private void Insert(int index, SelectionCellRangeWithItems item, bool repairIndex)
        {
            var wrapper = new SelectionCellRangeWithItemsWrapper(item, index);

            m_ranges.Insert(index, wrapper);

            if (repairIndex)
            {
                this.RepairIndex(index + 1);
            }

            if (!SelectedCellsStorage.IsEmpty(item))
            {
                m_map.Add(SelectedCellsStorage.GetArea(item), wrapper);
            }
        }
Esempio n. 4
0
            internal static int Compare(SelectionRange range, SelectionCellRangeWithItemsWrapper wrapper)
            {
                var itemRange = wrapper.Value.ItemRange;

                if (range < itemRange)
                {
                    return(-1);
                }

                if (range > itemRange)
                {
                    return(1);
                }

                Debug.Assert(!range.Intersect(itemRange).IsEmpty);

                return(0);
            }
Esempio n. 5
0
        private void Insert(int index, SelectionCellRangeWithItems item, bool repairIndex)
        {
            var wrapper = new SelectionCellRangeWithItemsWrapper(item, index);

            m_unsortedRanges.Insert(index, wrapper);

            if (repairIndex)
            {
                this.RepairIndex(index + 1);
            }

            if (!SelectedCellsStorage.IsEmpty(item))
            {
                var insertionIndex = ~this.FindIndex(new ItemComparer(wrapper));
                Debug.Assert(insertionIndex >= 0);

                m_sortedRanges.Insert(insertionIndex, wrapper);
            }
        }
Esempio n. 6
0
 public int Compare(SelectionCellRangeWithItemsWrapper item)
 {
     return(ItemRangeComparer.Compare(m_target, item));
 }