// Token: 0x06007245 RID: 29253 RVA: 0x0020AA54 File Offset: 0x00208C54 internal static List <AutomationPeer> GetAutomationPeersFromRange(ITextPointer start, ITextPointer end, ITextPointer ownerContentStart) { List <AutomationPeer> list = new List <AutomationPeer>(); start = start.CreatePointer(); while (start.CompareTo(end) < 0) { bool flag = false; if (start.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart) { object adjacentElement = start.GetAdjacentElement(LogicalDirection.Forward); if (adjacentElement is ContentElement) { AutomationPeer automationPeer = ContentElementAutomationPeer.CreatePeerForElement((ContentElement)adjacentElement); if (automationPeer != null) { if (ownerContentStart == null || TextContainerHelper.IsImmediateAutomationChild(start, ownerContentStart)) { list.Add(automationPeer); } start.MoveToNextContextPosition(LogicalDirection.Forward); start.MoveToElementEdge(ElementEdge.AfterEnd); flag = true; } } } else if (start.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.EmbeddedElement) { object adjacentElement = start.GetAdjacentElement(LogicalDirection.Forward); if (adjacentElement is UIElement) { if (ownerContentStart == null || TextContainerHelper.IsImmediateAutomationChild(start, ownerContentStart)) { AutomationPeer automationPeer = UIElementAutomationPeer.CreatePeerForElement((UIElement)adjacentElement); if (automationPeer != null) { list.Add(automationPeer); } else { TextContainerHelper.iterate((Visual)adjacentElement, list); } } } else if (adjacentElement is ContentElement) { AutomationPeer automationPeer = ContentElementAutomationPeer.CreatePeerForElement((ContentElement)adjacentElement); if (automationPeer != null && (ownerContentStart == null || TextContainerHelper.IsImmediateAutomationChild(start, ownerContentStart))) { list.Add(automationPeer); } } } if (!flag && !start.MoveToNextContextPosition(LogicalDirection.Forward)) { break; } } return(list); }
// Token: 0x06007247 RID: 29255 RVA: 0x0020ABF0 File Offset: 0x00208DF0 internal static AutomationPeer GetEnclosingAutomationPeer(ITextPointer start, ITextPointer end, out ITextPointer elementStart, out ITextPointer elementEnd) { List <object> list = new List <object>(); List <ITextPointer> list2 = new List <ITextPointer>(); ITextPointer textPointer = start.CreatePointer(); while (typeof(TextElement).IsAssignableFrom(textPointer.ParentType)) { textPointer.MoveToElementEdge(ElementEdge.BeforeStart); object obj = textPointer.GetAdjacentElement(LogicalDirection.Forward); if (obj != null) { list.Insert(0, obj); list2.Insert(0, textPointer.CreatePointer(LogicalDirection.Forward)); } } List <object> list3 = new List <object>(); List <ITextPointer> list4 = new List <ITextPointer>(); textPointer = end.CreatePointer(); while (typeof(TextElement).IsAssignableFrom(textPointer.ParentType)) { textPointer.MoveToElementEdge(ElementEdge.AfterEnd); object obj = textPointer.GetAdjacentElement(LogicalDirection.Backward); if (obj != null) { list3.Insert(0, obj); list4.Insert(0, textPointer.CreatePointer(LogicalDirection.Backward)); } } AutomationPeer automationPeer = null; ITextPointer textPointer2; elementEnd = (textPointer2 = null); elementStart = textPointer2; for (int i = Math.Min(list.Count, list3.Count); i > 0; i--) { if (list[i - 1] == list3[i - 1]) { object obj = list[i - 1]; if (obj is UIElement) { automationPeer = UIElementAutomationPeer.CreatePeerForElement((UIElement)obj); } else if (obj is ContentElement) { automationPeer = ContentElementAutomationPeer.CreatePeerForElement((ContentElement)obj); } if (automationPeer != null) { elementStart = list2[i - 1]; elementEnd = list4[i - 1]; break; } } } return(automationPeer); }
/// <summary> /// Is AutometionPeer represented by 'elementStart' is immediate child of AutomationPeer /// represented by 'ownerContentStart'. /// </summary> internal static bool IsImmediateAutomationChild(ITextPointer elementStart, ITextPointer ownerContentStart) { Invariant.Assert(elementStart.CompareTo(ownerContentStart) >= 0); bool immediateChild = true; // Walk element tree up looking for AutomationPeers. ITextPointer position = elementStart.CreatePointer(); while (typeof(TextElement).IsAssignableFrom(position.ParentType)) { position.MoveToElementEdge(ElementEdge.BeforeStart); if (position.CompareTo(ownerContentStart) <= 0) { break; } AutomationPeer peer = null; object element = position.GetAdjacentElement(LogicalDirection.Forward); if (element is UIElement) { peer = UIElementAutomationPeer.CreatePeerForElement((UIElement)element); } else if (element is ContentElement) { peer = ContentElementAutomationPeer.CreatePeerForElement((ContentElement)element); } if (peer != null) { immediateChild = false; break; } } return(immediateChild); }
// Token: 0x06007246 RID: 29254 RVA: 0x0020AB60 File Offset: 0x00208D60 internal static bool IsImmediateAutomationChild(ITextPointer elementStart, ITextPointer ownerContentStart) { Invariant.Assert(elementStart.CompareTo(ownerContentStart) >= 0); bool result = true; ITextPointer textPointer = elementStart.CreatePointer(); while (typeof(TextElement).IsAssignableFrom(textPointer.ParentType)) { textPointer.MoveToElementEdge(ElementEdge.BeforeStart); if (textPointer.CompareTo(ownerContentStart) <= 0) { break; } AutomationPeer automationPeer = null; object adjacentElement = textPointer.GetAdjacentElement(LogicalDirection.Forward); if (adjacentElement is UIElement) { automationPeer = UIElementAutomationPeer.CreatePeerForElement((UIElement)adjacentElement); } else if (adjacentElement is ContentElement) { automationPeer = ContentElementAutomationPeer.CreatePeerForElement((ContentElement)adjacentElement); } if (automationPeer != null) { result = false; break; } } return(result); }
// Token: 0x06003889 RID: 14473 RVA: 0x000FDB54 File Offset: 0x000FBD54 private static UIElement GetUIElementWhenMouseOver(TextEditor This, Point mouseMovePoint) { ITextPointer textPositionFromPoint = This.TextView.GetTextPositionFromPoint(mouseMovePoint, false); if (textPositionFromPoint == null) { return(null); } if (textPositionFromPoint.GetPointerContext(textPositionFromPoint.LogicalDirection) != TextPointerContext.EmbeddedElement) { return(null); } ITextPointer textPointer = textPositionFromPoint.GetNextContextPosition(textPositionFromPoint.LogicalDirection); LogicalDirection gravity = (textPositionFromPoint.LogicalDirection == LogicalDirection.Forward) ? LogicalDirection.Backward : LogicalDirection.Forward; textPointer = textPointer.CreatePointer(0, gravity); Rect rectangleFromTextPosition = This.TextView.GetRectangleFromTextPosition(textPositionFromPoint); Rect rectangleFromTextPosition2 = This.TextView.GetRectangleFromTextPosition(textPointer); Rect rect = rectangleFromTextPosition; rect.Union(rectangleFromTextPosition2); if (!rect.Contains(mouseMovePoint)) { return(null); } return(textPositionFromPoint.GetAdjacentElement(textPositionFromPoint.LogicalDirection) as UIElement); }
// Token: 0x0600384C RID: 14412 RVA: 0x000FB73C File Offset: 0x000F993C private static ITextPointer GetContentPosition(ITextPointer position) { while (position.GetAdjacentElement(LogicalDirection.Forward) is Inline) { position = position.GetNextContextPosition(LogicalDirection.Forward); } return(position); }
// Return a UIElement when mouseMovePoint is within the ui element's bounding Rect. Null otherwise. private static UIElement GetUIElementWhenMouseOver(TextEditor This, Point mouseMovePoint) { ITextPointer mouseMovePosition = This.TextView.GetTextPositionFromPoint(mouseMovePoint, /*snapToText:*/ false); if (mouseMovePosition == null) { return(null); } if (!(mouseMovePosition.GetPointerContext(mouseMovePosition.LogicalDirection) == TextPointerContext.EmbeddedElement)) { return(null); } // Find out if mouseMovePoint is within the bounding Rect of UIElement, we need to do this check explicitly // because even when snapToText is false, textview returns a first/last position on a line when point is in // an area before/after line start/end. This is by-design behavior for textview. // Need to get Rect from TextView, since Rect returned by TextPointer.GetCharacterRect() // is transformed to UiScope coordinates and we want RenderScope coordinates here. ITextPointer otherEdgePosition = mouseMovePosition.GetNextContextPosition(mouseMovePosition.LogicalDirection); LogicalDirection otherEdgeDirection = (mouseMovePosition.LogicalDirection == LogicalDirection.Forward) ? LogicalDirection.Backward : LogicalDirection.Forward; // Normalize with correct gravity otherEdgePosition = otherEdgePosition.CreatePointer(0, otherEdgeDirection); Rect uiElementFirstEdgeRect = This.TextView.GetRectangleFromTextPosition(mouseMovePosition); Rect uiElementSecondEdgeRect = This.TextView.GetRectangleFromTextPosition(otherEdgePosition); Rect boundingRect = uiElementFirstEdgeRect; boundingRect.Union(uiElementSecondEdgeRect); if (!boundingRect.Contains(mouseMovePoint)) { return(null); } return(mouseMovePosition.GetAdjacentElement(mouseMovePosition.LogicalDirection) as UIElement); }
// Normalizes a range: // // -The start position is advanced over all element edges not visible // to the IMEs. // -Start and end positions are moved to insertion positions. private void GetNormalizedRange(int startCharOffset, int endCharOffset, out ITextPointer start, out ITextPointer end) { start = CreatePointerAtCharOffset(startCharOffset, LogicalDirection.Forward); end = (startCharOffset == endCharOffset) ? start : CreatePointerAtCharOffset(endCharOffset, LogicalDirection.Backward); // Skip over hidden element edges. while (start.CompareTo(end) < 0) { TextPointerContext forwardContext = start.GetPointerContext(LogicalDirection.Forward); if (forwardContext == TextPointerContext.ElementStart) { TextElement element = start.GetAdjacentElement(LogicalDirection.Forward) as TextElement; if (element == null) break; if (element.IMELeftEdgeCharCount != 0) break; } else if (forwardContext != TextPointerContext.ElementEnd) { break; } start.MoveToNextContextPosition(LogicalDirection.Forward); } // Move to insertion positions. // If the positions are already adjacent to text, we must respect // the IME's decision in regards to exact placement. // MoveToInsertionPosition will skip over surrogates and combining // marks, but the IME needs fine-grained control over these positions. if (start.CompareTo(end) == 0) { start = start.GetFormatNormalizedPosition(LogicalDirection.Backward); end = start; } else { start = start.GetFormatNormalizedPosition(LogicalDirection.Backward); end = end.GetFormatNormalizedPosition(LogicalDirection.Backward); } }
// GetText handler for Blocks and TableCell to add '\n' or TS_CHAR_REGION. private static bool WalkRegionBoundary(ITextPointer navigator, ITextPointer limit, char[] text, int cchReq, ref int charsCopied, UnsafeNativeMethods.TS_RUNINFO[] runInfo, int cRunInfoReq, ref int cRunInfoRcv) { bool hitLimit; Invariant.Assert(navigator.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart || navigator.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementEnd); Invariant.Assert(limit == null || navigator.CompareTo(limit) <= 0); // If the caller passed in a non-null limit, we don't do anything and just return true. // we've passed it. if (limit != null) { if (navigator.CompareTo(limit) >= 0) { return true; } } hitLimit = false; if (cchReq > 0) { // Add one TS_CHAR_REGION (TableCell) or '\n' (everything else) char. char ch = (navigator.GetAdjacentElement(LogicalDirection.Forward) is TableCell) ? UnsafeNativeMethods.TS_CHAR_REGION : '\n'; text[charsCopied] = ch; navigator.MoveByOffset(1); charsCopied += 1; hitLimit = (text.Length == charsCopied) || (limit != null && navigator.CompareTo(limit) == 0); } else { // Caller doesn't want text, just run info. // Advance the navigator. // Add one TS_CHAR_REGION char. navigator.MoveByOffset(1); } if (cRunInfoReq > 0) { // Be sure to merge this text run with the previous run, if they are both text runs. // (A good robustness fix would be to make cicero handle this, if we ever get the chance.) if (cRunInfoRcv > 0 && runInfo[cRunInfoRcv - 1].type == UnsafeNativeMethods.TsRunType.TS_RT_PLAIN) { runInfo[cRunInfoRcv - 1].count += 1; } else { runInfo[cRunInfoRcv].count = 1; runInfo[cRunInfoRcv].type = UnsafeNativeMethods.TsRunType.TS_RT_PLAIN; cRunInfoRcv++; } } return hitLimit; }
// Returns a position ajacent to the supplied position, skipping any // intermediate Inlines. // This is useful for sliding inside the context of adjacent Hyperlinks, // Spans, etc. private static ITextPointer GetContentPosition(ITextPointer position) { while (position.GetAdjacentElement(LogicalDirection.Forward) is Inline) { position = position.GetNextContextPosition(LogicalDirection.Forward); } return position; }
// Part of plain text converter: called from GetTextInternal when processing ElementStart for AccessKey elements // Uses s stack of list items indices and updates it for following list items. private static void PlainConvertAccessKey(StringBuilder textBuffer, ITextPointer navigator) { // Creating an "_" prefix for AccessKey character (represented as a Run with special serialization attribution) object element = navigator.GetAdjacentElement(LogicalDirection.Forward); if (AccessText.HasCustomSerialization(element)) { textBuffer.Append(AccessText.AccessKeyMarker); } }
// Part of plain text converter: called from GetTextInternal when processing ElementStart for ListItem elements // Uses s stack of list items indices and updates it for following list items. private static void PlainConvertListItemStart(StringBuilder textBuffer, ITextPointer navigator, ref Stack<int> listItemCounter) { if (navigator is TextPointer) // can do somethinng useful only in concrete TextContainer - not in an abstract one { List list = (List)((TextPointer)navigator).Parent; ListItem listItem = (ListItem)navigator.GetAdjacentElement(LogicalDirection.Forward); // Initialize list context if (listItemCounter == null) { listItemCounter = new Stack<int>(1); } if (listItemCounter.Count == 0) { // List is taken from its middle position. Need to identify starting item number listItemCounter.Push(((IList)listItem.SiblingListItems).IndexOf(listItem)); } // Get list item number Invariant.Assert(listItemCounter.Count > 0, "expectinng listItemCounter.Count > 0"); int listItemIndex = listItemCounter.Pop(); int indexBase = list != null ? list.StartIndex : 0; TextMarkerStyle markerStyle = list != null ? list.MarkerStyle : TextMarkerStyle.Disc; WriteListMarker(textBuffer, markerStyle, listItemIndex + indexBase); // Advance listItemIndex++; listItemCounter.Push(listItemIndex); } }
internal object BuildObjectTree() { IAddChild root; switch (_type) { case ElementType.Table: root = new Table(); break; case ElementType.TableRowGroup: root = new TableRowGroup(); break; case ElementType.TableRow: root = new TableRow(); break; case ElementType.TableCell: root = new TableCell(); break; case ElementType.Paragraph: root = new Paragraph(); break; case ElementType.Hyperlink: Hyperlink link = new Hyperlink(); link.NavigateUri = GetValue(NavigateUriProperty) as Uri; link.RequestNavigate += new RequestNavigateEventHandler(ClickHyperlink); AutomationProperties.SetHelpText(link, (String)this.GetValue(HelpTextProperty)); AutomationProperties.SetName(link, (String)this.GetValue(NameProperty)); root = link; break; default: Debug.Assert(false); root = null; break; } ITextPointer pos = ((ITextPointer)_start).CreatePointer(); while (pos.CompareTo((ITextPointer)_end) < 0) { TextPointerContext tpc = pos.GetPointerContext(LogicalDirection.Forward); if (tpc == TextPointerContext.Text) { root.AddText(pos.GetTextInRun(LogicalDirection.Forward)); } else if (tpc == TextPointerContext.EmbeddedElement) { root.AddChild(pos.GetAdjacentElement(LogicalDirection.Forward)); } else if (tpc == TextPointerContext.ElementStart) { object obj = pos.GetAdjacentElement(LogicalDirection.Forward); if (obj != null) { root.AddChild(obj); pos.MoveToNextContextPosition(LogicalDirection.Forward); pos.MoveToElementEdge(ElementEdge.BeforeEnd); } } pos.MoveToNextContextPosition(LogicalDirection.Forward); } return(root); }
/// <summary> /// Retrieves the range of a child object. /// </summary> /// <param name="childElementProvider">The child element. A provider should check that the /// passed element is a child of the text container, and should throw an /// InvalidOperationException if it is not.</param> /// <returns>A range that spans the child element.</returns> ITextRangeProvider ITextProvider.RangeFromChild(IRawElementProviderSimple childElementProvider) { if (childElementProvider == null) { throw new ArgumentNullException("childElementProvider"); } // Retrieve DependencyObject from AutomationElement DependencyObject childElement; if (_textPeer is TextAutomationPeer) { childElement = ((TextAutomationPeer)_textPeer).ElementFromProvider(childElementProvider); } else { childElement = ((ContentTextAutomationPeer)_textPeer).ElementFromProvider(childElementProvider); } TextRangeAdaptor range = null; if (childElement != null) { ITextPointer rangeStart = null; ITextPointer rangeEnd = null; // Retrieve start and end positions for given element. // If element is TextElement, retrieve its Element Start and End positions. // If element is UIElement hosted by UIContainer (Inlien of Block), // retrieve content Start and End positions of the container. // Otherwise scan ITextContainer to find a range for given element. if (childElement is TextElement) { rangeStart = ((TextElement)childElement).ElementStart; rangeEnd = ((TextElement)childElement).ElementEnd; } else { DependencyObject parent = LogicalTreeHelper.GetParent(childElement); if (parent is InlineUIContainer || parent is BlockUIContainer) { rangeStart = ((TextElement)parent).ContentStart; rangeEnd = ((TextElement)parent).ContentEnd; } else { ITextPointer position = _textContainer.Start.CreatePointer(); while (position.CompareTo(_textContainer.End) < 0) { TextPointerContext context = position.GetPointerContext(LogicalDirection.Forward); if (context == TextPointerContext.ElementStart) { if (childElement == position.GetAdjacentElement(LogicalDirection.Forward)) { rangeStart = position.CreatePointer(LogicalDirection.Forward); position.MoveToElementEdge(ElementEdge.AfterEnd); rangeEnd = position.CreatePointer(LogicalDirection.Backward); break; } } else if (context == TextPointerContext.EmbeddedElement) { if (childElement == position.GetAdjacentElement(LogicalDirection.Forward)) { rangeStart = position.CreatePointer(LogicalDirection.Forward); position.MoveToNextContextPosition(LogicalDirection.Forward); rangeEnd = position.CreatePointer(LogicalDirection.Backward); break; } } position.MoveToNextContextPosition(LogicalDirection.Forward); } } } // Create range if (rangeStart != null && rangeEnd != null) { range = new TextRangeAdaptor(this, rangeStart, rangeEnd, _textPeer); } } if (range == null) { throw new InvalidOperationException(SR.Get(SRID.TextProvider_InvalidChildElement)); } return(range); }
/// <summary> /// This helper method is used by TextRangeAdaptor to bring the range into view /// through multiple nested scroll providers. /// </summary> internal void ScrollIntoView(ITextPointer start, ITextPointer end, bool alignToTop) { // Calculate the bounding rectangle for the range Rect rangeBounds = Rect.Empty; Rect[] lineBounds = GetBoundingRectangles(start, end, false, false); foreach (Rect rect in lineBounds) { rangeBounds.Union(rect); } ITextView textView = GetUpdatedTextView(); if (textView != null && !rangeBounds.IsEmpty) { // Find out the visible portion of the range. Rect visibleRect = GetVisibleRectangle(textView); Rect rangeVisibleBounds = Rect.Intersect(rangeBounds, visibleRect); if (rangeVisibleBounds == rangeBounds) { // The range is already in the view. It's probably not aligned as requested, // but who cares since it's entirely visible anyway. return; } // Ensure the visibility of the range. // BringIntoView will do most of the magic except the very first scroll // in order to satisfy the requested alignment. UIElement renderScope = textView.RenderScope; Visual visual = renderScope; while (visual != null) { IScrollInfo isi = visual as IScrollInfo; if (isi != null) { // Transform the bounding rectangle into the IScrollInfo coordinates. if (visual != renderScope) { GeneralTransform childToParent = renderScope.TransformToAncestor(visual); rangeBounds = childToParent.TransformBounds(rangeBounds); } if (isi.CanHorizontallyScroll) { isi.SetHorizontalOffset(alignToTop ? rangeBounds.Left : (rangeBounds.Right - isi.ViewportWidth)); } if (isi.CanVerticallyScroll) { isi.SetVerticalOffset(alignToTop ? rangeBounds.Top : (rangeBounds.Bottom - isi.ViewportHeight)); } break; } visual = VisualTreeHelper.GetParent(visual) as Visual; } FrameworkElement fe = renderScope as FrameworkElement; if (fe != null) { fe.BringIntoView(rangeVisibleBounds); } } else { // If failed to retrive range bounds, try to Bring into view closes element. ITextPointer pointer = alignToTop ? start.CreatePointer() : end.CreatePointer(); pointer.MoveToElementEdge(alignToTop ? ElementEdge.AfterStart : ElementEdge.AfterEnd); FrameworkContentElement element = pointer.GetAdjacentElement(LogicalDirection.Backward) as FrameworkContentElement; if (element != null) { element.BringIntoView(); } } }
//------------------------------------------------------------------- // // Internal Methods // //------------------------------------------------------------------- #region Internal Methods /// <summary> /// Retrieves a collection of AutomationPeers that fall within the range. /// Children that overlap with the range but are not entirely enclosed by /// it will also be included in the collection. /// </summary> internal static List <AutomationPeer> GetAutomationPeersFromRange(ITextPointer start, ITextPointer end, ITextPointer ownerContentStart) { bool positionMoved; AutomationPeer peer = null; object element; List <AutomationPeer> peers = new List <AutomationPeer>(); start = start.CreatePointer(); while (start.CompareTo(end) < 0) { // Indicate that 'start' position is not moved yet. positionMoved = false; if (start.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart) { // Get adjacent element and try to retrive AutomationPeer for it. element = start.GetAdjacentElement(LogicalDirection.Forward); if (element is ContentElement) { peer = ContentElementAutomationPeer.CreatePeerForElement((ContentElement)element); // If AutomationPeer has been retrieved, add it to the collection. // And skip entire element. if (peer != null) { if (ownerContentStart == null || IsImmediateAutomationChild(start, ownerContentStart)) { peers.Add(peer); } start.MoveToNextContextPosition(LogicalDirection.Forward); start.MoveToElementEdge(ElementEdge.AfterEnd); positionMoved = true; } } } else if (start.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.EmbeddedElement) { // Get adjacent element and try to retrive AutomationPeer for it. element = start.GetAdjacentElement(LogicalDirection.Forward); if (element is UIElement) { if (ownerContentStart == null || IsImmediateAutomationChild(start, ownerContentStart)) { peer = UIElementAutomationPeer.CreatePeerForElement((UIElement)element); // If AutomationPeer has been retrieved, add it to the collection. if (peer != null) { peers.Add(peer); } else { iterate((Visual)element, peers); } } } else if (element is ContentElement) { peer = ContentElementAutomationPeer.CreatePeerForElement((ContentElement)element); // If AutomationPeer has been retrieved, add it to the collection. if (peer != null) { if (ownerContentStart == null || IsImmediateAutomationChild(start, ownerContentStart)) { peers.Add(peer); } } } } // Move to the next content position, if position has not been moved already. if (!positionMoved) { if (!start.MoveToNextContextPosition(LogicalDirection.Forward)) { break; } } } return(peers); }
// Token: 0x060065C7 RID: 26055 RVA: 0x001C84A0 File Offset: 0x001C66A0 internal void ScrollIntoView(ITextPointer start, ITextPointer end, bool alignToTop) { Rect rect = Rect.Empty; Rect[] boundingRectangles = this.GetBoundingRectangles(start, end, false, false); foreach (Rect rect2 in boundingRectangles) { rect.Union(rect2); } ITextView updatedTextView = this.GetUpdatedTextView(); if (updatedTextView != null && !rect.IsEmpty) { Rect visibleRectangle = this.GetVisibleRectangle(updatedTextView); Rect rect3 = Rect.Intersect(rect, visibleRectangle); if (rect3 == rect) { return; } UIElement renderScope = updatedTextView.RenderScope; Visual visual = renderScope; while (visual != null) { IScrollInfo scrollInfo = visual as IScrollInfo; if (scrollInfo != null) { if (visual != renderScope) { GeneralTransform generalTransform = renderScope.TransformToAncestor(visual); rect = generalTransform.TransformBounds(rect); } if (scrollInfo.CanHorizontallyScroll) { scrollInfo.SetHorizontalOffset(alignToTop ? rect.Left : (rect.Right - scrollInfo.ViewportWidth)); } if (scrollInfo.CanVerticallyScroll) { scrollInfo.SetVerticalOffset(alignToTop ? rect.Top : (rect.Bottom - scrollInfo.ViewportHeight)); break; } break; } else { visual = (VisualTreeHelper.GetParent(visual) as Visual); } } FrameworkElement frameworkElement = renderScope as FrameworkElement; if (frameworkElement != null) { frameworkElement.BringIntoView(rect3); return; } } else { ITextPointer textPointer = alignToTop ? start.CreatePointer() : end.CreatePointer(); textPointer.MoveToElementEdge(alignToTop ? ElementEdge.AfterStart : ElementEdge.AfterEnd); FrameworkContentElement frameworkContentElement = textPointer.GetAdjacentElement(LogicalDirection.Backward) as FrameworkContentElement; if (frameworkContentElement != null) { frameworkContentElement.BringIntoView(); } } }
// Token: 0x060065D1 RID: 26065 RVA: 0x001C8918 File Offset: 0x001C6B18 ITextRangeProvider ITextProvider.RangeFromChild(IRawElementProviderSimple childElementProvider) { if (childElementProvider == null) { throw new ArgumentNullException("childElementProvider"); } DependencyObject dependencyObject; if (this._textPeer is TextAutomationPeer) { dependencyObject = ((TextAutomationPeer)this._textPeer).ElementFromProvider(childElementProvider); } else { dependencyObject = ((ContentTextAutomationPeer)this._textPeer).ElementFromProvider(childElementProvider); } TextRangeAdaptor textRangeAdaptor = null; if (dependencyObject != null) { ITextPointer textPointer = null; ITextPointer textPointer2 = null; if (dependencyObject is TextElement) { textPointer = ((TextElement)dependencyObject).ElementStart; textPointer2 = ((TextElement)dependencyObject).ElementEnd; } else { DependencyObject parent = LogicalTreeHelper.GetParent(dependencyObject); if (parent is InlineUIContainer || parent is BlockUIContainer) { textPointer = ((TextElement)parent).ContentStart; textPointer2 = ((TextElement)parent).ContentEnd; } else { ITextPointer textPointer3 = this._textContainer.Start.CreatePointer(); while (textPointer3.CompareTo(this._textContainer.End) < 0) { TextPointerContext pointerContext = textPointer3.GetPointerContext(LogicalDirection.Forward); if (pointerContext == TextPointerContext.ElementStart) { if (dependencyObject == textPointer3.GetAdjacentElement(LogicalDirection.Forward)) { textPointer = textPointer3.CreatePointer(LogicalDirection.Forward); textPointer3.MoveToElementEdge(ElementEdge.AfterEnd); textPointer2 = textPointer3.CreatePointer(LogicalDirection.Backward); break; } } else if (pointerContext == TextPointerContext.EmbeddedElement && dependencyObject == textPointer3.GetAdjacentElement(LogicalDirection.Forward)) { textPointer = textPointer3.CreatePointer(LogicalDirection.Forward); textPointer3.MoveToNextContextPosition(LogicalDirection.Forward); textPointer2 = textPointer3.CreatePointer(LogicalDirection.Backward); break; } textPointer3.MoveToNextContextPosition(LogicalDirection.Forward); } } } if (textPointer != null && textPointer2 != null) { textRangeAdaptor = new TextRangeAdaptor(this, textPointer, textPointer2, this._textPeer); } } if (textRangeAdaptor == null) { throw new InvalidOperationException(SR.Get("TextProvider_InvalidChildElement")); } return(textRangeAdaptor); }
//------------------------------------------------------------------- // // Internal Methods // //------------------------------------------------------------------- #region Internal Methods /// <summary> /// Retrieves a collection of AutomationPeers that fall within the range. /// Children that overlap with the range but are not entirely enclosed by /// it will also be included in the collection. /// </summary> internal static List<AutomationPeer> GetAutomationPeersFromRange(ITextPointer start, ITextPointer end, ITextPointer ownerContentStart) { bool positionMoved; AutomationPeer peer = null; object element; List<AutomationPeer> peers = new List<AutomationPeer>(); start = start.CreatePointer(); while (start.CompareTo(end) < 0) { // Indicate that 'start' position is not moved yet. positionMoved = false; if (start.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart) { // Get adjacent element and try to retrive AutomationPeer for it. element = start.GetAdjacentElement(LogicalDirection.Forward); if (element is ContentElement) { peer = ContentElementAutomationPeer.CreatePeerForElement((ContentElement)element); // If AutomationPeer has been retrieved, add it to the collection. // And skip entire element. if (peer != null) { if (ownerContentStart == null || IsImmediateAutomationChild(start, ownerContentStart)) { peers.Add(peer); } start.MoveToNextContextPosition(LogicalDirection.Forward); start.MoveToElementEdge(ElementEdge.AfterEnd); positionMoved = true; } } } else if (start.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.EmbeddedElement) { // Get adjacent element and try to retrive AutomationPeer for it. element = start.GetAdjacentElement(LogicalDirection.Forward); if (element is UIElement) { if (ownerContentStart == null || IsImmediateAutomationChild(start, ownerContentStart)) { peer = UIElementAutomationPeer.CreatePeerForElement((UIElement)element); // If AutomationPeer has been retrieved, add it to the collection. if (peer != null) { peers.Add(peer); } else { iterate((Visual)element, peers); } } } else if (element is ContentElement) { peer = ContentElementAutomationPeer.CreatePeerForElement((ContentElement)element); // If AutomationPeer has been retrieved, add it to the collection. if (peer != null) { if (ownerContentStart == null || IsImmediateAutomationChild(start, ownerContentStart)) { peers.Add(peer); } } } } // Move to the next content position, if position has not been moved already. if (!positionMoved) { if (!start.MoveToNextContextPosition(LogicalDirection.Forward)) { break; } } } return peers; }
/// <summary> /// Return true if Hyperlink range is invalid. /// Hyperlink is invalid if it include a UiElement except Image or the range end position /// is stated before the end position of hyperlink. /// This must be called before Hyperlink start element position. /// </summary> private static bool IsHyperlinkInvalid(ITextPointer textReader, ITextPointer rangeEnd) { // TextRead must be on the position before the element start position of Hyperlink Invariant.Assert(textReader.GetPointerContext(LogicalDirection.Forward) == TextPointerContext.ElementStart); Invariant.Assert(typeof(Hyperlink).IsAssignableFrom(textReader.GetElementType(LogicalDirection.Forward))); bool hyperlinkInvalid = false; // Get the forward adjacent element and cast Hyperlink hardly since it must be Hyperlink Hyperlink hyperlink = (Hyperlink)textReader.GetAdjacentElement(LogicalDirection.Forward); ITextPointer hyperlinkNavigation = textReader.CreatePointer(); ITextPointer hyperlinkEnd = textReader.CreatePointer(); hyperlinkEnd.MoveToNextContextPosition(LogicalDirection.Forward); // Find the hyperlink end position hyperlinkEnd.MoveToElementEdge(ElementEdge.AfterEnd); // Hyperlink end position is stated after the range end position. if (hyperlinkEnd.CompareTo(rangeEnd) > 0) { hyperlinkInvalid = true; } else { // Check whether the hyperlink having a UiElement except Image until hyperlink end position while (hyperlinkNavigation.CompareTo(hyperlinkEnd) < 0) { InlineUIContainer inlineUIContainer = hyperlinkNavigation.GetAdjacentElement(LogicalDirection.Forward) as InlineUIContainer; if (inlineUIContainer != null && !(inlineUIContainer.Child is Image)) { hyperlinkInvalid = true; break; } hyperlinkNavigation.MoveToNextContextPosition(LogicalDirection.Forward); } } return hyperlinkInvalid; }
// Part of plain text converter: called from GetTextInternal when processing ElementStart for List elements. // Initializes a stack of list item counters and pushes a new zero for the opened list level. private static void PlainConvertListStart(ITextPointer navigator, ref Stack<int> listItemCounter) { List list = (List)navigator.GetAdjacentElement(LogicalDirection.Forward); // Initialize list context if (listItemCounter == null) { listItemCounter = new Stack<int>(1); } listItemCounter.Push(0); }
/// <summary> /// Writes an opening tag of an element together with all attributes /// representing Avalon properties. /// </summary> /// <param name="range"> /// Parameter used for top-level Table element - to decide what columns to output. /// For all other elements it's ignored. /// </param> /// <param name="textReader"> /// TextPointer positioned in the scope of element whose /// start tag is going to be written. /// </param> /// <param name="xmlWriter"> /// XmlWriter to output element opening tag. /// </param> /// <param name="xamlTypeMapper"></param> /// <param name="reduceElement"> /// True value of this parameter indicates that /// serialization goes into XamlPackage, so all elements /// can be preserved as is; otherwise some of them must be /// reduced into simpler representations (such as InlineUIContainer -> Run /// and BlockUIContainer -> Paragraph). /// </param> /// <param name="preserveTextElements"> /// If TRUE, TextElements are serialized as-is. If FALSE, they're upcast /// to their base types. /// </param> private static void WriteStartXamlElement(ITextRange range, ITextPointer textReader, XmlWriter xmlWriter, XamlTypeMapper xamlTypeMapper, bool reduceElement, bool preserveTextElements) { Type elementType = textReader.ParentType; Type elementTypeStandardized = TextSchema.GetStandardElementType(elementType, reduceElement); // Get rid f UIContainers when their child is not an image if (elementTypeStandardized == typeof(InlineUIContainer) || elementTypeStandardized == typeof(BlockUIContainer)) { Invariant.Assert(!reduceElement); InlineUIContainer inlineUIContainer = textReader.GetAdjacentElement(LogicalDirection.Backward) as InlineUIContainer; BlockUIContainer blockUIContainer = textReader.GetAdjacentElement(LogicalDirection.Backward) as BlockUIContainer; if ((inlineUIContainer == null || !(inlineUIContainer.Child is Image)) && (blockUIContainer == null || !(blockUIContainer.Child is Image))) { // Even when we serialize for DataFormats.XamlPackage we strip out UIElement // different from Images. // Note that this condition is consistent with the one in WriteEmbeddedObject - // so that when we reduce the element type fromm UIContainer to Run/Paragraph // we also output just a space instead of the embedded object conntained in it. elementTypeStandardized = TextSchema.GetStandardElementType(elementType, /*reduceElement:*/true); } } else if (preserveTextElements) { elementTypeStandardized = elementType; } bool customTextElement = preserveTextElements && !TextSchema.IsKnownType(elementType); if (customTextElement) { // If the element is not from PresentationFramework, we'll need to serialize a namespace // int index = elementTypeStandardized.Module.Name.LastIndexOf('.'); string assembly = (index == -1 ? elementTypeStandardized.Module.Name : elementTypeStandardized.Module.Name.Substring(0, index)); string nameSpace = "clr-namespace:" + elementTypeStandardized.Namespace + ";" + "assembly=" + assembly; string prefix = elementTypeStandardized.Namespace; xmlWriter.WriteStartElement(prefix, elementTypeStandardized.Name, nameSpace); } else { xmlWriter.WriteStartElement(elementTypeStandardized.Name); } // Write properties DependencyObject complexProperties = new DependencyObject(); WriteInheritableProperties(elementTypeStandardized, textReader, xmlWriter, /*onlyAffected:*/true, complexProperties); WriteNoninheritableProperties(elementTypeStandardized, textReader, xmlWriter, /*onlyAffected:*/true, complexProperties); if (customTextElement) { WriteLocallySetProperties(elementTypeStandardized, textReader, xmlWriter, complexProperties); } WriteComplexProperties(xmlWriter, complexProperties, elementTypeStandardized); // Special case for Table element serialization if (elementTypeStandardized == typeof(Table) && textReader is TextPointer) { // Write the columns text. WriteTableColumnsInformation(range, (Table)((TextPointer)textReader).Parent, xmlWriter, xamlTypeMapper); } }
// Token: 0x06002D1F RID: 11551 RVA: 0x000CBAC0 File Offset: 0x000C9CC0 internal object BuildObjectTree() { FixedElement.ElementType type = this._type; IAddChild addChild; if (type != FixedElement.ElementType.Paragraph) { switch (type) { case FixedElement.ElementType.Table: addChild = new Table(); goto IL_C7; case FixedElement.ElementType.TableRowGroup: addChild = new TableRowGroup(); goto IL_C7; case FixedElement.ElementType.TableRow: addChild = new TableRow(); goto IL_C7; case FixedElement.ElementType.TableCell: addChild = new TableCell(); goto IL_C7; case FixedElement.ElementType.Hyperlink: { Hyperlink hyperlink = new Hyperlink(); hyperlink.NavigateUri = (base.GetValue(FixedElement.NavigateUriProperty) as Uri); hyperlink.RequestNavigate += this.ClickHyperlink; AutomationProperties.SetHelpText(hyperlink, (string)base.GetValue(FixedElement.HelpTextProperty)); AutomationProperties.SetName(hyperlink, (string)base.GetValue(FixedElement.NameProperty)); addChild = hyperlink; goto IL_C7; } } addChild = null; } else { addChild = new Paragraph(); } IL_C7: ITextPointer textPointer = ((ITextPointer)this._start).CreatePointer(); while (textPointer.CompareTo(this._end) < 0) { TextPointerContext pointerContext = textPointer.GetPointerContext(LogicalDirection.Forward); if (pointerContext == TextPointerContext.Text) { addChild.AddText(textPointer.GetTextInRun(LogicalDirection.Forward)); } else if (pointerContext == TextPointerContext.EmbeddedElement) { addChild.AddChild(textPointer.GetAdjacentElement(LogicalDirection.Forward)); } else if (pointerContext == TextPointerContext.ElementStart) { object adjacentElement = textPointer.GetAdjacentElement(LogicalDirection.Forward); if (adjacentElement != null) { addChild.AddChild(adjacentElement); textPointer.MoveToNextContextPosition(LogicalDirection.Forward); textPointer.MoveToElementEdge(ElementEdge.BeforeEnd); } } textPointer.MoveToNextContextPosition(LogicalDirection.Forward); } return(addChild); }