/// <summary> /// Inserts a new node in a list. /// </summary> /// <param name="operation">Details of the operation performed.</param> public virtual void Insert(WriteableInsertNodeOperation operation) { int InsertionIndex = operation.Index; Debug.Assert(InsertionIndex >= 0 && InsertionIndex <= StateList.Count); Node ParentNode = Owner.Node; Node Node = operation.Node; NodeTreeHelperList.InsertIntoList(ParentNode, PropertyName, InsertionIndex, Node); IWriteableBrowsingListNodeIndex BrowsingIndex = CreateBrowsingNodeIndex(Node, InsertionIndex); IWriteablePlaceholderNodeState ChildState = (IWriteablePlaceholderNodeState)CreateNodeState(BrowsingIndex); InsertInStateList(InsertionIndex, ChildState); operation.Update(BrowsingIndex, ChildState); while (++InsertionIndex < StateList.Count) { IWriteablePlaceholderNodeState State = (IWriteablePlaceholderNodeState)StateList[InsertionIndex]; IWriteableBrowsingListNodeIndex NodeIndex = State.ParentIndex as IWriteableBrowsingListNodeIndex; Debug.Assert(NodeIndex != null); Debug.Assert(NodeIndex.Index == InsertionIndex - 1); NodeIndex.MoveUp(); } }
/// <summary> /// Modifies the index to address the next position in a list. /// </summary> public virtual void MoveUp() { NodeTreeHelperList.GetLastListIndex(ParentNode, PropertyName, out int LastIndex); Debug.Assert(Index + 1 < LastIndex); Index++; }
/// <summary> /// Removes a node from a list or block list. /// </summary> /// <param name="operation">Details of the operation performed.</param> public virtual void Remove(WriteableRemoveNodeOperation operation) { int RemoveIndex = operation.Index; Debug.Assert(RemoveIndex >= 0 && RemoveIndex < StateList.Count); IWriteablePlaceholderNodeState OldChildState = (IWriteablePlaceholderNodeState)StateList[RemoveIndex]; RemoveFromStateList(RemoveIndex); Node ParentNode = Owner.Node; NodeTreeHelperList.RemoveFromList(ParentNode, PropertyName, RemoveIndex); while (RemoveIndex < StateList.Count) { IWriteablePlaceholderNodeState State = (IWriteablePlaceholderNodeState)StateList[RemoveIndex]; IWriteableBrowsingListNodeIndex NodeIndex = State.ParentIndex as IWriteableBrowsingListNodeIndex; Debug.Assert(NodeIndex != null); Debug.Assert(NodeIndex.Index == RemoveIndex + 1); NodeIndex.MoveDown(); RemoveIndex++; } operation.Update(OldChildState); }
private protected virtual bool IsNodeTreeValid(Node node) { Type ChildNodeType; IList <string> PropertyNames = NodeTreeHelper.EnumChildNodeProperties(node); bool IsValid = true; foreach (string PropertyName in PropertyNames) { if (NodeTreeHelperChild.IsChildNodeProperty(node, PropertyName, out ChildNodeType)) { IsValid &= InvariantFailed(IsNodeTreeChildNodeValid(node, PropertyName)); } else if (NodeTreeHelperOptional.IsOptionalChildNodeProperty(node, PropertyName, out ChildNodeType)) { IsValid &= InvariantFailed(IsNodeTreeOptionalNodeValid(node, PropertyName)); } else if (NodeTreeHelperList.IsNodeListProperty(node, PropertyName, out ChildNodeType)) { IsValid &= InvariantFailed(IsNodeTreeListValid(node, PropertyName)); } else if (NodeTreeHelperBlockList.IsBlockListProperty(node, PropertyName, /*out Type ChildInterfaceType,*/ out ChildNodeType)) { IsValid &= InvariantFailed(IsNodeTreeBlockListValid(node, PropertyName)); } } return(IsValid); }
/// <summary> /// Replaces a node. /// </summary> /// <param name="operation">Details of the operation performed.</param> public virtual void Replace(IWriteableReplaceOperation operation) { Debug.Assert(operation != null); int Index = operation.Index; Debug.Assert(Index >= 0 && Index < StateList.Count); INode ParentNode = Owner.Node; IWriteableNodeState OldChildState = StateList[Index]; INode OldNode = OldChildState.Node; IWriteableBrowsingListNodeIndex OldBrowsingIndex = (IWriteableBrowsingListNodeIndex)OldChildState.ParentIndex; RemoveFromStateList(Index); NodeTreeHelperList.ReplaceNode(ParentNode, PropertyName, Index, operation.NewNode); IWriteableBrowsingListNodeIndex NewBrowsingIndex = CreateBrowsingNodeIndex(operation.NewNode, Index); IWriteablePlaceholderNodeState NewChildState = (IWriteablePlaceholderNodeState)CreateNodeState(NewBrowsingIndex); InsertInStateList(Index, NewChildState); operation.Update(OldBrowsingIndex, NewBrowsingIndex, OldNode, NewChildState); }
/// <summary> /// Initializes a new instance of the <see cref="WriteableInsertionListNodeIndex"/> class. /// </summary> /// <param name="parentNode">Node containing the list.</param> /// <param name="propertyName">Property in <paramref name="parentNode"/> corresponding to the list.</param> /// <param name="node">Inserted node.</param> /// <param name="index">Position where to insert <paramref name="node"/> in the list.</param> public WriteableInsertionListNodeIndex(INode parentNode, string propertyName, INode node, int index) : base(parentNode, propertyName, node) { Debug.Assert(index >= 0); Debug.Assert(NodeTreeHelperList.GetLastListIndex(parentNode, propertyName, out int LastIndex) && index <= LastIndex); Index = index; }
/// <summary> /// Initializes a new instance of the <see cref="ReadOnlyBrowsingListNodeIndex"/> class. /// </summary> /// <param name="parentNode">Node containing the list.</param> /// <param name="node">Indexed node in the list</param> /// <param name="propertyName">Property in <paramref name="parentNode"/> corresponding to the list.</param> /// <param name="index">Position of the node in the list.</param> public ReadOnlyBrowsingListNodeIndex(INode parentNode, INode node, string propertyName, int index) : base(node, propertyName) { Debug.Assert(parentNode != null); Debug.Assert(index >= 0); Debug.Assert(NodeTreeHelperList.IsListChildNode(parentNode, propertyName, index, node)); ParentNode = parentNode; Index = index; }
/// <summary> /// Checks that a frame is correctly constructed. /// </summary> /// <param name="nodeType">Type of the node this frame can describe.</param> /// <param name="nodeTemplateTable">Table of templates with all frames.</param> /// <param name="commentFrameCount">Number of comment frames found so far.</param> public override bool IsValid(Type nodeType, FrameTemplateReadOnlyDictionary nodeTemplateTable, ref int commentFrameCount) { bool IsValid = true; IsValid &= base.IsValid(nodeType, nodeTemplateTable, ref commentFrameCount); IsValid &= NodeTreeHelperList.IsNodeListProperty(nodeType, PropertyName, out Type ChildNodeType); Debug.Assert(IsValid); return(IsValid); }
/// <summary> /// Initializes a new instance of the <see cref="ReadOnlyBrowsingListNodeIndex"/> class. /// </summary> /// <param name="parentNode">Node containing the list.</param> /// <param name="node">Indexed node in the list</param> /// <param name="propertyName">Property in <paramref name="parentNode"/> corresponding to the list.</param> /// <param name="index">Position of the node in the list.</param> public ReadOnlyBrowsingListNodeIndex(Node parentNode, Node node, string propertyName, int index) : base(node, propertyName) { Contract.RequireNotNull(parentNode, out Node ParentNode); Debug.Assert(index >= 0); Debug.Assert(NodeTreeHelperList.IsListChildNode(ParentNode, propertyName, index, node)); this.ParentNode = ParentNode; Index = index; }
/// <summary> /// Checks that a frame visibility is correctly constructed. /// </summary> /// <param name="nodeType">Type of the node this frame visibility can describe.</param> public override bool IsValid(Type nodeType) { bool IsValid = true; IsValid &= !string.IsNullOrEmpty(PropertyName); IsValid &= MaxInvisibleCount >= 0; Type /*ChildInterfaceType,*/ ChildNodeType; IsValid &= NodeTreeHelperList.IsNodeListProperty(nodeType, PropertyName, out ChildNodeType) || NodeTreeHelperBlockList.IsBlockListProperty(nodeType, PropertyName, /*out ChildInterfaceType,*/ out ChildNodeType); return(IsValid); }
private protected virtual void SetNodeTypeToDefault(IFrameTemplateDictionary dictionary, Type nodeType) { Debug.Assert(dictionary.ContainsKey(nodeType)); Debug.Assert(dictionary[nodeType] == null); FrameHorizontalPanelFrame RootFrame = (FrameHorizontalPanelFrame)CreateHorizontalPanelFrame(); FrameNodeTemplate RootTemplate = (FrameNodeTemplate)CreateNodeTemplate(); RootTemplate.NodeType = nodeType; RootTemplate.Root = RootFrame; // Set the template, even if empty, in case the node recursively refers to itself (ex: expressions). dictionary[nodeType] = RootTemplate; RootFrame.Items.Add(CreateCommentFrame()); Type ChildNodeType; IList <string> Properties = NodeTreeHelper.EnumChildNodeProperties(nodeType); foreach (string PropertyName in Properties) { bool IsHandled = false; if (NodeTreeHelperChild.IsChildNodeProperty(nodeType, PropertyName, out ChildNodeType)) { FramePlaceholderFrame NewFrame = (FramePlaceholderFrame)CreatePlaceholderFrame(); NewFrame.PropertyName = PropertyName; RootFrame.Items.Add(NewFrame); IsHandled = true; } else if (NodeTreeHelperOptional.IsOptionalChildNodeProperty(nodeType, PropertyName, out ChildNodeType)) { FrameOptionalFrame NewFrame = (FrameOptionalFrame)CreateOptionalFrame(); NewFrame.PropertyName = PropertyName; RootFrame.Items.Add(NewFrame); IsHandled = true; } else if (NodeTreeHelperList.IsNodeListProperty(nodeType, PropertyName, out Type ListNodeType)) { FrameHorizontalListFrame NewFrame = (FrameHorizontalListFrame)CreateHorizontalListFrame(); NewFrame.PropertyName = PropertyName; RootFrame.Items.Add(NewFrame); IsHandled = true; } else if (NodeTreeHelperBlockList.IsBlockListProperty(nodeType, PropertyName, out Type ChildInterfaceType, out Type ChildItemType)) { FrameHorizontalBlockListFrame NewFrame = (FrameHorizontalBlockListFrame)CreateHorizontalBlockListFrame(); NewFrame.PropertyName = PropertyName; RootFrame.Items.Add(NewFrame); IsHandled = true; }
/// <inheritdoc/> public override void CloneChildren(Node parentNode) { NodeTreeHelperList.ClearChildNodeList(parentNode, PropertyName); for (int i = 0; i < StateList.Count; i++) { IReadOnlyPlaceholderNodeState ChildState = StateList[i]; // Clone all children recursively. Node ChildNodeClone = ChildState.CloneNode(); Debug.Assert(ChildNodeClone != null); NodeTreeHelperList.InsertIntoList(parentNode, PropertyName, i, ChildNodeClone); } }
/// <summary> /// Moves a node around in a list or block list. In a block list, the node stays in same block. /// </summary> /// <param name="operation">Details of the operation performed.</param> public virtual void Move(IWriteableMoveNodeOperation operation) { Debug.Assert(operation != null); int MoveIndex = operation.Index; int Direction = operation.Direction; Debug.Assert(MoveIndex >= 0 && MoveIndex < StateList.Count); Debug.Assert(MoveIndex + operation.Direction >= 0 && MoveIndex + operation.Direction < StateList.Count); IWriteableBrowsingListNodeIndex MovedNodeIndex = StateList[MoveIndex].ParentIndex as IWriteableBrowsingListNodeIndex; Debug.Assert(MovedNodeIndex != null); INode ParentNode = Owner.Node; MoveInStateList(MoveIndex, Direction); NodeTreeHelperList.MoveNode(ParentNode, PropertyName, MoveIndex, Direction); operation.Update(StateList[MoveIndex + Direction]); if (Direction > 0) { for (int i = MoveIndex; i < MoveIndex + Direction; i++) { IWriteableBrowsingListNodeIndex ChildNodeIndex = StateList[i].ParentIndex as IWriteableBrowsingListNodeIndex; Debug.Assert(ChildNodeIndex != null); ChildNodeIndex.MoveDown(); MovedNodeIndex.MoveUp(); } } else if (Direction < 0) { for (int i = MoveIndex; i > MoveIndex + Direction; i--) { IWriteableBrowsingListNodeIndex ChildNodeIndex = StateList[i].ParentIndex as IWriteableBrowsingListNodeIndex; Debug.Assert(ChildNodeIndex != null); ChildNodeIndex.MoveUp(); MovedNodeIndex.MoveDown(); } } }
/// <summary> /// Checks that a frame selector is correctly constructed. /// </summary> /// <param name="nodeType">Type of the node this frame selector can describe.</param> /// <param name="nodeTemplateTable">Table of templates with all frames.</param> /// <param name="propertyName">The property for which frames can be selected.</param> public virtual bool IsValid(Type nodeType, IFocusTemplateReadOnlyDictionary nodeTemplateTable, string propertyName) { bool IsValid = true; IsValid &= SelectorType != null; IsValid &= !string.IsNullOrEmpty(SelectorName); Type ChildInterfaceType, ChildNodeType; IsValid &= NodeTreeHelperChild.IsChildNodeProperty(nodeType, propertyName, out ChildInterfaceType) || NodeTreeHelperOptional.IsOptionalChildNodeProperty(nodeType, propertyName, out ChildInterfaceType) || NodeTreeHelperList.IsNodeListProperty(nodeType, propertyName, out ChildInterfaceType) || NodeTreeHelperBlockList.IsBlockListProperty(nodeType, propertyName, out ChildInterfaceType, out ChildNodeType) || (NodeTreeHelper.IsBlockType(nodeType) && propertyName == nameof(BaseNode.IBlock.NodeList)); IsValid &= nodeTemplateTable.ContainsKey(SelectorType); IFocusNodeTemplate Template = nodeTemplateTable[SelectorType] as IFocusNodeTemplate; Debug.Assert(Template != null); IFocusSelectionFrame AsSelectionFrame = Template.Root as IFocusSelectionFrame; IsValid &= AsSelectionFrame != null; if (IsValid) { IFocusSelectableFrame SelectedItem = null; foreach (IFocusSelectableFrame Item in AsSelectionFrame.Items) { if (Item.Name == SelectorName) { SelectedItem = Item; break; } } IsValid &= SelectedItem != null; } Debug.Assert(IsValid); return(IsValid); }
/// <summary> /// Initializes a new instance of the <see cref="FocusNodeListSelection"/> class. /// </summary> /// <param name="stateView">The state view that encompasses the selection.</param> /// <param name="propertyName">The property name.</param> /// <param name="startIndex">Index of the first selected node in the list.</param> /// <param name="endIndex">Index following the last selected node in the list.</param> public FocusNodeListSelection(IFocusNodeStateView stateView, string propertyName, int startIndex, int endIndex) : base(stateView) { Node Node = stateView.State.Node; Debug.Assert(NodeTreeHelperList.IsNodeListProperty(Node, propertyName, out Type childNodeType)); PropertyName = propertyName; if (startIndex <= endIndex) { StartIndex = startIndex; EndIndex = endIndex; } else { StartIndex = endIndex; EndIndex = startIndex; } }
private protected virtual bool IsNodeTreeListValid(Node node, string propertyName) { NodeTreeHelperList.GetChildNodeList(node, propertyName, out IReadOnlyList <Node> ChildNodeList); Debug.Assert(ChildNodeList != null); bool IsValid = true; if (ChildNodeList.Count == 0) { IsValid &= InvariantFailed(IsEmptyListValid(node, propertyName)); } for (int Index = 0; Index < ChildNodeList.Count; Index++) { Node ChildNode = ChildNodeList[Index]; Debug.Assert(ChildNode != null); IsValid &= InvariantFailed(IsNodeTreeValid(ChildNode)); } return(IsValid); }
private protected virtual bool IsEmptyListValid(Node node, string propertyName) { Type NodeType = Type.FromGetType(node); Debug.Assert(NodeTreeHelperList.IsNodeListProperty(NodeType, propertyName, out Type ChildNodeType)); bool IsValid = true; //Type InterfaceType = NodeTreeHelper.NodeTypeToInterfaceType(NodeType); Type InterfaceType = NodeType; IReadOnlyDictionary <Type, string[]> NeverEmptyCollectionTable = NodeHelper.NeverEmptyCollectionTable; if (NeverEmptyCollectionTable.ContainsKey(InterfaceType)) { foreach (string Item in NeverEmptyCollectionTable[InterfaceType]) { IsValid &= InvariantFailed(Item != propertyName); } } return(IsValid); }
static void BrowseNode(ReadOnlyController controller, IReadOnlyIndex index, Stats stats) { Assert.That(index != null, "ReadOnly #0"); Assert.That(controller.Contains(index), "ReadOnly #1"); IReadOnlyNodeState State = controller.IndexToState(index); Assert.That(State != null, "ReadOnly #2"); Assert.That(State.ParentIndex == index, "ReadOnly #4"); Node Node; if (State is IReadOnlyPlaceholderNodeState AsPlaceholderState) { Node = AsPlaceholderState.Node; } else if (State is IReadOnlyPatternState AsPatternState) { Node = AsPatternState.Node; } else if (State is IReadOnlySourceState AsSourceState) { Node = AsSourceState.Node; } else { Assert.That(State is IReadOnlyOptionalNodeState, "ReadOnly #5"); IReadOnlyOptionalNodeState AsOptionalState = (IReadOnlyOptionalNodeState)State; IReadOnlyOptionalInner ParentInner = AsOptionalState.ParentInner; //Assert.That(ParentInner.IsAssigned, "ReadOnly #6"); Node = AsOptionalState.Node; } stats.NodeCount++; Type ChildNodeType; IList <string> PropertyNames = NodeTreeHelper.EnumChildNodeProperties(Node); foreach (string PropertyName in PropertyNames) { if (NodeTreeHelperChild.IsChildNodeProperty(Node, PropertyName, out ChildNodeType)) { stats.PlaceholderNodeCount++; IReadOnlyPlaceholderInner Inner = (IReadOnlyPlaceholderInner)State.PropertyToInner(PropertyName); IReadOnlyNodeState ChildState = Inner.ChildState; IReadOnlyIndex ChildIndex = ChildState.ParentIndex; BrowseNode(controller, ChildIndex, stats); } else if (NodeTreeHelperOptional.IsOptionalChildNodeProperty(Node, PropertyName, out ChildNodeType)) { stats.OptionalNodeCount++; NodeTreeHelperOptional.GetChildNode(Node, PropertyName, out bool IsAssigned, out Node ChildNode); Debug.Assert(ChildNode is not null); //if (IsAssigned) { if (IsAssigned) { stats.AssignedOptionalNodeCount++; } IReadOnlyOptionalInner Inner = (IReadOnlyOptionalInner)State.PropertyToInner(PropertyName); IReadOnlyNodeState ChildState = Inner.ChildState; IReadOnlyIndex ChildIndex = ChildState.ParentIndex; BrowseNode(controller, ChildIndex, stats); } /*else * stats.NodeCount++;*/ } else if (NodeTreeHelperList.IsNodeListProperty(Node, PropertyName, out ChildNodeType)) { stats.ListCount++; IReadOnlyListInner Inner = (IReadOnlyListInner)State.PropertyToInner(PropertyName); for (int i = 0; i < Inner.StateList.Count; i++) { stats.PlaceholderNodeCount++; IReadOnlyPlaceholderNodeState ChildState = Inner.StateList[i]; IReadOnlyIndex ChildIndex = ChildState.ParentIndex; BrowseNode(controller, ChildIndex, stats); } } else if (NodeTreeHelperBlockList.IsBlockListProperty(Node, PropertyName, /*out Type ChildInterfaceType,*/ out ChildNodeType)) { stats.BlockListCount++; IReadOnlyBlockListInner Inner = (IReadOnlyBlockListInner)State.PropertyToInner(PropertyName); for (int BlockIndex = 0; BlockIndex < Inner.BlockStateList.Count; BlockIndex++) { IReadOnlyBlockState BlockState = Inner.BlockStateList[BlockIndex]; stats.PlaceholderNodeCount++; BrowseNode(controller, BlockState.PatternIndex, stats); stats.PlaceholderNodeCount++; BrowseNode(controller, BlockState.SourceIndex, stats); for (int i = 0; i < BlockState.StateList.Count; i++) { stats.PlaceholderNodeCount++; IReadOnlyPlaceholderNodeState ChildState = BlockState.StateList[i]; IReadOnlyIndex ChildIndex = ChildState.ParentIndex; BrowseNode(controller, ChildIndex, stats); } } } else { Type NodeType = Type.FromGetType(Node); PropertyInfo Info = NodeType.GetProperty(PropertyName); if (Info.PropertyType.IsTypeof <Document>()) { } else if (Info.PropertyType.IsTypeof <bool>()) { } else if (Info.PropertyType.IsEnum) { } else if (Info.PropertyType.IsTypeof <string>()) { } else if (Info.PropertyType.IsTypeof <Guid>()) { } else { Assert.That(false, $"State Tree unexpected property: {Info.PropertyType.Name}"); } } } }
private protected virtual void UpdateInterfaceType(Type nodeType) { if (InterfaceType == Type.Missing) { string[] Split = CollectionName.Split('.'); Type BaseType = nodeType; for (int i = 0; i < Split.Length; i++) { string PropertyName = Split[i]; Type ChildNodeType; if (i + 1 < Split.Length) { bool IsValidProperty = NodeTreeHelperChild.IsChildNodeProperty(BaseType, PropertyName, out ChildNodeType) || NodeTreeHelperOptional.IsOptionalChildNodeProperty(BaseType, PropertyName, out ChildNodeType); Debug.Assert(IsValidProperty); BaseType = ChildNodeType; } else { Type ChildInterfaceType; bool IsValidProperty = NodeTreeHelperBlockList.IsBlockListProperty(BaseType, PropertyName, /*out ChildInterfaceType,*/ out /*ChildNodeType*/ ChildInterfaceType) || NodeTreeHelperList.IsNodeListProperty(BaseType, PropertyName, out ChildInterfaceType); Debug.Assert(IsValidProperty); BaseType = ChildInterfaceType; } } InterfaceType = BaseType; } }
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); } }
private protected virtual void SetNodeTypeToDefault(FrameTemplateDictionary dictionary, Type nodeType) { Debug.Assert(dictionary.ContainsKey(nodeType)); Debug.Assert(dictionary[nodeType] == null); FrameHorizontalPanelFrame RootFrame = (FrameHorizontalPanelFrame)CreateHorizontalPanelFrame(); FrameNodeTemplate RootTemplate = (FrameNodeTemplate)CreateNodeTemplate(); RootTemplate.NodeType = nodeType; RootTemplate.Root = RootFrame; // Set the template, even if empty, in case the node recursively refers to itself (ex: expressions). dictionary[nodeType] = RootTemplate; RootFrame.Items.Add(CreateCommentFrame()); Type ChildNodeType; IList <string> Properties = NodeTreeHelper.EnumChildNodeProperties(nodeType); foreach (string PropertyName in Properties) { bool IsHandled = false; if (NodeTreeHelperChild.IsChildNodeProperty(nodeType, PropertyName, out ChildNodeType)) { FramePlaceholderFrame NewFrame = (FramePlaceholderFrame)CreatePlaceholderFrame(); NewFrame.PropertyName = PropertyName; RootFrame.Items.Add(NewFrame); IsHandled = true; } else if (NodeTreeHelperOptional.IsOptionalChildNodeProperty(nodeType, PropertyName, out ChildNodeType)) { FrameOptionalFrame NewFrame = (FrameOptionalFrame)CreateOptionalFrame(); NewFrame.PropertyName = PropertyName; RootFrame.Items.Add(NewFrame); IsHandled = true; } else if (NodeTreeHelperList.IsNodeListProperty(nodeType, PropertyName, out Type ListNodeType)) { FrameHorizontalListFrame NewFrame = (FrameHorizontalListFrame)CreateHorizontalListFrame(); NewFrame.PropertyName = PropertyName; RootFrame.Items.Add(NewFrame); IsHandled = true; } else if (NodeTreeHelperBlockList.IsBlockListProperty(nodeType, PropertyName, /*out Type ChildInterfaceType,*/ out Type ChildItemType)) { FrameHorizontalBlockListFrame NewFrame = (FrameHorizontalBlockListFrame)CreateHorizontalBlockListFrame(); NewFrame.PropertyName = PropertyName; RootFrame.Items.Add(NewFrame); IsHandled = true; } else if (NodeTreeHelper.IsBooleanProperty(nodeType, PropertyName)) { FrameDiscreteFrame NewDiscreteFrame = (FrameDiscreteFrame)CreateDiscreteFrame(); NewDiscreteFrame.PropertyName = PropertyName; FrameKeywordFrame KeywordFalseFrame = (FrameKeywordFrame)CreateKeywordFrame(); KeywordFalseFrame.Text = $"{PropertyName}=False"; NewDiscreteFrame.Items.Add(KeywordFalseFrame); FrameKeywordFrame KeywordTrueFrame = (FrameKeywordFrame)CreateKeywordFrame(); KeywordTrueFrame.Text = $"{PropertyName}=True"; NewDiscreteFrame.Items.Add(KeywordTrueFrame); RootFrame.Items.Add(NewDiscreteFrame); IsHandled = true; } else if (NodeTreeHelper.IsEnumProperty(nodeType, PropertyName)) { NodeTreeHelper.GetEnumRange(nodeType, PropertyName, out int Min, out int Max); FrameDiscreteFrame NewDiscreteFrame = (FrameDiscreteFrame)CreateDiscreteFrame(); NewDiscreteFrame.PropertyName = PropertyName; for (int i = Min; i <= Max; i++) { FrameKeywordFrame KeywordFrame = (FrameKeywordFrame)CreateKeywordFrame(); KeywordFrame.Text = $"{PropertyName}={i}"; NewDiscreteFrame.Items.Add(KeywordFrame); } RootFrame.Items.Add(NewDiscreteFrame); IsHandled = true; } else if (NodeTreeHelper.IsStringProperty(nodeType, PropertyName)) { FrameTextValueFrame NewDiscreteFrame = (FrameTextValueFrame)CreateTextValueFrame(); NewDiscreteFrame.PropertyName = PropertyName; RootFrame.Items.Add(NewDiscreteFrame); IsHandled = true; } else if (NodeTreeHelper.IsGuidProperty(nodeType, PropertyName)) { IsHandled = true; } else if (NodeTreeHelper.IsDocumentProperty(nodeType, PropertyName)) { IsHandled = true; } Debug.Assert(IsHandled); } RootFrame.UpdateParent(RootTemplate, GetRoot()); }