| /* |
| * Copyright (c) 2008, 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 |
| * @bug 6766342 |
| * @summary Tests clipping invariance for AA rectangle and line primitives |
| * @run main RenderClipTest -strict -readfile 6766342.tests |
| * @run main RenderClipTest -rectsuite -count 10 |
| */ |
| |
| import java.awt.*; |
| import java.awt.geom.*; |
| import java.awt.image.*; |
| import java.awt.event.*; |
| import java.util.Vector; |
| import java.io.*; |
| |
| public class RenderClipTest { |
| public static double randDblCoord() { |
| return Math.random()*60 - 10; |
| } |
| |
| public static float randFltCoord() { |
| return (float) randDblCoord(); |
| } |
| |
| public static int randIntCoord() { |
| return (int) Math.round(randDblCoord()); |
| } |
| |
| public static int randInt(int n) { |
| return ((int) (Math.random() * (n*4))) >> 2; |
| } |
| |
| static int numtests; |
| static int numerrors; |
| static int numfillfailures; |
| static int numstrokefailures; |
| static int maxerr; |
| |
| static boolean useAA; |
| static boolean strokePure; |
| static boolean testFill; |
| static boolean testDraw; |
| static boolean silent; |
| static boolean verbose; |
| static boolean strict; |
| static boolean showErrors; |
| static float lw; |
| static double rot; |
| |
| static BufferedImage imgref; |
| static BufferedImage imgtst; |
| |
| static Graphics2D grefclear; |
| static Graphics2D gtstclear; |
| static Graphics2D grefrender; |
| static Graphics2D gtstrender; |
| |
| public static abstract class AnnotatedRenderOp { |
| public static AnnotatedRenderOp parse(String str) { |
| AnnotatedRenderOp ar; |
| if (((ar = Cubic.tryparse(str)) != null) || |
| ((ar = Quad.tryparse(str)) != null) || |
| ((ar = Poly.tryparse(str)) != null) || |
| ((ar = Path.tryparse(str)) != null) || |
| ((ar = Rect.tryparse(str)) != null) || |
| ((ar = Line.tryparse(str)) != null) || |
| ((ar = RectMethod.tryparse(str)) != null) || |
| ((ar = LineMethod.tryparse(str)) != null)) |
| { |
| return ar; |
| } |
| System.err.println("Unable to parse shape: "+str); |
| return null; |
| } |
| |
| public abstract void randomize(); |
| |
| public abstract void fill(Graphics2D g2d); |
| |
| public abstract void draw(Graphics2D g2d); |
| } |
| |
| public static abstract class AnnotatedShapeOp extends AnnotatedRenderOp { |
| public abstract Shape getShape(); |
| |
| public void fill(Graphics2D g2d) { |
| g2d.fill(getShape()); |
| } |
| |
| public void draw(Graphics2D g2d) { |
| g2d.draw(getShape()); |
| } |
| } |
| |
| public static void usage(String err) { |
| if (err != null) { |
| System.err.println(err); |
| } |
| System.err.println("usage: java RenderClipTest "+ |
| "[-read[file F]] [-rectsuite] [-fill] [-draw]"); |
| System.err.println(" "+ |
| "[-aa] [-pure] [-lw N] [-rot N]"); |
| System.err.println(" "+ |
| "[-rectmethod] [-linemethod] [-rect] [-line]"); |
| System.err.println(" "+ |
| "[-cubic] [-quad] [-poly] [-path]"); |
| System.err.println(" "+ |
| "[-silent] [-verbose] [-showerr] [-count N]"); |
| System.err.println(" "+ |
| "[-strict] [-usage]"); |
| System.err.println(" -read Read test data from stdin"); |
| System.err.println(" -readfile F Read test data from file F"); |
| System.err.println(" -rectsuite Run a suite of rect/line tests"); |
| System.err.println(" -fill Test g.fill*(...)"); |
| System.err.println(" -draw Test g.draw*(...)"); |
| System.err.println(" -aa Use antialiased rendering"); |
| System.err.println(" -pure Use STROKE_PURE hint"); |
| System.err.println(" -lw N Test line widths of N "+ |
| "(default 1.0)"); |
| System.err.println(" -rot N Test rotation by N degrees "+ |
| "(default 0.0)"); |
| System.err.println(" -rectmethod Test fillRect/drawRect methods"); |
| System.err.println(" -linemethod Test drawLine method"); |
| System.err.println(" -rect Test Rectangle2D shapes"); |
| System.err.println(" -line Test Line2D shapes"); |
| System.err.println(" -cubic Test CubicCurve2D shapes"); |
| System.err.println(" -quad Test QuadCurve2D shapes"); |
| System.err.println(" -poly Test Polygon shapes"); |
| System.err.println(" -path Test GeneralPath shapes"); |
| System.err.println(" -silent Do not print out error curves"); |
| System.err.println(" -verbose Print out progress info"); |
| System.err.println(" -showerr Display errors on screen"); |
| System.err.println(" -count N N tests per shape, then exit "+ |
| "(default 1000)"); |
| System.err.println(" -strict All failures are important"); |
| System.err.println(" -usage Print this help, then exit"); |
| System.exit((err != null) ? -1 : 0); |
| } |
| |
| public static void main(String argv[]) { |
| boolean readTests = false; |
| String readFile = null; |
| boolean rectsuite = false; |
| int count = 1000; |
| lw = 1.0f; |
| rot = 0.0; |
| Vector<AnnotatedRenderOp> testOps = new Vector<AnnotatedRenderOp>(); |
| for (int i = 0; i < argv.length; i++) { |
| String arg = argv[i].toLowerCase(); |
| if (arg.equals("-aa")) { |
| useAA = true; |
| } else if (arg.equals("-pure")) { |
| strokePure = true; |
| } else if (arg.equals("-fill")) { |
| testFill = true; |
| } else if (arg.equals("-draw")) { |
| testDraw = true; |
| } else if (arg.equals("-lw")) { |
| if (i+1 >= argv.length) { |
| usage("Missing argument: "+argv[i]); |
| } |
| lw = Float.parseFloat(argv[++i]); |
| } else if (arg.equals("-rot")) { |
| if (i+1 >= argv.length) { |
| usage("Missing argument: "+argv[i]); |
| } |
| rot = Double.parseDouble(argv[++i]); |
| } else if (arg.equals("-cubic")) { |
| testOps.add(new Cubic()); |
| } else if (arg.equals("-quad")) { |
| testOps.add(new Quad()); |
| } else if (arg.equals("-poly")) { |
| testOps.add(new Poly()); |
| } else if (arg.equals("-path")) { |
| testOps.add(new Path()); |
| } else if (arg.equals("-rect")) { |
| testOps.add(new Rect()); |
| } else if (arg.equals("-line")) { |
| testOps.add(new Line()); |
| } else if (arg.equals("-rectmethod")) { |
| testOps.add(new RectMethod()); |
| } else if (arg.equals("-linemethod")) { |
| testOps.add(new LineMethod()); |
| } else if (arg.equals("-verbose")) { |
| verbose = true; |
| } else if (arg.equals("-strict")) { |
| strict = true; |
| } else if (arg.equals("-silent")) { |
| silent = true; |
| } else if (arg.equals("-showerr")) { |
| showErrors = true; |
| } else if (arg.equals("-readfile")) { |
| if (i+1 >= argv.length) { |
| usage("Missing argument: "+argv[i]); |
| } |
| readTests = true; |
| readFile = argv[++i]; |
| } else if (arg.equals("-read")) { |
| readTests = true; |
| readFile = null; |
| } else if (arg.equals("-rectsuite")) { |
| rectsuite = true; |
| } else if (arg.equals("-count")) { |
| if (i+1 >= argv.length) { |
| usage("Missing argument: "+argv[i]); |
| } |
| count = Integer.parseInt(argv[++i]); |
| } else if (arg.equals("-usage")) { |
| usage(null); |
| } else { |
| usage("Unknown argument: "+argv[i]); |
| } |
| } |
| if (readTests) { |
| if (rectsuite || testDraw || testFill || |
| useAA || strokePure || |
| lw != 1.0f || rot != 0.0 || |
| testOps.size() > 0) |
| { |
| usage("Should not specify test types with -read options"); |
| } |
| } else if (rectsuite) { |
| if (testDraw || testFill || |
| useAA || strokePure || |
| lw != 1.0f || rot != 0.0 || |
| testOps.size() > 0) |
| { |
| usage("Should not specify test types with -rectsuite option"); |
| } |
| } else { |
| if (!testDraw && !testFill) { |
| usage("No work: Must specify one or both of "+ |
| "-fill or -draw"); |
| } |
| if (testOps.size() == 0) { |
| usage("No work: Must specify one or more of "+ |
| "-rect[method], -line[method], "+ |
| "-cubic, -quad, -poly, or -path"); |
| } |
| } |
| initImages(); |
| if (readTests) { |
| try { |
| InputStream is; |
| if (readFile == null) { |
| is = System.in; |
| } else { |
| File f = |
| new File(System.getProperty("test.src", "."), |
| readFile); |
| is = new FileInputStream(f); |
| } |
| parseAndRun(is); |
| } catch (IOException e) { |
| throw new RuntimeException(e); |
| } |
| } else if (rectsuite) { |
| runRectSuite(count); |
| } else { |
| initGCs(); |
| for (int k = 0; k < testOps.size(); k++) { |
| AnnotatedRenderOp ar = testOps.get(k); |
| runRandomTests(ar, count); |
| } |
| disposeGCs(); |
| } |
| grefclear.dispose(); |
| gtstclear.dispose(); |
| grefclear = gtstclear = null; |
| reportStatistics(); |
| } |
| |
| public static int reportStatistics() { |
| String connector = ""; |
| if (numfillfailures > 0) { |
| System.out.print(numfillfailures+" fills "); |
| connector = "and "; |
| } |
| if (numstrokefailures > 0) { |
| System.out.print(connector+numstrokefailures+" strokes "); |
| } |
| int totalfailures = numfillfailures + numstrokefailures; |
| if (totalfailures == 0) { |
| System.out.print("0 "); |
| } |
| System.out.println("out of "+numtests+" tests failed..."); |
| int critical = numerrors; |
| if (strict) { |
| critical += totalfailures; |
| } |
| if (critical > 0) { |
| throw new RuntimeException(critical+" tests had critical errors"); |
| } |
| System.out.println("No tests had critical errors"); |
| return (numerrors+totalfailures); |
| } |
| |
| public static void runRectSuite(int count) { |
| AnnotatedRenderOp ops[] = { |
| new Rect(), |
| new RectMethod(), |
| new Line(), |
| new LineMethod(), |
| }; |
| // Sometimes different fill algorithms are chosen for |
| // thin and wide line modes, make sure we test both... |
| float filllinewidths[] = { 0.0f, 2.0f }; |
| float drawlinewidths[] = { 0.0f, 0.5f, 1.0f, |
| 2.0f, 2.5f, |
| 5.0f, 5.3f }; |
| double rotations[] = { 0.0, 15.0, 90.0, |
| 135.0, 180.0, |
| 200.0, 270.0, |
| 300.0}; |
| for (AnnotatedRenderOp ar: ops) { |
| for (double r: rotations) { |
| rot = r; |
| for (int i = 0; i < 8; i++) { |
| float linewidths[]; |
| if ((i & 1) == 0) { |
| if ((ar instanceof Line) || |
| (ar instanceof LineMethod)) |
| { |
| continue; |
| } |
| testFill = true; |
| testDraw = false; |
| linewidths = filllinewidths; |
| } else { |
| testFill = false; |
| testDraw = true; |
| linewidths = drawlinewidths; |
| } |
| useAA = ((i & 2) != 0); |
| strokePure = ((i & 4) != 0); |
| for (float w : linewidths) { |
| lw = w; |
| runSuiteTests(ar, count); |
| } |
| } |
| } |
| } |
| } |
| |
| public static void runSuiteTests(AnnotatedRenderOp ar, int count) { |
| if (verbose) { |
| System.out.print("Running "); |
| System.out.print(testFill ? "Fill " : "Draw "); |
| System.out.print(BaseName(ar)); |
| if (useAA) { |
| System.out.print(" AA"); |
| } |
| if (strokePure) { |
| System.out.print(" Pure"); |
| } |
| if (lw != 1.0f) { |
| System.out.print(" lw="+lw); |
| } |
| if (rot != 0.0f) { |
| System.out.print(" rot="+rot); |
| } |
| System.out.println(); |
| } |
| initGCs(); |
| runRandomTests(ar, count); |
| disposeGCs(); |
| } |
| |
| public static String BaseName(AnnotatedRenderOp ar) { |
| String s = ar.toString(); |
| int leftparen = s.indexOf('('); |
| if (leftparen >= 0) { |
| s = s.substring(0, leftparen); |
| } |
| return s; |
| } |
| |
| public static void runRandomTests(AnnotatedRenderOp ar, int count) { |
| for (int i = 0; i < count; i++) { |
| ar.randomize(); |
| if (testDraw) { |
| test(ar, false); |
| } |
| if (testFill) { |
| test(ar, true); |
| } |
| } |
| } |
| |
| public static void initImages() { |
| imgref = new BufferedImage(40, 40, BufferedImage.TYPE_INT_RGB); |
| imgtst = new BufferedImage(40, 40, BufferedImage.TYPE_INT_RGB); |
| grefclear = imgref.createGraphics(); |
| gtstclear = imgtst.createGraphics(); |
| grefclear.setColor(Color.white); |
| gtstclear.setColor(Color.white); |
| } |
| |
| public static void initGCs() { |
| grefrender = imgref.createGraphics(); |
| gtstrender = imgtst.createGraphics(); |
| gtstrender.clipRect(10, 10, 20, 20); |
| grefrender.setColor(Color.blue); |
| gtstrender.setColor(Color.blue); |
| if (lw != 1.0f) { |
| BasicStroke bs = new BasicStroke(lw); |
| grefrender.setStroke(bs); |
| gtstrender.setStroke(bs); |
| } |
| if (rot != 0.0) { |
| double rotrad = Math.toRadians(rot); |
| grefrender.rotate(rotrad, 20, 20); |
| gtstrender.rotate(rotrad, 20, 20); |
| } |
| if (strokePure) { |
| grefrender.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, |
| RenderingHints.VALUE_STROKE_PURE); |
| gtstrender.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, |
| RenderingHints.VALUE_STROKE_PURE); |
| } |
| if (useAA) { |
| grefrender.setRenderingHint(RenderingHints.KEY_ANTIALIASING, |
| RenderingHints.VALUE_ANTIALIAS_ON); |
| gtstrender.setRenderingHint(RenderingHints.KEY_ANTIALIASING, |
| RenderingHints.VALUE_ANTIALIAS_ON); |
| maxerr = 1; |
| } |
| } |
| |
| public static void disposeGCs() { |
| grefrender.dispose(); |
| gtstrender.dispose(); |
| grefrender = gtstrender = null; |
| } |
| |
| public static void parseAndRun(InputStream in) throws IOException { |
| BufferedReader br = new BufferedReader(new InputStreamReader(in)); |
| String str; |
| while ((str = br.readLine()) != null) { |
| if (str.startsWith("Stroked ") || str.startsWith("Filled ")) { |
| parseTest(str); |
| continue; |
| } |
| if (str.startsWith("Running ")) { |
| continue; |
| } |
| if (str.startsWith("Failed: ")) { |
| continue; |
| } |
| if (str.indexOf(" out of ") > 0 && |
| str.indexOf(" tests failed...") > 0) |
| { |
| continue; |
| } |
| if (str.indexOf(" tests had critical errors") > 0) { |
| continue; |
| } |
| System.err.println("Unparseable line: "+str); |
| } |
| } |
| |
| public static void parseTest(String origstr) { |
| String str = origstr; |
| boolean isfill = false; |
| useAA = strokePure = false; |
| lw = 1.0f; |
| rot = 0.0; |
| if (str.startsWith("Stroked ")) { |
| str = str.substring(8); |
| isfill = false; |
| } else if (str.startsWith("Filled ")) { |
| str = str.substring(7); |
| isfill = true; |
| } else { |
| System.err.println("Unparseable test line: "+origstr); |
| } |
| if (str.startsWith("AA ")) { |
| str = str.substring(3); |
| useAA = true; |
| } |
| if (str.startsWith("Pure ")) { |
| str = str.substring(5); |
| strokePure = true; |
| } |
| if (str.startsWith("Lw=")) { |
| int index = str.indexOf(' ', 3); |
| if (index > 0) { |
| lw = Float.parseFloat(str.substring(3, index)); |
| str = str.substring(index+1); |
| } |
| } |
| if (str.startsWith("Rot=")) { |
| int index = str.indexOf(' ', 4); |
| if (index > 0) { |
| rot = Double.parseDouble(str.substring(4, index)); |
| str = str.substring(index+1); |
| } |
| } |
| AnnotatedRenderOp ar = AnnotatedRenderOp.parse(str); |
| if (ar != null) { |
| initGCs(); |
| test(ar, isfill); |
| disposeGCs(); |
| } else { |
| System.err.println("Unparseable test line: "+origstr); |
| } |
| } |
| |
| public static void test(AnnotatedRenderOp ar, boolean isfill) { |
| grefclear.fillRect(0, 0, 40, 40); |
| gtstclear.fillRect(0, 0, 40, 40); |
| if (isfill) { |
| ar.fill(grefrender); |
| ar.fill(gtstrender); |
| } else { |
| ar.draw(grefrender); |
| ar.draw(gtstrender); |
| } |
| check(imgref, imgtst, ar, isfill); |
| } |
| |
| public static int[] getData(BufferedImage img) { |
| Raster r = img.getRaster(); |
| DataBufferInt dbi = (DataBufferInt) r.getDataBuffer(); |
| return dbi.getData(); |
| } |
| |
| public static int getScan(BufferedImage img) { |
| Raster r = img.getRaster(); |
| SinglePixelPackedSampleModel sppsm = |
| (SinglePixelPackedSampleModel) r.getSampleModel(); |
| return sppsm.getScanlineStride(); |
| } |
| |
| public static int getOffset(BufferedImage img) { |
| Raster r = img.getRaster(); |
| SinglePixelPackedSampleModel sppsm = |
| (SinglePixelPackedSampleModel) r.getSampleModel(); |
| return sppsm.getOffset(-r.getSampleModelTranslateX(), |
| -r.getSampleModelTranslateY()); |
| } |
| |
| final static int opaque = 0xff000000; |
| final static int whitergb = Color.white.getRGB(); |
| |
| public static final int maxdiff(int rgb1, int rgb2) { |
| int maxd = 0; |
| for (int i = 0; i < 32; i += 8) { |
| int c1 = (rgb1 >> i) & 0xff; |
| int c2 = (rgb2 >> i) & 0xff; |
| int d = Math.abs(c1-c2); |
| if (maxd < d) { |
| maxd = d; |
| } |
| } |
| return maxd; |
| } |
| |
| public static void check(BufferedImage imgref, BufferedImage imgtst, |
| AnnotatedRenderOp ar, boolean wasfill) |
| { |
| numtests++; |
| int dataref[] = getData(imgref); |
| int datatst[] = getData(imgtst); |
| int scanref = getScan(imgref); |
| int scantst = getScan(imgtst); |
| int offref = getOffset(imgref); |
| int offtst = getOffset(imgtst); |
| |
| // We want to check for errors outside the clip at a higher |
| // priority than errors involving different pixels touched |
| // inside the clip. |
| |
| // Check above clip |
| if (check(ar, wasfill, |
| null, 0, 0, |
| datatst, scantst, offtst, |
| 0, 0, 40, 10)) |
| { |
| return; |
| } |
| // Check below clip |
| if (check(ar, wasfill, |
| null, 0, 0, |
| datatst, scantst, offtst, |
| 0, 30, 40, 40)) |
| { |
| return; |
| } |
| // Check left of clip |
| if (check(ar, wasfill, |
| null, 0, 0, |
| datatst, scantst, offtst, |
| 0, 10, 10, 30)) |
| { |
| return; |
| } |
| // Check right of clip |
| if (check(ar, wasfill, |
| null, 0, 0, |
| datatst, scantst, offtst, |
| 30, 10, 40, 30)) |
| { |
| return; |
| } |
| // Check inside clip |
| check(ar, wasfill, |
| dataref, scanref, offref, |
| datatst, scantst, offtst, |
| 10, 10, 30, 30); |
| } |
| |
| public static boolean check(AnnotatedRenderOp ar, boolean wasfill, |
| int dataref[], int scanref, int offref, |
| int datatst[], int scantst, int offtst, |
| int x0, int y0, int x1, int y1) |
| { |
| offref += scanref * y0; |
| offtst += scantst * y0; |
| for (int y = y0; y < y1; y++) { |
| for (int x = x0; x < x1; x++) { |
| boolean failed; |
| String reason; |
| int rgbref; |
| int rgbtst; |
| |
| rgbtst = datatst[offtst+x] | opaque; |
| if (dataref == null) { |
| /* Outside of clip, must be white, no error tolerance */ |
| rgbref = whitergb; |
| failed = (rgbtst != rgbref); |
| reason = "stray pixel rendered outside of clip"; |
| } else { |
| /* Inside of clip, check for maxerr delta in components */ |
| rgbref = dataref[offref+x] | opaque; |
| failed = (rgbref != rgbtst && |
| maxdiff(rgbref, rgbtst) > maxerr); |
| reason = "different pixel rendered inside clip"; |
| } |
| if (failed) { |
| if (dataref == null) { |
| numerrors++; |
| } |
| if (wasfill) { |
| numfillfailures++; |
| } else { |
| numstrokefailures++; |
| } |
| if (!silent) { |
| System.out.println("Failed: "+reason+" at "+x+", "+y+ |
| " ["+Integer.toHexString(rgbref)+ |
| " != "+Integer.toHexString(rgbtst)+ |
| "]"); |
| System.out.print(wasfill ? "Filled " : "Stroked "); |
| if (useAA) System.out.print("AA "); |
| if (strokePure) System.out.print("Pure "); |
| if (lw != 1) System.out.print("Lw="+lw+" "); |
| if (rot != 0) System.out.print("Rot="+rot+" "); |
| System.out.println(ar); |
| } |
| if (showErrors) { |
| show(imgref, imgtst); |
| } |
| return true; |
| } |
| } |
| offref += scanref; |
| offtst += scantst; |
| } |
| return false; |
| } |
| |
| static ErrorWindow errw; |
| |
| public static void show(BufferedImage imgref, BufferedImage imgtst) { |
| ErrorWindow errw = new ErrorWindow(); |
| errw.setImages(imgref, imgtst); |
| errw.setVisible(true); |
| errw.waitForHide(); |
| errw.dispose(); |
| } |
| |
| public static class Cubic extends AnnotatedShapeOp { |
| public static Cubic tryparse(String str) { |
| str = str.trim(); |
| if (!str.startsWith("Cubic(")) { |
| return null; |
| } |
| str = str.substring(6); |
| double coords[] = new double[8]; |
| boolean foundparen = false; |
| for (int i = 0; i < coords.length; i++) { |
| int index = str.indexOf(","); |
| if (index < 0) { |
| if (i < coords.length-1) { |
| return null; |
| } |
| index = str.indexOf(")"); |
| if (index < 0) { |
| return null; |
| } |
| foundparen = true; |
| } |
| String num = str.substring(0, index); |
| try { |
| coords[i] = Double.parseDouble(num); |
| } catch (NumberFormatException nfe) { |
| return null; |
| } |
| str = str.substring(index+1); |
| } |
| if (!foundparen || str.length() > 0) { |
| return null; |
| } |
| Cubic c = new Cubic(); |
| c.cubic.setCurve(coords[0], coords[1], |
| coords[2], coords[3], |
| coords[4], coords[5], |
| coords[6], coords[7]); |
| return c; |
| } |
| |
| private CubicCurve2D cubic = new CubicCurve2D.Double(); |
| |
| public void randomize() { |
| cubic.setCurve(randDblCoord(), randDblCoord(), |
| randDblCoord(), randDblCoord(), |
| randDblCoord(), randDblCoord(), |
| randDblCoord(), randDblCoord()); |
| } |
| |
| public Shape getShape() { |
| return cubic; |
| } |
| |
| public String toString() { |
| return ("Cubic("+ |
| cubic.getX1()+", "+ |
| cubic.getY1()+", "+ |
| cubic.getCtrlX1()+", "+ |
| cubic.getCtrlY1()+", "+ |
| cubic.getCtrlX2()+", "+ |
| cubic.getCtrlY2()+", "+ |
| cubic.getX2()+", "+ |
| cubic.getY2() |
| +")"); |
| } |
| } |
| |
| public static class Quad extends AnnotatedShapeOp { |
| public static Quad tryparse(String str) { |
| str = str.trim(); |
| if (!str.startsWith("Quad(")) { |
| return null; |
| } |
| str = str.substring(5); |
| double coords[] = new double[6]; |
| boolean foundparen = false; |
| for (int i = 0; i < coords.length; i++) { |
| int index = str.indexOf(","); |
| if (index < 0) { |
| if (i < coords.length-1) { |
| return null; |
| } |
| index = str.indexOf(")"); |
| if (index < 0) { |
| return null; |
| } |
| foundparen = true; |
| } |
| String num = str.substring(0, index); |
| try { |
| coords[i] = Double.parseDouble(num); |
| } catch (NumberFormatException nfe) { |
| return null; |
| } |
| str = str.substring(index+1); |
| } |
| if (!foundparen || str.length() > 0) { |
| return null; |
| } |
| Quad c = new Quad(); |
| c.quad.setCurve(coords[0], coords[1], |
| coords[2], coords[3], |
| coords[4], coords[5]); |
| return c; |
| } |
| |
| private QuadCurve2D quad = new QuadCurve2D.Double(); |
| |
| public void randomize() { |
| quad.setCurve(randDblCoord(), randDblCoord(), |
| randDblCoord(), randDblCoord(), |
| randDblCoord(), randDblCoord()); |
| } |
| |
| public Shape getShape() { |
| return quad; |
| } |
| |
| public String toString() { |
| return ("Quad("+ |
| quad.getX1()+", "+ |
| quad.getY1()+", "+ |
| quad.getCtrlX()+", "+ |
| quad.getCtrlY()+", "+ |
| quad.getX2()+", "+ |
| quad.getY2() |
| +")"); |
| } |
| } |
| |
| public static class Poly extends AnnotatedShapeOp { |
| public static Poly tryparse(String str) { |
| str = str.trim(); |
| if (!str.startsWith("Poly(")) { |
| return null; |
| } |
| str = str.substring(5); |
| Polygon p = new Polygon(); |
| while (true) { |
| int x, y; |
| str = str.trim(); |
| if (str.startsWith(")")) { |
| str = str.substring(1); |
| break; |
| } |
| if (p.npoints > 0) { |
| if (str.startsWith(",")) { |
| str = str.substring(2).trim(); |
| } else { |
| return null; |
| } |
| } |
| if (str.startsWith("[")) { |
| str = str.substring(1); |
| } else { |
| return null; |
| } |
| int index = str.indexOf(","); |
| if (index < 0) { |
| return null; |
| } |
| String num = str.substring(0, index); |
| try { |
| x = Integer.parseInt(num); |
| } catch (NumberFormatException nfe) { |
| return null; |
| } |
| str = str.substring(index+1); |
| index = str.indexOf("]"); |
| if (index < 0) { |
| return null; |
| } |
| num = str.substring(0, index).trim(); |
| try { |
| y = Integer.parseInt(num); |
| } catch (NumberFormatException nfe) { |
| return null; |
| } |
| str = str.substring(index+1); |
| p.addPoint(x, y); |
| } |
| if (str.length() > 0) { |
| return null; |
| } |
| if (p.npoints < 3) { |
| return null; |
| } |
| return new Poly(p); |
| } |
| |
| private Polygon poly; |
| |
| public Poly() { |
| this.poly = new Polygon(); |
| } |
| |
| private Poly(Polygon p) { |
| this.poly = p; |
| } |
| |
| public void randomize() { |
| poly.reset(); |
| poly.addPoint(randIntCoord(), randIntCoord()); |
| poly.addPoint(randIntCoord(), randIntCoord()); |
| poly.addPoint(randIntCoord(), randIntCoord()); |
| poly.addPoint(randIntCoord(), randIntCoord()); |
| poly.addPoint(randIntCoord(), randIntCoord()); |
| } |
| |
| public Shape getShape() { |
| return poly; |
| } |
| |
| public String toString() { |
| StringBuffer sb = new StringBuffer(100); |
| sb.append("Poly("); |
| for (int i = 0; i < poly.npoints; i++) { |
| if (i != 0) { |
| sb.append(", "); |
| } |
| sb.append("["); |
| sb.append(poly.xpoints[i]); |
| sb.append(", "); |
| sb.append(poly.ypoints[i]); |
| sb.append("]"); |
| } |
| sb.append(")"); |
| return sb.toString(); |
| } |
| } |
| |
| public static class Path extends AnnotatedShapeOp { |
| public static Path tryparse(String str) { |
| str = str.trim(); |
| if (!str.startsWith("Path(")) { |
| return null; |
| } |
| str = str.substring(5); |
| GeneralPath gp = new GeneralPath(); |
| float coords[] = new float[6]; |
| int numsegs = 0; |
| while (true) { |
| int type; |
| int n; |
| str = str.trim(); |
| if (str.startsWith(")")) { |
| str = str.substring(1); |
| break; |
| } |
| if (str.startsWith("M[")) { |
| type = PathIterator.SEG_MOVETO; |
| n = 2; |
| } else if (str.startsWith("L[")) { |
| type = PathIterator.SEG_LINETO; |
| n = 2; |
| } else if (str.startsWith("Q[")) { |
| type = PathIterator.SEG_QUADTO; |
| n = 4; |
| } else if (str.startsWith("C[")) { |
| type = PathIterator.SEG_CUBICTO; |
| n = 6; |
| } else if (str.startsWith("E[")) { |
| type = PathIterator.SEG_CLOSE; |
| n = 0; |
| } else { |
| return null; |
| } |
| str = str.substring(2); |
| if (n == 0) { |
| if (str.startsWith("]")) { |
| str = str.substring(1); |
| } else { |
| return null; |
| } |
| } |
| for (int i = 0; i < n; i++) { |
| int index; |
| if (i < n-1) { |
| index = str.indexOf(","); |
| } else { |
| index = str.indexOf("]"); |
| } |
| if (index < 0) { |
| return null; |
| } |
| String num = str.substring(0, index); |
| try { |
| coords[i] = Float.parseFloat(num); |
| } catch (NumberFormatException nfe) { |
| return null; |
| } |
| str = str.substring(index+1).trim(); |
| } |
| switch (type) { |
| case PathIterator.SEG_MOVETO: |
| gp.moveTo(coords[0], coords[1]); |
| break; |
| case PathIterator.SEG_LINETO: |
| gp.lineTo(coords[0], coords[1]); |
| break; |
| case PathIterator.SEG_QUADTO: |
| gp.quadTo(coords[0], coords[1], |
| coords[2], coords[3]); |
| break; |
| case PathIterator.SEG_CUBICTO: |
| gp.curveTo(coords[0], coords[1], |
| coords[2], coords[3], |
| coords[4], coords[5]); |
| break; |
| case PathIterator.SEG_CLOSE: |
| gp.closePath(); |
| break; |
| } |
| numsegs++; |
| } |
| if (str.length() > 0) { |
| return null; |
| } |
| if (numsegs < 2) { |
| return null; |
| } |
| return new Path(gp); |
| } |
| |
| private GeneralPath path; |
| |
| public Path() { |
| this.path = new GeneralPath(); |
| } |
| |
| private Path(GeneralPath gp) { |
| this.path = gp; |
| } |
| |
| public void randomize() { |
| path.reset(); |
| path.moveTo(randFltCoord(), randFltCoord()); |
| for (int i = randInt(5)+3; i > 0; --i) { |
| switch(randInt(5)) { |
| case 0: |
| path.moveTo(randFltCoord(), randFltCoord()); |
| break; |
| case 1: |
| path.lineTo(randFltCoord(), randFltCoord()); |
| break; |
| case 2: |
| path.quadTo(randFltCoord(), randFltCoord(), |
| randFltCoord(), randFltCoord()); |
| break; |
| case 3: |
| path.curveTo(randFltCoord(), randFltCoord(), |
| randFltCoord(), randFltCoord(), |
| randFltCoord(), randFltCoord()); |
| break; |
| case 4: |
| path.closePath(); |
| break; |
| } |
| } |
| } |
| |
| public Shape getShape() { |
| return path; |
| } |
| |
| public String toString() { |
| StringBuffer sb = new StringBuffer(100); |
| sb.append("Path("); |
| PathIterator pi = path.getPathIterator(null); |
| float coords[] = new float[6]; |
| boolean first = true; |
| while (!pi.isDone()) { |
| int n; |
| char c; |
| switch(pi.currentSegment(coords)) { |
| case PathIterator.SEG_MOVETO: |
| c = 'M'; |
| n = 2; |
| break; |
| case PathIterator.SEG_LINETO: |
| c = 'L'; |
| n = 2; |
| break; |
| case PathIterator.SEG_QUADTO: |
| c = 'Q'; |
| n = 4; |
| break; |
| case PathIterator.SEG_CUBICTO: |
| c = 'C'; |
| n = 6; |
| break; |
| case PathIterator.SEG_CLOSE: |
| c = 'E'; |
| n = 0; |
| break; |
| default: |
| throw new InternalError("Unknown segment!"); |
| } |
| sb.append(c); |
| sb.append("["); |
| for (int i = 0; i < n; i++) { |
| if (i != 0) { |
| sb.append(","); |
| } |
| sb.append(coords[i]); |
| } |
| sb.append("]"); |
| pi.next(); |
| } |
| sb.append(")"); |
| return sb.toString(); |
| } |
| } |
| |
| public static class Rect extends AnnotatedShapeOp { |
| public static Rect tryparse(String str) { |
| str = str.trim(); |
| if (!str.startsWith("Rect(")) { |
| return null; |
| } |
| str = str.substring(5); |
| double coords[] = new double[4]; |
| boolean foundparen = false; |
| for (int i = 0; i < coords.length; i++) { |
| int index = str.indexOf(","); |
| if (index < 0) { |
| if (i < coords.length-1) { |
| return null; |
| } |
| index = str.indexOf(")"); |
| if (index < 0) { |
| return null; |
| } |
| foundparen = true; |
| } |
| String num = str.substring(0, index); |
| try { |
| coords[i] = Double.parseDouble(num); |
| } catch (NumberFormatException nfe) { |
| return null; |
| } |
| str = str.substring(index+1); |
| } |
| if (!foundparen || str.length() > 0) { |
| return null; |
| } |
| Rect r = new Rect(); |
| r.rect.setRect(coords[0], coords[1], |
| coords[2], coords[3]); |
| return r; |
| } |
| |
| private Rectangle2D rect = new Rectangle2D.Double(); |
| |
| public void randomize() { |
| rect.setRect(randDblCoord(), randDblCoord(), |
| randDblCoord(), randDblCoord()); |
| } |
| |
| public Shape getShape() { |
| return rect; |
| } |
| |
| public String toString() { |
| return ("Rect("+ |
| rect.getX()+", "+ |
| rect.getY()+", "+ |
| rect.getWidth()+", "+ |
| rect.getHeight() |
| +")"); |
| } |
| } |
| |
| public static class Line extends AnnotatedShapeOp { |
| public static Line tryparse(String str) { |
| str = str.trim(); |
| if (!str.startsWith("Line(")) { |
| return null; |
| } |
| str = str.substring(5); |
| double coords[] = new double[4]; |
| boolean foundparen = false; |
| for (int i = 0; i < coords.length; i++) { |
| int index = str.indexOf(","); |
| if (index < 0) { |
| if (i < coords.length-1) { |
| return null; |
| } |
| index = str.indexOf(")"); |
| if (index < 0) { |
| return null; |
| } |
| foundparen = true; |
| } |
| String num = str.substring(0, index); |
| try { |
| coords[i] = Double.parseDouble(num); |
| } catch (NumberFormatException nfe) { |
| return null; |
| } |
| str = str.substring(index+1); |
| } |
| if (!foundparen || str.length() > 0) { |
| return null; |
| } |
| Line l = new Line(); |
| l.line.setLine(coords[0], coords[1], |
| coords[2], coords[3]); |
| return l; |
| } |
| |
| private Line2D line = new Line2D.Double(); |
| |
| public void randomize() { |
| line.setLine(randDblCoord(), randDblCoord(), |
| randDblCoord(), randDblCoord()); |
| } |
| |
| public Shape getShape() { |
| return line; |
| } |
| |
| public String toString() { |
| return ("Line("+ |
| line.getX1()+", "+ |
| line.getY1()+", "+ |
| line.getX2()+", "+ |
| line.getY2() |
| +")"); |
| } |
| } |
| |
| public static class RectMethod extends AnnotatedRenderOp { |
| public static RectMethod tryparse(String str) { |
| str = str.trim(); |
| if (!str.startsWith("RectMethod(")) { |
| return null; |
| } |
| str = str.substring(11); |
| int coords[] = new int[4]; |
| boolean foundparen = false; |
| for (int i = 0; i < coords.length; i++) { |
| int index = str.indexOf(","); |
| if (index < 0) { |
| if (i < coords.length-1) { |
| return null; |
| } |
| index = str.indexOf(")"); |
| if (index < 0) { |
| return null; |
| } |
| foundparen = true; |
| } |
| String num = str.substring(0, index).trim(); |
| try { |
| coords[i] = Integer.parseInt(num); |
| } catch (NumberFormatException nfe) { |
| return null; |
| } |
| str = str.substring(index+1); |
| } |
| if (!foundparen || str.length() > 0) { |
| return null; |
| } |
| RectMethod rm = new RectMethod(); |
| rm.rect.setBounds(coords[0], coords[1], |
| coords[2], coords[3]); |
| return rm; |
| } |
| |
| private Rectangle rect = new Rectangle(); |
| |
| public void randomize() { |
| rect.setBounds(randIntCoord(), randIntCoord(), |
| randIntCoord(), randIntCoord()); |
| } |
| |
| public void fill(Graphics2D g2d) { |
| g2d.fillRect(rect.x, rect.y, rect.width, rect.height); |
| } |
| |
| public void draw(Graphics2D g2d) { |
| g2d.drawRect(rect.x, rect.y, rect.width, rect.height); |
| } |
| |
| public String toString() { |
| return ("RectMethod("+ |
| rect.x+", "+ |
| rect.y+", "+ |
| rect.width+", "+ |
| rect.height |
| +")"); |
| } |
| } |
| |
| public static class LineMethod extends AnnotatedRenderOp { |
| public static LineMethod tryparse(String str) { |
| str = str.trim(); |
| if (!str.startsWith("LineMethod(")) { |
| return null; |
| } |
| str = str.substring(11); |
| int coords[] = new int[4]; |
| boolean foundparen = false; |
| for (int i = 0; i < coords.length; i++) { |
| int index = str.indexOf(","); |
| if (index < 0) { |
| if (i < coords.length-1) { |
| return null; |
| } |
| index = str.indexOf(")"); |
| if (index < 0) { |
| return null; |
| } |
| foundparen = true; |
| } |
| String num = str.substring(0, index).trim(); |
| try { |
| coords[i] = Integer.parseInt(num); |
| } catch (NumberFormatException nfe) { |
| return null; |
| } |
| str = str.substring(index+1); |
| } |
| if (!foundparen || str.length() > 0) { |
| return null; |
| } |
| LineMethod lm = new LineMethod(); |
| lm.line = coords; |
| return lm; |
| } |
| |
| private int line[] = new int[4]; |
| |
| public void randomize() { |
| line[0] = randIntCoord(); |
| line[1] = randIntCoord(); |
| line[2] = randIntCoord(); |
| line[3] = randIntCoord(); |
| } |
| |
| public void fill(Graphics2D g2d) { |
| } |
| |
| public void draw(Graphics2D g2d) { |
| g2d.drawLine(line[0], line[1], line[2], line[3]); |
| } |
| |
| public String toString() { |
| return ("LineMethod("+ |
| line[0]+", "+ |
| line[1]+", "+ |
| line[2]+", "+ |
| line[3] |
| +")"); |
| } |
| } |
| |
| public static class ErrorWindow extends Frame { |
| ImageCanvas unclipped; |
| ImageCanvas reference; |
| ImageCanvas actual; |
| ImageCanvas diff; |
| |
| public ErrorWindow() { |
| super("Error Comparison Window"); |
| |
| unclipped = new ImageCanvas(); |
| reference = new ImageCanvas(); |
| actual = new ImageCanvas(); |
| diff = new ImageCanvas(); |
| |
| setLayout(new SmartGridLayout(0, 2, 5, 5)); |
| addImagePanel(unclipped, "Unclipped rendering"); |
| addImagePanel(reference, "Clipped reference"); |
| addImagePanel(actual, "Actual clipped"); |
| addImagePanel(diff, "Difference"); |
| |
| addWindowListener(new WindowAdapter() { |
| public void windowClosing(WindowEvent e) { |
| setVisible(false); |
| } |
| }); |
| } |
| |
| public void addImagePanel(ImageCanvas ic, String label) { |
| add(ic); |
| add(new Label(label)); |
| } |
| |
| public void setImages(BufferedImage imgref, BufferedImage imgtst) { |
| unclipped.setImage(imgref); |
| reference.setReference(imgref); |
| actual.setImage(imgtst); |
| diff.setDiff(reference.getImage(), imgtst); |
| invalidate(); |
| pack(); |
| repaint(); |
| } |
| |
| public void setVisible(boolean vis) { |
| super.setVisible(vis); |
| synchronized (this) { |
| notifyAll(); |
| } |
| } |
| |
| public synchronized void waitForHide() { |
| while (isShowing()) { |
| try { |
| wait(); |
| } catch (InterruptedException e) { |
| System.exit(2); |
| } |
| } |
| } |
| } |
| |
| public static class SmartGridLayout implements LayoutManager { |
| int rows; |
| int cols; |
| int hgap; |
| int vgap; |
| |
| public SmartGridLayout(int r, int c, int h, int v) { |
| this.rows = r; |
| this.cols = c; |
| this.hgap = h; |
| this.vgap = v; |
| } |
| |
| public void addLayoutComponent(String name, Component comp) { |
| } |
| |
| public void removeLayoutComponent(Component comp) { |
| } |
| |
| public int[][] getGridSizes(Container parent, boolean min) { |
| int ncomponents = parent.getComponentCount(); |
| int nrows = rows; |
| int ncols = cols; |
| |
| if (nrows > 0) { |
| ncols = (ncomponents + nrows - 1) / nrows; |
| } else { |
| nrows = (ncomponents + ncols - 1) / ncols; |
| } |
| int widths[] = new int[ncols+1]; |
| int heights[] = new int[nrows+1]; |
| int x = 0; |
| int y = 0; |
| for (int i = 0 ; i < ncomponents ; i++) { |
| Component comp = parent.getComponent(i); |
| Dimension d = (min |
| ? comp.getMinimumSize() |
| : comp.getPreferredSize()); |
| if (widths[x] < d.width) { |
| widths[x] = d.width; |
| } |
| if (heights[y] < d.height) { |
| heights[y] = d.height; |
| } |
| x++; |
| if (x >= ncols) { |
| x = 0; |
| y++; |
| } |
| } |
| for (int i = 0; i < ncols; i++) { |
| widths[ncols] += widths[i]; |
| } |
| for (int i = 0; i < nrows; i++) { |
| heights[nrows] += heights[i]; |
| } |
| return new int[][] { widths, heights }; |
| } |
| |
| public Dimension getSize(Container parent, boolean min) { |
| int sizes[][] = getGridSizes(parent, min); |
| int widths[] = sizes[0]; |
| int heights[] = sizes[1]; |
| int nrows = heights.length-1; |
| int ncols = widths.length-1; |
| int w = widths[ncols]; |
| int h = heights[nrows]; |
| Insets insets = parent.getInsets(); |
| return new Dimension(insets.left+insets.right + w+(ncols+1)*hgap, |
| insets.top+insets.bottom + h+(nrows+1)*vgap); |
| } |
| |
| public Dimension preferredLayoutSize(Container parent) { |
| return getSize(parent, false); |
| } |
| |
| public Dimension minimumLayoutSize(Container parent) { |
| return getSize(parent, true); |
| } |
| |
| public void layoutContainer(Container parent) { |
| int pref[][] = getGridSizes(parent, false); |
| int min[][] = getGridSizes(parent, true); |
| int minwidths[] = min[0]; |
| int minheights[] = min[1]; |
| int prefwidths[] = pref[0]; |
| int prefheights[] = pref[1]; |
| int nrows = minheights.length - 1; |
| int ncols = minwidths.length - 1; |
| Insets insets = parent.getInsets(); |
| int w = parent.getWidth() - insets.left - insets.right; |
| int h = parent.getHeight() - insets.top - insets.bottom; |
| w = w - (ncols+1)*hgap; |
| h = h - (nrows+1)*vgap; |
| int widths[] = calculateSizes(w, ncols, minwidths, prefwidths); |
| int heights[] = calculateSizes(h, nrows, minheights, prefheights); |
| int ncomponents = parent.getComponentCount(); |
| int x = insets.left + hgap; |
| int y = insets.top + vgap; |
| int r = 0; |
| int c = 0; |
| for (int i = 0; i < ncomponents; i++) { |
| parent.getComponent(i).setBounds(x, y, widths[c], heights[r]); |
| x += widths[c++] + hgap; |
| if (c >= ncols) { |
| c = 0; |
| x = insets.left + hgap; |
| y += heights[r++] + vgap; |
| if (r >= nrows) { |
| // just in case |
| break; |
| } |
| } |
| } |
| } |
| |
| public static int[] calculateSizes(int total, int num, |
| int minsizes[], int prefsizes[]) |
| { |
| if (total <= minsizes[num]) { |
| return minsizes; |
| } |
| if (total >= prefsizes[num]) { |
| return prefsizes; |
| } |
| int sizes[] = new int[total]; |
| int prevhappy = 0; |
| int nhappy = 0; |
| int happysize = 0; |
| do { |
| int addsize = (total - happysize) / (num - nhappy); |
| happysize = 0; |
| for (int i = 0; i < num; i++) { |
| if (sizes[i] >= prefsizes[i] || |
| minsizes[i] + addsize > prefsizes[i]) |
| { |
| happysize += (sizes[i] = prefsizes[i]); |
| nhappy++; |
| } else { |
| sizes[i] = minsizes[i] + addsize; |
| } |
| } |
| } while (nhappy < num && nhappy > prevhappy); |
| return sizes; |
| } |
| } |
| |
| public static class ImageCanvas extends Canvas { |
| BufferedImage image; |
| |
| public void setImage(BufferedImage img) { |
| this.image = img; |
| } |
| |
| public BufferedImage getImage() { |
| return image; |
| } |
| |
| public void checkImage(int w, int h) { |
| if (image == null || |
| image.getWidth() < w || |
| image.getHeight() < h) |
| { |
| image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); |
| } |
| } |
| |
| public void setReference(BufferedImage img) { |
| checkImage(img.getWidth(), img.getHeight()); |
| Graphics g = image.createGraphics(); |
| g.drawImage(img, 0, 0, null); |
| g.setColor(Color.white); |
| g.fillRect(0, 0, 30, 10); |
| g.fillRect(30, 0, 10, 30); |
| g.fillRect(10, 30, 30, 10); |
| g.fillRect(0, 10, 10, 30); |
| g.dispose(); |
| } |
| |
| public void setDiff(BufferedImage imgref, BufferedImage imgtst) { |
| int w = Math.max(imgref.getWidth(), imgtst.getWidth()); |
| int h = Math.max(imgref.getHeight(), imgtst.getHeight()); |
| checkImage(w, h); |
| Graphics g = image.createGraphics(); |
| g.drawImage(imgref, 0, 0, null); |
| g.setXORMode(Color.white); |
| g.drawImage(imgtst, 0, 0, null); |
| g.setPaintMode(); |
| g.setColor(new Color(1f, 1f, 0f, 0.25f)); |
| g.fillRect(10, 10, 20, 20); |
| g.setColor(new Color(1f, 0f, 0f, 0.25f)); |
| g.fillRect(0, 0, 30, 10); |
| g.fillRect(30, 0, 10, 30); |
| g.fillRect(10, 30, 30, 10); |
| g.fillRect(0, 10, 10, 30); |
| g.dispose(); |
| } |
| |
| public Dimension getPreferredSize() { |
| if (image == null) { |
| return new Dimension(); |
| } else { |
| return new Dimension(image.getWidth(), image.getHeight()); |
| } |
| } |
| |
| public void paint(Graphics g) { |
| g.drawImage(image, 0, 0, null); |
| } |
| } |
| } |
