juce_Rectangle.h

Go to the documentation of this file.

 /*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
   Agreement and JUCE Privacy Policy.
 
   End User License Agreement: www.juce.com/juce-7-licence
   Privacy Policy: www.juce.com/juce-privacy-policy
 
   Or: You may also use this code under the terms of the GPL v3 (see
   www.gnu.org/licenses).
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
 
#ifndef DOXYGEN
namespace detail
{
 
template <typename> struct Tag {};
 
inline auto getNumericValue (StringRef s, Tag<int>)    { return s.text.getIntValue32(); }
inline auto getNumericValue (StringRef s, Tag<double>) { return s.text.getDoubleValue(); }
inline auto getNumericValue (StringRef s, Tag<float>)  { return static_cast<float> (s.text.getDoubleValue()); }
 
template <typename ValueType>
ValueType parseAfterSpace (StringRef s) noexcept
{
    return static_cast<ValueType> (getNumericValue (s.text.findEndOfWhitespace(),
                                                    Tag<ValueType>{}));
}
 
inline int floorAsInt (int n) noexcept     { return n; }
inline int floorAsInt (float n) noexcept   { return n > (float)  std::numeric_limits<int>::min() ? (int) std::floor (n) : std::numeric_limits<int>::min(); }
inline int floorAsInt (double n) noexcept  { return n > (double) std::numeric_limits<int>::min() ? (int) std::floor (n) : std::numeric_limits<int>::min(); }
 
inline int ceilAsInt (int n) noexcept      { return n; }
inline int ceilAsInt (float n) noexcept    { return n < (float)  std::numeric_limits<int>::max() ? (int) std::ceil (n) : std::numeric_limits<int>::max(); }
inline int ceilAsInt (double n) noexcept   { return n < (double) std::numeric_limits<int>::max() ? (int) std::ceil (n) : std::numeric_limits<int>::max(); }
 
} // namespace detail
#endif
 
//==============================================================================
template <typename ValueType>
class Rectangle
{
public:
    //==============================================================================
    Rectangle() = default;
 
    Rectangle (const Rectangle&) = default;
 
    Rectangle (ValueType initialX, ValueType initialY,
               ValueType width, ValueType height) noexcept
      : pos (initialX, initialY),
        w (width), h (height)
    {
    }
 
    Rectangle (ValueType width, ValueType height) noexcept
      : w (width), h (height)
    {
    }
 
    Rectangle (Point<ValueType> corner1, Point<ValueType> corner2) noexcept
      : pos (jmin (corner1.x, corner2.x),
             jmin (corner1.y, corner2.y)),
        w (corner1.x - corner2.x),
        h (corner1.y - corner2.y)
    {
        if (w < ValueType()) w = -w;
        if (h < ValueType()) h = -h;
    }
 
    static Rectangle leftTopRightBottom (ValueType left, ValueType top,
                                         ValueType right, ValueType bottom) noexcept
    {
        return { left, top, right - left, bottom - top };
    }
 
    Rectangle& operator= (const Rectangle&) = default;
 
    ~Rectangle() = default;
 
    //==============================================================================
    bool isEmpty() const noexcept                                   { return w <= ValueType() || h <= ValueType(); }
 
    inline bool isFinite() const noexcept                           { return pos.isFinite() && juce_isfinite (w) && juce_isfinite (h); }
 
    inline ValueType getX() const noexcept                          { return pos.x; }
 
    inline ValueType getY() const noexcept                          { return pos.y; }
 
    inline ValueType getWidth() const noexcept                      { return w; }
 
    inline ValueType getHeight() const noexcept                     { return h; }
 
    inline ValueType getRight() const noexcept                      { return pos.x + w; }
 
    inline ValueType getBottom() const noexcept                     { return pos.y + h; }
 
    ValueType getCentreX() const noexcept                           { return pos.x + w / (ValueType) 2; }
 
    ValueType getCentreY() const noexcept                           { return pos.y + h / (ValueType) 2; }
 
    Point<ValueType> getCentre() const noexcept                     { return { pos.x + w / (ValueType) 2,
                                                                               pos.y + h / (ValueType) 2 }; }
 
    ValueType getAspectRatio (bool widthOverHeight = true) const noexcept                           { return widthOverHeight ? w / h : h / w; }
 
    //==============================================================================
    inline Point<ValueType> getPosition() const noexcept                                            { return pos; }
 
    inline void setPosition (Point<ValueType> newPos) noexcept                                      { pos = newPos; }
 
    inline void setPosition (ValueType newX, ValueType newY) noexcept                               { pos.setXY (newX, newY); }
 
    Point<ValueType> getTopLeft() const noexcept                                                    { return pos; }
 
    Point<ValueType> getTopRight() const noexcept                                                   { return { pos.x + w, pos.y }; }
 
    Point<ValueType> getBottomLeft() const noexcept                                                 { return { pos.x, pos.y + h }; }
 
    Point<ValueType> getBottomRight() const noexcept                                                { return { pos.x + w, pos.y + h }; }
 
    Range<ValueType> getHorizontalRange() const noexcept                                            { return Range<ValueType>::withStartAndLength (pos.x, w); }
 
    Range<ValueType> getVerticalRange() const noexcept                                              { return Range<ValueType>::withStartAndLength (pos.y, h); }
 
    void setSize (ValueType newWidth, ValueType newHeight) noexcept                                 { w = newWidth; h = newHeight; }
 
    void setBounds (ValueType newX, ValueType newY,
                    ValueType newWidth, ValueType newHeight) noexcept                               { pos.x = newX; pos.y = newY; w = newWidth; h = newHeight; }
 
    inline void setX (ValueType newX) noexcept                                                      { pos.x = newX; }
 
    inline void setY (ValueType newY) noexcept                                                      { pos.y = newY; }
 
    inline void setWidth (ValueType newWidth) noexcept                                              { w = newWidth; }
 
    inline void setHeight (ValueType newHeight) noexcept                                            { h = newHeight; }
 
    inline void setCentre (ValueType newCentreX, ValueType newCentreY) noexcept                     { pos.x = newCentreX - w / (ValueType) 2;
                                                                                                      pos.y = newCentreY - h / (ValueType) 2; }
 
    inline void setCentre (Point<ValueType> newCentre) noexcept                                     { setCentre (newCentre.x, newCentre.y); }
 
    void setHorizontalRange (Range<ValueType> range) noexcept                                       { pos.x = range.getStart(); w = range.getLength(); }
 
    void setVerticalRange (Range<ValueType> range) noexcept                                         { pos.y = range.getStart(); h = range.getLength(); }
 
    [[nodiscard]] Rectangle withX (ValueType newX) const noexcept                                  { return { newX, pos.y, w, h }; }
 
    [[nodiscard]] Rectangle withY (ValueType newY) const noexcept                                  { return { pos.x, newY, w, h }; }
 
    [[nodiscard]] Rectangle withRightX (ValueType newRightX) const noexcept                        { return { newRightX - w, pos.y, w, h }; }
 
    [[nodiscard]] Rectangle withBottomY (ValueType newBottomY) const noexcept                      { return { pos.x, newBottomY - h, w, h }; }
 
    [[nodiscard]] Rectangle withPosition (ValueType newX, ValueType newY) const noexcept           { return { newX, newY, w, h }; }
 
    [[nodiscard]] Rectangle withPosition (Point<ValueType> newPos) const noexcept                  { return { newPos.x, newPos.y, w, h }; }
 
    [[nodiscard]] Rectangle withZeroOrigin() const noexcept                                        { return { w, h }; }
 
    [[nodiscard]] Rectangle withCentre (Point<ValueType> newCentre) const noexcept                 { return { newCentre.x - w / (ValueType) 2,
                                                                                                               newCentre.y - h / (ValueType) 2, w, h }; }
 
    [[nodiscard]] Rectangle withWidth (ValueType newWidth) const noexcept                          { return { pos.x, pos.y, jmax (ValueType(), newWidth), h }; }
 
    [[nodiscard]] Rectangle withHeight (ValueType newHeight) const noexcept                        { return { pos.x, pos.y, w, jmax (ValueType(), newHeight) }; }
 
    [[nodiscard]] Rectangle withSize (ValueType newWidth, ValueType newHeight) const noexcept      { return { pos.x, pos.y, jmax (ValueType(), newWidth), jmax (ValueType(), newHeight) }; }
 
    [[nodiscard]] Rectangle withSizeKeepingCentre (ValueType newWidth, ValueType newHeight) const noexcept { return { pos.x + (w - newWidth)  / (ValueType) 2,
                                                                                                                       pos.y + (h - newHeight) / (ValueType) 2, newWidth, newHeight }; }
 
    void setLeft (ValueType newLeft) noexcept                   { w = jmax (ValueType(), pos.x + w - newLeft); pos.x = newLeft; }
 
    [[nodiscard]] Rectangle withLeft (ValueType newLeft) const noexcept       { return { newLeft, pos.y, jmax (ValueType(), pos.x + w - newLeft), h }; }
 
    void setTop (ValueType newTop) noexcept                     { h = jmax (ValueType(), pos.y + h - newTop); pos.y = newTop; }
 
    [[nodiscard]] Rectangle withTop (ValueType newTop) const noexcept         { return { pos.x, newTop, w, jmax (ValueType(), pos.y + h - newTop) }; }
 
    void setRight (ValueType newRight) noexcept                 { pos.x = jmin (pos.x, newRight); w = newRight - pos.x; }
 
    [[nodiscard]] Rectangle withRight (ValueType newRight) const noexcept     { return { jmin (pos.x, newRight), pos.y, jmax (ValueType(), newRight - pos.x), h }; }
 
    void setBottom (ValueType newBottom) noexcept               { pos.y = jmin (pos.y, newBottom); h = newBottom - pos.y; }
 
    [[nodiscard]] Rectangle withBottom (ValueType newBottom) const noexcept   { return { pos.x, jmin (pos.y, newBottom), w, jmax (ValueType(), newBottom - pos.y) }; }
 
    [[nodiscard]] Rectangle withTrimmedLeft (ValueType amountToRemove) const noexcept     { return withLeft (pos.x + amountToRemove); }
 
    [[nodiscard]] Rectangle withTrimmedRight (ValueType amountToRemove) const noexcept    { return withWidth (w - amountToRemove); }
 
    [[nodiscard]] Rectangle withTrimmedTop (ValueType amountToRemove) const noexcept      { return withTop (pos.y + amountToRemove); }
 
    [[nodiscard]] Rectangle withTrimmedBottom (ValueType amountToRemove) const noexcept   { return withHeight (h - amountToRemove); }
 
    //==============================================================================
    void translate (ValueType deltaX,
                    ValueType deltaY) noexcept
    {
        pos.x += deltaX;
        pos.y += deltaY;
    }
 
    [[nodiscard]] Rectangle translated (ValueType deltaX,
                                        ValueType deltaY) const noexcept
    {
        return { pos.x + deltaX, pos.y + deltaY, w, h };
    }
 
    Rectangle operator+ (Point<ValueType> deltaPosition) const noexcept
    {
        return { pos.x + deltaPosition.x, pos.y + deltaPosition.y, w, h };
    }
 
    Rectangle& operator+= (Point<ValueType> deltaPosition) noexcept
    {
        pos += deltaPosition;
        return *this;
    }
 
    Rectangle operator- (Point<ValueType> deltaPosition) const noexcept
    {
        return { pos.x - deltaPosition.x, pos.y - deltaPosition.y, w, h };
    }
 
    Rectangle& operator-= (Point<ValueType> deltaPosition) noexcept
    {
        pos -= deltaPosition;
        return *this;
    }
 
    template <typename FloatType>
    Rectangle operator* (FloatType scaleFactor) const noexcept
    {
        Rectangle r (*this);
        r *= scaleFactor;
        return r;
    }
 
    template <typename FloatType>
    Rectangle operator*= (FloatType scaleFactor) noexcept
    {
        Rectangle<FloatType> ((FloatType) pos.x * scaleFactor,
                              (FloatType) pos.y * scaleFactor,
                              (FloatType) w * scaleFactor,
                              (FloatType) h * scaleFactor).copyWithRounding (*this);
        return *this;
    }
 
    template <typename FloatType>
    Rectangle operator*= (Point<FloatType> scaleFactor) noexcept
    {
        Rectangle<FloatType> ((FloatType) pos.x * scaleFactor.x,
                              (FloatType) pos.y * scaleFactor.y,
                              (FloatType) w * scaleFactor.x,
                              (FloatType) h * scaleFactor.y).copyWithRounding (*this);
        return *this;
    }
 
    template <typename FloatType>
    Rectangle operator/ (FloatType scaleFactor) const noexcept
    {
        Rectangle r (*this);
        r /= scaleFactor;
        return r;
    }
 
    template <typename FloatType>
    Rectangle operator/= (FloatType scaleFactor) noexcept
    {
        Rectangle<FloatType> ((FloatType) pos.x / scaleFactor,
                              (FloatType) pos.y / scaleFactor,
                              (FloatType) w / scaleFactor,
                              (FloatType) h / scaleFactor).copyWithRounding (*this);
        return *this;
    }
 
    template <typename FloatType>
    Rectangle operator/= (Point<FloatType> scaleFactor) noexcept
    {
        Rectangle<FloatType> ((FloatType) pos.x / scaleFactor.x,
                              (FloatType) pos.y / scaleFactor.y,
                              (FloatType) w / scaleFactor.x,
                              (FloatType) h / scaleFactor.y).copyWithRounding (*this);
        return *this;
    }
 
    void expand (ValueType deltaX,
                 ValueType deltaY) noexcept
    {
        auto nw = jmax (ValueType(), w + deltaX * 2);
        auto nh = jmax (ValueType(), h + deltaY * 2);
        setBounds (pos.x - deltaX, pos.y - deltaY, nw, nh);
    }
 
    [[nodiscard]] Rectangle expanded (ValueType deltaX,
                                      ValueType deltaY) const noexcept
    {
        auto nw = jmax (ValueType(), w + deltaX * 2);
        auto nh = jmax (ValueType(), h + deltaY * 2);
        return { pos.x - deltaX, pos.y - deltaY, nw, nh };
    }
 
    [[nodiscard]] Rectangle expanded (ValueType delta) const noexcept
    {
        return expanded (delta, delta);
    }
 
    void reduce (ValueType deltaX,
                 ValueType deltaY) noexcept
    {
        expand (-deltaX, -deltaY);
    }
 
    [[nodiscard]] Rectangle reduced (ValueType deltaX,
                                     ValueType deltaY) const noexcept
    {
        return expanded (-deltaX, -deltaY);
    }
 
    [[nodiscard]] Rectangle reduced (ValueType delta) const noexcept
    {
        return reduced (delta, delta);
    }
 
    Rectangle removeFromTop (ValueType amountToRemove) noexcept
    {
        const Rectangle r (pos.x, pos.y, w, jmin (amountToRemove, h));
        pos.y += r.h; h -= r.h;
        return r;
    }
 
    Rectangle removeFromLeft (ValueType amountToRemove) noexcept
    {
        const Rectangle r (pos.x, pos.y, jmin (amountToRemove, w), h);
        pos.x += r.w; w -= r.w;
        return r;
    }
 
    Rectangle removeFromRight (ValueType amountToRemove) noexcept
    {
        amountToRemove = jmin (amountToRemove, w);
        const Rectangle r (pos.x + w - amountToRemove, pos.y, amountToRemove, h);
        w -= amountToRemove;
        return r;
    }
 
    Rectangle removeFromBottom (ValueType amountToRemove) noexcept
    {
        amountToRemove = jmin (amountToRemove, h);
        const Rectangle r (pos.x, pos.y + h - amountToRemove, w, amountToRemove);
        h -= amountToRemove;
        return r;
    }
 
    //==============================================================================
    Point<ValueType> getConstrainedPoint (Point<ValueType> point) const noexcept
    {
        return { jlimit (pos.x, pos.x + w, point.x),
                 jlimit (pos.y, pos.y + h, point.y) };
    }
 
    template <typename FloatType>
    Point<ValueType> getRelativePoint (FloatType relativeX, FloatType relativeY) const noexcept
    {
        return { pos.x + static_cast<ValueType> ((FloatType) w * relativeX),
                 pos.y + static_cast<ValueType> ((FloatType) h * relativeY) };
    }
 
    template <typename FloatType>
    ValueType proportionOfWidth (FloatType proportion) const noexcept
    {
        return static_cast<ValueType> ((FloatType) w * proportion);
    }
 
    template <typename FloatType>
    ValueType proportionOfHeight (FloatType proportion) const noexcept
    {
        return static_cast<ValueType> ((FloatType) h * proportion);
    }
 
    template <typename FloatType>
    Rectangle getProportion (Rectangle<FloatType> proportionalRect) const noexcept
    {
        return { pos.x + static_cast<ValueType> (w * proportionalRect.pos.x),
                 pos.y + static_cast<ValueType> (h * proportionalRect.pos.y),
                 proportionOfWidth  (proportionalRect.w),
                 proportionOfHeight (proportionalRect.h) };
    }
 
    //==============================================================================
    bool operator== (const Rectangle& other) const noexcept
    {
        const auto tie = [] (const Rectangle& r) { return std::tie (r.pos, r.w, r.h); };
        return tie (*this) == tie (other);
    }
 
    bool operator!= (const Rectangle& other) const noexcept     { return ! operator== (other); }
 
    bool contains (ValueType xCoord, ValueType yCoord) const noexcept
    {
        return xCoord >= pos.x && yCoord >= pos.y && xCoord < pos.x + w && yCoord < pos.y + h;
    }
 
    bool contains (Point<ValueType> point) const noexcept
    {
        return point.x >= pos.x && point.y >= pos.y && point.x < pos.x + w && point.y < pos.y + h;
    }
 
    bool contains (Rectangle other) const noexcept
    {
        return pos.x <= other.pos.x && pos.y <= other.pos.y
            && pos.x + w >= other.pos.x + other.w && pos.y + h >= other.pos.y + other.h;
    }
 
    bool intersects (Rectangle other) const noexcept
    {
        return pos.x + w > other.pos.x
            && pos.y + h > other.pos.y
            && pos.x < other.pos.x + other.w
            && pos.y < other.pos.y + other.h
            && w > ValueType() && h > ValueType()
            && other.w > ValueType() && other.h > ValueType();
    }
 
    bool intersects (const Line<ValueType>& line) const noexcept
    {
        return contains (line.getStart()) || contains (line.getEnd())
                || line.intersects (Line<ValueType> (getTopLeft(),     getTopRight()))
                || line.intersects (Line<ValueType> (getTopRight(),    getBottomRight()))
                || line.intersects (Line<ValueType> (getBottomRight(), getBottomLeft()))
                || line.intersects (Line<ValueType> (getBottomLeft(),  getTopLeft()));
    }
 
    Rectangle getIntersection (Rectangle other) const noexcept
    {
        auto nx = jmax (pos.x, other.pos.x);
        auto ny = jmax (pos.y, other.pos.y);
        auto nw = jmin (pos.x + w, other.pos.x + other.w) - nx;
 
        if (nw >= ValueType())
        {
            auto nh = jmin (pos.y + h, other.pos.y + other.h) - ny;
 
            if (nh >= ValueType())
                return { nx, ny, nw, nh };
        }
 
        return {};
    }
 
    bool intersectRectangle (ValueType& otherX, ValueType& otherY, ValueType& otherW, ValueType& otherH) const noexcept
    {
        auto maxX = jmax (otherX, pos.x);
        otherW = jmin (otherX + otherW, pos.x + w) - maxX;
 
        if (otherW > ValueType())
        {
            auto maxY = jmax (otherY, pos.y);
            otherH = jmin (otherY + otherH, pos.y + h) - maxY;
 
            if (otherH > ValueType())
            {
                otherX = maxX; otherY = maxY;
                return true;
            }
        }
 
        return false;
    }
 
    bool intersectRectangle (Rectangle<ValueType>& rectangleToClip) const noexcept
    {
        return intersectRectangle (rectangleToClip.pos.x, rectangleToClip.pos.y,
                                   rectangleToClip.w,     rectangleToClip.h);
    }
 
    Rectangle getUnion (Rectangle other) const noexcept
    {
        if (other.isEmpty())  return *this;
        if (isEmpty())        return other;
 
        auto newX = jmin (pos.x, other.pos.x);
        auto newY = jmin (pos.y, other.pos.y);
 
        return { newX, newY,
                 jmax (pos.x + w, other.pos.x + other.w) - newX,
                 jmax (pos.y + h, other.pos.y + other.h) - newY };
    }
 
    bool enlargeIfAdjacent (Rectangle other) noexcept
    {
        if (exactlyEqual (pos.x, other.pos.x) && exactlyEqual (getRight(), other.getRight())
             && (other.getBottom() >= pos.y && other.pos.y <= getBottom()))
        {
            auto newY = jmin (pos.y, other.pos.y);
            h = jmax (getBottom(), other.getBottom()) - newY;
            pos.y = newY;
            return true;
        }
 
        if (exactlyEqual (pos.y, other.pos.y) && exactlyEqual (getBottom(), other.getBottom())
             && (other.getRight() >= pos.x && other.pos.x <= getRight()))
        {
            auto newX = jmin (pos.x, other.pos.x);
            w = jmax (getRight(), other.getRight()) - newX;
            pos.x = newX;
            return true;
        }
 
        return false;
    }
 
    bool reduceIfPartlyContainedIn (Rectangle other) noexcept
    {
        int inside = 0;
        auto otherR = other.getRight();
        if (pos.x >= other.pos.x && pos.x < otherR) inside = 1;
        auto otherB = other.getBottom();
        if (pos.y >= other.pos.y && pos.y < otherB) inside |= 2;
        auto r = pos.x + w;
        if (r >= other.pos.x && r < otherR) inside |= 4;
        auto b = pos.y + h;
        if (b >= other.pos.y && b < otherB) inside |= 8;
 
        switch (inside)
        {
            case 1 + 2 + 8:  w = r - otherR; pos.x = otherR; return true;
            case 1 + 2 + 4:  h = b - otherB; pos.y = otherB; return true;
            case 2 + 4 + 8:  w = other.pos.x - pos.x;        return true;
            case 1 + 4 + 8:  h = other.pos.y - pos.y;        return true;
            default:         break;
        }
 
        return false;
    }
 
    Rectangle constrainedWithin (Rectangle areaToFitWithin) const noexcept
    {
        auto newPos = areaToFitWithin.withSize (areaToFitWithin.getWidth() - w,
                                                areaToFitWithin.getHeight() - h)
                        .getConstrainedPoint (pos);
 
        return { newPos.x, newPos.y,
                 jmin (w, areaToFitWithin.getWidth()),
                 jmin (h, areaToFitWithin.getHeight()) };
    }
 
    [[nodiscard]] Rectangle transformedBy (const AffineTransform& transform) const noexcept
    {
        using FloatType = TypeHelpers::SmallestFloatType<ValueType>;
 
        auto x1 = static_cast<FloatType> (pos.x),     y1 = static_cast<FloatType> (pos.y);
        auto x2 = static_cast<FloatType> (pos.x + w), y2 = static_cast<FloatType> (pos.y);
        auto x3 = static_cast<FloatType> (pos.x),     y3 = static_cast<FloatType> (pos.y + h);
        auto x4 = static_cast<FloatType> (x2),        y4 = static_cast<FloatType> (y3);
 
        transform.transformPoints (x1, y1, x2, y2);
        transform.transformPoints (x3, y3, x4, y4);
 
        auto rx1 = jmin (x1, x2, x3, x4);
        auto rx2 = jmax (x1, x2, x3, x4);
        auto ry1 = jmin (y1, y2, y3, y4);
        auto ry2 = jmax (y1, y2, y3, y4);
 
        Rectangle r;
        Rectangle<FloatType> (rx1, ry1, rx2 - rx1, ry2 - ry1).copyWithRounding (r);
        return r;
    }
 
    Rectangle<int> getSmallestIntegerContainer() const noexcept
    {
        return Rectangle<int>::leftTopRightBottom (detail::floorAsInt (pos.x),
                                                   detail::floorAsInt (pos.y),
                                                   detail::ceilAsInt  (pos.x + w),
                                                   detail::ceilAsInt  (pos.y + h));
    }
 
    Rectangle<int> toNearestInt() const noexcept
    {
        return { roundToInt (pos.x), roundToInt (pos.y),
                 roundToInt (w),     roundToInt (h) };
    }
 
    Rectangle<int> toNearestIntEdges() const noexcept
    {
        return Rectangle<int>::leftTopRightBottom (roundToInt (pos.x),       roundToInt (pos.y),
                                                   roundToInt (getRight()),  roundToInt (getBottom()));
    }
 
    Rectangle<float> toFloat() const noexcept
    {
        return { static_cast<float> (pos.x), static_cast<float> (pos.y),
                 static_cast<float> (w),     static_cast<float> (h) };
    }
 
    Rectangle<double> toDouble() const noexcept
    {
        return { static_cast<double> (pos.x), static_cast<double> (pos.y),
                 static_cast<double> (w),     static_cast<double> (h) };
    }
 
    template <typename TargetType>
    Rectangle<TargetType> toType() const noexcept
    {
        Rectangle<TargetType> r;
        copyWithRounding (r);
        return r;
    }
 
    static Rectangle findAreaContainingPoints (const Point<ValueType>* points, int numPoints) noexcept
    {
        if (numPoints <= 0)
            return {};
 
        auto minX = points[0].x;
        auto maxX = minX;
        auto minY = points[0].y;
        auto maxY = minY;
 
        for (int i = 1; i < numPoints; ++i)
        {
            minX = jmin (minX, points[i].x);
            maxX = jmax (maxX, points[i].x);
            minY = jmin (minY, points[i].y);
            maxY = jmax (maxY, points[i].y);
        }
 
        return { minX, minY, maxX - minX, maxY - minY };
    }
 
    //==============================================================================
    static bool intersectRectangles (ValueType& x1, ValueType& y1, ValueType& w1, ValueType& h1,
                                     ValueType  x2, ValueType  y2, ValueType  w2, ValueType  h2) noexcept
    {
        auto x = jmax (x1, x2);
        w1 = jmin (x1 + w1, x2 + w2) - x;
 
        if (w1 > ValueType())
        {
            auto y = jmax (y1, y2);
            h1 = jmin (y1 + h1, y2 + h2) - y;
 
            if (h1 > ValueType())
            {
                x1 = x; y1 = y;
                return true;
            }
        }
 
        return false;
    }
 
    //==============================================================================
    String toString() const
    {
        String s;
        s.preallocateBytes (32);
        s << pos.x << ' ' << pos.y << ' ' << w << ' ' << h;
        return s;
    }
 
    static Rectangle fromString (StringRef stringVersion)
    {
        StringArray toks;
        toks.addTokens (stringVersion.text.findEndOfWhitespace(), ",; \t\r\n", "");
 
        return { detail::parseAfterSpace<ValueType> (toks[0]),
                 detail::parseAfterSpace<ValueType> (toks[1]),
                 detail::parseAfterSpace<ValueType> (toks[2]),
                 detail::parseAfterSpace<ValueType> (toks[3]) };
    }
 
   #ifndef DOXYGEN
    [[deprecated ("This has been renamed to transformedBy in order to match the method names used in the Point class.")]]
    Rectangle transformed (const AffineTransform& t) const noexcept { return transformedBy (t); }
   #endif
 
private:
    template <typename OtherType> friend class Rectangle;
 
    Point<ValueType> pos;
    ValueType w {}, h {};
 
    void copyWithRounding (Rectangle<int>&    result) const noexcept { result = getSmallestIntegerContainer(); }
    void copyWithRounding (Rectangle<float>&  result) const noexcept { result = toFloat(); }
    void copyWithRounding (Rectangle<double>& result) const noexcept { result = toDouble(); }
};
 
} // namespace juce