public FormatNode SplitNodeBeforeChild(FormatNode child) { FormatStore.NodeEntry[] array = this.nodes.Plane(this.nodeHandle); int num = this.nodes.Index(this.nodeHandle); int handle = this.nodes.Allocate(this.NodeType, array[num].BeginTextPosition); FormatStore.NodeEntry[] array2 = this.nodes.Plane(handle); int num2 = this.nodes.Index(handle); array2[num2].NodeFlags = array[num].NodeFlags; array2[num2].TextMapping = array[num].TextMapping; array2[num2].EndTextPosition = child.BeginTextPosition; array2[num2].FlagProperties = array[num].FlagProperties; array2[num2].PropertyMask = array[num].PropertyMask; array2[num2].Properties = array[num].Properties; array[num].BeginTextPosition = child.BeginTextPosition; FormatNode formatNode = new FormatNode(this.nodes, handle); do { FormatNode firstChild = this.FirstChild; firstChild.RemoveFromParent(); formatNode.AppendChild(firstChild); }while (this.FirstChild != child); this.InsertSiblingBefore(formatNode); return(formatNode); }
public NodePropertiesEnumerator(FormatNode node) { this.FlagProperties = node.FlagProperties; this.Properties = node.Properties; this.CurrentPropertyIndex = 0; this.CurrentProperty = Property.Null; }
public void InsertSiblingBefore(FormatNode newSiblingNode) { int num = newSiblingNode.nodeHandle; FormatStore.NodeEntry[] array = this.nodes.Plane(num); int num2 = this.nodes.Index(num); FormatStore.NodeEntry[] array2 = this.nodes.Plane(this.nodeHandle); int num3 = this.nodes.Index(this.nodeHandle); int parent = array2[num3].Parent; FormatStore.NodeEntry[] array3 = this.nodes.Plane(parent); int num4 = this.nodes.Index(parent); int handle = array3[num4].LastChild; FormatStore.NodeEntry[] array4 = this.nodes.Plane(handle); int num5 = this.nodes.Index(handle); while (array4[num5].NextSibling != this.nodeHandle) { handle = array4[num5].NextSibling; array4 = this.nodes.Plane(handle); num5 = this.nodes.Index(handle); } array[num2].Parent = parent; array[num2].NextSibling = this.nodeHandle; array4[num5].NextSibling = num; }
public void Restart(FormatNode rootNode) { this.outputStackTop = 0; this.currentOutputLevel.Node = rootNode; this.currentOutputLevel.State = FormatOutput.OutputState.NotStarted; this.rootNode = rootNode; }
protected FormatNode CreateNode(FormatContainerType type) { FormatNode result = this.Store.AllocateNode(type); result.EndTextPosition = result.BeginTextPosition; result.SetOutOfOrder(); return(result); }
public void Restart(FormatNode rootNode) { outputStackTop = 0; currentOutputLevel.node = rootNode; currentOutputLevel.state = OutputState.NotStarted; this.rootNode = rootNode; }
public void MoveAllChildrenToNewParent(FormatNode newParent) { while (!this.FirstChild.IsNull) { FormatNode firstChild = this.FirstChild; firstChild.RemoveFromParent(); newParent.AppendChild(firstChild); } }
private void PopPushNextSibling() { FormatNode nextSibling = this.currentOutputLevel.Node.NextSibling; this.Pop(); this.currentOutputLevel.ChildIndex = this.currentOutputLevel.ChildIndex + 1; if (!nextSibling.IsNull) { this.Push(nextSibling); return; } this.currentOutputLevel.State = FormatOutput.OutputState.EndPending; }
private void PushFirstChild() { FormatNode firstChild = this.currentOutputLevel.Node.FirstChild; if (!firstChild.IsNull) { this.currentOutputLevel.State = FormatOutput.OutputState.Started; this.Push(firstChild); return; } if (this.currentOutputLevel.Node.IsText) { this.currentOutputLevel.State = FormatOutput.OutputState.Started; return; } this.currentOutputLevel.State = FormatOutput.OutputState.EndPending; }
private void Push(FormatNode node) { if (outputStack == null) { InternalDebug.Assert(outputStackTop == 0 && formatStore != null); outputStack = new OutputStackEntry[32]; } else if (outputStackTop == outputStack.Length) { if (outputStackTop >= HtmlSupport.HtmlNestingLimit) { throw new TextConvertersException(Strings.InputDocumentTooComplex); } var newOutputStack = new OutputStackEntry[outputStack.Length * 2]; Array.Copy(outputStack, 0, newOutputStack, 0, outputStackTop); outputStack = newOutputStack; } #if DEBUG if (formatOutputTraceWriter != null) { formatOutputTraceWriter.WriteLine("{0}{1} Push {2}", Indent(outputStackTop), outputStackTop, node.NodeType.ToString()); formatOutputTraceWriter.Flush(); } #endif outputStack[outputStackTop++] = currentOutputLevel; currentOutputLevel.node = node; currentOutputLevel.state = OutputState.NotStarted; currentOutputLevel.index = currentOutputLevel.childIndex; currentOutputLevel.childIndex = 0; currentOutputLevel.propertyUndoLevel = propertyState.ApplyProperties(node.FlagProperties, node.Properties, FormatStoreData.GlobalInheritanceMasks[node.InheritanceMaskIndex].flagProperties, FormatStoreData.GlobalInheritanceMasks[node.InheritanceMaskIndex].propertyMask); #if DEBUG if (formatOutputTraceWriter != null) { formatOutputTraceWriter.WriteLine("{0}{1} Props After {2}", Indent(outputStackTop), outputStackTop, propertyState.ToString()); formatOutputTraceWriter.Flush(); } #endif node.SetOnLeftEdge(); }
private void PrepareToCloseContainer(int stackPosition) { if (this.BuildStack[stackPosition].Properties != null) { for (int i = 0; i < this.BuildStack[stackPosition].Properties.Length; i++) { if (this.BuildStack[stackPosition].Properties[i].Value.IsRefCountedHandle) { this.Store.ReleaseValue(this.BuildStack[stackPosition].Properties[i].Value); } } this.BuildStack[stackPosition].Properties = null; } if (this.BuildStack[stackPosition].Node != 0) { FormatNode node = this.Store.GetNode(this.BuildStack[stackPosition].Node); if (!this.newLine && (byte)(node.NodeType & FormatContainerType.BlockFlag) != 0) { this.Store.AddBlockBoundary(); this.newLine = true; this.textQuotingExpected = true; } node.PrepareToClose(this.Store.CurrentTextPosition); if (!node.Parent.IsNull && node.Parent.NodeType == FormatContainerType.TableContainer) { node.Parent.PrepareToClose(this.Store.CurrentTextPosition); } if (this.BuildStack[stackPosition].Node == this.LastNodeInternal) { for (int j = stackPosition - 1; j >= 0; j--) { if (this.BuildStack[j].Node != 0) { this.LastNodeInternal = this.BuildStack[j].Node; break; } } } } this.Store.SetTextBoundary(); this.EmptyContainer = false; }
public FormatNode SplitTextNode(uint splitPosition) { FormatStore.NodeEntry[] array = this.nodes.Plane(this.nodeHandle); int num = this.nodes.Index(this.nodeHandle); int handle = this.nodes.Allocate(FormatContainerType.Text, array[num].BeginTextPosition); FormatStore.NodeEntry[] array2 = this.nodes.Plane(handle); int num2 = this.nodes.Index(handle); array2[num2].NodeFlags = array[num].NodeFlags; array2[num2].TextMapping = array[num].TextMapping; array2[num2].EndTextPosition = splitPosition; array2[num2].FlagProperties = array[num].FlagProperties; array2[num2].PropertyMask = array[num].PropertyMask; array2[num2].Properties = array[num].Properties; array[num].BeginTextPosition = splitPosition; FormatNode formatNode = new FormatNode(this.nodes, handle); this.InsertSiblingBefore(formatNode); return(formatNode); }
public FormatNode DuplicateInsertAsChild() { int handle = this.nodes.Allocate(this.NodeType, this.BeginTextPosition); FormatStore.NodeEntry[] array = this.nodes.Plane(this.nodeHandle); int num = this.nodes.Index(this.nodeHandle); FormatStore.NodeEntry[] array2 = this.nodes.Plane(handle); int num2 = this.nodes.Index(handle); array2[num2].NodeFlags = array[num].NodeFlags; array2[num2].TextMapping = array[num].TextMapping; array2[num2].EndTextPosition = array[num].EndTextPosition; array2[num2].FlagProperties = array[num].FlagProperties; array2[num2].PropertyMask = array[num].PropertyMask; array2[num2].Properties = array[num].Properties; FormatNode formatNode = new FormatNode(this.nodes, handle); this.MoveAllChildrenToNewParent(formatNode); this.AppendChild(formatNode); return(formatNode); }
public void InsertSiblingAfter(FormatNode newSiblingNode) { int num = newSiblingNode.nodeHandle; FormatStore.NodeEntry[] array = this.nodes.Plane(num); int num2 = this.nodes.Index(num); FormatStore.NodeEntry[] array2 = this.nodes.Plane(this.nodeHandle); int num3 = this.nodes.Index(this.nodeHandle); int parent = array2[num3].Parent; FormatStore.NodeEntry[] array3 = this.nodes.Plane(parent); int num4 = this.nodes.Index(parent); array[num2].Parent = parent; array[num2].NextSibling = array2[num3].NextSibling; array2[num3].NextSibling = num; if (this.nodeHandle == array3[num4].LastChild) { array3[num4].LastChild = num; } }
private void Push(FormatNode node) { if (this.outputStack == null) { this.outputStack = new FormatOutput.OutputStackEntry[32]; } else if (this.outputStackTop == this.outputStack.Length) { if (this.outputStackTop >= 4096) { throw new TextConvertersException(TextConvertersStrings.InputDocumentTooComplex); } FormatOutput.OutputStackEntry[] destinationArray = new FormatOutput.OutputStackEntry[this.outputStack.Length * 2]; Array.Copy(this.outputStack, 0, destinationArray, 0, this.outputStackTop); this.outputStack = destinationArray; } this.outputStack[this.outputStackTop++] = this.currentOutputLevel; this.currentOutputLevel.Node = node; this.currentOutputLevel.State = FormatOutput.OutputState.NotStarted; this.currentOutputLevel.Index = this.currentOutputLevel.ChildIndex; this.currentOutputLevel.ChildIndex = 0; this.currentOutputLevel.PropertyUndoLevel = this.propertyState.ApplyProperties(node.FlagProperties, node.Properties, FormatStoreData.GlobalInheritanceMasks[node.InheritanceMaskIndex].FlagProperties, FormatStoreData.GlobalInheritanceMasks[node.InheritanceMaskIndex].PropertyMask); node.SetOnLeftEdge(); }
public void OutputFragment(FormatNode beginNode, uint beginTextPosition, FormatNode endNode, uint endTextPosition) { this.Restart(this.rootNode); FormatNode formatNode = beginNode; int num = 0; while (formatNode != this.rootNode) { num++; formatNode = formatNode.Parent; } if (this.outputStack == null) { this.outputStack = new FormatOutput.OutputStackEntry[Math.Max(32, num)]; } else if (this.outputStack.Length < num) { if (this.outputStackTop >= 4096) { throw new TextConvertersException(TextConvertersStrings.InputDocumentTooComplex); } this.outputStack = new FormatOutput.OutputStackEntry[Math.Max(this.outputStack.Length * 2, num)]; } formatNode = beginNode; int i = num - 1; while (formatNode != this.rootNode) { this.outputStack[i--].Node = formatNode; formatNode = formatNode.Parent; } for (i = 0; i < num; i++) { if (!this.StartCurrentLevel()) { this.PopPushNextSibling(); break; } this.currentOutputLevel.State = FormatOutput.OutputState.Started; this.Push(this.outputStack[i].Node); } bool flag = false; while (this.currentOutputLevel.State != FormatOutput.OutputState.Ended) { if (this.currentOutputLevel.State == FormatOutput.OutputState.NotStarted) { if (this.StartCurrentLevel()) { this.PushFirstChild(); } else { this.PopPushNextSibling(); } } else if (this.currentOutputLevel.State == FormatOutput.OutputState.Started) { uint num2 = (this.currentOutputLevel.Node == beginNode) ? beginTextPosition : this.currentOutputLevel.Node.BeginTextPosition; uint num3 = (this.currentOutputLevel.Node == endNode) ? endTextPosition : this.currentOutputLevel.Node.EndTextPosition; if (num2 <= num3) { this.ContinueText(num2, num3); } this.currentOutputLevel.State = FormatOutput.OutputState.EndPending; } else { this.EndCurrentLevel(); this.currentOutputLevel.State = FormatOutput.OutputState.Ended; if (this.outputStackTop != 0) { if (!flag && this.currentOutputLevel.Node != endNode && (this.currentOutputLevel.Node.NextSibling.IsNull || this.currentOutputLevel.Node.NextSibling != endNode || (this.currentOutputLevel.Node.NextSibling.NodeType == FormatContainerType.Text && this.currentOutputLevel.Node.NextSibling.BeginTextPosition < endTextPosition))) { this.PopPushNextSibling(); } else { this.Pop(); this.currentOutputLevel.State = FormatOutput.OutputState.EndPending; flag = true; } } } } }
public void OutputFragment(FormatNode fragmentNode) { this.Restart(fragmentNode); this.FlushFragment(); }
private void FlushContainer(int stackPos) { FormatContainerType formatContainerType = this.FixContainerType(this.BuildStack[stackPos].Type, this.ContainerStyleBuildHelper); if (formatContainerType != this.BuildStack[stackPos].Type) { this.BuildStack[stackPos].Type = formatContainerType; } this.ContainerStyleBuildHelper.GetPropertyList(out this.BuildStack[stackPos].Properties, out this.BuildStack[stackPos].FlagProperties, out this.BuildStack[stackPos].PropertyMask); if (!this.BuildStack[stackPos].IsPropertyContainerOrNull) { if (!this.newLine && (byte)(this.BuildStack[stackPos].Type & FormatContainerType.BlockFlag) != 0) { this.Store.AddBlockBoundary(); this.newLine = true; this.textQuotingExpected = true; } FormatNode formatNode; if (formatContainerType == FormatContainerType.Document) { formatNode = this.Store.AllocateNode(this.BuildStack[stackPos].Type, 0U); } else { formatNode = this.Store.AllocateNode(this.BuildStack[stackPos].Type); } formatNode.SetOnRightEdge(); if ((byte)(this.BuildStack[stackPos].Type & FormatContainerType.InlineObjectFlag) != 0) { this.Store.AddInlineObject(); } FormatNode node = this.Store.GetNode(this.LastNodeInternal); int num; this.GetParentForNewNode(formatNode, node, stackPos, out num).AppendChild(formatNode); this.BuildStack[stackPos].Node = formatNode.Handle; this.LastNodeInternal = formatNode.Handle; FlagProperties flagProperties2; Property[] properties; PropertyBitMask propertyMask; if (num < stackPos) { FlagProperties flagProperties = FlagProperties.AllOn; PropertyBitMask propertyBitMask = PropertyBitMask.AllOn; int num2 = stackPos; while (num2 >= num && (!flagProperties.IsClear || !propertyBitMask.IsClear)) { if (num2 == stackPos || this.BuildStack[num2].Type == FormatContainerType.PropertyContainer) { flagProperties2 = (this.BuildStack[num2].FlagProperties & flagProperties); this.ContainerStyleBuildHelper.AddProperties(11, flagProperties2, propertyBitMask, this.BuildStack[num2].Properties); flagProperties &= ~this.BuildStack[num2].FlagProperties; propertyBitMask &= ~this.BuildStack[num2].PropertyMask; flagProperties &= FormatStoreData.GlobalInheritanceMasks[this.BuildStack[num2].InheritanceMaskIndex].FlagProperties; propertyBitMask &= FormatStoreData.GlobalInheritanceMasks[this.BuildStack[num2].InheritanceMaskIndex].PropertyMask; } num2--; } this.ContainerStyleBuildHelper.GetPropertyList(out properties, out flagProperties2, out propertyMask); } else { flagProperties2 = this.BuildStack[stackPos].FlagProperties; propertyMask = this.BuildStack[stackPos].PropertyMask; properties = this.BuildStack[stackPos].Properties; if (properties != null) { for (int i = 0; i < properties.Length; i++) { if (properties[i].Value.IsRefCountedHandle) { this.Store.AddRefValue(properties[i].Value); } } } } formatNode.SetProps(flagProperties2, propertyMask, properties, this.BuildStack[stackPos].InheritanceMaskIndex); } this.ContainerStyleBuildHelper.Clean(); this.ContainerFlushed = true; }
public void OutputFragment(FormatNode beginNode, uint beginTextPosition, FormatNode endNode, uint endTextPosition) { Restart(rootNode); var node = beginNode; var countStartLevels = 0; while (node != rootNode) { countStartLevels++; node = node.Parent; } if (outputStack == null) { InternalDebug.Assert(outputStackTop == 0 && formatStore != null); outputStack = new OutputStackEntry[Math.Max(32, countStartLevels)]; } else if (outputStack.Length < countStartLevels) { if (outputStackTop >= HtmlSupport.HtmlNestingLimit) { throw new TextConvertersException(Strings.InputDocumentTooComplex); } outputStack = new OutputStackEntry[Math.Max(outputStack.Length * 2, countStartLevels)]; } node = beginNode; var level = countStartLevels - 1; while (node != rootNode) { outputStack[level--].node = node; node = node.Parent; } InternalDebug.Assert(level == -1); for (level = 0; level < countStartLevels; level++) { if (!StartCurrentLevel()) { PopPushNextSibling(); break; } currentOutputLevel.state = OutputState.Started; Push(outputStack[level].node); } var endReached = false; while (currentOutputLevel.state != OutputState.Ended) { if (currentOutputLevel.state == OutputState.NotStarted) { if (StartCurrentLevel()) { PushFirstChild(); } else { PopPushNextSibling(); } } else if (currentOutputLevel.state == OutputState.Started) { InternalDebug.Assert(currentOutputLevel.node.NodeType == FormatContainerType.Text); var nodeBeginTextPosition = currentOutputLevel.node == beginNode ? beginTextPosition : currentOutputLevel.node.BeginTextPosition; var nodeEndTextPosition = currentOutputLevel.node == endNode ? endTextPosition : currentOutputLevel.node.EndTextPosition; if (nodeBeginTextPosition <= nodeEndTextPosition) { ContinueText(nodeBeginTextPosition, nodeEndTextPosition); } currentOutputLevel.state = OutputState.EndPending; } else { InternalDebug.Assert(currentOutputLevel.state == OutputState.EndPending); EndCurrentLevel(); currentOutputLevel.state = OutputState.Ended; if (outputStackTop != 0) { if (!endReached && currentOutputLevel.node != endNode && (currentOutputLevel.node.NextSibling.IsNull || currentOutputLevel.node.NextSibling != endNode || (currentOutputLevel.node.NextSibling.NodeType == FormatContainerType.Text && currentOutputLevel.node.NextSibling.BeginTextPosition < endTextPosition))) { PopPushNextSibling(); } else { Pop(); currentOutputLevel.state = OutputState.EndPending; endReached = true; } } } } InternalDebug.Assert(outputStackTop == 0); InternalDebug.Assert(propertyState.UndoStackTop == 0); }
public void OutputFragment(FormatNode fragmentNode) { Restart(fragmentNode); FlushFragment(); }
public void PrependChild(FormatNode newChildNode) { FormatNode.InternalPrependChild(this.nodes, this.nodeHandle, newChildNode.Handle); }
internal static void InternalAppendChild(FormatStore.NodeStore nodes, int thisNode, int newChildNode) { FormatNode.InternalPrependChild(nodes, thisNode, newChildNode); nodes.Plane(thisNode)[nodes.Index(thisNode)].LastChild = newChildNode; }
protected virtual FormatNode GetParentForNewNode(FormatNode node, FormatNode defaultParent, int stackPos, out int propContainerInheritanceStopLevel) { propContainerInheritanceStopLevel = this.DefaultPropContainerInheritanceStopLevel(stackPos); return(defaultParent); }