This doesn't appear to be supported, but can be built by telling the chart to read values backward. Making values backward is more or less a reflection of the graph across the other axis, so we'll want the chart to treat our number line as though all values are negative of their real values, without actually changing the labels.
First, you should make a valueprovider that makes all values negative. Here's a quick (untested!) example that can wrap any other ValueProvider and negate its values.
Code:
public class NegativeValueProvider<T> implements ValueProvider<T, Number> {
private final ValueProvider<T, Number> vp;
public NegativeValueProvider(ValueProvider<T, Number> original) {
this.vp = original;
}
public Number getValue(T object) {
return 0 - vp.getValue(object).doubleValue();
}
@Override
public void setValue(T object, Number value) {
throw new UnsupportedOperationException("NegativeValueProvider shouldnt be used to save values");
}
@Override
public String getPath() {
return vp.getPath();
}
}
Note that I cheat a bit and turn the numbers to doubles - if this is a problem for you, consider BigDecimal or the like.
You'll supply this to the Axis (and the Series) when it asks for a numeric field to operate on - wrap up your usual valueprovider in it, and it will make negative numbers.
Now we need to make sure those numbers aren't drawn as their opposites - easier way to do this is to make a custom LabelProvider. Again, we're computing the negative value - but this time it is the negative of the negative, so it is back to the oringal value:
Code:
public class NegativeLabelProvider implements LabelProvider<Number> {
public String getLabel(Number item) {
return (0 - item.doubleValue()) + "";
}
}
Again, double-specific, YMMV.
Then, pass both of these off to the axis:
Code:
y.addField(new NegativeValueProvider<MyObject>(props.sales());
//y.addField(new NegativeValueProvider<MyObject>(props.overhead());//you can still use more than one, just be sure they are all reversed
y.setLabelProvider(new NegativeLabelProvider());
And the series, however you construct it should also be given a negative valueprovider.
Between the two of these, the axis will render our values 'backward', but the label will be the correct values as (0 - (0 - X)) = X.
I've not tested this beyond confirming that it compiles, but I've created and used a logarithmic axis labeling system that followed this same scheme.