Examples of ae.java.awt.geom.GeneralPath

ae.java.awt.geom.GeneralPath
The {@code GeneralPath} class represents a geometric pathconstructed from straight lines, and quadratic and cubic (Bézier) curves. It can contain multiple subpaths.
{@code GeneralPath} is a legacy final class which exactlyimplements the behavior of its superclass {@link Path2D.Float}. Together with {@link Path2D.Double}, the {@link Path2D} classesprovide full implementations of a general geometric path that support all of the functionality of the {@link Shape} and{@link PathIterator} interfaces with the ability to explicitlyselect different levels of internal coordinate precision.
Use {@code Path2D.Float} (or this legacy {@code GeneralPath}subclass) when dealing with data that can be represented and used with floating point precision. Use {@code Path2D.Double}for data that requires the accuracy or range of double precision. @author Jim Graham @since 1.2

     */
    private Shape getGlyphsOutline(int start, int count, float x, float y) {
        setFRCTX();
        initPositions();


        GeneralPath result = new GeneralPath(GeneralPath.WIND_NON_ZERO);
        for (int i = start, e = start + count, n = start * 2; i < e; ++i, n += 2) {
            float px = x + positions[n];
            float py = y + positions[n+1];


            getGlyphStrike(i).appendGlyphOutline(glyphs[i], result, px, py);

View Full Code Here

                                         start, extent, Arc2D.PIE));
    }


    private Shape makePoly(int xPoints[], int yPoints[],
                           int nPoints, boolean close) {
        GeneralPath gp = new GeneralPath(GeneralPath.WIND_EVEN_ODD);
        if (nPoints > 0) {
            gp.moveTo(xPoints[0], yPoints[0]);
        }
        for (int i = 1; i < nPoints; i++) {
            gp.lineTo(xPoints[i], yPoints[i]);
        }
        if (close) {
            gp.closePath();
        }
        return gp;
    }

View Full Code Here

        if (graphicCount == 1) {
            AffineTransform tx = new AffineTransform(matrix);
            return graphic.getOutline(tx);
        }


        GeneralPath gp = new GeneralPath();
        for (int i = 0; i < graphicCount; ++i) {
            AffineTransform tx = new AffineTransform(matrix);
            gp.append(graphic.getOutline(tx), false);
            matrix[4] += graphicAdvance;
        }


        return gp;
    }

View Full Code Here

                    new double[] { x0, y0, x1, y1 };
    }




    private static GeneralPath pathToShape(double[] path, boolean close, LayoutPathImpl lp) {
        GeneralPath result = new GeneralPath(GeneralPath.WIND_EVEN_ODD, path.length);
        result.moveTo((float)path[0], (float)path[1]);
        for (int i = 2; i < path.length; i += 2) {
            result.lineTo((float)path[i], (float)path[i+1]);
        }
        if (close) {
            result.closePath();
        }


        if (lp != null) {
            result = (GeneralPath)lp.mapShape(result);
        }

View Full Code Here

        // that.  We do need to prevent the two segments which
        // join path0 to path1 from crossing each other.  So, if we
        // traverse path0 from top to bottom, we'll traverse path1 from
        // bottom to top (and vice versa).


        GeneralPath result = pathToShape(path0, false, null);


        boolean sameDirection;


        if (isVerticalLine) {
            sameDirection = (path0[1] > path0[path0.length-1]) ==
                            (path1[1] > path1[path1.length-1]);
        }
        else {
            sameDirection = (path0[0] > path0[path0.length-2]) ==
                            (path1[0] > path1[path1.length-2]);
        }


        int start;
        int limit;
        int increment;


        if (sameDirection) {
            start = path1.length-2;
            limit = -2;
            increment = -2;
        }
        else {
            start = 0;
            limit = path1.length;
            increment = 2;
        }


        for (int i = start; i != limit; i += increment) {
            result.lineTo((float)path1[i], (float)path1[i+1]);
        }


        result.closePath();


        return result;
    }

