Eclipse Remote Application Platform

## org.eclipse.swt.graphics
Class Rectangle

    java.lang.Object
      org.eclipse.swt.graphics.Rectangle

    public final class Rectangle

extends java.lang.Object

Instances of this class represent rectangular areas in an (x, y) coordinate system. The top left corner of the rectangle is specified by its x and y values, and the extent of the rectangle is specified by its width and height.

The coordinate space for rectangles and points is considered to have increasing values downward and to the right from its origin making this the normal, computer graphics oriented notion of (x, y) coordinates rather than the strict mathematical one.

The hashCode() method in this class uses the values of the public fields to compute the hash value. When storing instances of the class in hashed collections, do not modify these fields after the object has been inserted.

Application code does not need to explicitly release the resources managed by each instance when those instances are no longer required, and thus no `dispose()` method is provided.

Since:
  1.0
See Also:
  `Point`

Field Summary
`int` `height` the height of the rectangle
`int` `width` the width of the rectangle
`int` `x` the x coordinate of the rectangle
`int` `y` the y coordinate of the rectangle

Constructor Summary
`Rectangle(int x, int y, int width, int height)` Construct a new instance of this class given the x, y, width and height values.

Method Summary
`void` `add(Rectangle rect)` Destructively replaces the x, y, width and height values in the receiver with ones which represent the union of the rectangles specified by the receiver and the given rectangle.
`boolean` `contains(int x, int y)` Returns `true` if the point specified by the arguments is inside the area specified by the receiver, and `false` otherwise.
`boolean` `contains(Point pt)` Returns `true` if the given point is inside the area specified by the receiver, and `false` otherwise.
`boolean` `equals(java.lang.Object object)` Compares the argument to the receiver, and returns true if they represent the same object using a class specific comparison.
`int` `hashCode()` Returns an integer hash code for the receiver.
`void` `intersect(Rectangle rect)` Destructively replaces the x, y, width and height values in the receiver with ones which represent the intersection of the rectangles specified by the receiver and the given rectangle.
`Rectangle` `intersection(Rectangle rect)` Returns a new rectangle which represents the intersection of the receiver and the given rectangle.
`boolean` `intersects(int x, int y, int width, int height)` Returns `true` if the rectangle described by the arguments intersects with the receiver and `false` otherwise.
`boolean` `intersects(Rectangle rect)` Returns `true` if the given rectangle intersects with the receiver and `false` otherwise.
`boolean` `isEmpty()` Returns `true` if the receiver does not cover any area in the (x, y) coordinate plane, and `false` if the receiver does cover some area in the plane.
`java.lang.String` `toString()` Returns a string containing a concise, human-readable description of the receiver.
`Rectangle` `union(Rectangle rect)` Returns a new rectangle which represents the union of the receiver and the given rectangle.

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Field Detail

### x

    public int x

  the x coordinate of the rectangle

### y

    public int y

  the y coordinate of the rectangle

### width

    public int width

  the width of the rectangle

### height

    public int height

  the height of the rectangle

Constructor Detail

### Rectangle

    public Rectangle(int x,
                     int y,
                     int width,
                     int height)

  Construct a new instance of this class given the x, y, width and height values.

  Parameters:
    `x` - the x coordinate of the origin of the rectangle
    `y` - the y coordinate of the origin of the rectangle
    `width` - the width of the rectangle
    `height` - the height of the rectangle

Method Detail

### add

    public void add(Rectangle rect)

  Destructively replaces the x, y, width and height values in the receiver with ones which represent the union of the rectangles specified by the receiver and the given rectangle.

  The union of two rectangles is the smallest single rectangle that completely covers both of the areas covered by the two given rectangles.

  Parameters:
    `rect` - the rectangle to merge with the receiver
  Throws:
    `java.lang.IllegalArgumentException` -
    - ERROR_NULL_ARGUMENT - if the argument is null

### contains

    public boolean contains(int x,
                            int y)

  Returns `true` if the point specified by the arguments is inside the area specified by the receiver, and `false` otherwise.

  Parameters:
    `x` - the x coordinate of the point to test for containment
    `y` - the y coordinate of the point to test for containment
  Returns:
    `true` if the rectangle contains the point and `false` otherwise

