/// <summary> /// Initializes the cycle index list if not already initialized. /// </summary> public virtual void InitializeCycleIndexList() { // If it's the first time we're cycling through this node, initialize it. if (CycleIndexList == null) { IFocusInsertionChildNodeIndex ThisIndex = ((IFocusBrowsingInsertableIndex)ParentIndex).ToInsertionIndex(ParentState.Node, Node) as IFocusInsertionChildNodeIndex; Debug.Assert(ThisIndex != null); CycleIndexList = CreateInsertionChildIndexList(); CycleIndexList.Add(ThisIndex); } }
/// <summary> /// Checks if a node can be complexified. /// </summary> /// <param name="indexTable">List of indexes of more complex nodes upon return.</param> /// <returns>True if a node can be complexified at the focus.</returns> public virtual bool IsItemComplexifiable(out IDictionary <IFocusInner, IList <IFocusInsertionChildNodeIndex> > indexTable) { indexTable = new Dictionary <IFocusInner, IList <IFocusInsertionChildNodeIndex> >(); bool IsComplexifiable = false; IFocusNodeState CurrentState = Focus.CellView.StateView.State; // Search recursively for a complexifiable node. while (CurrentState != null) { if (NodeHelper.GetComplexifiedNode(CurrentState.Node, out IList <Node> ComplexifiedNodeList)) { Debug.Assert(ComplexifiedNodeList != null && ComplexifiedNodeList.Count > 0); Type InterfaceType = CurrentState.ParentInner.InterfaceType; bool IsAssignable = true; foreach (Node ComplexifiedNode in ComplexifiedNodeList) { IsAssignable &= InterfaceType.IsAssignableFrom(Type.FromGetType(ComplexifiedNode)); } if (IsAssignable) { IFocusBrowsingChildIndex ParentIndex = CurrentState.ParentIndex as IFocusBrowsingChildIndex; Debug.Assert(ParentIndex != null); IFocusInner Inner = CurrentState.ParentInner; IList <IFocusInsertionChildNodeIndex> IndexList = new List <IFocusInsertionChildNodeIndex>(); foreach (Node ComplexifiedNode in ComplexifiedNodeList) { IFocusInsertionChildNodeIndex NodeIndex = ((IFocusBrowsingInsertableIndex)ParentIndex).ToInsertionIndex(Inner.Owner.Node, ComplexifiedNode) as IFocusInsertionChildNodeIndex; IndexList.Add(NodeIndex); } indexTable.Add(Inner, IndexList); IsComplexifiable = true; } } CurrentState = CurrentState.ParentState; } return(IsComplexifiable); }
/// <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 override void Update(IWriteableBrowsingChildIndex oldBrowsingIndex, IWriteableBrowsingChildIndex newBrowsingIndex, INode oldNode, IWriteableNodeState newChildState) { base.Update(oldBrowsingIndex, newBrowsingIndex, oldNode, newChildState); int i; for (i = 0; i < CycleIndexList.Count; i++) { IFocusInsertionChildNodeIndex NodeIndex = CycleIndexList[i]; if (NodeIndex.Node == oldNode) { OldCyclePosition = i; break; } } Debug.Assert(OldCyclePosition < CycleIndexList.Count); Debug.Assert(NewCyclePosition < CycleIndexList.Count); }
/// <summary> /// Replace an existing node with a new one, keeping its cycle. /// </summary> /// <param name="inner">The inner where the node is replaced.</param> /// <param name="cycleIndexList">Cycle of nodes that can replace the current node.</param> /// <param name="cyclePosition">New position in the cycle.</param> /// <param name="nodeIndex">Index of the replacing node upon return.</param> public virtual void Replace(IFocusInner inner, FocusInsertionChildNodeIndexList cycleIndexList, int cyclePosition, out IFocusBrowsingChildIndex nodeIndex) { Contract.RequireNotNull(cycleIndexList, out FocusInsertionChildNodeIndexList CycleIndexList); Debug.Assert(CycleIndexList.Count >= 2); Debug.Assert(cyclePosition >= 0 && cyclePosition < CycleIndexList.Count); IFocusInsertionChildNodeIndex ReplacementIndex = CycleIndexList[cyclePosition]; IndexToPositionAndNode(ReplacementIndex, out int BlockIndex, out int Index, out _, out Node Node); System.Action <IWriteableOperation> HandlerRedo = (IWriteableOperation operation) => ExecuteReplaceWithCycle(operation); System.Action <IWriteableOperation> HandlerUndo = (IWriteableOperation operation) => UndoReplaceWithCycle(operation); IFocusReplaceWithCycleOperation Operation = CreateReplaceWithCycleOperation(inner.Owner.Node, inner.PropertyName, BlockIndex, Index, CycleIndexList, cyclePosition, HandlerRedo, HandlerUndo, isNested: false); ExecuteReplaceWithCycle(Operation); nodeIndex = Operation.NewBrowsingIndex; SetLastOperation(Operation); CheckInvariant(); }
/// <summary></summary> protected override void AddNextNodeToCycle(IFocusCyclableNodeState state) { FocusInsertionChildNodeIndexList CycleIndexList = state.CycleIndexList; Node ParentNode = state.ParentState.Node; IFocusIndex NodeIndex = state.ParentIndex; CycleBodyInfo Info = new(); List <Type> BodyTypeList = new List <Type>() { Type.FromTypeof <EffectiveBody>(), Type.FromTypeof <DeferredBody>(), Type.FromTypeof <ExternBody>(), Type.FromTypeof <PrecursorBody>() }; foreach (IFocusInsertionChildNodeIndex Index in CycleIndexList) { Body Body = (Body)Index.Node; if (BodyTypeList.Contains(Type.FromGetType(Body))) { BodyTypeList.Remove(Type.FromGetType(Body)); } Info.Update(Body); } // If the list is full, no need to add more nodes to the cycle. if (BodyTypeList.Count > 0) { Type NodeType = BodyTypeList[0]; Node NewBody = NodeHelper.CreateInitializedBody(NodeType, Info.Documentation, Info.RequireBlocks, Info.EnsureBlocks, Info.ExceptionIdentifierBlocks, Info.EntityDeclarationBlocks, Info.BodyInstructionBlocks, Info.ExceptionHandlerBlocks, Info.AncestorType); IFocusBrowsingInsertableIndex InsertableNodeIndex = NodeIndex as IFocusBrowsingInsertableIndex; Debug.Assert(InsertableNodeIndex != null); IFocusInsertionChildNodeIndex InsertionIndex = InsertableNodeIndex.ToInsertionIndex(ParentNode, NewBody) as IFocusInsertionChildNodeIndex; Debug.Assert(InsertionIndex != null); CycleIndexList.Add(InsertionIndex); } }
/// <summary></summary> protected override void AddNextNodeToCycle(IFocusCyclableNodeState state) { FocusInsertionChildNodeIndexList CycleIndexList = state.CycleIndexList; Node ParentNode = state.ParentState.Node; IFocusNodeIndex NodeIndex = state.ParentIndex as IFocusNodeIndex; CycleFeatureInfo Info = new(); List <Type> FeatureTypeList = new List <Type>() { Type.FromTypeof <AttributeFeature>(), Type.FromTypeof <ConstantFeature>(), Type.FromTypeof <CreationFeature>(), Type.FromTypeof <FunctionFeature>(), Type.FromTypeof <ProcedureFeature>(), Type.FromTypeof <PropertyFeature>(), Type.FromTypeof <IndexerFeature>() }; foreach (IFocusInsertionChildNodeIndex Index in CycleIndexList) { Feature Feature = Index.Node as Feature; Debug.Assert(Feature != null); if (FeatureTypeList.Contains(Type.FromGetType(Feature))) { FeatureTypeList.Remove(Type.FromGetType(Feature)); } Info.Update(Feature); } // If the list is full, no need to add more nodes to the cycle. if (FeatureTypeList.Count > 0) { Type NodeType = FeatureTypeList[0]; Node NewFeature = NodeHelper.CreateInitializedFeature(NodeType, Info.Documentation, Info.ExportIdentifier, Info.Export, Info.EntityName, Info.EntityType, Info.EnsureBlocks, Info.ConstantValue, Info.CommandOverloadBlocks, Info.Once, Info.QueryOverloadBlocks, Info.PropertyKind, Info.ModifiedQueryBlocks, Info.GetterBody, Info.SetterBody, Info.IndexParameterBlocks, Info.ParameterEnd); IFocusInsertionChildNodeIndex InsertionIndex = (IFocusInsertionChildNodeIndex)((IFocusBrowsingInsertableIndex)NodeIndex).ToInsertionIndex(ParentNode, NewFeature); CycleIndexList.Add(InsertionIndex); } }
/// <summary></summary> protected override void AddNextNodeToCycle(IFocusCyclableNodeState state) { IFocusInsertionChildNodeIndexList CycleIndexList = state.CycleIndexList; INode ParentNode = state.ParentState.Node; IFocusIndex NodeIndex = state.ParentIndex; IDocument Documentation = null; IBlockList <IAssertion, Assertion> RequireBlocks = null; IBlockList <IAssertion, Assertion> EnsureBlocks = null; IBlockList <IIdentifier, Identifier> ExceptionIdentifierBlocks = null; IBlockList <IEntityDeclaration, EntityDeclaration> EntityDeclarationBlocks = null; IBlockList <IInstruction, Instruction> BodyInstructionBlocks = null; IBlockList <IExceptionHandler, ExceptionHandler> ExceptionHandlerBlocks = null; IOptionalReference <IObjectType> AncestorType = null; List <Type> BodyTypeList = new List <Type>() { typeof(EffectiveBody), typeof(DeferredBody), typeof(ExternBody), typeof(PrecursorBody) }; foreach (IFocusInsertionChildNodeIndex Index in CycleIndexList) { IBody Body = Index.Node as IBody; Debug.Assert(Body != null); if (BodyTypeList.Contains(Body.GetType())) { BodyTypeList.Remove(Body.GetType()); } switch (Body) { case IEffectiveBody AsEffective: Documentation = AsEffective.Documentation; RequireBlocks = AsEffective.RequireBlocks; EnsureBlocks = AsEffective.EnsureBlocks; ExceptionIdentifierBlocks = AsEffective.ExceptionIdentifierBlocks; EntityDeclarationBlocks = AsEffective.EntityDeclarationBlocks; BodyInstructionBlocks = AsEffective.BodyInstructionBlocks; ExceptionHandlerBlocks = AsEffective.ExceptionHandlerBlocks; break; case IDeferredBody AsDeferred: Documentation = AsDeferred.Documentation; RequireBlocks = AsDeferred.RequireBlocks; EnsureBlocks = AsDeferred.EnsureBlocks; ExceptionIdentifierBlocks = AsDeferred.ExceptionIdentifierBlocks; break; case IExternBody AsExtern: Documentation = AsExtern.Documentation; RequireBlocks = AsExtern.RequireBlocks; EnsureBlocks = AsExtern.EnsureBlocks; ExceptionIdentifierBlocks = AsExtern.ExceptionIdentifierBlocks; break; case IPrecursorBody AsPrecursor: Documentation = AsPrecursor.Documentation; RequireBlocks = AsPrecursor.RequireBlocks; EnsureBlocks = AsPrecursor.EnsureBlocks; ExceptionIdentifierBlocks = AsPrecursor.ExceptionIdentifierBlocks; AncestorType = AsPrecursor.AncestorType; break; } } // If the list is full, no need to add more nodes to the cycle. if (BodyTypeList.Count > 0) { Type NodeType = BodyTypeList[0]; INode NewBody = NodeHelper.CreateInitializedBody(NodeType, Documentation, RequireBlocks, EnsureBlocks, ExceptionIdentifierBlocks, EntityDeclarationBlocks, BodyInstructionBlocks, ExceptionHandlerBlocks, AncestorType); IFocusBrowsingInsertableIndex InsertableNodeIndex = NodeIndex as IFocusBrowsingInsertableIndex; Debug.Assert(InsertableNodeIndex != null); IFocusInsertionChildNodeIndex InsertionIndex = InsertableNodeIndex.ToInsertionIndex(ParentNode, NewBody) as IFocusInsertionChildNodeIndex; Debug.Assert(InsertionIndex != null); CycleIndexList.Add(InsertionIndex); } }
bool ICollection <IFocusInsertionChildNodeIndex> .Remove(IFocusInsertionChildNodeIndex item) { return(Remove((ILayoutInsertionChildNodeIndex)item)); }
bool ICollection <IFocusInsertionChildNodeIndex> .Contains(IFocusInsertionChildNodeIndex value) { return(Contains((ILayoutInsertionChildNodeIndex)value)); }
void ICollection <IFocusInsertionChildNodeIndex> .Add(IFocusInsertionChildNodeIndex item) { Add((ILayoutInsertionChildNodeIndex)item); }
void IList <IFocusInsertionChildNodeIndex> .Insert(int index, IFocusInsertionChildNodeIndex item) { Insert(index, (ILayoutInsertionChildNodeIndex)item); }
int IList <IFocusInsertionChildNodeIndex> .IndexOf(IFocusInsertionChildNodeIndex value) { return(IndexOf((ILayoutInsertionChildNodeIndex)value)); }
/// <summary></summary> protected override void AddNextNodeToCycle(IFocusCyclableNodeState state) { IFocusInsertionChildNodeIndexList CycleIndexList = state.CycleIndexList; INode ParentNode = state.ParentState.Node; IFocusNodeIndex NodeIndex = state.ParentIndex as IFocusNodeIndex; IDocument Documentation = null; IIdentifier ExportIdentifier = null; ExportStatus Export = ExportStatus.Exported; IName EntityName = null; IObjectType EntityType = null; IBlockList <IAssertion, Assertion> EnsureBlocks = null; IExpression ConstantValue = null; IBlockList <ICommandOverload, CommandOverload> CommandOverloadBlocks = null; OnceChoice Once = OnceChoice.Normal; IBlockList <IQueryOverload, QueryOverload> QueryOverloadBlocks = null; UtilityType PropertyKind = UtilityType.ReadWrite; IBlockList <IIdentifier, Identifier> ModifiedQueryBlocks = null; IOptionalReference <IBody> GetterBody = null; IOptionalReference <IBody> SetterBody = null; IBlockList <IEntityDeclaration, EntityDeclaration> IndexParameterBlocks = null; ParameterEndStatus ParameterEnd = ParameterEndStatus.Closed; List <Type> FeatureTypeList = new List <Type>() { typeof(AttributeFeature), typeof(ConstantFeature), typeof(CreationFeature), typeof(FunctionFeature), typeof(ProcedureFeature), typeof(PropertyFeature), typeof(IndexerFeature) }; foreach (IFocusInsertionChildNodeIndex Index in CycleIndexList) { IFeature Feature = Index.Node as IFeature; Debug.Assert(Feature != null); if (FeatureTypeList.Contains(Feature.GetType())) { FeatureTypeList.Remove(Feature.GetType()); } switch (Feature) { case IAttributeFeature AsAttribute: Documentation = AsAttribute.Documentation; ExportIdentifier = AsAttribute.ExportIdentifier; Export = AsAttribute.Export; EntityName = AsAttribute.EntityName; EntityType = AsAttribute.EntityType; EnsureBlocks = AsAttribute.EnsureBlocks; break; case IConstantFeature AsConstant: Documentation = AsConstant.Documentation; ExportIdentifier = AsConstant.ExportIdentifier; Export = AsConstant.Export; EntityName = AsConstant.EntityName; EntityType = AsConstant.EntityType; ConstantValue = AsConstant.ConstantValue; break; case ICreationFeature AsCreation: Documentation = AsCreation.Documentation; ExportIdentifier = AsCreation.ExportIdentifier; Export = AsCreation.Export; EntityName = AsCreation.EntityName; CommandOverloadBlocks = AsCreation.OverloadBlocks; break; case IFunctionFeature AsFunction: Documentation = AsFunction.Documentation; ExportIdentifier = AsFunction.ExportIdentifier; Export = AsFunction.Export; EntityName = AsFunction.EntityName; Once = AsFunction.Once; QueryOverloadBlocks = AsFunction.OverloadBlocks; break; case IProcedureFeature AsProcedure: Documentation = AsProcedure.Documentation; ExportIdentifier = AsProcedure.ExportIdentifier; Export = AsProcedure.Export; EntityName = AsProcedure.EntityName; CommandOverloadBlocks = AsProcedure.OverloadBlocks; break; case IPropertyFeature AsProperty: Documentation = AsProperty.Documentation; ExportIdentifier = AsProperty.ExportIdentifier; Export = AsProperty.Export; EntityName = AsProperty.EntityName; EntityType = AsProperty.EntityType; PropertyKind = AsProperty.PropertyKind; ModifiedQueryBlocks = AsProperty.ModifiedQueryBlocks; GetterBody = AsProperty.GetterBody; SetterBody = AsProperty.SetterBody; break; case IIndexerFeature AsIndexer: Documentation = AsIndexer.Documentation; ExportIdentifier = AsIndexer.ExportIdentifier; Export = AsIndexer.Export; EntityType = AsIndexer.EntityType; IndexParameterBlocks = AsIndexer.IndexParameterBlocks; ParameterEnd = AsIndexer.ParameterEnd; ModifiedQueryBlocks = AsIndexer.ModifiedQueryBlocks; GetterBody = AsIndexer.GetterBody; SetterBody = AsIndexer.SetterBody; break; } Debug.Assert(CommandOverloadBlocks == null || CommandOverloadBlocks.NodeBlockList.Count > 0); Debug.Assert(QueryOverloadBlocks == null || QueryOverloadBlocks.NodeBlockList.Count > 0); Debug.Assert(IndexParameterBlocks == null || IndexParameterBlocks.NodeBlockList.Count > 0); } // If the list is full, no need to add more nodes to the cycle. if (FeatureTypeList.Count > 0) { Type NodeType = FeatureTypeList[0]; INode NewFeature = NodeHelper.CreateInitializedFeature(NodeType, Documentation, ExportIdentifier, Export, EntityName, EntityType, EnsureBlocks, ConstantValue, CommandOverloadBlocks, Once, QueryOverloadBlocks, PropertyKind, ModifiedQueryBlocks, GetterBody, SetterBody, IndexParameterBlocks, ParameterEnd); IFocusInsertionChildNodeIndex InsertionIndex = (IFocusInsertionChildNodeIndex)((IFocusBrowsingInsertableIndex)NodeIndex).ToInsertionIndex(ParentNode, NewFeature); CycleIndexList.Add(InsertionIndex); } }