src/java.desktop/share/classes/sun/java2d/pipe/Region.java

*** 26,35 ****
--- 26,36 ----
  package sun.java2d.pipe;
  
  import java.awt.Rectangle;
  import java.awt.Shape;
  import java.awt.geom.AffineTransform;
+ import java.awt.geom.Rectangle2D;
  import java.awt.geom.RectangularShape;
  
  import sun.java2d.loops.TransformHelper;
  
  /**
*** 116,125 ****
--- 117,154 ----
          }
          return newv;
      }
  
      /**
+      * Returns the closest {@code int} to the argument, with ties rounding to
+      * negative infinity.
+      * <p>
+      * Special cases:
+      * <ul><li>If the argument is NaN, the result is 0.
+      * <li>If the argument is negative infinity or any value less than or
+      * equal to the value of {@code Integer.MIN_VALUE}, the result is
+      * equal to the value of {@code Integer.MIN_VALUE}.
+      * <li>If the argument is positive infinity or any value greater than or
+      * equal to the value of {@code Integer.MAX_VALUE}, the result is
+      * equal to the value of {@code Integer.MAX_VALUE}.</ul>
+      *
+      * @param   coordinate a floating-point value to be rounded to an integer
+      * @return  the value of the argument rounded to the nearest
+      *          {@code int} value.
+      */
+     public static int clipRound(final double coordinate) {
+         final double newv = coordinate - 0.5;
+         if (newv < Integer.MIN_VALUE) {
+             return Integer.MIN_VALUE;
+         }
+         if (newv > Integer.MAX_VALUE) {
+             return Integer.MAX_VALUE;
+         }
+         return (int) Math.ceil(newv);
+     }
+ 
+     /**
       * Multiply the scale factor {@code sv} and the value {@code v} with
       * appropriate clipping to the bounds of Integer resolution. If the answer
       * would be greater than {@code Integer.MAX_VALUE} then {@code
       * Integer.MAX_VALUE} is returned. If the answer would be less than {@code
       * Integer.MIN_VALUE} then {@code Integer.MIN_VALUE} is returned. Otherwise
*** 557,566 ****
--- 586,616 ----
          return getIntersectionXYXY(x, y, dimAdd(x, w), dimAdd(y, h));
      }
  
      /**
       * Returns a Region object that represents the intersection of
+      * this object with the specified Rectangle2D. The return value
+      * may be this same object if no clipping occurs.
+      */
+     public Region getIntersection(Rectangle2D r) {
+         return getIntersectionXYXY(r.getMinX(), r.getMinY(), r.getMaxX(),
+                                    r.getMaxY());
+     }
+ 
+     /**
+      * Returns a Region object that represents the intersection of
+      * this object with the specified rectangular area. The return
+      * value may be this same object if no clipping occurs.
+      */
+     public Region getIntersectionXYXY(double lox, double loy, double hix,
+                                       double hiy) {
+         return getIntersectionXYXY(clipRound(lox), clipRound(loy),
+                                    clipRound(hix), clipRound(hiy));
+     }
+ 
+     /**
+      * Returns a Region object that represents the intersection of
       * this object with the specified rectangular area.  The return
       * value may be this same object if no clipping occurs.
       */
      public Region getIntersectionXYXY(int lox, int loy, int hix, int hiy) {
          if (isInsideXYXY(lox, loy, hix, hiy)) {