// Token: 0x06007C3C RID: 31804 RVA: 0x0022EF74 File Offset: 0x0022D174
internal static ITextView GetDocumentPageTextView(ITextPointer pointer)
{
DependencyObject parent = pointer.TextContainer.Parent;
if (parent != null)
{
FlowDocumentScrollViewer flowDocumentScrollViewer = PathNode.GetParent(parent) as FlowDocumentScrollViewer;
if (flowDocumentScrollViewer != null)
{
IServiceProvider serviceProvider = flowDocumentScrollViewer.ScrollViewer.Content as IServiceProvider;
Invariant.Assert(serviceProvider != null, "FlowDocumentScrollViewer should be an IServiceProvider.");
return(serviceProvider.GetService(typeof(ITextView)) as ITextView);
}
}
int num;
IDocumentPaginatorSource pointerPage = TextSelectionHelper.GetPointerPage(pointer, out num);
if (pointerPage != null && num >= 0)
{
DocumentPage page = pointerPage.DocumentPaginator.GetPage(num);
IServiceProvider serviceProvider2 = page as IServiceProvider;
if (serviceProvider2 != null)
{
return(serviceProvider2.GetService(typeof(ITextView)) as ITextView);
}
}
return(null);
}
/// <summary>
/// Gets the TextView exposed by the page where this pointer lives
/// </summary>
/// <param name="pointer">the pointer</param>
/// <returns>the TextView</returns>
internal static ITextView GetDocumentPageTextView(ITextPointer pointer)
{
int pageNumber;
DependencyObject content = pointer.TextContainer.Parent as DependencyObject;
if (content != null)
{
FlowDocumentScrollViewer scrollViewer = PathNode.GetParent(content) as FlowDocumentScrollViewer;
if (scrollViewer != null)
{
IServiceProvider provider = scrollViewer.ScrollViewer.Content as IServiceProvider;
Invariant.Assert(provider != null, "FlowDocumentScrollViewer should be an IServiceProvider.");
return(provider.GetService(typeof(ITextView)) as ITextView);
}
}
IDocumentPaginatorSource idp = GetPointerPage(pointer, out pageNumber);
if (idp != null && pageNumber >= 0)
{
DocumentPage docPage = idp.DocumentPaginator.GetPage(pageNumber);
IServiceProvider isp = docPage as IServiceProvider;
if (isp != null)
{
return(isp.GetService(typeof(ITextView)) as ITextView);
}
}
return(null);
}
/// <summary>
/// Builds a path from an element to the root of its tree. Every
/// element in between the element and the root is added to the
/// path.
/// </summary>
/// <param name="node">the element to build a path for</param>
/// <returns>the PathNode instance referring to the root of the tree; its
/// children/descendants only include the nodes between the root and
/// node</returns>
private static PathNode BuildPathForElement(DependencyObject node)
{
Debug.Assert(node != null, "node can not be null");
PathNode childNode = null;
while (node != null)
{
PathNode pathNode = new PathNode(node);
if (childNode != null)
{
pathNode.AddChild(childNode);
}
childNode = pathNode;
// If we find a node that has the service set on it, we should stop
// after processing it. For cases without a service like unit tests,
// this node won't be found and we'll continue to the root.
if (node.ReadLocalValue(AnnotationService.ServiceProperty) != DependencyProperty.UnsetValue)
{
break;
}
node = PathNode.GetParent(node);
}
return(childNode);
}
/// <summary>
/// Gets the parent element of ITextPointer.
/// </summary>
/// <param name="pointer">the pointer to examine</param>
/// <returns>the parent element of this pointer; can be null</returns>
/// <exception cref="ArgumentNullException">pointer is null</exception>
public static UIElement GetParent(ITextPointer pointer)
{
if (pointer == null)
{
throw new ArgumentNullException("pointer");
}
DependencyObject document = pointer.TextContainer.Parent;
DependencyObject parent = PathNode.GetParent(document);
FlowDocumentScrollViewer scrollViewer = parent as FlowDocumentScrollViewer;
if (scrollViewer != null)
{
return((UIElement)scrollViewer.ScrollViewer.Content);
}
// Special case - for paginated content we want the DocumentPageHost for the
// specific page instead of the viewer.
DocumentViewerBase documentViewerBase = parent as DocumentViewerBase;
if (documentViewerBase != null)
{
int pageNumber;
// We get the content again here GetPointerPage handles
// special cases like FixedDocumentSequences
IDocumentPaginatorSource content = GetPointerPage(pointer.CreatePointer(LogicalDirection.Forward), out pageNumber);
if (pageNumber >= 0)
{
foreach (DocumentPageView dpv in documentViewerBase.PageViews)
{
if (dpv.PageNumber == pageNumber)
{
// DPVs always have one child - the DocumentPageHost
int count = VisualTreeHelper.GetChildrenCount(dpv);
Invariant.Assert(count == 1);
return(VisualTreeHelper.GetChild(dpv, 0) as DocumentPageHost);
}
}
// Page must not be visible.
return(null);
}
}
return(parent as UIElement);
}
/// <summary>
/// Gets a list of ITextViews spanned by this text segment
/// </summary>
/// <param name="segment">the text segment</param>
/// <returns>the TextViews list</returns>
internal static List <ITextView> GetDocumentPageTextViews(TextSegment segment)
{
List <ITextView> res = null;
int startPageNumber, endPageNumber;
//revert the logical direction of the pointers
ITextPointer start = segment.Start.CreatePointer(LogicalDirection.Forward);
ITextPointer end = segment.End.CreatePointer(LogicalDirection.Backward);
DependencyObject content = start.TextContainer.Parent as DependencyObject;
if (content != null)
{
FlowDocumentScrollViewer scrollViewer = PathNode.GetParent(content) as FlowDocumentScrollViewer;
if (scrollViewer != null)
{
IServiceProvider provider = scrollViewer.ScrollViewer.Content as IServiceProvider;
Invariant.Assert(provider != null, "FlowDocumentScrollViewer should be an IServiceProvider.");
res = new List <ITextView>(1);
res.Add(provider.GetService(typeof(ITextView)) as ITextView);
return(res);
}
}
IDocumentPaginatorSource idp = GetPointerPage(start, out startPageNumber);
DynamicDocumentPaginator ddp = idp.DocumentPaginator as DynamicDocumentPaginator;
endPageNumber = ddp != null?ddp.GetPageNumber((ContentPosition)end) : -1;
if (startPageNumber == -1 || endPageNumber == -1)
{
// If either page couldn't be found, we return an empty list. This
// could be caused by a failure in paginating the document.
res = new List <ITextView>(0);
}
else if (startPageNumber == endPageNumber)
{
res = ProcessSinglePage(idp, startPageNumber);
}
else
{
res = ProcessMultiplePages(idp, startPageNumber, endPageNumber);
}
return(res);
}
/// <summary>
/// Gets existing views for pages from start to end. Scans only existing view to
/// avoid loading of unloaded pages.
/// </summary>
/// <param name="idp">IDocumentPaginatorSource</param>
/// <param name="startPageNumber">start page number</param>
/// <param name="endPageNumber">end page number</param>
/// <returns>returns a list of text views</returns>
private static List <ITextView> ProcessMultiplePages(IDocumentPaginatorSource idp, int startPageNumber, int endPageNumber)
{
Invariant.Assert(idp != null, "IDocumentPaginatorSource is null");
//now get available views
DocumentViewerBase viewer = PathNode.GetParent(idp as DependencyObject) as DocumentViewerBase;
Invariant.Assert(viewer != null, "DocumentViewer not found");
// If the pages for the text segment are reversed (possibly a floater where the floater
// reflow on to a page that comes after its anchor) we just swap them
if (endPageNumber < startPageNumber)
{
int temp = endPageNumber;
endPageNumber = startPageNumber;
startPageNumber = temp;
}
List <ITextView> res = null;
if (idp != null && startPageNumber >= 0 && endPageNumber >= startPageNumber)
{
res = new List <ITextView>(endPageNumber - startPageNumber + 1);
for (int pageNb = startPageNumber; pageNb <= endPageNumber; pageNb++)
{
DocumentPageView view = AnnotationHelper.FindView(viewer, pageNb);
if (view != null)
{
IServiceProvider serviceProvider = view.DocumentPage as IServiceProvider;
if (serviceProvider != null)
{
ITextView textView = serviceProvider.GetService(typeof(ITextView)) as ITextView;
if (textView != null)
{
res.Add(textView);
}
}
}
}
}
return(res);
}
// Token: 0x06007C1D RID: 31773 RVA: 0x0022E8B8 File Offset: 0x0022CAB8
private static PathNode BuildPathForElement(DependencyObject node)
{
PathNode pathNode = null;
while (node != null)
{
PathNode pathNode2 = new PathNode(node);
if (pathNode != null)
{
pathNode2.AddChild(pathNode);
}
pathNode = pathNode2;
if (node.ReadLocalValue(AnnotationService.ServiceProperty) != DependencyProperty.UnsetValue)
{
break;
}
node = PathNode.GetParent(node);
}
return(pathNode);
}
// Token: 0x06007C3D RID: 31805 RVA: 0x0022F01C File Offset: 0x0022D21C
internal static List <ITextView> GetDocumentPageTextViews(TextSegment segment)
{
ITextPointer textPointer = segment.Start.CreatePointer(LogicalDirection.Forward);
ITextPointer textPointer2 = segment.End.CreatePointer(LogicalDirection.Backward);
DependencyObject parent = textPointer.TextContainer.Parent;
if (parent != null)
{
FlowDocumentScrollViewer flowDocumentScrollViewer = PathNode.GetParent(parent) as FlowDocumentScrollViewer;
if (flowDocumentScrollViewer != null)
{
IServiceProvider serviceProvider = flowDocumentScrollViewer.ScrollViewer.Content as IServiceProvider;
Invariant.Assert(serviceProvider != null, "FlowDocumentScrollViewer should be an IServiceProvider.");
return(new List <ITextView>(1)
{
serviceProvider.GetService(typeof(ITextView)) as ITextView
});
}
}
int num;
IDocumentPaginatorSource pointerPage = TextSelectionHelper.GetPointerPage(textPointer, out num);
DynamicDocumentPaginator dynamicDocumentPaginator = pointerPage.DocumentPaginator as DynamicDocumentPaginator;
int num2 = (dynamicDocumentPaginator != null) ? dynamicDocumentPaginator.GetPageNumber((ContentPosition)textPointer2) : -1;
List <ITextView> result;
if (num == -1 || num2 == -1)
{
result = new List <ITextView>(0);
}
else if (num == num2)
{
result = TextSelectionHelper.ProcessSinglePage(pointerPage, num);
}
else
{
result = TextSelectionHelper.ProcessMultiplePages(pointerPage, num, num2);
}
return(result);
}
// Token: 0x06007C35 RID: 31797 RVA: 0x0022EBE4 File Offset: 0x0022CDE4
public static UIElement GetParent(ITextPointer pointer)
{
if (pointer == null)
{
throw new ArgumentNullException("pointer");
}
DependencyObject parent = pointer.TextContainer.Parent;
DependencyObject parent2 = PathNode.GetParent(parent);
FlowDocumentScrollViewer flowDocumentScrollViewer = parent2 as FlowDocumentScrollViewer;
if (flowDocumentScrollViewer != null)
{
return((UIElement)flowDocumentScrollViewer.ScrollViewer.Content);
}
DocumentViewerBase documentViewerBase = parent2 as DocumentViewerBase;
if (documentViewerBase != null)
{
int num;
IDocumentPaginatorSource pointerPage = TextSelectionHelper.GetPointerPage(pointer.CreatePointer(LogicalDirection.Forward), out num);
if (num >= 0)
{
foreach (DocumentPageView documentPageView in documentViewerBase.PageViews)
{
if (documentPageView.PageNumber == num)
{
int childrenCount = VisualTreeHelper.GetChildrenCount(documentPageView);
Invariant.Assert(childrenCount == 1);
return(VisualTreeHelper.GetChild(documentPageView, 0) as DocumentPageHost);
}
}
return(null);
}
}
return(parent2 as UIElement);
}
// Token: 0x06007C3F RID: 31807 RVA: 0x0022F168 File Offset: 0x0022D368
private static List <ITextView> ProcessMultiplePages(IDocumentPaginatorSource idp, int startPageNumber, int endPageNumber)
{
Invariant.Assert(idp != null, "IDocumentPaginatorSource is null");
DocumentViewerBase documentViewerBase = PathNode.GetParent(idp as DependencyObject) as DocumentViewerBase;
Invariant.Assert(documentViewerBase != null, "DocumentViewer not found");
if (endPageNumber < startPageNumber)
{
int num = endPageNumber;
endPageNumber = startPageNumber;
startPageNumber = num;
}
List <ITextView> list = null;
if (idp != null && startPageNumber >= 0 && endPageNumber >= startPageNumber)
{
list = new List <ITextView>(endPageNumber - startPageNumber + 1);
for (int i = startPageNumber; i <= endPageNumber; i++)
{
DocumentPageView documentPageView = AnnotationHelper.FindView(documentViewerBase, i);
if (documentPageView != null)
{
IServiceProvider serviceProvider = documentPageView.DocumentPage as IServiceProvider;
if (serviceProvider != null)
{
ITextView textView = serviceProvider.GetService(typeof(ITextView)) as ITextView;
if (textView != null)
{
list.Add(textView);
}
}
}
}
}
return(list);
}
/// <summary>
/// Creates a selection object spanning the portion of 'startNode'
/// specified by 'locatorPart'.
/// </summary>
/// <param name="locatorPart">locator part specifying data to be spanned</param>
/// <param name="startNode">the node to be spanned by the created
/// selection</param>
/// <param name="attachmentLevel">set to AttachmentLevel.Full if the entire range of text
/// was resolved, otherwise set to StartPortion, MiddlePortion, or EndPortion based on
/// which part of the range was resolved</param>
/// <returns>a selection spanning the portion of 'startNode' specified by
/// 'locatorPart', null if selection described by locator part could not be
/// recreated</returns>
/// <exception cref="ArgumentNullException">locatorPart or startNode are
/// null</exception>
/// <exception cref="ArgumentException">locatorPart is of the incorrect type</exception>
public override Object ResolveLocatorPart(ContentLocatorPart locatorPart, DependencyObject startNode, out AttachmentLevel attachmentLevel)
{
if (startNode == null)
{
throw new ArgumentNullException("startNode");
}
if (locatorPart == null)
{
throw new ArgumentNullException("locatorPart");
}
if (CharacterRangeElementName != locatorPart.PartType)
{
throw new ArgumentException(SR.Get(SRID.IncorrectLocatorPartType, locatorPart.PartType.Namespace + ":" + locatorPart.PartType.Name), "locatorPart");
}
// First we extract the offset and length of the
// text range from the locator part.
int startOffset = 0;
int endOffset = 0;
string stringCount = locatorPart.NameValuePairs[CountAttribute];
if (stringCount == null)
{
throw new ArgumentException(SR.Get(SRID.InvalidLocatorPart, TextSelectionProcessor.CountAttribute));
}
int count = Int32.Parse(stringCount, NumberFormatInfo.InvariantInfo);
TextAnchor anchor = new TextAnchor();
attachmentLevel = AttachmentLevel.Unresolved;
for (int i = 0; i < count; i++)
{
GetLocatorPartSegmentValues(locatorPart, i, out startOffset, out endOffset);
// Now we grab the TextRange so we can create a selection.
// TextBox doesn't expose its internal TextRange so we use
// its API for creating and getting the selection.
ITextPointer elementStart;
ITextPointer elementEnd;
// If we can't get the start/end of the node then we can't resolve the locator part
if (!GetNodesStartAndEnd(startNode, out elementStart, out elementEnd))
{
return(null);
}
// If the offset is not withing the element's text range we return null
int textRangeLength = elementStart.GetOffsetToPosition(elementEnd);
if (startOffset > textRangeLength)
{
return(null);
}
ITextPointer start = elementStart.CreatePointer(startOffset);// new TextPointer((TextPointer)elementStart, startOffset);
ITextPointer end = (textRangeLength <= endOffset) ?
elementEnd.CreatePointer() : //new TextPointer((TextPointer)elementEnd) :
elementStart.CreatePointer(endOffset); // new TextPointer((TextPointer)elementStart, endOffset);
//we do not process 0 length selection
if (start.CompareTo(end) >= 0)
{
return(null);
}
anchor.AddTextSegment(start, end);
}
//we do not support 0 or negative length selection
if (anchor.IsEmpty)
{
throw new ArgumentException(SR.Get(SRID.IncorrectAnchorLength), "locatorPart");
}
attachmentLevel = AttachmentLevel.Full;
if (_clamping)
{
ITextPointer currentStart = anchor.Start;
ITextPointer currentEnd = anchor.End;
IServiceProvider serviceProvider = null;
ITextView textView = null;
if (_targetPage != null)
{
serviceProvider = _targetPage as IServiceProvider;
}
else
{
FlowDocument content = currentStart.TextContainer.Parent as FlowDocument;
serviceProvider = PathNode.GetParent(content as DependencyObject) as IServiceProvider;
}
Invariant.Assert(serviceProvider != null, "No ServiceProvider found to get TextView from.");
textView = serviceProvider.GetService(typeof(ITextView)) as ITextView;
Invariant.Assert(textView != null, "Null TextView provided by ServiceProvider.");
anchor = TextAnchor.TrimToIntersectionWith(anchor, textView.TextSegments);
if (anchor == null)
{
attachmentLevel = AttachmentLevel.Unresolved;
}
else
{
if (anchor.Start.CompareTo(currentStart) != 0)
{
attachmentLevel &= ~AttachmentLevel.StartPortion;
}
if (anchor.End.CompareTo(currentEnd) != 0)
{
attachmentLevel &= ~AttachmentLevel.EndPortion;
}
}
}
return(anchor);
}
// Token: 0x06007C46 RID: 31814 RVA: 0x0022F3A8 File Offset: 0x0022D5A8
public override object ResolveLocatorPart(ContentLocatorPart locatorPart, DependencyObject startNode, out AttachmentLevel attachmentLevel)
{
if (startNode == null)
{
throw new ArgumentNullException("startNode");
}
if (locatorPart == null)
{
throw new ArgumentNullException("locatorPart");
}
if (TextSelectionProcessor.CharacterRangeElementName != locatorPart.PartType)
{
throw new ArgumentException(SR.Get("IncorrectLocatorPartType", new object[]
{
locatorPart.PartType.Namespace + ":" + locatorPart.PartType.Name
}), "locatorPart");
}
int num = 0;
int num2 = 0;
string text = locatorPart.NameValuePairs["Count"];
if (text == null)
{
throw new ArgumentException(SR.Get("InvalidLocatorPart", new object[]
{
"Count"
}));
}
int num3 = int.Parse(text, NumberFormatInfo.InvariantInfo);
TextAnchor textAnchor = new TextAnchor();
attachmentLevel = AttachmentLevel.Unresolved;
for (int i = 0; i < num3; i++)
{
TextSelectionProcessor.GetLocatorPartSegmentValues(locatorPart, i, out num, out num2);
ITextPointer textPointer;
ITextPointer textPointer2;
if (!this.GetNodesStartAndEnd(startNode, out textPointer, out textPointer2))
{
return(null);
}
int offsetToPosition = textPointer.GetOffsetToPosition(textPointer2);
if (num > offsetToPosition)
{
return(null);
}
ITextPointer textPointer3 = textPointer.CreatePointer(num);
ITextPointer textPointer4 = (offsetToPosition <= num2) ? textPointer2.CreatePointer() : textPointer.CreatePointer(num2);
if (textPointer3.CompareTo(textPointer4) >= 0)
{
return(null);
}
textAnchor.AddTextSegment(textPointer3, textPointer4);
}
if (textAnchor.IsEmpty)
{
throw new ArgumentException(SR.Get("IncorrectAnchorLength"), "locatorPart");
}
attachmentLevel = AttachmentLevel.Full;
if (this._clamping)
{
ITextPointer start = textAnchor.Start;
ITextPointer end = textAnchor.End;
IServiceProvider serviceProvider;
if (this._targetPage != null)
{
serviceProvider = this._targetPage;
}
else
{
FlowDocument node = start.TextContainer.Parent as FlowDocument;
serviceProvider = (PathNode.GetParent(node) as IServiceProvider);
}
Invariant.Assert(serviceProvider != null, "No ServiceProvider found to get TextView from.");
ITextView textView = serviceProvider.GetService(typeof(ITextView)) as ITextView;
Invariant.Assert(textView != null, "Null TextView provided by ServiceProvider.");
textAnchor = TextAnchor.TrimToIntersectionWith(textAnchor, textView.TextSegments);
if (textAnchor == null)
{
attachmentLevel = AttachmentLevel.Unresolved;
}
else
{
if (textAnchor.Start.CompareTo(start) != 0)
{
attachmentLevel &= ~AttachmentLevel.StartPortion;
}
if (textAnchor.End.CompareTo(end) != 0)
{
attachmentLevel &= ~AttachmentLevel.EndPortion;
}
}
}
return(textAnchor);
}
