stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

7117914: Fix javac warnings in src/share/classes/sun/java2d

Browse Source 
Fix some javac warnings in java2d related code for the Warning Cleanup Day.

Reviewed-by: prr, flar
This commit is contained in:
Mario Torre 2011-12-03 15:40:49 +01:00
parent 469f89911f
commit 163d5239e1
20 changed files with 132 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
jdk/src/share/classes/java/awt/geom/Path2D.java
View File

@ -667,7 +667,8 @@ public abstract class Path2D implements Shape, Cloneable {
// Collapse out initial moveto/lineto // Collapse out initial moveto/lineto
break; break;
} }
// NO BREAK; lineTo(coords[0], coords[1]);
break;
case SEG_LINETO: case SEG_LINETO:
lineTo(coords[0], coords[1]); lineTo(coords[0], coords[1]);
break; break;
@ -1392,7 +1393,8 @@ public abstract class Path2D implements Shape, Cloneable {
// Collapse out initial moveto/lineto // Collapse out initial moveto/lineto
break; break;
} }
// NO BREAK; lineTo(coords[0], coords[1]);
break;
case SEG_LINETO: case SEG_LINETO:
lineTo(coords[0], coords[1]); lineTo(coords[0], coords[1]);
break; break;
@ -2456,7 +2458,7 @@ public abstract class Path2D implements Shape, Cloneable {
} }
} }
} }
s.writeByte((byte) SERIAL_PATH_END); s.writeByte(SERIAL_PATH_END);
} }
final void readObject(java.io.ObjectInputStream s, boolean storedbl) final void readObject(java.io.ObjectInputStream s, boolean storedbl)

4
jdk/src/share/classes/sun/awt/image/BufImgSurfaceData.java
View File

@ -323,8 +323,8 @@ public class BufImgSurfaceData extends SurfaceData {
} }
public RenderLoops getRenderLoops(SunGraphics2D sg2d) { public RenderLoops getRenderLoops(SunGraphics2D sg2d) {
if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR && if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR &&
sg2d.compositeState <= sg2d.COMP_ISCOPY) sg2d.compositeState <= SunGraphics2D.COMP_ISCOPY)
{ {
return solidloops; return solidloops;
} }

6
jdk/src/share/classes/sun/java2d/SunGraphics2D.java
View File

