001    /* ===========================================================
002     * JFreeChart : a free chart library for the Java(tm) platform
003     * ===========================================================
004     *
005     * (C) Copyright 2000-2008, by Object Refinery Limited and Contributors.
006     *
007     * Project Info:  http://www.jfree.org/jfreechart/index.html
008     *
009     * This library is free software; you can redistribute it and/or modify it
010     * under the terms of the GNU Lesser General Public License as published by
011     * the Free Software Foundation; either version 2.1 of the License, or
012     * (at your option) any later version.
013     *
014     * This library is distributed in the hope that it will be useful, but
015     * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
016     * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
017     * License for more details.
018     *
019     * You should have received a copy of the GNU Lesser General Public
020     * License along with this library; if not, write to the Free Software
021     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
022     * USA.
023     *
024     * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
025     * in the United States and other countries.]
026     *
027     * ---------------------
028     * CyclicNumberAxis.java
029     * ---------------------
030     * (C) Copyright 2003-2008, by Nicolas Brodu and Contributors.
031     *
032     * Original Author:  Nicolas Brodu;
033     * Contributor(s):   David Gilbert (for Object Refinery Limited);
034     *
035     * Changes
036     * -------
037     * 19-Nov-2003 : Initial import to JFreeChart from the JSynoptic project (NB);
038     * 16-Mar-2004 : Added plotState to draw() method (DG);
039     * 07-Apr-2004 : Modifed text bounds calculation (DG);
040     * 21-Apr-2005 : Replaced Insets with RectangleInsets, removed redundant
041     *               argument in selectAutoTickUnit() (DG);
042     * 22-Apr-2005 : Renamed refreshHorizontalTicks() --> refreshTicksHorizontal
043     *               (for consistency with other classes) and removed unused
044     *               parameters (DG);
045     * 08-Jun-2005 : Fixed equals() method to handle GradientPaint (DG);
046     *
047     */
048    
049    package org.jfree.chart.axis;
050    
051    import java.awt.BasicStroke;
052    import java.awt.Color;
053    import java.awt.Font;
054    import java.awt.FontMetrics;
055    import java.awt.Graphics2D;
056    import java.awt.Paint;
057    import java.awt.Stroke;
058    import java.awt.geom.Line2D;
059    import java.awt.geom.Rectangle2D;
060    import java.io.IOException;
061    import java.io.ObjectInputStream;
062    import java.io.ObjectOutputStream;
063    import java.text.NumberFormat;
064    import java.util.List;
065    
066    import org.jfree.chart.plot.Plot;
067    import org.jfree.chart.plot.PlotRenderingInfo;
068    import org.jfree.data.Range;
069    import org.jfree.io.SerialUtilities;
070    import org.jfree.text.TextUtilities;
071    import org.jfree.ui.RectangleEdge;
072    import org.jfree.ui.TextAnchor;
073    import org.jfree.util.ObjectUtilities;
074    import org.jfree.util.PaintUtilities;
075    
076    /**
077    This class extends NumberAxis and handles cycling.
078    
079    Traditional representation of data in the range x0..x1
080    <pre>
081    |-------------------------|
082    x0                       x1
083    </pre>
084    
085    Here, the range bounds are at the axis extremities.
086    With cyclic axis, however, the time is split in
087    "cycles", or "time frames", or the same duration : the period.
088    
089    A cycle axis cannot by definition handle a larger interval
090    than the period : <pre>x1 - x0 >= period</pre>. Thus, at most a full
091    period can be represented with such an axis.
092    
093    The cycle bound is the number between x0 and x1 which marks
094    the beginning of new time frame:
095    <pre>
096    |---------------------|----------------------------|
097    x0                   cb                           x1
098    <---previous cycle---><-------current cycle-------->
099    </pre>
100    
101    It is actually a multiple of the period, plus optionally
102    a start offset: <pre>cb = n * period + offset</pre>
103    
104    Thus, by definition, two consecutive cycle bounds
105    period apart, which is precisely why it is called a
106    period.
107    
108    The visual representation of a cyclic axis is like that:
109    <pre>
110    |----------------------------|---------------------|
111    cb                         x1|x0                  cb
112    <-------current cycle--------><---previous cycle--->
113    </pre>
114    
115    The cycle bound is at the axis ends, then current
116    cycle is shown, then the last cycle. When using
117    dynamic data, the visual effect is the current cycle
118    erases the last cycle as x grows. Then, the next cycle
119    bound is reached, and the process starts over, erasing
120    the previous cycle.
121    
122    A Cyclic item renderer is provided to do exactly this.
123    
124     */
125    public class CyclicNumberAxis extends NumberAxis {
126    
127        /** For serialization. */
128        static final long serialVersionUID = -7514160997164582554L;
129    
130        /** The default axis line stroke. */
131        public static Stroke DEFAULT_ADVANCE_LINE_STROKE = new BasicStroke(1.0f);
132    
133        /** The default axis line paint. */
134        public static final Paint DEFAULT_ADVANCE_LINE_PAINT = Color.gray;
135    
136        /** The offset. */
137        protected double offset;
138    
139        /** The period.*/
140        protected double period;
141    
142        /** ??. */
143        protected boolean boundMappedToLastCycle;
144    
145        /** A flag that controls whether or not the advance line is visible. */
146        protected boolean advanceLineVisible;
147    
148        /** The advance line stroke. */
149        protected transient Stroke advanceLineStroke = DEFAULT_ADVANCE_LINE_STROKE;
150    
151        /** The advance line paint. */
152        protected transient Paint advanceLinePaint;
153    
154        private transient boolean internalMarkerWhenTicksOverlap;
155        private transient Tick internalMarkerCycleBoundTick;
156    
157        /**
158         * Creates a CycleNumberAxis with the given period.
159         *
160         * @param period  the period.
161         */
162        public CyclicNumberAxis(double period) {
163            this(period, 0.0);
164        }
165    
166        /**
167         * Creates a CycleNumberAxis with the given period and offset.
168         *
169         * @param period  the period.
170         * @param offset  the offset.
171         */
172        public CyclicNumberAxis(double period, double offset) {
173            this(period, offset, null);
174        }
175    
176        /**
177         * Creates a named CycleNumberAxis with the given period.
178         *
179         * @param period  the period.
180         * @param label  the label.
181         */
182        public CyclicNumberAxis(double period, String label) {
183            this(0, period, label);
184        }
185    
186        /**
187         * Creates a named CycleNumberAxis with the given period and offset.
188         *
189         * @param period  the period.
190         * @param offset  the offset.
191         * @param label  the label.
192         */
193        public CyclicNumberAxis(double period, double offset, String label) {
194            super(label);
195            this.period = period;
196            this.offset = offset;
197            setFixedAutoRange(period);
198            this.advanceLineVisible = true;
199            this.advanceLinePaint = DEFAULT_ADVANCE_LINE_PAINT;
200        }
201    
202        /**
203         * The advance line is the line drawn at the limit of the current cycle,
204         * when erasing the previous cycle.
205         *
206         * @return A boolean.
207         */
208        public boolean isAdvanceLineVisible() {
209            return this.advanceLineVisible;
210        }
211    
212        /**
213         * The advance line is the line drawn at the limit of the current cycle,
214         * when erasing the previous cycle.
215         *
216         * @param visible  the flag.
217         */
218        public void setAdvanceLineVisible(boolean visible) {
219            this.advanceLineVisible = visible;
220        }
221    
222        /**
223         * The advance line is the line drawn at the limit of the current cycle,
224         * when erasing the previous cycle.
225         *
226         * @return The paint (never <code>null</code>).
227         */
228        public Paint getAdvanceLinePaint() {
229            return this.advanceLinePaint;
230        }
231    
232        /**
233         * The advance line is the line drawn at the limit of the current cycle,
234         * when erasing the previous cycle.
235         *
236         * @param paint  the paint (<code>null</code> not permitted).
237         */
238        public void setAdvanceLinePaint(Paint paint) {
239            if (paint == null) {
240                throw new IllegalArgumentException("Null 'paint' argument.");
241            }
242            this.advanceLinePaint = paint;
243        }
244    
245        /**
246         * The advance line is the line drawn at the limit of the current cycle,
247         * when erasing the previous cycle.
248         *
249         * @return The stroke (never <code>null</code>).
250         */
251        public Stroke getAdvanceLineStroke() {
252            return this.advanceLineStroke;
253        }
254        /**
255         * The advance line is the line drawn at the limit of the current cycle,
256         * when erasing the previous cycle.
257         *
258         * @param stroke  the stroke (<code>null</code> not permitted).
259         */
260        public void setAdvanceLineStroke(Stroke stroke) {
261            if (stroke == null) {
262                throw new IllegalArgumentException("Null 'stroke' argument.");
263            }
264            this.advanceLineStroke = stroke;
265        }
266    
267        /**
268         * The cycle bound can be associated either with the current or with the
269         * last cycle.  It's up to the user's choice to decide which, as this is
270         * just a convention.  By default, the cycle bound is mapped to the current
271         * cycle.
272         * <br>
273         * Note that this has no effect on visual appearance, as the cycle bound is
274         * mapped successively for both axis ends. Use this function for correct
275         * results in translateValueToJava2D.
276         *
277         * @return <code>true</code> if the cycle bound is mapped to the last
278         *         cycle, <code>false</code> if it is bound to the current cycle
279         *         (default)
280         */
281        public boolean isBoundMappedToLastCycle() {
282            return this.boundMappedToLastCycle;
283        }
284    
285        /**
286         * The cycle bound can be associated either with the current or with the
287         * last cycle.  It's up to the user's choice to decide which, as this is
288         * just a convention. By default, the cycle bound is mapped to the current
289         * cycle.
290         * <br>
291         * Note that this has no effect on visual appearance, as the cycle bound is
292         * mapped successively for both axis ends. Use this function for correct
293         * results in valueToJava2D.
294         *
295         * @param boundMappedToLastCycle Set it to true to map the cycle bound to
296         *        the last cycle.
297         */
298        public void setBoundMappedToLastCycle(boolean boundMappedToLastCycle) {
299            this.boundMappedToLastCycle = boundMappedToLastCycle;
300        }
301    
302        /**
303         * Selects a tick unit when the axis is displayed horizontally.
304         *
305         * @param g2  the graphics device.
306         * @param drawArea  the drawing area.
307         * @param dataArea  the data area.
308         * @param edge  the side of the rectangle on which the axis is displayed.
309         */
310        protected void selectHorizontalAutoTickUnit(Graphics2D g2,
311                                                    Rectangle2D drawArea,
312                                                    Rectangle2D dataArea,
313                                                    RectangleEdge edge) {
314    
315            double tickLabelWidth
316                = estimateMaximumTickLabelWidth(g2, getTickUnit());
317    
318            // Compute number of labels
319            double n = getRange().getLength()
320                       * tickLabelWidth / dataArea.getWidth();
321    
322            setTickUnit(
323                (NumberTickUnit) getStandardTickUnits().getCeilingTickUnit(n),
324                false, false
325            );
326    
327         }
328    
329        /**
330         * Selects a tick unit when the axis is displayed vertically.
331         *
332         * @param g2  the graphics device.
333         * @param drawArea  the drawing area.
334         * @param dataArea  the data area.
335         * @param edge  the side of the rectangle on which the axis is displayed.
336         */
337        protected void selectVerticalAutoTickUnit(Graphics2D g2,
338                                                    Rectangle2D drawArea,
339                                                    Rectangle2D dataArea,
340                                                    RectangleEdge edge) {
341    
342            double tickLabelWidth
343                = estimateMaximumTickLabelWidth(g2, getTickUnit());
344    
345            // Compute number of labels
346            double n = getRange().getLength()
347                       * tickLabelWidth / dataArea.getHeight();
348    
349            setTickUnit(
350                (NumberTickUnit) getStandardTickUnits().getCeilingTickUnit(n),
351                false, false
352            );
353    
354         }
355    
356        /**
357         * A special Number tick that also hold information about the cycle bound
358         * mapping for this tick.  This is especially useful for having a tick at
359         * each axis end with the cycle bound value.  See also
360         * isBoundMappedToLastCycle()
361         */
362        protected static class CycleBoundTick extends NumberTick {
363    
364            /** Map to last cycle. */
365            public boolean mapToLastCycle;
366    
367            /**
368             * Creates a new tick.
369             *
370             * @param mapToLastCycle  map to last cycle?
371             * @param number  the number.
372             * @param label  the label.
373             * @param textAnchor  the text anchor.
374             * @param rotationAnchor  the rotation anchor.
375             * @param angle  the rotation angle.
376             */
377            public CycleBoundTick(boolean mapToLastCycle, Number number,
378                                  String label, TextAnchor textAnchor,
379                                  TextAnchor rotationAnchor, double angle) {
380                super(number, label, textAnchor, rotationAnchor, angle);
381                this.mapToLastCycle = mapToLastCycle;
382            }
383        }
384    
385        /**
386         * Calculates the anchor point for a tick.
387         *
388         * @param tick  the tick.
389         * @param cursor  the cursor.
390         * @param dataArea  the data area.
391         * @param edge  the side on which the axis is displayed.
392         *
393         * @return The anchor point.
394         */
395        protected float[] calculateAnchorPoint(ValueTick tick, double cursor,
396                                               Rectangle2D dataArea,
397                                               RectangleEdge edge) {
398            if (tick instanceof CycleBoundTick) {
399                boolean mapsav = this.boundMappedToLastCycle;
400                this.boundMappedToLastCycle
401                    = ((CycleBoundTick) tick).mapToLastCycle;
402                float[] ret = super.calculateAnchorPoint(
403                    tick, cursor, dataArea, edge
404                );
405                this.boundMappedToLastCycle = mapsav;
406                return ret;
407            }
408            return super.calculateAnchorPoint(tick, cursor, dataArea, edge);
409        }
410    
411    
412    
413        /**
414         * Builds a list of ticks for the axis.  This method is called when the
415         * axis is at the top or bottom of the chart (so the axis is "horizontal").
416         *
417         * @param g2  the graphics device.
418         * @param dataArea  the data area.
419         * @param edge  the edge.
420         *
421         * @return A list of ticks.
422         */
423        protected List refreshTicksHorizontal(Graphics2D g2,
424                                              Rectangle2D dataArea,
425                                              RectangleEdge edge) {
426    
427            List result = new java.util.ArrayList();
428    
429            Font tickLabelFont = getTickLabelFont();
430            g2.setFont(tickLabelFont);
431    
432            if (isAutoTickUnitSelection()) {
433                selectAutoTickUnit(g2, dataArea, edge);
434            }
435    
436            double unit = getTickUnit().getSize();
437            double cycleBound = getCycleBound();
438            double currentTickValue = Math.ceil(cycleBound / unit) * unit;
439            double upperValue = getRange().getUpperBound();
440            boolean cycled = false;
441    
442            boolean boundMapping = this.boundMappedToLastCycle;
443            this.boundMappedToLastCycle = false;
444    
445            CycleBoundTick lastTick = null;
446            float lastX = 0.0f;
447    
448            if (upperValue == cycleBound) {
449                currentTickValue = calculateLowestVisibleTickValue();
450                cycled = true;
451                this.boundMappedToLastCycle = true;
452            }
453    
454            while (currentTickValue <= upperValue) {
455    
456                // Cycle when necessary
457                boolean cyclenow = false;
458                if ((currentTickValue + unit > upperValue) && !cycled) {
459                    cyclenow = true;
460                }
461    
462                double xx = valueToJava2D(currentTickValue, dataArea, edge);
463                String tickLabel;
464                NumberFormat formatter = getNumberFormatOverride();
465                if (formatter != null) {
466                    tickLabel = formatter.format(currentTickValue);
467                }
468                else {
469                    tickLabel = getTickUnit().valueToString(currentTickValue);
470                }
471                float x = (float) xx;
472                TextAnchor anchor = null;
473                TextAnchor rotationAnchor = null;
474                double angle = 0.0;
475                if (isVerticalTickLabels()) {
476                    if (edge == RectangleEdge.TOP) {
477                        angle = Math.PI / 2.0;
478                    }
479                    else {
480                        angle = -Math.PI / 2.0;
481                    }
482                    anchor = TextAnchor.CENTER_RIGHT;
483                    // If tick overlap when cycling, update last tick too
484                    if ((lastTick != null) && (lastX == x)
485                            && (currentTickValue != cycleBound)) {
486                        anchor = isInverted()
487                            ? TextAnchor.TOP_RIGHT : TextAnchor.BOTTOM_RIGHT;
488                        result.remove(result.size() - 1);
489                        result.add(new CycleBoundTick(
490                            this.boundMappedToLastCycle, lastTick.getNumber(),
491                            lastTick.getText(), anchor, anchor,
492                            lastTick.getAngle())
493                        );
494                        this.internalMarkerWhenTicksOverlap = true;
495                        anchor = isInverted()
496                            ? TextAnchor.BOTTOM_RIGHT : TextAnchor.TOP_RIGHT;
497                    }
498                    rotationAnchor = anchor;
499                }
500                else {
501                    if (edge == RectangleEdge.TOP) {
502                        anchor = TextAnchor.BOTTOM_CENTER;
503                        if ((lastTick != null) && (lastX == x)
504                                && (currentTickValue != cycleBound)) {
505                            anchor = isInverted()
506                                ? TextAnchor.BOTTOM_LEFT : TextAnchor.BOTTOM_RIGHT;
507                            result.remove(result.size() - 1);
508                            result.add(new CycleBoundTick(
509                                this.boundMappedToLastCycle, lastTick.getNumber(),
510                                lastTick.getText(), anchor, anchor,
511                                lastTick.getAngle())
512                            );
513                            this.internalMarkerWhenTicksOverlap = true;
514                            anchor = isInverted()
515                                ? TextAnchor.BOTTOM_RIGHT : TextAnchor.BOTTOM_LEFT;
516                        }
517                        rotationAnchor = anchor;
518                    }
519                    else {
520                        anchor = TextAnchor.TOP_CENTER;
521                        if ((lastTick != null) && (lastX == x)
522                                && (currentTickValue != cycleBound)) {
523                            anchor = isInverted()
524                                ? TextAnchor.TOP_LEFT : TextAnchor.TOP_RIGHT;
525                            result.remove(result.size() - 1);
526                            result.add(new CycleBoundTick(
527                                this.boundMappedToLastCycle, lastTick.getNumber(),
528                                lastTick.getText(), anchor, anchor,
529                                lastTick.getAngle())
530                            );
531                            this.internalMarkerWhenTicksOverlap = true;
532                            anchor = isInverted()
533                                ? TextAnchor.TOP_RIGHT : TextAnchor.TOP_LEFT;
534                        }
535                        rotationAnchor = anchor;
536                    }
537                }
538    
539                CycleBoundTick tick = new CycleBoundTick(
540                    this.boundMappedToLastCycle,
541                    new Double(currentTickValue), tickLabel, anchor,
542                    rotationAnchor, angle
543                );
544                if (currentTickValue == cycleBound) {
545                    this.internalMarkerCycleBoundTick = tick;
546                }
547                result.add(tick);
548                lastTick = tick;
549                lastX = x;
550    
551                currentTickValue += unit;
552    
553                if (cyclenow) {
554                    currentTickValue = calculateLowestVisibleTickValue();
555                    upperValue = cycleBound;
556                    cycled = true;
557                    this.boundMappedToLastCycle = true;
558                }
559    
560            }
561            this.boundMappedToLastCycle = boundMapping;
562            return result;
563    
564        }
565    
566        /**
567         * Builds a list of ticks for the axis.  This method is called when the
568         * axis is at the left or right of the chart (so the axis is "vertical").
569         *
570         * @param g2  the graphics device.
571         * @param dataArea  the data area.
572         * @param edge  the edge.
573         *
574         * @return A list of ticks.
575         */
576        protected List refreshVerticalTicks(Graphics2D g2,
577                                            Rectangle2D dataArea,
578                                            RectangleEdge edge) {
579    
580            List result = new java.util.ArrayList();
581            result.clear();
582    
583            Font tickLabelFont = getTickLabelFont();
584            g2.setFont(tickLabelFont);
585            if (isAutoTickUnitSelection()) {
586                selectAutoTickUnit(g2, dataArea, edge);
587            }
588    
589            double unit = getTickUnit().getSize();
590            double cycleBound = getCycleBound();
591            double currentTickValue = Math.ceil(cycleBound / unit) * unit;
592            double upperValue = getRange().getUpperBound();
593            boolean cycled = false;
594    
595            boolean boundMapping = this.boundMappedToLastCycle;
596            this.boundMappedToLastCycle = true;
597    
598            NumberTick lastTick = null;
599            float lastY = 0.0f;
600    
601            if (upperValue == cycleBound) {
602                currentTickValue = calculateLowestVisibleTickValue();
603                cycled = true;
604                this.boundMappedToLastCycle = true;
605            }
606    
607            while (currentTickValue <= upperValue) {
608    
609                // Cycle when necessary
610                boolean cyclenow = false;
611                if ((currentTickValue + unit > upperValue) && !cycled) {
612                    cyclenow = true;
613                }
614    
615                double yy = valueToJava2D(currentTickValue, dataArea, edge);
616                String tickLabel;
617                NumberFormat formatter = getNumberFormatOverride();
618                if (formatter != null) {
619                    tickLabel = formatter.format(currentTickValue);
620                }
621                else {
622                    tickLabel = getTickUnit().valueToString(currentTickValue);
623                }
624    
625                float y = (float) yy;
626                TextAnchor anchor = null;
627                TextAnchor rotationAnchor = null;
628                double angle = 0.0;
629                if (isVerticalTickLabels()) {
630    
631                    if (edge == RectangleEdge.LEFT) {
632                        anchor = TextAnchor.BOTTOM_CENTER;
633                        if ((lastTick != null) && (lastY == y)
634                                && (currentTickValue != cycleBound)) {
635                            anchor = isInverted()
636                                ? TextAnchor.BOTTOM_LEFT : TextAnchor.BOTTOM_RIGHT;
637                            result.remove(result.size() - 1);
638                            result.add(new CycleBoundTick(
639                                this.boundMappedToLastCycle, lastTick.getNumber(),
640                                lastTick.getText(), anchor, anchor,
641                                lastTick.getAngle())
642                            );
643                            this.internalMarkerWhenTicksOverlap = true;
644                            anchor = isInverted()
645                                ? TextAnchor.BOTTOM_RIGHT : TextAnchor.BOTTOM_LEFT;
646                        }
647                        rotationAnchor = anchor;
648                        angle = -Math.PI / 2.0;
649                    }
650                    else {
651                        anchor = TextAnchor.BOTTOM_CENTER;
652                        if ((lastTick != null) && (lastY == y)
653                                && (currentTickValue != cycleBound)) {
654                            anchor = isInverted()
655                                ? TextAnchor.BOTTOM_RIGHT : TextAnchor.BOTTOM_LEFT;
656                            result.remove(result.size() - 1);
657                            result.add(new CycleBoundTick(
658                                this.boundMappedToLastCycle, lastTick.getNumber(),
659                                lastTick.getText(), anchor, anchor,
660                                lastTick.getAngle())
661                            );
662                            this.internalMarkerWhenTicksOverlap = true;
663                            anchor = isInverted()
664                                ? TextAnchor.BOTTOM_LEFT : TextAnchor.BOTTOM_RIGHT;
665                        }
666                        rotationAnchor = anchor;
667                        angle = Math.PI / 2.0;
668                    }
669                }
670                else {
671                    if (edge == RectangleEdge.LEFT) {
672                        anchor = TextAnchor.CENTER_RIGHT;
673                        if ((lastTick != null) && (lastY == y)
674                                && (currentTickValue != cycleBound)) {
675                            anchor = isInverted()
676                                ? TextAnchor.BOTTOM_RIGHT : TextAnchor.TOP_RIGHT;
677                            result.remove(result.size() - 1);
678                            result.add(new CycleBoundTick(
679                                this.boundMappedToLastCycle, lastTick.getNumber(),
680                                lastTick.getText(), anchor, anchor,
681                                lastTick.getAngle())
682                            );
683                            this.internalMarkerWhenTicksOverlap = true;
684                            anchor = isInverted()
685                                ? TextAnchor.TOP_RIGHT : TextAnchor.BOTTOM_RIGHT;
686                        }
687                        rotationAnchor = anchor;
688                    }
689                    else {
690                        anchor = TextAnchor.CENTER_LEFT;
691                        if ((lastTick != null) && (lastY == y)
692                                && (currentTickValue != cycleBound)) {
693                            anchor = isInverted()
694                                ? TextAnchor.BOTTOM_LEFT : TextAnchor.TOP_LEFT;
695                            result.remove(result.size() - 1);
696                            result.add(new CycleBoundTick(
697                                this.boundMappedToLastCycle, lastTick.getNumber(),
698                                lastTick.getText(), anchor, anchor,
699                                lastTick.getAngle())
700                            );
701                            this.internalMarkerWhenTicksOverlap = true;
702                            anchor = isInverted()
703                                ? TextAnchor.TOP_LEFT : TextAnchor.BOTTOM_LEFT;
704                        }
705                        rotationAnchor = anchor;
706                    }
707                }
708    
709                CycleBoundTick tick = new CycleBoundTick(
710                    this.boundMappedToLastCycle, new Double(currentTickValue),
711                    tickLabel, anchor, rotationAnchor, angle
712                );
713                if (currentTickValue == cycleBound) {
714                    this.internalMarkerCycleBoundTick = tick;
715                }
716                result.add(tick);
717                lastTick = tick;
718                lastY = y;
719    
720                if (currentTickValue == cycleBound) {
721                    this.internalMarkerCycleBoundTick = tick;
722                }
723    
724                currentTickValue += unit;
725    
726                if (cyclenow) {
727                    currentTickValue = calculateLowestVisibleTickValue();
728                    upperValue = cycleBound;
729                    cycled = true;
730                    this.boundMappedToLastCycle = false;
731                }
732    
733            }
734            this.boundMappedToLastCycle = boundMapping;
735            return result;
736        }
737    
738        /**
739         * Converts a coordinate from Java 2D space to data space.
740         *
741         * @param java2DValue  the coordinate in Java2D space.
742         * @param dataArea  the data area.
743         * @param edge  the edge.
744         *
745         * @return The data value.
746         */
747        public double java2DToValue(double java2DValue, Rectangle2D dataArea,
748                                    RectangleEdge edge) {
749            Range range = getRange();
750    
751            double vmax = range.getUpperBound();
752            double vp = getCycleBound();
753    
754            double jmin = 0.0;
755            double jmax = 0.0;
756            if (RectangleEdge.isTopOrBottom(edge)) {
757                jmin = dataArea.getMinX();
758                jmax = dataArea.getMaxX();
759            }
760            else if (RectangleEdge.isLeftOrRight(edge)) {
761                jmin = dataArea.getMaxY();
762                jmax = dataArea.getMinY();
763            }
764    
765            if (isInverted()) {
766                double jbreak = jmax - (vmax - vp) * (jmax - jmin) / this.period;
767                if (java2DValue >= jbreak) {
768                    return vp + (jmax - java2DValue) * this.period / (jmax - jmin);
769                }
770                else {
771                    return vp - (java2DValue - jmin) * this.period / (jmax - jmin);
772                }
773            }
774            else {
775                double jbreak = (vmax - vp) * (jmax - jmin) / this.period + jmin;
776                if (java2DValue <= jbreak) {
777                    return vp + (java2DValue - jmin) * this.period / (jmax - jmin);
778                }
779                else {
780                    return vp - (jmax - java2DValue) * this.period / (jmax - jmin);
781                }
782            }
783        }
784    
785        /**
786         * Translates a value from data space to Java 2D space.
787         *
788         * @param value  the data value.
789         * @param dataArea  the data area.
790         * @param edge  the edge.
791         *
792         * @return The Java 2D value.
793         */
794        public double valueToJava2D(double value, Rectangle2D dataArea,
795                                    RectangleEdge edge) {
796            Range range = getRange();
797    
798            double vmin = range.getLowerBound();
799            double vmax = range.getUpperBound();
800            double vp = getCycleBound();
801    
802            if ((value < vmin) || (value > vmax)) {
803                return Double.NaN;
804            }
805    
806    
807            double jmin = 0.0;
808            double jmax = 0.0;
809            if (RectangleEdge.isTopOrBottom(edge)) {
810                jmin = dataArea.getMinX();
811                jmax = dataArea.getMaxX();
812            }
813            else if (RectangleEdge.isLeftOrRight(edge)) {
814                jmax = dataArea.getMinY();
815                jmin = dataArea.getMaxY();
816            }
817    
818            if (isInverted()) {
819                if (value == vp) {
820                    return this.boundMappedToLastCycle ? jmin : jmax;
821                }
822                else if (value > vp) {
823                    return jmax - (value - vp) * (jmax - jmin) / this.period;
824                }
825                else {
826                    return jmin + (vp - value) * (jmax - jmin) / this.period;
827                }
828            }
829            else {
830                if (value == vp) {
831                    return this.boundMappedToLastCycle ? jmax : jmin;
832                }
833                else if (value >= vp) {
834                    return jmin + (value - vp) * (jmax - jmin) / this.period;
835                }
836                else {
837                    return jmax - (vp - value) * (jmax - jmin) / this.period;
838                }
839            }
840        }
841    
842        /**
843         * Centers the range about the given value.
844         *
845         * @param value  the data value.
846         */
847        public void centerRange(double value) {
848            setRange(value - this.period / 2.0, value + this.period / 2.0);
849        }
850    
851        /**
852         * This function is nearly useless since the auto range is fixed for this
853         * class to the period.  The period is extended if necessary to fit the
854         * minimum size.
855         *
856         * @param size  the size.
857         * @param notify  notify?
858         *
859         * @see org.jfree.chart.axis.ValueAxis#setAutoRangeMinimumSize(double,
860         *      boolean)
861         */
862        public void setAutoRangeMinimumSize(double size, boolean notify) {
863            if (size > this.period) {
864                this.period = size;
865            }
866            super.setAutoRangeMinimumSize(size, notify);
867        }
868    
869        /**
870         * The auto range is fixed for this class to the period by default.
871         * This function will thus set a new period.
872         *
873         * @param length  the length.
874         *
875         * @see org.jfree.chart.axis.ValueAxis#setFixedAutoRange(double)
876         */
877        public void setFixedAutoRange(double length) {
878            this.period = length;
879            super.setFixedAutoRange(length);
880        }
881    
882        /**
883         * Sets a new axis range. The period is extended to fit the range size, if
884         * necessary.
885         *
886         * @param range  the range.
887         * @param turnOffAutoRange  switch off the auto range.
888         * @param notify notify?
889         *
890         * @see org.jfree.chart.axis.ValueAxis#setRange(Range, boolean, boolean)
891         */
892        public void setRange(Range range, boolean turnOffAutoRange,
893                             boolean notify) {
894            double size = range.getUpperBound() - range.getLowerBound();
895            if (size > this.period) {
896                this.period = size;
897            }
898            super.setRange(range, turnOffAutoRange, notify);
899        }
900    
901        /**
902         * The cycle bound is defined as the higest value x such that
903         * "offset + period * i = x", with i and integer and x &lt;
904         * range.getUpperBound() This is the value which is at both ends of the
905         * axis :  x...up|low...x
906         * The values from x to up are the valued in the current cycle.
907         * The values from low to x are the valued in the previous cycle.
908         *
909         * @return The cycle bound.
910         */
911        public double getCycleBound() {
912            return Math.floor(
913                (getRange().getUpperBound() - this.offset) / this.period
914            ) * this.period + this.offset;
915        }
916    
917        /**
918         * The cycle bound is a multiple of the period, plus optionally a start
919         * offset.
920         * <P>
921         * <pre>cb = n * period + offset</pre><br>
922         *
923         * @return The current offset.
924         *
925         * @see #getCycleBound()
926         */
927        public double getOffset() {
928            return this.offset;
929        }
930    
931        /**
932         * The cycle bound is a multiple of the period, plus optionally a start
933         * offset.
934         * <P>
935         * <pre>cb = n * period + offset</pre><br>
936         *
937         * @param offset The offset to set.
938         *
939         * @see #getCycleBound()
940         */
941        public void setOffset(double offset) {
942            this.offset = offset;
943        }
944    
945        /**
946         * The cycle bound is a multiple of the period, plus optionally a start
947         * offset.
948         * <P>
949         * <pre>cb = n * period + offset</pre><br>
950         *
951         * @return The current period.
952         *
953         * @see #getCycleBound()
954         */
955        public double getPeriod() {
956            return this.period;
957        }
958    
959        /**
960         * The cycle bound is a multiple of the period, plus optionally a start
961         * offset.
962         * <P>
963         * <pre>cb = n * period + offset</pre><br>
964         *
965         * @param period The period to set.
966         *
967         * @see #getCycleBound()
968         */
969        public void setPeriod(double period) {
970            this.period = period;
971        }
972    
973        /**
974         * Draws the tick marks and labels.
975         *
976         * @param g2  the graphics device.
977         * @param cursor  the cursor.
978         * @param plotArea  the plot area.
979         * @param dataArea  the area inside the axes.
980         * @param edge  the side on which the axis is displayed.
981         *
982         * @return The axis state.
983         */
984        protected AxisState drawTickMarksAndLabels(Graphics2D g2, double cursor,
985                Rectangle2D plotArea, Rectangle2D dataArea, RectangleEdge edge) {
986            this.internalMarkerWhenTicksOverlap = false;
987            AxisState ret = super.drawTickMarksAndLabels(g2, cursor, plotArea,
988                    dataArea, edge);
989    
990            // continue and separate the labels only if necessary
991            if (!this.internalMarkerWhenTicksOverlap) {
992                return ret;
993            }
994    
995            double ol = getTickMarkOutsideLength();
996            FontMetrics fm = g2.getFontMetrics(getTickLabelFont());
997    
998            if (isVerticalTickLabels()) {
999                ol = fm.getMaxAdvance();
1000            }
1001            else {
1002                ol = fm.getHeight();
1003            }
1004    
1005            double il = 0;
1006            if (isTickMarksVisible()) {
1007                float xx = (float) valueToJava2D(getRange().getUpperBound(),
1008                        dataArea, edge);
1009                Line2D mark = null;
1010                g2.setStroke(getTickMarkStroke());
1011                g2.setPaint(getTickMarkPaint());
1012                if (edge == RectangleEdge.LEFT) {
1013                    mark = new Line2D.Double(cursor - ol, xx, cursor + il, xx);
1014                }
1015                else if (edge == RectangleEdge.RIGHT) {
1016                    mark = new Line2D.Double(cursor + ol, xx, cursor - il, xx);
1017                }
1018                else if (edge == RectangleEdge.TOP) {
1019                    mark = new Line2D.Double(xx, cursor - ol, xx, cursor + il);
1020                }
1021                else if (edge == RectangleEdge.BOTTOM) {
1022                    mark = new Line2D.Double(xx, cursor + ol, xx, cursor - il);
1023                }
1024                g2.draw(mark);
1025            }
1026            return ret;
1027        }
1028    
1029        /**
1030         * Draws the axis.
1031         *
1032         * @param g2  the graphics device (<code>null</code> not permitted).
1033         * @param cursor  the cursor position.
1034         * @param plotArea  the plot area (<code>null</code> not permitted).
1035         * @param dataArea  the data area (<code>null</code> not permitted).
1036         * @param edge  the edge (<code>null</code> not permitted).
1037         * @param plotState  collects information about the plot
1038         *                   (<code>null</code> permitted).
1039         *
1040         * @return The axis state (never <code>null</code>).
1041         */
1042        public AxisState draw(Graphics2D g2,
1043                              double cursor,
1044                              Rectangle2D plotArea,
1045                              Rectangle2D dataArea,
1046                              RectangleEdge edge,
1047                              PlotRenderingInfo plotState) {
1048    
1049            AxisState ret = super.draw(
1050                g2, cursor, plotArea, dataArea, edge, plotState
1051            );
1052            if (isAdvanceLineVisible()) {
1053                double xx = valueToJava2D(
1054                    getRange().getUpperBound(), dataArea, edge
1055                );
1056                Line2D mark = null;
1057                g2.setStroke(getAdvanceLineStroke());
1058                g2.setPaint(getAdvanceLinePaint());
1059                if (edge == RectangleEdge.LEFT) {
1060                    mark = new Line2D.Double(
1061                        cursor, xx, cursor + dataArea.getWidth(), xx
1062                    );
1063                }
1064                else if (edge == RectangleEdge.RIGHT) {
1065                    mark = new Line2D.Double(
1066                        cursor - dataArea.getWidth(), xx, cursor, xx
1067                    );
1068                }
1069                else if (edge == RectangleEdge.TOP) {
1070                    mark = new Line2D.Double(
1071                        xx, cursor + dataArea.getHeight(), xx, cursor
1072                    );
1073                }
1074                else if (edge == RectangleEdge.BOTTOM) {
1075                    mark = new Line2D.Double(
1076                        xx, cursor, xx, cursor - dataArea.getHeight()
1077                    );
1078                }
1079                g2.draw(mark);
1080            }
1081            return ret;
1082        }
1083    
1084        /**
1085         * Reserve some space on each axis side because we draw a centered label at
1086         * each extremity.
1087         *
1088         * @param g2  the graphics device.
1089         * @param plot  the plot.
1090         * @param plotArea  the plot area.
1091         * @param edge  the edge.
1092         * @param space  the space already reserved.
1093         *
1094         * @return The reserved space.
1095         */
1096        public AxisSpace reserveSpace(Graphics2D g2,
1097                                      Plot plot,
1098                                      Rectangle2D plotArea,
1099                                      RectangleEdge edge,
1100                                      AxisSpace space) {
1101    
1102            this.internalMarkerCycleBoundTick = null;
1103            AxisSpace ret = super.reserveSpace(g2, plot, plotArea, edge, space);
1104            if (this.internalMarkerCycleBoundTick == null) {
1105                return ret;
1106            }
1107    
1108            FontMetrics fm = g2.getFontMetrics(getTickLabelFont());
1109            Rectangle2D r = TextUtilities.getTextBounds(
1110                this.internalMarkerCycleBoundTick.getText(), g2, fm
1111            );
1112    
1113            if (RectangleEdge.isTopOrBottom(edge)) {
1114                if (isVerticalTickLabels()) {
1115                    space.add(r.getHeight() / 2, RectangleEdge.RIGHT);
1116                }
1117                else {
1118                    space.add(r.getWidth() / 2, RectangleEdge.RIGHT);
1119                }
1120            }
1121            else if (RectangleEdge.isLeftOrRight(edge)) {
1122                if (isVerticalTickLabels()) {
1123                    space.add(r.getWidth() / 2, RectangleEdge.TOP);
1124                }
1125                else {
1126                    space.add(r.getHeight() / 2, RectangleEdge.TOP);
1127                }
1128            }
1129    
1130            return ret;
1131    
1132        }
1133    
1134        /**
1135         * Provides serialization support.
1136         *
1137         * @param stream  the output stream.
1138         *
1139         * @throws IOException  if there is an I/O error.
1140         */
1141        private void writeObject(ObjectOutputStream stream) throws IOException {
1142    
1143            stream.defaultWriteObject();
1144            SerialUtilities.writePaint(this.advanceLinePaint, stream);
1145            SerialUtilities.writeStroke(this.advanceLineStroke, stream);
1146    
1147        }
1148    
1149        /**
1150         * Provides serialization support.
1151         *
1152         * @param stream  the input stream.
1153         *
1154         * @throws IOException  if there is an I/O error.
1155         * @throws ClassNotFoundException  if there is a classpath problem.
1156         */
1157        private void readObject(ObjectInputStream stream)
1158            throws IOException, ClassNotFoundException {
1159    
1160            stream.defaultReadObject();
1161            this.advanceLinePaint = SerialUtilities.readPaint(stream);
1162            this.advanceLineStroke = SerialUtilities.readStroke(stream);
1163    
1164        }
1165    
1166    
1167        /**
1168         * Tests the axis for equality with another object.
1169         *
1170         * @param obj  the object to test against.
1171         *
1172         * @return A boolean.
1173         */
1174        public boolean equals(Object obj) {
1175            if (obj == this) {
1176                return true;
1177            }
1178            if (!(obj instanceof CyclicNumberAxis)) {
1179                return false;
1180            }
1181            if (!super.equals(obj)) {
1182                return false;
1183            }
1184            CyclicNumberAxis that = (CyclicNumberAxis) obj;
1185            if (this.period != that.period) {
1186                return false;
1187            }
1188            if (this.offset != that.offset) {
1189                return false;
1190            }
1191            if (!PaintUtilities.equal(this.advanceLinePaint,
1192                    that.advanceLinePaint)) {
1193                return false;
1194            }
1195            if (!ObjectUtilities.equal(this.advanceLineStroke,
1196                    that.advanceLineStroke)) {
1197                return false;
1198            }
1199            if (this.advanceLineVisible != that.advanceLineVisible) {
1200                return false;
1201            }
1202            if (this.boundMappedToLastCycle != that.boundMappedToLastCycle) {
1203                return false;
1204            }
1205            return true;
1206        }
1207    }