home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / main.bin / Rectangle.java < prev    next >
Text File  |  1997-10-01  |  20KB  |  568 lines
  1. /*
  2.  * @(#)Rectangle.java    1.27 97/07/08
  3.  * 
  4.  * Copyright (c) 1995, 1996 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  * CopyrightVersion 1.1_beta
  20.  * 
  21.  */
  22.  
  23. package java.awt;
  24.  
  25. /**
  26.  * A rectangle specifies an area in a coordinate space that is 
  27.  * defined by the rectangle's top-left point (<i>x</i>, <i>y</i>) 
  28.  * in the coordinate space, its width, and its height. 
  29.  * <p>
  30.  * A rectangle's <code>width</code> and <code>height</code> are 
  31.  * public fields. The constructors that allow you to create a 
  32.  * rectangle, and the methods that allow you to modify one, do not 
  33.  * prevent you from setting a negative value for width or height. 
  34.  * <p>
  35.  * A rectangle whose width or height is negative is considered 
  36.  * empty, and all methods defined by the <code>Rectangle</code> class  
  37.  * behave accordingly. If the rectangle is empty, then the method 
  38.  * <code>isEmpty</code> returns <code>true</code>. No point can be 
  39.  * contained by or inside an empty rectangle, however the values of 
  40.  * <code>width</code> and <code>height</code> are still valid. An 
  41.  * empty rectangle still has a location in the coordinate space, and 
  42.  * methods that change its size or location remain valid. The 
  43.  * behavior of methods that operate on more than one rectangle is 
  44.  * undefined if any of the participating rectangles has a negative 
  45.  * <code>width</code> or <code>height</code>. These methods include 
  46.  * <code>intersects</code>, <code>intersection</code>, and 
  47.  * <code>union</code>. 
  48.  *
  49.  * @version     1.27, 07/08/97
  50.  * @author     Sami Shaio
  51.  * @since       JDK1.0
  52.  */
  53. public class Rectangle implements Shape, java.io.Serializable {
  54.  
  55.     /**
  56.      * The <i>x</i> coordinate of the rectangle.
  57.      * @since     JDK1.0
  58.      */
  59.     public int x;
  60.  
  61.     /**
  62.      * The <i>y</i> coordinate of the rectangle.
  63.      * @since     JDK1.0
  64.      */
  65.     public int y;
  66.  
  67.     /**
  68.      * The width of the rectangle.
  69.      * @since     JDK1.0.
  70.      */
  71.     public int width;
  72.  
  73.     /**
  74.      * The height of the rectangle.
  75.      * @since     JDK1.0
  76.      */
  77.     public int height;
  78.  
  79.     /*
  80.      * JDK 1.1 serialVersionUID 
  81.      */
  82.      private static final long serialVersionUID = -4345857070255674764L;
  83.  
  84.     /**
  85.      * Constructs a new rectangle whose top-left corner is at (0, 0) 
  86.      * in the coordinate space, and whose width and height are zero. 
  87.      * @since     JDK1.0
  88.      */
  89.     public Rectangle() {
  90.         this(0, 0, 0, 0);
  91.     }
  92.  
  93.     /**
  94.      * Constructs a new rectangle, initialized to match the values of
  95.      * the specificed rectangle.
  96.      * @param r  a rectangle from which to copy initial values.
  97.      * @since JDK1.1
  98.      */
  99.     public Rectangle(Rectangle r) {
  100.         this(r.x, r.y, r.width, r.height);
  101.     }
  102.  
  103.     /**
  104.      * Constructs a new rectangle whose top-left corner is specified as
  105.      * (<code>x</code>, <code>y</code>) and whose width and height 
  106.      * are specified by the arguments of the same name. 
  107.      * @param     x   the <i>x</i> coordinate.
  108.      * @param     y   the <i>y</i> coordinate.
  109.      * @param     width    the width of the rectangle.
  110.      * @param     height   the height of the rectangle.
  111.      * @since     JDK1.0
  112.      */
  113.     public Rectangle(int x, int y, int width, int height) {
  114.     this.x = x;
  115.     this.y = y;
  116.     this.width = width;
  117.     this.height = height;
  118.     }
  119.  
  120.     /**
  121.      * Constructs a new rectangle whose top-left corner is at (0, 0) 
  122.      * in the coordinate space, and whose width and height are specified 
  123.      * by the arguments of the same name. 
  124.      * @param     width    the width of the rectangle.
  125.      * @param     height   the height of the rectangle.
  126.      * @since     JDK1.0
  127.      */
  128.     public Rectangle(int width, int height) {
  129.     this(0, 0, width, height);
  130.     }
  131.  
  132.     /**
  133.      * Constructs a new rectangle whose top-left corner is specified 
  134.      * by the <code>point</code> argument, and whose width and height  
  135.      * are specified by the <code>dimension</code> argument. 
  136.      * @param     p   a point, the top-left corner of the rectangle.
  137.      * @param     d   a dimension, representing the width and height.
  138.      * @since     JDK1.0 
  139.      */
  140.     public Rectangle(Point p, Dimension d) {
  141.     this(p.x, p.y, d.width, d.height);
  142.     }
  143.     
  144.     /**
  145.      * Constructs a new rectangle whose top-left corner is the  
  146.      * specified point, and whose width and height are zero. 
  147.      * @param     p   the top left corner of the rectangle.
  148.      * @since     JDK1.0
  149.      */
  150.     public Rectangle(Point p) {
  151.     this(p.x, p.y, 0, 0);
  152.     }
  153.     
  154.     /**
  155.      * Constructs a new rectangle whose top left corner is  
  156.      * (0, 0) and whose width and height are specified  
  157.      * by the <code>dimension</code> argument. 
  158.      * @param     d   a dimension, specifying width and height.
  159.      * @since     JDK1.0
  160.      */
  161.     public Rectangle(Dimension d) {
  162.     this(0, 0, d.width, d.height);
  163.     }
  164.  
  165.     /**
  166.      * Gets the bounding rectangle of this rectangle.
  167.      * <p>
  168.      * This method is included for completeness, to parallel the
  169.      * <code>getBounds</code> method of <code>Component</code>.
  170.      * @return    a new rectangle, equal to the bounding rectangle 
  171.      *                for this rectangle.
  172.      * @see       java.awt.Component#getBounds
  173.      * @since     JDK1.1
  174.      */
  175.     public Rectangle getBounds() {
  176.     return new Rectangle(x, y, width, height);
  177.     }    
  178.  
  179.     /**
  180.      * Sets the bounding rectangle of this rectangle to match 
  181.      * the specified rectangle.
  182.      * <p>
  183.      * This method is included for completeness, to parallel the
  184.      * <code>setBounds</code> method of <code>Component</code>.
  185.      * @param     r   a rectangle.
  186.      * @see       java.awt.Component#setBounds(java.awt.Rectangle)
  187.      * @since     JDK1.1
  188.      */
  189.     public void setBounds(Rectangle r) {
  190.     setBounds(r.x, r.y, r.width, r.height);
  191.     }    
  192.  
  193.     /**
  194.      * Sets the bounding rectangle of this rectangle to the specified 
  195.      * values for <code>x</code>, <code>y</code>, <code>width</code>, 
  196.      * and <code>height</code>.
  197.      * <p>
  198.      * This method is included for completeness, to parallel the
  199.      * <code>setBounds</code> method of <code>Component</code>.
  200.      * @param     x       the new <i>x</i> coordinate for the top-left
  201.      *                    corner of this rectangle.
  202.      * @param     y       the new <i>y</i> coordinate for the top-left
  203.      *                    corner of this rectangle.
  204.      * @param     width   the new width for this rectangle.
  205.      * @param     height  the new height for this rectangle.
  206.      * @see       java.awt.Component#setBounds(int, int, int, int)
  207.      * @since     JDK1.1
  208.      */
  209.     public void setBounds(int x, int y, int width, int height) {
  210.         reshape(x, y, width, height);
  211.     }    
  212.  
  213.     /**
  214.      * @deprecated As of JDK version 1.1,
  215.      * replaced by <code>setBounds(int, int, int, int)</code>.
  216.      */
  217.     public void reshape(int x, int y, int width, int height) {
  218.     this.x = x;
  219.     this.y = y;
  220.     this.width = width;
  221.     this.height = height;
  222.     }    
  223.  
  224.     /**
  225.      * Returns the location of this rectangle.
  226.      * <p>
  227.      * This method is included for completeness, to parallel the
  228.      * <code>getLocation</code> method of <code>Component</code>.
  229.      * @see       java.awt.Component#getLocation
  230.      * @since     JDK1.1
  231.      */
  232.     public Point getLocation() {
  233.     return new Point(x, y);
  234.     }    
  235.  
  236.     /**
  237.      * Moves the rectangle to the specified location.
  238.      * <p>
  239.      * This method is included for completeness, to parallel the
  240.      * <code>setLocation</code> method of <code>Component</code>.
  241.      * @param     p  the new location for the point.
  242.      * @see       java.awt.Component#setLocation(java.awt.Point)
  243.      * @since     JDK1.1
  244.      */
  245.     public void setLocation(Point p) {
  246.     setLocation(p.x, p.y);
  247.     }    
  248.  
  249.     /**
  250.      * Moves the rectangle to the specified location.
  251.      * <p>
  252.      * This method is included for completeness, to parallel the
  253.      * <code>setLocation</code> method of <code>Component</code>.
  254.      * @param     x  the <i>x</i> coordinate of the new location.
  255.      * @param     y  the <i>y</i> coordinate of the new location.
  256.      * @see       java.awt.Component#setLocation(int, int)
  257.      * @since     JDK1.1
  258.      */
  259.     public void setLocation(int x, int y) {
  260.     move(x, y);
  261.     }    
  262.  
  263.     /**
  264.      * @deprecated As of JDK version 1.1,
  265.      * replaced by <code>setLocation(int, int)</code>.
  266.      */
  267.     public void move(int x, int y) {
  268.     this.x = x;
  269.     this.y = y;
  270.     }    
  271.  
  272.     /**
  273.      * Translates the rectangle the indicated distance,
  274.      * to the right along the <i>x</i> coordinate axis, and 
  275.      * downward along the <i>y</i> coordinate axis.
  276.      * @param     dx   the distance to move the rectangle 
  277.      *                 along the <i>x</i> axis.
  278.      * @param     dy   the distance to move the rectangle 
  279.      *                 along the <i>y</i> axis.
  280.      * @see       java.awt.Rectangle#setLocation(int, int)
  281.      * @see       java.awt.Rectangle#setLocation(java.awt.Point)
  282.      * @since     JDK1.0
  283.      */
  284.     public void translate(int x, int y) {
  285.     this.x += x;
  286.     this.y += y;
  287.     }    
  288.  
  289.     /**
  290.      * Gets the size (width and height) of this rectangle.
  291.      * <p>
  292.      * This method is included for completeness, to parallel the
  293.      * <code>getSize</code> method of <code>Component</code>.
  294.      * @return    a dimension, representing the size.
  295.      * @see       java.awt.Component#getSize
  296.      * @since     JDK1.1
  297.      */
  298.     public Dimension getSize() {
  299.     return new Dimension(width, height);
  300.     }    
  301.  
  302.     /**
  303.      * Sets the size of this rectangle to match the specified dimension.
  304.      * <p>
  305.      * This method is included for completeness, to parallel the
  306.      * <code>setSize</code> method of <code>Component</code>.
  307.      * @param d  the new size for the Dimension object
  308.      * @see       java.awt.Component#setSize(java.awt.Dimension)
  309.      * @since     JDK1.1
  310.      */
  311.     public void setSize(Dimension d) {
  312.     setSize(d.width, d.height);
  313.     }    
  314.  
  315.     /**
  316.      * Sets the size of this rectangle to the specified width and height.
  317.      * <p>
  318.      * This method is included for completeness, to parallel the
  319.      * <code>setSize</code> method of <code>Component</code>.
  320.      * @param     width    the new width for this rectangle object.
  321.      * @param     height   the new height for this rectangle object.
  322.      * @see       java.awt.Component#setSize(int, int)
  323.      * @since     JDK1.1
  324.      */
  325.     public void setSize(int width, int height) {
  326.         resize(width, height);
  327.     }    
  328.  
  329.     /**
  330.      * @deprecated As of JDK version 1.1,
  331.      * replaced by <code>setSize(int, int)</code>.
  332.      */
  333.     public void resize(int width, int height) {
  334.     this.width = width;
  335.     this.height = height;
  336.     }    
  337.  
  338.     /**
  339.      * Checks whether this rectangle contains the specified point.
  340.      * @param p the point (location) to test.
  341.      * @return    <code>true</code> if the point 
  342.      *            (<i>x</i>, <i>y</i>) is inside this rectangle; 
  343.      *            <code>false</code> otherwise.
  344.      * @since     JDK1.1
  345.      */
  346.     public boolean contains(Point p) {
  347.     return contains(p.x, p.y);
  348.     }
  349.  
  350.     /**
  351.      * Checks whether this rectangle contains the point
  352.      * at the specified location (<i>x</i>, <i>y</i>).
  353.      * @param     x   the <i>x</i> coordinate.
  354.      * @param     y   the <i>y</i> coordinate.
  355.      * @return    <code>true</code> if the point 
  356.      *            (<i>x</i>, <i>y</i>) is inside this rectangle; 
  357.      *            <code>false</code> otherwise.
  358.      * @since     JDK1.1
  359.      */
  360.     public boolean contains(int x, int y) {
  361.     return inside(x, y);
  362.     }
  363.  
  364.     /**
  365.      * @deprecated As of JDK version 1.1,
  366.      * replaced by <code>contains(int, int)</code>.
  367.      */
  368.     public boolean inside(int x, int y) {
  369.     return (x >= this.x) && ((x - this.x) < this.width) && (y >= this.y) && ((y-this.y) < this.height);
  370.     }
  371.  
  372.     /**
  373.      * Determines whether this rectangle and the specified rectangle  
  374.      * intersect. Two rectangles intersect if their intersection is 
  375.      * nonempty. 
  376.      * @param     r   a rectangle.
  377.      * @return    <code>true</code> if the specified rectangle 
  378.      *            and this rectangle insersect; 
  379.      *            <code>false</code> otherwise.
  380.      * @since     JDK1.0
  381.      */
  382.     public boolean intersects(Rectangle r) {
  383.     return !((r.x + r.width <= x) ||
  384.          (r.y + r.height <= y) ||
  385.          (r.x >= x + width) ||
  386.          (r.y >= y + height));
  387.     }
  388.  
  389.     /**
  390.      * Computes the intersection of this rectangle with the 
  391.      * specified rectangle. Returns a new rectangle that 
  392.      * represents the intersection of the two rectangles.
  393.      * @param     r   a rectangle.
  394.      * @return    the largest rectangle contained in both the 
  395.      *            specified rectangle and in this rectangle.
  396.      * @since   JDK1.0
  397.      */
  398.     public Rectangle intersection(Rectangle r) {
  399.     int x1 = Math.max(x, r.x);
  400.     int x2 = Math.min(x + width, r.x + r.width);
  401.     int y1 = Math.max(y, r.y);
  402.     int y2 = Math.min(y + height, r.y + r.height);
  403.     return new Rectangle(x1, y1, x2 - x1, y2 - y1);
  404.     }
  405.  
  406.     /**
  407.      * Computes the union of this rectangle with the 
  408.      * specified rectangle. Returns a new rectangle that 
  409.      * represents the union of the two rectangles.
  410.      * @param     r   a rectangle.
  411.      * @return    the smallest rectangle containing both the specified 
  412.      *            rectangle and this rectangle.
  413.      * @since     JDK1.0
  414.      */
  415.     public Rectangle union(Rectangle r) {
  416.     int x1 = Math.min(x, r.x);
  417.     int x2 = Math.max(x + width, r.x + r.width);
  418.     int y1 = Math.min(y, r.y);
  419.     int y2 = Math.max(y + height, r.y + r.height);
  420.     return new Rectangle(x1, y1, x2 - x1, y2 - y1);
  421.     }
  422.  
  423.     /**
  424.      * Adds a point, specified by the integer arguments <code>newx</code>
  425.      * and <code>newy</code>, to this rectangle. The resulting rectangle is
  426.      * the smallest rectangle that contains both the original rectangle 
  427.      * and the specified point.
  428.      * <p>
  429.      * After adding a point, a call to <code>contains<code> with the 
  430.      * added point as an argument will not necessarily return 
  431.      * <code>true</code>. The <code>contains</code> method does not 
  432.      * return <code>true</code> for points on the right or bottom 
  433.      * edges of a rectangle. Therefore if the added point falls on 
  434.      * the left or bottom edge of the enlarged rectangle, 
  435.      * <code>contains</code> will return <code>false</code> for that point.
  436.      * 
  437.      * @param     newx   the <i>x</i> coordinate of the new point.
  438.      * @param     newy   the <i>y</i> coordinate of the new point.
  439.      * @since     JDK1.0
  440.      */
  441.     public void add(int newx, int newy) {
  442.     int x1 = Math.min(x, newx);
  443.     int x2 = Math.max(x + width, newx);
  444.     int y1 = Math.min(y, newy);
  445.     int y2 = Math.max(y + height, newy);
  446.     x = x1;
  447.     y = y1;
  448.     width = x2 - x1;
  449.     height = y2 - y1;
  450.     }
  451.  
  452.     /**
  453.      * Adds the point <code>pt</code> to this rectangle. The resulting 
  454.      * rectangle is the smallest rectangle that contains both the 
  455.      * original rectangle and the specified point.
  456.      * <p>
  457.      * After adding a point, a call to <code>contains<code> with the 
  458.      * added point as an argument will not necessarily return 
  459.      * <code>true</code>. The <code>contains</code> method does not 
  460.      * return <code>true</code> for points on the right or bottom 
  461.      * edges of a rectangle. Therefore if the added point falls on 
  462.      * the left or bottom edge of the enlarged rectangle, 
  463.      * <code>contains</code> will return <code>false</code> for that point.
  464.      * 
  465.      * @param     pt the new point to add to the rectangle.
  466.      * @since     JDK1.0
  467.      */
  468.     public void add(Point pt) {
  469.     add(pt.x, pt.y);
  470.     }
  471.  
  472.     /**
  473.      * Adds a rectangle to this rectangle. The resulting rectangle is
  474.      * the union of the two rectangles. 
  475.      * @param     a rectangle.
  476.      * @since     JDK1.0
  477.      */
  478.     public void add(Rectangle r) {
  479.     int x1 = Math.min(x, r.x);
  480.     int x2 = Math.max(x + width, r.x + r.width);
  481.     int y1 = Math.min(y, r.y);
  482.     int y2 = Math.max(y + height, r.y + r.height);
  483.     x = x1;
  484.     y = y1;
  485.     width = x2 - x1;
  486.     height = y2 - y1;
  487.     }
  488.  
  489.     /**
  490.      * Grows the rectangle both horizontally and vertically.
  491.      * <p>
  492.      * This method modifies the rectangle so that it is 
  493.      * <code>h</code> units larger on both the left and right side, 
  494.      * and <code>v</code> units larger at both the top and bottom. 
  495.      * <p>
  496.      * The new rectangle has (<code>x - h</code>, 
  497.      * <code>y - v</code>) as its top-left corner, a 
  498.      * width of 
  499.      * <code>width</code> <code>+</code> <code>2h</code>, 
  500.      * and a height of 
  501.      * <code>height</code> <code>+</code> <code>2v</code>. 
  502.      * <p>
  503.      * If negative values are supplied for <code>h</code> and 
  504.      * <code>v</code>, the size of the rectangle decreases accordingly. 
  505.      * The <code>grow</code> method does not check whether the resulting 
  506.      * values of <code>width</code> and <code>height</code> are 
  507.      * non-negative. 
  508.      * @param     h   the horizontal expansion.
  509.      * @param     v   the vertical expansion.
  510.      * @since     JDK1.0
  511.      */
  512.     public void grow(int h, int v) {
  513.     x -= h;
  514.     y -= v;
  515.     width += h * 2;
  516.     height += v * 2;
  517.     }
  518.  
  519.     /**
  520.      * Determines whether this rectangle is empty. A rectangle is empty if 
  521.      * its width or its height is less than or equal to zero. 
  522.      * @return     <code>true</code> if this rectangle is empty; 
  523.      *             <code>false</code> otherwise.
  524.      * @since      JDK1.0
  525.      */
  526.     public boolean isEmpty() {
  527.     return (width <= 0) || (height <= 0);
  528.     }
  529.  
  530.     /**
  531.      * Returns the hashcode for this rectangle.
  532.      * @return     the hashcode for this rectangle.
  533.      * @since      JDK1.0
  534.      */
  535.     public int hashCode() {
  536.     return x ^ (y*37) ^ (width*43) ^ (height*47);
  537.     }
  538.  
  539.     /**
  540.      * Checks whether two rectangles are equal.
  541.      * <p>
  542.      * The result is <kbd>true</kbd> if and only if the argument is not 
  543.      * <kbd>null</kbd> and is a <kbd>Rectangle</kbd> object that has the 
  544.      * same top-left corner, width, and height as this rectangle. 
  545.      * @param     obj   the object to compare with.
  546.      * @return    <code>true</code> if the objects are equal; 
  547.      *            <code>false</code> otherwise.
  548.      * @since     JDK1.0
  549.      */
  550.     public boolean equals(Object obj) {
  551.     if (obj instanceof Rectangle) {
  552.         Rectangle r = (Rectangle)obj;
  553.         return (x == r.x) && (y == r.y) && (width == r.width) && (height == r.height);
  554.     }
  555.     return false;
  556.     }
  557.  
  558.     /**
  559.      * Returns a string representation of this rectangle 
  560.      * and its values.
  561.      * @return     a string representation of this rectangle.
  562.      * @since      JDK1.0
  563.      */
  564.     public String toString() {
  565.     return getClass().getName() + "[x=" + x + ",y=" + y + ",width=" + width + ",height=" + height + "]";
  566.     }
  567. }
  568.