javafx.scene.chart.NumberAxis Maven / Gradle / Ivy
/*
* Copyright (c) 2010, 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javafx.scene.chart;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javafx.animation.KeyFrame;
import javafx.animation.KeyValue;
import javafx.beans.property.BooleanProperty;
import javafx.beans.property.BooleanPropertyBase;
import javafx.beans.property.DoubleProperty;
import javafx.beans.property.SimpleStringProperty;
import javafx.beans.property.StringProperty;
import javafx.beans.value.ChangeListener;
import javafx.geometry.Dimension2D;
import javafx.geometry.Side;
import javafx.util.Duration;
import javafx.util.StringConverter;
import com.sun.javafx.charts.ChartLayoutAnimator;
import javafx.css.StyleableDoubleProperty;
import javafx.css.CssMetaData;
import javafx.css.converter.SizeConverter;
import javafx.css.Styleable;
import javafx.css.StyleableProperty;
/**
* An axis class that plots a range of numbers with major tick marks every tickUnit.
* You can use any Number type with this axis.
* @since JavaFX 2.0
*/
public final class NumberAxis extends ValueAxis {
private Object currentAnimationID;
private final ChartLayoutAnimator animator = new ChartLayoutAnimator(this);
private final StringProperty currentFormatterProperty = new SimpleStringProperty(this, "currentFormatter", "");
private final DefaultFormatter defaultFormatter = new DefaultFormatter(this);
// -------------- PUBLIC PROPERTIES --------------------------------------------------------------------------------
/** When true zero is always included in the visible range. This only has effect if auto-ranging is on. */
private BooleanProperty forceZeroInRange = new BooleanPropertyBase(true) {
@Override protected void invalidated() {
// This will affect layout if we are auto ranging
if(isAutoRanging()) {
requestAxisLayout();
invalidateRange();
}
}
@Override
public Object getBean() {
return NumberAxis.this;
}
@Override
public String getName() {
return "forceZeroInRange";
}
};
public final boolean isForceZeroInRange() { return forceZeroInRange.getValue(); }
public final void setForceZeroInRange(boolean value) { forceZeroInRange.setValue(value); }
public final BooleanProperty forceZeroInRangeProperty() { return forceZeroInRange; }
/** The value between each major tick mark in data units. This is automatically set if we are auto-ranging. */
private DoubleProperty tickUnit = new StyleableDoubleProperty(5) {
@Override protected void invalidated() {
if(!isAutoRanging()) {
invalidateRange();
requestAxisLayout();
}
}
@Override
public CssMetaData getCssMetaData() {
return StyleableProperties.TICK_UNIT;
}
@Override
public Object getBean() {
return NumberAxis.this;
}
@Override
public String getName() {
return "tickUnit";
}
};
public final double getTickUnit() { return tickUnit.get(); }
public final void setTickUnit(double value) { tickUnit.set(value); }
public final DoubleProperty tickUnitProperty() { return tickUnit; }
// -------------- CONSTRUCTORS -------------------------------------------------------------------------------------
/**
* Creates an auto-ranging NumberAxis.
*/
public NumberAxis() {}
/**
* Creates a non-auto-ranging NumberAxis with the given upper bound, lower bound and tick unit.
*
* @param lowerBound The lower bound for this axis, i.e. min plottable value
* @param upperBound The upper bound for this axis, i.e. max plottable value
* @param tickUnit The tick unit, i.e. space between tickmarks
*/
public NumberAxis(double lowerBound, double upperBound, double tickUnit) {
super(lowerBound, upperBound);
setTickUnit(tickUnit);
}
/**
* Creates a non-auto-ranging NumberAxis with the given lower bound, upper bound and tick unit.
*
* @param axisLabel The name to display for this axis
* @param lowerBound The lower bound for this axis, i.e. min plottable value
* @param upperBound The upper bound for this axis, i.e. max plottable value
* @param tickUnit The tick unit, i.e. space between tickmarks
*/
public NumberAxis(String axisLabel, double lowerBound, double upperBound, double tickUnit) {
super(lowerBound, upperBound);
setTickUnit(tickUnit);
setLabel(axisLabel);
}
// -------------- PROTECTED METHODS --------------------------------------------------------------------------------
/**
* Get the string label name for a tick mark with the given value.
*
* @param value The value to format into a tick label string
* @return A formatted string for the given value
*/
@Override protected String getTickMarkLabel(Number value) {
StringConverter formatter = getTickLabelFormatter();
if (formatter == null) formatter = defaultFormatter;
return formatter.toString(value);
}
/**
* Called to get the current axis range.
*
* @return A range object that can be passed to setRange() and calculateTickValues()
*/
@Override protected Object getRange() {
return new Object[]{
getLowerBound(),
getUpperBound(),
getTickUnit(),
getScale(),
currentFormatterProperty.get()
};
}
/**
* Called to set the current axis range to the given range. If isAnimating() is true then this method should
* animate the range to the new range.
*
* @param range A range object returned from autoRange()
* @param animate If true animate the change in range
*/
@Override protected void setRange(Object range, boolean animate) {
final Object[] rangeProps = (Object[]) range;
final double lowerBound = (Double)rangeProps[0];
final double upperBound = (Double)rangeProps[1];
final double tickUnit = (Double)rangeProps[2];
final double scale = (Double)rangeProps[3];
final String formatter = (String)rangeProps[4];
currentFormatterProperty.set(formatter);
final double oldLowerBound = getLowerBound();
setLowerBound(lowerBound);
setUpperBound(upperBound);
setTickUnit(tickUnit);
if(animate) {
animator.stop(currentAnimationID);
currentAnimationID = animator.animate(
new KeyFrame(Duration.ZERO,
new KeyValue(currentLowerBound, oldLowerBound),
new KeyValue(scalePropertyImpl(), getScale())
),
new KeyFrame(Duration.millis(700),
new KeyValue(currentLowerBound, lowerBound),
new KeyValue(scalePropertyImpl(), scale)
)
);
} else {
currentLowerBound.set(lowerBound);
setScale(scale);
}
}
/**
* Calculates a list of all the data values for each tick mark in range
*
* @param length The length of the axis in display units
* @param range A range object returned from autoRange()
* @return A list of tick marks that fit along the axis if it was the given length
*/
@Override protected List calculateTickValues(double length, Object range) {
final Object[] rangeProps = (Object[]) range;
final double lowerBound = (Double)rangeProps[0];
final double upperBound = (Double)rangeProps[1];
final double tickUnit = (Double)rangeProps[2];
List tickValues = new ArrayList<>();
if (lowerBound == upperBound) {
tickValues.add(lowerBound);
} else if (tickUnit <= 0) {
tickValues.add(lowerBound);
tickValues.add(upperBound);
} else if (tickUnit > 0) {
tickValues.add(lowerBound);
if (((upperBound - lowerBound) / tickUnit) > 2000) {
// This is a ridiculous amount of major tick marks, something has probably gone wrong
System.err.println("Warning we tried to create more than 2000 major tick marks on a NumberAxis. " +
"Lower Bound=" + lowerBound + ", Upper Bound=" + upperBound + ", Tick Unit=" + tickUnit);
} else {
if (lowerBound + tickUnit < upperBound) {
// If tickUnit is integer, start with the nearest integer
double major = Math.rint(tickUnit) == tickUnit ? Math.ceil(lowerBound) : lowerBound + tickUnit;
int count = (int)Math.ceil((upperBound - major)/tickUnit);
for (int i = 0; major < upperBound && i < count; major += tickUnit, i++) {
if (!tickValues.contains(major)) {
tickValues.add(major);
}
}
}
}
tickValues.add(upperBound);
}
return tickValues;
}
/**
* Calculates a list of the data values for every minor tick mark
*
* @return List of data values where to draw minor tick marks
*/
@Override
protected List calculateMinorTickMarks() {
final List minorTickMarks = new ArrayList<>();
final double lowerBound = getLowerBound();
final double upperBound = getUpperBound();
final double tickUnit = getTickUnit();
final double minorUnit = tickUnit/Math.max(1, getMinorTickCount());
if (tickUnit > 0) {
if(((upperBound - lowerBound) / minorUnit) > 10000) {
// This is a ridiculous amount of major tick marks, something has probably gone wrong
System.err.println("Warning we tried to create more than 10000 minor tick marks on a NumberAxis. " +
"Lower Bound=" + getLowerBound() + ", Upper Bound=" + getUpperBound() + ", Tick Unit=" + tickUnit);
return minorTickMarks;
}
final boolean tickUnitIsInteger = Math.rint(tickUnit) == tickUnit;
if (tickUnitIsInteger) {
double minor = Math.floor(lowerBound) + minorUnit;
int count = (int)Math.ceil((Math.ceil(lowerBound) - minor)/minorUnit);
for (int i = 0; minor < Math.ceil(lowerBound) && i < count; minor += minorUnit, i++) {
if (minor > lowerBound) {
minorTickMarks.add(minor);
}
}
}
double major = tickUnitIsInteger ? Math.ceil(lowerBound) : lowerBound;
int count = (int)Math.ceil((upperBound - major)/tickUnit);
for (int i = 0; major < upperBound && i < count; major += tickUnit, i++) {
final double next = Math.min(major + tickUnit, upperBound);
double minor = major + minorUnit;
int minorCount = (int)Math.ceil((next - minor)/minorUnit);
for (int j = 0; minor < next && j < minorCount; minor += minorUnit, j++) {
minorTickMarks.add(minor);
}
}
}
return minorTickMarks;
}
/**
* Measures the size of the label for a given tick mark value. This uses the font that is set for the tick marks.
*
* @param value tick mark value
* @param range range to use during calculations
* @return size of tick mark label for given value
*/
@Override protected Dimension2D measureTickMarkSize(Number value, Object range) {
final Object[] rangeProps = (Object[]) range;
final String formatter = (String)rangeProps[4];
return measureTickMarkSize(value, getTickLabelRotation(), formatter);
}
/**
* Measures the size of the label for a given tick mark value. This uses the font that is set for the tick marks.
*
* @param value tick mark value
* @param rotation The text rotation
* @param numFormatter The number formatter
* @return size of tick mark label for given value
*/
private Dimension2D measureTickMarkSize(Number value, double rotation, String numFormatter) {
String labelText;
StringConverter formatter = getTickLabelFormatter();
if (formatter == null) formatter = defaultFormatter;
if(formatter instanceof DefaultFormatter) {
labelText = ((DefaultFormatter)formatter).toString(value, numFormatter);
} else {
labelText = formatter.toString(value);
}
return measureTickMarkLabelSize(labelText, rotation);
}
/**
* Called to set the upper and lower bound and anything else that needs to be auto-ranged.
*
* @param minValue The min data value that needs to be plotted on this axis
* @param maxValue The max data value that needs to be plotted on this axis
* @param length The length of the axis in display coordinates
* @param labelSize The approximate average size a label takes along the axis
* @return The calculated range
*/
@Override protected Object autoRange(double minValue, double maxValue, double length, double labelSize) {
final Side side = getEffectiveSide();
// check if we need to force zero into range
if (isForceZeroInRange()) {
if (maxValue < 0) {
maxValue = 0;
} else if (minValue > 0) {
minValue = 0;
}
}
// calculate the number of tick-marks we can fit in the given length
int numOfTickMarks = (int)Math.floor(length/labelSize);
// can never have less than 2 tick marks one for each end
numOfTickMarks = Math.max(numOfTickMarks, 2);
int minorTickCount = Math.max(getMinorTickCount(), 1);
double range = maxValue-minValue;
if (range != 0 && range/(numOfTickMarks*minorTickCount) <= Math.ulp(minValue)) {
range = 0;
}
// pad min and max by 2%, checking if the range is zero
final double paddedRange = (range == 0)
? minValue == 0 ? 2 : Math.abs(minValue)*0.02
: Math.abs(range)*1.02;
final double padding = (paddedRange - range) / 2;
// if min and max are not zero then add padding to them
double paddedMin = minValue - padding;
double paddedMax = maxValue + padding;
// check padding has not pushed min or max over zero line
if ((paddedMin < 0 && minValue >= 0) || (paddedMin > 0 && minValue <= 0)) {
// padding pushed min above or below zero so clamp to 0
paddedMin = 0;
}
if ((paddedMax < 0 && maxValue >= 0) || (paddedMax > 0 && maxValue <= 0)) {
// padding pushed min above or below zero so clamp to 0
paddedMax = 0;
}
// calculate tick unit for the number of ticks can have in the given data range
double tickUnit = paddedRange/numOfTickMarks;
// search for the best tick unit that fits
double tickUnitRounded = 0;
double minRounded = 0;
double maxRounded = 0;
int count = 0;
double reqLength = Double.MAX_VALUE;
String formatter = "0.00000000";
// loop till we find a set of ticks that fit length and result in a total of less than 20 tick marks
while (reqLength > length || count > 20) {
int exp = (int)Math.floor(Math.log10(tickUnit));
final double mant = tickUnit / Math.pow(10, exp);
double ratio = mant;
if (mant > 5d) {
exp++;
ratio = 1;
} else if (mant > 1d) {
ratio = mant > 2.5 ? 5 : 2.5;
}
if (exp > 1) {
formatter = "#,##0";
} else if (exp == 1) {
formatter = "0";
} else {
final boolean ratioHasFrac = Math.rint(ratio) != ratio;
final StringBuilder formatterB = new StringBuilder("0");
int n = ratioHasFrac ? Math.abs(exp) + 1 : Math.abs(exp);
if (n > 0) formatterB.append(".");
for (int i = 0; i < n; ++i) {
formatterB.append("0");
}
formatter = formatterB.toString();
}
tickUnitRounded = ratio * Math.pow(10, exp);
// move min and max to nearest tick mark
minRounded = Math.floor(paddedMin / tickUnitRounded) * tickUnitRounded;
maxRounded = Math.ceil(paddedMax / tickUnitRounded) * tickUnitRounded;
// calculate the required length to display the chosen tick marks for real, this will handle if there are
// huge numbers involved etc or special formatting of the tick mark label text
double maxReqTickGap = 0;
double last = 0;
count = (int)Math.ceil((maxRounded - minRounded)/tickUnitRounded);
double major = minRounded;
for (int i = 0; major <= maxRounded && i < count; major += tickUnitRounded, i++) {
Dimension2D markSize = measureTickMarkSize(major, getTickLabelRotation(), formatter);
double size = side.isVertical() ? markSize.getHeight() : markSize.getWidth();
if (i == 0) { // first
last = size/2;
} else {
maxReqTickGap = Math.max(maxReqTickGap, last + 6 + (size/2) );
}
}
reqLength = (count-1) * maxReqTickGap;
tickUnit = tickUnitRounded;
// fix for RT-35600 where a massive tick unit was being selected
// unnecessarily. There is probably a better solution, but this works
// well enough for now.
if (numOfTickMarks == 2 && reqLength > length) {
break;
}
if (reqLength > length || count > 20) tickUnit *= 2; // This is just for the while loop, if there are still too many ticks
}
// calculate new scale
final double newScale = calculateNewScale(length, minRounded, maxRounded);
// return new range
return new Object[]{minRounded, maxRounded, tickUnitRounded, newScale, formatter};
}
// -------------- STYLESHEET HANDLING ------------------------------------------------------------------------------
private static class StyleableProperties {
private static final CssMetaData TICK_UNIT =
new CssMetaData<>("-fx-tick-unit",
SizeConverter.getInstance(), 5.0) {
@Override
public boolean isSettable(NumberAxis n) {
return n.tickUnit == null || !n.tickUnit.isBound();
}
@Override
public StyleableProperty getStyleableProperty(NumberAxis n) {
return (StyleableProperty)n.tickUnitProperty();
}
};
private static final List> STYLEABLES;
static {
final List> styleables =
new ArrayList<>(ValueAxis.getClassCssMetaData());
styleables.add(TICK_UNIT);
STYLEABLES = Collections.unmodifiableList(styleables);
}
}
/**
* Gets the {@code CssMetaData} associated with this class, which may include the
* {@code CssMetaData} of its superclasses.
* @return the {@code CssMetaData}
* @since JavaFX 8.0
*/
public static List> getClassCssMetaData() {
return StyleableProperties.STYLEABLES;
}
/**
* {@inheritDoc}
* @since JavaFX 8.0
*/
@Override
public List> getCssMetaData() {
return getClassCssMetaData();
}
// -------------- INNER CLASSES ------------------------------------------------------------------------------------
/**
* Default number formatter for NumberAxis, this stays in sync with auto-ranging and formats values appropriately.
* You can wrap this formatter to add prefixes or suffixes;
* @since JavaFX 2.0
*/
public static class DefaultFormatter extends StringConverter {
private DecimalFormat formatter;
private String prefix = null;
private String suffix = null;
/**
* Construct a DefaultFormatter for the given NumberAxis
*
* @param axis The axis to format tick marks for
*/
public DefaultFormatter(final NumberAxis axis) {
formatter = axis.isAutoRanging()? new DecimalFormat(axis.currentFormatterProperty.get()) : new DecimalFormat();
final ChangeListener © 2015 - 2024 Weber Informatics LLC | Privacy Policy