| /* |
| * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| @test |
| @key headful |
| @bug 6244574 |
| @bug 6258142 |
| @bug 6395165 |
| @bug 6588884 |
| @summary Tests that source is clipped correctly when blitting |
| different types of images to the screen |
| @author Dmitri.Trembovetski: area=Graphics2D |
| @run main SourceClippingBlitTest |
| */ |
| |
| import java.awt.AWTException; |
| import java.awt.Canvas; |
| import java.awt.Color; |
| import java.awt.Dimension; |
| import java.awt.Frame; |
| import java.awt.Graphics; |
| import java.awt.GraphicsConfiguration; |
| import java.awt.Image; |
| import java.awt.Point; |
| import java.awt.Rectangle; |
| import java.awt.Robot; |
| import java.awt.Toolkit; |
| import java.awt.Transparency; |
| import java.awt.event.ComponentAdapter; |
| import java.awt.event.ComponentEvent; |
| import java.awt.event.WindowAdapter; |
| import java.awt.event.WindowEvent; |
| import java.awt.image.BufferedImage; |
| import java.awt.image.VolatileImage; |
| |
| public class SourceClippingBlitTest extends Canvas { |
| static final int TESTW = 300; |
| static final int TESTH = 300; |
| static final int IMAGEW = 50; |
| static final int IMAGEH = 50; |
| |
| static final Rectangle IMAGE_BOUNDS = new Rectangle(0, 0, IMAGEW, IMAGEH); |
| static Robot robot; |
| static private boolean showErrors; |
| |
| private static final Object lock = new Object(); |
| private static volatile boolean done = false; |
| |
| BufferedImage grabbedBI; |
| |
| public static void main(String[] args) { |
| // allow user to override the properties if needed |
| if (System.getProperty("sun.java2d.pmoffscreen") == null) { |
| System.setProperty("sun.java2d.pmoffscreen", "true"); |
| } |
| |
| if (args.length > 0 && args[0].equals("-showerrors")) { |
| showErrors = true; |
| } |
| |
| try { |
| robot = new Robot(); |
| } catch (AWTException e) { |
| throw new RuntimeException(e); |
| } |
| |
| Frame f = new Frame(SourceClippingBlitTest.class.getName()); |
| final SourceClippingBlitTest test = new SourceClippingBlitTest(); |
| f.add(test); |
| f.addWindowListener(new WindowAdapter() { |
| public void windowActivated(WindowEvent e) { |
| if (!done) { |
| test.runTests(); |
| } |
| } |
| |
| }); |
| f.pack(); |
| f.setLocation(100, 100); |
| f.setVisible(true); |
| synchronized (lock) { |
| while (!done) { |
| try { |
| lock.wait(); |
| } catch (InterruptedException ex) { |
| ex.printStackTrace(); |
| } |
| } |
| } |
| if (!showErrors) { |
| f.dispose(); |
| } |
| } |
| |
| public Dimension getPreferredSize() { |
| return new Dimension(TESTW, TESTH); |
| } |
| |
| public void paint(Graphics g) { |
| if (showErrors && done && grabbedBI != null) { |
| g.drawImage(grabbedBI, 0, 0, null); |
| } |
| } |
| |
| public void runTests() { |
| GraphicsConfiguration gc = getGraphicsConfiguration(); |
| for (Image srcIm : |
| new Image[] { |
| getBufferedImage(gc, IMAGEW, IMAGEH, |
| BufferedImage.TYPE_INT_RGB, true), |
| getBufferedImage(gc, IMAGEW, IMAGEH, |
| BufferedImage.TYPE_INT_RGB, false), |
| // commented out due to 6593406 |
| // getBMImage(gc, IMAGEW, IMAGEH), |
| // getBufferedImage(gc, IMAGEW, IMAGEH, |
| // BufferedImage.TYPE_INT_ARGB, true), |
| // getBufferedImage(gc, IMAGEW, IMAGEH, |
| // BufferedImage.TYPE_INT_ARGB, false), |
| getVImage(gc, IMAGEW, IMAGEH), |
| }) |
| { |
| System.out.println("Testing source: " + srcIm); |
| // wiggle the source and dest rectangles |
| try { |
| for (int locationVar = -10; locationVar < 20; locationVar += 10) |
| { |
| for (int sizeVar = -10; sizeVar < 20; sizeVar += 10) { |
| Rectangle srcRect = (Rectangle)IMAGE_BOUNDS.clone(); |
| srcRect.translate(locationVar, locationVar); |
| srcRect.grow(sizeVar, sizeVar); |
| |
| Rectangle dstRect = |
| new Rectangle(sizeVar, sizeVar, |
| srcRect.width, srcRect.height); |
| System.out.println("testing blit rect src: " + srcRect); |
| System.out.println(" dst: " + dstRect); |
| render(getGraphics(), srcIm, srcRect, dstRect); |
| test(srcRect, dstRect); |
| } |
| } |
| System.out.println("Test passed."); |
| } finally { |
| synchronized (lock) { |
| done = true; |
| lock.notifyAll(); |
| } |
| } |
| } |
| } |
| |
| public void render(Graphics g, Image image, |
| Rectangle srcRect, Rectangle dstRect) |
| { |
| int w = getWidth(); |
| int h = getHeight(); |
| g.setColor(Color.green); |
| g.fillRect(0, 0, w, h); |
| |
| int bltWidth = srcRect.width; |
| int bltHeight = srcRect.height; |
| VolatileImage vi = null; |
| if (image instanceof VolatileImage) { |
| vi = (VolatileImage)image; |
| } |
| do { |
| if (vi != null) { |
| GraphicsConfiguration gc = getGraphicsConfiguration(); |
| if (vi.validate(gc) != VolatileImage.IMAGE_OK) { |
| initImage(gc, vi); |
| } |
| } |
| g.drawImage(image, |
| dstRect.x, dstRect.y, |
| dstRect.x + bltWidth, dstRect.y + bltHeight, |
| srcRect.x, srcRect.y, |
| srcRect.x + bltWidth, srcRect.y + bltHeight, |
| Color.red, |
| null); |
| } while (vi != null && vi.contentsLost()); |
| } |
| |
| |
| public void test(Rectangle srcRect, Rectangle dstRect) { |
| int w = getWidth(); |
| int h = getHeight(); |
| Toolkit.getDefaultToolkit().sync(); |
| try { |
| Thread.sleep(2000); |
| } catch (InterruptedException ex) {} |
| Point p = getLocationOnScreen(); |
| grabbedBI = robot.createScreenCapture(new Rectangle(p.x, p.y, w, h)); |
| |
| // calculate the destination rectangle |
| Rectangle srcBounds = srcRect.intersection(IMAGE_BOUNDS); |
| int trX = dstRect.x - srcRect.x; |
| int trY = dstRect.y - srcRect.y; |
| Rectangle newDstRect = (Rectangle)dstRect.clone(); |
| newDstRect.translate(-trX, -trY); |
| Rectangle.intersect(newDstRect, srcBounds, newDstRect); |
| newDstRect.translate(trX, trY); |
| Rectangle.intersect(newDstRect, new Rectangle(0, 0, w, h), newDstRect); |
| |
| System.out.println("calculated dest rect:" + newDstRect); |
| |
| // we do implicit clipping of the destination surface |
| // by only checking pixels within its bounds |
| for (int y = 0; y < h; y++) { |
| for (int x = 0; x < w; x++) { |
| int rgb = 0; |
| if (newDstRect.contains(x, y)) { |
| rgb = Color.red.getRGB(); |
| } else { |
| rgb = Color.green.getRGB(); |
| } |
| if (grabbedBI.getRGB(x, y) != rgb) { |
| String msg1 = "Test failed at x="+x+" y="+y; |
| System.out.println(msg1); |
| System.out.println(" expected: "+Integer.toHexString(rgb)+ |
| " got:"+Integer.toHexString(grabbedBI.getRGB(x, y))); |
| throw new RuntimeException(msg1); |
| } |
| } |
| } |
| System.out.println("subtest passed"); |
| } |
| |
| static VolatileImage dstImage; |
| static void initImage(GraphicsConfiguration gc, Image image) { |
| Graphics g = image.getGraphics(); |
| g.setColor(Color.RED); |
| int w = image.getWidth(null); |
| int h = image.getHeight(null); |
| g.fillRect(0, 0, w, h); |
| g.dispose(); |
| |
| // need to 'accelerate' the image |
| if (dstImage == null) { |
| dstImage = |
| gc.createCompatibleVolatileImage(TESTW, TESTH, |
| Transparency.OPAQUE); |
| } |
| dstImage.validate(gc); |
| g = dstImage.getGraphics(); |
| g.drawImage(image, 0, 0, null); |
| g.drawImage(image, 0, 0, null); |
| g.drawImage(image, 0, 0, null); |
| } |
| |
| static VolatileImage getVImage(GraphicsConfiguration gc, |
| int w, int h) |
| { |
| VolatileImage image = |
| gc.createCompatibleVolatileImage(w, h, Transparency.OPAQUE); |
| image.validate(gc); |
| initImage(gc, image); |
| return image; |
| } |
| |
| static Image getBMImage(GraphicsConfiguration gc, |
| int w, int h) |
| { |
| Image image = |
| gc.createCompatibleImage(w, h, Transparency.BITMASK); |
| initImage(gc, image); |
| return image; |
| } |
| |
| static Image getBufferedImage(GraphicsConfiguration gc, |
| int w, int h, int type, boolean acceleratable) |
| { |
| BufferedImage image = new BufferedImage(w, h, type); |
| if (!acceleratable) { |
| image.setAccelerationPriority(0.0f); |
| } |
| initImage(gc, image); |
| return image; |
| } |
| } |