// Token: 0x06003BE5 RID: 15333 RVA: 0x00114150 File Offset: 0x00112350
internal static bool ValidateChild(TextElement parent, Type childType, bool throwIfIllegalChild, bool throwIfIllegalHyperlinkDescendent)
{
if (TextSchema.HasHyperlinkAncestor(parent) && (typeof(Hyperlink).IsAssignableFrom(childType) || typeof(AnchoredBlock).IsAssignableFrom(childType)))
{
if (throwIfIllegalHyperlinkDescendent)
{
throw new InvalidOperationException(SR.Get("TextSchema_IllegalHyperlinkChild", new object[]
{
childType
}));
}
return(false);
}
else
{
bool flag = TextSchema.IsValidChild(parent.GetType(), childType);
if (!flag && throwIfIllegalChild)
{
throw new InvalidOperationException(SR.Get("TextSchema_ChildTypeIsInvalid", new object[]
{
parent.GetType().Name,
childType.Name
}));
}
return(flag);
}
}
internal static bool ValidateChild(TextPointer position, Type childType, bool throwIfIllegalChild, bool throwIfIllegalHyperlinkDescendent)
{
DependencyObject parent = position.Parent;
if (parent == null)
{
TextElement leftElement = position.GetAdjacentElementFromOuterPosition(LogicalDirection.Backward);
TextElement rightElement = position.GetAdjacentElementFromOuterPosition(LogicalDirection.Forward);
return((leftElement == null || IsValidSibling(leftElement.GetType(), childType)) &&
(rightElement == null || IsValidSibling(rightElement.GetType(), childType)));
}
if (parent is TextElement)
{
return(ValidateChild((TextElement)parent, childType, throwIfIllegalChild, throwIfIllegalHyperlinkDescendent));
}
bool isValidChild = IsValidChild(parent.GetType(), childType);
if (!isValidChild && throwIfIllegalChild)
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_ChildTypeIsInvalid, parent.GetType().Name, childType.Name));
}
return(isValidChild);
}
internal static bool ValidateChild(TextElement parent, Type childType, bool throwIfIllegalChild, bool throwIfIllegalHyperlinkDescendent)
{
// Disallow nested hyperlink elements.
if (TextSchema.HasHyperlinkAncestor(parent))
{
if (typeof(Hyperlink).IsAssignableFrom(childType) ||
typeof(AnchoredBlock).IsAssignableFrom(childType))
{
if (throwIfIllegalHyperlinkDescendent)
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_IllegalHyperlinkChild, childType));
}
return(false);
}
}
bool isValidChild = IsValidChild(parent.GetType(), childType);
if (!isValidChild && throwIfIllegalChild)
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_ChildTypeIsInvalid, parent.GetType().Name, childType.Name));
}
return(isValidChild);
}
// Token: 0x06003C04 RID: 15364 RVA: 0x00114F28 File Offset: 0x00113128
private static bool HasIllegalHyperlinkDescendant(TextElement element, bool throwIfIllegalDescendent)
{
TextPointer textPointer = element.ElementStart;
TextPointer elementEnd = element.ElementEnd;
while (textPointer.CompareTo(elementEnd) < 0)
{
TextPointerContext pointerContext = textPointer.GetPointerContext(LogicalDirection.Forward);
if (pointerContext == TextPointerContext.ElementStart)
{
TextElement textElement = (TextElement)textPointer.GetAdjacentElement(LogicalDirection.Forward);
if (textElement is Hyperlink || textElement is AnchoredBlock)
{
if (throwIfIllegalDescendent)
{
throw new InvalidOperationException(SR.Get("TextSchema_IllegalHyperlinkChild", new object[]
{
textElement.GetType()
}));
}
return(true);
}
}
textPointer = textPointer.GetNextContextPosition(LogicalDirection.Forward);
}
return(false);
}
public Component CreateComponent(TextElement textElement)
{
var elementType = textElement.GetType();
var title = elementType.Name;
if (elementType == typeof(Paragraph))
{
return new ParagraphComponent(title, textElement as Paragraph);
}
if (elementType == typeof(Volume))
{
return new VolumeComponent(title, textElement as Volume);
}
if (elementType == typeof(Section))
{
return new SectionComponent(title, textElement as Section);
}
if (elementType == typeof(Run))
{
return new RunComponent(title, textElement as Run);
}
throw new NotSupportedException(string.Format("Not supported type {0}.", elementType));
}
// Token: 0x06003BE3 RID: 15331 RVA: 0x001140D8 File Offset: 0x001122D8
internal static bool ValidateChild(TextElement parent, TextElement child, bool throwIfIllegalChild, bool throwIfIllegalHyperlinkDescendent)
{
if (TextSchema.HasHyperlinkAncestor(parent) && TextSchema.HasIllegalHyperlinkDescendant(child, throwIfIllegalHyperlinkDescendent))
{
return(false);
}
bool flag = TextSchema.IsValidChild(parent.GetType(), child.GetType());
if (!flag && throwIfIllegalChild)
{
throw new InvalidOperationException(SR.Get("TextSchema_ChildTypeIsInvalid", new object[]
{
parent.GetType().Name,
child.GetType().Name
}));
}
return(flag);
}
// -------------------------------------------------------------------
//
// Internal Methods
//
// -------------------------------------------------------------------
#region Internal Methods
internal static TextElement InsertElementClone(TextPointer start, TextPointer end, TextElement element)
{
TextElement newElement = (TextElement)Activator.CreateInstance(element.GetType());
// Copy properties to the newElement
newElement.TextContainer.SetValues(newElement.ContentStart, element.GetLocalValueEnumerator());
newElement.Reposition(start, end);
return newElement;
}
internal static bool ValidateChild(TextElement parent, TextElement child, bool throwIfIllegalChild, bool throwIfIllegalHyperlinkDescendent)
{
// Disallow nested hyperlink elements.
if (TextSchema.HasHyperlinkAncestor(parent) &&
TextSchema.HasIllegalHyperlinkDescendant(child, throwIfIllegalHyperlinkDescendent))
{
return(false);
}
bool isValidChild = IsValidChild(parent.GetType(), child.GetType());
if (!isValidChild && throwIfIllegalChild)
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_ChildTypeIsInvalid, parent.GetType().Name, child.GetType().Name));
}
return(isValidChild);
}
// Applies a whole property bag to a range from start to end to simulate inheritance of this property from source conntext
private static void ApplyContextualProperties(TextPointer start, TextPointer end, TextElement propertyBag)
{
Invariant.Assert(propertyBag.IsEmpty && propertyBag.Parent == null, "propertyBag is supposed to be an empty element outside any tree");
LocalValueEnumerator contextualProperties = propertyBag.GetLocalValueEnumerator();
while (start.CompareTo(end) < 0 && contextualProperties.MoveNext())
{
// Note: we repeatedly check for IsEmpty because the selection
// may become empty as a result of normalization after formatting
// (thai character sequence).
LocalValueEntry propertyEntry = contextualProperties.Current;
DependencyProperty property = propertyEntry.Property;
if (TextSchema.IsCharacterProperty(property) &&
TextSchema.IsParagraphProperty(property))
{
// In case a property is both an Inline and Paragraph property,
// propertyBag element type (section or span) decides how it should be applied.
if (TextSchema.IsBlock(propertyBag.GetType()))
{
ApplyContextualProperty(typeof(Block), start, end, property, propertyEntry.Value);
}
else
{
ApplyContextualProperty(typeof(Inline), start, end, property, propertyEntry.Value);
}
}
else if (TextSchema.IsCharacterProperty(property))
{
ApplyContextualProperty(typeof(Inline), start, end, property, propertyEntry.Value);
}
else if (TextSchema.IsParagraphProperty(property))
{
ApplyContextualProperty(typeof(Block), start, end, property, propertyEntry.Value);
}
}
// Merge formatting elements at end position
TextRangeEdit.MergeFormattingInlines(start);
TextRangeEdit.MergeFormattingInlines(end);
}
// --------------------------------------------------------------------
//
// Internal Methods
//
// --------------------------------------------------------------------
#region Internal Methods
/// <summary>
/// Merges two paragraphs followinng one another.
/// The content of a second paragraph is moved into the end
/// of the first one.
/// </summary>
/// <param name="firstParagraphOrBlockUIContainer">
/// First of two merged paragraphs or BlockUIContainer.
/// </param>
/// <param name="secondParagraphOrBlockUIContainer">
/// Second of two mered paragraphs or BlockUIContainer.
/// </param>
/// <returns>
/// true if paragraphs have been merged; false if no actions where made.
/// </returns>
internal static bool MergeParagraphs(Block firstParagraphOrBlockUIContainer, Block secondParagraphOrBlockUIContainer)
{
if (!ParagraphsAreMergeable(firstParagraphOrBlockUIContainer, secondParagraphOrBlockUIContainer))
{
return(false); // Cannot mearge these paragraphs.
}
// Store parent list item of a second paragraph -
// to correct its structure after the merge
ListItem secondListItem = secondParagraphOrBlockUIContainer.PreviousBlock == null ? secondParagraphOrBlockUIContainer.Parent as ListItem : null;
if (secondListItem != null && secondListItem.PreviousListItem == null && secondParagraphOrBlockUIContainer.NextBlock is List)
{
// The second paragraph is a first list item in some list.
// It has a sublists in it, so this sublist must be unindented
// to avoid double bulleted line.
List sublistOfSecondParagraph = (List)secondParagraphOrBlockUIContainer.NextBlock;
if (sublistOfSecondParagraph.ElementEnd.CompareTo(secondListItem.ContentEnd) == 0)
{
secondListItem.Reposition(null, null);
}
else
{
secondListItem.Reposition(sublistOfSecondParagraph.ElementEnd, secondListItem.ContentEnd);
}
// At this point the schema is temporaty broken: the secondParagraph and the sublistOfSecondParagraph have List as a parent
sublistOfSecondParagraph.Reposition(null, null);
// The schema is repared as to sublistOfSecondParagraph concern, but still broken for secondParagraph - must be corrected in the following code
}
// Move the second paragraph out of its wrappers separating from the first paragraph (if any).
// We can not use RepositionWithContent because it would destroy
// all pointers and ranges within a moved paragraph.
// Instead we reposition elements around the two paragraphs.
while (secondParagraphOrBlockUIContainer.ElementStart.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart)
{
TextElement parentBlock = (TextElement)secondParagraphOrBlockUIContainer.Parent;
Invariant.Assert(parentBlock != null);
Invariant.Assert(TextSchema.AllowsParagraphMerging(parentBlock.GetType()));
if (secondParagraphOrBlockUIContainer.ElementEnd.CompareTo(parentBlock.ContentEnd) == 0)
{
// Remove ancestor block if it becomes empty
parentBlock.Reposition(null, null);
}
else
{
// Move ancestor's Start after the end of our paragraph
parentBlock.Reposition(secondParagraphOrBlockUIContainer.ElementEnd, parentBlock.ContentEnd);
}
}
// Store a position after the second paragraph where list merging may be needed
TextPointer positionAfterSecondParagraph = secondParagraphOrBlockUIContainer.ElementEnd.GetFrozenPointer(LogicalDirection.Forward);
// Move the second paragraph to become an immediate following sibling of the first paragraph
while (true)
{
TextElement previousBlock = secondParagraphOrBlockUIContainer.ElementStart.GetAdjacentElement(LogicalDirection.Backward) as TextElement;
// Note: We cannot use Block.NextSibling property, because the structure is invalid during this process
Invariant.Assert(previousBlock != null);
if (previousBlock is Paragraph || previousBlock is BlockUIContainer)
{
break;
}
Invariant.Assert(TextSchema.AllowsParagraphMerging(previousBlock.GetType()));
previousBlock.Reposition(previousBlock.ContentStart, secondParagraphOrBlockUIContainer.ElementEnd);
}
// Now that paragraphs are next to each other merge them.
// If one of paragraphs is empty we will apply special logic - to preserve a formatting from a non-empty one
if (secondParagraphOrBlockUIContainer.TextRange.IsEmpty)
{
secondParagraphOrBlockUIContainer.RepositionWithContent(null);
}
else if (firstParagraphOrBlockUIContainer.TextRange.IsEmpty)
{
firstParagraphOrBlockUIContainer.RepositionWithContent(null);
}
else if (firstParagraphOrBlockUIContainer is Paragraph && secondParagraphOrBlockUIContainer is Paragraph)
{
// Do reposition magic for merging paragraph content
// without destroying any pointers positioned in them.
// Pull the second paragraph into the first one
Invariant.Assert(firstParagraphOrBlockUIContainer.ElementEnd.CompareTo(secondParagraphOrBlockUIContainer.ElementStart) == 0);
firstParagraphOrBlockUIContainer.Reposition(firstParagraphOrBlockUIContainer.ContentStart, secondParagraphOrBlockUIContainer.ElementEnd);
// Store inline merging position
TextPointer inlineMergingPosition = secondParagraphOrBlockUIContainer.ElementStart;
// Now we can delete the second paragraph
secondParagraphOrBlockUIContainer.Reposition(null, null);
// Merge formatting elements at the point of paragraphs merging
TextRangeEdit.MergeFormattingInlines(inlineMergingPosition);
}
// Merge ListItems wrapping first and second paragraphs.
ListItem followingListItem = positionAfterSecondParagraph.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart
? positionAfterSecondParagraph.GetAdjacentElement(LogicalDirection.Forward) as ListItem : null;
if (followingListItem != null && followingListItem == secondListItem)
{
ListItem precedingListItem = positionAfterSecondParagraph.GetAdjacentElement(LogicalDirection.Backward) as ListItem;
if (precedingListItem != null)
{
// Merge the second list item with the preceding one
Invariant.Assert(positionAfterSecondParagraph.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart);
Invariant.Assert(positionAfterSecondParagraph.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementEnd);
precedingListItem.Reposition(precedingListItem.ContentStart, followingListItem.ElementEnd);
followingListItem.Reposition(null, null);
}
}
// Merge lists at merge position
MergeLists(positionAfterSecondParagraph);
return(true);
}
internal static bool ValidateChild(TextElement parent, Type childType, bool throwIfIllegalChild, bool throwIfIllegalHyperlinkDescendent)
{
// Disallow nested hyperlink elements.
if (TextSchema.HasHyperlinkAncestor(parent))
{
if (typeof(Hyperlink).IsAssignableFrom(childType) ||
typeof(AnchoredBlock).IsAssignableFrom(childType))
{
if (throwIfIllegalHyperlinkDescendent)
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_IllegalHyperlinkChild, childType));
}
return false;
}
}
bool isValidChild = IsValidChild(parent.GetType(), childType);
if (!isValidChild && throwIfIllegalChild)
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_ChildTypeIsInvalid, parent.GetType().Name, childType.Name));
}
return isValidChild;
}
internal static bool ValidateChild(TextElement parent, TextElement child, bool throwIfIllegalChild, bool throwIfIllegalHyperlinkDescendent)
{
// Disallow nested hyperlink elements.
if (TextSchema.HasHyperlinkAncestor(parent) &&
TextSchema.HasIllegalHyperlinkDescendant(child, throwIfIllegalHyperlinkDescendent))
{
return false;
}
bool isValidChild = IsValidChild(parent.GetType(), child.GetType());
if (!isValidChild && throwIfIllegalChild)
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_ChildTypeIsInvalid, parent.GetType().Name, child.GetType().Name));
}
return isValidChild;
}
// Returns true if passed textelement has any Hyperlink or AnchoredBlock descendant.
// It this context, the element or one of its ancestors is a Hyperlink.
private static bool HasIllegalHyperlinkDescendant(TextElement element, bool throwIfIllegalDescendent)
{
TextPointer start = element.ElementStart;
TextPointer end = element.ElementEnd;
while (start.CompareTo(end) < 0)
{
TextPointerContext forwardContext = start.GetPointerContext(LogicalDirection.Forward);
if (forwardContext == TextPointerContext.ElementStart)
{
TextElement nextElement = (TextElement)start.GetAdjacentElement(LogicalDirection.Forward);
if (nextElement is Hyperlink ||
nextElement is AnchoredBlock)
{
if (throwIfIllegalDescendent)
{
throw new InvalidOperationException(SR.Get(SRID.TextSchema_IllegalHyperlinkChild, nextElement.GetType()));
}
return(true);
}
}
start = start.GetNextContextPosition(LogicalDirection.Forward);
}
return(false);
}
// Token: 0x06003BE7 RID: 15335 RVA: 0x001141F8 File Offset: 0x001123F8
internal static bool ValidateChild(TextPointer position, Type childType, bool throwIfIllegalChild, bool throwIfIllegalHyperlinkDescendent)
{
DependencyObject parent = position.Parent;
if (parent == null)
{
TextElement adjacentElementFromOuterPosition = position.GetAdjacentElementFromOuterPosition(LogicalDirection.Backward);
TextElement adjacentElementFromOuterPosition2 = position.GetAdjacentElementFromOuterPosition(LogicalDirection.Forward);
return((adjacentElementFromOuterPosition == null || TextSchema.IsValidSibling(adjacentElementFromOuterPosition.GetType(), childType)) && (adjacentElementFromOuterPosition2 == null || TextSchema.IsValidSibling(adjacentElementFromOuterPosition2.GetType(), childType)));
}
if (parent is TextElement)
{
return(TextSchema.ValidateChild((TextElement)parent, childType, throwIfIllegalChild, throwIfIllegalHyperlinkDescendent));
}
bool flag = TextSchema.IsValidChild(parent.GetType(), childType);
if (!flag && throwIfIllegalChild)
{
throw new InvalidOperationException(SR.Get("TextSchema_ChildTypeIsInvalid", new object[]
{
parent.GetType().Name,
childType.Name
}));
}
return(flag);
}
// Token: 0x06003B7E RID: 15230 RVA: 0x0010EB84 File Offset: 0x0010CD84
internal static bool MergeParagraphs(Block firstParagraphOrBlockUIContainer, Block secondParagraphOrBlockUIContainer)
{
if (!TextRangeEditLists.ParagraphsAreMergeable(firstParagraphOrBlockUIContainer, secondParagraphOrBlockUIContainer))
{
return(false);
}
ListItem listItem = (secondParagraphOrBlockUIContainer.PreviousBlock == null) ? (secondParagraphOrBlockUIContainer.Parent as ListItem) : null;
if (listItem != null && listItem.PreviousListItem == null && secondParagraphOrBlockUIContainer.NextBlock is List)
{
List list = (List)secondParagraphOrBlockUIContainer.NextBlock;
if (list.ElementEnd.CompareTo(listItem.ContentEnd) == 0)
{
listItem.Reposition(null, null);
}
else
{
listItem.Reposition(list.ElementEnd, listItem.ContentEnd);
}
list.Reposition(null, null);
}
while (secondParagraphOrBlockUIContainer.ElementStart.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart)
{
TextElement textElement = (TextElement)secondParagraphOrBlockUIContainer.Parent;
Invariant.Assert(textElement != null);
Invariant.Assert(TextSchema.AllowsParagraphMerging(textElement.GetType()));
if (secondParagraphOrBlockUIContainer.ElementEnd.CompareTo(textElement.ContentEnd) == 0)
{
textElement.Reposition(null, null);
}
else
{
textElement.Reposition(secondParagraphOrBlockUIContainer.ElementEnd, textElement.ContentEnd);
}
}
TextPointer frozenPointer = secondParagraphOrBlockUIContainer.ElementEnd.GetFrozenPointer(LogicalDirection.Forward);
for (;;)
{
TextElement textElement2 = secondParagraphOrBlockUIContainer.ElementStart.GetAdjacentElement(LogicalDirection.Backward) as TextElement;
Invariant.Assert(textElement2 != null);
if (textElement2 is Paragraph || textElement2 is BlockUIContainer)
{
break;
}
Invariant.Assert(TextSchema.AllowsParagraphMerging(textElement2.GetType()));
textElement2.Reposition(textElement2.ContentStart, secondParagraphOrBlockUIContainer.ElementEnd);
}
if (secondParagraphOrBlockUIContainer.TextRange.IsEmpty)
{
secondParagraphOrBlockUIContainer.RepositionWithContent(null);
}
else if (firstParagraphOrBlockUIContainer.TextRange.IsEmpty)
{
firstParagraphOrBlockUIContainer.RepositionWithContent(null);
}
else if (firstParagraphOrBlockUIContainer is Paragraph && secondParagraphOrBlockUIContainer is Paragraph)
{
Invariant.Assert(firstParagraphOrBlockUIContainer.ElementEnd.CompareTo(secondParagraphOrBlockUIContainer.ElementStart) == 0);
firstParagraphOrBlockUIContainer.Reposition(firstParagraphOrBlockUIContainer.ContentStart, secondParagraphOrBlockUIContainer.ElementEnd);
TextPointer elementStart = secondParagraphOrBlockUIContainer.ElementStart;
secondParagraphOrBlockUIContainer.Reposition(null, null);
TextRangeEdit.MergeFormattingInlines(elementStart);
}
ListItem listItem2 = (frozenPointer.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart) ? (frozenPointer.GetAdjacentElement(LogicalDirection.Forward) as ListItem) : null;
if (listItem2 != null && listItem2 == listItem)
{
ListItem listItem3 = frozenPointer.GetAdjacentElement(LogicalDirection.Backward) as ListItem;
if (listItem3 != null)
{
Invariant.Assert(frozenPointer.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart);
Invariant.Assert(frozenPointer.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementEnd);
listItem3.Reposition(listItem3.ContentStart, listItem2.ElementEnd);
listItem2.Reposition(null, null);
}
}
TextRangeEditLists.MergeLists(frozenPointer);
return(true);
}
