internal void Initialize(object source, IndexPath sourceIndexPath, bool throwOnAccess)
{
m_source = source;
m_sourceIndexPath = sourceIndexPath;
m_throwOnAccess = throwOnAccess;
Children = null;
}
public static void Traverse(
SelectionNode root,
bool realizeChildren,
Action <TreeWalkNodeInfo> nodeAction)
{
var pendingNodes = new List <TreeWalkNodeInfo>();
var current = new IndexPath(null);
pendingNodes.Add(new TreeWalkNodeInfo(root, current));
while (pendingNodes.Count > 0)
{
var nextNode = pendingNodes.Last();
pendingNodes.RemoveLast();
int count = realizeChildren ? nextNode.Node.DataCount: nextNode.Node.ChildrenNodeCount;
for (int i = count - 1; i >= 0; i--)
{
SelectionNode child = nextNode.Node.GetAt(i, realizeChildren);
var childPath = nextNode.Path.CloneWithChildIndex(i);
if (child != null)
{
pendingNodes.Add(new TreeWalkNodeInfo(child, childPath, nextNode.Node));
}
}
// Queue the children first and then perform the action. This way
// the action can remove the children in the action if necessary
nodeAction(nextNode);
}
}
public void SelectRangeRegressionTest()
{
RunOnUIThread.Execute(() =>
{
var selectionModel = new SelectionModel()
{
Source = CreateNestedData(1, 2, 3)
};
// length of start smaller than end used to cause an out of range error.
selectionModel.SelectRange(IndexPath.CreateFrom(0), IndexPath.CreateFrom(1, 1));
ValidateSelection(selectionModel,
new List <IndexPath>()
{
Path(0, 0),
Path(0, 1),
Path(0, 2),
Path(0),
Path(1, 0),
Path(1, 1)
},
new List <IndexPath>()
{
Path(),
Path(1)
},
1 /* selectedInnerNodes */);
});
}
public void ValidateCanSetSelectedIndex()
{
RunOnUIThread.Execute(() =>
{
var model = new SelectionModel();
var ip = IndexPath.CreateFrom(34);
model.SelectedIndex = ip;
Verify.AreEqual(0, ip.CompareTo(model.SelectedIndex));
});
}
static IndexPath StartPath(IndexPath path, int length)
{
List <int> subPath = new List <int>();
for (int i = 0; i < length; i++)
{
subPath.Add(path.GetAt(i));
}
return(new IndexPath(subPath));
}
private void Select(SelectionModel manager, IndexPath index, bool select)
{
Log.Comment((select ? "Selecting " : "DeSelecting ") + index);
if (select)
{
manager.SelectAt(index);
}
else
{
manager.DeselectAt(index);
}
}
private void SelectRangeFromAnchor(SelectionModel manager, IndexPath index, bool select)
{
Log.Comment("SelectRangeFromAnchor " + index + " select: " + select.ToString());
if (select)
{
manager.SelectRangeFromAnchorTo(index);
}
else
{
manager.DeselectRangeFromAnchorTo(index);
}
}
private object GetData(SelectionModel selectionModel, IndexPath indexPath)
{
var data = selectionModel.Source;
for (int i = 0; i < indexPath.GetSize(); i++)
{
var listData = data as IList;
data = listData[indexPath.GetAt(i)];
}
return(data);
}
static bool IsSubSet(IndexPath path, IndexPath subset)
{
bool isSubset = true;
for (int i = 0; i < subset.GetSize(); i++)
{
isSubset = path.GetAt(i) == subset.GetAt(i);
if (!isSubset)
{
break;
}
}
return(isSubset);
}
private bool Contains(List <IndexPath> list, IndexPath index)
{
bool contains = false;
foreach (var item in list)
{
if (item.CompareTo(index) == 0)
{
contains = true;
break;
}
}
return(contains);
}
private bool AreEqual(IndexPath a, IndexPath b)
{
if (a.GetSize() != b.GetSize())
{
return(false);
}
for (int i = 0; i < a.GetSize(); i++)
{
if (a.GetAt(i) != b.GetAt(i))
{
return(false);
}
}
return(true);
}
static bool IsSubSet(IndexPath path, IndexPath subset)
{
var subsetSize = subset.GetSize();
if (path.GetSize() < subsetSize)
{
return(false);
}
for (int i = 0; i < subsetSize; i++)
{
if (path.GetAt(i) != subset.GetAt(i))
{
return(false);
}
}
return(true);
}
public static void TraverseIndexPath(
SelectionNode root,
IndexPath path,
bool realizeChildren,
Action <SelectionNode, IndexPath, int /*depth*/, int /*childIndex*/> nodeAction)
{
var node = root;
for (int depth = 0; depth < path.GetSize(); depth++)
{
int childIndex = path.GetAt(depth);
nodeAction(node, path, depth, childIndex);
if (depth < path.GetSize() - 1)
{
node = node.GetAt(childIndex, realizeChildren);
}
}
}
private static void Traverse(object root, Action <TreeWalkNodeInfo> nodeAction)
{
var pendingNodes = new Stack <TreeWalkNodeInfo>();
IndexPath current = Path(null);
pendingNodes.Push(new TreeWalkNodeInfo()
{
Current = root, Path = current
});
while (pendingNodes.Count > 0)
{
var currentNode = pendingNodes.Pop();
var currentObject = currentNode.Current as IList;
if (currentObject != null)
{
for (int i = currentObject.Count - 1; i >= 0; i--)
{
var child = currentObject[i];
List <int> path = new List <int>();
for (int idx = 0; idx < currentNode.Path.GetSize(); idx++)
{
path.Add(currentNode.Path.GetAt(idx));
}
path.Add(i);
var childPath = IndexPath.CreateFromIndices(path);
if (child != null)
{
pendingNodes.Push(new TreeWalkNodeInfo()
{
Current = child, Path = childPath
});
}
}
}
nodeAction(currentNode);
}
}
public int CompareTo(IndexPath other)
{
var rhsPath = other;
int compareResult = 0;
int lhsCount = m_path.Count;
int rhsCount = rhsPath.m_path.Count;
if (lhsCount == 0 || rhsCount == 0)
{
// one of the paths are empty, compare based on size
compareResult = (lhsCount - rhsCount);
}
else
{
// both paths are non-empty, but can be of different size
for (int i = 0; i < Math.Min(lhsCount, rhsCount); i++)
{
if (m_path[i] < rhsPath.m_path[i])
{
compareResult = -1;
break;
}
else if (m_path[i] > rhsPath.m_path[i])
{
compareResult = 1;
break;
}
}
// if both match upto min(lhsCount, rhsCount), compare based on size
compareResult = compareResult == 0 ? (lhsCount - rhsCount) : compareResult;
}
if (compareResult != 0)
{
compareResult = compareResult > 0 ? 1 : -1;
}
return(compareResult);
}
public static IndexPath Path(params int[] path)
{
return(IndexPath.CreateFromIndices(path));
}
public TreeWalkNodeInfo(SelectionNode node, IndexPath indexPath)
: this(node, indexPath, null)
{
}
private void SetAnchorIndex(SelectionModel manager, IndexPath index)
{
Log.Comment("SetAnchor " + index);
manager.AnchorIndex = index;
}
public static void TraverseRangeRealizeChildren(
SelectionNode root,
IndexPath start,
IndexPath end,
Action <TreeWalkNodeInfo> nodeAction)
{
Debug.Assert(start.CompareTo(end) == -1);
var pendingNodes = new List <TreeWalkNodeInfo>();
IndexPath current = start;
// Build up the stack to account for the depth first walk up to the
// start index path.
TraverseIndexPath(
root,
start,
true, /* realizeChildren */
(node, path, depth, childIndex) =>
{
var currentPath = StartPath(path, depth);
bool isStartPath = IsSubSet(start, currentPath);
bool isEndPath = IsSubSet(end, currentPath);
int startIndex = depth < start.GetSize() && isStartPath ? Math.Max(0, start.GetAt(depth)) : 0;
int endIndex = depth < end.GetSize() && isEndPath ? Math.Min(node.DataCount - 1, end.GetAt(depth)) : node.DataCount - 1;
for (int i = endIndex; i >= startIndex; i--)
{
var child = node.GetAt(i, true /* realizeChild */);
if (child != null)
{
var childPath = currentPath.CloneWithChildIndex(i);
pendingNodes.Add(new TreeWalkNodeInfo(child, childPath, node));
}
}
});
// From the start index path, do a depth first walk as long as the
// current path is less than the end path.
while (pendingNodes.Count > 0)
{
var info = pendingNodes.Last();
pendingNodes.RemoveLast();
int depth = info.Path.GetSize();
bool isStartPath = IsSubSet(start, info.Path);
bool isEndPath = IsSubSet(end, info.Path);
int startIndex = depth < start.GetSize() && isStartPath?start.GetAt(depth) : 0;
int endIndex = depth < end.GetSize() && isEndPath?end.GetAt(depth) : info.Node.DataCount - 1;
for (int i = endIndex; i >= startIndex; i--)
{
var child = info.Node.GetAt(i, true /* realizeChild */);
if (child != null)
{
var childPath = info.Path.CloneWithChildIndex(i);
pendingNodes.Add(new TreeWalkNodeInfo(child, childPath, info.Node));
}
}
nodeAction(info);
if (info.Path.CompareTo(end) == 0)
{
// We reached the end index path. stop iterating.
break;
}
}
}
public TreeWalkNodeInfo(SelectionNode node, IndexPath indexPath, SelectionNode parent)
{
Node = node;
Path = indexPath;
ParentNode = parent;
}
internal SelectionModelChildrenRequestedEventArgs(object source, IndexPath sourceIndexPath, bool throwOnAccess)
{
Initialize(source, sourceIndexPath, throwOnAccess);
}
public SelectedItemInfo(SelectionNode node, IndexPath path)
{
Node = new WeakReference <SelectionNode>(node);
Path = path;
}