### contains

    public boolean contains(Point pt)

  Returns `true` if the given point is inside the area specified by the receiver, and `false` otherwise.

  Parameters:
    `pt` - the point to test for containment
  Returns:
    `true` if the rectangle contains the point and `false` otherwise
  Throws:
    `java.lang.IllegalArgumentException` -
    - ERROR_NULL_ARGUMENT - if the argument is null

### equals

    public boolean equals(java.lang.Object object)

  Compares the argument to the receiver, and returns true if they represent the same object using a class specific comparison.

  Overrides:
    `equals` in class `java.lang.Object`
  Parameters:
    `object` - the object to compare with this object
  Returns:
    `true` if the object is the same as this object and `false` otherwise
  See Also:
    `hashCode()`

### hashCode

    public int hashCode()

  Returns an integer hash code for the receiver. Any two objects that return `true` when passed to `equals` must return the same value for this method.

  Overrides:
    `hashCode` in class `java.lang.Object`
  Returns:
    the receiver's hash
  See Also:
    `equals(Object)`

### intersect

    public void intersect(Rectangle rect)

  Destructively replaces the x, y, width and height values in the receiver with ones which represent the intersection of the rectangles specified by the receiver and the given rectangle.

  Parameters:
    `rect` - the rectangle to intersect with the receiver
  Throws:
    `java.lang.IllegalArgumentException` -
    - ERROR_NULL_ARGUMENT - if the argument is null
    since 3.0

### intersection

    public Rectangle intersection(Rectangle rect)

  Returns a new rectangle which represents the intersection of the receiver and the given rectangle.

  The intersection of two rectangles is the rectangle that covers the area which is contained within both rectangles.

  Parameters:
    `rect` - the rectangle to intersect with the receiver
  Returns:
    the intersection of the receiver and the argument
  Throws:
    `java.lang.IllegalArgumentException` -
    - ERROR_NULL_ARGUMENT - if the argument is null

### intersects

    public boolean intersects(int x,
                              int y,
                              int width,
                              int height)

  Returns `true` if the rectangle described by the arguments intersects with the receiver and `false` otherwise.

  Two rectangles intersect if the area of the rectangle representing their intersection is not empty.

  Parameters:
    `x` - the x coordinate of the origin of the rectangle
    `y` - the y coordinate of the origin of the rectangle
    `width` - the width of the rectangle
    `height` - the height of the rectangle
  Returns:
    `true` if the rectangle intersects with the receiver, and `false` otherwise
  Throws:
    `java.lang.IllegalArgumentException` -
    - ERROR_NULL_ARGUMENT - if the argument is null
  Since:
    1.0
  See Also:
    `intersection(Rectangle)`, `isEmpty()`

### intersects

    public boolean intersects(Rectangle rect)

  Returns `true` if the given rectangle intersects with the receiver and `false` otherwise.

  Two rectangles intersect if the area of the rectangle representing their intersection is not empty.

  Parameters:
    `rect` - the rectangle to test for intersection
  Returns:
    `true` if the rectangle intersects with the receiver, and `false` otherwise
  Throws:
    `java.lang.IllegalArgumentException` -
    - ERROR_NULL_ARGUMENT - if the argument is null
  See Also:
    `intersection(Rectangle)`, `isEmpty()`

### isEmpty

    public boolean isEmpty()

  Returns `true` if the receiver does not cover any area in the (x, y) coordinate plane, and `false` if the receiver does cover some area in the plane.

  A rectangle is considered to cover area in the (x, y) coordinate plane if both its width and height are non-zero.

  Returns:
    `true` if the receiver is empty, and `false` otherwise

### toString

    public java.lang.String toString()

  Returns a string containing a concise, human-readable description of the receiver.

  Overrides:
    `toString` in class `java.lang.Object`
  Returns:
    a string representation of the rectangle

### union

    public Rectangle union(Rectangle rect)

  Returns a new rectangle which represents the union of the receiver and the given rectangle.

  The union of two rectangles is the smallest single rectangle that completely covers both of the areas covered by the two given rectangles.

  Parameters:
    `rect` - the rectangle to perform union with
  Returns:
    the union of the receiver and the argument
  Throws:
    `java.lang.IllegalArgumentException` -
    - ERROR_NULL_ARGUMENT - if the argument is null
  See Also:
    `add(Rectangle)`

Eclipse Remote Application Platform

Copyright (c) EclipseSource and others 2002, 2014. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0