@ -941,7 +941,7 @@ public final class SunGraphics2D
} }
} }
} }
Class paintClass = paint.getClass(); Class<? extends Paint> paintClass = paint.getClass();
if (paintClass == GradientPaint.class) { if (paintClass == GradientPaint.class) {
paintState = PAINT_GRADIENT; paintState = PAINT_GRADIENT;
} else if (paintClass == LinearGradientPaint.class) { } else if (paintClass == LinearGradientPaint.class) {
@ -1280,7 +1280,7 @@ public final class SunGraphics2D
interpolationHint = -1; interpolationHint = -1;
interpolationType = AffineTransformOp.TYPE_NEAREST_NEIGHBOR; interpolationType = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;
boolean customHintPresent = false; boolean customHintPresent = false;
Iterator iter = hints.keySet().iterator(); Iterator<?> iter = hints.keySet().iterator();
while (iter.hasNext()) { while (iter.hasNext()) {
Object key = iter.next(); Object key = iter.next();
if (key == SunHints.KEY_RENDERING || if (key == SunHints.KEY_RENDERING ||
@ -1311,7 +1311,7 @@ public final class SunGraphics2D
*/ */
public void addRenderingHints(Map<?,?> hints) { public void addRenderingHints(Map<?,?> hints) {
boolean customHintPresent = false; boolean customHintPresent = false;
Iterator iter = hints.keySet().iterator(); Iterator<?> iter = hints.keySet().iterator();
while (iter.hasNext()) { while (iter.hasNext()) {
Object key = iter.next(); Object key = iter.next();
if (key == SunHints.KEY_RENDERING || if (key == SunHints.KEY_RENDERING ||

48
jdk/src/share/classes/sun/java2d/SurfaceData.java
View File

@ -520,8 +520,8 @@ public abstract class SurfaceData
} }
public boolean canRenderParallelograms(SunGraphics2D sg2d) { public boolean canRenderParallelograms(SunGraphics2D sg2d) {
if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) { if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) {
if (sg2d.compositeState == sg2d.COMP_XOR) { if (sg2d.compositeState == SunGraphics2D.COMP_XOR) {
if (havePgramXORLoop == LOOP_UNKNOWN) { if (havePgramXORLoop == LOOP_UNKNOWN) {
FillParallelogram loop = FillParallelogram loop =
FillParallelogram.locate(SurfaceType.AnyColor, FillParallelogram.locate(SurfaceType.AnyColor,
@ -531,9 +531,9 @@ public abstract class SurfaceData
(loop != null) ? LOOP_FOUND : LOOP_NOTFOUND; (loop != null) ? LOOP_FOUND : LOOP_NOTFOUND;
} }
return havePgramXORLoop == LOOP_FOUND; return havePgramXORLoop == LOOP_FOUND;
} else if (sg2d.compositeState <= sg2d.COMP_ISCOPY && } else if (sg2d.compositeState <= SunGraphics2D.COMP_ISCOPY &&
sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON && sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON &&
sg2d.clipState != sg2d.CLIP_SHAPE) sg2d.clipState != SunGraphics2D.CLIP_SHAPE)
{ {
if (havePgramSolidLoop == LOOP_UNKNOWN) { if (havePgramSolidLoop == LOOP_UNKNOWN) {
FillParallelogram loop = FillParallelogram loop =
@ -551,8 +551,8 @@ public abstract class SurfaceData
public void validatePipe(SunGraphics2D sg2d) { public void validatePipe(SunGraphics2D sg2d) {
sg2d.imagepipe = imagepipe; sg2d.imagepipe = imagepipe;
if (sg2d.compositeState == sg2d.COMP_XOR) { if (sg2d.compositeState == SunGraphics2D.COMP_XOR) {
if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) { if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
sg2d.drawpipe = paintViaShape; sg2d.drawpipe = paintViaShape;
sg2d.fillpipe = paintViaShape; sg2d.fillpipe = paintViaShape;
sg2d.shapepipe = paintShape; sg2d.shapepipe = paintShape;
@ -576,7 +576,7 @@ public abstract class SurfaceData
converter = colorViaShape; converter = colorViaShape;
sg2d.shapepipe = colorPrimitives; sg2d.shapepipe = colorPrimitives;
} }
if (sg2d.clipState == sg2d.CLIP_SHAPE) { if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
sg2d.drawpipe = converter; sg2d.drawpipe = converter;
sg2d.fillpipe = converter; sg2d.fillpipe = converter;
// REMIND: We should not be changing text strategies // REMIND: We should not be changing text strategies
@ -589,11 +589,11 @@ public abstract class SurfaceData
// which is not defined for XOR. // which is not defined for XOR.
sg2d.textpipe = outlineTextRenderer; sg2d.textpipe = outlineTextRenderer;
} else { } else {
if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) { if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
sg2d.drawpipe = converter; sg2d.drawpipe = converter;
sg2d.fillpipe = converter; sg2d.fillpipe = converter;
} else { } else {
if (sg2d.strokeState != sg2d.STROKE_THIN) { if (sg2d.strokeState != SunGraphics2D.STROKE_THIN) {
sg2d.drawpipe = converter; sg2d.drawpipe = converter;
} else { } else {
sg2d.drawpipe = colorPrimitives; sg2d.drawpipe = colorPrimitives;
@ -604,9 +604,9 @@ public abstract class SurfaceData
} }
// assert(sg2d.surfaceData == this); // assert(sg2d.surfaceData == this);
} }
} else if (sg2d.compositeState == sg2d.COMP_CUSTOM) { } else if (sg2d.compositeState == SunGraphics2D.COMP_CUSTOM) {
if (sg2d.antialiasHint == SunHints.INTVAL_ANTIALIAS_ON) { if (sg2d.antialiasHint == SunHints.INTVAL_ANTIALIAS_ON) {
if (sg2d.clipState == sg2d.CLIP_SHAPE) { if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
sg2d.drawpipe = AAClipCompViaShape; sg2d.drawpipe = AAClipCompViaShape;
sg2d.fillpipe = AAClipCompViaShape; sg2d.fillpipe = AAClipCompViaShape;
sg2d.shapepipe = AAClipCompViaShape; sg2d.shapepipe = AAClipCompViaShape;
@ -621,7 +621,7 @@ public abstract class SurfaceData
sg2d.drawpipe = compViaShape; sg2d.drawpipe = compViaShape;
sg2d.fillpipe = compViaShape; sg2d.fillpipe = compViaShape;
sg2d.shapepipe = compShape; sg2d.shapepipe = compShape;
if (sg2d.clipState == sg2d.CLIP_SHAPE) { if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
sg2d.textpipe = clipCompText; sg2d.textpipe = clipCompText;
} else { } else {
sg2d.textpipe = compText; sg2d.textpipe = compText;
@ -631,7 +631,7 @@ public abstract class SurfaceData
sg2d.alphafill = getMaskFill(sg2d); sg2d.alphafill = getMaskFill(sg2d);
// assert(sg2d.surfaceData == this); // assert(sg2d.surfaceData == this);
if (sg2d.alphafill != null) { if (sg2d.alphafill != null) {
if (sg2d.clipState == sg2d.CLIP_SHAPE) { if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
sg2d.drawpipe = AAClipColorViaShape; sg2d.drawpipe = AAClipColorViaShape;
sg2d.fillpipe = AAClipColorViaShape; sg2d.fillpipe = AAClipColorViaShape;
sg2d.shapepipe = AAClipColorViaShape; sg2d.shapepipe = AAClipColorViaShape;
@ -644,8 +644,8 @@ public abstract class SurfaceData
sg2d.drawpipe = converter; sg2d.drawpipe = converter;
sg2d.fillpipe = converter; sg2d.fillpipe = converter;
sg2d.shapepipe = converter; sg2d.shapepipe = converter;
if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR || if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR ||
sg2d.compositeState > sg2d.COMP_ISCOPY) sg2d.compositeState > SunGraphics2D.COMP_ISCOPY)
{ {
sg2d.textpipe = colorText; sg2d.textpipe = colorText;
} else { } else {
@ -653,7 +653,7 @@ public abstract class SurfaceData
} }
} }
} else { } else {
if (sg2d.clipState == sg2d.CLIP_SHAPE) { if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
sg2d.drawpipe = AAClipPaintViaShape; sg2d.drawpipe = AAClipPaintViaShape;
sg2d.fillpipe = AAClipPaintViaShape; sg2d.fillpipe = AAClipPaintViaShape;
sg2d.shapepipe = AAClipPaintViaShape; sg2d.shapepipe = AAClipPaintViaShape;
@ -665,9 +665,9 @@ public abstract class SurfaceData
sg2d.textpipe = paintText; sg2d.textpipe = paintText;
} }
} }
} else if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR || } else if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR ||
sg2d.compositeState > sg2d.COMP_ISCOPY || sg2d.compositeState > SunGraphics2D.COMP_ISCOPY ||
sg2d.clipState == sg2d.CLIP_SHAPE) sg2d.clipState == SunGraphics2D.CLIP_SHAPE)
{ {
sg2d.drawpipe = paintViaShape; sg2d.drawpipe = paintViaShape;
sg2d.fillpipe = paintViaShape; sg2d.fillpipe = paintViaShape;
@ -675,13 +675,13 @@ public abstract class SurfaceData
sg2d.alphafill = getMaskFill(sg2d); sg2d.alphafill = getMaskFill(sg2d);
// assert(sg2d.surfaceData == this); // assert(sg2d.surfaceData == this);
if (sg2d.alphafill != null) { if (sg2d.alphafill != null) {
if (sg2d.clipState == sg2d.CLIP_SHAPE) { if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
sg2d.textpipe = clipColorText; sg2d.textpipe = clipColorText;
} else { } else {
sg2d.textpipe = colorText; sg2d.textpipe = colorText;
} }
} else { } else {
if (sg2d.clipState == sg2d.CLIP_SHAPE) { if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
sg2d.textpipe = clipPaintText; sg2d.textpipe = clipPaintText;
} else { } else {
sg2d.textpipe = paintText; sg2d.textpipe = paintText;
@ -700,11 +700,11 @@ public abstract class SurfaceData
converter = colorViaShape; converter = colorViaShape;
sg2d.shapepipe = colorPrimitives; sg2d.shapepipe = colorPrimitives;
} }
if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) { if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
sg2d.drawpipe = converter; sg2d.drawpipe = converter;
sg2d.fillpipe = converter; sg2d.fillpipe = converter;
} else { } else {
if (sg2d.strokeState != sg2d.STROKE_THIN) { if (sg2d.strokeState != SunGraphics2D.STROKE_THIN) {
sg2d.drawpipe = converter; sg2d.drawpipe = converter;
} else { } else {
sg2d.drawpipe = colorPrimitives; sg2d.drawpipe = colorPrimitives;
@ -817,7 +817,7 @@ public abstract class SurfaceData
private static CompositeType getFillCompositeType(SunGraphics2D sg2d) { private static CompositeType getFillCompositeType(SunGraphics2D sg2d) {
CompositeType compType = sg2d.imageComp; CompositeType compType = sg2d.imageComp;
if (sg2d.compositeState == sg2d.COMP_ISCOPY) { if (sg2d.compositeState == SunGraphics2D.COMP_ISCOPY) {
if (compType == CompositeType.SrcOverNoEa) { if (compType == CompositeType.SrcOverNoEa) {
compType = CompositeType.OpaqueSrcOverNoEa; compType = CompositeType.OpaqueSrcOverNoEa;
} else { } else {

4
jdk/src/share/classes/sun/java2d/SurfaceDataProxy.java
View File

@ -71,7 +71,7 @@ public abstract class SurfaceDataProxy
static { static {
cachingAllowed = true; cachingAllowed = true;
String manimg = (String)AccessController.doPrivileged( String manimg = AccessController.doPrivileged(
new GetPropertyAction("sun.java2d.managedimages")); new GetPropertyAction("sun.java2d.managedimages"));
if (manimg != null && manimg.equals("false")) { if (manimg != null && manimg.equals("false")) {
cachingAllowed = false; cachingAllowed = false;
@ -79,7 +79,7 @@ public abstract class SurfaceDataProxy
} }
defaultThreshold = 1; defaultThreshold = 1;
String num = (String)AccessController.doPrivileged( String num = AccessController.doPrivileged(
new GetPropertyAction("sun.java2d.accthreshold")); new GetPropertyAction("sun.java2d.accthreshold"));
if (num != null) { if (num != null) {
try { try {

14
jdk/src/share/classes/sun/java2d/loops/GraphicsPrimitive.java
View File

@ -328,7 +328,7 @@ public abstract class GraphicsPrimitive {
static { static {
GetPropertyAction gpa = new GetPropertyAction("sun.java2d.trace"); GetPropertyAction gpa = new GetPropertyAction("sun.java2d.trace");
String trace = (String)AccessController.doPrivileged(gpa); String trace = AccessController.doPrivileged(gpa);
if (trace != null) { if (trace != null) {
boolean verbose = false; boolean verbose = false;
int traceflags = 0; int traceflags = 0;
@ -391,9 +391,9 @@ public abstract class GraphicsPrimitive {
private static PrintStream getTraceOutputFile() { private static PrintStream getTraceOutputFile() {
if (traceout == null) { if (traceout == null) {
if (tracefile != null) { if (tracefile != null) {
Object o = FileOutputStream o = AccessController.doPrivileged(
AccessController.doPrivileged(new PrivilegedAction() { new PrivilegedAction<FileOutputStream>() {
public Object run() { public FileOutputStream run() {
try { try {
return new FileOutputStream(tracefile); return new FileOutputStream(tracefile);
} catch (FileNotFoundException e) { } catch (FileNotFoundException e) {
@ -402,7 +402,7 @@ public abstract class GraphicsPrimitive {
} }
}); });
if (o != null) { if (o != null) {
traceout = new PrintStream((OutputStream) o); traceout = new PrintStream(o);
} else { } else {
traceout = System.err; traceout = System.err;
} }
@ -415,8 +415,8 @@ public abstract class GraphicsPrimitive {
public static class TraceReporter extends Thread { public static class TraceReporter extends Thread {
public static void setShutdownHook() { public static void setShutdownHook() {
AccessController.doPrivileged(new PrivilegedAction() { AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Object run() { public Void run() {
TraceReporter t = new TraceReporter(); TraceReporter t = new TraceReporter();
t.setContextClassLoader(null); t.setContextClassLoader(null);
Runtime.getRuntime().addShutdownHook(t); Runtime.getRuntime().addShutdownHook(t);

4
jdk/src/share/classes/sun/java2d/loops/SurfaceType.java
View File

@ -56,7 +56,7 @@ import java.util.HashMap;
public final class SurfaceType { public final class SurfaceType {
private static int unusedUID = 1; private static int unusedUID = 1;
private static HashMap surfaceUIDMap = new HashMap(100); private static HashMap<String, Integer> surfaceUIDMap = new HashMap<>(100);
/* /*
* CONSTANTS USED BY ALL PRIMITIVES TO DESCRIBE THE SURFACES * CONSTANTS USED BY ALL PRIMITIVES TO DESCRIBE THE SURFACES
@ -402,7 +402,7 @@ public final class SurfaceType {
} }
public synchronized static final int makeUniqueID(String desc) { public synchronized static final int makeUniqueID(String desc) {
Integer i = (Integer) surfaceUIDMap.get((Object) desc); Integer i = surfaceUIDMap.get(desc);
if (i == null) { if (i == null) {
if (unusedUID > 255) { if (unusedUID > 255) {

4
jdk/src/share/classes/sun/java2d/opengl/OGLBufImgOps.java
View File

@ -78,12 +78,12 @@ class OGLBufImgOps extends BufferedBufImgOps {
} }
SurfaceData srcData = SurfaceData srcData =
dstData.getSourceSurfaceData(img, sg.TRANSFORM_ISIDENT, dstData.getSourceSurfaceData(img, SunGraphics2D.TRANSFORM_ISIDENT,
CompositeType.SrcOver, null); CompositeType.SrcOver, null);
if (!(srcData instanceof OGLSurfaceData)) { if (!(srcData instanceof OGLSurfaceData)) {
// REMIND: this hack tries to ensure that we have a cached texture // REMIND: this hack tries to ensure that we have a cached texture
srcData = srcData =
dstData.getSourceSurfaceData(img, sg.TRANSFORM_ISIDENT, dstData.getSourceSurfaceData(img, SunGraphics2D.TRANSFORM_ISIDENT,
CompositeType.SrcOver, null); CompositeType.SrcOver, null);
if (!(srcData instanceof OGLSurfaceData)) { if (!(srcData instanceof OGLSurfaceData)) {
return false; return false;

2
jdk/src/share/classes/sun/java2d/opengl/OGLDrawImage.java
View File

@ -60,7 +60,7 @@ public class OGLDrawImage extends DrawImage {
SurfaceData dstData = sg.surfaceData; SurfaceData dstData = sg.surfaceData;
SurfaceData srcData = SurfaceData srcData =
dstData.getSourceSurfaceData(img, dstData.getSourceSurfaceData(img,
sg.TRANSFORM_GENERIC, SunGraphics2D.TRANSFORM_GENERIC,
sg.imageComp, sg.imageComp,
bgColor); bgColor);

6
jdk/src/share/classes/sun/java2d/opengl/OGLPaints.java
View File

@ -123,14 +123,16 @@ abstract class OGLPaints {
} }
SurfaceData srcData = SurfaceData srcData =
dstData.getSourceSurfaceData(bi, sg2d.TRANSFORM_ISIDENT, dstData.getSourceSurfaceData(bi,
SunGraphics2D.TRANSFORM_ISIDENT,
CompositeType.SrcOver, null); CompositeType.SrcOver, null);
if (!(srcData instanceof OGLSurfaceData)) { if (!(srcData instanceof OGLSurfaceData)) {
// REMIND: this is a hack that attempts to cache the system // REMIND: this is a hack that attempts to cache the system
// memory image from the TexturePaint instance into an // memory image from the TexturePaint instance into an
// OpenGL texture... // OpenGL texture...
srcData = srcData =
dstData.getSourceSurfaceData(bi, sg2d.TRANSFORM_ISIDENT, dstData.getSourceSurfaceData(bi,
SunGraphics2D.TRANSFORM_ISIDENT,
CompositeType.SrcOver, null); CompositeType.SrcOver, null);
if (!(srcData instanceof OGLSurfaceData)) { if (!(srcData instanceof OGLSurfaceData)) {
return false; return false;

32
jdk/src/share/classes/sun/java2d/opengl/OGLSurfaceData.java
View File

@ -428,18 +428,18 @@ public abstract class OGLSurfaceData extends SurfaceData
// by the CompositeType.SrcNoEa (any color) test below.) // by the CompositeType.SrcNoEa (any color) test below.)
if (/* CompositeType.SrcNoEa (any color) */ if (/* CompositeType.SrcNoEa (any color) */
(sg2d.compositeState <= sg2d.COMP_ISCOPY && (sg2d.compositeState <= SunGraphics2D.COMP_ISCOPY &&
sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) || sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) ||
/* CompositeType.SrcOver (any color) */ /* CompositeType.SrcOver (any color) */
(sg2d.compositeState == sg2d.COMP_ALPHA && (sg2d.compositeState == SunGraphics2D.COMP_ALPHA &&
sg2d.paintState <= sg2d.PAINT_ALPHACOLOR && sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR &&
(((AlphaComposite)sg2d.composite).getRule() == (((AlphaComposite)sg2d.composite).getRule() ==
AlphaComposite.SRC_OVER)) || AlphaComposite.SRC_OVER)) ||
/* CompositeType.Xor (any color) */ /* CompositeType.Xor (any color) */
(sg2d.compositeState == sg2d.COMP_XOR && (sg2d.compositeState == SunGraphics2D.COMP_XOR &&
sg2d.paintState <= sg2d.PAINT_ALPHACOLOR)) sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR))
{ {
textpipe = oglTextPipe; textpipe = oglTextPipe;
} else { } else {
@ -454,12 +454,12 @@ public abstract class OGLSurfaceData extends SurfaceData
OGLRenderer nonTxPipe = null; OGLRenderer nonTxPipe = null;
if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON) { if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON) {
if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) { if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) {
if (sg2d.compositeState <= sg2d.COMP_XOR) { if (sg2d.compositeState <= SunGraphics2D.COMP_XOR) {
txPipe = oglTxRenderPipe; txPipe = oglTxRenderPipe;
nonTxPipe = oglRenderPipe; nonTxPipe = oglRenderPipe;
} }
} else if (sg2d.compositeState <= sg2d.COMP_ALPHA) { } else if (sg2d.compositeState <= SunGraphics2D.COMP_ALPHA) {
if (OGLPaints.isValid(sg2d)) { if (OGLPaints.isValid(sg2d)) {
txPipe = oglTxRenderPipe; txPipe = oglTxRenderPipe;
nonTxPipe = oglRenderPipe; nonTxPipe = oglRenderPipe;
@ -467,7 +467,7 @@ public abstract class OGLSurfaceData extends SurfaceData
// custom paints handled by super.validatePipe() below // custom paints handled by super.validatePipe() below
} }
} else { } else {
if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR) { if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR) {
if (graphicsConfig.isCapPresent(CAPS_PS30) && if (graphicsConfig.isCapPresent(CAPS_PS30) &&
(sg2d.imageComp == CompositeType.SrcOverNoEa || (sg2d.imageComp == CompositeType.SrcOverNoEa ||
sg2d.imageComp == CompositeType.SrcOver)) sg2d.imageComp == CompositeType.SrcOver))
@ -484,7 +484,7 @@ public abstract class OGLSurfaceData extends SurfaceData
sg2d.drawpipe = aaConverter; sg2d.drawpipe = aaConverter;
sg2d.fillpipe = aaConverter; sg2d.fillpipe = aaConverter;
sg2d.shapepipe = aaConverter; sg2d.shapepipe = aaConverter;
} else if (sg2d.compositeState == sg2d.COMP_XOR) { } else if (sg2d.compositeState == SunGraphics2D.COMP_XOR) {
// install the solid pipes when AA and XOR are both enabled // install the solid pipes when AA and XOR are both enabled
txPipe = oglTxRenderPipe; txPipe = oglTxRenderPipe;
nonTxPipe = oglRenderPipe; nonTxPipe = oglRenderPipe;
@ -494,10 +494,10 @@ public abstract class OGLSurfaceData extends SurfaceData
} }
if (txPipe != null) { if (txPipe != null) {
if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) { if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
sg2d.drawpipe = txPipe; sg2d.drawpipe = txPipe;
sg2d.fillpipe = txPipe; sg2d.fillpipe = txPipe;
} else if (sg2d.strokeState != sg2d.STROKE_THIN) { } else if (sg2d.strokeState != SunGraphics2D.STROKE_THIN) {
sg2d.drawpipe = txPipe; sg2d.drawpipe = txPipe;
sg2d.fillpipe = nonTxPipe; sg2d.fillpipe = nonTxPipe;
} else { } else {
@ -524,7 +524,7 @@ public abstract class OGLSurfaceData extends SurfaceData
@Override @Override
protected MaskFill getMaskFill(SunGraphics2D sg2d) { protected MaskFill getMaskFill(SunGraphics2D sg2d) {
if (sg2d.paintState > sg2d.PAINT_ALPHACOLOR) { if (sg2d.paintState > SunGraphics2D.PAINT_ALPHACOLOR) {
/* /*
* We can only accelerate non-Color MaskFill operations if * We can only accelerate non-Color MaskFill operations if
* all of the following conditions hold true: * all of the following conditions hold true:
@ -548,8 +548,8 @@ public abstract class OGLSurfaceData extends SurfaceData
public boolean copyArea(SunGraphics2D sg2d, public boolean copyArea(SunGraphics2D sg2d,
int x, int y, int w, int h, int dx, int dy) int x, int y, int w, int h, int dx, int dy)
{ {
if (sg2d.transformState < sg2d.TRANSFORM_TRANSLATESCALE && if (sg2d.transformState < SunGraphics2D.TRANSFORM_TRANSLATESCALE &&
sg2d.compositeState < sg2d.COMP_XOR) sg2d.compositeState < SunGraphics2D.COMP_XOR)
{ {
x += sg2d.transX; x += sg2d.transX;
y += sg2d.transY; y += sg2d.transY;

2
jdk/src/share/classes/sun/java2d/pipe/AAShapePipe.java
View File

@ -144,7 +144,7 @@ public class AAShapePipe
public void renderPath(SunGraphics2D sg, Shape s, BasicStroke bs) { public void renderPath(SunGraphics2D sg, Shape s, BasicStroke bs) {
boolean adjust = (bs != null && boolean adjust = (bs != null &&
sg.strokeHint != SunHints.INTVAL_STROKE_PURE); sg.strokeHint != SunHints.INTVAL_STROKE_PURE);
boolean thin = (sg.strokeState <= sg.STROKE_THINDASHED); boolean thin = (sg.strokeState <= SunGraphics2D.STROKE_THINDASHED);
Region clip = sg.getCompClip(); Region clip = sg.getCompClip();
int abox[] = new int[4]; int abox[] = new int[4];

2
jdk/src/share/classes/sun/java2d/pipe/BufferedPaints.java
View File

@ -247,7 +247,7 @@ public class BufferedPaints {
BufferedImage bi = paint.getImage(); BufferedImage bi = paint.getImage();
SurfaceData dstData = sg2d.surfaceData; SurfaceData dstData = sg2d.surfaceData;
SurfaceData srcData = SurfaceData srcData =
dstData.getSourceSurfaceData(bi, sg2d.TRANSFORM_ISIDENT, dstData.getSourceSurfaceData(bi, SunGraphics2D.TRANSFORM_ISIDENT,
CompositeType.SrcOver, null); CompositeType.SrcOver, null);
boolean filter = boolean filter =
(sg2d.interpolationType != (sg2d.interpolationType !=

14
jdk/src/share/classes/sun/java2d/pipe/BufferedRenderPipe.java
View File

@ -508,9 +508,9 @@ public abstract class BufferedRenderPipe
} }
public void draw(SunGraphics2D sg2d, Shape s) { public void draw(SunGraphics2D sg2d, Shape s) {
if (sg2d.strokeState == sg2d.STROKE_THIN) { if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
if (s instanceof Polygon) { if (s instanceof Polygon) {
if (sg2d.transformState < sg2d.TRANSFORM_TRANSLATESCALE) { if (sg2d.transformState < SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
Polygon p = (Polygon)s; Polygon p = (Polygon)s;
drawPolygon(sg2d, p.xpoints, p.ypoints, p.npoints); drawPolygon(sg2d, p.xpoints, p.ypoints, p.npoints);
return; return;
@ -518,7 +518,7 @@ public abstract class BufferedRenderPipe
} }
Path2D.Float p2df; Path2D.Float p2df;
int transx, transy; int transx, transy;
if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) { if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
if (s instanceof Path2D.Float) { if (s instanceof Path2D.Float) {
p2df = (Path2D.Float)s; p2df = (Path2D.Float)s;
} else { } else {
@ -532,7 +532,7 @@ public abstract class BufferedRenderPipe
transy = 0; transy = 0;
} }
drawPath(sg2d, p2df, transx, transy); drawPath(sg2d, p2df, transx, transy);
} else if (sg2d.strokeState < sg2d.STROKE_CUSTOM) { } else if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM) {
ShapeSpanIterator si = LoopPipe.getStrokeSpans(sg2d, s); ShapeSpanIterator si = LoopPipe.getStrokeSpans(sg2d, s);
try { try {
fillSpans(sg2d, si, 0, 0); fillSpans(sg2d, si, 0, 0);
@ -547,11 +547,11 @@ public abstract class BufferedRenderPipe
public void fill(SunGraphics2D sg2d, Shape s) { public void fill(SunGraphics2D sg2d, Shape s) {
int transx, transy; int transx, transy;
if (sg2d.strokeState == sg2d.STROKE_THIN) { if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
// Here we are able to use fillPath() for // Here we are able to use fillPath() for
// high-quality fills. // high-quality fills.
Path2D.Float p2df; Path2D.Float p2df;
if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) { if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
if (s instanceof Path2D.Float) { if (s instanceof Path2D.Float) {
p2df = (Path2D.Float)s; p2df = (Path2D.Float)s;
} else { } else {
@ -569,7 +569,7 @@ public abstract class BufferedRenderPipe
} }
AffineTransform at; AffineTransform at;
if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) { if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
// Transform (translation) will be done by FillSpans (we could // Transform (translation) will be done by FillSpans (we could
// delegate to fillPolygon() here, but most hardware accelerated // delegate to fillPolygon() here, but most hardware accelerated
// libraries cannot handle non-convex polygons, so we will use // libraries cannot handle non-convex polygons, so we will use

35
jdk/src/share/classes/sun/java2d/pipe/DrawImage.java
View File

@ -146,7 +146,7 @@ public class DrawImage implements DrawImagePipe
int imgh = img.getHeight(null); int imgh = img.getHeight(null);
boolean checkfinalxform; boolean checkfinalxform;
if (sg.transformState <= sg.TRANSFORM_ANY_TRANSLATE && if (sg.transformState <= SunGraphics2D.TRANSFORM_ANY_TRANSLATE &&
(txtype == AffineTransform.TYPE_IDENTITY || (txtype == AffineTransform.TYPE_IDENTITY ||
txtype == AffineTransform.TYPE_TRANSLATION)) txtype == AffineTransform.TYPE_TRANSLATION))
{ {
@ -166,7 +166,7 @@ public class DrawImage implements DrawImagePipe
return; return;
} }
checkfinalxform = false; checkfinalxform = false;
} else if (sg.transformState <= sg.TRANSFORM_TRANSLATESCALE && } else if (sg.transformState <= SunGraphics2D.TRANSFORM_TRANSLATESCALE &&
((txtype & (AffineTransform.TYPE_FLIP | ((txtype & (AffineTransform.TYPE_FLIP |
AffineTransform.TYPE_MASK_ROTATION | AffineTransform.TYPE_MASK_ROTATION |
AffineTransform.TYPE_GENERAL_TRANSFORM)) == 0)) AffineTransform.TYPE_GENERAL_TRANSFORM)) == 0))
@ -344,14 +344,14 @@ public class DrawImage implements DrawImagePipe
Region clip = sg.getCompClip(); Region clip = sg.getCompClip();
SurfaceData dstData = sg.surfaceData; SurfaceData dstData = sg.surfaceData;
SurfaceData srcData = dstData.getSourceSurfaceData(img, SurfaceData srcData = dstData.getSourceSurfaceData(img,
sg.TRANSFORM_GENERIC, SunGraphics2D.TRANSFORM_GENERIC,
sg.imageComp, sg.imageComp,
bgColor); bgColor);
if (srcData == null) { if (srcData == null) {
img = getBufferedImage(img); img = getBufferedImage(img);
srcData = dstData.getSourceSurfaceData(img, srcData = dstData.getSourceSurfaceData(img,
sg.TRANSFORM_GENERIC, SunGraphics2D.TRANSFORM_GENERIC,
sg.imageComp, sg.imageComp,
bgColor); bgColor);
if (srcData == null) { if (srcData == null) {
@ -372,7 +372,7 @@ public class DrawImage implements DrawImagePipe
sx1 = sy1 = 0; sx1 = sy1 = 0;
srcData = dstData.getSourceSurfaceData(img, srcData = dstData.getSourceSurfaceData(img,
sg.TRANSFORM_GENERIC, SunGraphics2D.TRANSFORM_GENERIC,
sg.imageComp, sg.imageComp,
bgColor); bgColor);
} }
@ -398,7 +398,7 @@ public class DrawImage implements DrawImagePipe
sx1 = sy1 = 0; sx1 = sy1 = 0;
srcData = dstData.getSourceSurfaceData(img, srcData = dstData.getSourceSurfaceData(img,
sg.TRANSFORM_GENERIC, SunGraphics2D.TRANSFORM_GENERIC,
sg.imageComp, sg.imageComp,
null); null);
srcType = srcData.getSurfaceType(); srcType = srcData.getSurfaceType();
@ -449,7 +449,7 @@ public class DrawImage implements DrawImagePipe
SurfaceType dstType = dstData.getSurfaceType(); SurfaceType dstType = dstData.getSurfaceType();
MaskBlit maskblit; MaskBlit maskblit;
Blit blit; Blit blit;
if (sg.compositeState <= sg.COMP_ALPHA) { if (sg.compositeState <= SunGraphics2D.COMP_ALPHA) {
/* NOTE: We either have, or we can make, /* NOTE: We either have, or we can make,
* a MaskBlit for any alpha composite type * a MaskBlit for any alpha composite type
*/ */
@ -565,7 +565,7 @@ public class DrawImage implements DrawImagePipe
while (true) { while (true) {
SurfaceData srcData = SurfaceData srcData =
dstData.getSourceSurfaceData(img, dstData.getSourceSurfaceData(img,
sg.TRANSFORM_ISIDENT, SunGraphics2D.TRANSFORM_ISIDENT,
sg.imageComp, sg.imageComp,
bgColor); bgColor);
if (srcData == null) { if (srcData == null) {
@ -628,7 +628,7 @@ public class DrawImage implements DrawImagePipe
while (true) { while (true) {
SurfaceData srcData = SurfaceData srcData =
dstData.getSourceSurfaceData(img, dstData.getSourceSurfaceData(img,
sg.TRANSFORM_TRANSLATESCALE, SunGraphics2D.TRANSFORM_TRANSLATESCALE,
sg.imageComp, sg.imageComp,
bgColor); bgColor);
@ -800,11 +800,11 @@ public class DrawImage implements DrawImagePipe
public static boolean isSimpleTranslate(SunGraphics2D sg) { public static boolean isSimpleTranslate(SunGraphics2D sg) {
int ts = sg.transformState; int ts = sg.transformState;
if (ts <= sg.TRANSFORM_INT_TRANSLATE) { if (ts <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
// Integer translates are always "simple" // Integer translates are always "simple"
return true; return true;
} }
if (ts >= sg.TRANSFORM_TRANSLATESCALE) { if (ts >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
// Scales and beyond are always "not simple" // Scales and beyond are always "not simple"
return false; return false;
} }
@ -846,8 +846,11 @@ public class DrawImage implements DrawImagePipe
} }
int type = tx.getType(); int type = tx.getType();
boolean needTrans = boolean needTrans =
((type&(tx.TYPE_MASK_ROTATION|tx.TYPE_GENERAL_TRANSFORM)) != 0); ((type & (AffineTransform.TYPE_MASK_ROTATION |
if (! needTrans && type != tx.TYPE_TRANSLATION && type != tx.TYPE_IDENTITY) AffineTransform.TYPE_GENERAL_TRANSFORM)) != 0);
if (! needTrans &&
type != AffineTransform.TYPE_TRANSLATION &&
type != AffineTransform.TYPE_IDENTITY)
{ {
double[] mtx = new double[4]; double[] mtx = new double[4];
tx.getMatrix(mtx); tx.getMatrix(mtx);
@ -861,7 +864,7 @@ public class DrawImage implements DrawImagePipe
Raster raster = bImg.getRaster(); Raster raster = bImg.getRaster();
IndexColorModel icm = (IndexColorModel) cm; IndexColorModel icm = (IndexColorModel) cm;
// Just need to make sure that we have a transparent pixel // Just need to make sure that we have a transparent pixel
if (needTrans && cm.getTransparency() == cm.OPAQUE) { if (needTrans && cm.getTransparency() == Transparency.OPAQUE) {
// Fix 4221407 // Fix 4221407
if (raster instanceof sun.awt.image.BytePackedRaster) { if (raster instanceof sun.awt.image.BytePackedRaster) {
dstCM = ColorModel.getRGBdefault(); dstCM = ColorModel.getRGBdefault();
@ -892,7 +895,7 @@ public class DrawImage implements DrawImagePipe
} /* raster instanceof sun.awt.image.BytePackedRaster */ } /* raster instanceof sun.awt.image.BytePackedRaster */
} /* if (cm.getTransparency() == cm.OPAQUE) */ } /* if (cm.getTransparency() == cm.OPAQUE) */
} /* if (cm instanceof IndexColorModel) */ } /* if (cm instanceof IndexColorModel) */
else if (needTrans && cm.getTransparency() == cm.OPAQUE) { else if (needTrans && cm.getTransparency() == Transparency.OPAQUE) {
// Need a bitmask transparency // Need a bitmask transparency
// REMIND: for now, use full transparency since no loops // REMIND: for now, use full transparency since no loops
// for bitmask // for bitmask
@ -902,7 +905,7 @@ public class DrawImage implements DrawImagePipe
else { else {
if (cm instanceof IndexColorModel || if (cm instanceof IndexColorModel ||
(needTrans && cm.getTransparency() == cm.OPAQUE)) (needTrans && cm.getTransparency() == Transparency.OPAQUE))
{ {
// Need a bitmask transparency // Need a bitmask transparency
// REMIND: for now, use full transparency since no loops // REMIND: for now, use full transparency since no loops

6
jdk/src/share/classes/sun/java2d/pipe/GlyphListPipe.java
View File

@ -54,7 +54,7 @@ public abstract class GlyphListPipe implements TextPipe {
} }
float devx, devy; float devx, devy;
if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) { if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
double origin[] = {x + info.originX, y + info.originY}; double origin[] = {x + info.originX, y + info.originY};
sg2d.transform.transform(origin, 0, origin, 0, 1); sg2d.transform.transform(origin, 0, origin, 0, 1);
devx = (float)origin[0]; devx = (float)origin[0];
@ -90,7 +90,7 @@ public abstract class GlyphListPipe implements TextPipe {
sg2d, data, offset, length, ix, iy); sg2d, data, offset, length, ix, iy);
return; return;
} }
if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) { if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
double origin[] = {ix + info.originX, iy + info.originY}; double origin[] = {ix + info.originX, iy + info.originY};
sg2d.transform.transform(origin, 0, origin, 0, 1); sg2d.transform.transform(origin, 0, origin, 0, 1);
x = (float) origin[0]; x = (float) origin[0];
@ -122,7 +122,7 @@ public abstract class GlyphListPipe implements TextPipe {
SurfaceData.outlineTextRenderer.drawGlyphVector(sg2d, gv, x, y); SurfaceData.outlineTextRenderer.drawGlyphVector(sg2d, gv, x, y);
return; return;
} }
if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) { if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
double origin[] = {x, y}; double origin[] = {x, y};
sg2d.transform.transform(origin, 0, origin, 0, 1); sg2d.transform.transform(origin, 0, origin, 0, 1);
x = (float) origin[0]; x = (float) origin[0];

16
jdk/src/share/classes/sun/java2d/pipe/LoopPipe.java
View File

@ -171,11 +171,11 @@ public class LoopPipe
public void draw(SunGraphics2D sg2d, Shape s) { public void draw(SunGraphics2D sg2d, Shape s) {
if (sg2d.strokeState == sg2d.STROKE_THIN) { if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
Path2D.Float p2df; Path2D.Float p2df;
int transX; int transX;
int transY; int transY;
if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) { if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
if (s instanceof Path2D.Float) { if (s instanceof Path2D.Float) {
p2df = (Path2D.Float)s; p2df = (Path2D.Float)s;
} else { } else {
@ -193,7 +193,7 @@ public class LoopPipe
return; return;
} }
if (sg2d.strokeState == sg2d.STROKE_CUSTOM) { if (sg2d.strokeState == SunGraphics2D.STROKE_CUSTOM) {
fill(sg2d, sg2d.stroke.createStrokedShape(s)); fill(sg2d, sg2d.stroke.createStrokedShape(s));
return; return;
} }
@ -271,7 +271,7 @@ public class LoopPipe
sr.setRule(PathIterator.WIND_NON_ZERO); sr.setRule(PathIterator.WIND_NON_ZERO);
BasicStroke bs = (BasicStroke) sg2d.stroke; BasicStroke bs = (BasicStroke) sg2d.stroke;
boolean thin = (sg2d.strokeState <= sg2d.STROKE_THINDASHED); boolean thin = (sg2d.strokeState <= SunGraphics2D.STROKE_THINDASHED);
boolean normalize = boolean normalize =
(sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE); (sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE);
@ -288,11 +288,11 @@ public class LoopPipe
} }
public void fill(SunGraphics2D sg2d, Shape s) { public void fill(SunGraphics2D sg2d, Shape s) {
if (sg2d.strokeState == sg2d.STROKE_THIN) { if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
Path2D.Float p2df; Path2D.Float p2df;
int transX; int transX;
int transY; int transY;
if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) { if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
if (s instanceof Path2D.Float) { if (s instanceof Path2D.Float) {
p2df = (Path2D.Float)s; p2df = (Path2D.Float)s;
} else { } else {
@ -314,7 +314,7 @@ public class LoopPipe
try { try {
sr.setOutputArea(sg2d.getCompClip()); sr.setOutputArea(sg2d.getCompClip());
AffineTransform at = AffineTransform at =
((sg2d.transformState == sg2d.TRANSFORM_ISIDENT) ((sg2d.transformState == SunGraphics2D.TRANSFORM_ISIDENT)
? null ? null
: sg2d.transform); : sg2d.transform);
sr.appendPath(s.getPathIterator(at)); sr.appendPath(s.getPathIterator(at));
@ -328,7 +328,7 @@ public class LoopPipe
// REMIND: Eventually, the plan is that it will not be possible for // REMIND: Eventually, the plan is that it will not be possible for
// fs to be null since the FillSpans loop will be the fundamental // fs to be null since the FillSpans loop will be the fundamental
// loop implemented for any destination type... // loop implemented for any destination type...
if (sg2d.clipState == sg2d.CLIP_SHAPE) { if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
si = sg2d.clipRegion.filter(si); si = sg2d.clipRegion.filter(si);
// REMIND: Region.filter produces a Java-only iterator // REMIND: Region.filter produces a Java-only iterator
// with no native counterpart... // with no native counterpart...

12
jdk/src/share/classes/sun/java2d/pipe/RenderingEngine.java
View File

@ -117,16 +117,16 @@ public abstract class RenderingEngine {
return reImpl; return reImpl;
} }
reImpl = (RenderingEngine) reImpl =
AccessController.doPrivileged(new PrivilegedAction() { AccessController.doPrivileged(new PrivilegedAction<RenderingEngine>() {
public Object run() { public RenderingEngine run() {
final String ductusREClass = "sun.dc.DuctusRenderingEngine"; final String ductusREClass = "sun.dc.DuctusRenderingEngine";
String reClass = String reClass =
System.getProperty("sun.java2d.renderer", ductusREClass); System.getProperty("sun.java2d.renderer", ductusREClass);
if (reClass.equals(ductusREClass)) { if (reClass.equals(ductusREClass)) {
try { try {
Class cls = Class.forName(ductusREClass); Class<?> cls = Class.forName(ductusREClass);
return cls.newInstance(); return (RenderingEngine) cls.newInstance();
} catch (ReflectiveOperationException ignored) { } catch (ReflectiveOperationException ignored) {
// not found // not found
} }
@ -153,7 +153,7 @@ public abstract class RenderingEngine {
GetPropertyAction gpa = GetPropertyAction gpa =
new GetPropertyAction("sun.java2d.renderer.trace"); new GetPropertyAction("sun.java2d.renderer.trace");
String reTrace = (String) AccessController.doPrivileged(gpa); String reTrace = AccessController.doPrivileged(gpa);
if (reTrace != null) { if (reTrace != null) {
reImpl = new Tracer(reImpl); reImpl = new Tracer(reImpl);
} }

14
jdk/src/solaris/classes/sun/java2d/x11/X11Renderer.java
View File

@ -299,7 +299,7 @@ public class X11Renderer implements
private void doPath(SunGraphics2D sg2d, Shape s, boolean isFill) { private void doPath(SunGraphics2D sg2d, Shape s, boolean isFill) {
Path2D.Float p2df; Path2D.Float p2df;
int transx, transy; int transx, transy;
if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) { if (sg2d.transformState <= SunGraphics2D.TRANSFORM_INT_TRANSLATE) {
if (s instanceof Path2D.Float) { if (s instanceof Path2D.Float) {
p2df = (Path2D.Float)s; p2df = (Path2D.Float)s;
} else { } else {
@ -323,10 +323,10 @@ public class X11Renderer implements
} }
public void draw(SunGraphics2D sg2d, Shape s) { public void draw(SunGraphics2D sg2d, Shape s) {
if (sg2d.strokeState == sg2d.STROKE_THIN) { if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
// Delegate to drawPolygon() if possible... // Delegate to drawPolygon() if possible...
if (s instanceof Polygon && if (s instanceof Polygon &&
sg2d.transformState < sg2d.TRANSFORM_TRANSLATESCALE) sg2d.transformState < SunGraphics2D.TRANSFORM_TRANSLATESCALE)
{ {
Polygon p = (Polygon) s; Polygon p = (Polygon) s;
drawPolygon(sg2d, p.xpoints, p.ypoints, p.npoints); drawPolygon(sg2d, p.xpoints, p.ypoints, p.npoints);
@ -336,7 +336,7 @@ public class X11Renderer implements
// Otherwise we will use drawPath() for // Otherwise we will use drawPath() for
// high-quality thin paths. // high-quality thin paths.
doPath(sg2d, s, false); doPath(sg2d, s, false);
} else if (sg2d.strokeState < sg2d.STROKE_CUSTOM) { } else if (sg2d.strokeState < SunGraphics2D.STROKE_CUSTOM) {
// REMIND: X11 can handle uniform scaled wide lines // REMIND: X11 can handle uniform scaled wide lines
// and dashed lines itself if we set the appropriate // and dashed lines itself if we set the appropriate
// XGC attributes (TBD). // XGC attributes (TBD).
@ -360,10 +360,10 @@ public class X11Renderer implements
} }
public void fill(SunGraphics2D sg2d, Shape s) { public void fill(SunGraphics2D sg2d, Shape s) {
if (sg2d.strokeState == sg2d.STROKE_THIN) { if (sg2d.strokeState == SunGraphics2D.STROKE_THIN) {
// Delegate to fillPolygon() if possible... // Delegate to fillPolygon() if possible...
if (s instanceof Polygon && if (s instanceof Polygon &&
sg2d.transformState < sg2d.TRANSFORM_TRANSLATESCALE) sg2d.transformState < SunGraphics2D.TRANSFORM_TRANSLATESCALE)
{ {
Polygon p = (Polygon) s; Polygon p = (Polygon) s;
fillPolygon(sg2d, p.xpoints, p.ypoints, p.npoints); fillPolygon(sg2d, p.xpoints, p.ypoints, p.npoints);
@ -378,7 +378,7 @@ public class X11Renderer implements
AffineTransform at; AffineTransform at;
int transx, transy; int transx, transy;
if (sg2d.transformState < sg2d.TRANSFORM_TRANSLATESCALE) { if (sg2d.transformState < SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
// Transform (translation) will be done by XFillSpans // Transform (translation) will be done by XFillSpans
at = null; at = null;
transx = sg2d.transX; transx = sg2d.transX;

22
jdk/src/solaris/classes/sun/java2d/x11/X11SurfaceData.java
View File

@ -295,9 +295,9 @@ public abstract class X11SurfaceData extends XSurfaceData {
public void validatePipe(SunGraphics2D sg2d) { public void validatePipe(SunGraphics2D sg2d) {
if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON && if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON &&
sg2d.paintState <= sg2d.PAINT_ALPHACOLOR && sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR &&
(sg2d.compositeState <= sg2d.COMP_ISCOPY || (sg2d.compositeState <= SunGraphics2D.COMP_ISCOPY ||
sg2d.compositeState == sg2d.COMP_XOR)) sg2d.compositeState == SunGraphics2D.COMP_XOR))
{ {
if (x11txpipe == null) { if (x11txpipe == null) {
/* /*
@ -315,7 +315,7 @@ public abstract class X11SurfaceData extends XSurfaceData {
return; return;
} }
if (sg2d.clipState == sg2d.CLIP_SHAPE) { if (sg2d.clipState == SunGraphics2D.CLIP_SHAPE) {
// Do this to init textpipe correctly; we will override the // Do this to init textpipe correctly; we will override the
// other non-text pipes below // other non-text pipes below
// REMIND: we should clean this up eventually instead of // REMIND: we should clean this up eventually instead of
@ -329,7 +329,7 @@ public abstract class X11SurfaceData extends XSurfaceData {
case SunHints.INTVAL_TEXT_ANTIALIAS_OFF: case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
// Use X11 pipe even if DGA is available since DGA // Use X11 pipe even if DGA is available since DGA
// text slows everything down when mixed with X11 calls // text slows everything down when mixed with X11 calls
if (sg2d.compositeState == sg2d.COMP_ISCOPY) { if (sg2d.compositeState == SunGraphics2D.COMP_ISCOPY) {
sg2d.textpipe = x11textpipe; sg2d.textpipe = x11textpipe;
} else { } else {
sg2d.textpipe = solidTextRenderer; sg2d.textpipe = solidTextRenderer;
@ -353,7 +353,7 @@ public abstract class X11SurfaceData extends XSurfaceData {
case SunHints.INTVAL_TEXT_ANTIALIAS_OFF: case SunHints.INTVAL_TEXT_ANTIALIAS_OFF:
// Use X11 pipe even if DGA is available since DGA // Use X11 pipe even if DGA is available since DGA
// text slows everything down when mixed with X11 calls // text slows everything down when mixed with X11 calls
if (sg2d.compositeState == sg2d.COMP_ISCOPY) { if (sg2d.compositeState == SunGraphics2D.COMP_ISCOPY) {
sg2d.textpipe = x11textpipe; sg2d.textpipe = x11textpipe;
} else { } else {
sg2d.textpipe = solidTextRenderer; sg2d.textpipe = solidTextRenderer;
@ -370,10 +370,10 @@ public abstract class X11SurfaceData extends XSurfaceData {
} }
} }
if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) { if (sg2d.transformState >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
sg2d.drawpipe = x11txpipe; sg2d.drawpipe = x11txpipe;
sg2d.fillpipe = x11txpipe; sg2d.fillpipe = x11txpipe;
} else if (sg2d.strokeState != sg2d.STROKE_THIN){ } else if (sg2d.strokeState != SunGraphics2D.STROKE_THIN){
sg2d.drawpipe = x11txpipe; sg2d.drawpipe = x11txpipe;
sg2d.fillpipe = x11pipe; sg2d.fillpipe = x11pipe;
} else { } else {
@ -398,8 +398,8 @@ public abstract class X11SurfaceData extends XSurfaceData {
} }
public RenderLoops getRenderLoops(SunGraphics2D sg2d) { public RenderLoops getRenderLoops(SunGraphics2D sg2d) {
if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR && if (sg2d.paintState <= SunGraphics2D.PAINT_ALPHACOLOR &&
sg2d.compositeState <= sg2d.COMP_ISCOPY) sg2d.compositeState <= SunGraphics2D.COMP_ISCOPY)
{ {
return solidloops; return solidloops;
} }
@ -488,7 +488,7 @@ public abstract class X11SurfaceData extends XSurfaceData {
makePipes(); makePipes();
} }
CompositeType comptype = sg2d.imageComp; CompositeType comptype = sg2d.imageComp;
if (sg2d.transformState < sg2d.TRANSFORM_TRANSLATESCALE && if (sg2d.transformState < SunGraphics2D.TRANSFORM_TRANSLATESCALE &&
(CompositeType.SrcOverNoEa.equals(comptype) || (CompositeType.SrcOverNoEa.equals(comptype) ||
CompositeType.SrcNoEa.equals(comptype))) CompositeType.SrcNoEa.equals(comptype)))
{ {