```Rect.Contains(double x, double y)``` returns ```true``` for points on both right and bottom edges

[lfmissonb]

Description

Rect.Contains(double x, double y) returns true for points on both right and bottom edges

Reproduction Steps

Console.WriteLine(new Rect(0, 0, 1, 1).Contains(0, 0));
Console.WriteLine(new Rect(0, 0, 1, 1).Contains(0, 1));
Console.WriteLine(new Rect(0, 0, 1, 1).Contains(1, 0));
Console.WriteLine(new Rect(0, 0, 1, 1).Contains(1, 1));

Expected behavior

output:
True
False
False
False

Actual behavior

output:
True
True
True
True

Regression?

No response

Known Workarounds

No response

Impact

No response

Configuration

No response

Other information

https://github.com/dotnet/wpf/blob/main/src/Microsoft.DotNet.Wpf/src/WindowsBase/System/Windows/Rect.cs#L763

            return ((x >= _x) && (x - _width <= _x) &&
                    (y >= _y) && (y - _height <= _y));

expected:

            return ((x >= _x) && (x - _width < _x) &&
                    (y >= _y) && (y - _height < _y));

[lindexi]

@lfmissonb I think it is by wpf design, which use the closed interval rule.

[lfmissonb]

@lfmissonb I think it is by wpf design, which use the closed interval rule.

@lindexi But this makes it strange, a 1x1 rectangle, which should have an area of 1, contains 4 pixel points

[miloush]

Pixel is not a little square. If you have a rectangle of countable things, In32Rect might be a better option. For a Rect with infinite width/height, your expected code would claim that infinity is not part of the rectangle. Either way, this would be a breaking change. You can create your own method for testing whether a rectangle contains a point. In many practical scenarios that includes some tolerance anyway.

What is the user scenario in which the current implementation is causing an undesired behavior?

[chalion]

@lfmissonb Please delete this issue, because even if the current behavior surprised you, no one is going to change it and potentially break existing code.

[lindexi]

@lfmissonb Please don’t feel obliged to follow @chalion 's advice, as he is neither a member of this project nor an active contributor to this open-source project. Your issues can still open for discussion, although I think it may be difficult to reach a definitive conclusion. When discussing an API, it’s not always necessary for the discussion to lead to actual changes—sometimes the exchange of ideas itself is valuable and interesting. If you have encountered confusion, chances are others might face the same questions in the future. When they find this thread and read through the conversation, they may benefit from the discussion as well.

[pchaurasia14]

@lfmissonb - Could you also provide ans to @miloush's question on -

What is the user scenario in which the current implementation is causing an undesired behavior?

[lfmissonb]

I made a ResizableBorder:

public class ResizableBorder : Border
{
    private static readonly DependencyProperty ResizeWidthProperty =
        DependencyProperty.Register(nameof(ResizeWidth), typeof(int), typeof(ResizableBorder));

    public int ResizeWidth
    {
        get => (int)GetValue(ResizeWidthProperty);
        set => SetValue(ResizeWidthProperty, value);
    }

    public bool IsResizing { get; private set; }
    private Point _lastMousePosition;

    private HitBorders _hitBorders;

    public ResizableBorder()
    {
        MouseDown += ResizableBorder_OnMouseDown;
        MouseMove += ResizableBorder_OnMouseMove;
        MouseUp += ResizableBorder_OnMouseUp;
    }

    private void ResizableBorder_OnMouseDown(object sender, MouseButtonEventArgs e)
    {
        if (e.ChangedButton == MouseButton.Left && _hitBorders != HitBorders.None)
        {
            IsResizing = true;
            _lastMousePosition = e.GetPosition(this);
            CaptureMouse();
        }
    }

    private void ResizableBorder_OnMouseMove(object sender, MouseEventArgs e)
    {
        var pos = e.GetPosition(this);
        if (IsResizing)
        {
            ShowResizeChange(pos);
        }
        else
        {
            _hitBorders = HitBorders.None;

            if (new Rect(0, 0, ResizeWidth, ActualHeight).Contains(pos))
            {
                _hitBorders |= HitBorders.Left;
            }

            if (new Rect(0, 0, ActualWidth, ResizeWidth).Contains(pos))
            {
                _hitBorders |= HitBorders.Top;
            }

            if (new Rect(ActualWidth - (ResizeWidth - 1), 0, ResizeWidth, ActualHeight).Contains(pos))
            {
                _hitBorders |= HitBorders.Right;
            }

            if (new Rect(0, ActualHeight - (ResizeWidth - 1), ActualWidth, ResizeWidth).Contains(pos))
            {
                _hitBorders |= HitBorders.Bottom;
            }


            Cursor = _hitBorders switch
            {
                HitBorders.Top => Cursors.SizeNS,
                HitBorders.Bottom => Cursors.SizeNS,
                HitBorders.Left => Cursors.SizeWE,
                HitBorders.Right => Cursors.SizeWE,
                HitBorders.TopLeft => Cursors.SizeNWSE,
                HitBorders.BottomRight => Cursors.SizeNWSE,
                HitBorders.TopRight => Cursors.SizeNESW,
                HitBorders.BottomLeft => Cursors.SizeNESW,
                _ => Cursors.Arrow
            };
        }
    }

