Module org.controlsfx.controls
Package impl.org.controlsfx.tools.rectangle

Class Rectangles2D

java.lang.Object
impl.org.controlsfx.tools.rectangle.Rectangles2D
public class Rectangles2D extends Object
Usability methods for rectangles.

  • Constructor Details

    • Rectangles2D

      public Rectangles2D()

  • Method Details

    • contains

      public static boolean contains(Rectangle2D rectangle, Edge2D edge)
      Indicates whether the specified rectangle contains the specified edge.
      Parameters:
      rectangle - the rectangle to check
      edge - the edge to check
      Returns:
      true if both end points of the edge are contained in the rectangle

    • inRectangle

      public static Point2D inRectangle(Rectangle2D rectangle, Point2D point)
      Moves the specified point into the specified rectangle. If the point is already with the rectangle, it is returned. Otherwise the point in the rectangle which is closest to the specified one is returned.
      Parameters:
      rectangle - the Rectangle2D into which the point should be moved
      point - the Point2D which is checked
      Returns:
      either the specified point or the Point2D which is closest to it while still being contained on the rectangle

    • getCenterPoint

      public static Point2D getCenterPoint(Rectangle2D rectangle)
      Returns the center of the specified rectangle as a point.
      Parameters:
      rectangle - the Rectangle2D whose center point will be returned
      Returns:
      the Point2D whose x/y coordinates lie at (min + max) / 2.

    • intersection

      public static Rectangle2D intersection(Rectangle2D a, Rectangle2D b)
      Returns the rectangle which represents the intersection of the two specified rectangles.
      Parameters:
      a - a Rectangle2D
      b - another Rectangle2D
      Returns:
      a Rectangle2D which is the intersection of a and b; possible Rectangle2D.EMPTY.

    • forDiagonalCorners

      public static Rectangle2D forDiagonalCorners(Point2D oneCorner, Point2D diagonalCorner)
      Creates a new rectangle with the two specified corners. The two corners will be interpreted as being diagonal of each other.
      Parameters:
      oneCorner - one corner
      diagonalCorner - another corner, diagonal from the first
      Returns:
      the Rectangle2D which is defined by the two corners

    • forUpperLeftCornerAndSize

      public static Rectangle2D forUpperLeftCornerAndSize(Point2D upperLeft, double width, double height)
      Creates a new rectangle with the specified upperLeft corner and the specified width and height.
      Parameters:
      upperLeft - one corner
      width - the new rectangle's width
      height - the new rectangle's height
      Returns:
      the Rectangle2D which is defined by the specified upper left corner and width and height

    • forDiagonalCornersAndRatio

      public static Rectangle2D forDiagonalCornersAndRatio(Point2D fixedCorner, Point2D diagonalCorner, double ratio)
      Creates a new rectangle with the two specified corners. The two corners will be interpreted as being diagonal of each other. The returned rectangle will have the specified fixedCorner as its corner. The other one will either be on the same x- or y-parallel as the diagonalCorner but will be such that the rectangle has the specified ratio.
      Parameters:
      fixedCorner - one corner
      diagonalCorner - another corner, diagonal from the first
      ratio - the ratio the returned rectangle must have; must be non-negative
      Returns:
      the Rectangle2D which is defined by the fixedCorner, the x- or y-parallel of the diagonalCorner and the ratio

    • forCenterAndSize

      public static Rectangle2D forCenterAndSize(Point2D centerPoint, double width, double height)
      Creates a new rectangle with the specified center and the specified width and height.
      Parameters:
      centerPoint - the center point o the new rectangle
      width - the width of the new rectangle
      height - the height of the new rectangle
      Returns:
      a rectangle with the specified center and size

    • fixRatio

      public static Rectangle2D fixRatio(Rectangle2D original, double ratio)
      Creates a new rectangle with the same center point and area as the specified original rectangle with the specified ratio.
      Parameters:
      original - the original rectangle
      ratio - the new ratio
      Returns:
      a new Rectangle2D with the same center point as the original and the specified ratio; it has the same area as the original
      Throws:
      NullPointerException - if the original rectangle is null

    • fixRatioWithinBounds

      public static Rectangle2D fixRatioWithinBounds(Rectangle2D original, double ratio, Rectangle2D bounds)
      Creates a new rectangle with the same center point and area (if possible) as the specified original rectangle with the specified ratio and respecting the specified bounds.
      Parameters:
      original - the original rectangle
      ratio - the new ratio
      bounds - the bounds within which the new rectangle will be located
      Returns:
      a new Rectangle2D with the same center point as the original and the specified ratio; it has the same area as the original unless this would violate the bounds; in this case it is as large as possible while still staying within the bounds
      Throws:
      NullPointerException - if the original or bounds rectangle is null
      IllegalArgumentException - if the original rectangle's center point is out of the bounds

    • forCenterAndAreaAndRatio

      public static Rectangle2D forCenterAndAreaAndRatio(Point2D centerPoint, double area, double ratio)
      Creates a new rectangle with the specified centerPoint, area and ratio.
      Parameters:
      centerPoint - the new rectangle's center point
      area - the new rectangle's area
      ratio - the new ratio
      Returns:
      a new Rectangle2D with the specified centerPoint, area and ratio
      Throws:
      IllegalArgumentException - if the centerPoint is out of the bounds

    • forCenterAndAreaAndRatioWithinBounds

      public static Rectangle2D forCenterAndAreaAndRatioWithinBounds(Point2D centerPoint, double area, double ratio, Rectangle2D bounds)
      Creates a new rectangle with the specified centerPoint, area (if possible) and ratio, respecting the specified bounds.
      Parameters:
      centerPoint - the new rectangle's center point
      area - the new rectangle's area (if possible without violating the bounds)
      ratio - the new ratio
      bounds - the bounds within which the new rectangle will be located
      Returns:
      a new Rectangle2D with the specified centerPoint and ratio; it has the specified area unless this would violate the bounds; in this case it is as large as possible while still staying within the bounds
      Throws:
      IllegalArgumentException - if the centerPoint is out of the bounds

    • forEdgeAndOpposingPoint

      public static Rectangle2D forEdgeAndOpposingPoint(Edge2D edge, Point2D point)
      Returns a rectangle that has the specified edge and has its opposing edge on the parallel axis defined by the specified point's X or Y coordinate (depending on the edge's orientation).
      Parameters:
      edge - the edge which will be contained in the returned rectangle
      point - the point whose X or Y coordinate defines the other edge
      Returns:
      a rectangle

    • forEdgeAndOpposingPointAndRatioWithinBounds

      public static Rectangle2D forEdgeAndOpposingPointAndRatioWithinBounds(Edge2D edge, Point2D point, double ratio, Rectangle2D bounds)
      Returns a rectangle that is principally defined by the specified edge and point. It should have the specified edge as one of its own and its parallel edge should contain the point. While this would already well-define the rectangle (compare forEdgeAndOpposingPoint) the additionally specified ratio and bounds have precedence over these arguments:
      The returned rectangle will have the ratio and will be within the bounds. If the bounds make it possible, the specified point will lie on the edge parallel to the specified one. In order to maintain the ratio, this will make it necessary to not use the specified edge but instead one with a different length. The new edge will have the same center point as the specified one.
      This results on the following behavior: As the point is moved closer to or further away from the edge, the resulting rectangle shrinks and grows while being anchored to the specified edge's center point and keeping the ratio. This is limited by the bounds.
      Parameters:
      edge - the edge which defines the center point and orientation of one of the rectangle's edges; must be within the specified bounds
      point - the point to which the rectangle spans if ratio and bounds allow it
      ratio - the ratio the new rectangle must have
      bounds - the bounds within which the new rectangle must lie
      Returns:
      a rectangle

    • fromBounds

      public static Rectangle2D fromBounds(Bounds bounds)
      Returns a rectangle with the same coordinates as the specified bounds.
      Parameters:
      bounds - the Bounds for which the rectangle will be created
      Returns:
      a Rectangle2D with the same minX-, minY-, maxX- and maxY-coordiantes as the specified bounds