/// <summary> /// Get the bounds of an element relative to another element. /// </summary> /// <param name="element">The element.</param> /// <param name="otherElement"> /// The element relative to the other element. /// </param> /// <returns> /// The bounds of the element relative to another element, or null if /// the elements are not related. /// </returns> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="element"/> is null. /// </exception> /// <exception cref="T:System.ArgumentNullException"> /// <paramref name="otherElement"/> is null. /// </exception> public static Rect?GetBoundsRelativeTo(this FrameworkElement element, UIElement otherElement) { if (element == null) { throw new ArgumentNullException("element"); } else if (otherElement == null) { throw new ArgumentNullException("otherElement"); } try { Point origin, bottom; GeneralTransform transform = element.TransformToVisual(otherElement); if (transform != null && transform.TryTransform(new Point(), out origin) && transform.TryTransform(new Point(element.ActualWidth, element.ActualHeight), out bottom)) { return(new Rect(origin, bottom)); } } catch (ArgumentException) { // Ignore any exceptions thrown while trying to transform } return(null); }
/// <summary> /// Private helper that takes an element and transforms it's 4 points /// into the InkCanvas's space /// </summary> private static ElementCornerPoints GetTransformedElementCornerPoints(InkCanvasInnerCanvas canvas, UIElement childElement) { Debug.Assert(canvas != null); Debug.Assert(childElement != null); Debug.Assert(canvas.CheckAccess()); ElementCornerPoints elementPoints = new ElementCornerPoints(); elementPoints.Set = false; if (childElement.Visibility != Visibility.Visible) { // // this little one's not worth it... // return(elementPoints); } // // get the transform from us to our parent InkCavas // GeneralTransform parentTransform = childElement.TransformToAncestor(canvas); // parentTransform.TryTransform(new Point(0, 0), out elementPoints.UpperLeft); parentTransform.TryTransform(new Point(childElement.RenderSize.Width, 0), out elementPoints.UpperRight); parentTransform.TryTransform(new Point(0, childElement.RenderSize.Height), out elementPoints.LowerLeft); parentTransform.TryTransform(new Point(childElement.RenderSize.Width, childElement.RenderSize.Height), out elementPoints.LowerRight); elementPoints.Set = true; return(elementPoints); }
/// <summary> /// Private helper that takes an element and transforms it's 4 points /// into the InkCanvas's space /// </summary> private static ElementCornerPoints GetTransformedElementCornerPoints(InkCanvasInnerCanvas canvas, UIElement childElement) { Debug.Assert(canvas != null); Debug.Assert(childElement != null); Debug.Assert(canvas.CheckAccess()); ElementCornerPoints elementPoints = new ElementCornerPoints(); elementPoints.Set = false; if (childElement.Visibility != Visibility.Visible) { // // this little one's not worth it... // return(elementPoints); } // // get the transform from us to our parent InkCavas // GeneralTransform parentTransform = childElement.TransformToAncestor(canvas); // REVIEW: any of the methods below may not actually perform the transformation // Do we need to do anything special in that scenario? parentTransform.TryTransform(new Point(0, 0), out elementPoints.UpperLeft); parentTransform.TryTransform(new Point(childElement.RenderSize.Width, 0), out elementPoints.UpperRight); parentTransform.TryTransform(new Point(0, childElement.RenderSize.Height), out elementPoints.LowerLeft); parentTransform.TryTransform(new Point(childElement.RenderSize.Width, childElement.RenderSize.Height), out elementPoints.LowerRight); elementPoints.Set = true; return(elementPoints); }
// Token: 0x0600384A RID: 14410 RVA: 0x000FB61C File Offset: 0x000F981C private static void ClipToElement(FrameworkElement element, GeneralTransform transform, ref double horizontalOffset, ref double verticalOffset) { Geometry clip = VisualTreeHelper.GetClip(element); Point inPoint; Point inPoint2; if (clip != null) { Rect bounds = clip.Bounds; inPoint = new Point(bounds.X, bounds.Y); inPoint2 = new Point(bounds.X + bounds.Width, bounds.Y + bounds.Height); } else { if (element.ActualWidth == 0.0 && element.ActualHeight == 0.0) { return; } inPoint = new Point(0.0, 0.0); inPoint2 = new Point(element.ActualWidth, element.ActualHeight); } transform.TryTransform(inPoint, out inPoint); transform.TryTransform(inPoint2, out inPoint2); horizontalOffset = TextEditorContextMenu.ClipToBounds(inPoint.X, horizontalOffset, inPoint2.X); verticalOffset = TextEditorContextMenu.ClipToBounds(inPoint.Y, verticalOffset, inPoint2.Y); }
private static void GetClippedPositionOffsets(TextEditor This, ITextPointer position, LogicalDirection direction, out double horizontalOffset, out double verticalOffset) { Rect characterRect = position.GetCharacterRect(direction); horizontalOffset = characterRect.X; verticalOffset = characterRect.Y + characterRect.Height; FrameworkElement frameworkElement = This.TextView.RenderScope as FrameworkElement; if (frameworkElement != null) { GeneralTransform generalTransform = frameworkElement.TransformToAncestor(This.UiScope); if (generalTransform != null) { TextEditorContextMenu.ClipToElement(frameworkElement, generalTransform, ref horizontalOffset, ref verticalOffset); } } for (Visual visual = This.UiScope; visual != null; visual = (VisualTreeHelper.GetParent(visual) as Visual)) { frameworkElement = (visual as FrameworkElement); if (frameworkElement != null) { GeneralTransform generalTransform2 = visual.TransformToDescendant(This.UiScope); if (generalTransform2 != null) { TextEditorContextMenu.ClipToElement(frameworkElement, generalTransform2, ref horizontalOffset, ref verticalOffset); } } } PresentationSource presentationSource = PresentationSource.CriticalFromVisual(This.UiScope); IWin32Window win32Window = presentationSource as IWin32Window; if (win32Window != null) { IntPtr handle = IntPtr.Zero; new UIPermission(UIPermissionWindow.AllWindows).Assert(); try { handle = win32Window.Handle; } finally { CodeAccessPermission.RevertAssert(); } NativeMethods.RECT rect = new NativeMethods.RECT(0, 0, 0, 0); SafeNativeMethods.GetClientRect(new HandleRef(null, handle), ref rect); Point point = new Point((double)rect.left, (double)rect.top); Point point2 = new Point((double)rect.right, (double)rect.bottom); CompositionTarget compositionTarget = presentationSource.CompositionTarget; point = compositionTarget.TransformFromDevice.Transform(point); point2 = compositionTarget.TransformFromDevice.Transform(point2); GeneralTransform generalTransform3 = compositionTarget.RootVisual.TransformToDescendant(This.UiScope); if (generalTransform3 != null) { generalTransform3.TryTransform(point, out point); generalTransform3.TryTransform(point2, out point2); horizontalOffset = TextEditorContextMenu.ClipToBounds(point.X, horizontalOffset, point2.X); verticalOffset = TextEditorContextMenu.ClipToBounds(point.Y, verticalOffset, point2.Y); } } }
// Calculates ribbonTab.TabHeaderLeft and ribbonTab.TabHeaderRight. private void RecalculateTabHeaderLeftAndRightCallback() { Ribbon ribbon = Ribbon; RibbonTab ribbonTab = RibbonTab; if (ribbon != null && ribbonTab != null && ribbon.IsAncestorOf(ribbonTab)) { Thickness margin = _outerBorder != null ? _outerBorder.Margin : new Thickness(); Thickness borderThickness = _outerBorder != null ? _outerBorder.BorderThickness : new Thickness(); Point leftBottom = new Point(margin.Left + borderThickness.Left, ActualHeight); Point rightBottom = new Point(ActualWidth - margin.Right - borderThickness.Right, ActualHeight); GeneralTransform transformToRibbon = this.TransformToAncestor(ribbon); transformToRibbon.TryTransform(leftBottom, out leftBottom); transformToRibbon.TryTransform(rightBottom, out rightBottom); GeneralTransform transformToRibbonTab = ribbon.TransformToDescendant(ribbonTab); transformToRibbonTab.TryTransform(leftBottom, out leftBottom); transformToRibbonTab.TryTransform(rightBottom, out rightBottom); ribbonTab.TabHeaderLeft = leftBottom.X; ribbonTab.TabHeaderRight = rightBottom.X; } }
// Clips a Point to the ActualWidth/Height of a containing FrameworkElement. private static void ClipToElement(FrameworkElement element, GeneralTransform transform, ref double horizontalOffset, ref double verticalOffset) { Point minPoint; Point maxPoint; Geometry clip = VisualTreeHelper.GetClip(element); if (clip != null) { Rect bounds = clip.Bounds; minPoint = new Point(bounds.X, bounds.Y); maxPoint = new Point(bounds.X + bounds.Width, bounds.Y + bounds.Height); } else { if (element.ActualWidth == 0 && element.ActualHeight == 0) { // Some elements, noteably Canvas, have a (0, 0) desired size // and should be ignored. return; } minPoint = new Point(0, 0); maxPoint = new Point(element.ActualWidth, element.ActualHeight); } transform.TryTransform(minPoint, out minPoint); transform.TryTransform(maxPoint, out maxPoint); // NB: ClipToBounds will handle the case where transform flips a coordinate // axis. In that case, minPoint.X will be > maxPoint.X. horizontalOffset = ClipToBounds(minPoint.X, horizontalOffset, maxPoint.X); verticalOffset = ClipToBounds(minPoint.Y, verticalOffset, maxPoint.Y); }
public static Rect?GetBoundsRelativeTo(this FrameworkElement element, UIElement otherElement) { if (element == null) { throw new ArgumentNullException("element"); } if (otherElement == null) { throw new ArgumentNullException("otherElement"); } try { GeneralTransform generalTransform = element.TransformToVisual((Visual)otherElement); if (generalTransform != null) { Point result1; if (generalTransform.TryTransform(new Point(), out result1)) { Point result2; if (generalTransform.TryTransform(new Point(element.ActualWidth, element.ActualHeight), out result2)) { return(new Rect?(new Rect(result1, result2))); } } } } catch (ArgumentException ex) { } return(new Rect?()); }
// Token: 0x06006502 RID: 25858 RVA: 0x001C5614 File Offset: 0x001C3814 internal static void DumpDocumentPage(XmlTextWriter writer, DocumentPage page, Visual parent) { writer.WriteStartElement("DocumentPage"); writer.WriteAttributeString("Type", page.GetType().FullName); if (page != DocumentPage.Missing) { LayoutDump.DumpSize(writer, "Size", page.Size); GeneralTransform generalTransform = page.Visual.TransformToAncestor(parent); Point point = new Point(0.0, 0.0); generalTransform.TryTransform(point, out point); if (point.X != 0.0 || point.Y != 0.0) { LayoutDump.DumpPoint(writer, "Position", point); } Type type = page.GetType(); LayoutDump.DumpCustomDocumentPage dumpCustomDocumentPage = null; while (dumpCustomDocumentPage == null && type != null) { dumpCustomDocumentPage = (LayoutDump._documentPageToDumpHandler[type] as LayoutDump.DumpCustomDocumentPage); type = type.BaseType; } if (dumpCustomDocumentPage != null) { dumpCustomDocumentPage(writer, page); } } writer.WriteEndElement(); }
/// <summary> /// Returns a geometry for the insertion indicator. /// </summary> /// <param name="dropTarget">The drop target.</param> /// <param name="insertionIndex">The insertion index within the drop /// target.</param> /// <param name="dragEventArgs">Information about the drag event. /// </param> /// <returns>The geometry for the insertion indicator.</returns> protected override Geometry GetInsertionIndicatorGeometry(ItemsControl dropTarget, int insertionIndex, SW.DragEventArgs dragEventArgs) { ItemsControl itemsControlAncestor = GetItemsControlAncestor((DependencyObject)dragEventArgs.OriginalSource); TreeViewItem treeViewItem = dropTarget as TreeViewItem; // If the parent items control is the drop target then we're // appending the item into the child collection of the currently // hovered tree view item. if (treeViewItem != null && itemsControlAncestor != dropTarget) { GeneralTransform generalTransform = dropTarget.SafeTransformToVisual(this); if (generalTransform != null) { Rect dropTargetRect = GetTreeViewItemRectExcludingChildren(treeViewItem); Point origin; if (generalTransform.TryTransform(new Point(0, 0), out origin)) { Point dropTargetPositionRelativeToDragDropTarget = origin; dropTargetPositionRelativeToDragDropTarget.X += dropTargetRect.Left; dropTargetPositionRelativeToDragDropTarget.Y += dropTargetRect.Top; return(new RectangleGeometry { Rect = new Rect(dropTargetPositionRelativeToDragDropTarget, new Size(dropTargetRect.Width, dropTargetRect.Height)) }); } } } return(base.GetInsertionIndicatorGeometry(dropTarget, insertionIndex, dragEventArgs)); }
// Token: 0x060085BD RID: 34237 RVA: 0x0024AA08 File Offset: 0x00248C08 private ITextPointer GetDropPosition(Visual target, Point point) { Invariant.Assert(target != null); Invariant.Assert(this._textEditor.TextView.IsValid); if (target != this._textEditor.TextView.RenderScope && target != null && this._textEditor.TextView.RenderScope.IsAncestorOf(target)) { GeneralTransform generalTransform = target.TransformToAncestor(this._textEditor.TextView.RenderScope); generalTransform.TryTransform(point, out point); } ITextPointer textPointer = this.TextView.GetTextPositionFromPoint(point, true); if (textPointer != null) { textPointer = textPointer.GetInsertionPosition(textPointer.LogicalDirection); if (this._textEditor.AcceptsRichContent) { TextSegment normalizedLineRange = TextEditorSelection.GetNormalizedLineRange(this.TextView, textPointer); if (!normalizedLineRange.IsNull && textPointer.CompareTo(normalizedLineRange.End) < 0 && !TextPointerBase.IsAtWordBoundary(textPointer, LogicalDirection.Forward) && this._dragSourceTextRange != null && TextPointerBase.IsAtWordBoundary(this._dragSourceTextRange.Start, LogicalDirection.Forward) && TextPointerBase.IsAtWordBoundary(this._dragSourceTextRange.End, LogicalDirection.Forward)) { TextSegment wordRange = TextPointerBase.GetWordRange(textPointer); string textInternal = TextRangeBase.GetTextInternal(wordRange.Start, wordRange.End); int offsetToPosition = wordRange.Start.GetOffsetToPosition(textPointer); textPointer = ((offsetToPosition < textInternal.Length / 2) ? wordRange.Start : wordRange.End); } } } return(textPointer); }
// Token: 0x06006500 RID: 25856 RVA: 0x001C5414 File Offset: 0x001C3614 internal static void DumpVisual(XmlTextWriter writer, Visual visual, Visual parent) { if (visual is UIElement) { LayoutDump.DumpUIElement(writer, (UIElement)visual, parent, false); return; } writer.WriteStartElement(visual.GetType().Name); Rect visualContentBounds = visual.VisualContentBounds; if (!visualContentBounds.IsEmpty) { LayoutDump.DumpRect(writer, "ContentRect", visualContentBounds); } Geometry clip = VisualTreeHelper.GetClip(visual); if (clip != null) { LayoutDump.DumpRect(writer, "Clip.Bounds", clip.Bounds); } GeneralTransform generalTransform = visual.TransformToAncestor(parent); Point point = new Point(0.0, 0.0); generalTransform.TryTransform(point, out point); if (point.X != 0.0 || point.Y != 0.0) { LayoutDump.DumpPoint(writer, "Position", point); } LayoutDump.DumpVisualChildren(writer, "Children", visual); writer.WriteEndElement(); }
// Token: 0x0600650D RID: 25869 RVA: 0x001C5B40 File Offset: 0x001C3D40 private static bool DumpFlowDocumentView(XmlTextWriter writer, UIElement element, bool uiElementsOnly) { FlowDocumentView flowDocumentView = element as FlowDocumentView; IScrollInfo scrollInfo = flowDocumentView; if (scrollInfo.ScrollOwner != null) { Size size = new Size(scrollInfo.ExtentWidth, scrollInfo.ExtentHeight); if (DoubleUtil.AreClose(size, element.DesiredSize)) { LayoutDump.DumpSize(writer, "Extent", size); } Point point = new Point(scrollInfo.HorizontalOffset, scrollInfo.VerticalOffset); if (!DoubleUtil.IsZero(point.X) || !DoubleUtil.IsZero(point.Y)) { LayoutDump.DumpPoint(writer, "Offset", point); } } FlowDocumentPage documentPage = flowDocumentView.Document.BottomlessFormatter.DocumentPage; GeneralTransform generalTransform = documentPage.Visual.TransformToAncestor(flowDocumentView); Point point2 = new Point(0.0, 0.0); generalTransform.TryTransform(point2, out point2); if (!DoubleUtil.IsZero(point2.X) && !DoubleUtil.IsZero(point2.Y)) { LayoutDump.DumpPoint(writer, "PagePosition", point2); } LayoutDump.DumpFlowDocumentPage(writer, documentPage); return(false); }
public void SimulateMouseLeftDoubleClick(UIElement element, Point pt) { GeneralTransform transform = GetTransformToRootElement(element); transform.TryTransform(pt, out pt); _mouse.SimulateLeftDoubleClick(this.MainWindow, pt); }
/// <summary> /// Calculates the new Value of this control using a location and relative source. /// The location is translated to the control, and then used to set the value. /// </summary> /// <param name="location">A point.</param> /// <param name="locationRelativeSource">The UIElement that the point originated from.</param> private void PerformValueCalculation(Point location, UIElement locationRelativeSource) { GeneralTransform gt = locationRelativeSource.TransformToVisual(this); gt.TryTransform(location, out location); double numberOfPositions = _filledItemCollection.Count; if (AllowHalfItemIncrement) { numberOfPositions *= 2; } double newValue; if (Orientation == Orientation.Horizontal) { newValue = Math.Ceiling(location.X / ActualWidth * numberOfPositions); } else { newValue = Math.Ceiling(location.Y / ActualHeight * numberOfPositions); } if (!AllowSelectingZero && newValue <= 0) { newValue = 1; } Value = newValue; }
// ------------------------------------------------------------------ // Dump paragraph offset. // ------------------------------------------------------------------ private static Visual DumpParagraphOffset(XmlTextWriter writer, ParagraphResult paragraph, Visual visualParent) { Type paragraphResultType = paragraph.GetType(); System.Reflection.FieldInfo field = paragraphResultType.GetField("_paraClient", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic); object paraClient = field.GetValue(paragraph); Type paraClientType = paraClient.GetType(); System.Reflection.PropertyInfo prop = paraClientType.GetProperty("Visual", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic); Visual visual = (Visual)prop.GetValue(paraClient, null); // Dump transform relative to its parent if (visualParent.IsAncestorOf(visual)) { GeneralTransform g = visual.TransformToAncestor(visualParent); Point point = new Point(0.0f, 0.0f); g.TryTransform(point, out point); if (point.X != 0 || point.Y != 0) { DumpPoint(writer, "Origin", point); } } return(visual); }
// ------------------------------------------------------------------ // Dump content of DocumentPage. // ------------------------------------------------------------------ internal static void DumpDocumentPage(XmlTextWriter writer, DocumentPage page, Visual parent) { writer.WriteStartElement("DocumentPage"); writer.WriteAttributeString("Type", page.GetType().FullName); if (page != DocumentPage.Missing) { DumpSize(writer, "Size", page.Size); // Dump transform relative to its parent GeneralTransform g = page.Visual.TransformToAncestor(parent); Point point = new Point(0, 0); g.TryTransform(point, out point); if (point.X != 0 || point.Y != 0) { DumpPoint(writer, "Position", point); } // Dump page specific information Type t = page.GetType(); DumpCustomDocumentPage dumpDocumentPage = null; while (dumpDocumentPage == null && t != null) { dumpDocumentPage = _documentPageToDumpHandler[t] as DumpCustomDocumentPage; t = t.BaseType; } if (dumpDocumentPage != null) { dumpDocumentPage(writer, page); } } writer.WriteEndElement(); }
private Rect GetBounds(StylusPoint stylusPoint, Point position, IInputElement relativeTo, GeneralTransform elementToRoot, GeneralTransform rootToElement) { // Get width and heith in pixel value double width = GetStylusPointWidthOrHeight(stylusPoint, /*isWidth*/ true); double height = GetStylusPointWidthOrHeight(stylusPoint, /*isWidth*/ false); // Get the position with respect to root Point rootPoint; if (elementToRoot == null || !elementToRoot.TryTransform(position, out rootPoint)) { rootPoint = position; } // Create a Rect with respect to root and transform it to element coordinate space Rect rectBounds = new Rect(rootPoint.X - width * 0.5, rootPoint.Y - height * 0.5, width, height); if (rootToElement != null) { rectBounds = rootToElement.TransformBounds(rectBounds); } return(rectBounds); }
public override bool TryTransform(Point inPoint, out Point result) { bool ok = false; result = new Point(); // Both the normal and the inverse require the point to first be // translated from world space to unit space. Point?unitSpace = Effect.WorldToUnit(inPoint, _worldBounds); if (unitSpace != null) { // Now just run through the normal or the inverse version of the // inner effect. GeneralTransform innerToUse = GetCorrectInnerTransform(); Point unitResult; if (innerToUse.TryTransform(unitSpace.Value, out unitResult)) { // Both the normal and the inverse require the unit-space result // to be converted back to world space Point?worldSpace = Effect.UnitToWorld(unitResult, _worldBounds); if (worldSpace != null) { result = worldSpace.Value; ok = true; } } } return(ok); }
/// <summary> /// Retrieves the location and dimensions of a TreeViewItem excluding /// its children. /// </summary> /// <param name="treeViewItem">The tree view item.</param> /// <returns>The location and dimensions of the TreeViewItem excluding /// its children.</returns> protected virtual Rect GetTreeViewItemRectExcludingChildren(TreeViewItem treeViewItem) { if (treeViewItem.IsExpanded) { FrameworkElement rootVisual = treeViewItem.GetVisualChildren().FirstOrDefault() as FrameworkElement; if (rootVisual != null) { FrameworkElement header = rootVisual .GetLogicalDescendents() .Where(element => element.Name == "Header").FirstOrDefault(); if (header != null) { Rect rectangle = new Rect(0, 0, 0, 0); GeneralTransform generalTransform = header.SafeTransformToVisual(treeViewItem); Point origin; if (generalTransform != null && generalTransform.TryTransform(new Point(0, 0), out origin)) { rectangle = new Rect(origin, header.GetSize()); } return(rectangle); } } } return(new Rect(new Point(), treeViewItem.GetSize())); }
public static Point LocationOnScreen(Visual visual) { Application currApp = Application.Current; Window appWindow = currApp != null ? currApp.MainWindow : null; if (appWindow == null || !appWindow.IsAncestorOf(visual)) { appWindow = FindParentWindow(visual); } Point relativeToWindow = new Point(0, 0); GeneralTransform targetToWindowTransform = visual.TransformToVisual(appWindow); if (!targetToWindowTransform.TryTransform(new Point(0, 0), out relativeToWindow)) { throw new Exception("Failed to transform point."); } // // Add 4 to X and 24 to Y because _window.Left/Top return Content position, so we // adjust for the window chrome. // // Adding DPI scaling. Will multiply actual points and the buffer noted above // by the current DPI/96.. relativeToWindow = new Point(Monitor.ConvertLogicalToScreen(Dimension.Width, relativeToWindow.X), Monitor.ConvertLogicalToScreen(Dimension.Height, relativeToWindow.Y)); Point relativeToScreen = new Point(relativeToWindow.X + appWindow.Left + Monitor.ConvertLogicalToScreen(Dimension.Width, 4.0), relativeToWindow.Y + appWindow.Top + Monitor.ConvertLogicalToScreen(Dimension.Height, 24.0)); return(relativeToScreen); }
/// <summary> /// Private clone implementation /// </summary> private StylusPointCollection Clone(GeneralTransform transform, StylusPointDescription descriptionToUse, int count) { Debug.Assert(count <= this.Count); // // We don't need to copy our _stylusPointDescription because it is immutable // and we don't need to copy our StylusPoints, because they are structs. // StylusPointCollection newCollection = new StylusPointCollection(descriptionToUse, count); bool isIdentity = (transform is Transform) ? ((Transform)transform).IsIdentity : false; for (int x = 0; x < count; x++) { if (isIdentity) { ((List <StylusPoint>)newCollection.Items).Add(this[x]); } else { Point point = new Point(); StylusPoint stylusPoint = this[x]; point.X = stylusPoint.X; point.Y = stylusPoint.Y; transform.TryTransform(point, out point); stylusPoint.X = point.X; stylusPoint.Y = point.Y; ((List <StylusPoint>)newCollection.Items).Add(stylusPoint); } } return(newCollection); }
/// <summary> /// Internal ctor called by input with a raw int[] /// </summary> /// <param name="stylusPointDescription">stylusPointDescription</param> /// <param name="rawPacketData">rawPacketData</param> /// <param name="tabletToView">tabletToView</param> /// <param name="tabletToViewMatrix">tabletToView</param> internal StylusPointCollection(StylusPointDescription stylusPointDescription, int[] rawPacketData, GeneralTransform tabletToView, Matrix tabletToViewMatrix) { if (null == stylusPointDescription) { throw new ArgumentNullException("stylusPointDescription"); } _stylusPointDescription = stylusPointDescription; int lengthPerPoint = stylusPointDescription.GetInputArrayLengthPerPoint(); int logicalPointCount = rawPacketData.Length / lengthPerPoint; Debug.Assert(0 == rawPacketData.Length % lengthPerPoint, "Invalid assumption about packet length, there shouldn't be any remainder"); // // set our capacity and validate // ((List <StylusPoint>) this.Items).Capacity = logicalPointCount; for (int count = 0, i = 0; count < logicalPointCount; count++, i += lengthPerPoint) { //first, determine the x, y values by xf-ing them Point p = new Point(rawPacketData[i], rawPacketData[i + 1]); if (tabletToView != null) { tabletToView.TryTransform(p, out p); } else { p = tabletToViewMatrix.Transform(p); } int startIndex = 2; bool containsTruePressure = stylusPointDescription.ContainsTruePressure; if (containsTruePressure) { //don't copy pressure in the int[] for extra data startIndex++; } int[] data = null; int dataLength = lengthPerPoint - startIndex; if (dataLength > 0) { //copy the rest of the data var rawArrayStartIndex = i + startIndex; data = rawPacketData.AsSpan(rawArrayStartIndex, dataLength).ToArray(); } StylusPoint newPoint = new StylusPoint(p.X, p.Y, StylusPoint.DefaultPressure, _stylusPointDescription, data, false, false); if (containsTruePressure) { //use the algorithm to set pressure in StylusPoint int pressure = rawPacketData[i + 2]; newPoint.SetPropertyValue(StylusPointProperties.NormalPressure, pressure); } //this does not go through our protected virtuals ((List <StylusPoint>) this.Items).Add(newPoint); } }
// Token: 0x06006DBE RID: 28094 RVA: 0x001F8850 File Offset: 0x001F6A50 private static LassoSelectionBehavior.ElementCornerPoints GetTransformedElementCornerPoints(InkCanvasInnerCanvas canvas, UIElement childElement) { LassoSelectionBehavior.ElementCornerPoints result = default(LassoSelectionBehavior.ElementCornerPoints); result.Set = false; if (childElement.Visibility != Visibility.Visible) { return(result); } GeneralTransform generalTransform = childElement.TransformToAncestor(canvas); generalTransform.TryTransform(new Point(0.0, 0.0), out result.UpperLeft); generalTransform.TryTransform(new Point(childElement.RenderSize.Width, 0.0), out result.UpperRight); generalTransform.TryTransform(new Point(0.0, childElement.RenderSize.Height), out result.LowerLeft); generalTransform.TryTransform(new Point(childElement.RenderSize.Width, childElement.RenderSize.Height), out result.LowerRight); result.Set = true; return(result); }
// Token: 0x06002EF5 RID: 12021 RVA: 0x000D4514 File Offset: 0x000D2714 private Rect _GetTransformedCaretRect(GeneralTransform transform, Point origin, double height) { Point point = origin; point.Y += height; transform.TryTransform(origin, out origin); transform.TryTransform(point, out point); Rect result = new Rect(origin, point); if (result.Width > 0.0) { result.X += result.Width / 2.0; result.Width = 0.0; } if (result.Height < 1.0) { result.Height = 1.0; } return(result); }
private Point TransformPointToToolBar(ToolBar toolBar, Point point) { Point p = point; GeneralTransform transform = this.TransformToDescendant(toolBar); if (transform != null) { transform.TryTransform(point, out p); } return(p); }
// Token: 0x0600585A RID: 22618 RVA: 0x00187904 File Offset: 0x00185B04 private Point TransformPointToToolBar(ToolBar toolBar, Point point) { Point result = point; GeneralTransform generalTransform = base.TransformToDescendant(toolBar); if (generalTransform != null) { generalTransform.TryTransform(point, out result); } return(result); }
// ------------------------------------------------------------------ // Dump content of UIElement. // ------------------------------------------------------------------ private static void DumpUIElement(XmlTextWriter writer, UIElement element, Visual parent, bool uiElementsOnly) { writer.WriteStartElement(element.GetType().Name); // Dump layout information DumpSize(writer, "DesiredSize", element.DesiredSize); DumpSize(writer, "ComputedSize", element.RenderSize); Geometry clip = VisualTreeHelper.GetClip(element); if (clip != null) { DumpRect(writer, "Clip.Bounds", clip.Bounds); } // Dump transform relative to its parent GeneralTransform g = element.TransformToAncestor(parent); Point point = new Point(0, 0); g.TryTransform(point, out point); if (point.X != 0 || point.Y != 0) { DumpPoint(writer, "Position", point); } // Dump element specific information bool childrenHandled = false; Type t = element.GetType(); DumpCustomUIElement dumpElement = null; while (dumpElement == null && t != null) { dumpElement = _elementToDumpHandler[t] as DumpCustomUIElement; t = t.BaseType; } if (dumpElement != null) { childrenHandled = dumpElement(writer, element, uiElementsOnly); } if (!childrenHandled) { if (uiElementsOnly) { DumpUIElementChildren(writer, "Children", element); } else { DumpVisualChildren(writer, "Children", element); } } writer.WriteEndElement(); }
internal HitTestResultBehavior RaiseCallback(HitTestResultCallback resultCallback, HitTestFilterCallback filterCallback, HitTestResultBehavior lastResult, double distanceAdjustment) { results.Sort(RayHitTestResult.CompareByDistanceToRayOrigin); for (int i = 0, count = results.Count; i < count; i++) { RayHitTestResult result = results[i]; result.SetDistanceToRayOrigin(result.DistanceToRayOrigin + distanceAdjustment); Viewport2DVisual3D viewport2DVisual3D = result.VisualHit as Viewport2DVisual3D; if (viewport2DVisual3D != null) { Point intersectionPoint; Visual viewport2DVisual3DChild = viewport2DVisual3D.Visual; if (viewport2DVisual3DChild != null) { if (Viewport2DVisual3D.GetIntersectionInfo(result, out intersectionPoint)) { // convert the resulting point to visual coordinates Point visualPoint = Viewport2DVisual3D.TextureCoordsToVisualCoords(intersectionPoint, viewport2DVisual3DChild); GeneralTransform gt = viewport2DVisual3DChild.TransformToOuterSpace().Inverse; Point pointOnChild; if (gt != null && gt.TryTransform(visualPoint, out pointOnChild)) { HitTestResultBehavior behavior2D = viewport2DVisual3DChild.HitTestPoint(filterCallback, resultCallback, new PointHitTestParameters(pointOnChild)); if (behavior2D == HitTestResultBehavior.Stop) { return(HitTestResultBehavior.Stop); } } } } } HitTestResultBehavior behavior = resultCallback(results[i]); if (behavior == HitTestResultBehavior.Stop) { return(HitTestResultBehavior.Stop); } } return(lastResult); }
// Token: 0x06002EF1 RID: 12017 RVA: 0x000D3FAC File Offset: 0x000D21AC private ITextPointer _SnapToText(Point point) { FixedNode[] line = this.Container.FixedTextBuilder.GetLine(this.PageIndex, point); ITextPointer textPointer; if (line != null && line.Length != 0) { double num = double.MaxValue; double xoffset = 0.0; Glyphs glyphs = null; FixedNode fixedNode = line[0]; foreach (FixedNode fixedNode2 in line) { Glyphs glyphsElement = this.FixedPage.GetGlyphsElement(fixedNode2); GeneralTransform generalTransform = this.FixedPage.TransformToDescendant(glyphsElement); Point inPoint = point; if (generalTransform != null) { generalTransform.TryTransform(inPoint, out inPoint); } GlyphRun glyphRun = glyphsElement.ToGlyphRun(); Rect rect = glyphRun.ComputeAlignmentBox(); rect.Offset(glyphsElement.OriginX, glyphsElement.OriginY); double num2 = Math.Max(0.0, (inPoint.X > rect.X) ? (inPoint.X - rect.Right) : (rect.X - inPoint.X)); double num3 = Math.Max(0.0, (inPoint.Y > rect.Y) ? (inPoint.Y - rect.Bottom) : (rect.Y - inPoint.Y)); double num4 = num2 + num3; if (glyphs == null || num4 < num) { num = num4; glyphs = glyphsElement; fixedNode = fixedNode2; xoffset = inPoint.X; } } int offset; LogicalDirection edge; this._GlyphRunHitTest(glyphs, xoffset, out offset, out edge); FixedPosition fixedPosition = new FixedPosition(fixedNode, offset); textPointer = this._CreateTextPointer(fixedPosition, edge); } else if (point.Y < this.FixedPage.Height / 2.0) { textPointer = ((ITextPointer)this.Start).CreatePointer(LogicalDirection.Forward); textPointer.MoveToInsertionPosition(LogicalDirection.Forward); } else { textPointer = ((ITextPointer)this.End).CreatePointer(LogicalDirection.Backward); textPointer.MoveToInsertionPosition(LogicalDirection.Backward); } return(textPointer); }