C# FrameworkElement.TransformToAncestor方法代码示例

        public static Point ComputeIntersectionPoint(FrameworkElement thisV, FrameworkElement toV)
        {
            PathGeometry fromGeometryFlat;
            //using the cached geometry or building one up
            fromGeometryFlat = BuildVertexGeometry(thisV);
            if (toV != null)
            {
                //transforming the argument vertex's center to the coordinate space of this vertex
                Panel panel = (Panel)VisualTreeHelper.GetParent(thisV);
                Transform transformToPanel = (Transform)toV.TransformToAncestor(panel);
                Transform transformToFromV = (Transform)panel.TransformToDescendant(thisV);
                Point transformedToVCenter = new Point(toV.RenderSize.Width / 2, toV.RenderSize.Height / 2);
                if (transformToPanel != null)
                    transformedToVCenter = transformToPanel.Transform(transformedToVCenter);
                if (transformToFromV != null)
                    transformedToVCenter = transformToFromV.Transform(transformedToVCenter);

                Point thisCenter = new Point(thisV.RenderSize.Width / 2, thisV.RenderSize.Height / 2);
                Vector centerVector = thisCenter - transformedToVCenter;
                //getting intersection point in the coordinate space of this vertex
                Point p1 = FindOppositePoint(fromGeometryFlat, transformedToVCenter, centerVector, null);
                //transforming back to the panel coordinate space
                if (transformToFromV != null)
                    p1 = transformToFromV.Inverse.Transform(p1);
                return p1;
            }
            return new Point(thisV.RenderSize.Width/2, thisV.RenderSize.Height/2);
        }

        /// <summary>
        /// Excludes a UI element from the AeroGlass frame.
        /// </summary>
        /// <param name="element">The element to exclude.</param>
        /// <remarks>Many non-WPF rendered controls (i.e., the ExplorerBrowser control) will not 
        /// render properly on top of an AeroGlass frame. </remarks>
        public void ExcludeElementFromAeroGlass(FrameworkElement element)
        {
            if (AeroGlassCompositionEnabled && element != null)
            {
                // calculate total size of window nonclient area
                HwndSource hwndSource = PresentationSource.FromVisual(this) as HwndSource;
                NativeRect windowRect;
                NativeRect clientRect;
                DesktopWindowManagerNativeMethods.GetWindowRect(hwndSource.Handle, out windowRect);
                DesktopWindowManagerNativeMethods.GetClientRect(hwndSource.Handle, out clientRect);
                Size nonClientSize = new Size(
                        (double)(windowRect.Right - windowRect.Left) - (double)(clientRect.Right - clientRect.Left),
                        (double)(windowRect.Bottom - windowRect.Top) - (double)(clientRect.Bottom - clientRect.Top));

                // calculate size of element relative to nonclient area
                GeneralTransform transform = element.TransformToAncestor(this);
                Point topLeftFrame = transform.Transform(new Point(0, 0));
                Point bottomRightFrame = transform.Transform(new Point(
                            element.ActualWidth + nonClientSize.Width,
                            element.ActualHeight + nonClientSize.Height));

                // Create a margin structure
                Margins margins = new Margins();
                margins.LeftWidth = (int)topLeftFrame.X;
                margins.RightWidth = (int)(this.ActualWidth - bottomRightFrame.X);
                margins.TopHeight = (int)(topLeftFrame.Y);
                margins.BottomHeight = (int)(this.ActualHeight - bottomRightFrame.Y);

                // Extend the Frame into client area
                DesktopWindowManagerNativeMethods.DwmExtendFrameIntoClientArea(windowHandle, ref margins);
            }
        }

        public static double GetVisibleWidth(FrameworkElement element, UIElement parent)
        {
            if (element == null) throw new ArgumentNullException(nameof(element));
            if (parent == null) throw new ArgumentNullException(nameof(parent));

            var location = element.TransformToAncestor(parent).Transform(new Point(0, 0));

            int width = (int) Math.Floor(element.ActualWidth);
            var hitTest = parent.InputHitTest(new Point(location.X + width, location.Y));

            if (IsAncestorTill(hitTest as FrameworkElement, element, parent))
            {
                return width;
            }

            //BinarySearch here
            int end = (int) Math.Floor(element.ActualWidth);
            int start = 0;

            while (start < end)
            {
                width = (end + start)/2;
                hitTest = parent.InputHitTest(new Point(location.X + width, location.Y));

                if (IsAncestorTill(hitTest as FrameworkElement, element, parent))
                {
                    //Speed tweak
                    hitTest = parent.InputHitTest(new Point(location.X + width + 1, location.Y));

                    if (IsAncestorTill(hitTest as FrameworkElement, element, parent))
                    {
                        start = width;
                    }
                    else
                    {
                        return width;
                    }
                }
                else
                {
                    end = width;
                }
            }


            //for (int width = (int) Math.Floor(element.ActualWidth); width >= 0; width--)
            //{
            //    var hitTest = parent.InputHitTest(new Point(location.X + width, location.Y));
            //
            //    if (hitTest == null) continue;
            //    
            //    if (IsAncestorTill(hitTest as FrameworkElement, element, parent))
            //    {
            //        return width;
            //    }
            //}

            return element.ActualWidth;
        }

        public static IntPoint ClientToScreen(FrameworkElement element, Point point)
        {
            PresentationSource source = PresentationSource.FromVisual(element);
            point = element.TransformToAncestor(source.RootVisual).Transform(point);

            Point offset = source.CompositionTarget.TransformToDevice.Transform(new Point(point.X, point.Y));

            Win32Point winPt = new Win32Point((int)offset.X, (int)offset.Y);
            NativeMethods.ClientToScreen(((HwndSource)source).Handle, ref winPt);

            return new IntPoint(winPt.x, winPt.y);
        }

 public static Point GetVisualTopLeftRelativeParent(FrameworkElement reference, Window parent)
 {
     return reference.TransformToAncestor(parent).Transform(new Point(0.0, 0.0));
 }

        private bool IsElementVisible(FrameworkElement element, FrameworkElement container)
        {
            if (!element.IsVisible)
                return false;

            // "element" here represents the "Border" object which contains TextBlock/Image of 
            // a class button. "container" here is the "ScrollLibraryViewer" on the library. 
            // The bounds of this class button is transformed to the rectangle it occupies in 
            // the "ScrollLibraryViewer" before being compared to the the region of container 
            // to determine if it lies outside of the container.
            // 
            var elementRect = new Rect(0.0, 0.0, element.ActualWidth, element.ActualHeight);
            var containerRect = new Rect(0.0, 0.0, container.ActualWidth, container.ActualHeight);
            elementRect = element.TransformToAncestor(container).TransformBounds(elementRect);
            return containerRect.IntersectsWith(elementRect);
        }

        private void ApplySlideOutToTop(FrameworkElement fe, Duration duration, Duration delay)
        {
            GeneralTransform transform = fe.TransformToAncestor(this);
             Point slidepoint = transform.Transform(new Point(0, fe.ActualHeight));

             if (delay.TimeSpan == TimeSpan.Zero)
             {
            DoubleAnimation da = new DoubleAnimation(0, -slidepoint.Y, duration);
            da.AccelerationRatio = da.DecelerationRatio = 0.2;
            fe.RenderTransformOrigin = new Point(0, 0);
            fe.RenderTransform = new TranslateTransform(0, 0);
            fe.RenderTransform.BeginAnimation(TranslateTransform.YProperty, da);
             }
             else
             {
            DoubleAnimationUsingKeyFrames da = new DoubleAnimationUsingKeyFrames();
            da.KeyFrames.Add(new LinearDoubleKeyFrame(0.0, KeyTime.FromTimeSpan(TimeSpan.Zero)));
            da.KeyFrames.Add(new LinearDoubleKeyFrame(0.0, KeyTime.FromTimeSpan(delay.TimeSpan)));
            da.KeyFrames.Add(new LinearDoubleKeyFrame(-slidepoint.Y, KeyTime.FromTimeSpan(delay.TimeSpan + duration.TimeSpan)));
            da.Duration = delay + duration;
            da.AccelerationRatio = da.DecelerationRatio = 0.2;
            fe.RenderTransformOrigin = new Point(0, 0);
            fe.RenderTransform = new TranslateTransform(0, 0);
            fe.RenderTransform.BeginAnimation(TranslateTransform.YProperty, da);
             }
        }

 protected Point FindPoint(FrameworkElement border, Point point)
 {
     var transform = border.TransformToAncestor((Visual) AdornedItemsControl);
     return transform.Transform(point);
 }

        /// <summary>Excludes a UI element from the Aero Glass frame.</summary>
        /// <param name="element">The element to exclude.</param>
        /// <param name="window">The window the element resides in.</param>
        /// <remarks>
        ///   cMany non-WPF rendered controls (i.e., the ExplorerBrowser control) will not render properly on top of an
        ///   Aero Glass frame.
        /// </remarks>
        public static void ExcludeElementFromAeroGlass(FrameworkElement element, Window window)
        {
            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            if (window == null)
            {
                throw new ArgumentNullException("window");
            }

            IntPtr handle = new WindowInteropHelper(window).Handle;

            if (!IsGlassEnabled)
            {
                return;
            }

            // calculate total size of window non-client area
            var handleSource = PresentationSource.FromVisual(window) as HwndSource;
            var windowRect = new Rect();
            var clientRect = new Rect();
            if (handleSource != null)
            {
                NativeMethods.GetWindowRect(handleSource.Handle, ref windowRect);
                NativeMethods.GetClientRect(handleSource.Handle, ref clientRect);
            }

            var nonClientSize =
                new Size(
                    (windowRect.Right - windowRect.Left) - (double)(clientRect.Right - clientRect.Left),
                    (windowRect.Bottom - windowRect.Top) - (double)(clientRect.Bottom - clientRect.Top));

            // calculate size of element relative to non-client area
            GeneralTransform transform = element.TransformToAncestor(window);
            Point topLeftFrame = transform.Transform(new Point(0, 0));
            Point bottomRightFrame =
                transform.Transform(
                    new Point(element.ActualWidth + nonClientSize.Width, element.ActualHeight + nonClientSize.Height));

            // Create a margin structure
            var margins = new Margins(
                (int)topLeftFrame.X,
                (int)topLeftFrame.Y,
                (int)(window.ActualWidth - bottomRightFrame.X),
                (int)(window.ActualHeight - bottomRightFrame.Y));

            // Extend the Frame into client area
            if (NativeMethods.DwmExtendFrameIntoClientArea(handle, ref margins) != 0)
            {
                // throw new InvalidOperationException();
            }
        }

        /// <summary>
        ///     Determines if a cell meets the criteria for being chosen. If it does, it
        ///     calculates its a "distance" that can be compared to other cells.
        /// </summary>
        /// <param name="distance">
        ///     A value that represents the distance between the mouse and the cell.
        ///     This is not necessarily an accurate pixel number in some cases.
        /// </param>
        /// <returns>
        ///     true if the cell can be a drag target. false otherwise.
        /// </returns>
        private static bool CalculateCellDistance(FrameworkElement cell, DataGridRow rowOwner, Panel itemsHost, Rect itemsHostBounds, bool isMouseInCorner, out double distance)
        {
            GeneralTransform transform = cell.TransformToAncestor(itemsHost);
            Rect cellBounds = new Rect(new Point(), cell.RenderSize);

            // Limit to only cells that are entirely visible
            if (itemsHostBounds.Contains(transform.TransformBounds(cellBounds)))
            {
                Point pt = Mouse.GetPosition(cell);
                if (isMouseInCorner)
                {
                    // When the mouse is in the corner, go by distance from center of the cell
                    Vector v = new Vector(pt.X - (cellBounds.Width * 0.5), pt.Y - (cellBounds.Height * 0.5));
                    distance = v.Length;
                    return true;
                }
                else
                {
                    Point rowPt = Mouse.GetPosition(rowOwner);
                    Rect rowBounds = new Rect(new Point(), rowOwner.RenderSize);

                    // The mouse should overlap a row or column
                    if ((pt.X >= cellBounds.Left) && (pt.X <= cellBounds.Right))
                    {
                        // The mouse is within a column
                        if ((rowPt.Y >= rowBounds.Top) && (rowPt.Y <= rowBounds.Bottom))
                        {
                            // Mouse is within the cell
                            distance = 0.0;
                        }
                        else
                        {
                            // Mouse is outside but is within a columns horizontal bounds
                            distance = Math.Abs(pt.Y - cellBounds.Top);
                        }

                        return true;
                    }
                    else if ((rowPt.Y >= rowBounds.Top) && (rowPt.Y <= rowBounds.Bottom))
                    {
                        // Mouse is outside but is within a row's vertical bounds
                        distance = Math.Abs(pt.X - cellBounds.Left);
                        return true;
                    }
                }
            }

            distance = Double.PositiveInfinity;
            return false;
        }

        private void AdjustOffsetToAlignWithEdge(FrameworkElement element, FocusNavigationDirection direction)
        {
            Debug.Assert(ScrollHost != null, "This operation to adjust the offset along an edge is only possible when there is a ScrollHost available");

            if (VirtualizingPanel.GetScrollUnit(this) != ScrollUnit.Item)
            {
                ScrollViewer scrollHost = ScrollHost;
                FrameworkElement viewportElement = GetViewportElement();
                element = TryGetTreeViewItemHeader(element) as FrameworkElement;
                Rect elementBounds = new Rect(new Point(), element.RenderSize);
                elementBounds = element.TransformToAncestor(viewportElement).TransformBounds(elementBounds);
                bool isHorizontal = (ItemsHost.HasLogicalOrientation && ItemsHost.LogicalOrientation == Orientation.Horizontal);

                if (direction == FocusNavigationDirection.Down)
                {
                    // Align with the bottom edge of viewport
                    if (isHorizontal)
                    {
                        scrollHost.ScrollToHorizontalOffset(scrollHost.HorizontalOffset - scrollHost.ViewportWidth + elementBounds.Right);
                    }
                    else
                    {
                        scrollHost.ScrollToVerticalOffset(scrollHost.VerticalOffset - scrollHost.ViewportHeight + elementBounds.Bottom);
                    }
                }
                else if (direction == FocusNavigationDirection.Up)
                {
                    // Align with the top edge of viewport
                    if (isHorizontal)
                    {
                        scrollHost.ScrollToHorizontalOffset(scrollHost.HorizontalOffset + elementBounds.Left);
                    }
                    else
                    {
                        scrollHost.ScrollToVerticalOffset(scrollHost.VerticalOffset + elementBounds.Top);
                    }
                }
            }
        }

        private Point CalculateViewRenderTransformOrigin(Panel panel, FrameworkElement element) {
            if (panel == null || element == null
                || Math.Abs(panel.ActualWidth - 0) < double.Epsilon
                || Math.Abs(panel.ActualHeight - 0) < double.Epsilon)
                return ViewRenderTransformOriginDefaultValue;

            // The Old Solution:
            //var panelPoint = panel.PointToScreen(ZeroPoint);
            //var elementPoint = element.PointToScreen(ZeroPoint);
            //var centerX = (elementPoint.X - panelPoint.X) + (element.ActualWidth / 2);
            //var centerY = (elementPoint.Y - panelPoint.Y) + (element.ActualHeight / 2);

            // The New One:
            var relativeElementPoint = element.TransformToAncestor(panel).Transform(new Point(0, 0));
            var centerX = (relativeElementPoint.X) + (element.ActualWidth / 2);
            var centerY = (relativeElementPoint.Y) + (element.ActualHeight / 2);

            var percentX = centerX * 100 / panel.ActualWidth;
            var percentY = centerY * 100 / panel.ActualHeight;
            var originX = percentX / 100;
            var originY = percentY / 100;

            return new Point(originX, originY);
        }

        private bool ElementPastBoundary(FrameworkElement fe, out Vector pastEdgeVector)
        {
            bool pastEdge = false;

            pastEdgeVector = new Vector();

            FrameworkElement feParent = fe.Parent as FrameworkElement;
            if (feParent != null)
            {
                Rect feRect = fe.TransformToAncestor(feParent).TransformBounds(
                    new Rect(0.0, 0.0, fe.ActualWidth, fe.ActualHeight));

                if (feRect.Left > feParent.ActualWidth - 20)
                    pastEdgeVector.X = feRect.Left - (feParent.ActualWidth - 20);

                if (feRect.Right < 20)
                    pastEdgeVector.X = feRect.Right - 20;

                if (feRect.Top > feParent.ActualHeight - 20)
                    pastEdgeVector.Y = feRect.Top - (feParent.ActualHeight - 20);

                if (feRect.Bottom < 20)
                    pastEdgeVector.Y = feRect.Bottom - 20;

                if ((pastEdgeVector.X != 0) || (pastEdgeVector.Y != 0))
                    pastEdge = true;
            }

            return pastEdge;
        }

 /// <summary>
 /// Scroll the given framework element into view using a smooth animation.
 /// </summary>
 /// <param name="e"></param>
 public Rect ScrollIntoView(FrameworkElement e)
 {
     StopAnimations();
     Rect rect = new Rect(0, 0, e.ActualWidth, e.ActualHeight);
     // Get zoomed & translated coordinates of this object by transforming to the container coordinates.
     rect = e.TransformToAncestor(_container).TransformBounds(rect);
     rect.Inflate(margin, margin);
     ScrollIntoView(rect, new Duration(TimeSpan.FromMilliseconds(_defaultZoomTime)), true);
     return rect;
 }

 private Rect GetBoundingBox(FrameworkElement element, Window containerWindow)
 {
     GeneralTransform transform = element.TransformToAncestor(containerWindow);
     Point topLeft = transform.Transform(new Point(0, 0));
     Point bottomRight = transform.Transform(new Point(element.ActualWidth, element.ActualHeight));
     return new Rect(topLeft, bottomRight);
 }