public CompareTo ( |
||
position | ||
Результат | int |
//--------------------------- // public static methods //--------------------------- /// <summary> /// resolves text effect on a text range to a list of text effect targets. /// The method will walk the text and perform the following task: /// 1) For each continous block of text, create a text effect targeting the scoping element /// 2) For the text effect created, calculate the starting cp index and cp count for the effect /// /// The method will create freezable copy of the TextEffect passed in and fill in /// CharacterIndex and Count for the range. /// </summary> /// <param name="startPosition">starting text pointer</param> /// <param name="endPosition">end text pointer</param> /// <param name="effect">effect that is apply on the text</param> public static TextEffectTarget[] Resolve( TextPointer startPosition, TextPointer endPosition, TextEffect effect ) { if (effect == null) throw new ArgumentNullException("effect"); ValidationHelper.VerifyPositionPair(startPosition, endPosition); TextPointer effectStart = new TextPointer(startPosition); // move to the first character symbol at or after Start position MoveToFirstCharacterSymbol(effectStart); TextEffect effectCopy; List<TextEffectTarget> list = new List<TextEffectTarget>(); // we will now traverse the TOM and resolve text effects to the immediate parent // of the characters. We are effectively applying the text effect onto // block of continous text. while (effectStart.CompareTo(endPosition) < 0) { // create a copy of the text effect // so that we can set the CharacterIndex and Count effectCopy = effect.Clone(); // create a position TextPointer continuousTextEnd = new TextPointer(effectStart); // move the position to the end of the continuous text block MoveToFirstNonCharacterSymbol(continuousTextEnd, endPosition); // make sure we are not out of the range continuousTextEnd = (TextPointer)TextPointerBase.Min(continuousTextEnd, endPosition); // set the character index to be the distance from the Start // of this text block to the Start of the text container effectCopy.PositionStart = effectStart.TextContainer.Start.GetOffsetToPosition(effectStart); // count is the distance from the text block start to end effectCopy.PositionCount = effectStart.GetOffsetToPosition(continuousTextEnd); list.Add( new TextEffectTarget( effectStart.Parent, effectCopy ) ); // move the effectStart to the beginning of the next text block. effectStart = continuousTextEnd; MoveToFirstCharacterSymbol(effectStart); } return list.ToArray(); }
//------------------------------------------------------ // // Public Methods // //------------------------------------------------------ //------------------------------------------------------ // // Public Properties // //------------------------------------------------------ //------------------------------------------------------ // // Protected Methods // //------------------------------------------------------ //------------------------------------------------------ // // Internal Methods // //------------------------------------------------------ #region Internal methods. /// <summary> /// Writes the container into the specified XmlWriter. /// </summary> internal void Write(TextPointer start, TextPointer end, XmlWriter writer) { System.Diagnostics.Debug.Assert(start != null); System.Diagnostics.Debug.Assert(end != null); System.Diagnostics.Debug.Assert(start.CompareTo(end) <= 0); System.Diagnostics.Debug.Assert(writer != null); WriteContainer(start, end, writer); }
// move to the first non-character symbol, but not pass beyond the limit private static void MoveToFirstNonCharacterSymbol( TextPointer navigator, // navigator to move TextPointer stopHint // don't move further if we already pass beyond this point ) { while (navigator.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text && navigator.CompareTo(stopHint) < 0 && navigator.MoveToNextContextPosition(LogicalDirection.Forward)) { ; } }
private static int GetCharOffsetToPosition(InlineCollection inlineCollection, TextPointer position, out TextPointer result) { int offset = 0; foreach (var inline in inlineCollection) { offset += GetCharOffsetToPosition(inline, position, out result); if (result == null || result.CompareTo(position) >= 0) return offset; } result = null; return offset; }
private static int GetCharOffsetToPosition(BlockCollection blockCollection, TextPointer position, out TextPointer result) { int offset = 0; foreach (var block in blockCollection) { offset += GetCharOffsetToPosition(block, position, out result); if (result == null || result.CompareTo(position) >= 0) return offset; } result = null; return offset; }
public static int GetCharOffsetToPosition(this FlowDocument document, TextPointer position) { if (document == null) throw new ArgumentNullException("document"); if (position == null) throw new ArgumentNullException("position"); if (position.CompareTo(document.ContentStart) == 0) return 0; TextPointer result; return GetCharOffsetToPosition(document.Blocks, position, out result); }
internal override Rect[] GetCharacterRects(TextPointer startPointer, TextPointer endPointer) { if (!invalidatedCache && cachedStartP != null && startPointer.CompareTo(cachedStartP) == 0) { return cachedRects; } else { cachedRects = base.GetCharacterRects(startPointer, endPointer); cachedStartP = startPointer; invalidatedCache = false; } return cachedRects; }
// Token: 0x06003E2C RID: 15916 RVA: 0x0011D638 File Offset: 0x0011B838 internal static TextTreeDeleteContentUndoUnit CreateDeleteContentUndoUnit(TextContainer tree, TextPointer start, TextPointer end) { if (start.CompareTo(end) == 0) { return(null); } UndoManager orClearUndoManager = TextTreeUndo.GetOrClearUndoManager(tree); if (orClearUndoManager == null) { return(null); } TextTreeDeleteContentUndoUnit textTreeDeleteContentUndoUnit = new TextTreeDeleteContentUndoUnit(tree, start, end); orClearUndoManager.Add(textTreeDeleteContentUndoUnit); return(textTreeDeleteContentUndoUnit); }
// Adds a DeleteContentUndoUnit to the open parent undo unit, if any. // Called by TextContainer.DeleteContent. internal static TextTreeDeleteContentUndoUnit CreateDeleteContentUndoUnit(TextContainer tree, TextPointer start, TextPointer end) { UndoManager undoManager; TextTreeDeleteContentUndoUnit undoUnit; if (start.CompareTo(end) == 0) return null; undoManager = GetOrClearUndoManager(tree); if (undoManager == null) return null; undoUnit = new TextTreeDeleteContentUndoUnit(tree, start, end); undoManager.Add(undoUnit); return undoUnit; }
/// <summary>Initializes a new instance of the <see cref="T:System.Windows.Documents.Hyperlink" /> class, taking two <see cref="T:System.Windows.Documents.TextPointer" /> objects that indicate the beginning and end of a selection of content to be contained by the new <see cref="T:System.Windows.Documents.Hyperlink" />.</summary> /// <param name="start">A <see cref="T:System.Windows.Documents.TextPointer" /> indicating the beginning of a selection of content to be contained by the new <see cref="T:System.Windows.Documents.Hyperlink" />.</param> /// <param name="end">A <see cref="T:System.Windows.Documents.TextPointer" /> indicating the end of a selection of content to be contained by the new <see cref="T:System.Windows.Documents.Hyperlink" />.</param> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="start" /> or <paramref name="end" /> is <see langword="null" />.</exception> /// <exception cref="T:System.ArgumentException"> /// <paramref name="start" /> and <paramref name="end" /> do not resolve to a range of content suitable for enclosure by a <see cref="T:System.Windows.Documents.Span" /> element; for example, if <paramref name="start" /> and <paramref name="end" /> indicate positions in different paragraphs.</exception> // Token: 0x0600301F RID: 12319 RVA: 0x000D8A18 File Offset: 0x000D6C18 public Hyperlink(TextPointer start, TextPointer end) : base(start, end) { TextPointer textPointer = base.ContentStart.CreatePointer(); TextPointer contentEnd = base.ContentEnd; while (textPointer.CompareTo(contentEnd) < 0) { Hyperlink hyperlink = textPointer.GetAdjacentElement(LogicalDirection.Forward) as Hyperlink; if (hyperlink != null) { hyperlink.Reposition(null, null); } else { textPointer.MoveToNextContextPosition(LogicalDirection.Forward); } } }
//------------------------------------------------------------------- // // Internal Methods // //------------------------------------------------------------------- #region Internal Methods /// <summary> /// Returns the integer "index" of a specified ListItem that is an immediate child of /// this List. This index is defined to be a sequential counter of ListElementItems only /// (skipping other elements) among this List's immediate children. /// /// The list item index of the first child of type ListItem is specified by /// this.StartListIndex, which has a default value of 1. /// /// The index returned by this method is used in the formation of some ListItem /// markers such as "(b)" and "viii." (as opposed to others, like disks and wedges, /// which are not sequential-position-dependent). /// </summary> /// <param name="item">The item whose index is to be returned.</param> /// <returns>Returns the index of a specified ListItem.</returns> internal int GetListItemIndex(ListItem item) { // Check for valid arg if (item == null) { throw new ArgumentNullException("item"); } if (item.Parent != this) { throw new InvalidOperationException(SR.Get(SRID.ListElementItemNotAChildOfList)); } // Count ListItem siblings (not other element types) back to first item. int itemIndex = StartIndex; TextPointer textNav = new TextPointer(this.ContentStart); while (textNav.CompareTo(this.ContentEnd) != 0) { // ListItem is a content element, so look for ElementStart runs only if (textNav.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart) { DependencyObject element = textNav.GetAdjacentElementFromOuterPosition(LogicalDirection.Forward); if (element is ListItem) { if (element == item) { break; } if (itemIndex < int.MaxValue) { ++itemIndex; } } // Skip entire content element content, because we are looking // only for immediate children. textNav.MoveToPosition(((TextElement)element).ElementEnd); } else { textNav.MoveToNextContextPosition(LogicalDirection.Forward); } } return(itemIndex); }
// Checks whether two paragraphs are meargeable. // To be meargeable they need to be separated by s sequence of closing, then opening // tags only. // And all tags must be Sections/Lists/ListItems only. internal static bool ParagraphsAreMergeable(Block firstParagraphOrBlockUIContainer, Block secondParagraphOrBlockUIContainer) { if (firstParagraphOrBlockUIContainer == null || secondParagraphOrBlockUIContainer == null || firstParagraphOrBlockUIContainer == secondParagraphOrBlockUIContainer) { return(false); // nothing to merge } TextPointer position = firstParagraphOrBlockUIContainer.ElementEnd; TextPointer startOfSecondParagraph = secondParagraphOrBlockUIContainer.ElementStart; // Skip and check all closing tags (if any) while (position.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementEnd) { if (!TextSchema.AllowsParagraphMerging(position.Parent.GetType())) { return(false); // Crossing hard-structured element. Paragraphs are not meargeable. } position = position.GetNextContextPosition(LogicalDirection.Forward); } // Skip and check all opening tags (if any) while (position.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart) { if (position.CompareTo(startOfSecondParagraph) == 0) { // Successfully skipped all tags, and reached the seconfParagraph. // The paragraphs are meargeable. return(true); } position = position.GetNextContextPosition(LogicalDirection.Forward); if (!TextSchema.AllowsParagraphMerging(position.Parent.GetType())) { return(false); // Crossing hardd-structured element. Paragraphs are not meargeable. } } // Non-tag run found. Paragraphs are not meargeable. return(false); }
/// <summary> /// Creates a new Hyperlink instance covering existing content. /// </summary> /// <param name="start"> /// Start position of the new Hyperlink. /// </param> /// <param name="end"> /// End position of the new Hyperlink. /// </param> /// <remarks> /// start and end must both be parented by the same Paragraph, otherwise /// the method will raise an ArgumentException. /// </remarks> public Hyperlink(TextPointer start, TextPointer end) : base(start, end) { // After inserting this Hyperlink, we need to extract any child Hyperlinks. TextPointer navigator = this.ContentStart.CreatePointer(); TextPointer stop = this.ContentEnd; while (navigator.CompareTo(stop) < 0) { Hyperlink hyperlink = navigator.GetAdjacentElement(LogicalDirection.Forward) as Hyperlink; if (hyperlink != null) { hyperlink.Reposition(null, null); } else { navigator.MoveToNextContextPosition(LogicalDirection.Forward); } } }
// Adds a DeleteContentUndoUnit to the open parent undo unit, if any. // Called by TextContainer.DeleteContent. internal static TextTreeDeleteContentUndoUnit CreateDeleteContentUndoUnit(TextContainer tree, TextPointer start, TextPointer end) { UndoManager undoManager; TextTreeDeleteContentUndoUnit undoUnit; if (start.CompareTo(end) == 0) { return(null); } undoManager = GetOrClearUndoManager(tree); if (undoManager == null) { return(null); } undoUnit = new TextTreeDeleteContentUndoUnit(tree, start, end); undoManager.Add(undoUnit); return(undoUnit); }
// Token: 0x060031B9 RID: 12729 RVA: 0x000DBB64 File Offset: 0x000D9D64 internal int GetListItemIndex(ListItem item) { if (item == null) { throw new ArgumentNullException("item"); } if (item.Parent != this) { throw new InvalidOperationException(SR.Get("ListElementItemNotAChildOfList")); } int num = this.StartIndex; TextPointer textPointer = new TextPointer(base.ContentStart); while (textPointer.CompareTo(base.ContentEnd) != 0) { if (textPointer.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart) { DependencyObject adjacentElementFromOuterPosition = textPointer.GetAdjacentElementFromOuterPosition(LogicalDirection.Forward); if (adjacentElementFromOuterPosition is ListItem) { if (adjacentElementFromOuterPosition == item) { break; } if (num < 2147483647) { num++; } } textPointer.MoveToPosition(((TextElement)adjacentElementFromOuterPosition).ElementEnd); } else { textPointer.MoveToNextContextPosition(LogicalDirection.Forward); } } return(num); }
/// <summary> /// Find the input string within the document, starting at the specified position. /// </summary> /// <param name="position">the current text position</param> /// <param name="input">input text</param> /// <returns>An <see cref="TextRange"/> representing the (next) matching string within the text container. Null if there are no matches.</returns> public TextRange FindNext(ref TextPointer position, String input) { FindText(input); foreach (var result in _searchHits) { if (position.CompareTo(result.End) < 0) { position = result.Start; double top = this.PointToScreen(position.GetLineStartPosition(0).GetCharacterRect(LogicalDirection.Forward).TopLeft).Y + this.PointFromScreen(new System.Windows.Point(0, 0)).Y; Trace.WriteLine(string.Format(" Top: {0}, CharOffset: {1}", top, position)); ScrollViewer.ScrollToVerticalOffset(ScrollViewer.VerticalOffset + top); position = result.End; return result; } } return null; }
// Token: 0x06003922 RID: 14626 RVA: 0x001031AC File Offset: 0x001013AC private static void MoveToFirstNonCharacterSymbol(TextPointer navigator, TextPointer stopHint) { while (navigator.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text && navigator.CompareTo(stopHint) < 0 && navigator.MoveToNextContextPosition(LogicalDirection.Forward)) { } }
// .................................................................... // // Row editing // // .................................................................... #region Row Editing /// <summary> /// Checks whether the given TextPointer is at row end position, where text insertion is impossible /// and returns a following position where text insertion or pasting is valid. /// New paragraphs is creeated at the end of TextContainer if necessary. /// </summary> internal static TextPointer EnsureInsertionPosition(TextPointer position) { Invariant.Assert(position != null, "null check: position"); // Normalize the pointer position = position.GetInsertionPosition(position.LogicalDirection); if (!TextPointerBase.IsAtInsertionPosition(position)) { // There is no insertion positions in the whole document at all. // Generate minimally necessary content to ensure at least one insertion position. position = CreateInsertionPositionInIncompleteContent(position); } else { // Check if position is at one of special structural boundary positions, where we can potentially have an // insertion position and create one. if (position.IsAtRowEnd) { // Find a next insertion position within the scope of the parent table. Table currentTable = TextRangeEditTables.GetTableFromPosition(position); position = GetAdjustedRowEndPosition(currentTable, position); if (position.CompareTo(currentTable.ElementEnd) == 0) { // The range is at the end of table which is the last block of text container OR // next insertion position crossed table boundary. // In both cases, we want to insert a paragraph after table end and move our insertion position there. position = CreateImplicitParagraph(currentTable.ElementEnd); } } Invariant.Assert(!position.IsAtRowEnd, "position is not expected to be at RowEnd anymore"); // Note that this is not an else if, because our next insertion position (if it is within the same table), // can fall into one of the following cases. We need to handle it. if (TextPointerBase.IsInBlockUIContainer(position)) { BlockUIContainer blockUIContainer = (BlockUIContainer)position.Parent; bool insertBefore = position.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart; position = insertBefore ? CreateImplicitParagraph(blockUIContainer.ElementStart) : CreateImplicitParagraph(blockUIContainer.ElementEnd); // Clean potentialy incomplete content if (blockUIContainer.IsEmpty) { blockUIContainer.RepositionWithContent(null); } } else if (TextPointerBase.IsBeforeFirstTable(position) || TextPointerBase.IsAtPotentialParagraphPosition(position)) { position = CreateImplicitParagraph(position); } else if (TextPointerBase.IsAtPotentialRunPosition(position)) { position = CreateImplicitRun(position); } } Invariant.Assert(TextSchema.IsInTextContent(position), "position must be in text content now"); return position; }
/// <summary> /// Deletes all equi-scoped segments of content from start TextPointer /// up to fragment root. Thus clears one half of a fragment. /// The other half remains untouched. /// All elements whose boundaries are crossed by this range /// remain in the tree (except for emptied formatting elements). /// </summary> /// <param name="start"> /// A position from which content clearinng starts. /// All content segments between this position and a fragment /// root will be deleted. /// </param> /// <param name="end"> /// A position indicating the other boundary of a fragment. /// This position is used for fragment root identification. /// </param> private static void DeleteEquiScopedContent(TextPointer start, TextPointer end) { // Validate parameters Invariant.Assert(start != null, "null check: start"); Invariant.Assert(end != null, "null check: end"); if (start.CompareTo(end) == 0) { return; } if (start.Parent == end.Parent) { DeleteContentBetweenPositions(start, end); return; } // Identify directional parameters LogicalDirection direction; LogicalDirection oppositeDirection; TextPointerContext enterScopeSymbol; TextPointerContext leaveScopeSymbol; ElementEdge edgeBeforeElement; ElementEdge edgeAfterElement; if (start.CompareTo(end) < 0) { direction = LogicalDirection.Forward; oppositeDirection = LogicalDirection.Backward; enterScopeSymbol = TextPointerContext.ElementStart; leaveScopeSymbol = TextPointerContext.ElementEnd; edgeBeforeElement = ElementEdge.BeforeStart; edgeAfterElement = ElementEdge.AfterEnd; } else { direction = LogicalDirection.Backward; oppositeDirection = LogicalDirection.Forward; enterScopeSymbol = TextPointerContext.ElementEnd; leaveScopeSymbol = TextPointerContext.ElementStart; edgeBeforeElement = ElementEdge.AfterEnd; edgeAfterElement = ElementEdge.BeforeStart; } // previousPosition will store a location where nondeleted content starts TextPointer previousPosition = new TextPointer(start); // nextPosition runs toward other end until level change - // so that we could delete all content from previousPosition // to nextPosition at once. TextPointer nextPosition = new TextPointer(start); // Run nextPosition forward until the very end of affected range while (nextPosition.CompareTo(end) != 0) { Invariant.Assert(direction == LogicalDirection.Forward && nextPosition.CompareTo(end) < 0 || direction == LogicalDirection.Backward && nextPosition.CompareTo(end) > 0, "Inappropriate position ordering"); Invariant.Assert(previousPosition.Parent == nextPosition.Parent, "inconsistent position Parents: previous and next"); TextPointerContext pointerContext = nextPosition.GetPointerContext(direction); if (pointerContext == TextPointerContext.Text || pointerContext == TextPointerContext.EmbeddedElement) { // Add this run to a collection of equi-scoped content nextPosition.MoveToNextContextPosition(direction); // Check if we went too far and return a little to end if necessary if (direction == LogicalDirection.Forward && nextPosition.CompareTo(end) > 0 || direction == LogicalDirection.Backward && nextPosition.CompareTo(end) < 0) { Invariant.Assert(nextPosition.Parent == end.Parent, "inconsistent poaition Parents: next and end"); nextPosition.MoveToPosition(end); break; } } else if (pointerContext == enterScopeSymbol) { // Jump over the element and continue collecting equi-scoped content nextPosition.MoveToNextContextPosition(direction); ((ITextPointer)nextPosition).MoveToElementEdge(edgeAfterElement); // If our range crosses the element then we stop before its opening tag if (direction == LogicalDirection.Forward && nextPosition.CompareTo(end) >= 0 || direction == LogicalDirection.Backward && nextPosition.CompareTo(end) <= 0) { nextPosition.MoveToNextContextPosition(oppositeDirection); ((ITextPointer)nextPosition).MoveToElementEdge(edgeBeforeElement); break; } } else if (pointerContext == leaveScopeSymbol) { // Delete preceding content and continue on outer level DeleteContentBetweenPositions(previousPosition, nextPosition); if (!ExtractEmptyFormattingElements(previousPosition)) { // Continue on outer level Invariant.Assert(nextPosition.GetPointerContext(direction) == leaveScopeSymbol, "Unexpected context of nextPosition"); nextPosition.MoveToNextContextPosition(direction); } previousPosition.MoveToPosition(nextPosition); } else { Invariant.Assert(false, "Not expecting None context here"); Invariant.Assert(pointerContext == TextPointerContext.None, "Unknown pointer context"); break; } } Invariant.Assert(previousPosition.Parent == nextPosition.Parent, "inconsistent Parents: previousPosition, nextPosition"); DeleteContentBetweenPositions(previousPosition, nextPosition); }
/// <summary> /// Creates a new Span instance covering existing content. /// </summary> /// <param name="start"> /// Start position of the new Span. /// </param> /// <param name="end"> /// End position of the new Span. /// </param> /// <remarks> /// start and end must both be parented by the same Paragraph, otherwise /// the method will raise an ArgumentException. /// </remarks> public Span(TextPointer start, TextPointer end) { if (start == null) { throw new ArgumentNullException("start"); } if (end == null) { throw new ArgumentNullException("start"); } if (start.TextContainer != end.TextContainer) { throw new ArgumentException(SR.Get(SRID.InDifferentTextContainers, "start", "end")); } if (start.CompareTo(end) > 0) { throw new ArgumentException(SR.Get(SRID.BadTextPositionOrder, "start", "end")); } start.TextContainer.BeginChange(); try { start = TextRangeEditTables.EnsureInsertionPosition(start); Invariant.Assert(start.Parent is Run); end = TextRangeEditTables.EnsureInsertionPosition(end); Invariant.Assert(end.Parent is Run); if (start.Paragraph != end.Paragraph) { throw new ArgumentException(SR.Get(SRID.InDifferentParagraphs, "start", "end")); } // If start or end positions have a Hyperlink ancestor, we cannot split them. Inline nonMergeableAncestor; if ((nonMergeableAncestor = start.GetNonMergeableInlineAncestor()) != null) { throw new InvalidOperationException(SR.Get(SRID.TextSchema_CannotSplitElement, nonMergeableAncestor.GetType().Name)); } if ((nonMergeableAncestor = end.GetNonMergeableInlineAncestor()) != null) { throw new InvalidOperationException(SR.Get(SRID.TextSchema_CannotSplitElement, nonMergeableAncestor.GetType().Name)); } TextElement commonAncestor = TextElement.GetCommonAncestor((TextElement)start.Parent, (TextElement)end.Parent); while (start.Parent != commonAncestor) { start = SplitElement(start); } while (end.Parent != commonAncestor) { end = SplitElement(end); } if (start.Parent is Run) { start = SplitElement(start); } if (end.Parent is Run) { end = SplitElement(end); } Invariant.Assert(start.Parent == end.Parent); Invariant.Assert(TextSchema.IsValidChild(/*position*/ start, /*childType*/ typeof(Span))); this.Reposition(start, end); } finally { start.TextContainer.EndChange(); } }
internal static bool UnindentListItems(TextRange range) { // If listitems in this range cross a list boundary, we cannot unindent them. if (!IsRangeWithinSingleList(range)) { return(false); } ListItem firstListItem = TextPointerBase.GetListItem(range.Start); ListItem lastListItem = TextPointerBase.GetListItem((TextPointer)TextRangeEdit.GetAdjustedRangeEnd(range.Start, range.End)); // At this point it is possible that lastListItem is a child of // firstListItem. // // This is due to a special case in IsRangeWithinSingleList // which allows the input TextRange to cross List boundaries only // in the case where the TextRange ends adjacent to an insertion // position at the same level as the start, e.g.: // // - parent item // - start item (range starts here) // - child item (range ends here) // <start item must not have any siblings> // // Here we check for that special case and ensure that // lastListItem is at the same level as firstListItem. TextElement parent = (TextElement)lastListItem.Parent; while (parent != firstListItem.Parent) { lastListItem = parent as ListItem; parent = (TextElement)parent.Parent; } if (lastListItem == null) { // This can happen if the input is a fragment, a collection // of ListItems not parented by an outer List. return(false); } // Cut wrapping list before startListItem if (firstListItem.PreviousListItem != null) { TextRangeEdit.SplitElement(firstListItem.ElementStart); } // Cut wrapping list after endListItem if (lastListItem.NextListItem != null) { TextRangeEdit.SplitElement(lastListItem.ElementEnd); } // Remove List wrapper from selected items List unindentedList = (List)firstListItem.Parent; // Check whether we have outer ListItem ListItem outerListItem = unindentedList.Parent as ListItem; if (outerListItem != null) { // Selected items belong to a nested list. // So we need to pull them to the level of enclosing ListItem, i.e. cut this ListItem. // In this case we also need to include trailing list into the last of selected items // Remove a wrapping List from selected items unindentedList.Reposition(null, null); // Remember end position of outerListItem to pull any trailing list or other blocks into the last of selected listitems TextPointer outerListItemEnd = outerListItem.ContentEnd; if (outerListItem.ContentStart.CompareTo(firstListItem.ElementStart) == 0) { // There is nothing before first list item; so outer list item would be empty - just delete it outerListItem.Reposition(null, null); } else { // Wrap all stuff preceding firstListItem in outerListItem outerListItem.Reposition(outerListItem.ContentStart, firstListItem.ElementStart); } if (outerListItemEnd.CompareTo(lastListItem.ElementEnd) == 0) { // There are no following siblings to pull into last selected item; do nothing. } else { // Pull trailing items (following siblings to the selected ones) into the last selected item // Remember a position to merge any trailing list after lastListItem TextPointer mergePosition = lastListItem.ContentEnd; // Reposition last selectd ListItem so that it includes trailing list (or other block) as its children lastListItem.Reposition(lastListItem.ContentStart, outerListItemEnd); // Merge any trailing list with a sublist outdented with our listitem MergeLists(mergePosition); } } else { // Selected items are not in nested list. // We need to simply unwrap them and convert to paragraphs TextPointer start = unindentedList.ElementStart; TextPointer end = unindentedList.ElementEnd; // Save the list's FlowDirection value, to apply later to its children. object listFlowDirectionValue = unindentedList.GetValue(Paragraph.FlowDirectionProperty); // Remove a wrapping List from selected items unindentedList.Reposition(null, null); // Remove ListItems from all selected items ListItem listItem = firstListItem; while (listItem != null) { ListItem nextListItem = listItem.ElementEnd.GetAdjacentElement(LogicalDirection.Forward) as ListItem; // If this is an empty <ListItem></ListItem>, insert an explicit paragraph in it before deleting the list item. if (listItem.ContentStart.CompareTo(listItem.ContentEnd) == 0) { TextRangeEditTables.EnsureInsertionPosition(listItem.ContentStart); } listItem.Reposition(null, null); listItem = listItem == lastListItem ? null : nextListItem; } // Apply FlowDirection of the list just deleted to all its children. TextRangeEdit.SetParagraphProperty(start, end, Paragraph.FlowDirectionProperty, listFlowDirectionValue); // Merge lists on boundaries MergeLists(start); MergeLists(end); } return(true); }
// Token: 0x06003B85 RID: 15237 RVA: 0x0010F26C File Offset: 0x0010D46C internal static bool UnindentListItems(TextRange range) { if (!TextRangeEditLists.IsRangeWithinSingleList(range)) { return(false); } ListItem listItem = TextPointerBase.GetListItem(range.Start); ListItem listItem2 = TextPointerBase.GetListItem((TextPointer)TextRangeEdit.GetAdjustedRangeEnd(range.Start, range.End)); for (TextElement textElement = (TextElement)listItem2.Parent; textElement != listItem.Parent; textElement = (TextElement)textElement.Parent) { listItem2 = (textElement as ListItem); } if (listItem2 == null) { return(false); } if (listItem.PreviousListItem != null) { TextRangeEdit.SplitElement(listItem.ElementStart); } if (listItem2.NextListItem != null) { TextRangeEdit.SplitElement(listItem2.ElementEnd); } List list = (List)listItem.Parent; ListItem listItem3 = list.Parent as ListItem; if (listItem3 != null) { list.Reposition(null, null); TextPointer contentEnd = listItem3.ContentEnd; if (listItem3.ContentStart.CompareTo(listItem.ElementStart) == 0) { listItem3.Reposition(null, null); } else { listItem3.Reposition(listItem3.ContentStart, listItem.ElementStart); } if (contentEnd.CompareTo(listItem2.ElementEnd) != 0) { TextPointer contentEnd2 = listItem2.ContentEnd; listItem2.Reposition(listItem2.ContentStart, contentEnd); TextRangeEditLists.MergeLists(contentEnd2); } } else { TextPointer elementStart = list.ElementStart; TextPointer elementEnd = list.ElementEnd; object value = list.GetValue(Block.FlowDirectionProperty); list.Reposition(null, null); ListItem listItem5; for (ListItem listItem4 = listItem; listItem4 != null; listItem4 = ((listItem4 == listItem2) ? null : listItem5)) { listItem5 = (listItem4.ElementEnd.GetAdjacentElement(LogicalDirection.Forward) as ListItem); if (listItem4.ContentStart.CompareTo(listItem4.ContentEnd) == 0) { TextRangeEditTables.EnsureInsertionPosition(listItem4.ContentStart); } listItem4.Reposition(null, null); } TextRangeEdit.SetParagraphProperty(elementStart, elementEnd, Block.FlowDirectionProperty, value); TextRangeEditLists.MergeLists(elementStart); TextRangeEditLists.MergeLists(elementEnd); } return(true); }
/// <summary> /// Applies a property to a range between start and end positions. /// </summary> /// <param name="start"> /// TextPointer identifying start of affected range. /// </param> /// <param name="end"> /// TextPointer identifying end of affected range. /// </param> /// <param name="formattingProperty"> /// A dependency property whose value is supposed to applied to a range. /// </param> /// <param name="value"> /// A value for a property to apply. /// </param> /// <param name="propertyValueAction"> /// Specifies how to use the value - as absolute, as increment or a decrement. /// </param> internal static void SetInlineProperty(TextPointer start, TextPointer end, DependencyProperty formattingProperty, object value, PropertyValueAction propertyValueAction) { // Check for corner case when we have siple text run with all properties set as requested. // This case is iportant optimization for Backspace-Type scenario, when Springload formatting applies for nothing for 50 properties if (start.CompareTo(end) >= 0 || propertyValueAction == PropertyValueAction.SetValue && start.Parent is Run && start.Parent == end.Parent && TextSchema.ValuesAreEqual(start.Parent.GetValue(formattingProperty), value)) { return; } // Remove unnecessary spans on range ends - to optimize resulting markup RemoveUnnecessarySpans(start); RemoveUnnecessarySpans(end); if (TextSchema.IsStructuralCharacterProperty(formattingProperty)) { SetStructuralInlineProperty(start, end, formattingProperty, value); } else { SetNonStructuralInlineProperty(start, end, formattingProperty, value, propertyValueAction); } }
// Helper that walks paragraphs between start and end positions, applying passed formattingProperty value on them. private static void ApplyStructuralInlinePropertyAcrossParagraphs(TextPointer start, TextPointer end, DependencyProperty formattingProperty, object value) { // We assume to call this method only for paragraph crossing case Invariant.Assert(start.Paragraph != null); Invariant.Assert(start.Paragraph.ContentEnd.CompareTo(end) < 0); // Apply to first Paragraph SetStructuralInlineProperty(start, start.Paragraph.ContentEnd, formattingProperty, value); start = start.Paragraph.ElementEnd; // Apply to last paragraph if (end.Paragraph != null) { SetStructuralInlineProperty(end.Paragraph.ContentStart, end, formattingProperty, value); end = end.Paragraph.ElementStart; } // Now, loop through paragraphs between start and end positions while (start != null && start.CompareTo(end) < 0) { if (start.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart && start.Parent is Paragraph) { Paragraph paragraph = (Paragraph)start.Parent; // Apply property to paragraph just found. SetStructuralInlineProperty(paragraph.ContentStart, paragraph.ContentEnd, formattingProperty, value); // Jump to Paragraph end to skip Inline formatting tags. start = paragraph.ElementEnd; } start = start.GetNextContextPosition(LogicalDirection.Forward); } }
private static void ApplyStructuralInlinePropertyAcrossRun(TextPointer start, TextPointer end, Run run, DependencyProperty formattingProperty, object value) { if (start.CompareTo(end) == 0) { // When the range is empty we should ignore the command, except // for the case of empty Run which can be encountered in empty paragraphs if (run.IsEmpty) { run.SetValue(formattingProperty, value); } } else { // Split elements at start and end boundaries. start = SplitFormattingElements(start, /*keepEmptyFormatting:*/false, /*limitingAncestor*/run.Parent as TextElement); end = SplitFormattingElements(end, /*keepEmptyFormatting:*/false, /*limitingAncestor*/run.Parent as TextElement); run = (Run)start.GetAdjacentElement(LogicalDirection.Forward); run.SetValue(formattingProperty, value); } // Clear property value from all ancestors of this Run. FixupStructuralPropertyEnvironment(run, formattingProperty); }
// Helper that walks Run and Span elements between start and end positions, // clearing value of passed formattingProperty on them. // private static void ClearPropertyValueFromSpansAndRuns(TextPointer start, TextPointer end, DependencyProperty formattingProperty) { // Normalize start position forward. start = start.GetPositionAtOffset(0, LogicalDirection.Forward); // Move to next context position before entering loop below, // since in the loop we look backward. start = start.GetNextContextPosition(LogicalDirection.Forward); while (start != null && start.CompareTo(end) < 0) { if (start.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart && TextSchema.IsFormattingType(start.Parent.GetType())) // look for Run/Span elements { start.Parent.ClearValue(formattingProperty); // Remove unnecessary Spans around this position, delete empty formatting elements (if any) // and merge with adjacent inlines if they have identical set of formatting properties. MergeFormattingInlines(start); } start = start.GetNextContextPosition(LogicalDirection.Forward); } }
// Finds a Run element with ElementStart at or after the given pointer // Creates Runs at potential run positions if encounters some. private static Run GetNextRun(TextPointer pointer, TextPointer limit) { Run run = null; while (pointer != null && pointer.CompareTo(limit) < 0) { if (pointer.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart && (run = pointer.GetAdjacentElement(LogicalDirection.Forward) as Run) != null) { break; } if (TextPointerBase.IsAtPotentialRunPosition(pointer)) { pointer = TextRangeEditTables.EnsureInsertionPosition(pointer); Invariant.Assert(pointer.Parent is Run); run = pointer.Parent as Run; break; } // Advance the scanning pointer pointer = pointer.GetNextContextPosition(LogicalDirection.Forward); } return run; }
/// <summary> /// Helper for TextContainer.DeleteContent allowing arbitrary /// order of positions and doinng nothing in case of empty range. /// Removes remaining empty formatting elements - if they not inside empty blocks. /// </summary> /// <param name="one"> /// One of content boundary positions. May precede or follow the TextPointer two. /// Must belong to the same scope as TextPointer two. /// </param> /// <param name="two"> /// Another content boundary position. May precede or follow the TextPointer one. /// Must belong to the same scope as TextPointer one. /// </param> /// <returns> /// true if surrounding formatting elements have beed deleted as a side effect. /// </returns> private static bool DeleteContentBetweenPositions(TextPointer one, TextPointer two) { Invariant.Assert(one.Parent == two.Parent, "inconsistent Parents: one and two"); if (one.CompareTo(two) < 0) { one.TextContainer.DeleteContentInternal(one, two); } else if (one.CompareTo(two) > 0) { two.TextContainer.DeleteContentInternal(two, one); } Invariant.Assert(one.CompareTo(two) == 0, "Positions one and two must be equal now"); return false; }
public static TextRange FindText(TextPointer findContainerStartPosition, TextPointer findContainerEndPosition, String input, FindFlags flags, CultureInfo cultureInfo) { TextRange textRange = null; if (findContainerStartPosition.CompareTo(findContainerEndPosition) < 0) { try { if (findMethod == null) { findMethod = typeof(FrameworkElement).Assembly.GetType("System.Windows.Documents.TextFindEngine"). GetMethod("Find", BindingFlags.Static | BindingFlags.Public); } textRange = findMethod.Invoke(null, new Object[] { findContainerStartPosition, findContainerEndPosition, input, flags, CultureInfo.CurrentCulture }) as TextRange; } catch (ApplicationException) { textRange = null; } } return textRange; }
/// <summary>Initializes a new instance of the <see cref="T:System.Windows.Documents.Span" /> class, taking two <see cref="T:System.Windows.Documents.TextPointer" /> objects that indicate the beginning and end of a selection of content that the new <see cref="T:System.Windows.Documents.Span" /> will contain.</summary> /// <param name="start">A <see cref="T:System.Windows.Documents.TextPointer" /> that indicates the beginning of a selection of content that the new <see cref="T:System.Windows.Documents.Span" /> will contain.</param> /// <param name="end">A <see cref="T:System.Windows.Documents.TextPointer" /> that indicates the end of a selection of content that the new <see cref="T:System.Windows.Documents.Span" /> will contain.</param> /// <exception cref="T:System.ArgumentNullException">Raised when <paramref name="start" /> or <paramref name="end" /> is null.</exception> /// <exception cref="T:System.ArgumentException">Raised when <paramref name="start" /> and <paramref name="end" /> do not resolve to a range of content suitable for enclosure by a <see cref="T:System.Windows.Documents.Span" /> element; for example, if <paramref name="start" /> and <paramref name="end" /> indicate positions in different paragraphs.</exception> // Token: 0x06003543 RID: 13635 RVA: 0x000F1218 File Offset: 0x000EF418 public Span(TextPointer start, TextPointer end) { if (start == null) { throw new ArgumentNullException("start"); } if (end == null) { throw new ArgumentNullException("start"); } if (start.TextContainer != end.TextContainer) { throw new ArgumentException(SR.Get("InDifferentTextContainers", new object[] { "start", "end" })); } if (start.CompareTo(end) > 0) { throw new ArgumentException(SR.Get("BadTextPositionOrder", new object[] { "start", "end" })); } start.TextContainer.BeginChange(); try { start = TextRangeEditTables.EnsureInsertionPosition(start); Invariant.Assert(start.Parent is Run); end = TextRangeEditTables.EnsureInsertionPosition(end); Invariant.Assert(end.Parent is Run); if (start.Paragraph != end.Paragraph) { throw new ArgumentException(SR.Get("InDifferentParagraphs", new object[] { "start", "end" })); } Inline nonMergeableInlineAncestor; if ((nonMergeableInlineAncestor = start.GetNonMergeableInlineAncestor()) != null) { throw new InvalidOperationException(SR.Get("TextSchema_CannotSplitElement", new object[] { nonMergeableInlineAncestor.GetType().Name })); } if ((nonMergeableInlineAncestor = end.GetNonMergeableInlineAncestor()) != null) { throw new InvalidOperationException(SR.Get("TextSchema_CannotSplitElement", new object[] { nonMergeableInlineAncestor.GetType().Name })); } TextElement commonAncestor = TextElement.GetCommonAncestor((TextElement)start.Parent, (TextElement)end.Parent); while (start.Parent != commonAncestor) { start = this.SplitElement(start); } while (end.Parent != commonAncestor) { end = this.SplitElement(end); } if (start.Parent is Run) { start = this.SplitElement(start); } if (end.Parent is Run) { end = this.SplitElement(end); } Invariant.Assert(start.Parent == end.Parent); Invariant.Assert(TextSchema.IsValidChild(start, typeof(Span))); base.Reposition(start, end); } finally { start.TextContainer.EndChange(); } }
/// <summary> /// Applies formatting properties for whole block elements. /// </summary> /// <param name="start"> /// a position within first block in sequence /// </param> /// <param name="end"> /// a positionn within last block in sequence /// </param> /// <param name="property"> /// property changed on blocks /// </param> /// <param name="value"> /// value for the property /// </param> /// <param name="propertyValueAction"> /// Specifies how to use the value - as absolute, as increment or a decrement. /// </param> internal static void SetParagraphProperty(TextPointer start, TextPointer end, DependencyProperty property, object value, PropertyValueAction propertyValueAction) { Invariant.Assert(start != null, "null check: start"); Invariant.Assert(end != null, "null check: end"); Invariant.Assert(start.CompareTo(end) <= 0, "expecting: start <= end"); Invariant.Assert(property != null, "null check: property"); // Exclude last opening tag to avoid affecting a paragraph following the selection end = (TextPointer)TextRangeEdit.GetAdjustedRangeEnd(start, end); // Expand start pointer to the beginning of the first paragraph/blockuicontainer Block startParagraphOrBlockUIContainer = start.ParagraphOrBlockUIContainer; if (startParagraphOrBlockUIContainer != null) { start = startParagraphOrBlockUIContainer.ContentStart; } // Applying FlowDirection requires splitting all containing lists on the range boundaries // because the property is applied to whole List element (to affect bullet appearence) if (property == Block.FlowDirectionProperty) { // Split any boundary lists if needed. // We want to maintain the invariant that all lists and paragraphs within a list, have the same FlowDirection value. // If paragraph FlowDirection command requests a different value of FlowDirection on parts of a list, // we split the list to maintain this invariant. if (!TextRangeEditLists.SplitListsForFlowDirectionChange(start, end, value)) { // If lists at start and end cannot be split successfully, we cannot apply FlowDirection property to the paragraph content. return; } // And expand range start to the beginning of the containing list ListItem listItem = start.GetListAncestor(); if (listItem != null && listItem.List != null) { start = listItem.List.ElementStart; } } // Walk all paragraphs in the affected segment. For FlowDirection property, also walk lists. SetParagraphPropertyWorker(start, end, property, value, propertyValueAction); }
/// <summary> /// Makes sure that the content spanned by the range is totally deleted /// including all structural elements and boundaries. /// We need this method to be able to make the range empty for any kind of content. /// This operation is straightforward for all kinds of ranges expect for /// TableCellRange. For cell range it means merging all selected cells /// and deleting the text content of resulting cell. /// </summary> internal static void DeleteContent(TextPointer start, TextPointer end) { // Order positions, as we do not to distinguish between anchor/moving ends in this operation; // but the following code depends on start<=end ordering if (start.CompareTo(end) > 0) { TextPointer whatWasEnd = end; end = start; start = whatWasEnd; } // Check whether we cross table structure boundaries TableCell startCell; TableCell endCell; TableRow startRow; TableRow endRow; TableRowGroup startRowGroup; TableRowGroup endRowGroup; Table startTable; Table endTable; // We need to run a loop here because after boundary tables deletions // we may encounter following tables, so that start/end range will be // again table-crossing. while ( start.CompareTo(end) < 0 && IdentifyTableElements( /*anchorPosition:*/start, /*movingPosition:*/end, /*includeCellAtMovingPosition:*/false, out startCell, out endCell, out startRow, out endRow, out startRowGroup, out endRowGroup, out startTable, out endTable)) { if (startTable == null && endTable == null || startTable == endTable) { bool isTableCellRange; List<TextSegment> textSegments = TextRangeEditTables.BuildTableRange( /*anchorPosition:*/start, /*movingPosition:*/end, /*includeCellAtMovingPosition*/false, out isTableCellRange); if (isTableCellRange && textSegments != null) { // It is cell selection. Create the content of all selected cells for (int i = 0; i < textSegments.Count; i++) { ClearTableCells(textSegments[i]); } // Collapse the range to bypass the folowing paragraph deletion end = start; } else { // Our range is within one table, so we need to delete // crossed row boundaries // Find start row if (startCell != null) { startRow = startCell.Row; } else if (startRow != null) { // do nothing here. we already have a start row for deletion. } else if (startRowGroup != null) { startRow = startRowGroup.Rows[0]; } // Find end row if (endCell != null) { endRow = startCell.Row; } else if (endRow != null) { // do nothing here. we already have an end row for deletion. } else if (endRowGroup != null) { endRow = endRowGroup.Rows[endRowGroup.Rows.Count - 1]; } Invariant.Assert(startRow != null && endRow != null, "startRow and endRow cannot be null, since our range is within one table"); TextRange rowsSegment = new TextRange(startRow.ContentStart, endRow.ContentEnd); TextRangeEditTables.DeleteRows(rowsSegment); // it will take care of rowspans } } else { // Table boundary is crossed on one or both of edges. // So we must delete half(s) of crossed table(s) if (startRow != null) { // Table boundary is crossed on start edge. // So we need to delete all rows from start to the end of this table. // Store position immediately after the first table start = startRow.Table.ElementEnd; // Delete all rows from startRow to the very end of the table TextRange rowsSegment = new TextRange(startRow.ContentStart, startRow.Table.ContentEnd); TextRangeEditTables.DeleteRows(rowsSegment); // it will take care of rowspans } if (endRow != null) { // Table boundary is crossed on end egde. // So we need to delete all rows from start of the table to this endRow. // Store position immediately before the second table end = endRow.Table.ElementStart; // Delete all rows from the beginning of the table to endRow TextRange rowsSegment = new TextRange(endRow.Table.ContentStart, endRow.ContentEnd); TextRangeEditTables.DeleteRows(rowsSegment); } } } // Now that we do not cross table structure, we can apply simple paragraph content deletion. // Delete remaining content between tables if (start.CompareTo(end) < 0) { // Note that both start and end are not normalized here, // which is important, say, when the block between deleted tables // was another Table or something - we want to delete the whole thing, whatever it is // and normalizting start/end would cross its boundary. TextRangeEdit.DeleteParagraphContent(start, end); } }
// Validates that the sibling element at this position belong to expected itemType (Inline, Block, ListItem) private static void ValidateMergingPositions(Type itemType, TextPointer start, TextPointer end) { if (start.CompareTo(end) < 0) { // Verify inner part TextPointerContext forwardFromStart = start.GetPointerContext(LogicalDirection.Forward); TextPointerContext backwardFromEnd = end.GetPointerContext(LogicalDirection.Backward); Invariant.Assert(forwardFromStart == TextPointerContext.ElementStart, "Expecting first opening tag of pasted fragment"); Invariant.Assert(backwardFromEnd == TextPointerContext.ElementEnd, "Expecting last closing tag of pasted fragment"); Invariant.Assert(itemType.IsAssignableFrom(start.GetAdjacentElement(LogicalDirection.Forward).GetType()), "The first pasted fragment item is expected to be a " + itemType.Name); Invariant.Assert(itemType.IsAssignableFrom(end.GetAdjacentElement(LogicalDirection.Backward).GetType()), "The last pasted fragment item is expected to be a " + itemType.Name); // Veryfy outer part TextPointerContext backwardFromStart = start.GetPointerContext(LogicalDirection.Backward); TextPointerContext forwardFromEnd = end.GetPointerContext(LogicalDirection.Forward); Invariant.Assert(backwardFromStart == TextPointerContext.ElementStart || backwardFromStart == TextPointerContext.ElementEnd || backwardFromStart == TextPointerContext.None, "Bad context preceding a pasted fragment"); Invariant.Assert(!(backwardFromStart == TextPointerContext.ElementEnd) || itemType.IsAssignableFrom(start.GetAdjacentElement(LogicalDirection.Backward).GetType()), "An element preceding a pasted fragment is expected to be a " + itemType.Name); Invariant.Assert(forwardFromEnd == TextPointerContext.ElementStart || forwardFromEnd == TextPointerContext.ElementEnd || forwardFromEnd == TextPointerContext.None, "Bad context following a pasted fragment"); Invariant.Assert(!(forwardFromEnd == TextPointerContext.ElementStart) || itemType.IsAssignableFrom(end.GetAdjacentElement(LogicalDirection.Forward).GetType()), "An element following a pasted fragment is expected to be a " + itemType.Name); } }
// ------------------------------------------------------------------ // IContentHost Helpers // ------------------------------------------------------------------ /// <summary> /// Searches for an element in the _complexContent.TextContainer. If the element is found, returns the /// position at which it is found. Otherwise returns null. /// </summary> /// <param name="e"> /// Element to be found. /// </param> /// <remarks> /// We assume that this function is called from within text if the caller knows that _complexContent exists /// and contains a TextContainer. Hence we assert for this condition within the function /// </remarks> private TextPointer FindElementPosition(IInputElement e) { // Parameter validation Debug.Assert(e != null); // Validate that this function is only called when a TextContainer exists as complex content Debug.Assert(_complexContent.TextContainer is TextContainer); TextPointer position; // If e is a TextElement we can optimize by checking its TextContainer if (e is TextElement) { if ((e as TextElement).TextContainer == _complexContent.TextContainer) { // Element found position = new TextPointer((e as TextElement).ElementStart); return position; } } // Else: search for e in the complex content position = new TextPointer((TextPointer)_complexContent.TextContainer.Start); while (position.CompareTo((TextPointer)_complexContent.TextContainer.End) < 0) { // Search each position in _complexContent.TextContainer for the element switch (position.GetPointerContext(LogicalDirection.Forward)) { case TextPointerContext.EmbeddedElement: DependencyObject embeddedObject = position.GetAdjacentElement(LogicalDirection.Forward); if (embeddedObject is ContentElement || embeddedObject is UIElement) { if (embeddedObject == e as ContentElement || embeddedObject == e as UIElement) { return position; } } break; default: break; } position.MoveByOffset(+1); } // Reached end of complex content without finding the element return null; }
// Applies one property to a range from start to end to simulate inheritance of this property from source conntext private static void ApplyContextualProperty(Type targetType, TextPointer start, TextPointer end, DependencyProperty property, object value) { if (TextSchema.ValuesAreEqual(start.Parent.GetValue(property), value)) { return; // The property at insertion position is the same as it was in source context. Nothing to do. } // Advance start pointer to enter pasted fragment start = start.GetNextContextPosition(LogicalDirection.Forward); while (start != null && start.CompareTo(end) < 0) { TextPointerContext passedContext = start.GetPointerContext(LogicalDirection.Backward); if (passedContext == TextPointerContext.ElementStart) { TextElement element = (TextElement)start.Parent; // Check if this element affects the property in question if (element.ReadLocalValue(property) != DependencyProperty.UnsetValue || !TextSchema.ValuesAreEqual(element.GetValue(property), element.Parent.GetValue(property))) { // The element affects this property, so we can skip it start = element.ElementEnd; } else if (targetType.IsAssignableFrom(element.GetType())) { start = element.ElementEnd; if (targetType == typeof(Block) && start.CompareTo(end) > 0) { // Contextual properties should not apply to the last paragraph // when it is merged with the following content - // to avoid affecting the folowing visible content formatting. break; } // This is topmost-level inline element which inherits this property. // Set the value explicitly if (!TextSchema.ValuesAreEqual(value, element.GetValue(property))) { element.ClearValue(property); if (!TextSchema.ValuesAreEqual(value, element.GetValue(property))) { element.SetValue(property, value); } TextRangeEdit.MergeFormattingInlines(element.ElementStart); } } else { // Traverse down into a structured (non-innline) element start = start.GetNextContextPosition(LogicalDirection.Forward); } } else { // Traverse up from any element Invariant.Assert(passedContext != TextPointerContext.None, "TextPointerContext.None is not expected"); start = start.GetNextContextPosition(LogicalDirection.Forward); } } }
/// <summary> /// Find the corresponding <see cref="TextRange"/> instance /// representing the input string given a specified text pointer position. /// </summary> /// <param name="position">the current text position</param> /// <param name="textToFind">input text</param> /// <param name="findOptions">the search option</param> /// <returns>An <see cref="TextRange"/> instance represeneting the matching string withing the text container.</returns> public TextRange GetTextRangeFromPosition(ref TextPointer position, String input, FindOptions findOptions) { Boolean matchCase = findOptions.MatchCase; Boolean matchWholeWord = findOptions.MatchWholeWord; TextRange textRange = null; while (position != null) { if (position.CompareTo(inputDocument.ContentEnd) == 0) //到了文档结尾 { break; } //是文本元素 if (position.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.Text) { String textRun = position.GetTextInRun(LogicalDirection.Forward); //读取文本 StringComparison stringComparison = matchCase ? StringComparison.CurrentCulture : StringComparison.CurrentCultureIgnoreCase; //进行查找 Int32 indexInRun = textRun.IndexOf(input, stringComparison); if (indexInRun >= 0) //找到了 { position = position.GetPositionAtOffset(indexInRun); //移动文字指针到开头 TextPointer nextPointer = position.GetPositionAtOffset(input.Length); //设定匹配项尾文字指针 textRange = new TextRange(position, nextPointer); if (matchWholeWord) //是全字匹配的话 { if (IsWholeWord(textRange)) // 测试匹配项是否是一个单词 { // 是一个完整的单词 break; } else { // 找到的不是一个完整的单词,继续在本Run元素中查找 position = position.GetPositionAtOffset(input.Length); return GetTextRangeFromPosition(ref position, input, findOptions); } } else { //不要求全字匹配 position = position.GetPositionAtOffset(input.Length); break; } } else { // 没找到匹配项,移到当前的Run元素之后 "textRun". position = position.GetPositionAtOffset(textRun.Length); } } else { //如果当前位置不是文本类型的元素,继续"前进",跳过这些非文本元素. position = position.GetNextContextPosition(LogicalDirection.Forward); } } return textRange; }
// Finds a Paragraph/BlockUIContainer/List element with ElementStart before or at the given pointer // Creates implicit paragraphs at potential paragraph positions if needed private static Block GetNextBlock(TextPointer pointer, TextPointer limit) { Block block = null; while (pointer != null && pointer.CompareTo(limit) <= 0) { if (pointer.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart) { block = pointer.Parent as Block; if (block is Paragraph || block is BlockUIContainer || block is List) { break; } } if (TextPointerBase.IsAtPotentialParagraphPosition(pointer)) { pointer = TextRangeEditTables.EnsureInsertionPosition(pointer); block = pointer.Paragraph; Invariant.Assert(block != null); break; } // Advance the scanning pointer pointer = pointer.GetNextContextPosition(LogicalDirection.Forward); } return block; }
// 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); }
/// <summary> /// Creates a new Span instance covering existing content. /// </summary> /// <param name="start"> /// Start position of the new Span. /// </param> /// <param name="end"> /// End position of the new Span. /// </param> /// <remarks> /// start and end must both be parented by the same Paragraph, otherwise /// the method will raise an ArgumentException. /// </remarks> public Span(TextPointer start, TextPointer end) { if (start == null) { throw new ArgumentNullException("start"); } if (end == null) { throw new ArgumentNullException("start"); } if (start.TextContainer != end.TextContainer) { throw new ArgumentException(SR.Get(SRID.InDifferentTextContainers, "start", "end")); } if (start.CompareTo(end) > 0) { throw new ArgumentException(SR.Get(SRID.BadTextPositionOrder, "start", "end")); } start.TextContainer.BeginChange(); try { start = TextRangeEditTables.EnsureInsertionPosition(start); Invariant.Assert(start.Parent is Run); end = TextRangeEditTables.EnsureInsertionPosition(end); Invariant.Assert(end.Parent is Run); if (start.Paragraph != end.Paragraph) { throw new ArgumentException(SR.Get(SRID.InDifferentParagraphs, "start", "end")); } // If start or end positions have a Hyperlink ancestor, we cannot split them. Inline nonMergeableAncestor; if ((nonMergeableAncestor = start.GetNonMergeableInlineAncestor()) != null) { throw new InvalidOperationException(SR.Get(SRID.TextSchema_CannotSplitElement, nonMergeableAncestor.GetType().Name)); } if ((nonMergeableAncestor = end.GetNonMergeableInlineAncestor()) != null) { throw new InvalidOperationException(SR.Get(SRID.TextSchema_CannotSplitElement, nonMergeableAncestor.GetType().Name)); } TextElement commonAncestor = TextElement.GetCommonAncestor((TextElement)start.Parent, (TextElement)end.Parent); while (start.Parent != commonAncestor) { start = SplitElement(start); } while (end.Parent != commonAncestor) { end = SplitElement(end); } if (start.Parent is Run) { start = SplitElement(start); } if (end.Parent is Run) { end = SplitElement(end); } Invariant.Assert(start.Parent == end.Parent); Invariant.Assert(TextSchema.IsValidChild(/*position*/start, /*childType*/typeof(Span))); this.Reposition(start, end); } finally { start.TextContainer.EndChange(); } }
/// <summary> /// 根据搜索选项在文档中查找并替换全部匹配字串 /// </summary> /// <param name="input">要查找的字串</param> /// <param name="replacement">用于替换的字串</param> /// <param name="findOptions">搜索选项 </param> /// <returns>进行了替换的次数</returns> /// <remarks> /// 此方法将移动文字指针到最后位置 /// </remarks> public int ReplaceAll(String input, String replacement, FindOptions findOptions) { int count = 0; currentPosition = inputDocument.ContentStart; while (currentPosition.CompareTo(inputDocument.ContentEnd) < 0) { TextRange textRange = Replace(input, replacement, findOptions); if (textRange != null) { count++; } } return count; }
/// <summary> /// UpdateAccessKey - Scans forward in the tree looking for the access key marker, replacing it with access key element. We only support one find. /// </summary> private void UpdateAccessKey() { TextPointer navigator = new TextPointer(TextContainer.Start); while (!_accessKeyLocated && navigator.CompareTo(TextContainer.End) < 0 ) { TextPointerContext symbolType = navigator.GetPointerContext(LogicalDirection.Forward); switch (symbolType) { case TextPointerContext.Text: string text = navigator.GetTextInRun(LogicalDirection.Forward); int index = FindAccessKeyMarker(text); if(index != -1 && index < text.Length - 1) { string keyText = StringInfo.GetNextTextElement(text, index + 1); TextPointer keyEnd = navigator.GetPositionAtOffset(index + 1 + keyText.Length); _accessKey = new Run(keyText); _accessKey.Style = AccessKeyStyle; RegisterAccessKey(); HasCustomSerializationStorage.SetValue(_accessKey, true); _accessKeyLocated = true; UninitializeTextContainerListener(); TextContainer.BeginChange(); try { TextPointer underlineStart = new TextPointer(navigator, index); TextRangeEdit.DeleteInlineContent(underlineStart, keyEnd); _accessKey.RepositionWithContent(underlineStart); } finally { TextContainer.EndChange(); InitializeTextContainerListener(); } } break; } navigator.MoveToNextContextPosition(LogicalDirection.Forward); } // Convert double _ to single _ navigator = new TextPointer(TextContainer.Start); string accessKeyMarker = AccessKeyMarker.ToString(); string doubleAccessKeyMarker = accessKeyMarker + accessKeyMarker; while (navigator.CompareTo(TextContainer.End) < 0) { TextPointerContext symbolType = navigator.GetPointerContext(LogicalDirection.Forward); switch (symbolType) { case TextPointerContext.Text: string text = navigator.GetTextInRun(LogicalDirection.Forward); string nexText = text.Replace(doubleAccessKeyMarker, accessKeyMarker); if (text != nexText) { TextPointer keyStart = new TextPointer(navigator, 0); TextPointer keyEnd = new TextPointer(navigator, text.Length); UninitializeTextContainerListener(); TextContainer.BeginChange(); try { keyEnd.InsertTextInRun(nexText); TextRangeEdit.DeleteInlineContent(keyStart, keyEnd); } finally { TextContainer.EndChange(); InitializeTextContainerListener(); } } break; } navigator.MoveToNextContextPosition(LogicalDirection.Forward); } }
// Removes inline properties that affect formatting from the given range internal static void CharacterResetFormatting(TextPointer start, TextPointer end) { if (start.CompareTo(end) < 0) { // Split formatting elements at range boundaries start = SplitFormattingElements(start, /*keepEmptyFormatting:*/false, /*preserveStructuralFormatting*/true, /*limitingAncestor*/null); end = SplitFormattingElements(end, /*keepEmptyFormatting:*/false, /*preserveStructuralFormatting*/true, /*limitingAncestor*/null); while (start.CompareTo(end) < 0) { if (start.GetPointerContext(LogicalDirection.Backward) == TextPointerContext.ElementStart) { // When entering a next element check whether we should clear its inline properties. TextElement parent = (TextElement)start.Parent; // Note we do cleaning for Inline elements only - so properties set on Paragraphs // and other blocks will stay unchanged even if they set as local value. if (parent is Span && parent.ContentEnd.CompareTo(end) > 0) { // Preserve Hyperlink/Span properties when it is partially selected } // We can't assume that custom types derived from Span, once their formatting // properties are removed, can be transformed into a Span. So treat custom // types as inlines, even if they're derived from Span. else if (parent is Span && TextSchema.IsKnownType(parent.GetType())) { // Remember a position to merge inlines TextPointer mergePosition = parent.ElementStart; // Preserve only non-formatting properties of original span element. Span newSpan = TransferNonFormattingInlineProperties((Span)parent); if (newSpan != null) { newSpan.Reposition(parent.ElementStart, parent.ElementEnd); mergePosition = newSpan.ElementStart; } // Throw away original span parent.Reposition(null, null); // Now that content has changed, we must try to merge inlines at this position MergeFormattingInlines(mergePosition); } else if (parent is Inline) { ClearFormattingInlineProperties((Inline)parent); // Now that properties may be removed we must try to merge this element with a preceding one MergeFormattingInlines(parent.ElementStart); } } start = start.GetNextContextPosition(LogicalDirection.Forward); } // At the end try ro merge elements at end position MergeFormattingInlines(end); } }
private static List<TextSegment> BuildCrossTableSelection( TextPointer anchorPosition, TextPointer movingPosition, TableRow anchorRow, TableRow movingRow) { List<TextSegment> textSegments = new List<TextSegment>(1); if (anchorPosition.CompareTo(movingPosition) < 0) { textSegments.Add( NewNormalizedTextSegment( anchorRow != null ? anchorRow.ContentStart : anchorPosition, movingRow != null ? movingRow.ContentEnd : movingPosition)); } else { textSegments.Add( NewNormalizedTextSegment( movingRow != null ? movingRow.ContentStart : movingPosition, anchorRow != null ? anchorRow.ContentEnd : anchorPosition)); } return textSegments; }