/// <summary> /// Update the operation with details. /// </summary> /// <param name="state">State changed.</param> /// <param name="oldValue">The old value.</param> public virtual void Update(IWriteableNodeState state, int oldValue) { Contract.RequireNotNull(state, out IWriteableNodeState State); this.State = State; OldValue = oldValue; }
bool IDictionary <IWriteableNodeState, IWriteableNodeStateView> .TryGetValue(IWriteableNodeState key, out IWriteableNodeStateView value) { bool Result = TryGetValue((IFocusNodeState)key, out IFocusNodeStateView Value); value = Value; return(Result); }
/// <summary> /// Update the operation with details. /// </summary> /// <param name="state">State changed.</param> /// <param name="oldValue">The old value.</param> public virtual void Update(IWriteableNodeState state, int oldValue) { Debug.Assert(state != null); State = state; OldValue = oldValue; }
private protected virtual void PruneStateChildren(IWriteableNodeState state) { foreach (string Key in state.InnerTable.Keys) { IWriteableInner Value = (IWriteableInner)state.InnerTable[Key]; bool IsHandled = false; if (Value is IWriteablePlaceholderInner <IWriteableBrowsingPlaceholderNodeIndex> AsPlaceholderInner) { PrunePlaceholderInner(AsPlaceholderInner); IsHandled = true; } else if (Value is IWriteableOptionalInner <IWriteableBrowsingOptionalNodeIndex> AsOptionalInner) { PruneOptionalInner(AsOptionalInner); IsHandled = true; } else if (Value is IWriteableListInner <IWriteableBrowsingListNodeIndex> AsListInner) { PruneListInner(AsListInner); IsHandled = true; } else if (Value is IWriteableBlockListInner <IWriteableBrowsingBlockNodeIndex> AsBlockListInner) { PruneBlockListInner(AsBlockListInner); IsHandled = true; } Debug.Assert(IsHandled); } }
/// <summary> /// Initializes a new instance of the <see cref="WriteableBrowseContext"/> class. /// </summary> /// <param name="state">The state that will be browsed.</param> public WriteableBrowseContext(IWriteableNodeState state) : base(state) { Debug.Assert(State == state); Debug.Assert(IndexCollectionList != null); Debug.Assert(IndexCollectionList.Count == 0); }
/// <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> /// Replaces a node. /// </summary> /// <param name="operation">Details of the operation performed.</param> public virtual void Replace(IWriteableReplaceOperation operation) { int BlockIndex = operation.BlockIndex; Debug.Assert(BlockIndex >= 0 && BlockIndex < BlockStateList.Count); IWriteableBlockState BlockState = (IWriteableBlockState)BlockStateList[BlockIndex]; int Index = operation.Index; Debug.Assert(Index >= 0 && Index < BlockState.StateList.Count); IBlock ChildBlock = BlockState.ChildBlock; Node ParentNode = Owner.Node; IWriteableNodeState OldChildState = (IWriteableNodeState)BlockState.StateList[Index]; Node OldNode = OldChildState.Node; IWriteableBrowsingBlockNodeIndex OldBrowsingIndex = (IWriteableBrowsingBlockNodeIndex)OldChildState.ParentIndex; BlockState.Remove(OldBrowsingIndex, Index); NodeTreeHelperBlockList.ReplaceInBlock(ChildBlock, Index, operation.NewNode); IWriteableBrowsingExistingBlockNodeIndex NewBrowsingIndex = CreateBrowsingNodeIndex(operation.NewNode, BlockIndex, Index); IWriteablePlaceholderNodeState NewChildState = (IWriteablePlaceholderNodeState)CreateNodeState(NewBrowsingIndex); BlockState.Insert(NewBrowsingIndex, Index, NewChildState); operation.Update(OldBrowsingIndex, NewBrowsingIndex, OldNode, NewChildState); }
/// <summary> /// Replace an existing node with a new one. /// </summary> /// <param name="inner">The inner where the node is replaced.</param> /// <param name="replaceIndex">Index for the replace operation.</param> /// <param name="nodeIndex">Index of the replacing node upon return.</param> public void Replace(IWriteableInner inner, IWriteableInsertionChildIndex replaceIndex, out IWriteableBrowsingChildIndex nodeIndex) { Contract.RequireNotNull(inner, out IWriteableInner Inner); Contract.RequireNotNull(replaceIndex, out IWriteableInsertionChildIndex ReplaceIndex); IWriteableNodeState Owner = Inner.Owner; IWriteableIndex ParentIndex = Owner.ParentIndex; Debug.Assert(Contains(ParentIndex)); Debug.Assert(IndexToState(ParentIndex) == Owner); WriteableInnerReadOnlyDictionary <string> InnerTable = Owner.InnerTable; Debug.Assert(InnerTable.ContainsKey(Inner.PropertyName)); Debug.Assert(InnerTable[Inner.PropertyName] == Inner); IndexToPositionAndNode(ReplaceIndex, out int BlockIndex, out int Index, out bool ClearNode, out Node NewNode); Action <IWriteableOperation> HandlerRedo = (IWriteableOperation operation) => RedoReplace(operation); Action <IWriteableOperation> HandlerUndo = (IWriteableOperation operation) => UndoReplace(operation); IWriteableReplaceOperation Operation = CreateReplaceOperation(Inner.Owner.Node, Inner.PropertyName, BlockIndex, Index, ClearNode, NewNode, HandlerRedo, HandlerUndo, isNested: false); Operation.Redo(); SetLastOperation(Operation); CheckInvariant(); nodeIndex = Operation.NewBrowsingIndex; }
/// <summary> /// Handler called every time a comment is changed in the controller. /// </summary> /// <param name="operation">Details of the operation performed.</param> private protected virtual void OnCommentChanged(WriteableChangeCommentOperation operation) { IWriteableNodeState State = operation.State; Debug.Assert(State != null); Debug.Assert(StateViewTable.ContainsKey(State)); }
/// <summary> /// Reduces the block list. /// </summary> private protected virtual void ReduceBlockList(IWriteableBlockListInner <IWriteableBrowsingBlockNodeIndex> blockListInner, WriteableOperationList operationList, bool isNested) { if (!blockListInner.IsSingle) { return; } if (NodeHelper.IsCollectionNeverEmpty(blockListInner.Owner.Node, blockListInner.PropertyName)) { return; } if (!NodeHelper.IsCollectionWithExpand(blockListInner.Owner.Node, blockListInner.PropertyName)) { return; } Debug.Assert(blockListInner.BlockStateList.Count == 1); Debug.Assert(blockListInner.BlockStateList[0].StateList.Count == 1); IWriteableNodeState FirstState = (IWriteableNodeState)blockListInner.BlockStateList[0].StateList[0]; if (!NodeHelper.IsDefaultNode(FirstState.Node)) { return; } Action <IWriteableOperation> HandlerRedo = (IWriteableOperation operation) => RedoRemoveBlock(operation); Action <IWriteableOperation> HandlerUndo = (IWriteableOperation operation) => UndoRemoveBlock(operation); IWriteableRemoveBlockOperation Operation = CreateRemoveBlockOperation(blockListInner.Owner.Node, blockListInner.PropertyName, 0, HandlerRedo, HandlerUndo, isNested); Operation.Redo(); operationList.Add(Operation); }
/// <summary> /// Update the operation with details. /// </summary> /// <param name="state">State changed.</param> /// <param name="oldText">The old comment.</param> public virtual void Update(IWriteableNodeState state, string oldText) { Contract.RequireNotNull(state, out IWriteableNodeState State); this.State = State; OldText = oldText; }
/// <summary> /// Inserts a new node in a list or block list. /// </summary> /// <param name="inner">The inner for the list or block list where the node is inserted.</param> /// <param name="insertedIndex">Index for the insertion operation.</param> /// <param name="nodeIndex">Index of the inserted node upon return.</param> public virtual void Insert(IWriteableCollectionInner inner, IWriteableInsertionCollectionNodeIndex insertedIndex, out IWriteableBrowsingCollectionNodeIndex nodeIndex) { Contract.RequireNotNull(inner, out IWriteableCollectionInner Inner); Contract.RequireNotNull(insertedIndex, out IWriteableInsertionCollectionNodeIndex InsertedIndex); IWriteableNodeState Owner = Inner.Owner; IWriteableIndex ParentIndex = Owner.ParentIndex; Debug.Assert(Contains(ParentIndex)); Debug.Assert(IndexToState(ParentIndex) == Owner); WriteableInnerReadOnlyDictionary <string> InnerTable = Owner.InnerTable; Debug.Assert(InnerTable.ContainsKey(Inner.PropertyName)); Debug.Assert(InnerTable[Inner.PropertyName] == Inner); bool IsHandled = false; nodeIndex = null; if (Inner is IWriteableBlockListInner <IWriteableBrowsingBlockNodeIndex> AsBlockListInner && InsertedIndex is IWriteableInsertionNewBlockNodeIndex AsNewBlockIndex) { InsertNewBlock(AsBlockListInner, AsNewBlockIndex, out nodeIndex); IsHandled = true; } else if (Inner is IWriteableCollectionInner <IWriteableBrowsingCollectionNodeIndex> AsCollectionInner && InsertedIndex is IWriteableInsertionCollectionNodeIndex AsCollectionIndex) { InsertNewNode(AsCollectionInner, AsCollectionIndex, out nodeIndex); IsHandled = true; } Debug.Assert(IsHandled); }
/// <summary> /// Update the operation with details. /// </summary> /// <param name="state">State changed.</param> /// <param name="oldText">The old comment.</param> public virtual void Update(IWriteableNodeState state, string oldText) { Debug.Assert(state != null); State = state; OldText = oldText; }
/// <summary> /// Handler called to refresh views. /// </summary> /// <param name="operation">Details of the operation performed.</param> private protected virtual void OnGenericRefresh(WriteableGenericRefreshOperation operation) { Debug.Assert(!operation.IsNested); IWriteableNodeState RefreshState = operation.RefreshState; Debug.Assert(RefreshState != null); Debug.Assert(StateViewTable.ContainsKey(RefreshState)); }
/// <summary> /// Handler called every time a string is changed in the controller. /// </summary> /// <param name="operation">Details of the operation performed.</param> private protected virtual void OnTextChanged(IWriteableChangeTextOperation operation) { Debug.Assert(operation != null); IWriteableNodeState State = operation.State; Debug.Assert(State != null); Debug.Assert(StateViewTable.ContainsKey(State)); }
/// <summary> /// Update the operation with details. /// </summary> /// <param name="blockState">Block state removed.</param> /// <param name="removedState">The state removed.</param> public virtual void Update(IWriteableBlockState blockState, IWriteableNodeState removedState) { Debug.Assert(blockState != null); Debug.Assert(blockState.StateList.Count == 0); BlockState = blockState; Block = blockState.ChildBlock; RemovedState = removedState; Node = removedState.Node; }
private protected virtual void Canonicalize(IWriteableNodeState state, WriteableOperationList operationList) { IWriteableNodeIndex NodeIndex = state.ParentIndex as IWriteableNodeIndex; Debug.Assert(NodeIndex != null); CanonicalizeChildren(state, operationList); Reduce(NodeIndex, operationList, isNested: state != RootState); }
/// <summary> /// Update the operation with details. /// </summary> /// <param name="blockState">Block state removed.</param> /// <param name="removedState">The state removed.</param> public virtual void Update(IWriteableBlockState blockState, IWriteableNodeState removedState) { Contract.RequireNotNull(blockState, out IWriteableBlockState BlockState); Debug.Assert(BlockState.StateList.Count == 0); this.BlockState = BlockState; Block = BlockState.ChildBlock; RemovedState = removedState; Node = removedState.Node; }
/// <summary> /// Split an identifier with replace and insert indexes. /// </summary> /// <param name="inner">The inner where the node is replaced.</param> /// <param name="replaceIndex">Index for the replace operation.</param> /// <param name="insertIndex">Index for the insert operation.</param> /// <param name="firstIndex">Index of the replacing node upon return.</param> /// <param name="secondIndex">Index of the inserted node upon return.</param> public virtual void SplitIdentifier(IWriteableListInner inner, IWriteableInsertionListNodeIndex replaceIndex, IWriteableInsertionListNodeIndex insertIndex, out IWriteableBrowsingListNodeIndex firstIndex, out IWriteableBrowsingListNodeIndex secondIndex) { Contract.RequireNotNull(inner, out IWriteableListInner Inner); Contract.RequireNotNull(replaceIndex, out IWriteableInsertionListNodeIndex ReplaceIndex); Contract.RequireNotNull(insertIndex, out IWriteableInsertionListNodeIndex InsertIndex); IWriteableNodeState Owner = Inner.Owner; IWriteableIndex ParentIndex = Owner.ParentIndex; Debug.Assert(Contains(ParentIndex)); Debug.Assert(IndexToState(ParentIndex) == Owner); WriteableInnerReadOnlyDictionary <string> InnerTable = Owner.InnerTable; Debug.Assert(InnerTable.ContainsKey(Inner.PropertyName)); Debug.Assert(InnerTable[Inner.PropertyName] == Inner); int Index = ReplaceIndex.Index; Debug.Assert(InsertIndex.Index == Index + 1); Node ReplacingNode = ReplaceIndex.Node; Node InsertedNode = InsertIndex.Node; Action <IWriteableOperation> HandlerRedoReplace = (IWriteableOperation operation) => RedoReplace(operation); Action <IWriteableOperation> HandlerUndoReplace = (IWriteableOperation operation) => UndoReplace(operation); IWriteableReplaceOperation ReplaceOperation = CreateReplaceOperation(Inner.Owner.Node, Inner.PropertyName, -1, Index, clearNode: false, ReplacingNode, HandlerRedoReplace, HandlerUndoReplace, isNested: true); Action <IWriteableOperation> HandlerRedoInsert = (IWriteableOperation operation) => RedoInsertNewNode(operation); Action <IWriteableOperation> HandlerUndoInsert = (IWriteableOperation operation) => UndoInsertNewNode(operation); WriteableInsertNodeOperation InsertOperation = CreateInsertNodeOperation(Inner.Owner.Node, Inner.PropertyName, -1, Index + 1, InsertedNode, HandlerRedoInsert, HandlerUndoInsert, isNested: true); ReplaceOperation.Redo(); InsertOperation.Redo(); Action <IWriteableOperation> HandlerRedoRefresh = (IWriteableOperation operation) => RedoRefresh(operation); Action <IWriteableOperation> HandlerUndoRefresh = (IWriteableOperation operation) => throw new NotImplementedException(); // Undo is not possible. WriteableGenericRefreshOperation RefreshOperation = CreateGenericRefreshOperation(RootState, HandlerRedoRefresh, HandlerUndoRefresh, isNested: false); RefreshOperation.Redo(); WriteableOperationList OperationList = CreateOperationList(); OperationList.Add(ReplaceOperation); OperationList.Add(InsertOperation); WriteableOperationReadOnlyList OperationReadOnlyList = OperationList.ToReadOnly(); WriteableOperationGroup OperationGroup = CreateOperationGroup(OperationReadOnlyList, RefreshOperation); SetLastOperation(OperationGroup); CheckInvariant(); firstIndex = ReplaceOperation.NewBrowsingIndex as IWriteableBrowsingListNodeIndex; Debug.Assert(firstIndex != null); secondIndex = InsertOperation.BrowsingIndex as IWriteableBrowsingListNodeIndex; Debug.Assert(secondIndex != null); }
/// <summary> /// Update the operation with details. /// </summary> /// <param name="oldBrowsingIndex">Index of the state before it's replaced.</param> /// <param name="newBrowsingIndex">Index of the state after it's replaced.</param> /// <param name="oldNode">The old node. Can be null if optional and replaced.</param> /// <param name="newChildState">The new state.</param> public virtual void Update(IWriteableBrowsingChildIndex oldBrowsingIndex, IWriteableBrowsingChildIndex newBrowsingIndex, Node oldNode, IWriteableNodeState newChildState) { Contract.RequireNotNull(oldBrowsingIndex, out IWriteableBrowsingChildIndex OldBrowsingIndex); Contract.RequireNotNull(newBrowsingIndex, out IWriteableBrowsingChildIndex NewBrowsingIndex); Contract.RequireNotNull(newChildState, out IWriteableNodeState NewChildState); this.OldBrowsingIndex = OldBrowsingIndex; this.NewBrowsingIndex = NewBrowsingIndex; OldNode = oldNode; this.NewChildState = NewChildState; }
/// <summary> /// Update the operation with details. /// </summary> /// <param name="oldBrowsingIndex">Index of the state before it's replaced.</param> /// <param name="newBrowsingIndex">Index of the state after it's replaced.</param> /// <param name="oldNode">The old node. Can be null if optional and replaced.</param> /// <param name="newChildState">The new state.</param> public virtual void Update(IWriteableBrowsingChildIndex oldBrowsingIndex, IWriteableBrowsingChildIndex newBrowsingIndex, INode oldNode, IWriteableNodeState newChildState) { Debug.Assert(oldBrowsingIndex != null); Debug.Assert(newBrowsingIndex != null); Debug.Assert(newChildState != null); OldBrowsingIndex = oldBrowsingIndex; NewBrowsingIndex = newBrowsingIndex; OldNode = oldNode; NewChildState = newChildState; }
/// <summary> /// Handler called every time a state is inserted in the controller. /// </summary> /// <param name="operation">Details of the operation performed.</param> private protected virtual void OnStateInserted(WriteableInsertNodeOperation operation) { IWriteableNodeState ChildState = operation.ChildState; Debug.Assert(ChildState != null); Debug.Assert(StateViewTable.ContainsKey(ChildState)); IWriteableBrowsingCollectionNodeIndex BrowsingIndex = operation.BrowsingIndex; Debug.Assert(ChildState.ParentIndex == BrowsingIndex); }
private protected virtual void ReplaceState(IWriteableReplaceOperation operation, IWriteableInner <IWriteableBrowsingChildIndex> inner) { Contract.RequireNotNull(inner, out IWriteableInner <IWriteableBrowsingChildIndex> Inner); IWriteableNodeState Owner = Inner.Owner; IWriteableIndex ParentIndex = Owner.ParentIndex; Debug.Assert(Contains(ParentIndex)); Debug.Assert(IndexToState(ParentIndex) == Owner); WriteableInnerReadOnlyDictionary <string> InnerTable = Owner.InnerTable; Debug.Assert(InnerTable.ContainsKey(Inner.PropertyName)); Debug.Assert(InnerTable[Inner.PropertyName] == Inner); IWriteableOptionalInner <IWriteableBrowsingOptionalNodeIndex> AsOptionalInner = Inner as IWriteableOptionalInner <IWriteableBrowsingOptionalNodeIndex>; if (AsOptionalInner != null) { IWriteableNodeState OldState = AsOptionalInner.ChildState; PruneStateChildren(OldState); if (AsOptionalInner.IsAssigned) { Stats.AssignedOptionalNodeCount--; } } Inner.Replace(operation); IWriteableBrowsingChildIndex OldBrowsingIndex = operation.OldBrowsingIndex; IWriteableBrowsingChildIndex NewBrowsingIndex = operation.NewBrowsingIndex; IWriteableNodeState ChildState = operation.NewChildState; if (AsOptionalInner != null) { if (AsOptionalInner.IsAssigned) { Stats.AssignedOptionalNodeCount++; } } else { Debug.Assert(Contains(OldBrowsingIndex)); IWriteableNodeState OldState = (IWriteableNodeState)StateTable[OldBrowsingIndex]; PruneStateChildren(OldState); } RemoveState(OldBrowsingIndex); AddState(NewBrowsingIndex, ChildState); BuildStateTable(Inner, null, NewBrowsingIndex, ChildState); }
/// <summary> /// Checks whether a node can be moved in a list. /// </summary> /// <param name="inner">The inner where the node is.</param> /// <param name="nodeIndex">Index of the node that would be moved.</param> /// <param name="direction">Direction of the move, relative to the current position of the item.</param> public virtual bool IsMoveable(IWriteableCollectionInner inner, IWriteableBrowsingCollectionNodeIndex nodeIndex, int direction) { Contract.RequireNotNull(inner, out IWriteableCollectionInner Inner); Contract.RequireNotNull(nodeIndex, out IWriteableBrowsingCollectionNodeIndex NodeIndex); IWriteableNodeState State = (IWriteableNodeState)StateTable[NodeIndex]; Debug.Assert(State != null); bool Result = Inner.IsMoveable(NodeIndex, direction); return(Result); }
private protected virtual void ExecuteRemoveNode(WriteableRemoveNodeOperation operation) { Node ParentNode = operation.ParentNode; string PropertyName = operation.PropertyName; IWriteableCollectionInner <IWriteableBrowsingCollectionNodeIndex> Inner = GetInner(ParentNode, PropertyName) as IWriteableCollectionInner <IWriteableBrowsingCollectionNodeIndex>; Inner.Remove(operation); IWriteableNodeState RemovedState = operation.RemovedState; PruneState(RemovedState); Stats.PlaceholderNodeCount--; NotifyStateRemoved(operation); }
/// <summary> /// Changes the value of an enum or boolean. /// If the value exceeds allowed values, it is rounded to fit. /// </summary> /// <param name="nodeIndex">Index of the state with the enum to change.</param> /// <param name="propertyName">Name of the property to change.</param> /// <param name="value">The new value.</param> public virtual void ChangeDiscreteValue(IWriteableIndex nodeIndex, string propertyName, int value) { Contract.RequireNotNull(nodeIndex, out IWriteableIndex NodeIndex); Debug.Assert(StateTable.ContainsKey(NodeIndex)); Debug.Assert(value >= 0); System.Action <IWriteableOperation> HandlerRedo = (IWriteableOperation operation) => RedoChangeDiscreteValue(operation); System.Action <IWriteableOperation> HandlerUndo = (IWriteableOperation operation) => UndoChangeDiscreteValue(operation); IWriteableNodeState State = (IWriteableNodeState)StateTable[NodeIndex]; WriteableChangeDiscreteValueOperation Operation = CreateChangeDiscreteValueOperation(State.Node, propertyName, value, HandlerRedo, HandlerUndo, isNested: false); Operation.Redo(); SetLastOperation(Operation); CheckInvariant(); }
/// <summary> /// Changes the value of a text. /// </summary> /// <param name="nodeIndex">Index of the state with the comment to change.</param> /// <param name="text">The new comment.</param> public virtual void ChangeComment(IWriteableIndex nodeIndex, string text) { Contract.RequireNotNull(nodeIndex, out IWriteableIndex NodeIndex); Debug.Assert(StateTable.ContainsKey(NodeIndex)); Contract.RequireNotNull(text, out string Text); System.Action <IWriteableOperation> HandlerRedo = (IWriteableOperation operation) => RedoChangeComment(operation); System.Action <IWriteableOperation> HandlerUndo = (IWriteableOperation operation) => UndoChangeComment(operation); IWriteableNodeState State = (IWriteableNodeState)StateTable[NodeIndex]; WriteableChangeCommentOperation Operation = CreateChangeCommentOperation(State.Node, Text, HandlerRedo, HandlerUndo, isNested: false); Operation.Redo(); SetLastOperation(Operation); CheckInvariant(); }
/// <summary> /// Handler called every time a block state is removed from the controller. /// </summary> /// <param name="operation">Details of the operation performed.</param> private protected virtual void OnBlockStateRemoved(IWriteableRemoveBlockOperation operation) { IWriteableBlockState BlockState = operation.BlockState; Debug.Assert(BlockState != null); Debug.Assert(!BlockStateViewTable.ContainsKey(BlockState)); Debug.Assert(!StateViewTable.ContainsKey(BlockState.PatternState)); Debug.Assert(!StateViewTable.ContainsKey(BlockState.SourceState)); IWriteableNodeState RemovedState = operation.RemovedState; Debug.Assert(!StateViewTable.ContainsKey(RemovedState)); Debug.Assert(BlockState.StateList.Count == 0); }
/// <summary> /// Handler called every time a state is replaced in the controller. /// </summary> /// <param name="operation">Details of the operation performed.</param> private protected virtual void OnStateReplaced(IWriteableReplaceOperation operation) { IWriteableNodeState NewChildState = operation.NewChildState; Debug.Assert(NewChildState != null); Debug.Assert(StateViewTable.ContainsKey(NewChildState)); IWriteableBrowsingChildIndex OldBrowsingIndex = operation.OldBrowsingIndex; Debug.Assert(OldBrowsingIndex != null); Debug.Assert(NewChildState.ParentIndex != OldBrowsingIndex); IWriteableBrowsingChildIndex NewBrowsingIndex = operation.NewBrowsingIndex; Debug.Assert(NewBrowsingIndex != null); Debug.Assert(NewChildState.ParentIndex == NewBrowsingIndex); }
private protected virtual void CanonicalizeChildren(IWriteableNodeState state, WriteableOperationList operationList) { List <IWriteableNodeState> ChildStateList = new List <IWriteableNodeState>(); foreach (string Key in state.InnerTable.Keys) { IWriteableInner Value = (IWriteableInner)state.InnerTable[Key]; switch (Value) { case IWriteablePlaceholderInner <IWriteableBrowsingPlaceholderNodeIndex> AsPlaceholderInner: ChildStateList.Add(AsPlaceholderInner.ChildState); break; case IWriteableOptionalInner <IWriteableBrowsingOptionalNodeIndex> AsOptionalInner: if (AsOptionalInner.IsAssigned) { CanonicalizeChildren(AsOptionalInner.ChildState, operationList); } break; case IWriteableListInner <IWriteableBrowsingListNodeIndex> AsListlInner: foreach (IWriteablePlaceholderNodeState ChildState in AsListlInner.StateList) { ChildStateList.Add(ChildState); } break; case IWriteableBlockListInner <IWriteableBrowsingBlockNodeIndex> AsBlockListlInner: foreach (IWriteableBlockState BlockState in AsBlockListlInner.BlockStateList) { foreach (IWriteablePlaceholderNodeState ChildState in BlockState.StateList) { ChildStateList.Add(ChildState); } } break; } } foreach (IWriteableNodeState ChildState in ChildStateList) { Canonicalize(ChildState, operationList); } }