    private void ResizableBorder_OnMouseUp(object sender, MouseButtonEventArgs e)
    {
        if (IsResizing)
        {
            ShowResizeChange(e.GetPosition(this));
            IsResizing = false;
            ReleaseMouseCapture();
        }
    }

    private void ShowResizeChange(Point pos)
    {
        var left = (_hitBorders & HitBorders.Left) == HitBorders.Left;
        var right = (_hitBorders & HitBorders.Right) == HitBorders.Right;
        var top = (_hitBorders & HitBorders.Top) == HitBorders.Top;
        var bottom = (_hitBorders & HitBorders.Bottom) == HitBorders.Bottom;

        if (left || right)
        {
            var oldWidth = Width;
            Width = double.Max(Width + (pos.X - _lastMousePosition.X) * (left ? -1 : 1), 0);

            var deltaX = Width - oldWidth;
            if (left)
            {
                Canvas.SetLeft(this, Canvas.GetLeft(this) - deltaX);
            }
            else
            {
                _lastMousePosition.X += deltaX;
            }
        }

        if (top || bottom)
        {
            var oldHeight = Height;
            Height = double.Max(Height + (pos.Y - _lastMousePosition.Y) * (top ? -1 : 1), 0);

            var deltaY = Height - oldHeight;
            if (top)
            {
                Canvas.SetTop(this, Canvas.GetTop(this) - deltaY);
            }
            else
            {
                _lastMousePosition.Y += deltaY;
            }
        }
    }

    [Flags]
    private enum HitBorders
    {
        None = 0,
        Left = 1,
        Top = 2,
        Right = 4,
        Bottom = 8,
        TopLeft = Top | Left,
        TopRight = Top | Right,
        BottomLeft = Bottom | Left,
        BottomRight = Bottom | Right,
    }
}

<Canvas>
    <local:ResizableBorder Width="100" Height="100" Canvas.Left="100" Canvas.Top="100" Background="Blue" ResizeWidth="8" />
    <local:ResizableBorder Width="100" Height="100" Canvas.Left="300" Canvas.Top="100" Background="Red" ResizeWidth="0" />
 </Canvas>

I found this issue when ResizeWidth was set to 0 (the left and top borders still have a 1 pixel resizeable border).

            if (new Rect(0, 0, ResizeWidth, ActualHeight).Contains(pos))
            {
                _hitBorders |= HitBorders.Left;
            }

            if (new Rect(0, 0, ActualWidth, ResizeWidth).Contains(pos))
            {
                _hitBorders |= HitBorders.Top;
            }

These two rectangles: Rect(0, 0, 0, ActualHeight) and Rect(0, 0, ActualWidth, 0) should not hit test anything.

@miloush @pchaurasia14

@lfmissonb - Could you also provide ans to @miloush's question on -

What is the user scenario in which the current implementation is causing an undesired behavior?

Pixel is not a little square. If you have a rectangle of countable things, In32Rect might be a better option. For a Rect with infinite width/height, your expected code would claim that infinity is not part of the rectangle. Either way, this would be a breaking change. You can create your own method for testing whether a rectangle contains a point. In many practical scenarios that includes some tolerance anyway.

What is the user scenario in which the current implementation is causing an undesired behavior?

[miloush]

If I understand it correctly, you are arguing that Rect(0,0,0,0) should not contain the point (0,0). What do you expect the Width and Height be for a Rect that only contains point (0,0) and nothing else?

[lfmissonb]

I think Rect(0,0,1,1) should only contains the point (0,0), Rect(0, 0, 0, 0) should contains nothing.

If I understand it correctly, you are arguing that Rect(0,0,0,0) should not contain the point (0,0). What do you expect the Width and Height be for a Rect that only contains point (0,0) and nothing else?

[lindexi]

I think it is the math open and closed interval issues. The rect does not necessarily always represent the pixel range.

[miloush]

I think Rect(0,0,1,1) should only contains the point (0,0), Rect(0, 0, 0, 0) should contains nothing.

So Rect(0,0,1,1) should not contain (0.5, 0.5)?