View Full Code Here


        if(bounds == null) {
                throw new IllegalArgumentException("Null Rectangle2D passed to TextLayout.getVisualHighlightShape()");
        }


        GeneralPath result = new GeneralPath(GeneralPath.WIND_EVEN_ODD);


        int firstCaret = hitToCaret(firstEndpoint);
        int secondCaret = hitToCaret(secondEndpoint);


        result.append(caretBoundingShape(firstCaret, secondCaret, bounds),
                      false);


        if (firstCaret == 0 || secondCaret == 0) {
            GeneralPath ls = leftShape(bounds);
            if (!ls.getBounds().isEmpty())
                result.append(ls, false);
        }


        if (firstCaret == characterCount || secondCaret == characterCount) {
            GeneralPath rs = rightShape(bounds);
            if (!rs.getBounds().isEmpty()) {
                result.append(rs, false);
            }
        }


        LayoutPathImpl lp = textLine.getLayoutPath();

View Full Code Here


        if(firstEndpoint < 0 || secondEndpoint > characterCount) {
            throw new IllegalArgumentException("Range is invalid in TextLayout.getLogicalHighlightShape()");
        }


        GeneralPath result = new GeneralPath(GeneralPath.WIND_EVEN_ODD);


        int[] carets = new int[10]; // would this ever not handle all cases?
        int count = 0;


        if (firstEndpoint < secondEndpoint) {
            int logIndex = firstEndpoint;
            do {
                carets[count++] = hitToCaret(TextHitInfo.leading(logIndex));
                boolean ltr = textLine.isCharLTR(logIndex);


                do {
                    logIndex++;
                } while (logIndex < secondEndpoint && textLine.isCharLTR(logIndex) == ltr);


                int hitCh = logIndex;
                carets[count++] = hitToCaret(TextHitInfo.trailing(hitCh - 1));


                if (count == carets.length) {
                    int[] temp = new int[carets.length + 10];
                    System.arraycopy(carets, 0, temp, 0, count);
                    carets = temp;
                }
            } while (logIndex < secondEndpoint);
        }
        else {
            count = 2;
            carets[0] = carets[1] = hitToCaret(TextHitInfo.leading(firstEndpoint));
        }


        // now create paths for pairs of carets


        for (int i = 0; i < count; i += 2) {
            result.append(caretBoundingShape(carets[i], carets[i+1], bounds),
                          false);
        }


        if (firstEndpoint != secondEndpoint) {
            if ((textLine.isDirectionLTR() && firstEndpoint == 0) || (!textLine.isDirectionLTR() &&
                                                                      secondEndpoint == characterCount)) {
                GeneralPath ls = leftShape(bounds);
                if (!ls.getBounds().isEmpty()) {
                    result.append(ls, false);
                }
            }


            if ((textLine.isDirectionLTR() && secondEndpoint == characterCount) ||
                (!textLine.isDirectionLTR() && firstEndpoint == 0)) {


                GeneralPath rs = rightShape(bounds);
                if (!rs.getBounds().isEmpty()) {
                    result.append(rs, false);
                }
            }
        }

View Full Code Here

        /*
         * return an area that consists of the bounding boxes of all the
         * characters from firstEndpoint to limit
         */


        GeneralPath result = new GeneralPath(GeneralPath.WIND_NON_ZERO);


        if (firstEndpoint < characterCount) {
            for (int logIndex = firstEndpoint;
                        logIndex < secondEndpoint;
                        logIndex++) {


                Rectangle2D r = textLine.getCharBounds(logIndex);
                if (!r.isEmpty()) {
                    result.append(r, false);
                }
            }
        }


        if (dx != 0 || dy != 0) {

View Full Code Here

            }


            // area won't be null here, since at least one underline exists.
            area.add(new Area(label.handleGetOutline(x, y)));


            return new GeneralPath(area);
        }

View Full Code Here

    }


    GeneralPath getGlyphOutline(int glyphCode, float x, float y) {


        PhysicalStrike strike = getStrikeForGlyph(glyphCode);
        GeneralPath path = strike.getGlyphOutline(glyphCode & SLOTMASK, x, y);
        if (path == null) {
            return new GeneralPath();
        } else {
            return path;
        }
    }

View Full Code Here

0 1 2

TOP

Related Classes of ae.java.awt.geom.GeneralPath

ae.java.awt.font.TextLayout

ae.java.awt.font.TextLine

ae.sun.font.CompositeStrike

ae.sun.font.Decoration$DecorationImpl

ae.sun.font.GraphicComponent

ae.sun.font.LayoutPathImpl$SegmentPath$Mapper

ae.sun.font.LayoutPathImpl$SegmentPath$Segment

ae.sun.font.NullFontScaler

ae.sun.font.StandardGlyphVector

ae.sun.font.StandardGlyphVector$GlyphStrike

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.