// Returns the character offset of a node.
// In the worst case this takes log time.
internal int GetIMECharOffset()
{
SplayTreeNode node;
int charOffset;
charOffset = 0;
node = this;
// Each iteration walks a sibling tree.
while (true)
{
// Splay this node up to the root, we're referencing it.
node.Splay();
// Offset gets everything to the left of this node.
charOffset += node.LeftCharCount;
node = node.ParentNode;
if (node == null)
{
break;
}
// Add the parent start edge.
TextTreeTextElementNode elementNode = node as TextTreeTextElementNode;
if (elementNode != null)
{
charOffset += elementNode.IMELeftEdgeCharCount;
}
}
return(charOffset);
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
// Returns a shallow copy of this node.
internal override TextTreeNode Clone()
{
TextTreeTextElementNode clone;
clone = new TextTreeTextElementNode();
clone._symbolCount = _symbolCount;
clone._imeCharCount = _imeCharCount;
clone._textElement = _textElement;
return(clone);
}
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
// Returns a shallow copy of this node.
internal override TextTreeNode Clone()
{
TextTreeTextElementNode clone;
clone = new TextTreeTextElementNode();
clone._symbolCount = _symbolCount;
clone._imeCharCount = _imeCharCount;
clone._textElement = _textElement;
return clone;
}
// Token: 0x06003D16 RID: 15638 RVA: 0x0011BC18 File Offset: 0x00119E18
internal TextTreeExtractElementUndoUnit(TextContainer tree, TextTreeTextElementNode elementNode) : base(tree, elementNode.GetSymbolOffset(tree.Generation))
{
this._symbolCount = elementNode.SymbolCount;
this._type = elementNode.TextElement.GetType();
this._localValues = TextTreeUndoUnit.GetPropertyRecordArray(elementNode.TextElement);
this._resources = elementNode.TextElement.Resources;
if (elementNode.TextElement is Table)
{
this._columns = TextTreeDeleteContentUndoUnit.SaveColumns((Table)elementNode.TextElement);
}
}
// Token: 0x06003D15 RID: 15637 RVA: 0x0011BB88 File Offset: 0x00119D88
private TextTreeNode CopyElementNode(TextTreeTextElementNode elementNode, out TextTreeDeleteContentUndoUnit.ContentContainer container)
{
if (elementNode.TextElement is Table)
{
container = new TextTreeDeleteContentUndoUnit.TableElementContentContainer(elementNode.TextElement as Table, TextTreeUndoUnit.GetPropertyRecordArray(elementNode.TextElement), this.CopyContent((TextTreeNode)elementNode.GetFirstContainedNode(), null));
}
else
{
container = new TextTreeDeleteContentUndoUnit.ElementContentContainer(elementNode.TextElement.GetType(), TextTreeUndoUnit.GetPropertyRecordArray(elementNode.TextElement), elementNode.TextElement.Resources, this.CopyContent((TextTreeNode)elementNode.GetFirstContainedNode(), null));
}
return((TextTreeNode)elementNode.GetNextNode());
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
// Creates a new undo unit instance.
internal TextTreeExtractElementUndoUnit(TextContainer tree, TextTreeTextElementNode elementNode)
: base(tree, elementNode.GetSymbolOffset(tree.Generation))
{
_symbolCount = elementNode.SymbolCount;
_type = elementNode.TextElement.GetType();
_localValues = GetPropertyRecordArray(elementNode.TextElement);
_resources = elementNode.TextElement.Resources;
// Table requires additional work for storing its Columns collection
if (elementNode.TextElement is Table)
{
_columns = TextTreeDeleteContentUndoUnit.SaveColumns((Table)elementNode.TextElement);
}
}
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
// Creates a new undo unit instance.
internal TextTreeExtractElementUndoUnit(TextContainer tree, TextTreeTextElementNode elementNode)
: base(tree, elementNode.GetSymbolOffset(tree.Generation))
{
_symbolCount = elementNode.SymbolCount;
_type = elementNode.TextElement.GetType();
_localValues = GetPropertyRecordArray(elementNode.TextElement);
_resources = elementNode.TextElement.Resources;
// Table requires additional work for storing its Columns collection
if (elementNode.TextElement is Table)
{
_columns = TextTreeDeleteContentUndoUnit.SaveColumns((Table)elementNode.TextElement);
}
}
// Copies a TextElement and all its contained content into a ContentContainer.
// Returns the next node to examine.
private TextTreeNode CopyElementNode(TextTreeTextElementNode elementNode, out ContentContainer container)
{
if (elementNode.TextElement is Table)
{
container = new TableElementContentContainer(elementNode.TextElement as Table,
GetPropertyRecordArray(elementNode.TextElement),
CopyContent((TextTreeNode)elementNode.GetFirstContainedNode(), null));
}
else
{
container = new ElementContentContainer(elementNode.TextElement.GetType(),
GetPropertyRecordArray(elementNode.TextElement),
elementNode.TextElement.Resources,
CopyContent((TextTreeNode)elementNode.GetFirstContainedNode(), null));
}
return((TextTreeNode)elementNode.GetNextNode());
}
// Token: 0x060035C2 RID: 13762 RVA: 0x000F442C File Offset: 0x000F262C
internal int GetIMECharOffset()
{
int num = 0;
SplayTreeNode splayTreeNode = this;
for (;;)
{
splayTreeNode.Splay();
num += splayTreeNode.LeftCharCount;
splayTreeNode = splayTreeNode.ParentNode;
if (splayTreeNode == null)
{
break;
}
TextTreeTextElementNode textTreeTextElementNode = splayTreeNode as TextTreeTextElementNode;
if (textTreeTextElementNode != null)
{
num += textTreeTextElementNode.IMELeftEdgeCharCount;
}
}
return(num);
}
// Token: 0x06003D12 RID: 15634 RVA: 0x0011BA44 File Offset: 0x00119C44
private TextTreeDeleteContentUndoUnit.ContentContainer CopyContent(TextTreeNode node, TextTreeNode haltNode)
{
TextTreeDeleteContentUndoUnit.ContentContainer result = null;
TextTreeDeleteContentUndoUnit.ContentContainer contentContainer = null;
while (node != haltNode && node != null)
{
TextTreeTextNode textTreeTextNode = node as TextTreeTextNode;
TextTreeDeleteContentUndoUnit.ContentContainer contentContainer2;
if (textTreeTextNode != null)
{
node = this.CopyTextNode(textTreeTextNode, haltNode, out contentContainer2);
}
else
{
TextTreeObjectNode textTreeObjectNode = node as TextTreeObjectNode;
if (textTreeObjectNode != null)
{
node = this.CopyObjectNode(textTreeObjectNode, out contentContainer2);
}
else
{
Invariant.Assert(node is TextTreeTextElementNode, "Unexpected TextTreeNode type!");
TextTreeTextElementNode elementNode = (TextTreeTextElementNode)node;
node = this.CopyElementNode(elementNode, out contentContainer2);
}
}
if (contentContainer == null)
{
result = contentContainer2;
}
else
{
contentContainer.NextContainer = contentContainer2;
}
contentContainer = contentContainer2;
}
return(result);
}
// Copies a TextElement and all its contained content into a ContentContainer.
// Returns the next node to examine.
private TextTreeNode CopyElementNode(TextTreeTextElementNode elementNode, out ContentContainer container)
{
if(elementNode.TextElement is Table)
{
container = new TableElementContentContainer(elementNode.TextElement as Table,
GetPropertyRecordArray(elementNode.TextElement),
CopyContent((TextTreeNode)elementNode.GetFirstContainedNode(), null));
}
else
{
container = new ElementContentContainer(elementNode.TextElement.GetType(),
GetPropertyRecordArray(elementNode.TextElement),
elementNode.TextElement.Resources,
CopyContent((TextTreeNode)elementNode.GetFirstContainedNode(), null));
}
return (TextTreeNode)elementNode.GetNextNode();
}
// Inserts an element node into a sibling tree. The node is expected to cover existing content.
// Returns the symbol count of all contained nodes the elementNode covers.
private int InsertElementToSiblingTreeComplex(TextPointer startPosition, TextPointer endPosition, TextTreeTextElementNode elementNode,
out int childCharCount)
{
SplayTreeNode containingNode;
SplayTreeNode leftSubTree;
SplayTreeNode middleSubTree;
SplayTreeNode rightSubTree;
int childSymbolCount;
containingNode = startPosition.GetScopingNode();
// Rip out all the nodes the new element node is going to contain.
childSymbolCount = CutContent(startPosition, endPosition, out childCharCount, out leftSubTree, out middleSubTree, out rightSubTree);
// Join left/right trees under elementNode.
TextTreeNode.Join(elementNode, leftSubTree, rightSubTree);
// Reparent middle tree under elementNode.
elementNode.ContainedNode = middleSubTree;
middleSubTree.ParentNode = elementNode;
// Reparent the whole thing under the original container.
containingNode.ContainedNode = elementNode;
elementNode.ParentNode = containingNode;
return childSymbolCount;
}
// Adds a TextTreeExtractElementUndoUnit to the open parent undo unit, if any.
// Called by TextContainer.ExtractElement.
internal static TextTreeExtractElementUndoUnit CreateExtractElementUndoUnit(TextContainer tree, TextTreeTextElementNode elementNode)
{
UndoManager undoManager;
TextTreeExtractElementUndoUnit undoUnit;
undoManager = GetOrClearUndoManager(tree);
if (undoManager == null)
{
return(null);
}
undoUnit = new TextTreeExtractElementUndoUnit(tree, elementNode);
undoManager.Add(undoUnit);
return(undoUnit);
}
// Increments the position reference counts on nodes immediately
// preceding and following a delete operation on a single TextElementNode.
// This is similar to AdjustRefCountsForContentDelete, except that
// in this case we deleting a single node, and positions at the
// BeforeStart/AfterEnd edges may move into contained content, which
// is still live in the tree.
//
// Whenever we delete a span of content, we have to worry about any
// positions still referencing the deleted content. They have enough
// information to find their way back to the surrounding nodes, but
// we need to increment the ref count on those nodes now so that they'll
// still be around when the positions need them.
//
// Because incrementing a ref count on a text node edge may involve
// splitting the text node, this method takes refs to nodes and will
// update the refs if a node is split.
//
// Called by ExtractElementFromSiblingTree.
private void AdjustRefCountsForShallowDelete(ref TextTreeNode previousNode, ElementEdge previousEdge,
ref TextTreeNode nextNode,ElementEdge nextEdge,
ref TextTreeNode firstContainedNode, ref TextTreeNode lastContainedNode,
TextTreeTextElementNode extractedElementNode)
{
previousNode = previousNode.IncrementReferenceCount(previousEdge, extractedElementNode.AfterStartReferenceCount);
nextNode = nextNode.IncrementReferenceCount(nextEdge, extractedElementNode.BeforeEndReferenceCount);
if (firstContainedNode != null)
{
firstContainedNode = firstContainedNode.IncrementReferenceCount(ElementEdge.BeforeStart, extractedElementNode.BeforeStartReferenceCount);
}
else
{
nextNode = nextNode.IncrementReferenceCount(nextEdge, extractedElementNode.BeforeStartReferenceCount);
}
if (lastContainedNode != null)
{
lastContainedNode = lastContainedNode.IncrementReferenceCount(ElementEdge.AfterEnd, extractedElementNode.AfterEndReferenceCount);
}
else
{
previousNode = previousNode.IncrementReferenceCount(previousEdge, extractedElementNode.AfterEndReferenceCount);
}
}
// Removes an element node from its sibling tree.
//
// If deep == true, then this method also removes any contained nodes
// and returns a deep copy of them.
//
// If deep == false, any contained nodes are inserted into the original
// node's sibling tree.
private void ExtractElementFromSiblingTree(SplayTreeNode containingNode, TextTreeTextElementNode elementNode, bool deep)
{
TextTreeNode previousNode;
ElementEdge previousEdge;
TextTreeNode nextNode;
ElementEdge nextEdge;
SplayTreeNode childNode;
SplayTreeNode minChildNode;
SplayTreeNode maxChildNode;
SplayTreeNode localRootNode;
TextTreeNode firstContainedNode;
TextTreeNode lastContainedNode;
// Remember the nodes surrounding the one we're going to remove.
previousNode = (TextTreeNode)elementNode.GetPreviousNode();
previousEdge = ElementEdge.AfterEnd;
if (previousNode == null)
{
previousNode = (TextTreeNode)containingNode;
previousEdge = ElementEdge.AfterStart;
}
nextNode = (TextTreeNode)elementNode.GetNextNode();
nextEdge = ElementEdge.BeforeStart;
if (nextNode == null)
{
nextNode = (TextTreeNode)containingNode;
nextEdge = ElementEdge.BeforeEnd;
}
// Remove the element node.
elementNode.Remove();
Invariant.Assert(elementNode.Role == SplayTreeNodeRole.LocalRoot);
if (deep)
{
// Increment previous/nextNode reference counts. This may involve
// splitting a text node, so we use refs.
AdjustRefCountsForContentDelete(ref previousNode, previousEdge, ref nextNode, nextEdge, elementNode);
// Reparent the removed node with a FixupNode, so that any orphaned
// positions can find their way back to the tree.
// We have to do this after the AdjustRefCountsForContentDelete call, because the fixup
// node doesn't act like a regular node.
elementNode.ParentNode = new TextTreeFixupNode(previousNode, previousEdge, nextNode, nextEdge);
DeepCopy(elementNode);
}
else
{
// Reparent contained nodes to elementNode's parent.
childNode = elementNode.ContainedNode;
elementNode.ContainedNode = null;
if (childNode != null)
{
childNode.ParentNode = null;
firstContainedNode = (TextTreeNode)childNode.GetMinSibling();
lastContainedNode = (TextTreeNode)childNode.GetMaxSibling();
}
else
{
firstContainedNode = null;
lastContainedNode = null;
}
// Increment previous/nextNode reference counts. This may involve
// splitting a text node, so we use refs.
AdjustRefCountsForShallowDelete(ref previousNode, previousEdge, ref nextNode, nextEdge, ref firstContainedNode, ref lastContainedNode, elementNode);
// Reparent the removed node with a FixupNode, so that any orphaned
// positions can find their way back to the tree.
// We have to do this after the AdjustRefCountsForContentDelete call, because the fixup
// node doesn't act like a regular node.
elementNode.ParentNode = new TextTreeFixupNode(previousNode, previousEdge, nextNode, nextEdge, firstContainedNode, lastContainedNode);
if (childNode != null)
{
// Get previous/next nodes into roots of individual trees.
// Then merge them with the element's children.
// We need to splay childNode because it may no longer be a local root.
// The addrefs in AdjustRefCountsForShallowDelete may have created new nodes
// and shuffled the tree.
childNode.Splay();
localRootNode = childNode;
if (previousNode != containingNode)
{
previousNode.Split();
Invariant.Assert(previousNode.Role == SplayTreeNodeRole.LocalRoot);
Invariant.Assert(previousNode.RightChildNode == null);
minChildNode = childNode.GetMinSibling();
minChildNode.Splay();
previousNode.RightChildNode = minChildNode;
minChildNode.ParentNode = previousNode;
localRootNode = previousNode;
}
if (nextNode != containingNode)
{
nextNode.Splay();
Invariant.Assert(nextNode.Role == SplayTreeNodeRole.LocalRoot);
Invariant.Assert(nextNode.LeftChildNode == null);
maxChildNode = childNode.GetMaxSibling();
maxChildNode.Splay();
nextNode.LeftChildNode = maxChildNode;
nextNode.LeftSymbolCount += maxChildNode.LeftSymbolCount + maxChildNode.SymbolCount;
nextNode.LeftCharCount += maxChildNode.LeftCharCount + maxChildNode.IMECharCount;
maxChildNode.ParentNode = nextNode;
localRootNode = nextNode;
}
containingNode.ContainedNode = localRootNode;
if (localRootNode != null)
{
localRootNode.ParentNode = containingNode;
}
}
}
}
// Inserts an element node into a sibling tree.
// Returns the symbol count of any contained nodes the elementNode covers.
private int InsertElementToSiblingTree(TextPointer startPosition, TextPointer endPosition, TextTreeTextElementNode elementNode)
{
int childSymbolCount = 0;
int childCharCount = 0;
if (startPosition.CompareTo(endPosition) == 0)
{
// Simple insert, no children for elementNode.
// Calculate childCharCount now, before we change position.
// IMELeftEdgeCharCount depends on context.
int childIMECharCount = elementNode.IMECharCount - elementNode.IMELeftEdgeCharCount;
elementNode.InsertAtPosition(startPosition);
if (elementNode.ContainedNode != null)
{
childSymbolCount = elementNode.SymbolCount - 2;
childCharCount = childIMECharCount;
}
}
else
{
// Complex insert, elementNode is going to have children.
childSymbolCount = InsertElementToSiblingTreeComplex(startPosition, endPosition, elementNode, out childCharCount);
}
elementNode.SymbolCount = childSymbolCount + 2;
elementNode.IMECharCount = childCharCount + elementNode.IMELeftEdgeCharCount;
return childSymbolCount;
}
// Returns a copy of elementNode and all its children. The copy is
// guaranteed to have no position references.
//
// All TextElements referencing TextTreeTextElementNodes in the copy
// are adjusted to point to the new copied nodes.
private TextTreeTextElementNode DeepCopy(TextTreeTextElementNode elementNode)
{
TextTreeTextElementNode clone;
clone = (TextTreeTextElementNode)elementNode.Clone();
elementNode.TextElement.TextElementNode = clone;
if (elementNode.ContainedNode != null)
{
clone.ContainedNode = DeepCopyContainedNodes((TextTreeNode)elementNode.ContainedNode.GetMinSibling());
clone.ContainedNode.ParentNode = clone;
}
return clone;
}
// InsertElement worker. Adds a TextElement to the tree.
// If element is already in a tree, we remove it, do a deep copy of its content,
// and insert that too.
internal void InsertElementInternal(TextPointer startPosition, TextPointer endPosition, TextElement element)
{
TextTreeTextElementNode elementNode;
int symbolOffset;
int childSymbolCount;
TextPointer startEdgePosition;
TextPointer endEdgePosition;
char[] elementText;
ExtractChangeEventArgs extractChangeEventArgs;
DependencyObject parentLogicalNode;
bool newElementNode;
int deltaCharCount;
Invariant.Assert(!this.PlainTextOnly);
Invariant.Assert(startPosition.TextContainer == this);
Invariant.Assert(endPosition.TextContainer == this);
DemandCreateText();
startPosition.SyncToTreeGeneration();
endPosition.SyncToTreeGeneration();
bool scopesExistingContent = startPosition.CompareTo(endPosition) != 0;
BeforeAddChange();
// Remove element from any previous tree.
// When called from a public method we already checked all the
// illegal cases in CanInsertElementInternal.
if (element.TextElementNode != null)
{
// This element is already in a tree. Remove it!
bool sameTextContainer = (this == element.TextContainer);
if (!sameTextContainer)
{
// This is a cross-tree extract.
// We need to start a change block now, so that we can
// raise a Changing event inside ExtractElementInternal
// before raising the LogicalTree events below.
// We'll make an EndChange call to wrap up below.
element.TextContainer.BeginChange();
}
bool exceptionThrown = true;
try
{
// ExtractElementInternal will raise LogicalTree events which
// could raise exceptions from external code.
elementText = element.TextContainer.ExtractElementInternal(element, true /* deep */, out extractChangeEventArgs);
exceptionThrown = false;
}
finally
{
if (exceptionThrown && !sameTextContainer)
{
// If an exception is thrown, make sure we close the
// change block we opened above before unwinding.
element.TextContainer.EndChange();
}
}
elementNode = element.TextElementNode;
deltaCharCount = extractChangeEventArgs.ChildIMECharCount;
if (sameTextContainer)
{
// Re-[....] the TextPointers in case we just extracted from this tree.
startPosition.SyncToTreeGeneration();
endPosition.SyncToTreeGeneration();
// We must add the extract change now, before we move on to the insert.
// (When !sameTextContainer we want to delay the notification in the extract
// tree until the insert tree is in an accessible state, ie at the end of this method.)
extractChangeEventArgs.AddChange();
// Don't re-raise the change below.
extractChangeEventArgs = null;
}
newElementNode = false;
}
else
{
// Allocate a node in the tree to hold the element.
elementText = null;
elementNode = new TextTreeTextElementNode();
deltaCharCount = 0;
newElementNode = true;
extractChangeEventArgs = null;
}
parentLogicalNode = startPosition.GetLogicalTreeNode();
// Invalidate any TextElementCollection that depends on the parent.
// Make sure we do that before raising any public events.
TextElementCollectionHelper.MarkDirty(parentLogicalNode);
// Link the TextElement to the TextElementNode.
if (newElementNode)
{
elementNode.TextElement = element;
element.TextElementNode = (TextTreeTextElementNode)elementNode;
}
// If the new element will become the parent of an old element,
// the old element may become a firstIMEVisibleSibling.
TextTreeTextElementNode newFirstIMEVisibleNode = null;
int newFirstIMEVisibleNodeCharDelta = 0;
if (scopesExistingContent)
{
newFirstIMEVisibleNode = startPosition.GetAdjacentTextElementNodeSibling(LogicalDirection.Forward);
if (newFirstIMEVisibleNode != null)
{
newFirstIMEVisibleNodeCharDelta = -newFirstIMEVisibleNode.IMELeftEdgeCharCount;
newFirstIMEVisibleNode.IMECharCount += newFirstIMEVisibleNodeCharDelta;
}
}
// Attach the element node.
childSymbolCount = InsertElementToSiblingTree(startPosition, endPosition, elementNode);
// Add the edge char count to our delta. We couldn't get this before
// because it depends on the position of the element in the tree.
deltaCharCount += elementNode.IMELeftEdgeCharCount;
TextTreeTextElementNode formerFirstIMEVisibleNode = null;
int formerFirstIMEVisibleNodeCharDelta = 0;
if (element.IsFirstIMEVisibleSibling && !scopesExistingContent)
{
formerFirstIMEVisibleNode = (TextTreeTextElementNode)elementNode.GetNextNode();
if (formerFirstIMEVisibleNode != null)
{
// The following node was the former first ime visible sibling.
// It just moved, and gains an edge character.
formerFirstIMEVisibleNodeCharDelta = formerFirstIMEVisibleNode.IMELeftEdgeCharCount;
formerFirstIMEVisibleNode.IMECharCount += formerFirstIMEVisibleNodeCharDelta;
}
}
// Ancester nodes gain the two edge symbols.
UpdateContainerSymbolCount(elementNode.GetContainingNode(), /* symbolCount */ elementText == null ? 2 : elementText.Length, deltaCharCount + formerFirstIMEVisibleNodeCharDelta + newFirstIMEVisibleNodeCharDelta);
symbolOffset = elementNode.GetSymbolOffset(this.Generation);
if (newElementNode)
{
// Insert text to account for the element edges.
TextTreeText.InsertElementEdges(_rootNode.RootTextBlock, symbolOffset, childSymbolCount);
}
else
{
// element already has an existing child, just copy over the corresponding text.
TextTreeText.InsertText(_rootNode.RootTextBlock, symbolOffset, elementText);
}
NextGeneration(false /* deletedContent */);
// Handle undo.
TextTreeUndo.CreateInsertElementUndoUnit(this, symbolOffset, elementText != null /* deep */);
// If we extracted the TextElement from another tree, raise that event now.
// We can't raise this event any earlier, because prior to now _this_ tree
// is in an invalid state and this tree could be referenced by a listener
// to changes on the other tree.
if (extractChangeEventArgs != null)
{
// Announce the extract from the old tree.
// NB: we already Removed the element from the original logical tree with LogicalTreeHelper,
// and did a BeginChange above.
extractChangeEventArgs.AddChange();
extractChangeEventArgs.TextContainer.EndChange();
}
// Raise the public event for the insert into this tree.
// During document load we won't have listeners and we can save
// an allocation on every insert. This can easily save 1000's of allocations during boot.
if (this.HasListeners)
{
//
startEdgePosition = new TextPointer(this, elementNode, ElementEdge.BeforeStart);
if (childSymbolCount == 0 || elementText != null)
{
AddChange(startEdgePosition, elementText == null ? 2 : elementText.Length, deltaCharCount, PrecursorTextChangeType.ContentAdded);
}
else
{
endEdgePosition = new TextPointer(this, elementNode, ElementEdge.BeforeEnd);
AddChange(startEdgePosition, endEdgePosition, elementNode.SymbolCount,
elementNode.IMELeftEdgeCharCount, elementNode.IMECharCount - elementNode.IMELeftEdgeCharCount,
PrecursorTextChangeType.ElementAdded, null, false);
}
if (formerFirstIMEVisibleNodeCharDelta != 0)
{
RaiseEventForFormerFirstIMEVisibleNode(formerFirstIMEVisibleNode);
}
if (newFirstIMEVisibleNodeCharDelta != 0)
{
RaiseEventForNewFirstIMEVisibleNode(newFirstIMEVisibleNode);
}
}
// Insert the element into a Framework logical tree
element.BeforeLogicalTreeChange();
try
{
LogicalTreeHelper.AddLogicalChild(parentLogicalNode, element);
}
finally
{
element.AfterLogicalTreeChange();
}
// Reparent all children.
// We only need to do this if we created a new element node.
if (newElementNode)
{
ReparentLogicalChildren(elementNode, elementNode.TextElement, parentLogicalNode /* oldParent */);
}
// Notify the TextElement of a content change if it was moved to parent new content. This
// can happen when Runs get merged.
if (scopesExistingContent)
{
element.OnTextUpdated();
}
}
//------------------------------------------------------
//
// Constructors
//
//-----------------------------------------------------
#region Constructors
// Creates a new instance.
internal ExtractChangeEventArgs(TextContainer textTree, TextPointer startPosition, TextTreeTextElementNode node,
TextTreeTextElementNode newFirstIMEVisibleNode, TextTreeTextElementNode formerFirstIMEVisibleNode, int charCount, int childCharCount)
{
_textTree = textTree;
_startPosition = startPosition;
_symbolCount = node.SymbolCount;
_charCount = charCount;
_childCharCount = childCharCount;
_newFirstIMEVisibleNode = newFirstIMEVisibleNode;
_formerFirstIMEVisibleNode = formerFirstIMEVisibleNode;
}
// Adds a TextTreeExtractElementUndoUnit to the open parent undo unit, if any.
// Called by TextContainer.ExtractElement.
internal static TextTreeExtractElementUndoUnit CreateExtractElementUndoUnit(TextContainer tree, TextTreeTextElementNode elementNode)
{
UndoManager undoManager;
TextTreeExtractElementUndoUnit undoUnit;
undoManager = GetOrClearUndoManager(tree);
if (undoManager == null)
return null;
undoUnit = new TextTreeExtractElementUndoUnit(tree, elementNode);
undoManager.Add(undoUnit);
return undoUnit;
}
// Token: 0x06003E2D RID: 15917 RVA: 0x0011D670 File Offset: 0x0011B870
internal static TextTreeExtractElementUndoUnit CreateExtractElementUndoUnit(TextContainer tree, TextTreeTextElementNode elementNode)
{
UndoManager orClearUndoManager = TextTreeUndo.GetOrClearUndoManager(tree);
if (orClearUndoManager == null)
{
return(null);
}
TextTreeExtractElementUndoUnit textTreeExtractElementUndoUnit = new TextTreeExtractElementUndoUnit(tree, elementNode);
orClearUndoManager.Add(textTreeExtractElementUndoUnit);
return(textTreeExtractElementUndoUnit);
}