/// <summary>
/// Browse the optional node in the node tree.
/// </summary>
/// <param name="browseContext">The context used to browse the node tree.</param>
/// <param name="parentInner">The inner containing this state as a child.</param>
public override void BrowseChildren(IReadOnlyBrowseContext browseContext, IReadOnlyInner <IReadOnlyBrowsingChildIndex> parentInner)
{
Debug.Assert(browseContext != null);
Debug.Assert(parentInner != null);
NodeTreeHelperOptional.GetChildNode(Optional, out bool IsAssigned, out INode ChildNode);
if (ChildNode != null)
{
BrowseChildrenOfNode(browseContext, ChildNode);
}
}
private protected virtual IReadOnlyIndexCollection BrowseNodeBlockList(IReadOnlyBrowseContext browseNodeContext, INode node, string propertyName, IReadOnlyList <INodeTreeBlock> childBlockList)
{
Debug.Assert(!string.IsNullOrEmpty(propertyName));
IReadOnlyBrowsingBlockNodeIndexList NodeIndexList = CreateBrowsingBlockNodeIndexList();
for (int BlockIndex = 0; BlockIndex < childBlockList.Count; BlockIndex++)
{
INodeTreeBlock ChildBlock = childBlockList[BlockIndex];
BrowseBlock(browseNodeContext, node, propertyName, BlockIndex, ChildBlock, NodeIndexList);
}
return(CreateBlockIndexCollection(browseNodeContext, propertyName, NodeIndexList));
}
private protected virtual IReadOnlyIndexCollection BrowseNodeList(IReadOnlyBrowseContext browseNodeContext, INode node, string propertyName, IReadOnlyList <INode> childNodeList)
{
Debug.Assert(!string.IsNullOrEmpty(propertyName));
IReadOnlyBrowsingListNodeIndexList NodeIndexList = CreateBrowsingListNodeIndexList();
for (int Index = 0; Index < childNodeList.Count; Index++)
{
INode ChildNode = childNodeList[Index];
Debug.Assert(ChildNode != null);
IReadOnlyBrowsingListNodeIndex NewNodeIndex = CreateListNodeIndex(browseNodeContext, node, propertyName, ChildNode, Index);
NodeIndexList.Add(NewNodeIndex);
}
return(CreateListIndexCollection(browseNodeContext, propertyName, NodeIndexList));
}
private protected virtual void BrowseBlock(IReadOnlyBrowseContext browseNodeContext, INode node, string propertyName, int blockIndex, INodeTreeBlock childBlock, IReadOnlyBrowsingBlockNodeIndexList nodeIndexList)
{
Debug.Assert(!string.IsNullOrEmpty(propertyName));
for (int Index = 0; Index < childBlock.NodeList.Count; Index++)
{
INode ChildNode = childBlock.NodeList[Index];
IReadOnlyBrowsingBlockNodeIndex NewNodeIndex;
if (Index == 0) // For the first node, we use a IxxxBrowsingNewBlockNodeIndex, otherwise a IxxxBrowsingExistingBlockNodeIndex.
{
NewNodeIndex = CreateNewBlockNodeIndex(browseNodeContext, node, propertyName, blockIndex, ChildNode);
}
else
{
NewNodeIndex = CreateExistingBlockNodeIndex(browseNodeContext, node, propertyName, blockIndex, Index, ChildNode);
}
nodeIndexList.Add(NewNodeIndex);
}
}
/// <summary>
/// Creates a IxxxIndexCollection with IxxxBrowsingBlockNodeIndex objects.
/// </summary>
private protected override IReadOnlyIndexCollection CreateBlockIndexCollection(IReadOnlyBrowseContext browseNodeContext, string propertyName, IReadOnlyBrowsingBlockNodeIndexList nodeIndexList)
{
ControllerTools.AssertNoOverride(this, typeof(WriteableOptionalNodeState <IInner>));
return(new WriteableIndexCollection <IWriteableBrowsingBlockNodeIndex>(propertyName, (IWriteableBrowsingBlockNodeIndexList)nodeIndexList));
}
/// <summary>
/// Creates a IxxxIndexCollection with one IxxxBrowsingPlaceholderNodeIndex.
/// </summary>
private protected override IReadOnlyIndexCollection CreatePlaceholderIndexCollection(IReadOnlyBrowseContext browseNodeContext, string propertyName, IReadOnlyBrowsingPlaceholderNodeIndex childNodeIndex)
{
ControllerTools.AssertNoOverride(this, typeof(WriteableOptionalNodeState <IInner>));
return(new WriteableIndexCollection <IWriteableBrowsingPlaceholderNodeIndex>(propertyName, new List <IWriteableBrowsingPlaceholderNodeIndex>()
{
(IWriteableBrowsingPlaceholderNodeIndex)childNodeIndex
}));
}
/// <summary>
/// Creates a IxxxBrowsingNewBlockNodeIndex object.
/// </summary>
private protected override IReadOnlyBrowsingNewBlockNodeIndex CreateNewBlockNodeIndex(IReadOnlyBrowseContext browseNodeContext, INode node, string propertyName, int blockIndex, INode childNode)
{
ControllerTools.AssertNoOverride(this, typeof(WriteableOptionalNodeState <IInner>));
return(new WriteableBrowsingNewBlockNodeIndex(node, childNode, propertyName, blockIndex));
}
/// <summary>
/// Creates a IxxxIndexCollection with IxxxBrowsingListNodeIndex objects.
/// </summary>
private protected override IReadOnlyIndexCollection CreateListIndexCollection(IReadOnlyBrowseContext browseNodeContext, string propertyName, IReadOnlyBrowsingListNodeIndexList nodeIndexList)
{
ControllerTools.AssertNoOverride(this, typeof(LayoutPlaceholderNodeState <IInner>));
return(new LayoutIndexCollection <ILayoutBrowsingListNodeIndex>(propertyName, (ILayoutBrowsingListNodeIndexList)nodeIndexList));
}
/// <summary>
/// Creates a IxxxBrowsingListNodeIndex object.
/// </summary>
private protected override IReadOnlyBrowsingListNodeIndex CreateListNodeIndex(IReadOnlyBrowseContext browseNodeContext, INode node, string propertyName, INode childNode, int index)
{
ControllerTools.AssertNoOverride(this, typeof(LayoutPlaceholderNodeState <IInner>));
return(new LayoutBrowsingListNodeIndex(node, childNode, propertyName, index));
}
private protected virtual void BrowseChildrenOfNode(IReadOnlyBrowseContext browseNodeContext, INode node)
{
IList <string> PropertyNames = NodeTreeHelper.EnumChildNodeProperties(node);
foreach (string PropertyName in PropertyNames)
{
INode ChildNode;
Type ChildInterfaceType, ChildNodeType;
IReadOnlyList <INode> ChildNodeList;
IReadOnlyList <INodeTreeBlock> ChildBlockList;
bool IsHandled = false;
if (NodeTreeHelperChild.IsChildNodeProperty(node, PropertyName, out ChildNodeType))
{
NodeTreeHelperChild.GetChildNode(node, PropertyName, out ChildNode);
Debug.Assert(ChildNode != null);
IReadOnlyBrowsingPlaceholderNodeIndex ChildNodeIndex = CreateChildNodeIndex(browseNodeContext, node, PropertyName, ChildNode);
// Create a collection containing one index for this child node.
IReadOnlyIndexCollection IndexCollection = CreatePlaceholderIndexCollection(browseNodeContext, PropertyName, ChildNodeIndex);
browseNodeContext.AddIndexCollection(IndexCollection);
IsHandled = true;
}
else if (NodeTreeHelperOptional.IsOptionalChildNodeProperty(node, PropertyName, out ChildNodeType))
{
IReadOnlyBrowsingOptionalNodeIndex OptionalNodeIndex = CreateOptionalNodeIndex(browseNodeContext, node, PropertyName);
// Create a collection containing one index for this optional node.
IReadOnlyIndexCollection IndexCollection = CreateOptionalIndexCollection(browseNodeContext, PropertyName, OptionalNodeIndex);
browseNodeContext.AddIndexCollection(IndexCollection);
IsHandled = true;
}
else if (NodeTreeHelperList.IsNodeListProperty(node, PropertyName, out ChildNodeType))
{
NodeTreeHelperList.GetChildNodeList(node, PropertyName, out ChildNodeList);
Debug.Assert(ChildNodeList != null);
// Create a collection containing indexes for each children.
IReadOnlyIndexCollection IndexCollection = BrowseNodeList(browseNodeContext, node, PropertyName, ChildNodeList);
browseNodeContext.AddIndexCollection(IndexCollection);
IsHandled = true;
}
else if (NodeTreeHelperBlockList.IsBlockListProperty(node, PropertyName, out ChildInterfaceType, out ChildNodeType))
{
NodeTreeHelperBlockList.GetChildBlockList(node, PropertyName, out ChildBlockList);
Debug.Assert(ChildBlockList != null);
// Create a collection containing indexes for each child blocks and their children.
IReadOnlyIndexCollection IndexCollection = BrowseNodeBlockList(browseNodeContext, node, PropertyName, ChildBlockList);
browseNodeContext.AddIndexCollection(IndexCollection);
IsHandled = true;
}
else if (NodeTreeHelper.IsBooleanProperty(node, PropertyName))
{
browseNodeContext.AddValueProperty(PropertyName, ValuePropertyType.Boolean);
IsHandled = true;
}
else if (NodeTreeHelper.IsEnumProperty(node, PropertyName))
{
browseNodeContext.AddValueProperty(PropertyName, ValuePropertyType.Enum);
IsHandled = true;
}
else if (NodeTreeHelper.IsStringProperty(node, PropertyName))
{
browseNodeContext.AddValueProperty(PropertyName, ValuePropertyType.String);
IsHandled = true;
}
else if (NodeTreeHelper.IsGuidProperty(node, PropertyName))
{
browseNodeContext.AddValueProperty(PropertyName, ValuePropertyType.Guid);
IsHandled = true;
}
else if (NodeTreeHelper.IsDocumentProperty(node, PropertyName))
{
IsHandled = true; // Ignore the doc node.
}
Debug.Assert(IsHandled);
}
}
/// <summary>
/// Creates a IxxxIndexCollection with one IxxxBrowsingOptionalNodeIndex.
/// </summary>
private protected override IReadOnlyIndexCollection CreateOptionalIndexCollection(IReadOnlyBrowseContext browseNodeContext, string propertyName, IReadOnlyBrowsingOptionalNodeIndex optionalNodeIndex)
{
ControllerTools.AssertNoOverride(this, typeof(FocusPlaceholderNodeState <IInner>));
return(new FocusIndexCollection <IFocusBrowsingOptionalNodeIndex>(propertyName, new List <IFocusBrowsingOptionalNodeIndex>()
{
(IFocusBrowsingOptionalNodeIndex)optionalNodeIndex
}));
}
private protected override void CheckContextConsistency(IReadOnlyBrowseContext browseContext)
{
((LayoutBrowseContext)browseContext).CheckConsistency();
}
/// <summary>
/// Creates a IxxxIndexCollection with IxxxBrowsingBlockNodeIndex objects.
/// </summary>
private protected virtual IReadOnlyIndexCollection CreateBlockIndexCollection(IReadOnlyBrowseContext browseNodeContext, string propertyName, IReadOnlyBrowsingBlockNodeIndexList nodeIndexList)
{
ControllerTools.AssertNoOverride(this, typeof(ReadOnlyNodeState <IInner>));
return(new ReadOnlyIndexCollection <IReadOnlyBrowsingBlockNodeIndex>(propertyName, nodeIndexList));
}
/// <summary>
/// Creates a IxxxIndexCollection with one IxxxBrowsingOptionalNodeIndex.
/// </summary>
private protected virtual IReadOnlyIndexCollection CreateOptionalIndexCollection(IReadOnlyBrowseContext browseNodeContext, string propertyName, IReadOnlyBrowsingOptionalNodeIndex optionalNodeIndex)
{
ControllerTools.AssertNoOverride(this, typeof(ReadOnlyNodeState <IInner>));
return(new ReadOnlyIndexCollection <IReadOnlyBrowsingOptionalNodeIndex>(propertyName, new List <IReadOnlyBrowsingOptionalNodeIndex>()
{
optionalNodeIndex
}));
}
/// <summary>
/// Creates a IxxxBrowsingPlaceholderNodeIndex object.
/// </summary>
private protected virtual IReadOnlyBrowsingPlaceholderNodeIndex CreateChildNodeIndex(IReadOnlyBrowseContext browseNodeContext, INode node, string propertyName, INode childNode)
{
ControllerTools.AssertNoOverride(this, typeof(ReadOnlyNodeState <IInner>));
return(new ReadOnlyBrowsingPlaceholderNodeIndex(node, childNode, propertyName));
}
/// <summary>
/// Creates a IxxxBrowsingOptionalNodeIndex object.
/// </summary>
private protected override IReadOnlyBrowsingOptionalNodeIndex CreateOptionalNodeIndex(IReadOnlyBrowseContext browseNodeContext, INode node, string propertyName)
{
ControllerTools.AssertNoOverride(this, typeof(FocusPlaceholderNodeState <IInner>));
return(new FocusBrowsingOptionalNodeIndex(node, propertyName));
}
/// <summary>
/// Creates a IxxxBrowsingExistingBlockNodeIndex object.
/// </summary>
private protected override IReadOnlyBrowsingExistingBlockNodeIndex CreateExistingBlockNodeIndex(IReadOnlyBrowseContext browseNodeContext, INode node, string propertyName, int blockIndex, int index, INode childNode)
{
ControllerTools.AssertNoOverride(this, typeof(FocusPlaceholderNodeState <IInner>));
return(new FocusBrowsingExistingBlockNodeIndex(node, childNode, propertyName, blockIndex, index));
}
/// <summary>
/// Creates a IxxxxBrowseContext object.
/// </summary>
private protected override IReadOnlyBrowseContext CreateBrowseContext(IReadOnlyBrowseContext parentBrowseContext, IReadOnlyNodeState state)
{
ControllerTools.AssertNoOverride(this, typeof(LayoutController));
return(new LayoutBrowseContext((ILayoutNodeState)state));
}
/// <summary>
/// Creates a IxxxIndexCollection with IxxxBrowsingBlockNodeIndex objects.
/// </summary>
private protected override IReadOnlyIndexCollection CreateBlockIndexCollection(IReadOnlyBrowseContext browseNodeContext, string propertyName, IReadOnlyBrowsingBlockNodeIndexList nodeIndexList)
{
ControllerTools.AssertNoOverride(this, typeof(FocusPlaceholderNodeState <IInner>));
return(new FocusIndexCollection <IFocusBrowsingBlockNodeIndex>(propertyName, (IFocusBrowsingBlockNodeIndexList)nodeIndexList));
}
/// <summary>
/// Find children in the node tree.
/// </summary>
/// <param name="browseContext">The context used to browse the node tree.</param>
/// <param name="parentInner">The inner containing this state as a child.</param>
public virtual void BrowseChildren(IReadOnlyBrowseContext browseContext, IReadOnlyInner <IReadOnlyBrowsingChildIndex> parentInner)
{
BrowseChildrenOfNode(browseContext, Node);
}
