Mercurial > hg > release > icedtea7-forest-2.0 > jdk
changeset 4244:499d216a751e
Merge
author | jgodinez |
---|---|
date | Tue, 03 May 2011 22:11:02 -0700 |
parents | 9caec666c577 (current diff) 55ef0efa2b14 (diff) |
children | 4e6897c7779f |
files | |
diffstat | 14 files changed, 586 insertions(+), 155 deletions(-) [+] |
line wrap: on
line diff
--- a/src/share/classes/java/awt/RadialGradientPaint.java Tue May 03 15:02:55 2011 -0700 +++ b/src/share/classes/java/awt/RadialGradientPaint.java Tue May 03 22:11:02 2011 -0700 @@ -49,9 +49,11 @@ * from the focus point to the circumference will thus span all the gradient * colors. * <p> - * Specifying a focus point outside of the circle's radius will result in the - * focus being set to the intersection point of the focus-center line and the - * perimeter of the circle. + * Specifying a focus point outside of the radius of the circle will cause + * the rings of the gradient pattern to be centered on the point just inside + * the edge of the circle in the direction of the focus point. + * The rendering will internally use this modified location as if it were + * the specified focus point. * <p> * The user must provide an array of floats specifying how to distribute the * colors along the gradient. These values should range from 0.0 to 1.0 and @@ -621,6 +623,11 @@ /** * Returns a copy of the focus point of the radial gradient. + * Note that if the focus point specified when the radial gradient + * was constructed lies outside of the radius of the circle, this + * method will still return the original focus point even though + * the rendering may center the rings of color on a different + * point that lies inside the radius. * * @return a {@code Point2D} object that is a copy of the focus point */
--- a/src/share/classes/java/awt/geom/Arc2D.java Tue May 03 15:02:55 2011 -0700 +++ b/src/share/classes/java/awt/geom/Arc2D.java Tue May 03 22:11:02 2011 -0700 @@ -681,7 +681,7 @@ * @see java.awt.geom.Arc2D.Float * @see java.awt.geom.Arc2D.Double */ - Arc2D() { + protected Arc2D() { this(OPEN); }
--- a/src/share/classes/java/awt/geom/Path2D.java Tue May 03 15:02:55 2011 -0700 +++ b/src/share/classes/java/awt/geom/Path2D.java Tue May 03 22:11:02 2011 -0700 @@ -732,7 +732,7 @@ * * @since 1.6 */ - public PathIterator getPathIterator(AffineTransform at) { + public final PathIterator getPathIterator(AffineTransform at) { if (at == null) { return new CopyIterator(this); } else { @@ -1461,7 +1461,7 @@ * of this {@code Shape}'s outline * @since 1.6 */ - public PathIterator getPathIterator(AffineTransform at) { + public final PathIterator getPathIterator(AffineTransform at) { if (at == null) { return new CopyIterator(this); } else { @@ -2342,8 +2342,8 @@ * * @since 1.6 */ - public PathIterator getPathIterator(AffineTransform at, - double flatness) + public final PathIterator getPathIterator(AffineTransform at, + double flatness) { return new FlatteningPathIterator(getPathIterator(at), flatness); }
--- a/src/share/classes/sun/java2d/pisces/Stroker.java Tue May 03 15:02:55 2011 -0700 +++ b/src/share/classes/sun/java2d/pisces/Stroker.java Tue May 03 22:11:02 2011 -0700 @@ -27,6 +27,8 @@ import java.util.Arrays; import java.util.Iterator; +import static java.lang.Math.ulp; +import static java.lang.Math.sqrt; import sun.awt.geom.PathConsumer2D; @@ -130,7 +132,7 @@ private static void computeOffset(final float lx, final float ly, final float w, final float[] m) { - final float len = (float)Math.sqrt(lx*lx + ly*ly); + final float len = (float) sqrt(lx*lx + ly*ly); if (len == 0) { m[0] = m[1] = 0; } else { @@ -217,7 +219,7 @@ // this normal's length is at least 0.5 and at most sqrt(2)/2 (because // we know the angle of the arc is > 90 degrees). float nx = my - omy, ny = omx - mx; - float nlen = (float)Math.sqrt(nx*nx + ny*ny); + float nlen = (float) sqrt(nx*nx + ny*ny); float scale = lineWidth2/nlen; float mmx = nx * scale, mmy = ny * scale; @@ -246,8 +248,8 @@ // define the bezier curve we're computing. // It is computed using the constraints that P1-P0 and P3-P2 are parallel // to the arc tangents at the endpoints, and that |P1-P0|=|P3-P2|. - float cv = (float)((4.0 / 3.0) * Math.sqrt(0.5-cosext2) / - (1.0 + Math.sqrt(cosext2+0.5))); + float cv = (float) ((4.0 / 3.0) * sqrt(0.5-cosext2) / + (1.0 + sqrt(cosext2+0.5))); // if clockwise, we need to negate cv. if (rev) { // rev is equivalent to isCW(omx, omy, mx, my) cv = -cv; @@ -284,28 +286,20 @@ false); } - // Return the intersection point of the lines (x0, y0) -> (x1, y1) - // and (x0p, y0p) -> (x1p, y1p) in m[0] and m[1] - private void computeMiter(final float x0, final float y0, - final float x1, final float y1, - final float x0p, final float y0p, - final float x1p, final float y1p, - final float[] m, int off) + // Put the intersection point of the lines (x0, y0) -> (x1, y1) + // and (x0p, y0p) -> (x1p, y1p) in m[off] and m[off+1]. + // If the lines are parallel, it will put a non finite number in m. + private void computeIntersection(final float x0, final float y0, + final float x1, final float y1, + final float x0p, final float y0p, + final float x1p, final float y1p, + final float[] m, int off) { float x10 = x1 - x0; float y10 = y1 - y0; float x10p = x1p - x0p; float y10p = y1p - y0p; - // if this is 0, the lines are parallel. If they go in the - // same direction, there is no intersection so m[off] and - // m[off+1] will contain infinity, so no miter will be drawn. - // If they go in the same direction that means that the start of the - // current segment and the end of the previous segment have the same - // tangent, in which case this method won't even be involved in - // miter drawing because it won't be called by drawMiter (because - // (mx == omx && my == omy) will be true, and drawMiter will return - // immediately). float den = x10*y10p - x10p*y10; float t = x10p*(y0-y0p) - y10p*(x0-x0p); t /= den; @@ -321,7 +315,8 @@ { if ((mx == omx && my == omy) || (pdx == 0 && pdy == 0) || - (dx == 0 && dy == 0)) { + (dx == 0 && dy == 0)) + { return; } @@ -332,12 +327,17 @@ my = -my; } - computeMiter((x0 - pdx) + omx, (y0 - pdy) + omy, x0 + omx, y0 + omy, - (dx + x0) + mx, (dy + y0) + my, x0 + mx, y0 + my, - miter, 0); + computeIntersection((x0 - pdx) + omx, (y0 - pdy) + omy, x0 + omx, y0 + omy, + (dx + x0) + mx, (dy + y0) + my, x0 + mx, y0 + my, + miter, 0); float lenSq = (miter[0]-x0)*(miter[0]-x0) + (miter[1]-y0)*(miter[1]-y0); + // If the lines are parallel, lenSq will be either NaN or +inf + // (actually, I'm not sure if the latter is possible. The important + // thing is that -inf is not possible, because lenSq is a square). + // For both of those values, the comparison below will fail and + // no miter will be drawn, which is correct. if (lenSq < miterLimitSq) { emitLineTo(miter[0], miter[1], rev); } @@ -566,8 +566,8 @@ // if p1 == p2 && p3 == p4: draw line from p1->p4, unless p1 == p4, // in which case ignore if p1 == p2 - final boolean p1eqp2 = within(x1,y1,x2,y2, 6 * Math.ulp(y2)); - final boolean p3eqp4 = within(x3,y3,x4,y4, 6 * Math.ulp(y4)); + final boolean p1eqp2 = within(x1,y1,x2,y2, 6 * ulp(y2)); + final boolean p3eqp4 = within(x3,y3,x4,y4, 6 * ulp(y4)); if (p1eqp2 && p3eqp4) { getLineOffsets(x1, y1, x4, y4, leftOff, rightOff); return 4; @@ -583,7 +583,7 @@ float dotsq = (dx1 * dx4 + dy1 * dy4); dotsq = dotsq * dotsq; float l1sq = dx1 * dx1 + dy1 * dy1, l4sq = dx4 * dx4 + dy4 * dy4; - if (Helpers.within(dotsq, l1sq * l4sq, 4 * Math.ulp(dotsq))) { + if (Helpers.within(dotsq, l1sq * l4sq, 4 * ulp(dotsq))) { getLineOffsets(x1, y1, x4, y4, leftOff, rightOff); return 4; } @@ -693,8 +693,6 @@ return 8; } - // compute offset curves using bezier spline through t=0.5 (i.e. - // ComputedCurve(0.5) == IdealParallelCurve(0.5)) // return the kind of curve in the right and left arrays. private int computeOffsetQuad(float[] pts, final int off, float[] leftOff, float[] rightOff) @@ -703,56 +701,67 @@ final float x2 = pts[off + 2], y2 = pts[off + 3]; final float x3 = pts[off + 4], y3 = pts[off + 5]; - float dx3 = x3 - x2; - float dy3 = y3 - y2; - float dx1 = x2 - x1; - float dy1 = y2 - y1; + final float dx3 = x3 - x2; + final float dy3 = y3 - y2; + final float dx1 = x2 - x1; + final float dy1 = y2 - y1; + + // this computes the offsets at t = 0, 1 + computeOffset(dx1, dy1, lineWidth2, offset[0]); + computeOffset(dx3, dy3, lineWidth2, offset[1]); + + leftOff[0] = x1 + offset[0][0]; leftOff[1] = y1 + offset[0][1]; + leftOff[4] = x3 + offset[1][0]; leftOff[5] = y3 + offset[1][1]; + rightOff[0] = x1 - offset[0][0]; rightOff[1] = y1 - offset[0][1]; + rightOff[4] = x3 - offset[1][0]; rightOff[5] = y3 - offset[1][1]; + + float x1p = leftOff[0]; // start + float y1p = leftOff[1]; // point + float x3p = leftOff[4]; // end + float y3p = leftOff[5]; // point - // if p1=p2 or p3=p4 it means that the derivative at the endpoint - // vanishes, which creates problems with computeOffset. Usually - // this happens when this stroker object is trying to winden - // a curve with a cusp. What happens is that curveTo splits - // the input curve at the cusp, and passes it to this function. - // because of inaccuracies in the splitting, we consider points - // equal if they're very close to each other. + // Corner cases: + // 1. If the two control vectors are parallel, we'll end up with NaN's + // in leftOff (and rightOff in the body of the if below), so we'll + // do getLineOffsets, which is right. + // 2. If the first or second two points are equal, then (dx1,dy1)==(0,0) + // or (dx3,dy3)==(0,0), so (x1p, y1p)==(x1p+dx1, y1p+dy1) + // or (x3p, y3p)==(x3p-dx3, y3p-dy3), which means that + // computeIntersection will put NaN's in leftOff and right off, and + // we will do getLineOffsets, which is right. + computeIntersection(x1p, y1p, x1p+dx1, y1p+dy1, x3p, y3p, x3p-dx3, y3p-dy3, leftOff, 2); + float cx = leftOff[2]; + float cy = leftOff[3]; - // if p1 == p2 && p3 == p4: draw line from p1->p4, unless p1 == p4, - // in which case ignore. - final boolean p1eqp2 = within(x1,y1,x2,y2, 6 * Math.ulp(y2)); - final boolean p2eqp3 = within(x2,y2,x3,y3, 6 * Math.ulp(y3)); - if (p1eqp2 || p2eqp3) { - getLineOffsets(x1, y1, x3, y3, leftOff, rightOff); - return 4; + if (!(isFinite(cx) && isFinite(cy))) { + // maybe the right path is not degenerate. + x1p = rightOff[0]; + y1p = rightOff[1]; + x3p = rightOff[4]; + y3p = rightOff[5]; + computeIntersection(x1p, y1p, x1p+dx1, y1p+dy1, x3p, y3p, x3p-dx3, y3p-dy3, rightOff, 2); + cx = rightOff[2]; + cy = rightOff[3]; + if (!(isFinite(cx) && isFinite(cy))) { + // both are degenerate. This curve is a line. + getLineOffsets(x1, y1, x3, y3, leftOff, rightOff); + return 4; + } + // {left,right}Off[0,1,4,5] are already set to the correct values. + leftOff[2] = 2*x2 - cx; + leftOff[3] = 2*y2 - cy; + return 6; } - // if p2-p1 and p4-p3 are parallel, that must mean this curve is a line - float dotsq = (dx1 * dx3 + dy1 * dy3); - dotsq = dotsq * dotsq; - float l1sq = dx1 * dx1 + dy1 * dy1, l3sq = dx3 * dx3 + dy3 * dy3; - if (Helpers.within(dotsq, l1sq * l3sq, 4 * Math.ulp(dotsq))) { - getLineOffsets(x1, y1, x3, y3, leftOff, rightOff); - return 4; - } + // rightOff[2,3] = (x2,y2) - ((left_x2, left_y2) - (x2, y2)) + // == 2*(x2, y2) - (left_x2, left_y2) + rightOff[2] = 2*x2 - cx; + rightOff[3] = 2*y2 - cy; + return 6; + } - // this computes the offsets at t=0, 0.5, 1, using the property that - // for any bezier curve the vectors p2-p1 and p4-p3 are parallel to - // the (dx/dt, dy/dt) vectors at the endpoints. - computeOffset(dx1, dy1, lineWidth2, offset[0]); - computeOffset(dx3, dy3, lineWidth2, offset[1]); - float x1p = x1 + offset[0][0]; // start - float y1p = y1 + offset[0][1]; // point - float x3p = x3 + offset[1][0]; // end - float y3p = y3 + offset[1][1]; // point - - computeMiter(x1p, y1p, x1p+dx1, y1p+dy1, x3p, y3p, x3p-dx3, y3p-dy3, leftOff, 2); - leftOff[0] = x1p; leftOff[1] = y1p; - leftOff[4] = x3p; leftOff[5] = y3p; - x1p = x1 - offset[0][0]; y1p = y1 - offset[0][1]; - x3p = x3 - offset[1][0]; y3p = y3 - offset[1][1]; - computeMiter(x1p, y1p, x1p+dx1, y1p+dy1, x3p, y3p, x3p-dx3, y3p-dy3, rightOff, 2); - rightOff[0] = x1p; rightOff[1] = y1p; - rightOff[4] = x3p; rightOff[5] = y3p; - return 6; + private static boolean isFinite(float x) { + return (Float.NEGATIVE_INFINITY < x && x < Float.POSITIVE_INFINITY); } // This is where the curve to be processed is put. We give it @@ -812,12 +821,12 @@ // if these vectors are too small, normalize them, to avoid future // precision problems. if (Math.abs(dxs) < 0.1f && Math.abs(dys) < 0.1f) { - float len = (float)Math.sqrt(dxs*dxs + dys*dys); + float len = (float) sqrt(dxs*dxs + dys*dys); dxs /= len; dys /= len; } if (Math.abs(dxf) < 0.1f && Math.abs(dyf) < 0.1f) { - float len = (float)Math.sqrt(dxf*dxf + dyf*dyf); + float len = (float) sqrt(dxf*dxf + dyf*dyf); dxf /= len; dyf /= len; } @@ -834,7 +843,6 @@ while(it.hasNext()) { int curCurveOff = it.next(); - kind = 0; switch (type) { case 8: kind = computeOffsetCubic(middle, curCurveOff, lp, rp); @@ -843,24 +851,22 @@ kind = computeOffsetQuad(middle, curCurveOff, lp, rp); break; } - if (kind != 0) { - emitLineTo(lp[0], lp[1]); - switch(kind) { - case 8: - emitCurveTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], lp[6], lp[7], false); - emitCurveTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], rp[6], rp[7], true); - break; - case 6: - emitQuadTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], false); - emitQuadTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], true); - break; - case 4: - emitLineTo(lp[2], lp[3]); - emitLineTo(rp[0], rp[1], true); - break; - } - emitLineTo(rp[kind - 2], rp[kind - 1], true); + emitLineTo(lp[0], lp[1]); + switch(kind) { + case 8: + emitCurveTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], lp[6], lp[7], false); + emitCurveTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], rp[6], rp[7], true); + break; + case 6: + emitQuadTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], false); + emitQuadTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], true); + break; + case 4: + emitLineTo(lp[2], lp[3]); + emitLineTo(rp[0], rp[1], true); + break; } + emitLineTo(rp[kind - 2], rp[kind - 1], true); } this.cmx = (lp[kind - 2] - rp[kind - 2]) / 2; @@ -887,7 +893,7 @@ // we rotate it so that the first vector in the control polygon is // parallel to the x-axis. This will ensure that rotated quarter // circles won't be subdivided. - final float hypot = (float)Math.sqrt(x12 * x12 + y12 * y12); + final float hypot = (float) sqrt(x12 * x12 + y12 * y12); final float cos = x12 / hypot; final float sin = y12 / hypot; final float x1 = cos * pts[0] + sin * pts[1]; @@ -976,12 +982,12 @@ // if these vectors are too small, normalize them, to avoid future // precision problems. if (Math.abs(dxs) < 0.1f && Math.abs(dys) < 0.1f) { - float len = (float)Math.sqrt(dxs*dxs + dys*dys); + float len = (float) sqrt(dxs*dxs + dys*dys); dxs /= len; dys /= len; } if (Math.abs(dxf) < 0.1f && Math.abs(dyf) < 0.1f) { - float len = (float)Math.sqrt(dxf*dxf + dyf*dyf); + float len = (float) sqrt(dxf*dxf + dyf*dyf); dxf /= len; dyf /= len; } @@ -999,20 +1005,18 @@ int curCurveOff = it.next(); kind = computeOffsetCubic(middle, curCurveOff, lp, rp); - if (kind != 0) { - emitLineTo(lp[0], lp[1]); - switch(kind) { - case 8: - emitCurveTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], lp[6], lp[7], false); - emitCurveTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], rp[6], rp[7], true); - break; - case 4: - emitLineTo(lp[2], lp[3]); - emitLineTo(rp[0], rp[1], true); - break; - } - emitLineTo(rp[kind - 2], rp[kind - 1], true); + emitLineTo(lp[0], lp[1]); + switch(kind) { + case 8: + emitCurveTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], lp[6], lp[7], false); + emitCurveTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], rp[6], rp[7], true); + break; + case 4: + emitLineTo(lp[2], lp[3]); + emitLineTo(rp[0], rp[1], true); + break; } + emitLineTo(rp[kind - 2], rp[kind - 1], true); } this.cmx = (lp[kind - 2] - rp[kind - 2]) / 2; @@ -1050,12 +1054,12 @@ // if these vectors are too small, normalize them, to avoid future // precision problems. if (Math.abs(dxs) < 0.1f && Math.abs(dys) < 0.1f) { - float len = (float)Math.sqrt(dxs*dxs + dys*dys); + float len = (float) sqrt(dxs*dxs + dys*dys); dxs /= len; dys /= len; } if (Math.abs(dxf) < 0.1f && Math.abs(dyf) < 0.1f) { - float len = (float)Math.sqrt(dxf*dxf + dyf*dyf); + float len = (float) sqrt(dxf*dxf + dyf*dyf); dxf /= len; dyf /= len; } @@ -1073,20 +1077,18 @@ int curCurveOff = it.next(); kind = computeOffsetQuad(middle, curCurveOff, lp, rp); - if (kind != 0) { - emitLineTo(lp[0], lp[1]); - switch(kind) { - case 6: - emitQuadTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], false); - emitQuadTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], true); - break; - case 4: - emitLineTo(lp[2], lp[3]); - emitLineTo(rp[0], rp[1], true); - break; - } - emitLineTo(rp[kind - 2], rp[kind - 1], true); + emitLineTo(lp[0], lp[1]); + switch(kind) { + case 6: + emitQuadTo(lp[0], lp[1], lp[2], lp[3], lp[4], lp[5], false); + emitQuadTo(rp[0], rp[1], rp[2], rp[3], rp[4], rp[5], true); + break; + case 4: + emitLineTo(lp[2], lp[3]); + emitLineTo(rp[0], rp[1], true); + break; } + emitLineTo(rp[kind - 2], rp[kind - 1], true); } this.cmx = (lp[kind - 2] - rp[kind - 2]) / 2;
--- a/src/share/native/sun/awt/giflib/dgif_lib.c Tue May 03 15:02:55 2011 -0700 +++ b/src/share/native/sun/awt/giflib/dgif_lib.c Tue May 03 22:11:02 2011 -0700 @@ -70,7 +70,7 @@ /* avoid extra function call in case we use fread (TVT) */ #define READ(_gif,_buf,_len) \ (((GifFilePrivateType*)_gif->Private)->Read ? \ - ((GifFilePrivateType*)_gif->Private)->Read(_gif,_buf,_len) : \ + (size_t)((GifFilePrivateType*)_gif->Private)->Read(_gif,_buf,_len) : \ fread(_buf,1,_len,((GifFilePrivateType*)_gif->Private)->File)) static int DGifGetWord(GifFileType *GifFile, int *Word);
--- a/src/share/native/sun/font/fontscalerdefs.h Tue May 03 15:02:55 2011 -0700 +++ b/src/share/native/sun/font/fontscalerdefs.h Tue May 03 22:11:02 2011 -0700 @@ -55,13 +55,15 @@ typedef Int32 hsFract; typedef UInt32 Bool32; +#ifndef __cplusplus #ifndef false - #define false 0 + #define false 0 #endif #ifndef true #define true 1 #endif +#endif #define kPosInfinity32 (0x7fffffff) #define kNegInfinity32 (0x80000000)
--- a/src/share/native/sun/font/layout/HangulLayoutEngine.cpp Tue May 03 15:02:55 2011 -0700 +++ b/src/share/native/sun/font/layout/HangulLayoutEngine.cpp Tue May 03 22:11:02 2011 -0700 @@ -162,7 +162,7 @@ return 0; } - lead = LJMO_FIRST + (sIndex / HSYL_LVCNT); + lead = (LEUnicode)(LJMO_FIRST + (sIndex / HSYL_LVCNT)); vowel = VJMO_FIRST + (sIndex % HSYL_LVCNT) / TJMO_COUNT; trail = TJMO_FIRST + (sIndex % TJMO_COUNT);
--- a/src/share/native/sun/font/layout/MPreFixups.cpp Tue May 03 15:02:55 2011 -0700 +++ b/src/share/native/sun/font/layout/MPreFixups.cpp Tue May 03 22:11:02 2011 -0700 @@ -65,9 +65,9 @@ } } -void MPreFixups::apply(LEGlyphStorage &glyphStorage, LEErrorCode& success) +void MPreFixups::apply(LEGlyphStorage &glyphStorage, LEErrorCode& leSuccess) { - if (LE_FAILURE(success)) { + if (LE_FAILURE(leSuccess)) { return; }
--- a/src/solaris/classes/sun/font/FcFontConfiguration.java Tue May 03 15:02:55 2011 -0700 +++ b/src/solaris/classes/sun/font/FcFontConfiguration.java Tue May 03 22:11:02 2011 -0700 @@ -256,9 +256,9 @@ } if (installedFallbackFontFiles != null) { - System.arraycopy(fileNames, index, - installedFallbackFontFiles, - 0, installedFallbackFontFiles.length); + System.arraycopy(installedFallbackFontFiles, 0, + fileNames, fcFonts.length, + installedFallbackFontFiles.length); } result[fontIndex * NUM_STYLES + styleIndex]
--- a/src/solaris/native/sun/awt/fontpath.c Tue May 03 15:02:55 2011 -0700 +++ b/src/solaris/native/sun/awt/fontpath.c Tue May 03 22:11:02 2011 -0700 @@ -1107,7 +1107,8 @@ arrlen = (*env)->GetArrayLength(env, fcCompFontArray); for (i=0; i<arrlen; i++) { FcFontSet* fontset; - int fn, j, fontCount, nfonts, minGlyphs; + int fn, j, fontCount, nfonts; + unsigned int minGlyphs; FcChar8 **family, **styleStr, **fullname, **file; jarray fcFontArr;
--- a/src/windows/native/sun/font/fontpath.c Tue May 03 15:02:55 2011 -0700 +++ b/src/windows/native/sun/font/fontpath.c Tue May 03 22:11:02 2011 -0700 @@ -235,7 +235,7 @@ } fullname = (*env)->NewString(env, lpelfe->elfFullName, - wcslen((LPWSTR)lpelfe->elfFullName)); + (jsize)wcslen((LPWSTR)lpelfe->elfFullName)); fullnameLC = (*env)->CallObjectMethod(env, fullname, fmi->toLowerCaseMID, fmi->locale); (*env)->CallBooleanMethod(env, fmi->list, fmi->addMID, fullname); @@ -314,7 +314,7 @@ GdiFontMapInfo *fmi = (GdiFontMapInfo*)lParam; JNIEnv *env = fmi->env; jstring familyLC; - int slen; + size_t slen; LOGFONTW lfw; /* Both Vista and XP return DEVICE_FONTTYPE for OTF fonts */ @@ -336,7 +336,7 @@ return 1; } slen = wcslen(lpelfe->elfLogFont.lfFaceName); - fmi->family = (*env)->NewString(env,lpelfe->elfLogFont.lfFaceName, slen); + fmi->family = (*env)->NewString(env,lpelfe->elfLogFont.lfFaceName, (jsize)slen); familyLC = (*env)->CallObjectMethod(env, fmi->family, fmi->toLowerCaseMID, fmi->locale); /* check if already seen this family with a different charset */ @@ -386,10 +386,10 @@ static BOOL RegistryToBaseTTNameA(LPSTR name) { static const char TTSUFFIX[] = " (TrueType)"; static const char OTSUFFIX[] = " (OpenType)"; - int TTSLEN = strlen(TTSUFFIX); + size_t TTSLEN = strlen(TTSUFFIX); char *suffix; - int len = strlen(name); + size_t len = strlen(name); if (len == 0) { return FALSE; } @@ -412,10 +412,10 @@ static BOOL RegistryToBaseTTNameW(LPWSTR name) { static const wchar_t TTSUFFIX[] = L" (TrueType)"; static const wchar_t OTSUFFIX[] = L" (OpenType)"; - int TTSLEN = wcslen(TTSUFFIX); + size_t TTSLEN = wcslen(TTSUFFIX); wchar_t *suffix; - int len = wcslen(name); + size_t len = wcslen(name); if (len == 0) { return FALSE; } @@ -439,7 +439,7 @@ LPSTR ptr1, ptr2; jstring fontStr; JNIEnv *env = fmi->env; - int dslen = strlen(data); + size_t dslen = strlen(data); jstring fileStr = JNU_NewStringPlatform(env, data); /* TTC or ttc means it may be a collection. Need to parse out @@ -488,8 +488,8 @@ wchar_t *ptr1, *ptr2; jstring fontStr; JNIEnv *env = fmi->env; - int dslen = wcslen(data); - jstring fileStr = (*env)->NewString(env, data, dslen); + size_t dslen = wcslen(data); + jstring fileStr = (*env)->NewString(env, data, (jsize)dslen); /* TTC or ttc means it may be a collection. Need to parse out * multiple font face names separated by " & " @@ -510,7 +510,7 @@ while ((ptr2 = wcsstr(ptr1, L" & ")) != NULL) { ptr1 = ptr2+3; } - fontStr = (*env)->NewString(env, ptr1, wcslen(ptr1)); + fontStr = (*env)->NewString(env, ptr1, (jsize)wcslen(ptr1)); fontStr = (*env)->CallObjectMethod(env, fontStr, fmi->toLowerCaseMID, fmi->locale); @@ -524,7 +524,7 @@ } } } else { - fontStr = (*env)->NewString(env, name, wcslen(name)); + fontStr = (*env)->NewString(env, name, (jsize)wcslen(name)); fontStr = (*env)->CallObjectMethod(env, fontStr, fmi->toLowerCaseMID, fmi->locale); (*env)->CallObjectMethod(env, fontToFileMap, fmi->putMID,
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/java/awt/Graphics2D/MTGraphicsAccessTest/MTGraphicsAccessTest.java Tue May 03 22:11:02 2011 -0700 @@ -0,0 +1,361 @@ +/* + * Copyright (c) 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 5089429 6982632 + @summary Checks that we don't crash if rendering operations and state + changes are performed on a graphics context from different threads. + + @author Dmitri.Trembovetski@sun.com area=Graphics + @run main MTGraphicsAccessTest + */ + +import java.awt.*; +import java.awt.image.*; +import java.awt.geom.*; + +public class MTGraphicsAccessTest { + + // in seconds + static final long STANDALONE_RUN_TIME = 20; + static final long JTREG_RUN_TIME = 7; + + static boolean standaloneMode; + static boolean allowExceptions = true; + static long testRunTime; + + volatile boolean done; + volatile int stillRunning; + volatile int numexceptions; + + Graphics2D sharedGraphics; + BufferedImage sharedBI = + new BufferedImage(50, 50, BufferedImage.TYPE_INT_RGB); + + static final Paint colors[] = { + Color.red, + new Color(0x7f, 0xff, 0x00, 0x7f), + new GradientPaint(0, 0, Color.red, + 50, 50, new Color(0x7f, 0xff, 0x00, 0x7f)), + }; + static final Font fonts[] = { + new Font("Dialog", Font.PLAIN, 12), + new Font("Dialog", Font.BOLD, 16), + new Font("Dialog", Font.ITALIC, 18), + }; + static final AlphaComposite comps[] = { + AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 1.0f), + AlphaComposite.Src, + AlphaComposite.Xor, + AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.5f), + null, + }; + static final Stroke strokes[] = { + new BasicStroke(), + new BasicStroke(0.0f), + new BasicStroke(2.0f), + new BasicStroke(2.0f, BasicStroke.CAP_ROUND, + BasicStroke.JOIN_BEVEL), + new BasicStroke(5.0f, BasicStroke.CAP_SQUARE, + BasicStroke.JOIN_ROUND), + new BasicStroke(0.0f, BasicStroke.CAP_ROUND, + BasicStroke.JOIN_ROUND, 0, + new float[]{0,6,0,6}, 0), + }; + static final AffineTransform transforms[] = { + new AffineTransform(), + AffineTransform.getRotateInstance(10.0), + AffineTransform.getShearInstance(10.0, 4.0), + AffineTransform.getScaleInstance(1.1, 1.2), + AffineTransform.getScaleInstance(3.0, 2.0), + }; + + public MTGraphicsAccessTest() { + BufferedImage bi = + new BufferedImage(50, 50, BufferedImage.TYPE_INT_RGB); + sharedGraphics = (Graphics2D)bi.getGraphics(); + + done = false; + numexceptions = 0; + + for (int i = 0; i < (standaloneMode ? stateChangers.length : 3); i++) { + (new TesterThread(stateChangers[i])).start(); + } + for (int i = 0; i < (standaloneMode ? renderTests.length : 5); i++) { + (new TesterThread(renderTests[i])).start(); + } + + mysleep(testRunTime); + done = true; + while (stillRunning > 0) { mysleep(500); } + + if (numexceptions == 0) { + System.err.println("Test passed"); + } else if (!allowExceptions) { + throw new RuntimeException("Test failed with "+ + numexceptions+" exceptions"); + } else { + System.err.println("Test finished with "+ + numexceptions+" exceptions"); + } + } + + private void mysleep(long time) { + try { + // add +/-5ms variance to increase randomness + Thread.sleep(time + (long)(5 - Math.random()*10)); + } catch (InterruptedException e) {}; + } + + public static void usage(String message) { + if (message != null) { + System.err.println(message); + } + System.err.println("Usage: MTGraphicsAccessTest [-full] "+ + "[-time N/forever] [-help]"); + System.err.println(" -full: run full suite of tests "+ + "(default: limited number of tests is run)"); + System.err.println(" -time N: test duration in seconds/forever"+ + " (default: "+JTREG_RUN_TIME+"s for the short suite, "+ + STANDALONE_RUN_TIME+"s for the full suite)"); + System.err.println(" -help: print this help page"); + System.exit(1); + } + + public static void main(String[] args) { + boolean testRunSet = false; + for (int i = 0; i < args.length; i++) { + if ("-full".equals(args[i])) { + standaloneMode = true; + System.err.println("Running complete list of tests"); + } else if ("-noexc".equals(args[i])) { + allowExceptions = false; + } else if ("-time".equals(args[i])) { + try { + String time = args[++i]; + if ("forever".equals(time)) { + testRunTime = (Long.MAX_VALUE - 20)/1000; + } else { + testRunTime = 1000*Integer.parseInt(time); + } + testRunSet = true; + } catch (NumberFormatException e) { + usage("Can't parse number of seconds: " + args[i]); + } catch (ArrayIndexOutOfBoundsException e1) { + usage("Missing the 'seconds' argument for -time parameter"); + } + } else if ("-help".equals(args[i])) { + usage(null); + } else { + usage("Unknown argument:" + args[i]); + } + } + + if (!testRunSet) { + testRunTime = 1000 * + (standaloneMode ? STANDALONE_RUN_TIME : JTREG_RUN_TIME); + } + + System.err.println("Approximate test run time: "+ + testRunTime/1000+" seconds"); + + new MTGraphicsAccessTest(); + } + + class TesterThread extends Thread { + Runnable testRunnable; + + public TesterThread(Runnable testRunnable) { + stillRunning++; + this.testRunnable = testRunnable; + } + + public void run() { + try { + while (!done) { + try { + testRunnable.run(); + yield(); + } catch (Throwable t) { + numexceptions++; + t.printStackTrace(); + } + } + } finally { + stillRunning--; + } + } + } + + final Runnable stateChangers[] = { + new Runnable() { + public void run() { + sharedGraphics.setClip(10, 10, 30, 30); + mysleep(10); + } + }, + new Runnable() { + public void run() { + sharedGraphics.setClip(10, 10, 30, 30); + mysleep(10); + } + }, + new Runnable() { + int c = 0; + public void run() { + sharedGraphics.setPaint(colors[c++ % colors.length]); + mysleep(10); + } + }, + new Runnable() { + boolean AA = false; + public void run() { + if (AA) { + sharedGraphics.setRenderingHint( + RenderingHints.KEY_ANTIALIASING, + RenderingHints.VALUE_ANTIALIAS_ON); + } else { + sharedGraphics.setRenderingHint( + RenderingHints.KEY_ANTIALIASING, + RenderingHints.VALUE_ANTIALIAS_OFF); + } + AA = !AA; + mysleep(10); + } + }, + new Runnable() { + int t = 0; + public void run() { + sharedGraphics.setTransform( + transforms[t++ % transforms.length]); + mysleep(10); + } + }, + new Runnable() { + int c = 0; + public void run() { + AlphaComposite comp = comps[c++ % comps.length]; + if (comp == null) { + sharedGraphics.setXORMode(Color.green); + } else { + sharedGraphics.setComposite(comp); + } + mysleep(10); + } + }, + new Runnable() { + int s = 0; + public void run() { + sharedGraphics.setStroke(strokes[s++ % strokes.length]); + mysleep(10); + } + }, + new Runnable() { + int f = 0; + public void run() { + sharedGraphics.setFont(fonts[f++ % fonts.length]); + mysleep(10); + } + }, + }; + + final Runnable renderTests[] = { + new Runnable() { + public void run() { + sharedGraphics.drawLine(10, 10, 30, 30); + } + }, + new Runnable() { + public void run() { + sharedGraphics.drawLine(10, 10, 30, 30); + } + }, + new Runnable() { + public void run() { + sharedGraphics.drawRect(10, 10, 30, 30); + } + }, + new Runnable() { + public void run() { + sharedGraphics.fillRect(10, 10, 30, 30); + } + }, + new Runnable() { + public void run() { + sharedGraphics.drawString("Stuff", 10, 10); + } + }, + new Runnable() { + public void run() { + sharedGraphics.draw3DRect(10, 10, 30, 30, true); + } + }, + new Runnable() { + public void run() { + sharedGraphics.drawImage(sharedBI, 10, 10, null); + } + }, + new Runnable() { + public void run() { + sharedGraphics.fill3DRect(10, 10, 30, 30, false); + } + }, + // REMIND: copyArea doesn't work when transform is set.. + // new Runnable() { + // public void run() { + // sharedGraphics.copyArea(10, 10, 30, 30, 20, 20); + // } + // }, + new Runnable() { + public void run() { + sharedGraphics.drawRoundRect(10, 10, 30, 30, 20, 20); + } + }, + new Runnable() { + public void run() { + sharedGraphics.fillRoundRect(10, 10, 30, 30, 20, 20); + } + }, + new Runnable() { + public void run() { + sharedGraphics.drawArc(10, 10, 30, 30, 0, 90); + } + }, + new Runnable() { + public void run() { + sharedGraphics.fillArc(10, 10, 30, 30, 0, 90); + } + }, + new Runnable() { + public void run() { + sharedGraphics.drawOval(10, 10, 30, 30); + } + }, + new Runnable() { + public void run() { + sharedGraphics.fillOval(10, 10, 30, 30); + } + } + }; +}
--- a/test/sun/java2d/pipe/Test7027667.java Tue May 03 15:02:55 2011 -0700 +++ b/test/sun/java2d/pipe/Test7027667.java Tue May 03 22:11:02 2011 -0700 @@ -23,7 +23,7 @@ /** * @test - * @bug 7027667, 7023591 + * @bug 7027667 7023591 7037091 * * @summary Verifies that aa clipped rectangles are drawn, not filled. *
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/sun/java2d/pisces/Test7036754.java Tue May 03 22:11:02 2011 -0700 @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2011, 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 7036754 + * + * @summary Verifies that there are no non-finite numbers when stroking + * certain quadratic curves. + * + * @author Jim Graham + * @run main Test7036754 + */ + +import java.awt.*; +import java.awt.geom.*; + +public class Test7036754 { + public static void main(String argv[]) { + Shape s = new QuadCurve2D.Float(839.24677f, 508.97888f, + 839.2953f, 508.97122f, + 839.3438f, 508.96353f); + s = new BasicStroke(10f).createStrokedShape(s); + float nsegs[] = {2, 2, 4, 6, 0}; + float coords[] = new float[6]; + PathIterator pi = s.getPathIterator(null); + while (!pi.isDone()) { + int type = pi.currentSegment(coords); + for (int i = 0; i < nsegs[type]; i++) { + float c = coords[i]; + if (Float.isNaN(c) || Float.isInfinite(c)) { + throw new RuntimeException("bad value in stroke"); + } + } + pi.next(); + } + } +}