History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/awt/geom/Arc2D.java (1 of 18352 files). Show all

Unified · Split

java/pkg/java/awt/geom/Arc2D.java+1474−0
@@ -0,0 +1,1474 @@
1+/*
2+ * Copyright (c) 1997, 2006, Oracle and/or its affiliates. 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. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * 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+ protected 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+ }
1136+ return angle;
1137+ }
1138+
1139+ /**
1140+ * Determines whether or not the specified angle is within the
1141+ * angular extents of the arc.
1142+ *
1143+ * @param angle The angle to test.
1144+ *
1145+ * @return <CODE>true</CODE> if the arc contains the angle,
1146+ * <CODE>false</CODE> if the arc doesn't contain the angle.
1147+ * @since 1.2
1148+ */
1149+ public boolean containsAngle(double angle) {
1150+ double angExt = getAngleExtent();
1151+ boolean backwards = (angExt < 0.0);
1152+ if (backwards) {
1153+ angExt = -angExt;
1154+ }
1155+ if (angExt >= 360.0) {
1156+ return true;
1157+ }
1158+ angle = normalizeDegrees(angle) - normalizeDegrees(getAngleStart());
1159+ if (backwards) {
1160+ angle = -angle;
1161+ }
1162+ if (angle < 0.0) {
1163+ angle += 360.0;
1164+ }
1165+
1166+
1167+ return (angle >= 0.0) && (angle < angExt);
1168+ }
1169+
1170+ /**
1171+ * Determines whether or not the specified point is inside the boundary
1172+ * of the arc.
1173+ *
1174+ * @param x The X coordinate of the point to test.
1175+ * @param y The Y coordinate of the point to test.
1176+ *
1177+ * @return <CODE>true</CODE> if the point lies within the bound of
1178+ * the arc, <CODE>false</CODE> if the point lies outside of the
1179+ * arc's bounds.
1180+ * @since 1.2
1181+ */
1182+ public boolean contains(double x, double y) {
1183+ // Normalize the coordinates compared to the ellipse
1184+ // having a center at 0,0 and a radius of 0.5.
1185+ double ellw = getWidth();
1186+ if (ellw <= 0.0) {
1187+ return false;
1188+ }
1189+ double normx = (x - getX()) / ellw - 0.5;
1190+ double ellh = getHeight();
1191+ if (ellh <= 0.0) {
1192+ return false;
1193+ }
1194+ double normy = (y - getY()) / ellh - 0.5;
1195+ double distSq = (normx * normx + normy * normy);
1196+ if (distSq >= 0.25) {
1197+ return false;
1198+ }
1199+ double angExt = Math.abs(getAngleExtent());
1200+ if (angExt >= 360.0) {
1201+ return true;
1202+ }
1203+ boolean inarc = containsAngle(-Math.toDegrees(Math.atan2(normy,
1204+ normx)));
1205+ if (type == PIE) {
1206+ return inarc;
1207+ }
1208+ // CHORD and OPEN behave the same way
1209+ if (inarc) {
1210+ if (angExt >= 180.0) {
1211+ return true;
1212+ }
1213+ // point must be outside the "pie triangle"
1214+ } else {
1215+ if (angExt <= 180.0) {
1216+ return false;
1217+ }
1218+ // point must be inside the "pie triangle"
1219+ }
1220+ // The point is inside the pie triangle iff it is on the same
1221+ // side of the line connecting the ends of the arc as the center.
1222+ double angle = Math.toRadians(-getAngleStart());
1223+ double x1 = Math.cos(angle);
1224+ double y1 = Math.sin(angle);
1225+ angle += Math.toRadians(-getAngleExtent());
1226+ double x2 = Math.cos(angle);
1227+ double y2 = Math.sin(angle);
1228+ boolean inside = (Line2D.relativeCCW(x1, y1, x2, y2, 2*normx, 2*normy) *
1229+ Line2D.relativeCCW(x1, y1, x2, y2, 0, 0) >= 0);
1230+ return inarc ? !inside : inside;
1231+ }
1232+
1233+ /**
1234+ * Determines whether or not the interior of the arc intersects
1235+ * the interior of the specified rectangle.
1236+ *
1237+ * @param x The X coordinate of the rectangle's upper-left corner.
1238+ * @param y The Y coordinate of the rectangle's upper-left corner.
1239+ * @param w The width of the rectangle.
1240+ * @param h The height of the rectangle.
1241+ *
1242+ * @return <CODE>true</CODE> if the arc intersects the rectangle,
1243+ * <CODE>false</CODE> if the arc doesn't intersect the rectangle.
1244+ * @since 1.2
1245+ */
1246+ public boolean intersects(double x, double y, double w, double h) {
1247+
1248+ double aw = getWidth();
1249+ double ah = getHeight();
1250+
1251+ if ( w <= 0 || h <= 0 || aw <= 0 || ah <= 0 ) {
1252+ return false;
1253+ }
1254+ double ext = getAngleExtent();
1255+ if (ext == 0) {
1256+ return false;
1257+ }
1258+
1259+ double ax = getX();
1260+ double ay = getY();
1261+ double axw = ax + aw;
1262+ double ayh = ay + ah;
1263+ double xw = x + w;
1264+ double yh = y + h;
1265+
1266+ // check bbox
1267+ if (x >= axw || y >= ayh || xw <= ax || yh <= ay) {
1268+ return false;
1269+ }
1270+
1271+ // extract necessary data
1272+ double axc = getCenterX();
1273+ double ayc = getCenterY();
1274+ Point2D sp = getStartPoint();
1275+ Point2D ep = getEndPoint();
1276+ double sx = sp.getX();
1277+ double sy = sp.getY();
1278+ double ex = ep.getX();
1279+ double ey = ep.getY();
1280+
1281+ /*
1282+ * Try to catch rectangles that intersect arc in areas
1283+ * outside of rectagle with left top corner coordinates
1284+ * (min(center x, start point x, end point x),
1285+ * min(center y, start point y, end point y))
1286+ * and rigth bottom corner coordinates
1287+ * (max(center x, start point x, end point x),
1288+ * max(center y, start point y, end point y)).
1289+ * So we'll check axis segments outside of rectangle above.
1290+ */
1291+ if (ayc >= y && ayc <= yh) { // 0 and 180
1292+ if ((sx < xw && ex < xw && axc < xw &&
1293+ axw > x && containsAngle(0)) ||
1294+ (sx > x && ex > x && axc > x &&
1295+ ax < xw && containsAngle(180))) {
1296+ return true;
1297+ }
1298+ }
1299+ if (axc >= x && axc <= xw) { // 90 and 270
1300+ if ((sy > y && ey > y && ayc > y &&
1301+ ay < yh && containsAngle(90)) ||
1302+ (sy < yh && ey < yh && ayc < yh &&
1303+ ayh > y && containsAngle(270))) {
1304+ return true;
1305+ }
1306+ }
1307+
1308+ /*
1309+ * For PIE we should check intersection with pie slices;
1310+ * also we should do the same for arcs with extent is greater
1311+ * than 180, because we should cover case of rectangle, which
1312+ * situated between center of arc and chord, but does not
1313+ * intersect the chord.
1314+ */
1315+ Rectangle2D rect = new Rectangle2D.Double(x, y, w, h);
1316+ if (type == PIE || Math.abs(ext) > 180) {
1317+ // for PIE: try to find intersections with pie slices
1318+ if (rect.intersectsLine(axc, ayc, sx, sy) ||
1319+ rect.intersectsLine(axc, ayc, ex, ey)) {
1320+ return true;
1321+ }
1322+ } else {
1323+ // for CHORD and OPEN: try to find intersections with chord
1324+ if (rect.intersectsLine(sx, sy, ex, ey)) {
1325+ return true;
1326+ }
1327+ }
1328+
1329+ // finally check the rectangle corners inside the arc
1330+ if (contains(x, y) || contains(x + w, y) ||
1331+ contains(x, y + h) || contains(x + w, y + h)) {
1332+ return true;
1333+ }
1334+
1335+ return false;
1336+ }
1337+
1338+ /**
1339+ * Determines whether or not the interior of the arc entirely contains
1340+ * the specified rectangle.
1341+ *
1342+ * @param x The X coordinate of the rectangle's upper-left corner.
1343+ * @param y The Y coordinate of the rectangle's upper-left corner.
1344+ * @param w The width of the rectangle.
1345+ * @param h The height of the rectangle.
1346+ *
1347+ * @return <CODE>true</CODE> if the arc contains the rectangle,
1348+ * <CODE>false</CODE> if the arc doesn't contain the rectangle.
1349+ * @since 1.2
1350+ */
1351+ public boolean contains(double x, double y, double w, double h) {
1352+ return contains(x, y, w, h, null);
1353+ }
1354+
1355+ /**
1356+ * Determines whether or not the interior of the arc entirely contains
1357+ * the specified rectangle.
1358+ *
1359+ * @param r The <CODE>Rectangle2D</CODE> to test.
1360+ *
1361+ * @return <CODE>true</CODE> if the arc contains the rectangle,
1362+ * <CODE>false</CODE> if the arc doesn't contain the rectangle.
1363+ * @since 1.2
1364+ */
1365+ public boolean contains(Rectangle2D r) {
1366+ return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight(), r);
1367+ }
1368+
1369+ private boolean contains(double x, double y, double w, double h,
1370+ Rectangle2D origrect) {
1371+ if (!(contains(x, y) &&
1372+ contains(x + w, y) &&
1373+ contains(x, y + h) &&
1374+ contains(x + w, y + h))) {
1375+ return false;
1376+ }
1377+ // If the shape is convex then we have done all the testing
1378+ // we need. Only PIE arcs can be concave and then only if
1379+ // the angular extents are greater than 180 degrees.
1380+ if (type != PIE || Math.abs(getAngleExtent()) <= 180.0) {
1381+ return true;
1382+ }
1383+ // For a PIE shape we have an additional test for the case where
1384+ // the angular extents are greater than 180 degrees and all four
1385+ // rectangular corners are inside the shape but one of the
1386+ // rectangle edges spans across the "missing wedge" of the arc.
1387+ // We can test for this case by checking if the rectangle intersects
1388+ // either of the pie angle segments.
1389+ if (origrect == null) {
1390+ origrect = new Rectangle2D.Double(x, y, w, h);
1391+ }
1392+ double halfW = getWidth() / 2.0;
1393+ double halfH = getHeight() / 2.0;
1394+ double xc = getX() + halfW;
1395+ double yc = getY() + halfH;
1396+ double angle = Math.toRadians(-getAngleStart());
1397+ double xe = xc + halfW * Math.cos(angle);
1398+ double ye = yc + halfH * Math.sin(angle);
1399+ if (origrect.intersectsLine(xc, yc, xe, ye)) {
1400+ return false;
1401+ }
1402+ angle += Math.toRadians(-getAngleExtent());
1403+ xe = xc + halfW * Math.cos(angle);
1404+ ye = yc + halfH * Math.sin(angle);
1405+ return !origrect.intersectsLine(xc, yc, xe, ye);
1406+ }
1407+
1408+ /**
1409+ * Returns an iteration object that defines the boundary of the
1410+ * arc.
1411+ * This iterator is multithread safe.
1412+ * <code>Arc2D</code> guarantees that
1413+ * modifications to the geometry of the arc
1414+ * do not affect any iterations of that geometry that
1415+ * are already in process.
1416+ *
1417+ * @param at an optional <CODE>AffineTransform</CODE> to be applied
1418+ * to the coordinates as they are returned in the iteration, or null
1419+ * if the untransformed coordinates are desired.
1420+ *
1421+ * @return A <CODE>PathIterator</CODE> that defines the arc's boundary.
1422+ * @since 1.2
1423+ */
1424+ public PathIterator getPathIterator(AffineTransform at) {
1425+ return new ArcIterator(this, at);
1426+ }
1427+
1428+ /**
1429+ * Returns the hashcode for this <code>Arc2D</code>.
1430+ * @return the hashcode for this <code>Arc2D</code>.
1431+ * @since 1.6
1432+ */
1433+ public int hashCode() {
1434+ long bits = java.lang.Double.doubleToLongBits(getX());
1435+ bits += java.lang.Double.doubleToLongBits(getY()) * 37;
1436+ bits += java.lang.Double.doubleToLongBits(getWidth()) * 43;
1437+ bits += java.lang.Double.doubleToLongBits(getHeight()) * 47;
1438+ bits += java.lang.Double.doubleToLongBits(getAngleStart()) * 53;
1439+ bits += java.lang.Double.doubleToLongBits(getAngleExtent()) * 59;
1440+ bits += getArcType() * 61;
1441+ return (((int) bits) ^ ((int) (bits >> 32)));
1442+ }
1443+
1444+ /**
1445+ * Determines whether or not the specified <code>Object</code> is
1446+ * equal to this <code>Arc2D</code>. The specified
1447+ * <code>Object</code> is equal to this <code>Arc2D</code>
1448+ * if it is an instance of <code>Arc2D</code> and if its
1449+ * location, size, arc extents and type are the same as this
1450+ * <code>Arc2D</code>.
1451+ * @param obj an <code>Object</code> to be compared with this
1452+ * <code>Arc2D</code>.
1453+ * @return <code>true</code> if <code>obj</code> is an instance
1454+ * of <code>Arc2D</code> and has the same values;
1455+ * <code>false</code> otherwise.
1456+ * @since 1.6
1457+ */
1458+ public boolean equals(Object obj) {
1459+ if (obj == this) {
1460+ return true;
1461+ }
1462+ if (obj instanceof Arc2D) {
1463+ Arc2D a2d = (Arc2D) obj;
1464+ return ((getX() == a2d.getX()) &&
1465+ (getY() == a2d.getY()) &&
1466+ (getWidth() == a2d.getWidth()) &&
1467+ (getHeight() == a2d.getHeight()) &&
1468+ (getAngleStart() == a2d.getAngleStart()) &&
1469+ (getAngleExtent() == a2d.getAngleExtent()) &&
1470+ (getArcType() == a2d.getArcType()));
1471+ }
1472+ return false;
1473+ }
1474+}