/* */ public void DrawLine(
SunGraphics2D paramSunGraphics2D,
SurfaceData paramSurfaceData,
int paramInt1,
int paramInt2,
int paramInt3,
int paramInt4)
/* */ {
/* 747 */ PixelWriter localPixelWriter =
GeneralRenderer.createSolidPixelWriter(paramSunGraphics2D, paramSurfaceData);
/* */
/* 749 */ if (paramInt2 >= paramInt4) {
/* 750 */ GeneralRenderer.doDrawLine(
paramSurfaceData,
localPixelWriter,
null,
paramSunGraphics2D.getCompClip(),
paramInt3,
paramInt4,
paramInt1,
paramInt2);
/* */ }
/* */ else
/* */ {
/* 754 */ GeneralRenderer.doDrawLine(
paramSurfaceData,
localPixelWriter,
null,
paramSunGraphics2D.getCompClip(),
paramInt1,
paramInt2,
paramInt3,
paramInt4);
/* */ }
/* */ }
// Render an image using only integer scaling (no transform).
protected boolean renderImageScale(
SunGraphics2D sg,
Image img,
Color bgColor,
int interpType,
int sx1,
int sy1,
int sx2,
int sy2,
double dx1,
double dy1,
double dx2,
double dy2) {
// Currently only NEAREST_NEIGHBOR interpolation is implemented
// for ScaledBlit operations.
if (interpType != AffineTransformOp.TYPE_NEAREST_NEIGHBOR) {
return false;
}
Region clip = sg.getCompClip();
SurfaceData dstData = sg.surfaceData;
int attempts = 0;
// Loop up to twice through; this gives us a chance to
// revalidate the surfaceData objects in case of an exception
// and try it once more
while (true) {
SurfaceData srcData =
dstData.getSourceSurfaceData(img, sg.TRANSFORM_TRANSLATESCALE, sg.imageComp, bgColor);
if (srcData == null || isBgOperation(srcData, bgColor)) {
return false;
}
try {
SurfaceType srcType = srcData.getSurfaceType();
SurfaceType dstType = dstData.getSurfaceType();
return scaleSurfaceData(
sg, clip, srcData, dstData, srcType, dstType, sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2);
} catch (NullPointerException e) {
if (!SurfaceData.isNull(dstData)) {
// Something else caused the exception, throw it...
throw e;
}
return false;
// NOP if we have been disposed
} catch (InvalidPipeException e) {
// Always catch the exception; try this a couple of times
// and fail silently if the system is not yet ready to
// revalidate the source or dest surfaceData objects.
++attempts;
clip = sg.getCompClip(); // ensures sg.surfaceData is valid
dstData = sg.surfaceData;
if (SurfaceData.isNull(dstData) || SurfaceData.isNull(srcData) || (attempts > 1)) {
return false;
}
}
}
}
public void fill(SunGraphics2D sg2d, Shape s) {
if (sg2d.strokeState == sg2d.STROKE_THIN) {
Path2D.Float p2df;
int transX;
int transY;
if (sg2d.transformState <= sg2d.TRANSFORM_INT_TRANSLATE) {
if (s instanceof Path2D.Float) {
p2df = (Path2D.Float) s;
} else {
p2df = new Path2D.Float(s);
}
transX = sg2d.transX;
transY = sg2d.transY;
} else {
p2df = new Path2D.Float(s, sg2d.transform);
transX = 0;
transY = 0;
}
sg2d.loops.fillPathLoop.FillPath(sg2d, sg2d.getSurfaceData(), transX, transY, p2df);
return;
}
ShapeSpanIterator sr = getFillSSI(sg2d);
try {
sr.setOutputArea(sg2d.getCompClip());
AffineTransform at =
((sg2d.transformState == sg2d.TRANSFORM_ISIDENT) ? null : sg2d.transform);
sr.appendPath(s.getPathIterator(at));
fillSpans(sg2d, sr);
} finally {
sr.dispose();
}
}
// Render an image using only integer translation
// (no scale or transform or sub-pixel interpolated translations).
protected boolean renderImageCopy(
SunGraphics2D sg, Image img, Color bgColor, int dx, int dy, int sx, int sy, int w, int h) {
Region clip = sg.getCompClip();
SurfaceData dstData = sg.surfaceData;
int attempts = 0;
// Loop up to twice through; this gives us a chance to
// revalidate the surfaceData objects in case of an exception
// and try it once more
while (true) {
SurfaceData srcData =
dstData.getSourceSurfaceData(img, sg.TRANSFORM_ISIDENT, sg.imageComp, bgColor);
if (srcData == null) {
return false;
}
try {
SurfaceType srcType = srcData.getSurfaceType();
SurfaceType dstType = dstData.getSurfaceType();
blitSurfaceData(
sg, clip, srcData, dstData, srcType, dstType, sx, sy, dx, dy, w, h, bgColor);
return true;
} catch (NullPointerException e) {
if (!(SurfaceData.isNull(dstData) || SurfaceData.isNull(srcData))) {
// Something else caused the exception, throw it...
throw e;
}
return false;
// NOP if we have been disposed
} catch (InvalidPipeException e) {
// Always catch the exception; try this a couple of times
// and fail silently if the system is not yet ready to
// revalidate the source or dest surfaceData objects.
++attempts;
clip = sg.getCompClip(); // ensures sg.surfaceData is valid
dstData = sg.surfaceData;
if (SurfaceData.isNull(dstData) || SurfaceData.isNull(srcData) || (attempts > 1)) {
return false;
}
}
}
}
public void fillPolygon(SunGraphics2D sg2d, int xPoints[], int yPoints[], int nPoints) {
ShapeSpanIterator sr = getFillSSI(sg2d);
try {
sr.setOutputArea(sg2d.getCompClip());
sr.appendPoly(xPoints, yPoints, nPoints, sg2d.transX, sg2d.transY);
fillSpans(sg2d, sr);
} finally {
sr.dispose();
}
}
/*
* Return a ShapeSpanIterator ready to iterate the spans of the wide
* outline of Shape s using the attributes of the SunGraphics2D
* object.
*
* The ShapeSpanIterator returned will be fully constructed
* and filled with the geometry from the Shape widened by the
* appropriate BasicStroke and normalization parameters taken
* from the SunGraphics2D object and be ready to start returning
* spans.
*
* Note that the caller is responsible for calling dispose()
* on the returned ShapeSpanIterator inside a try/finally block.
* <pre>
* ShapeSpanIterator ssi = LoopPipe.getStrokeSpans(sg2d, s);
* try {
* // iterate the spans from ssi and operate on them
* } finally {
* ssi.dispose();
* }
* </pre>
*
* REMIND: This should return a SpanIterator interface object
* but the caller needs to dispose() the object and that method
* is only on ShapeSpanIterator.
* TODO: Add a dispose() method to the SpanIterator interface.
*/
public static ShapeSpanIterator getStrokeSpans(SunGraphics2D sg2d, Shape s) {
ShapeSpanIterator sr = new ShapeSpanIterator(false);
try {
sr.setOutputArea(sg2d.getCompClip());
sr.setRule(PathIterator.WIND_NON_ZERO);
BasicStroke bs = (BasicStroke) sg2d.stroke;
boolean thin = (sg2d.strokeState <= sg2d.STROKE_THINDASHED);
boolean normalize = (sg2d.strokeHint != SunHints.INTVAL_STROKE_PURE);
RenderEngine.strokeTo(s, sg2d.transform, bs, thin, normalize, false, sr);
} catch (Throwable t) {
sr.dispose();
sr = null;
t.printStackTrace();
throw new InternalError("Unable to Stroke shape (" + t.getMessage() + ")");
}
return sr;
}
public boolean copyArea(SunGraphics2D sg2d, int x, int y, int w, int h, int dx, int dy) {
CompositeType comptype = sg2d.imageComp;
if (sg2d.clipState != SunGraphics2D.CLIP_SHAPE
&& (CompositeType.SrcOverNoEa.equals(comptype) || CompositeType.SrcNoEa.equals(comptype))) {
int dstx1 = x + dx;
int dsty1 = y + dy;
int dstx2 = dstx1 + w;
int dsty2 = dsty1 + h;
Region clip = sg2d.getCompClip();
if (dstx1 < clip.getLoX()) dstx1 = clip.getLoX();
if (dsty1 < clip.getLoY()) dsty1 = clip.getLoY();
if (dstx2 > clip.getHiX()) dstx2 = clip.getHiX();
if (dsty2 > clip.getHiY()) dsty2 = clip.getHiY();
if (dstx1 < dstx2 && dsty1 < dsty2) {
gdiPipe.devCopyArea(this, dstx1 - dx, dsty1 - dy, dx, dy, dstx2 - dstx1, dsty2 - dsty1);
}
return true;
}
return false;
}
protected void renderImageXform(
SunGraphics2D sg,
Image img,
AffineTransform tx,
int interpType,
int sx1,
int sy1,
int sx2,
int sy2,
Color bgColor) {
Region clip = sg.getCompClip();
SurfaceData dstData = sg.surfaceData;
SurfaceData srcData =
dstData.getSourceSurfaceData(img, sg.TRANSFORM_GENERIC, sg.imageComp, bgColor);
if (srcData == null) {
img = getBufferedImage(img);
srcData = dstData.getSourceSurfaceData(img, sg.TRANSFORM_GENERIC, sg.imageComp, bgColor);
if (srcData == null) {
// REMIND: Is this correct? Can this happen?
return;
}
}
if (isBgOperation(srcData, bgColor)) {
// We cannot perform bg operations during transform so make
// an opaque temp image with the appropriate background
// and work from there.
img = makeBufferedImage(img, bgColor, BufferedImage.TYPE_INT_RGB, sx1, sy1, sx2, sy2);
// Temp image has appropriate subimage at 0,0 now.
sx2 -= sx1;
sy2 -= sy1;
sx1 = sy1 = 0;
srcData = dstData.getSourceSurfaceData(img, sg.TRANSFORM_GENERIC, sg.imageComp, bgColor);
}
SurfaceType srcType = srcData.getSurfaceType();
TransformHelper helper = TransformHelper.getFromCache(srcType);
if (helper == null) {
/* We have no helper for this source image type.
* But we know that we do have helpers for both RGB and ARGB,
* so convert to one of those types depending on transparency.
* ARGB_PRE might be a better choice if the source image has
* alpha, but it may cause some recursion here since we only
* tend to have converters that convert to ARGB.
*/
int type =
((srcData.getTransparency() == Transparency.OPAQUE)
? BufferedImage.TYPE_INT_RGB
: BufferedImage.TYPE_INT_ARGB);
img = makeBufferedImage(img, null, type, sx1, sy1, sx2, sy2);
// Temp image has appropriate subimage at 0,0 now.
sx2 -= sx1;
sy2 -= sy1;
sx1 = sy1 = 0;
srcData = dstData.getSourceSurfaceData(img, sg.TRANSFORM_GENERIC, sg.imageComp, null);
srcType = srcData.getSurfaceType();
helper = TransformHelper.getFromCache(srcType);
// assert(helper != null);
}
AffineTransform itx;
try {
itx = tx.createInverse();
} catch (NoninvertibleTransformException e) {
// Non-invertible transform means no output
return;
}
/*
* Find the maximum bounds on the destination that will be
* affected by the transformed source. First, transform all
* four corners of the source and then min and max the resulting
* destination coordinates of the transformed corners.
* Note that tx already has the offset to sx1,sy1 accounted
* for so we use the box (0, 0, sx2-sx1, sy2-sy1) as the
* source coordinates.
*/
double coords[] = new double[8];
/* corner: UL UR LL LR */
/* index: 0 1 2 3 4 5 6 7 */
/* coord: (0, 0), (w, 0), (0, h), (w, h) */
coords[2] = coords[6] = sx2 - sx1;
coords[5] = coords[7] = sy2 - sy1;
tx.transform(coords, 0, coords, 0, 4);
double ddx1, ddy1, ddx2, ddy2;
ddx1 = ddx2 = coords[0];
ddy1 = ddy2 = coords[1];
for (int i = 2; i < coords.length; i += 2) {
double d = coords[i];
if (ddx1 > d) ddx1 = d;
else if (ddx2 < d) ddx2 = d;
d = coords[i + 1];
if (ddy1 > d) ddy1 = d;
else if (ddy2 < d) ddy2 = d;
}
int dx1 = (int) Math.floor(ddx1);
int dy1 = (int) Math.floor(ddy1);
int dx2 = (int) Math.ceil(ddx2);
int dy2 = (int) Math.ceil(ddy2);
SurfaceType dstType = dstData.getSurfaceType();
MaskBlit maskblit;
Blit blit;
if (sg.compositeState <= sg.COMP_ALPHA) {
/* NOTE: We either have, or we can make,
* a MaskBlit for any alpha composite type
*/
maskblit = MaskBlit.getFromCache(SurfaceType.IntArgbPre, sg.imageComp, dstType);
/* NOTE: We can only use the native TransformHelper
* func to go directly to the dest if both the helper
* and the MaskBlit are native.
* All helpers are native at this point, but some MaskBlit
* objects are implemented in Java, so we need to check.
*/
if (maskblit.getNativePrim() != 0) {
// We can render directly.
helper.Transform(
maskblit,
srcData,
dstData,
sg.composite,
clip,
itx,
interpType,
sx1,
sy1,
sx2,
sy2,
dx1,
dy1,
dx2,
dy2,
null,
0,
0);
return;
}
blit = null;
} else {
/* NOTE: We either have, or we can make,
* a Blit for any composite type, even Custom
*/
maskblit = null;
blit = Blit.getFromCache(SurfaceType.IntArgbPre, sg.imageComp, dstType);
}
// We need to transform to a temp image and then copy
// just the pieces that are valid data to the dest.
BufferedImage tmpimg = new BufferedImage(dx2 - dx1, dy2 - dy1, BufferedImage.TYPE_INT_ARGB);
SurfaceData tmpData = SurfaceData.getPrimarySurfaceData(tmpimg);
SurfaceType tmpType = tmpData.getSurfaceType();
MaskBlit tmpmaskblit =
MaskBlit.getFromCache(SurfaceType.IntArgbPre, CompositeType.SrcNoEa, tmpType);
/*
* The helper function fills a temporary edges buffer
* for us with the bounding coordinates of each scanline
* in the following format:
*
* edges[0, 1] = [top y, bottom y)
* edges[2, 3] = [left x, right x) of top row
* ...
* edges[h*2, h*2+1] = [left x, right x) of bottom row
*
* all coordinates in the edges array will be relative to dx1, dy1
*
* edges thus has to be h*2+2 in length
*/
int edges[] = new int[(dy2 - dy1) * 2 + 2];
// It is important that edges[0]=edges[1]=0 when we call
// Transform in case it must return early and we would
// not want to render anything on an error condition.
helper.Transform(
tmpmaskblit,
srcData,
tmpData,
AlphaComposite.Src,
null,
itx,
interpType,
sx1,
sy1,
sx2,
sy2,
0,
0,
dx2 - dx1,
dy2 - dy1,
edges,
dx1,
dy1);
/*
* Now copy the results, scanline by scanline, into the dest.
* The edges array helps us minimize the work.
*/
int index = 2;
for (int y = edges[0]; y < edges[1]; y++) {
int relx1 = edges[index++];
int relx2 = edges[index++];
if (relx1 >= relx2) {
continue;
}
if (maskblit != null) {
maskblit.MaskBlit(
tmpData,
dstData,
sg.composite,
clip,
relx1,
y,
dx1 + relx1,
dy1 + y,
relx2 - relx1,
1,
null,
0,
0);
} else {
blit.Blit(
tmpData, dstData, sg.composite, clip, relx1, y, dx1 + relx1, dy1 + y, relx2 - relx1, 1);
}
}
}
@Override
protected void validateContext(SunGraphics2D sg2d, Composite comp, int ctxflags) {
D3DSurfaceData dstData = (D3DSurfaceData) sg2d.surfaceData;
D3DContext.validateContext(
dstData, dstData, sg2d.getCompClip(), comp, null, sg2d.paint, sg2d, ctxflags);
}