C# FrameworkElement.TransformToVisual方法代码示例

        public static bool IsItemVisible(this FrameworkElement container, FrameworkElement element)
        {
            var elementBounds = element.TransformToVisual(container).TransformBounds(new Rect(0, 0, element.ActualWidth, element.ActualHeight));
            var containerBounds = new Rect(0, 0, container.ActualWidth, container.ActualHeight);

            return (elementBounds.Top < containerBounds.Bottom && elementBounds.Bottom > containerBounds.Top);
        }

        private Point GetPosition(FrameworkElement sender)
        {
            GeneralTransform transform = sender.TransformToVisual(null);
            Point location = transform.TransformPoint(new Point());
            location.Y = location.Y + sender.ActualHeight;

            return location;
        }

 private Rect GetElementBounds(FrameworkElement element, FrameworkElement parent)
 {
     if (element == null || parent == null)
     {
         return Rect.Empty;
     }
     if (element.Visibility != Visibility.Visible)
     {
         return Rect.Empty;
     }
     return element.TransformToVisual(parent).TransformBounds(new Rect(0.0, 0.0, element.ActualWidth, element.ActualHeight));
 }

 /// <summary>
 /// Computes the delta between the centre of an element and its 
 /// container.
 /// </summary>
 /// <param name="element">The element to compare.</param>
 /// <param name="container">The element to compare against.</param>
 /// <returns>A point that represents the delta between the two centers.</returns>
 private static Point GetCenterToCenterDelta(FrameworkElement element, FrameworkElement container)
 {
     Point elementCenter = new Point(element.ActualWidth / 2, element.ActualHeight / 2);
     Point containerCenter = new Point(container.ActualWidth / 2, container.ActualHeight / 2);
     Point transformedElementCenter = element.TransformToVisual(container).TransformPoint(elementCenter);
     return new Point(containerCenter.X - transformedElementCenter.X, containerCenter.Y - transformedElementCenter.Y);
 }

 private Rect GetElementRect(FrameworkElement frameworkElement)
 {
     Windows.UI.Xaml.Media.GeneralTransform transform = frameworkElement.TransformToVisual(null);
     Point point = transform.TransformPoint(new Point());
     return new Rect(point, new Size(frameworkElement.ActualWidth, frameworkElement.ActualHeight));
 }

        internal void ScrollIntoView(FrameworkElement element)
        {
            var scrollHost = ScrollHost;
            if (scrollHost == null)
            {
                return;
            }
            GeneralTransform transform;
            try
            {
                transform = element.TransformToVisual(scrollHost);
            }
            catch (ArgumentException)
            {
                return;
            }
            var itemRect = new Rect(transform.TransformPoint(new Point()),
                transform.TransformPoint(new Point(element.ActualWidth, element.ActualHeight)));
            var verticalOffset = scrollHost.VerticalOffset;
            double verticalDelta = 0;
            var hostBottom = scrollHost.ViewportHeight;
            var itemBottom = itemRect.Bottom;
            if (hostBottom < itemBottom)
            {
                verticalDelta = itemBottom - hostBottom;
                verticalOffset += verticalDelta;
            }
            var itemTop = itemRect.Top;
            if (itemTop - verticalDelta < 0)
            {
                verticalOffset -= verticalDelta - itemTop;
            }

            var horizontalOffset = scrollHost.HorizontalOffset;
            double horizontalDelta = 0;
            var hostRight = scrollHost.ViewportWidth;
            var itemRight = itemRect.Right;
            if (hostRight < itemRight)
            {
                horizontalDelta = itemRight - hostRight;
                horizontalOffset += horizontalDelta;
            }
            var itemLeft = itemRect.Left;
            if (itemLeft - horizontalDelta < 0)
            {
                horizontalOffset -= horizontalDelta - itemLeft;
            }
            scrollHost.ChangeView(horizontalOffset, verticalOffset, null);
        }

        /// <summary>
        /// Start animations and re-parent to destination UI Elmenent to finish the operations
        /// </summary>
        /// <param name="destinationElement">Destination UIElement where Visual should show up after page has loaded</param>
        /// <param name="containerVisual">ContainerVisual that contains Visual which needs to show in UIElement</param>
        /// <param name="newContainerVisual">ContainerVisual after visual is parented to UIElement</param>
        public static void InitiateContinuity(FrameworkElement destinationElement, ContainerVisual containerVisual, out ContainerVisual newContainerVisual)
        {
            if (null == containerVisual || null == destinationElement)
            {
                newContainerVisual = null;
                return;
            }
            //Get the frame of Window
            Frame rootFrame = Window.Current.Content as Frame;
            Visual rootVisual = ElementCompositionPreview.GetElementVisual(rootFrame);
            Compositor compositor = rootVisual.Compositor;
            //Create Temporary Container. this will be added to final UIElement 
            ContainerVisual _TempContainer = compositor.CreateContainerVisual();
            // Get Sprite Visual from incoming container
            var spriteHeroImage = containerVisual.Children.FirstOrDefault();

            //Create animation scoped batch to track animation completion and to complete re-parenting
            CompositionScopedBatch scopeBatch = compositor.CreateScopedBatch(CompositionBatchTypes.Animation);

            //Get coordinates of UIElement in reference to root so that it can be used for animations final value
            var coordinate = destinationElement.TransformToVisual(rootFrame);
            var position = coordinate.TransformPoint(new Point(0, 0));
            
            //Create offset animation to make visual move on screen
            Vector3KeyFrameAnimation offsetAnimation = compositor.CreateVector3KeyFrameAnimation();
            offsetAnimation.InsertKeyFrame(1f, new System.Numerics.Vector3((float)position.X, (float)position.Y, 0));
            offsetAnimation.Duration = TimeSpan.FromMilliseconds(600);

            //Create size animation to change size of the visuals 
            Vector2KeyFrameAnimation sizeAnimation = compositor.CreateVector2KeyFrameAnimation();
            sizeAnimation.InsertKeyFrame(1f, new System.Numerics.Vector2((float)destinationElement.ActualWidth, (float)destinationElement.ActualHeight));
            sizeAnimation.Duration = TimeSpan.FromMilliseconds(600);

            //Start Animations 
            spriteHeroImage.StartAnimation("size", sizeAnimation);
            containerVisual.StartAnimation("offset", offsetAnimation);
            //Scoped batch completed event. 
            scopeBatch.Completed += (o, e) =>
            {
                //Re-parent SpriteVisual to temp container and add temp container to UIElement as animations are finished.
                spriteHeroImage.Offset = new System.Numerics.Vector3(0, 0, 0);
                containerVisual.Children.Remove(spriteHeroImage);
                _TempContainer.Children.InsertAtTop(spriteHeroImage);
                ElementCompositionPreview.SetElementChildVisual(destinationElement, _TempContainer);
                containerVisual = null;

            };
            newContainerVisual = _TempContainer;

            scopeBatch.End();
        }

 private Windows.Foundation.Rect GetElementRect(FrameworkElement element)
 {
     Windows.UI.Xaml.Media.GeneralTransform buttonTransform = element.TransformToVisual(null);
     Windows.Foundation.Point point = buttonTransform.TransformPoint(new Windows.Foundation.Point());
     return new Windows.Foundation.Rect(point, new Windows.Foundation.Size(element.ActualWidth, element.ActualHeight));
 }

 private Point GetPosition(FrameworkElement element)
 {
     return element.TransformToVisual(this.listBox).TransformPoint(new Point(0, 0));
 }

        private Point[] GetTransformedPoints(FrameworkElement element, bool isRTL, FrameworkElement relativeTo)
        {
            Point[] pointArray = new Point[4];
            if ((element != null) && (relativeTo != null))
            {
                GeneralTransform gt = relativeTo.TransformToVisual(_rootVisual);
                pointArray[0] = gt.TransformPoint(new Point(0.0, 0.0));
                pointArray[1] = gt.TransformPoint(new Point(element.ActualWidth, 0.0));
                pointArray[2] = gt.TransformPoint(new Point(0.0, element.ActualHeight));
                pointArray[3] = gt.TransformPoint(new Point(element.ActualWidth, element.ActualHeight));

                FrameworkElement _el = _rootVisual as FrameworkElement;
                bool flag = (_el != null) ? (_el.FlowDirection == FlowDirection.RightToLeft) : false;
                if (isRTL != flag)
                {
                    // TODO: Handle RTL - GetTransformedPoints
                    //for (int i = 0; i < pointArray.Length; i++)
                    //{
                    //    pointArray[i].X = _windowBounds.Width - pointArray[i].X;
                    //}
                }
            }
            return pointArray;
        }

        internal void ScrollIntoView(FrameworkElement element)
        {
            // Get the ScrollHost
            ScrollViewer scrollHost = ScrollHost;

            if (scrollHost == null)
            {
                return;
            }

            // Get the position of the element relative to the ScrollHost
            GeneralTransform transform = null;

            try
            {
                transform = element.TransformToVisual(scrollHost);
            }
            catch (ArgumentException)
            {
                // Ignore failures when not in the visual tree
                return;
            }

            Rect itemRect = new Rect(
                transform.TransformPoint(new Point()),
                transform.TransformPoint(new Point(element.ActualWidth, element.ActualHeight)));

            // Scroll vertically
            double verticalOffset = scrollHost.VerticalOffset;
            double verticalDelta = 0;
            double hostBottom = scrollHost.ViewportHeight;
            double itemBottom = itemRect.Bottom;

            if (hostBottom < itemBottom)
            {
                verticalDelta = itemBottom - hostBottom;
                verticalOffset += verticalDelta;
            }

            double itemTop = itemRect.Top;

            if (itemTop - verticalDelta < 0)
            {
                verticalOffset -= verticalDelta - itemTop;
            }

#pragma warning disable 4014
            scrollHost.ScrollToVerticalOffsetWithAnimationAsync(verticalOffset);
#pragma warning restore 4014

            // Scroll horizontally
            double horizontalOffset = scrollHost.HorizontalOffset;
            double horizontalDelta = 0;
            double hostRight = scrollHost.ViewportWidth;
            double itemRight = itemRect.Right;

            if (hostRight < itemRight)
            {
                horizontalDelta = itemRight - hostRight;
                horizontalOffset += horizontalDelta;
            }

            double itemLeft = itemRect.Left;

            if (itemLeft - horizontalDelta < 0)
            {
                horizontalOffset -= horizontalDelta - itemLeft;
            }

#pragma warning disable 4014
            scrollHost.ScrollToHorizontalOffsetWithAnimationAsync(horizontalOffset);
#pragma warning restore 4014
        }

 public static Rect GetElementRect(FrameworkElement element)
 {
     GeneralTransform buttonTransform = element.TransformToVisual(null);
     Windows.Foundation.Point point = buttonTransform.TransformPoint(new Windows.Foundation.Point());
     return new Rect(point, new Size(element.ActualWidth, element.ActualHeight));
 }

        //get the bounding rect of an element relative to 0,0
        private static Rect GetElementRect(FrameworkElement element)
        {
            //get the element point to open the window at the correct point
            GeneralTransform transform = element.TransformToVisual(null);
            Point point = transform.TransformPoint(new Point());

            return new Rect(point, new Size(element.ActualWidth, element.ActualHeight));
        }

 public static Rect GetElementRect(FrameworkElement element)
 {
     Windows.UI.Xaml.Media.GeneralTransform buttonTransform = element.TransformToVisual(null);
     Point point = buttonTransform.TransformPoint(new Point());
     return new Rect(point, new Size(element.ActualWidth, element.ActualHeight));
 }

 /// <summary>
 /// Determine whether an element is visible, assuming the container is visible.
 /// </summary>
 /// <param name="element"></param>
 /// <param name="container"></param>
 /// <returns></returns>
 private Boolean IsUserVisible(FrameworkElement element, FrameworkElement container)
 {
     if (element == null)
         return false;
     Rect elementBounds = element.TransformToVisual(container)
         .TransformBounds(new Rect(0.0, 0.0, element.ActualWidth, element.ActualHeight));
     Rect containerBounds = new Rect(0.0, 0.0, container.ActualWidth, container.ActualHeight);
     return (elementBounds.Top < containerBounds.Bottom && elementBounds.Bottom > containerBounds.Top)
         && (elementBounds.Left < containerBounds.Right && elementBounds.Right > containerBounds.Left);
 }