Examples with PRException sun.dc.pr.PRException used on opensource projects

Example 1 with PRException

use of sun.dc.pr.PRException in project jdk8u_jdk by JetBrains.

the class DuctusRenderingEngine method getAATileGenerator.

/**
     * {@inheritDoc}
     */
@Override
public AATileGenerator getAATileGenerator(double x, double y, double dx1, double dy1, double dx2, double dy2, double lw1, double lw2, Region clip, int[] bbox) {
    // REMIND: Deal with large coordinates!
    double ldx1, ldy1, ldx2, ldy2;
    boolean innerpgram = (lw1 > 0 && lw2 > 0);
    if (innerpgram) {
        ldx1 = dx1 * lw1;
        ldy1 = dy1 * lw1;
        ldx2 = dx2 * lw2;
        ldy2 = dy2 * lw2;
        x -= (ldx1 + ldx2) / 2.0;
        y -= (ldy1 + ldy2) / 2.0;
        dx1 += ldx1;
        dy1 += ldy1;
        dx2 += ldx2;
        dy2 += ldy2;
        if (lw1 > 1 && lw2 > 1) {
            // Inner parallelogram was entirely consumed by stroke...
            innerpgram = false;
        }
    } else {
        ldx1 = ldy1 = ldx2 = ldy2 = 0;
    }
    Rasterizer r = getRasterizer();
    r.setUsage(Rasterizer.EOFILL);
    r.beginPath();
    r.beginSubpath((float) x, (float) y);
    r.appendLine((float) (x + dx1), (float) (y + dy1));
    r.appendLine((float) (x + dx1 + dx2), (float) (y + dy1 + dy2));
    r.appendLine((float) (x + dx2), (float) (y + dy2));
    r.closedSubpath();
    if (innerpgram) {
        x += ldx1 + ldx2;
        y += ldy1 + ldy2;
        dx1 -= 2.0 * ldx1;
        dy1 -= 2.0 * ldy1;
        dx2 -= 2.0 * ldx2;
        dy2 -= 2.0 * ldy2;
        r.beginSubpath((float) x, (float) y);
        r.appendLine((float) (x + dx1), (float) (y + dy1));
        r.appendLine((float) (x + dx1 + dx2), (float) (y + dy1 + dy2));
        r.appendLine((float) (x + dx2), (float) (y + dy2));
        r.closedSubpath();
    }
    try {
        r.endPath();
        r.getAlphaBox(bbox);
        clip.clipBoxToBounds(bbox);
        if (bbox[0] >= bbox[2] || bbox[1] >= bbox[3]) {
            dropRasterizer(r);
            return null;
        }
        r.setOutputArea(bbox[0], bbox[1], bbox[2] - bbox[0], bbox[3] - bbox[1]);
    } catch (PRException e) {
        /*
             * This exeption is thrown from the native part of the Ductus
             * (only in case of a debug build) to indicate that some
             * segments of the path have very large coordinates.
             * See 4485298 for more info.
             */
        System.err.println("DuctusRenderingEngine.getAATileGenerator: " + e);
    }
    return r;
}

Example 2 with PRException

use of sun.dc.pr.PRException in project jdk8u_jdk by JetBrains.

the class DuctusRenderingEngine method getAATileGenerator.

/**
     * {@inheritDoc}
     */
