rectangle.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 701 行 · 第 1/2 页

	 * @since 1.1
	 */
	public void setLocation(int x, int y) {
		this.x = x;
		this.y = y;
	}

	/**
	 * Moves the location of this rectangle by setting its upper left
	 * corner to the specified coordinates.
	 *
	 * @param x the new X coordinate for this rectangle
	 * @param y the new Y coordinate for this rectangle
	 * @deprecated use {@link #setLocation(int, int)} instead
	 */
	public void move(int x, int y) {
		setLocation(x, y);
	}

	/**
	 * Translate the location of this rectangle by the given amounts.
	 *
	 * @param dx the x distance to move by
	 * @param dy the y distance to move by
	 * @see #setLocation(int, int)
	 */
	public void translate(int dx, int dy) {
		x += dx;
		y += dy;
	}

	/**
	 * Returns the size of this rectangle.
	 *
	 * @return the size of this rectangle
	 * @see #setSize(Dimension)
	 * @since 1.1
	 */
	public Dimension getSize() {
		return new Dimension(width, height);
	}

	/**
	 * Sets the size of this rectangle based on the specified dimensions.
	 *
	 * @param d the new dimensions of the rectangle
	 * @throws NullPointerException if d is null
	 * @see #getSize()
	 * @since 1.1
	 */
	public void setSize(Dimension d) {
		width = d.width;
		height = d.height;
	}

	/**
	 * Sets the size of this rectangle based on the specified dimensions.
	 *
	 * @param width the new width of the rectangle
	 * @param height the new height of the rectangle
	 * @since 1.1
	 */
	public void setSize(int width, int height) {
		this.width = width;
		this.height = height;
	}

	/**
	 * Sets the size of this rectangle based on the specified dimensions.
	 *
	 * @param width the new width of the rectangle
	 * @param height the new height of the rectangle
	 * @deprecated use {@link #setSize(int, int)} instead
	 */
	public void resize(int width, int height) {
		setSize(width, height);
	}

	/**
	 * Tests whether or not the specified point is inside this rectangle.
	 * According to the contract of Shape, a point on the border is in only if
	 * it has an adjacent point inside the rectangle in either the increasing
	 * x or y direction.
	 *
	 * @param p the point to test
	 * @return true if the point is inside the rectangle
	 * @throws NullPointerException if p is null
	 * @see #contains(int, int)
	 * @since 1.1
	 */
	public boolean contains(Point p) {
		return width > 0 && height > 0 && p.x >= x && p.x < x + width && p.y >= y && p.y < y + height;
	}

	/**
	 * Tests whether or not the specified point is inside this rectangle.
	 * According to the contract of Shape, a point on the border is in only if
	 * it has an adjacent point inside the rectangle in either the increasing
	 * x or y direction.
	 *
	 * @param x the X coordinate of the point to test
	 * @param y the Y coordinate of the point to test
	 * @return true if the point is inside the rectangle
	 * @since 1.1
	 */
	public boolean contains(int x, int y) {
		return width > 0 && height > 0 && x >= this.x && x < this.x + width && y >= this.y && y < this.y + height;
	}

	/**
	 * Checks whether all points in the given rectangle are contained in this
	 * rectangle.
	 *
	 * @param r the rectangle to check
	 * @return true if r is contained in this rectangle
	 * @throws NullPointerException if r is null
	 * @see #contains(int, int, int, int)
	 * @since 1.1
	 */
	public boolean contains(Rectangle r) {
		return width > 0 && height > 0 && r.width > 0 && r.height > 0 && r.x >= x && r.x + r.width <= x + width && r.y >= y && r.y + r.height <= y + height;
	}

	/**
	 * Checks whether all points in the given rectangle are contained in this
	 * rectangle.
	 *
	 * @param x the x coordinate of the rectangle to check
	 * @param y the y coordinate of the rectangle to check
	 * @param w the width of the rectangle to check
	 * @param h the height of the rectangle to check
	 * @return true if the parameters are contained in this rectangle
	 * @since 1.1
	 */
	public boolean contains(int x, int y, int w, int h) {
		return width > 0 && height > 0 && w > 0 && h > 0 && x >= this.x && x + w <= this.x + this.width && y >= this.y && y + h <= this.y + this.height;
	}

	/**
	 * Tests whether or not the specified point is inside this rectangle.
	 *
	 * @param x the X coordinate of the point to test
	 * @param y the Y coordinate of the point to test
	 * @return true if the point is inside the rectangle
	 * @deprecated use {@link #contains(int, int)} instead
	 */
	public boolean inside(int x, int y) {
		return contains(x, y);
	}

	/**
	 * Tests whether or not the specified rectangle intersects this rectangle.
	 * This means the two rectangles share at least one internal point.
	 *
	 * @param r the rectangle to test against
	 * @return true if the specified rectangle intersects this one
	 * @throws NullPointerException if r is null
	 * @since 1.2
	 */
	public boolean intersects(Rectangle r) {
		return width > 0 && height > 0 && r.width > 0 && r.height > 0 && r.x < x + width && r.x + r.width > x && r.y < y + height && r.y + r.height > y;
	}

	/**
	 * Determines the rectangle which is formed by the intersection of this
	 * rectangle with the specified rectangle. If the two do not intersect,
	 * an empty rectangle will be returned (meaning the width and/or height
	 * will be non-positive).
	 *
	 * @param r the rectange to calculate the intersection with
	 * @return a new rectangle bounding the intersection
	 * @throws NullPointerException if r is null
	 */
	public Rectangle intersection(Rectangle r) {
		Rectangle res = new Rectangle();
		intersect(this, r, res);
		return res;
	}

	/**
	 * Returns the smallest rectangle that contains both this rectangle
	 * and the specified rectangle.
	 *
	 * @param r the rectangle to compute the union with
	 * @return the smallest rectangle containing both rectangles
	 * @throws NullPointerException if r is null
	 */
	public Rectangle union(Rectangle r) {
		Rectangle res = new Rectangle();
		union(this, r, res);
		return res;
	}

	/**
	 * Modifies this rectangle so that it represents the smallest rectangle
	 * that contains both the existing rectangle and the specified point.
	 * However, if the point falls on one of the two borders which are not
	 * inside the rectangle, a subsequent call to <code>contains</code> may
	 * return false.
	 *
	 * @param x the X coordinate of the point to add to this rectangle
	 * @param y the Y coordinate of the point to add to this rectangle
	 */
	public void add(int x, int y) {
		add((double) x, (double) y);
	}

	/**
	 * Modifies this rectangle so that it represents the smallest rectangle
	 * that contains both the existing rectangle and the specified point.
	 * However, if the point falls on one of the two borders which are not
	 * inside the rectangle, a subsequent call to <code>contains</code> may
	 * return false.
	 *
	 * @param p the point to add to this rectangle
	 * @throws NullPointerException if p is null
	 */
	public void add(Point p) {
		add((double) p.x, (double) p.y);
	}

	/**
	 * Modifies this rectangle so that it represents the smallest rectangle
	 * that contains both the existing rectangle and the specified rectangle.
	 *
	 * @param r the rectangle to add to this rectangle
	 * @throws NullPointerException if r is null
	 * @see #union(Rectangle)
	 */
	public void add(Rectangle r) {
		union(this, r, this);
	}

	/**
	 * Expands the rectangle by the specified amount.  The horizontal
	 * and vertical expansion values are applied both to the X,Y coordinate
	 * of this rectangle, and its width and height.  Thus the width and
	 * height will increase by 2h and 2v accordingly.
	 *
	 * @param h the horizontal expansion value
	 * @param v the vertical expansion value
	 */
	public void grow(int h, int v) {
		x -= h;
		y -= v;
		width += h + h;
		height += v + v;
	}

	/**
	 * Tests whether or not this rectangle is empty.  An empty rectangle
	 * has a non-positive width or height.
	 *
	 * @return true if the rectangle is empty
	 */
	public boolean isEmpty() {
		return width <= 0 || height <= 0;
	}

	/**
	 * Determine where the point lies with respect to this rectangle. The
	 * result will be the binary OR of the appropriate bit masks.
	 *
	 * @param x the x coordinate to check
	 * @param y the y coordinate to check
	 * @return the binary OR of the result
	 * @see #OUT_LEFT
	 * @see #OUT_TOP
	 * @see #OUT_RIGHT
	 * @see #OUT_BOTTOM
	 * @since 1.2
	 */
	public int outcode(double x, double y) {
		int result = 0;
		if (width <= 0)
			result |= OUT_LEFT | OUT_RIGHT;
		else if (x < this.x)
			result |= OUT_LEFT;
		else if (x > this.x + width)
			result |= OUT_RIGHT;
		if (height <= 0)
			result |= OUT_BOTTOM | OUT_TOP;
		else if (y < this.y) // Remember that +y heads top-to-bottom.
			result |= OUT_TOP;
		else if (y > this.y + height)
			result |= OUT_BOTTOM;
		return result;
	}

	/**
	 * Determines the rectangle which is formed by the intersection of this
	 * rectangle with the specified rectangle. If the two do not intersect,
	 * an empty rectangle will be returned (meaning the width and/or height
	 * will be non-positive).
	 *
	 * @param r the rectange to calculate the intersection with
	 * @return a new rectangle bounding the intersection
	 * @throws NullPointerException if r is null
	 * @since 1.2
	 */
	public Rectangle2D createIntersection(Rectangle2D r) {
		// Favor runtime type of other rectangle.
		Rectangle2D res = r.getBounds2D();
		intersect(this, r, res);
		return res;
	}

	/**
	 * Returns the smallest rectangle that contains both this rectangle
	 * and the specified rectangle.
	 *
	 * @param r the rectangle to compute the union with
	 * @return the smallest rectangle containing both rectangles
	 * @throws NullPointerException if r is null
	 * @since 1.2
	 */
	public Rectangle2D createUnion(Rectangle2D r) {
		// Favor runtime type of other rectangle.
		Rectangle2D res = r.getBounds2D();
		union(this, r, res);
		return res;
	}

	/**
	 * Tests this rectangle for equality against the specified object.  This
	 * will be true if an only if the specified object is an instance of
	 * Rectangle2D with the same coordinates and dimensions.
	 *
	 * @param obj the object to test against for equality
	 * @return true if the specified object is equal to this one
	 */
	public boolean equals(Object obj) {
		if (!(obj instanceof Rectangle2D))
			return false;
		Rectangle2D r = (Rectangle2D) obj;
		return r.getX() == x && r.getY() == y && r.getWidth() == width && r.getHeight() == height;
	}

	/**
	 * Returns a string representation of this rectangle. This is in the form
	 * <code>getClass().getName() + "[x=" + x + ",y=" + y + ",width=" + width
	 * + ",height=" + height + ']'</code>.
	 *
	 * @return a string representation of this rectangle
	 */
	public String toString() {
		return getClass().getName() + "[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + ']';
	}
} // class Rectangle