1 /*

     2  * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 package java.awt.geom;

    27 

    28 import java.io.Serializable;

    29 

    30 /**

    31  * <CODE>Arc2D</CODE> is the abstract superclass for all objects that

    32  * store a 2D arc defined by a framing rectangle,

    33  * start angle, angular extent (length of the arc), and a closure type

    34  * (<CODE>OPEN</CODE>, <CODE>CHORD</CODE>, or <CODE>PIE</CODE>).

    35  * <p>

    36  * <a name="inscribes">

    37  * The arc is a partial section of a full ellipse which

    38  * inscribes the framing rectangle of its parent {@link RectangularShape}.

    39  * </a>

    40  * <a name="angles">

    41  * The angles are specified relative to the non-square

    42  * framing rectangle such that 45 degrees always falls on the line from

    43  * the center of the ellipse to the upper right corner of the framing

    44  * rectangle.

    45  * As a result, if the framing rectangle is noticeably longer along one

    46  * axis than the other, the angles to the start and end of the arc segment

    47  * will be skewed farther along the longer axis of the frame.

    48  * </a>

    49  * <p>

    50  * The actual storage representation of the coordinates is left to

    51  * the subclass.

    52  *

    53  * @author      Jim Graham

    54  * @since 1.2

    55  */

    56 public abstract class Arc2D extends RectangularShape {

    57 

    58     /**

    59      * The closure type for an open arc with no path segments

    60      * connecting the two ends of the arc segment.

    61      * @since 1.2

    62      */

    63     public final static int OPEN = 0;

    64 

    65     /**

    66      * The closure type for an arc closed by drawing a straight

    67      * line segment from the start of the arc segment to the end of the

    68      * arc segment.

    69      * @since 1.2

    70      */

    71     public final static int CHORD = 1;

    72 

    73     /**

    74      * The closure type for an arc closed by drawing straight line

    75      * segments from the start of the arc segment to the center

    76      * of the full ellipse and from that point to the end of the arc segment.

    77      * @since 1.2

    78      */

    79     public final static int PIE = 2;

    80 

    81     /**

    82      * This class defines an arc specified in {@code float} precision.

    83      * @since 1.2

    84      */

    85     public static class Float extends Arc2D implements Serializable {

    86         /**

    87          * The X coordinate of the upper-left corner of the framing

    88          * rectangle of the arc.

    89          * @since 1.2

    90          * @serial

    91          */

    92         public float x;

    93 

    94         /**

    95          * The Y coordinate of the upper-left corner of the framing

    96          * rectangle of the arc.

    97          * @since 1.2

    98          * @serial

    99          */

   100         public float y;

   101 

   102         /**

   103          * The overall width of the full ellipse of which this arc is

   104          * a partial section (not considering the

   105          * angular extents).

   106          * @since 1.2

   107          * @serial

   108          */

   109         public float width;

   110 

   111         /**

   112          * The overall height of the full ellipse of which this arc is

   113          * a partial section (not considering the

   114          * angular extents).

   115          * @since 1.2

   116          * @serial

   117          */

   118         public float height;

   119 

   120         /**

   121          * The starting angle of the arc in degrees.

   122          * @since 1.2

   123          * @serial

   124          */

   125         public float start;

   126 

   127         /**

   128          * The angular extent of the arc in degrees.

   129          * @since 1.2

   130          * @serial

   131          */

   132         public float extent;

   133 

   134         /**

   135          * Constructs a new OPEN arc, initialized to location (0, 0),

   136          * size (0, 0), angular extents (start = 0, extent = 0).

   137          * @since 1.2

   138          */

   139         public Float() {

   140             super(OPEN);

   141         }

   142 

   143         /**

   144          * Constructs a new arc, initialized to location (0, 0),

   145          * size (0, 0), angular extents (start = 0, extent = 0), and

   146          * the specified closure type.

   147          *

   148          * @param type The closure type for the arc:

   149          * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   150          * @since 1.2

   151          */

   152         public Float(int type) {

   153             super(type);

   154         }

   155 

   156         /**

   157          * Constructs a new arc, initialized to the specified location,

   158          * size, angular extents, and closure type.

   159          *

   160          * @param x The X coordinate of the upper-left corner of

   161          *          the arc's framing rectangle.

   162          * @param y The Y coordinate of the upper-left corner of

   163          *          the arc's framing rectangle.

   164          * @param w The overall width of the full ellipse of which

   165          *          this arc is a partial section.

   166          * @param h The overall height of the full ellipse of which this

   167          *          arc is a partial section.

   168          * @param start The starting angle of the arc in degrees.

   169          * @param extent The angular extent of the arc in degrees.

   170          * @param type The closure type for the arc:

   171          * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   172          * @since 1.2

   173          */

   174         public Float(float x, float y, float w, float h,

   175                      float start, float extent, int type) {

   176             super(type);

   177             this.x = x;

   178             this.y = y;

   179             this.width = w;

   180             this.height = h;

   181             this.start = start;

   182             this.extent = extent;

   183         }

   184 

   185         /**

   186          * Constructs a new arc, initialized to the specified location,

   187          * size, angular extents, and closure type.

   188          *

   189          * @param ellipseBounds The framing rectangle that defines the

   190          * outer boundary of the full ellipse of which this arc is a

   191          * partial section.

   192          * @param start The starting angle of the arc in degrees.

   193          * @param extent The angular extent of the arc in degrees.

   194          * @param type The closure type for the arc:

   195          * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   196          * @since 1.2

   197          */

   198         public Float(Rectangle2D ellipseBounds,

   199                      float start, float extent, int type) {

   200             super(type);

   201             this.x = (float) ellipseBounds.getX();

   202             this.y = (float) ellipseBounds.getY();

   203             this.width = (float) ellipseBounds.getWidth();

   204             this.height = (float) ellipseBounds.getHeight();

   205             this.start = start;

   206             this.extent = extent;

   207         }

   208 

   209         /**

   210          * {@inheritDoc}

   211          * Note that the arc

   212          * <a href="Arc2D.html#inscribes">partially inscribes</a>

   213          * the framing rectangle of this {@code RectangularShape}.

   214          *

   215          * @since 1.2

   216          */

   217         public double getX() {

   218             return (double) x;

   219         }

   220 

   221         /**

   222          * {@inheritDoc}

   223          * Note that the arc

   224          * <a href="Arc2D.html#inscribes">partially inscribes</a>

   225          * the framing rectangle of this {@code RectangularShape}.

   226          *

   227          * @since 1.2

   228          */

   229         public double getY() {

   230             return (double) y;

   231         }

   232 

   233         /**

   234          * {@inheritDoc}

   235          * Note that the arc

   236          * <a href="Arc2D.html#inscribes">partially inscribes</a>

   237          * the framing rectangle of this {@code RectangularShape}.

   238          *

   239          * @since 1.2

   240          */

   241         public double getWidth() {

   242             return (double) width;

   243         }

   244 

   245         /**

   246          * {@inheritDoc}

   247          * Note that the arc

   248          * <a href="Arc2D.html#inscribes">partially inscribes</a>

   249          * the framing rectangle of this {@code RectangularShape}.

   250          *

   251          * @since 1.2

   252          */

   253         public double getHeight() {

   254             return (double) height;

   255         }

   256 

   257         /**

   258          * {@inheritDoc}

   259          * @since 1.2

   260          */

   261         public double getAngleStart() {

   262             return (double) start;

   263         }

   264 

   265         /**

   266          * {@inheritDoc}

   267          * @since 1.2

   268          */

   269         public double getAngleExtent() {

   270             return (double) extent;

   271         }

   272 

   273         /**

   274          * {@inheritDoc}

   275          * @since 1.2

   276          */

   277         public boolean isEmpty() {

   278             return (width <= 0.0 || height <= 0.0);

   279         }

   280 

   281         /**

   282          * {@inheritDoc}

   283          * @since 1.2

   284          */

   285         public void setArc(double x, double y, double w, double h,

   286                            double angSt, double angExt, int closure) {

   287             this.setArcType(closure);

   288             this.x = (float) x;

   289             this.y = (float) y;

   290             this.width = (float) w;

   291             this.height = (float) h;

   292             this.start = (float) angSt;

   293             this.extent = (float) angExt;

   294         }

   295 

   296         /**

   297          * {@inheritDoc}

   298          * @since 1.2

   299          */

   300         public void setAngleStart(double angSt) {

   301             this.start = (float) angSt;

   302         }

   303 

   304         /**

   305          * {@inheritDoc}

   306          * @since 1.2

   307          */

   308         public void setAngleExtent(double angExt) {

   309             this.extent = (float) angExt;

   310         }

   311 

   312         /**

   313          * {@inheritDoc}

   314          * @since 1.2

   315          */

   316         protected Rectangle2D makeBounds(double x, double y,

   317                                          double w, double h) {

   318             return new Rectangle2D.Float((float) x, (float) y,

   319                                          (float) w, (float) h);

   320         }

   321 

   322         /*

   323          * JDK 1.6 serialVersionUID

   324          */

   325         private static final long serialVersionUID = 9130893014586380278L;

   326 

   327         /**

   328          * Writes the default serializable fields to the

   329          * <code>ObjectOutputStream</code> followed by a byte

   330          * indicating the arc type of this <code>Arc2D</code>

   331          * instance.

   332          *

   333          * @serialData

   334          * <ol>

   335          * <li>The default serializable fields.

   336          * <li>

   337          * followed by a <code>byte</code> indicating the arc type

   338          * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   339          * </ol>

   340          */

   341         private void writeObject(java.io.ObjectOutputStream s)

   342             throws java.io.IOException

   343         {

   344             s.defaultWriteObject();

   345 

   346             s.writeByte(getArcType());

   347         }

   348 

   349         /**

   350          * Reads the default serializable fields from the

   351          * <code>ObjectInputStream</code> followed by a byte

   352          * indicating the arc type of this <code>Arc2D</code>

   353          * instance.

   354          *

   355          * @serialData

   356          * <ol>

   357          * <li>The default serializable fields.

   358          * <li>

   359          * followed by a <code>byte</code> indicating the arc type

   360          * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   361          * </ol>

   362          */

   363         private void readObject(java.io.ObjectInputStream s)

   364             throws java.lang.ClassNotFoundException, java.io.IOException

   365         {

   366             s.defaultReadObject();

   367 

   368             try {

   369                 setArcType(s.readByte());

   370             } catch (IllegalArgumentException iae) {

   371                 throw new java.io.InvalidObjectException(iae.getMessage());

   372             }

   373         }

   374     }

   375 

   376     /**

   377      * This class defines an arc specified in {@code double} precision.

   378      * @since 1.2

   379      */

   380     public static class Double extends Arc2D implements Serializable {

   381         /**

   382          * The X coordinate of the upper-left corner of the framing

   383          * rectangle of the arc.

   384          * @since 1.2

   385          * @serial

   386          */

   387         public double x;

   388 

   389         /**

   390          * The Y coordinate of the upper-left corner of the framing

   391          * rectangle of the arc.

   392          * @since 1.2

   393          * @serial

   394          */

   395         public double y;

   396 

   397         /**

   398          * The overall width of the full ellipse of which this arc is

   399          * a partial section (not considering the angular extents).

   400          * @since 1.2

   401          * @serial

   402          */

   403         public double width;

   404 

   405         /**

   406          * The overall height of the full ellipse of which this arc is

   407          * a partial section (not considering the angular extents).

   408          * @since 1.2

   409          * @serial

   410          */

   411         public double height;

   412 

   413         /**

   414          * The starting angle of the arc in degrees.

   415          * @since 1.2

   416          * @serial

   417          */

   418         public double start;

   419 

   420         /**

   421          * The angular extent of the arc in degrees.

   422          * @since 1.2

   423          * @serial

   424          */

   425         public double extent;

   426 

   427         /**

   428          * Constructs a new OPEN arc, initialized to location (0, 0),

   429          * size (0, 0), angular extents (start = 0, extent = 0).

   430          * @since 1.2

   431          */

   432         public Double() {

   433             super(OPEN);

   434         }

   435 

   436         /**

   437          * Constructs a new arc, initialized to location (0, 0),

   438          * size (0, 0), angular extents (start = 0, extent = 0), and

   439          * the specified closure type.

   440          *

   441          * @param type The closure type for the arc:

   442          * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   443          * @since 1.2

   444          */

   445         public Double(int type) {

   446             super(type);

   447         }

   448 

   449         /**

   450          * Constructs a new arc, initialized to the specified location,

   451          * size, angular extents, and closure type.

   452          *

   453          * @param x The X coordinate of the upper-left corner

   454          *          of the arc's framing rectangle.

   455          * @param y The Y coordinate of the upper-left corner

   456          *          of the arc's framing rectangle.

   457          * @param w The overall width of the full ellipse of which this

   458          *          arc is a partial section.

   459          * @param h The overall height of the full ellipse of which this

   460          *          arc is a partial section.

   461          * @param start The starting angle of the arc in degrees.

   462          * @param extent The angular extent of the arc in degrees.

   463          * @param type The closure type for the arc:

   464          * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   465          * @since 1.2

   466          */

   467         public Double(double x, double y, double w, double h,

   468                       double start, double extent, int type) {

   469             super(type);

   470             this.x = x;

   471             this.y = y;

   472             this.width = w;

   473             this.height = h;

   474             this.start = start;

   475             this.extent = extent;

   476         }

   477 

   478         /**

   479          * Constructs a new arc, initialized to the specified location,

   480          * size, angular extents, and closure type.

   481          *

   482          * @param ellipseBounds The framing rectangle that defines the

   483          * outer boundary of the full ellipse of which this arc is a

   484          * partial section.

   485          * @param start The starting angle of the arc in degrees.

   486          * @param extent The angular extent of the arc in degrees.

   487          * @param type The closure type for the arc:

   488          * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   489          * @since 1.2

   490          */

   491         public Double(Rectangle2D ellipseBounds,

   492                       double start, double extent, int type) {

   493             super(type);

   494             this.x = ellipseBounds.getX();

   495             this.y = ellipseBounds.getY();

   496             this.width = ellipseBounds.getWidth();

   497             this.height = ellipseBounds.getHeight();

   498             this.start = start;

   499             this.extent = extent;

   500         }

   501 

   502         /**

   503          * {@inheritDoc}

   504          * Note that the arc

   505          * <a href="Arc2D.html#inscribes">partially inscribes</a>

   506          * the framing rectangle of this {@code RectangularShape}.

   507          *

   508          * @since 1.2

   509          */

   510         public double getX() {

   511             return x;

   512         }

   513 

   514         /**

   515          * {@inheritDoc}

   516          * Note that the arc

   517          * <a href="Arc2D.html#inscribes">partially inscribes</a>

   518          * the framing rectangle of this {@code RectangularShape}.

   519          *

   520          * @since 1.2

   521          */

   522         public double getY() {

   523             return y;

   524         }

   525 

   526         /**

   527          * {@inheritDoc}

   528          * Note that the arc

   529          * <a href="Arc2D.html#inscribes">partially inscribes</a>

   530          * the framing rectangle of this {@code RectangularShape}.

   531          *

   532          * @since 1.2

   533          */

   534         public double getWidth() {

   535             return width;

   536         }

   537 

   538         /**

   539          * {@inheritDoc}

   540          * Note that the arc

   541          * <a href="Arc2D.html#inscribes">partially inscribes</a>

   542          * the framing rectangle of this {@code RectangularShape}.

   543          *

   544          * @since 1.2

   545          */

   546         public double getHeight() {

   547             return height;

   548         }

   549 

   550         /**

   551          * {@inheritDoc}

   552          * @since 1.2

   553          */

   554         public double getAngleStart() {

   555             return start;

   556         }

   557 

   558         /**

   559          * {@inheritDoc}

   560          * @since 1.2

   561          */

   562         public double getAngleExtent() {

   563             return extent;

   564         }

   565 

   566         /**

   567          * {@inheritDoc}

   568          * @since 1.2

   569          */

   570         public boolean isEmpty() {

   571             return (width <= 0.0 || height <= 0.0);

   572         }

   573 

   574         /**

   575          * {@inheritDoc}

   576          * @since 1.2

   577          */

   578         public void setArc(double x, double y, double w, double h,

   579                            double angSt, double angExt, int closure) {

   580             this.setArcType(closure);

   581             this.x = x;

   582             this.y = y;

   583             this.width = w;

   584             this.height = h;

   585             this.start = angSt;

   586             this.extent = angExt;

   587         }

   588 

   589         /**

   590          * {@inheritDoc}

   591          * @since 1.2

   592          */

   593         public void setAngleStart(double angSt) {

   594             this.start = angSt;

   595         }

   596 

   597         /**

   598          * {@inheritDoc}

   599          * @since 1.2

   600          */

   601         public void setAngleExtent(double angExt) {

   602             this.extent = angExt;

   603         }

   604 

   605         /**

   606          * {@inheritDoc}

   607          * @since 1.2

   608          */

   609         protected Rectangle2D makeBounds(double x, double y,

   610                                          double w, double h) {

   611             return new Rectangle2D.Double(x, y, w, h);

   612         }

   613 

   614         /*

   615          * JDK 1.6 serialVersionUID

   616          */

   617         private static final long serialVersionUID = 728264085846882001L;

   618 

   619         /**

   620          * Writes the default serializable fields to the

   621          * <code>ObjectOutputStream</code> followed by a byte

   622          * indicating the arc type of this <code>Arc2D</code>

   623          * instance.

   624          *

   625          * @serialData

   626          * <ol>

   627          * <li>The default serializable fields.

   628          * <li>

   629          * followed by a <code>byte</code> indicating the arc type

   630          * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   631          * </ol>

   632          */

   633         private void writeObject(java.io.ObjectOutputStream s)

   634             throws java.io.IOException

   635         {

   636             s.defaultWriteObject();

   637 

   638             s.writeByte(getArcType());

   639         }

   640 

   641         /**

   642          * Reads the default serializable fields from the

   643          * <code>ObjectInputStream</code> followed by a byte

   644          * indicating the arc type of this <code>Arc2D</code>

   645          * instance.

   646          *

   647          * @serialData

   648          * <ol>

   649          * <li>The default serializable fields.

   650          * <li>

   651          * followed by a <code>byte</code> indicating the arc type

   652          * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   653          * </ol>

   654          */

   655         private void readObject(java.io.ObjectInputStream s)

   656             throws java.lang.ClassNotFoundException, java.io.IOException

   657         {

   658             s.defaultReadObject();

   659 

   660             try {

   661                 setArcType(s.readByte());

   662             } catch (IllegalArgumentException iae) {

   663                 throw new java.io.InvalidObjectException(iae.getMessage());

   664             }

   665         }

   666     }

   667 

   668     private int type;

   669 

   670     /**

   671      * This is an abstract class that cannot be instantiated directly.

   672      * Type-specific implementation subclasses are available for

   673      * instantiation and provide a number of formats for storing

   674      * the information necessary to satisfy the various accessor

   675      * methods below.

   676      * <p>

   677      * This constructor creates an object with a default closure

   678      * type of {@link #OPEN}.  It is provided only to enable

   679      * serialization of subclasses.

   680      *

   681      * @see java.awt.geom.Arc2D.Float

   682      * @see java.awt.geom.Arc2D.Double

   683      */

   684     Arc2D() {

   685         this(OPEN);

   686     }

   687 

   688     /**

   689      * This is an abstract class that cannot be instantiated directly.

   690      * Type-specific implementation subclasses are available for

   691      * instantiation and provide a number of formats for storing

   692      * the information necessary to satisfy the various accessor

   693      * methods below.

   694      *

   695      * @param type The closure type of this arc:

   696      * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   697      * @see java.awt.geom.Arc2D.Float

   698      * @see java.awt.geom.Arc2D.Double

   699      * @since 1.2

   700      */

   701     protected Arc2D(int type) {

   702         setArcType(type);

   703     }

   704 

   705     /**

   706      * Returns the starting angle of the arc.

   707      *

   708      * @return A double value that represents the starting angle

   709      * of the arc in degrees.

   710      * @see #setAngleStart

   711      * @since 1.2

   712      */

   713     public abstract double getAngleStart();

   714 

   715     /**

   716      * Returns the angular extent of the arc.

   717      *

   718      * @return A double value that represents the angular extent

   719      * of the arc in degrees.

   720      * @see #setAngleExtent

   721      * @since 1.2

   722      */

   723     public abstract double getAngleExtent();

   724 

   725     /**

   726      * Returns the arc closure type of the arc: {@link #OPEN},

   727      * {@link #CHORD}, or {@link #PIE}.

   728      * @return One of the integer constant closure types defined

   729      * in this class.

   730      * @see #setArcType

   731      * @since 1.2

   732      */

   733     public int getArcType() {

   734         return type;

   735     }

   736 

   737     /**

   738      * Returns the starting point of the arc.  This point is the

   739      * intersection of the ray from the center defined by the

   740      * starting angle and the elliptical boundary of the arc.

   741      *

   742      * @return A <CODE>Point2D</CODE> object representing the

   743      * x,y coordinates of the starting point of the arc.

   744      * @since 1.2

   745      */

   746     public Point2D getStartPoint() {

   747         double angle = Math.toRadians(-getAngleStart());

   748         double x = getX() + (Math.cos(angle) * 0.5 + 0.5) * getWidth();

   749         double y = getY() + (Math.sin(angle) * 0.5 + 0.5) * getHeight();

   750         return new Point2D.Double(x, y);

   751     }

   752 

   753     /**

   754      * Returns the ending point of the arc.  This point is the

   755      * intersection of the ray from the center defined by the

   756      * starting angle plus the angular extent of the arc and the

   757      * elliptical boundary of the arc.

   758      *

   759      * @return A <CODE>Point2D</CODE> object representing the

   760      * x,y coordinates  of the ending point of the arc.

   761      * @since 1.2

   762      */

   763     public Point2D getEndPoint() {

   764         double angle = Math.toRadians(-getAngleStart() - getAngleExtent());

   765         double x = getX() + (Math.cos(angle) * 0.5 + 0.5) * getWidth();

   766         double y = getY() + (Math.sin(angle) * 0.5 + 0.5) * getHeight();

   767         return new Point2D.Double(x, y);

   768     }

   769 

   770     /**

   771      * Sets the location, size, angular extents, and closure type of

   772      * this arc to the specified double values.

   773      *

   774      * @param x The X coordinate of the upper-left corner of the arc.

   775      * @param y The Y coordinate of the upper-left corner of the arc.

   776      * @param w The overall width of the full ellipse of which

   777      *          this arc is a partial section.

   778      * @param h The overall height of the full ellipse of which

   779      *          this arc is a partial section.

   780      * @param angSt The starting angle of the arc in degrees.

   781      * @param angExt The angular extent of the arc in degrees.

   782      * @param closure The closure type for the arc:

   783      * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   784      * @since 1.2

   785      */

   786     public abstract void setArc(double x, double y, double w, double h,

   787                                 double angSt, double angExt, int closure);

   788 

   789     /**

   790      * Sets the location, size, angular extents, and closure type of

   791      * this arc to the specified values.

   792      *

   793      * @param loc The <CODE>Point2D</CODE> representing the coordinates of

   794      * the upper-left corner of the arc.

   795      * @param size The <CODE>Dimension2D</CODE> representing the width

   796      * and height of the full ellipse of which this arc is

   797      * a partial section.

   798      * @param angSt The starting angle of the arc in degrees.

   799      * @param angExt The angular extent of the arc in degrees.

   800      * @param closure The closure type for the arc:

   801      * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   802      * @since 1.2

   803      */

   804     public void setArc(Point2D loc, Dimension2D size,

   805                        double angSt, double angExt, int closure) {

   806         setArc(loc.getX(), loc.getY(), size.getWidth(), size.getHeight(),

   807                angSt, angExt, closure);

   808     }

   809 

   810     /**

   811      * Sets the location, size, angular extents, and closure type of

   812      * this arc to the specified values.

   813      *

   814      * @param rect The framing rectangle that defines the

   815      * outer boundary of the full ellipse of which this arc is a

   816      * partial section.

   817      * @param angSt The starting angle of the arc in degrees.

   818      * @param angExt The angular extent of the arc in degrees.

   819      * @param closure The closure type for the arc:

   820      * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   821      * @since 1.2

   822      */

   823     public void setArc(Rectangle2D rect, double angSt, double angExt,

   824                        int closure) {

   825         setArc(rect.getX(), rect.getY(), rect.getWidth(), rect.getHeight(),

   826                angSt, angExt, closure);

   827     }

   828 

   829     /**

   830      * Sets this arc to be the same as the specified arc.

   831      *

   832      * @param a The <CODE>Arc2D</CODE> to use to set the arc's values.

   833      * @since 1.2

   834      */

   835     public void setArc(Arc2D a) {

   836         setArc(a.getX(), a.getY(), a.getWidth(), a.getHeight(),

   837                a.getAngleStart(), a.getAngleExtent(), a.type);

   838     }

   839 

   840     /**

   841      * Sets the position, bounds, angular extents, and closure type of

   842      * this arc to the specified values. The arc is defined by a center

   843      * point and a radius rather than a framing rectangle for the full ellipse.

   844      *

   845      * @param x The X coordinate of the center of the arc.

   846      * @param y The Y coordinate of the center of the arc.

   847      * @param radius The radius of the arc.

   848      * @param angSt The starting angle of the arc in degrees.

   849      * @param angExt The angular extent of the arc in degrees.

   850      * @param closure The closure type for the arc:

   851      * {@link #OPEN}, {@link #CHORD}, or {@link #PIE}.

   852      * @since 1.2

   853      */

   854     public void setArcByCenter(double x, double y, double radius,

   855                                double angSt, double angExt, int closure) {

   856         setArc(x - radius, y - radius, radius * 2.0, radius * 2.0,

   857                angSt, angExt, closure);

   858     }

   859 

   860     /**

   861      * Sets the position, bounds, and angular extents of this arc to the

   862      * specified value. The starting angle of the arc is tangent to the

   863      * line specified by points (p1, p2), the ending angle is tangent to

   864      * the line specified by points (p2, p3), and the arc has the

   865      * specified radius.

   866      *

   867      * @param p1 The first point that defines the arc. The starting

   868      * angle of the arc is tangent to the line specified by points (p1, p2).

   869      * @param p2 The second point that defines the arc. The starting

   870      * angle of the arc is tangent to the line specified by points (p1, p2).

   871      * The ending angle of the arc is tangent to the line specified by

   872      * points (p2, p3).

   873      * @param p3 The third point that defines the arc. The ending angle

   874      * of the arc is tangent to the line specified by points (p2, p3).

   875      * @param radius The radius of the arc.

   876      * @since 1.2

   877      */

   878     public void setArcByTangent(Point2D p1, Point2D p2, Point2D p3,

   879                                 double radius) {

   880         double ang1 = Math.atan2(p1.getY() - p2.getY(),

   881                                  p1.getX() - p2.getX());

   882         double ang2 = Math.atan2(p3.getY() - p2.getY(),

   883                                  p3.getX() - p2.getX());

   884         double diff = ang2 - ang1;

   885         if (diff > Math.PI) {

   886             ang2 -= Math.PI * 2.0;

   887         } else if (diff < -Math.PI) {

   888             ang2 += Math.PI * 2.0;

   889         }

   890         double bisect = (ang1 + ang2) / 2.0;

   891         double theta = Math.abs(ang2 - bisect);

   892         double dist = radius / Math.sin(theta);

   893         double x = p2.getX() + dist * Math.cos(bisect);

   894         double y = p2.getY() + dist * Math.sin(bisect);

   895         // REMIND: This needs some work...

   896         if (ang1 < ang2) {

   897             ang1 -= Math.PI / 2.0;

   898             ang2 += Math.PI / 2.0;

   899         } else {

   900             ang1 += Math.PI / 2.0;

   901             ang2 -= Math.PI / 2.0;

   902         }

   903         ang1 = Math.toDegrees(-ang1);

   904         ang2 = Math.toDegrees(-ang2);

   905         diff = ang2 - ang1;

   906         if (diff < 0) {

   907             diff += 360;

   908         } else {

   909             diff -= 360;

   910         }

   911         setArcByCenter(x, y, radius, ang1, diff, type);

   912     }

   913 

   914     /**

   915      * Sets the starting angle of this arc to the specified double

   916      * value.

   917      *

   918      * @param angSt The starting angle of the arc in degrees.

   919      * @see #getAngleStart

   920      * @since 1.2

   921      */

   922     public abstract void setAngleStart(double angSt);

   923 

   924     /**

   925      * Sets the angular extent of this arc to the specified double

   926      * value.

   927      *

   928      * @param angExt The angular extent of the arc in degrees.

   929      * @see #getAngleExtent

   930      * @since 1.2

   931      */

   932     public abstract void setAngleExtent(double angExt);

   933 

   934     /**

   935      * Sets the starting angle of this arc to the angle that the

   936      * specified point defines relative to the center of this arc.

   937      * The angular extent of the arc will remain the same.

   938      *

   939      * @param p The <CODE>Point2D</CODE> that defines the starting angle.

   940      * @see #getAngleStart

   941      * @since 1.2

   942      */

   943     public void setAngleStart(Point2D p) {

   944         // Bias the dx and dy by the height and width of the oval.

   945         double dx = getHeight() * (p.getX() - getCenterX());

   946         double dy = getWidth() * (p.getY() - getCenterY());

   947         setAngleStart(-Math.toDegrees(Math.atan2(dy, dx)));

   948     }

   949 

   950     /**

   951      * Sets the starting angle and angular extent of this arc using two

   952      * sets of coordinates. The first set of coordinates is used to

   953      * determine the angle of the starting point relative to the arc's

   954      * center. The second set of coordinates is used to determine the

   955      * angle of the end point relative to the arc's center.

   956      * The arc will always be non-empty and extend counterclockwise

   957      * from the first point around to the second point.

   958      *

   959      * @param x1 The X coordinate of the arc's starting point.

   960      * @param y1 The Y coordinate of the arc's starting point.

   961      * @param x2 The X coordinate of the arc's ending point.

   962      * @param y2 The Y coordinate of the arc's ending point.

   963      * @since 1.2

   964      */

   965     public void setAngles(double x1, double y1, double x2, double y2) {

   966         double x = getCenterX();

   967         double y = getCenterY();

   968         double w = getWidth();

   969         double h = getHeight();

   970         // Note: reversing the Y equations negates the angle to adjust

   971         // for the upside down coordinate system.

   972         // Also we should bias atans by the height and width of the oval.

   973         double ang1 = Math.atan2(w * (y - y1), h * (x1 - x));

   974         double ang2 = Math.atan2(w * (y - y2), h * (x2 - x));

   975         ang2 -= ang1;

   976         if (ang2 <= 0.0) {

   977             ang2 += Math.PI * 2.0;

   978         }

   979         setAngleStart(Math.toDegrees(ang1));

   980         setAngleExtent(Math.toDegrees(ang2));

   981     }

   982 

   983     /**

   984      * Sets the starting angle and angular extent of this arc using

   985      * two points. The first point is used to determine the angle of

   986      * the starting point relative to the arc's center.

   987      * The second point is used to determine the angle of the end point

   988      * relative to the arc's center.

   989      * The arc will always be non-empty and extend counterclockwise

   990      * from the first point around to the second point.

   991      *

   992      * @param p1 The <CODE>Point2D</CODE> that defines the arc's

   993      * starting point.

   994      * @param p2 The <CODE>Point2D</CODE> that defines the arc's

   995      * ending point.

   996      * @since 1.2

   997      */

   998     public void setAngles(Point2D p1, Point2D p2) {

   999         setAngles(p1.getX(), p1.getY(), p2.getX(), p2.getY());

  1000     }

  1001 

  1002     /**

  1003      * Sets the closure type of this arc to the specified value:

  1004      * <CODE>OPEN</CODE>, <CODE>CHORD</CODE>, or <CODE>PIE</CODE>.

  1005      *

  1006      * @param type The integer constant that represents the closure

  1007      * type of this arc: {@link #OPEN}, {@link #CHORD}, or

  1008      * {@link #PIE}.

  1009      *

  1010      * @throws IllegalArgumentException if <code>type</code> is not

  1011      * 0, 1, or 2.+

  1012      * @see #getArcType

  1013      * @since 1.2

  1014      */

  1015     public void setArcType(int type) {

  1016         if (type < OPEN || type > PIE) {

  1017             throw new IllegalArgumentException("invalid type for Arc: "+type);

  1018         }

  1019         this.type = type;

  1020     }

  1021 

  1022     /**

  1023      * {@inheritDoc}

  1024      * Note that the arc

  1025      * <a href="Arc2D.html#inscribes">partially inscribes</a>

  1026      * the framing rectangle of this {@code RectangularShape}.

  1027      *

  1028      * @since 1.2

  1029      */

  1030     public void setFrame(double x, double y, double w, double h) {

  1031         setArc(x, y, w, h, getAngleStart(), getAngleExtent(), type);

  1032     }

  1033 

  1034     /**

  1035      * Returns the high-precision framing rectangle of the arc.  The framing

  1036      * rectangle contains only the part of this <code>Arc2D</code> that is

  1037      * in between the starting and ending angles and contains the pie

  1038      * wedge, if this <code>Arc2D</code> has a <code>PIE</code> closure type.

  1039      * <p>

  1040      * This method differs from the

  1041      * {@link RectangularShape#getBounds() getBounds} in that the

  1042      * <code>getBounds</code> method only returns the bounds of the

  1043      * enclosing ellipse of this <code>Arc2D</code> without considering

  1044      * the starting and ending angles of this <code>Arc2D</code>.

  1045      *

  1046      * @return the <CODE>Rectangle2D</CODE> that represents the arc's

  1047      * framing rectangle.

  1048      * @since 1.2

  1049      */

  1050     public Rectangle2D getBounds2D() {

  1051         if (isEmpty()) {

  1052             return makeBounds(getX(), getY(), getWidth(), getHeight());

  1053         }

  1054         double x1, y1, x2, y2;

  1055         if (getArcType() == PIE) {

  1056             x1 = y1 = x2 = y2 = 0.0;

  1057         } else {

  1058             x1 = y1 = 1.0;

  1059             x2 = y2 = -1.0;

  1060         }

  1061         double angle = 0.0;

  1062         for (int i = 0; i < 6; i++) {

  1063             if (i < 4) {

  1064                 // 0-3 are the four quadrants

  1065                 angle += 90.0;

  1066                 if (!containsAngle(angle)) {

  1067                     continue;

  1068                 }

  1069             } else if (i == 4) {

  1070                 // 4 is start angle

  1071                 angle = getAngleStart();

  1072             } else {

  1073                 // 5 is end angle

  1074                 angle += getAngleExtent();

  1075             }

  1076             double rads = Math.toRadians(-angle);

  1077             double xe = Math.cos(rads);

  1078             double ye = Math.sin(rads);

  1079             x1 = Math.min(x1, xe);

  1080             y1 = Math.min(y1, ye);

  1081             x2 = Math.max(x2, xe);

  1082             y2 = Math.max(y2, ye);

  1083         }

  1084         double w = getWidth();

  1085         double h = getHeight();

  1086         x2 = (x2 - x1) * 0.5 * w;

  1087         y2 = (y2 - y1) * 0.5 * h;

  1088         x1 = getX() + (x1 * 0.5 + 0.5) * w;

  1089         y1 = getY() + (y1 * 0.5 + 0.5) * h;

  1090         return makeBounds(x1, y1, x2, y2);

  1091     }

  1092 

  1093     /**

  1094      * Constructs a <code>Rectangle2D</code> of the appropriate precision

  1095      * to hold the parameters calculated to be the framing rectangle

  1096      * of this arc.

  1097      *

  1098      * @param x The X coordinate of the upper-left corner of the

  1099      * framing rectangle.

  1100      * @param y The Y coordinate of the upper-left corner of the

  1101      * framing rectangle.

  1102      * @param w The width of the framing rectangle.

  1103      * @param h The height of the framing rectangle.

  1104      * @return a <code>Rectangle2D</code> that is the framing rectangle

  1105      *     of this arc.

  1106      * @since 1.2

  1107      */

  1108     protected abstract Rectangle2D makeBounds(double x, double y,

  1109                                               double w, double h);

  1110 

  1111     /*

  1112      * Normalizes the specified angle into the range -180 to 180.

  1113      */

  1114     static double normalizeDegrees(double angle) {

  1115         if (angle > 180.0) {

  1116             if (angle <= (180.0 + 360.0)) {

  1117                 angle = angle - 360.0;

  1118             } else {

  1119                 angle = Math.IEEEremainder(angle, 360.0);

  1120                 // IEEEremainder can return -180 here for some input values...

  1121                 if (angle == -180.0) {

  1122                     angle = 180.0;

  1123                 }

  1124             }

  1125         } else if (angle <= -180.0) {

  1126             if (angle > (-180.0 - 360.0)) {

  1127                 angle = angle + 360.0;

  1128             } else {

  1129                 angle = Math.IEEEremainder(angle, 360.0);

  1130                 // IEEEremainder can return -180 here for some input values...

  1131                 if (angle == -180.0) {

  1132                     angle = 180.0;

  1133                 }

  1134             }

  1135         }