@Override
public AATileGenerator getAATileGenerator(Shape s, AffineTransform at, Region clip, BasicStroke bs, boolean thin, boolean normalize, int[] bbox) {
    Rasterizer r = getRasterizer();
    PathIterator pi = s.getPathIterator(at);
    if (bs != null) {
        float[] matrix = null;
        r.setUsage(Rasterizer.STROKE);
        if (thin) {
            r.setPenDiameter(MinPenSizeAA);
        } else {
            r.setPenDiameter(bs.getLineWidth());
            if (at != null) {
                matrix = getTransformMatrix(at);
                r.setPenT4(matrix);
            }
            r.setPenFitting(PenUnits, MinPenUnitsAA);
        }
        r.setCaps(RasterizerCaps[bs.getEndCap()]);
        r.setCorners(RasterizerCorners[bs.getLineJoin()], bs.getMiterLimit());
        float[] dashes = bs.getDashArray();
        if (dashes != null) {
            r.setDash(dashes, bs.getDashPhase());
            if (at != null && matrix == null) {
                matrix = getTransformMatrix(at);
            }
            r.setDashT4(matrix);
        }
    } else {
        r.setUsage(pi.getWindingRule() == PathIterator.WIND_EVEN_ODD ? Rasterizer.EOFILL : Rasterizer.NZFILL);
    }
    r.beginPath();
    {
        boolean pathClosed = false;
        boolean skip = false;
        boolean subpathStarted = false;
        float mx = 0.0f;
        float my = 0.0f;
        float[] point = new float[6];
        float ax = 0.0f;
        float ay = 0.0f;
        while (!pi.isDone()) {
            int type = pi.currentSegment(point);
            if (pathClosed == true) {
                pathClosed = false;
                if (type != PathIterator.SEG_MOVETO) {
                    // Force current point back to last moveto point
                    r.beginSubpath(mx, my);
                    subpathStarted = true;
                }
            }
            if (normalize) {
                int index;
                switch(type) {
                    case PathIterator.SEG_CUBICTO:
                        index = 4;
                        break;
                    case PathIterator.SEG_QUADTO:
                        index = 2;
                        break;
                    case PathIterator.SEG_MOVETO:
                    case PathIterator.SEG_LINETO:
                        index = 0;
                        break;
                    case PathIterator.SEG_CLOSE:
                    default:
                        index = -1;
                        break;
                }
                if (index >= 0) {
                    float ox = point[index];
                    float oy = point[index + 1];
                    float newax = (float) Math.floor(ox) + 0.5f;
                    float neway = (float) Math.floor(oy) + 0.5f;
                    point[index] = newax;
                    point[index + 1] = neway;
                    newax -= ox;
                    neway -= oy;
                    switch(type) {
                        case PathIterator.SEG_CUBICTO:
                            point[0] += ax;
                            point[1] += ay;
                            point[2] += newax;
                            point[3] += neway;
                            break;
                        case PathIterator.SEG_QUADTO:
                            point[0] += (newax + ax) / 2;
                            point[1] += (neway + ay) / 2;
                            break;
                        case PathIterator.SEG_MOVETO:
                        case PathIterator.SEG_LINETO:
                        case PathIterator.SEG_CLOSE:
                            break;
                    }
                    ax = newax;
                    ay = neway;
                }
            }
            switch(type) {
                case PathIterator.SEG_MOVETO:
                    if (point[0] < UPPER_BND && point[0] > LOWER_BND && point[1] < UPPER_BND && point[1] > LOWER_BND) {
                        mx = point[0];
                        my = point[1];
                        r.beginSubpath(mx, my);
                        subpathStarted = true;
                        skip = false;
                    } else {
                        skip = true;
                    }
                    break;
                case PathIterator.SEG_LINETO:
                    /* Checking SEG_LINETO coordinates if they are out of the
                     * [LOWER_BND, UPPER_BND] range. This check also handles
                     * NaN and Infinity values. Ignoring current path segment
                     * in case of invalid data. If segment is skipped its
                     * endpoint (if valid) is used to begin new subpath.
                     */
                    if (point[0] < UPPER_BND && point[0] > LOWER_BND && point[1] < UPPER_BND && point[1] > LOWER_BND) {
                        if (skip) {
                            r.beginSubpath(point[0], point[1]);
                            subpathStarted = true;
                            skip = false;
                        } else {
                            r.appendLine(point[0], point[1]);
                        }
                    }
                    break;
                case PathIterator.SEG_QUADTO:
                    /* Checking SEG_QUADTO coordinates if they are out of the
                     * [LOWER_BND, UPPER_BND] range. This check also handles
                     * NaN and Infinity values. Ignoring current path segment
                     * in case of invalid endpoints's data. Equivalent to the
                     * SEG_LINETO if endpoint coordinates are valid but there
                     * are invalid data among other coordinates
                     */
                    if (point[2] < UPPER_BND && point[2] > LOWER_BND && point[3] < UPPER_BND && point[3] > LOWER_BND) {
                        if (skip) {
                            r.beginSubpath(point[2], point[3]);
                            subpathStarted = true;
                            skip = false;
                        } else {
                            if (point[0] < UPPER_BND && point[0] > LOWER_BND && point[1] < UPPER_BND && point[1] > LOWER_BND) {
                                r.appendQuadratic(point[0], point[1], point[2], point[3]);
                            } else {
                                r.appendLine(point[2], point[3]);
                            }
                        }
                    }
                    break;
                case PathIterator.SEG_CUBICTO:
                    if (point[4] < UPPER_BND && point[4] > LOWER_BND && point[5] < UPPER_BND && point[5] > LOWER_BND) {
                        if (skip) {
                            r.beginSubpath(point[4], point[5]);
                            subpathStarted = true;
                            skip = false;
                        } else {
                            if (point[0] < UPPER_BND && point[0] > LOWER_BND && point[1] < UPPER_BND && point[1] > LOWER_BND && point[2] < UPPER_BND && point[2] > LOWER_BND && point[3] < UPPER_BND && point[3] > LOWER_BND) {
                                r.appendCubic(point[0], point[1], point[2], point[3], point[4], point[5]);
                            } else {
                                r.appendLine(point[4], point[5]);
                            }
                        }
                    }
                    break;
                case PathIterator.SEG_CLOSE:
                    if (subpathStarted) {
                        r.closedSubpath();
                        subpathStarted = false;
                        pathClosed = true;
                    }
                    break;
            }
            pi.next();
        }
    }
    try {
        r.endPath();
        r.getAlphaBox(bbox);
        clip.clipBoxToBounds(bbox);
        if (bbox[0] >= bbox[2] || bbox[1] >= bbox[3]) {
            dropRasterizer(r);
            return null;
        }
        r.setOutputArea(bbox[0], bbox[1], bbox[2] - bbox[0], bbox[3] - bbox[1]);
    } catch (PRException e) {
        /*
             * This exeption is thrown from the native part of the Ductus
             * (only in case of a debug build) to indicate that some
             * segments of the path have very large coordinates.
             * See 4485298 for more info.
             */
        System.err.println("DuctusRenderingEngine.getAATileGenerator: " + e);
    }
    return r;
}