/*
* Copyright 2002-2007 Sun Microsystems, Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* - Neither the name of Sun Microsystems nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package j2dbench;
import java.awt.Image;
import java.awt.Component;
import java.awt.GraphicsConfiguration;
import java.awt.Transparency;
import java.awt.color.ColorSpace;
import java.awt.image.BufferedImage;
import java.awt.image.ComponentColorModel;
import java.awt.image.DataBuffer;
import java.awt.image.WritableRaster;
import j2dbench.tests.GraphicsTests;
import j2dbench.tests.ImageTests;
public abstract class Destinations extends Option.Enable {
public static Group.EnableSet destroot;
public static Group bufimgdestroot;
public static Group compatimgdestroot;
public static void init() {
destroot = new Group.EnableSet(TestEnvironment.globaloptroot,
"dest", "Output Destination Options");
new Screen();
new OffScreen();
if (GraphicsTests.hasGraphics2D) {
if (ImageTests.hasCompatImage) {
compatimgdestroot =
new Group.EnableSet(destroot, "compatimg",
"Compatible Image Destinations");
compatimgdestroot.setHorizontal();
new CompatImg();
new CompatImg(Transparency.OPAQUE);
new CompatImg(Transparency.BITMASK);
new CompatImg(Transparency.TRANSLUCENT);
}
if (ImageTests.hasVolatileImage) {
new VolatileImg();
}
bufimgdestroot = new Group.EnableSet(destroot, "bufimg",
"BufferedImage Destinations");
new BufImg(BufferedImage.TYPE_INT_RGB);
new BufImg(BufferedImage.TYPE_INT_ARGB);
new BufImg(BufferedImage.TYPE_INT_ARGB_PRE);
new BufImg(BufferedImage.TYPE_3BYTE_BGR);
new BufImg(BufferedImage.TYPE_BYTE_INDEXED);
new BufImg(BufferedImage.TYPE_BYTE_GRAY);
new CustomImg();
}
}
public Destinations(Group parent,
String nodename, String description,
boolean defenabled)
{
super(parent, nodename, description, defenabled);
}
public void modifyTest(TestEnvironment env) {
setDestination(env);
}
public void restoreTest(TestEnvironment env) {
env.setTestImage(null);
}
public String getAbbreviatedModifierDescription(Object val) {
return "to "+getModifierValueName(val);
}
public abstract void setDestination(TestEnvironment env);
public static class Screen extends Destinations {
public Screen() {
super(destroot, "screen", "Output to Screen", false);
}
public String getModifierValueName(Object val) {
return "Screen";
}
public void setDestination(TestEnvironment env) {
env.setTestImage(null);
}
}
public static class OffScreen extends Destinations {
public OffScreen() {
super(destroot, "offscreen", "Output to OffScreen Image", false);
}
public String getModifierValueName(Object val) {
return "OffScreen";
}
public void setDestination(TestEnvironment env) {
Component c = env.getCanvas();
env.setTestImage(c.createImage(env.getWidth(), env.getHeight()));
}
}
public static class CompatImg extends Destinations {
int transparency;
public static String ShortNames[] = {
"compatimg",
"opqcompatimg",
"bmcompatimg",
"transcompatimg",
};
public static String ShortDescriptions[] = {
"Default",
"Opaque",
"Bitmask",
"Translucent",
};
public static String LongDescriptions[] = {
"Default Compatible Image",
"Opaque Compatible Image",
"Bitmask Compatible Image",
"Translucent Compatible Image",
};
public static String ModifierNames[] = {
"CompatImage()",
"CompatImage(Opaque)",
"CompatImage(Bitmask)",
"CompatImage(Translucent)",
};
public CompatImg() {
this(0);
}
public CompatImg(int transparency) {
super(compatimgdestroot,
ShortNames[transparency],
ShortDescriptions[transparency],
false);
this.transparency = transparency;
}
public String getModifierValueName(Object val) {
return ModifierNames[transparency];
}
public void setDestination(TestEnvironment env) {
Component c = env.getCanvas();
GraphicsConfiguration gc = c.getGraphicsConfiguration();
int w = env.getWidth();
int h = env.getHeight();
if (transparency == 0) {
env.setTestImage(gc.createCompatibleImage(w, h));
} else {
env.setTestImage(gc.createCompatibleImage(w, h, transparency));
}
}
}
public static class VolatileImg extends Destinations {
public VolatileImg() {
super(destroot, "volimg", "Output to Volatile Image", false);
}
public String getModifierValueName(Object val) {
return "VolatileImg";
}
public void setDestination(TestEnvironment env) {
Component c = env.getCanvas();
env.setTestImage(c.createVolatileImage(env.getWidth(),
env.getHeight()));
}
}
public static class BufImg extends Destinations {
int type;
Image img;
public static String ShortNames[] = {
"custom",
"IntXrgb",
"IntArgb",
"IntArgbPre",
"IntXbgr",
"3ByteBgr",
"4ByteAbgr",
"4ByteAbgrPre",
"Short565",
"Short555",
"ByteGray",
"ShortGray",
"ByteBinary",
"ByteIndexed",
};
public static String Descriptions[] = {
"Custom Image",
"32-bit XRGB Packed Image",
"32-bit ARGB Packed Image",
"32-bit ARGB Alpha Premultiplied Packed Image",
"32-bit XBGR Packed Image",
"3-byte BGR Component Image",
"4-byte ABGR Component Image",
"4-byte ABGR Alpha Premultiplied Component Image",
"16-bit 565 RGB Packed Image",
"15-bit 555 RGB Packed Image",
"8-bit Grayscale Image",
"16-bit Grayscale Image",
"1-bit Binary Image",
"8-bit Indexed Image",
};
public BufImg(int type) {
super(bufimgdestroot, ShortNames[type], Descriptions[type], false);
this.type = type;
}
public String getModifierValueName(Object val) {
return "BufImg("+getNodeName()+")";
}
public void setDestination(TestEnvironment env) {
if (img == null) {
img = new BufferedImage(env.getWidth(), env.getHeight(), type);
}
env.setTestImage(img);
}
}
public static class CustomImg extends Destinations {
private Image img;
public CustomImg() {
super(bufimgdestroot,
"custom",
"Custom (3-float RGB) Image",
false);
}
public String getModifierValueName(Object val) {
return "CustomImg";
}
public void setDestination(TestEnvironment env) {
if (img == null) {
ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
ComponentColorModel cm =
new ComponentColorModel(cs, false, false,
Transparency.OPAQUE,
DataBuffer.TYPE_FLOAT);
WritableRaster raster =
cm.createCompatibleWritableRaster(env.getWidth(),
env.getHeight());
img = new BufferedImage(cm, raster, false, null);
}
env.setTestImage(img);
}
}
}