DistanceLineCounterEntry Split(int index)
{
if (index >= InternalCount)
{
return(null);
}
LineIndexEntryAt e = InitDistanceLine(index, true);
if (e.rbEntryPosition.LineCount != index)
{
int count1 = index - e.rbEntryPosition.LineCount;
int count2 = e.rbValue.LineCount - count1;
e.rbValue.LineCount = count1;
DistanceLineCounterEntry rbEntry2 = CreateTreeTableEntry(e.rbValue.SingleLineDistance, count2);
rbTree.Insert(rbTree.IndexOf(e.rbEntry) + 1, rbEntry2);
//rbEntry2.InvalidateCounterBottomUp(true);
e.rbEntry.InvalidateCounterBottomUp(true);
return(rbEntry2);
}
return(e.rbEntry);
}
double _GetCumulatedDistanceAt(int index)
{
CheckRange("index", 0, Count + 1, index);
if (index == Count + 1)
{
return(TotalDistance);
}
if (index == 0)
{
return(0);
}
int count = InternalCount;
if (count == 0)
{
return(index * DefaultDistance);
}
if (index >= count)
{
int delta = index - count;
DistanceLineCounter counter = rbTree.GetCounterTotal();
return(counter.Distance + delta * DefaultDistance);
}
else
{
LineIndexEntryAt e = InitDistanceLine(index, false);
e.rbEntryPosition = e.rbEntry.GetCounterPosition();
return(e.rbEntryPosition.Distance + (index - e.rbEntryPosition.LineCount) * e.rbValue.SingleLineDistance);
}
}
/// <summary>
/// Insert entities in the collection.
/// </summary>
/// <param name="insertAt">Insert position.</param>
/// <param name="count">The number of entities to be inserted.</param>
/// <param name="distance">The distance to be set.</param>
public void Insert(int insertAt, int count, double distance)
{
Count += count;
if (insertAt >= InternalCount && distance == defaultDistance)
{
return;
}
EnsureTreeCount(insertAt);
LineIndexEntryAt e = InitDistanceLine(insertAt, false);
if (e.rbValue.SingleLineDistance == distance)
{
e.rbValue.LineCount += count;
e.rbEntry.InvalidateCounterBottomUp(true);
}
else
{
DistanceLineCounterEntry rbEntry0 = Split(insertAt);
DistanceLineCounterEntry entry = CreateTreeTableEntry(distance, count);
if (rbEntry0 == null)
{
rbTree.Add(entry);
}
else
{
rbTree.Insert(rbTree.IndexOf(rbEntry0), entry);
}
//entry.InvalidateCounterBottomUp(true);
Merge(entry, true);
}
}
/// <summary>
/// Skip previous entities for which the distance is 0.0 and return the next entity.
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public int GetPreviousVisibleIndex(int index)
{
CheckRange("index", 0, Count, index);
if (index > InternalCount || index == 0)
{
return(index - 1);
}
LineIndexEntryAt e = InitDistanceLine(index - 1, false);
if (e.rbValue.SingleLineDistance > 0)
{
return(index - 1);
}
e.rbEntry = rbTree.GetPreviousVisibleEntry(e.rbEntry);
if (e.rbEntry == null)
{
return(-1);
}
e.rbEntryPosition = e.rbEntry.GetCounterPosition();
e.rbValue = e.rbEntry.Value;
return(e.rbEntryPosition.LineCount + e.rbValue.LineCount - 1);
}
/// <summary>
/// Skip subsequent entities for which the distance is 0.0 and return the next entity.
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public int GetNextVisibleIndex(int index)
{
CheckRange("index", 0, Count - 1, index);
if (index >= InternalCount)
{
return(index + 1);
}
LineIndexEntryAt e = InitDistanceLine(index + 1, true);
if (e.rbValue.SingleLineDistance > 0)
{
if (index - e.rbEntryPosition.LineCount < e.rbValue.LineCount)
{
return(index + 1);
}
}
e.rbEntry = rbTree.GetNextVisibleEntry(e.rbEntry);
if (e.rbEntry == null)
{
if (InternalCount < Count)
{
return(InternalCount);
}
return(-1);
}
e.rbEntryPosition = e.rbEntry.GetCounterPosition();
return(e.rbEntryPosition.LineCount);
}
LineIndexEntryAt InitDistanceLine(int lineIndex, bool determineEntryPosition)
{
var e = new LineIndexEntryAt {
searchPosition = new DistanceLineCounter(0, lineIndex)
};
e.rbEntry = rbTree.GetEntryAtCounterPosition(e.searchPosition, DistanceLineCounterKind.Lines, false);
e.rbValue = e.rbEntry.Value;
e.rbEntryPosition = null;
if (determineEntryPosition)
{
e.rbEntryPosition = e.rbValue.LineCount > 1 ? e.rbEntry.GetCounterPosition() : e.searchPosition;
}
return(e);
}
public void InvalidateNestedEntry(int index)
{
CheckRange("index", 0, Count - 1, index);
var start = GetCumulatedDistanceAt(index);
var end = GetCumulatedDistanceAt(index + 1);
var distance = end - start;
var nested = GetNestedDistances(index);
if (nested != null && distance != nested.TotalDistance)
{
LineIndexEntryAt e = InitDistanceLine(index, false);
e.rbEntry.InvalidateCounterBottomUp(true);
}
}
/// <summary>
/// Gets the nested entities at a given index. If the index does not hold
/// a mested distances collection the method returns null.
/// </summary>
/// <param name="index">The index.</param>
/// <returns>The nested collection or null.</returns>
public IDistanceCounterCollection GetNestedDistances(int index)
{
//CheckRange("index", 0, Count - 1, index); This moved after the condition check.Because While scrolling the nested grid it will raises the exception.
if (index >= InternalCount)
{
return(null);
}
CheckRange("index", 0, Count - 1, index);
LineIndexEntryAt e = InitDistanceLine(index, false);
var vcs = e.rbValue as NestedDistanceCounterCollectionSource;
if (vcs != null)
{
return(vcs.NestedDistances);
}
return(null);
}
/// <summary>
/// Gets or sets the distance for an entity.
/// </summary>
/// <param name="index">The index for the entity</param>
/// <returns></returns>
public double this[int index]
{
get
{
CheckRange("index", 0, Count - 1, index);
if (index >= InternalCount)
{
return(DefaultDistance);
}
LineIndexEntryAt e = InitDistanceLine(index, false);
return(e.rbValue.SingleLineDistance);
}
set
{
CheckRange("index", 0, Count - 1, index);
if (value < 0)
{
throw new ArgumentOutOfRangeException("value must not be negative.");
}
if (!value.Equals(this[index]))
{
if (index >= InternalCount)
{
EnsureTreeCount(Count);
}
DistanceLineCounterEntry entry = Split(index);
Split(index + 1);
entry.Value.SingleLineDistance = value;
entry.InvalidateCounterBottomUp(true);
}
}
}