private int GetAnchorIndex(
Size availableSize,
bool isWrapping,
double minItemSpacing,
string layoutId)
{
int anchorIndex = -1;
var anchorPosition = new Point();
var context = _context;
if (!IsVirtualizingContext)
{
// Non virtualizing host, start generating from the element 0
anchorIndex = context.ItemCount > 0 ? 0 : -1;
}
else
{
bool isRealizationWindowConnected = _elementManager.IsWindowConnected(RealizationRect, _orientation.ScrollOrientation, _scrollOrientationSameAsFlow);
// Item spacing and size in non-virtualizing direction change can cause elements to reflow
// and get a new column position. In that case we need the anchor to be positioned in the
// correct column.
bool needAnchorColumnRevaluation = isWrapping && (
_orientation.Minor(_lastAvailableSize) != _orientation.Minor(availableSize) ||
_lastItemSpacing != minItemSpacing ||
_collectionChangePending);
var suggestedAnchorIndex = _context.RecommendedAnchorIndex;
var isAnchorSuggestionValid = suggestedAnchorIndex >= 0 &&
_elementManager.IsDataIndexRealized(suggestedAnchorIndex);
if (isAnchorSuggestionValid)
{
anchorIndex = _algorithmCallbacks.Algorithm_GetAnchorForTargetElement(
suggestedAnchorIndex,
availableSize,
context).Index;
if (_elementManager.IsDataIndexRealized(anchorIndex))
{
var anchorBounds = _elementManager.GetLayoutBoundsForDataIndex(anchorIndex);
if (needAnchorColumnRevaluation)
{
// We were provided a valid anchor, but its position might be incorrect because for example it is in
// the wrong column. We do know that the anchor is the first element in the row, so we can force the minor position
// to start at 0.
anchorPosition = _orientation.MinorMajorPoint(0, _orientation.MajorStart(anchorBounds));
}
else
{
anchorPosition = new Point(anchorBounds.X, anchorBounds.Y);
}
}
else
{
// It is possible to end up in a situation during a collection change where GetAnchorForTargetElement returns an index
// which is not in the realized range. Eg. insert one item at index 0 for a grid layout.
// SuggestedAnchor will be 1 (used to be 0) and GetAnchorForTargetElement will return 0 (left most item in row). However 0 is not in the
// realized range yet. In this case we realize the gap between the target anchor and the suggested anchor.
int firstRealizedDataIndex = _elementManager.GetDataIndexFromRealizedRangeIndex(0);
for (int i = firstRealizedDataIndex - 1; i >= anchorIndex; --i)
{
_elementManager.EnsureElementRealized(false /*forward*/, i, layoutId);
}
var anchorBounds = _elementManager.GetLayoutBoundsForDataIndex(suggestedAnchorIndex);
anchorPosition = _orientation.MinorMajorPoint(0, _orientation.MajorStart(anchorBounds));
}
}
else if (needAnchorColumnRevaluation || !isRealizationWindowConnected)
{
// The anchor is based on the realization window because a connected ItemsRepeater might intersect the realization window
// but not the visible window. In that situation, we still need to produce a valid anchor.
var anchorInfo = _algorithmCallbacks.Algorithm_GetAnchorForRealizationRect(availableSize, context);
anchorIndex = anchorInfo.Index;
anchorPosition = _orientation.MinorMajorPoint(0, anchorInfo.Offset);
}
else
{
// No suggestion - just pick first in realized range
anchorIndex = _elementManager.GetDataIndexFromRealizedRangeIndex(0);
var firstElementBounds = _elementManager.GetLayoutBoundsForRealizedIndex(0);
anchorPosition = new Point(firstElementBounds.X, firstElementBounds.Y);
}
}
_firstRealizedDataIndexInsideRealizationWindow = _lastRealizedDataIndexInsideRealizationWindow = anchorIndex;
if (_elementManager.IsIndexValidInData(anchorIndex))
{
if (!_elementManager.IsDataIndexRealized(anchorIndex))
{
// Disconnected, throw everything and create new anchor
_elementManager.ClearRealizedRange();
var anchor = _context.GetOrCreateElementAt(anchorIndex, ElementRealizationOptions.ForceCreate | ElementRealizationOptions.SuppressAutoRecycle);
_elementManager.Add(anchor, anchorIndex);
}
var anchorElement = _elementManager.GetRealizedElement(anchorIndex);
var desiredSize = MeasureElement(anchorElement, anchorIndex, availableSize, _context);
var layoutBounds = new Rect(anchorPosition.X, anchorPosition.Y, desiredSize.Width, desiredSize.Height);
_elementManager.SetLayoutBoundsForDataIndex(anchorIndex, layoutBounds);
}
else
{
_elementManager.ClearRealizedRange();
}
// TODO: Perhaps we can track changes in the property setter
_lastAvailableSize = availableSize;
_lastItemSpacing = minItemSpacing;
return(anchorIndex);
}
int GetAnchorIndex(
Size availableSize,
bool isWrapping,
double minItemSpacing,
string layoutId)
{
int anchorIndex = -1;
Point anchorPosition = default;
var context = m_context;
if (!IsVirtualizingContext)
{
// Non virtualizing host, start generating from the element 0
anchorIndex = context.ItemCount > 0 ? 0 : -1;
}
else
{
bool isRealizationWindowConnected = m_elementManager.IsWindowConnected(RealizationRect, ScrollOrientation, m_scrollOrientationSameAsFlow);
// Item spacing and size in non-virtualizing direction change can cause elements to reflow
// and get a new column position. In that case we need the anchor to be positioned in the
// correct column.
bool needAnchorColumnRevaluation = isWrapping && (
Minor(m_lastAvailableSize) != Minor(availableSize) ||
m_lastItemSpacing != minItemSpacing ||
m_collectionChangePending);
var suggestedAnchorIndex = m_context.RecommendedAnchorIndex;
bool isAnchorSuggestionValid = suggestedAnchorIndex >= 0 &&
m_elementManager.IsDataIndexRealized(suggestedAnchorIndex);
if (isAnchorSuggestionValid)
{
REPEATER_TRACE_INFO("%*s: \tUsing suggested anchor %d\n", context.Indent, layoutId, suggestedAnchorIndex);
anchorIndex = m_algorithmCallbacks.Algorithm_GetAnchorForTargetElement(
suggestedAnchorIndex,
availableSize,
context).Index;
if (m_elementManager.IsDataIndexRealized(anchorIndex))
{
var anchorBounds = m_elementManager.GetLayoutBoundsForDataIndex(anchorIndex);
if (needAnchorColumnRevaluation)
{
// We were provided a valid anchor, but its position might be incorrect because for example it is in
// the wrong column. We do know that the anchor is the first element in the row, so we can force the minor position
// to start at 0.
anchorPosition = MinorMajorPoint(0, (float)MajorStart(anchorBounds));
}
else
{
anchorPosition = new Point(anchorBounds.X, anchorBounds.Y);
}
}
else
{
// It is possible to end up in a situation during a collection change where GetAnchorForTargetElement returns an index
// which is not in the realized range. Eg. insert one item at index 0 for a grid layout.
// SuggestedAnchor will be 1 (used to be 0) and GetAnchorForTargetElement will return 0 (left most item in row). However 0 is not in the
// realized range yet. In this case we realize the gap between the target anchor and the suggested anchor.
int firstRealizedDataIndex = m_elementManager.GetDataIndexFromRealizedRangeIndex(0);
global::System.Diagnostics.Debug.Assert(anchorIndex < firstRealizedDataIndex);
for (int i = firstRealizedDataIndex - 1; i >= anchorIndex; --i)
{
m_elementManager.EnsureElementRealized(false /*forward*/, i, layoutId);
}
var anchorBounds = m_elementManager.GetLayoutBoundsForDataIndex(suggestedAnchorIndex);
anchorPosition = MinorMajorPoint(0, (float)MajorStart(anchorBounds));
}
}
else if (needAnchorColumnRevaluation || !isRealizationWindowConnected)
{
if (needAnchorColumnRevaluation)
{
REPEATER_TRACE_INFO("%*s: \tNeedAnchorColumnReevaluation \n", context.Indent, layoutId);
}
if (!isRealizationWindowConnected)
{
REPEATER_TRACE_INFO("%*s: \tDisconnected Window \n", context.Indent, layoutId);
}
// The anchor is based on the realization window because a connected ItemsRepeater might intersect the realization window
// but not the visible window. In that situation, we still need to produce a valid anchor.
var anchorInfo = m_algorithmCallbacks.Algorithm_GetAnchorForRealizationRect(availableSize, context);
anchorIndex = anchorInfo.Index;
anchorPosition = MinorMajorPoint(0, (float)(anchorInfo.Offset));
}
else
{
REPEATER_TRACE_INFO("%*s: \tConnected Window - picking first realized element as anchor \n", context.Indent, layoutId);
// No suggestion - just pick first in realized range
anchorIndex = m_elementManager.GetDataIndexFromRealizedRangeIndex(0);
var firstElementBounds = m_elementManager.GetLayoutBoundsForRealizedIndex(0);
anchorPosition = new Point(firstElementBounds.X, firstElementBounds.Y);
}
}
REPEATER_TRACE_INFO("%*s: \tPicked anchor:%d \n", context.Indent, layoutId, anchorIndex);
global::System.Diagnostics.Debug.Assert(anchorIndex == -1 || m_elementManager.IsIndexValidInData(anchorIndex));
m_firstRealizedDataIndexInsideRealizationWindow = m_lastRealizedDataIndexInsideRealizationWindow = anchorIndex;
if (m_elementManager.IsIndexValidInData(anchorIndex))
{
if (!m_elementManager.IsDataIndexRealized(anchorIndex))
{
// Disconnected, throw everything and create new anchor
REPEATER_TRACE_INFO("%*s Disconnected Window - throwing away all realized elements \n", context.Indent, layoutId);
m_elementManager.ClearRealizedRange();
var anchor = m_context.GetOrCreateElementAt(anchorIndex, ElementRealizationOptions.ForceCreate | ElementRealizationOptions.SuppressAutoRecycle);
m_elementManager.Add(anchor, anchorIndex);
}
var anchorElement = m_elementManager.GetRealizedElement(anchorIndex);
var desiredSize = MeasureElement(anchorElement, anchorIndex, availableSize, m_context);
var layoutBounds = new Rect(anchorPosition.X, anchorPosition.Y, desiredSize.Width, desiredSize.Height);
m_elementManager.SetLayoutBoundsForDataIndex(anchorIndex, layoutBounds);
REPEATER_TRACE_INFO("%*s: \tLayout bounds of anchor %d are (%.0f,%.0f,%.0f,%.0f). \n",
context.Indent,
layoutId,
anchorIndex,
layoutBounds.X, layoutBounds.Y, layoutBounds.Width, layoutBounds.Height);
}
else
{
// Throw everything away
REPEATER_TRACE_INFO("%*s \tAnchor index is not valid - throwing away all realized elements \n",
context.Indent,
layoutId);
m_elementManager.ClearRealizedRange();
}
// TODO: Perhaps we can track changes in the property setter
m_lastAvailableSize = availableSize;
m_lastItemSpacing = minItemSpacing;
return(anchorIndex);
}