C# Rect.Offset方法代码示例

        public void BasicTransformation()
        {
            Rect original = new Rect(1, 2, 3, 4);
            Rect originalF = new Rect(1.4f, 2.4f, 3.4f, 4.4f);

            // Transform operations should always return copies
            original.Scale(2.5f, 2.5f);
            original.Round();
            original.Offset(1.5f, 1.5f);
            original.Ceiling();
            original.Transform(2.5f, 2.5f);
            original.Floor();
            Assert.AreEqual(original, new Rect(1, 2, 3, 4));

            // Test some basic transformations
            Assert.AreEqual(new Rect(1, 2, 6, 8), original.Scale(2, 2));
            Assert.AreEqual(new Rect(3, 4, 3, 4), original.Offset(2, 2));
            Assert.AreEqual(new Rect(2, 4, 6, 8), original.Transform(2, 2));
            Assert.AreEqual(new Rect(1, 2, 3, 4), originalF.Round());
            Assert.AreEqual(new Rect(1, 2, 3, 4), originalF.Floor());
            Assert.AreEqual(new Rect(2, 3, 4, 5), originalF.Ceiling());

            // Check normalizing
            Assert.AreEqual(new Rect(1, 2, 3, 4), new Rect(4, 6, -3, -4).Normalize());
        }

        public void IntersectionRect(int x, int y, int w, int h)
        {
            Rect rect = new Rect(x, y, w, h);
            Rect norm = rect.Normalize();

            // Intersection with self and offset-variants
            Assert.AreEqual(norm, rect.Intersection(rect));
            Assert.AreEqual(new Rect(norm.X + 1, norm.Y    , norm.W - 1, norm.H    ), rect.Intersection(rect.Offset(1, 0)));
            Assert.AreEqual(new Rect(norm.X    , norm.Y    , norm.W - 1, norm.H    ), rect.Intersection(rect.Offset(-1, 0)));
            Assert.AreEqual(new Rect(norm.X    , norm.Y + 1, norm.W    , norm.H - 1), rect.Intersection(rect.Offset(0, 1)));
            Assert.AreEqual(new Rect(norm.X    , norm.Y    , norm.W    , norm.H - 1), rect.Intersection(rect.Offset(0, -1)));

            // Intersection with corners
            Assert.AreEqual(new Rect(rect.TopLeft.X        , rect.TopLeft.Y        , 1, 1), rect.Intersection(rect.TopLeft.X - 1    , rect.TopLeft.Y - 1    , 2, 2));
            Assert.AreEqual(new Rect(rect.TopRight.X - 1   , rect.TopRight.Y       , 1, 1), rect.Intersection(rect.TopRight.X - 1   , rect.TopRight.Y - 1   , 2, 2));
            Assert.AreEqual(new Rect(rect.BottomLeft.X     , rect.BottomLeft.Y - 1 , 1, 1), rect.Intersection(rect.BottomLeft.X - 1 , rect.BottomLeft.Y - 1 , 2, 2));
            Assert.AreEqual(new Rect(rect.BottomRight.X - 1, rect.BottomRight.Y - 1, 1, 1), rect.Intersection(rect.BottomRight.X - 1, rect.BottomRight.Y - 1, 2, 2));

            // Non-intersection
            Assert.AreEqual(0, rect.Intersection(rect.Offset(MathF.Abs(rect.W), 0)).Area);
            Assert.AreEqual(0, rect.Intersection(rect.Offset(-MathF.Abs(rect.W), 0)).Area);
            Assert.AreEqual(0, rect.Intersection(rect.Offset(0, MathF.Abs(rect.H))).Area);
            Assert.AreEqual(0, rect.Intersection(rect.Offset(0, -MathF.Abs(rect.H))).Area);
        }

        public void Containment()
        {
            Rect rect = new Rect(-5, -10, 10, 20);

            // A rect should contain all the points on its edge
            Assert.IsTrue(rect.Contains(rect.TopLeft));
            Assert.IsTrue(rect.Contains(rect.Top));
            Assert.IsTrue(rect.Contains(rect.TopRight));
            Assert.IsTrue(rect.Contains(rect.Left));
            Assert.IsTrue(rect.Contains(rect.Center));
            Assert.IsTrue(rect.Contains(rect.Right));
            Assert.IsTrue(rect.Contains(rect.BottomLeft));
            Assert.IsTrue(rect.Contains(rect.Bottom));
            Assert.IsTrue(rect.Contains(rect.BottomRight));

            // Points it shouldn't contain
            Assert.IsFalse(rect.Contains(rect.Left - Vector2.UnitX));
            Assert.IsFalse(rect.Contains(rect.Right + Vector2.UnitX));
            Assert.IsFalse(rect.Contains(rect.Top - Vector2.UnitY));
            Assert.IsFalse(rect.Contains(rect.Bottom + Vector2.UnitY));

            // A rect should contain itself, but not any offset variant
            Assert.IsTrue(rect.Contains(rect));
            Assert.IsFalse(rect.Contains(rect.Offset(1, 0)));
            Assert.IsFalse(rect.Contains(rect.Offset(-1, 0)));
            Assert.IsFalse(rect.Contains(rect.Offset(0, 1)));
            Assert.IsFalse(rect.Contains(rect.Offset(0, -1)));

            // It can contain a smaller rect, but not a bigger one
            Assert.IsTrue(rect.Contains(1, 2, 3, 4));
            Assert.IsFalse(rect.Contains(-6, -11, 12, 22));
            Assert.IsFalse(rect.Contains(-1, -11, 2, 22));
            Assert.IsFalse(rect.Contains(-6, -1, 12, 2));
        }

        public void IntersectionCheking(int x, int y, int w, int h)
        {
            Rect rect = new Rect(x, y, w, h);

            // Intersection with self and offset-variants
            Assert.IsTrue(rect.Intersects(rect));
            Assert.IsTrue(rect.Intersects(rect.Offset(1, 0)));
            Assert.IsTrue(rect.Intersects(rect.Offset(-1, 0)));
            Assert.IsTrue(rect.Intersects(rect.Offset(0, 1)));
            Assert.IsTrue(rect.Intersects(rect.Offset(0, -1)));

            // Intersection with crossing rect: Horizontal
            Assert.IsTrue(rect.Intersects(rect.MinX - 1, rect.MinY, rect.MaxX - rect.MinX + 2, rect.MaxY - rect.MinY));
            Assert.IsTrue(rect.Intersects(rect.MinX - 1, rect.MinY - 1, rect.MaxX - rect.MinX + 2, 2));
            Assert.IsTrue(rect.Intersects(rect.MinX - 1, rect.MaxY - 1, rect.MaxX - rect.MinX + 2, 2));

            // Intersection with crossing rect: Vertical
            Assert.IsTrue(rect.Intersects(rect.MinX, rect.MinY - 1, rect.MaxX - rect.MinX, rect.MaxY - rect.MinY + 2));
            Assert.IsTrue(rect.Intersects(rect.MinX - 1, rect.MinY - 1, 2, rect.MaxY - rect.MinY + 2));
            Assert.IsTrue(rect.Intersects(rect.MaxX - 1, rect.MinY - 1, 2, rect.MaxY - rect.MinY + 2));

            // Intersection with corners
            Assert.IsTrue(rect.Intersects(rect.TopLeft.X - 1, rect.TopLeft.Y - 1, 2, 2));
            Assert.IsTrue(rect.Intersects(rect.TopRight.X - 1, rect.TopRight.Y - 1, 2, 2));
            Assert.IsTrue(rect.Intersects(rect.BottomLeft.X - 1, rect.BottomLeft.Y - 1, 2, 2));
            Assert.IsTrue(rect.Intersects(rect.BottomRight.X - 1, rect.BottomRight.Y - 1, 2, 2));

            // Non-intersection
            Assert.IsFalse(rect.Intersects(rect.MinX - 2, rect.MinY, 1, rect.MaxY - rect.MinY));
            Assert.IsFalse(rect.Intersects(rect.MaxX + 2, rect.MinY, 1, rect.MaxY - rect.MinY));
            Assert.IsFalse(rect.Intersects(rect.MinX, rect.MinY - 2, rect.MaxX - rect.MinX, 1));
            Assert.IsFalse(rect.Intersects(rect.MinX, rect.MaxY + 2, rect.MaxX - rect.MinX, 1));

            // Non-intersection with corners
            Assert.IsFalse(rect.Intersects(rect.TopLeft.X - 2, rect.TopLeft.Y - 2, 1, 1));
            Assert.IsFalse(rect.Intersects(rect.TopRight.X + 2, rect.TopRight.Y - 2, 1, 1));
            Assert.IsFalse(rect.Intersects(rect.BottomLeft.X - 2, rect.BottomLeft.Y + 2, 1, 1));
            Assert.IsFalse(rect.Intersects(rect.BottomRight.X + 2, rect.BottomRight.Y + 2, 1, 1));
        }

        private void SetItemsHostInsetForChild(int index, UIElement child, IContainItemStorage itemStorageProvider, bool isHorizontal)
        {
            Debug.Assert(!IsVSP45Compat, "SetItemsHostInset should not be called in VSP45-compat mode");

            // this only applies to a hierarchical element with a visible ItemsHost
            bool isChildHorizontal = isHorizontal;
            IHierarchicalVirtualizationAndScrollInfo virtualizingChild = GetVirtualizingChild(child, ref isChildHorizontal);
            Panel itemsHost = (virtualizingChild == null) ? null : virtualizingChild.ItemsHost;
            if (itemsHost == null || !itemsHost.IsVisible)
                return;

            // get the transformation from child coords to itemsHost coords
            GeneralTransform transform = child.TransformToDescendant(itemsHost);
            if (transform == null)
                return;     // when transform is undefined, ItemsHost is effectively invisible

            // build a rect (in child coords) describing the child's extended frame
            FrameworkElement fe = virtualizingChild as FrameworkElement;
            Thickness margin = (fe == null) ? new Thickness() : fe.Margin;
            Rect childRect = new Rect(new Point(), child.DesiredSize);
            childRect.Offset(-margin.Left, -margin.Top);

            // transform to itemsHost coords
            Rect itemsRect = transform.TransformBounds(childRect);

            // compute the desired inset, avoiding catastrophic cancellation errors
            Size itemsSize = itemsHost.DesiredSize;
            double left = DoubleUtil.AreClose(0, itemsRect.Left) ? 0 : -itemsRect.Left;
            double top = DoubleUtil.AreClose(0, itemsRect.Top) ? 0 : -itemsRect.Top;
            double right = DoubleUtil.AreClose(itemsSize.Width, itemsRect.Right) ? 0 : itemsRect.Right-itemsSize.Width;
            double bottom = DoubleUtil.AreClose(itemsSize.Height, itemsRect.Bottom) ? 0 : itemsRect.Bottom-itemsSize.Height;
            Thickness inset = new Thickness(left, top, right, bottom);


            // get the item to use as the key into items storage
            object item = GetItemFromContainer(child);
            if (item == DependencyProperty.UnsetValue)
            {
                Debug.Assert(false, "SetInset should only be called for a container");
                return;
            }

            // see whether inset is changing
            object box = itemStorageProvider.ReadItemValue(item, ItemsHostInsetProperty);
            bool changed = (box == null);
            bool remeasure = changed;
            if (!changed)
            {
                Thickness oldInset = (Thickness)box;
                changed = !(    DoubleUtil.AreClose(oldInset.Left, inset.Left) &&
                                DoubleUtil.AreClose(oldInset.Top, inset.Top ) &&
                                DoubleUtil.AreClose(oldInset.Right, inset.Right) &&
                                DoubleUtil.AreClose(oldInset.Bottom, inset.Bottom) );

                // only changes along the scrolling axis require a remeasure.
                // use a less stringent "AreClose" test;  experiments show that the
                // trailing inset can change due to roundoff error by an amount
                // that is larger than the tolerance in DoubleUtil, but not large
                // enough to warrant an expensive remeasure.
                remeasure = changed &&
                    (   (isHorizontal  && !(AreInsetsClose(oldInset.Left, inset.Left) &&
                                            AreInsetsClose(oldInset.Right, inset.Right)))
                     || (!isHorizontal && !(AreInsetsClose(oldInset.Top, inset.Top) &&
                                            AreInsetsClose(oldInset.Bottom, inset.Bottom))) );
            }

            if (changed)
            {
                // store the new inset
                itemStorageProvider.StoreItemValue(item, ItemsHostInsetProperty, inset);
                child.SetValue(ItemsHostInsetProperty, inset);
            }

            if (remeasure)
            {
                // re-measure the scrolling panel
                ItemsControl scrollingItemsControl = GetScrollingItemsControl(child);
                Panel scrollingPanel = (scrollingItemsControl == null) ? null : scrollingItemsControl.ItemsHost;
                if (scrollingPanel != null)
                {
                    VirtualizingStackPanel vsp = scrollingPanel as VirtualizingStackPanel;
                    if (vsp != null)
                    {
                        vsp.AnchoredInvalidateMeasure();
                    }
                    else
                    {
                        scrollingPanel.InvalidateMeasure();
                    }
                }
            }
        }