1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110
/* * @(#)GeneralPath.java 1.64 06/03/13 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.awt.geom; import java.awt.Shape; /** * The {@code GeneralPath} class represents a geometric path * constructed from straight lines, and quadratic and cubic * (Bézier) curves. It can contain multiple subpaths. * <p> * {@code GeneralPath} is a legacy final class which exactly * implements the behavior of its superclass {@link Path2D.Float}. * Together with {@link Path2D.Double}, the {@link Path2D} classes * provide 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 explicitly * select different levels of internal coordinate precision. * <p> * 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. * * @version 1.64, 03/13/06 * @author Jim Graham * @since 1.2 */ public final class GeneralPath extends Path2D.Float { /** * Constructs a new empty single precision {@code GeneralPath} object * with a default winding rule of {@link #WIND_NON_ZERO}. * * @since 1.2 */ public GeneralPath() { super(WIND_NON_ZERO, INIT_SIZE); } /** * Constructs a new <code>GeneralPath</code> object with the specified * winding rule to control operations that require the interior of the * path to be defined. * * @param rule the winding rule * @see #WIND_EVEN_ODD * @see #WIND_NON_ZERO * @since 1.2 */ public GeneralPath(int rule) { super(rule, INIT_SIZE); } /** * Constructs a new <code>GeneralPath</code> object with the specified * winding rule and the specified initial capacity to store path * coordinates. * This number is an initial guess as to how many path segments * will be added to the path, but the storage is expanded as * needed to store whatever path segments are added. * * @param rule the winding rule * @param initialCapacity the estimate for the number of path segments * in the path * @see #WIND_EVEN_ODD * @see #WIND_NON_ZERO * @since 1.2 */ public GeneralPath(int rule, int initialCapacity) { super(rule, initialCapacity); } /** * Constructs a new <code>GeneralPath</code> object from an arbitrary * {@link Shape} object. * All of the initial geometry and the winding rule for this path are * taken from the specified <code>Shape</code> object. * * @param s the specified <code>Shape</code> object * @since 1.2 */ public GeneralPath(Shape s) { super(s, null); } GeneralPath(int windingRule, byte[] pointTypes, int numTypes, float[] pointCoords, int numCoords) { // used to construct from native this.windingRule = windingRule; this.pointTypes = pointTypes; this.numTypes = numTypes; this.floatCoords = pointCoords; this.numCoords = numCoords; } /* * JDK 1.6 serialVersionUID */ private static final long serialVersionUID = -8327096662768731142L; }