Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
*
* @return the rendererDataReducerProperty
*/
public ObjectProperty rendererDataReducerProperty() {
return rendererDataReducer;
}
/**
* @see #rendererDataReducerProperty()
* @return the active data set reducer algorithm
*/
public RendererDataReducer getRendererDataReducer() {
return rendererDataReducer.get();
}
/**
* @see #rendererDataReducerProperty()
* @param algorithm the new data reducing algorithm to be set (null -> {@link DefaultDataReducer})
* @return itself (fluent design)
*/
public R getRendererDataReducer(final RendererDataReducer algorithm) {
if (algorithm == null) {
rendererDataReducer.set(new DefaultDataReducer());
} else {
rendererDataReducer.set(algorithm);
}
return getThis();
}
/**
* Sets whether superfluous points, otherwise drawn on the same pixel area, are merged and represented by the
* multiple point average.
*
* @return true if point reduction is on (default) else false.
*/
public boolean isReducePoints() {
return pointReduction.get();
}
/**
* Sets whether superfluous points, otherwise drawn on the same pixel area, are merged and represented by the
* multiple point average.
*
* @param state true if data points are supposed to be reduced
* @return itself (fluent design)
*/
public R setPointReduction(final boolean state) {
pointReduction.set(state);
return getThis();
}
/**
* Sets whether superfluous points, otherwise drawn on the same pixel area, are merged and represented by the
* multiple point average.
*
* @return true if data points are supposed to be reduced
*/
public BooleanProperty pointReductionProperty() {
return pointReduction;
}
/**
* Returns the dashSize.
*
* @return the dashSize.
*/
public int getDashSize() {
return dashSize.get();
}
/**
* Sets the dashSize to the specified value. The dash is the horizontal line painted at the ends of the
* vertical line. It is not painted if set to 0.
*
* @param dashSize the dashSize to set.
* @return itself (fluent design)
*/
public R setDashSize(final int dashSize) {
AssertUtils.gtEqThanZero("dash size", dashSize);
this.dashSize.setValue(dashSize);
return getThis();
}
public IntegerProperty dashSizeProperty() {
return dashSize;
}
/**
* @return the minimum number of samples before performing data reduction
*/
public int getMinRequiredReductionSize() {
return minRequiredReductionSize.get();
}
/**
* @param size the minimum number of samples before performing data reduction
* @return itself (fluent design)
*/
public R setMinRequiredReductionSize(final int size) {
minRequiredReductionSize.setValue(size);
return getThis();
}
public IntegerProperty minRequiredReductionSizeProperty() {
return minRequiredReductionSize;
}
/**
* Returns the markerSize.
*
* @return the markerSize.
*/
public double getMarkerSize() {
return markerSize.get();
}
/**
* Sets the markerSize to the specified value.
*
* @param size the markerSize to set.
* @return itself (fluent design)
*/
public R setMarkerSize(final double size) {
AssertUtils.gtEqThanZero("marker size ", size);
markerSize.setValue(size);
return getThis();
}
public DoubleProperty markerSizeProperty() {
return markerSize;
}
/**
* Returns the intensityFading.
*
* @return the intensityFading.
*/
public double getIntensityFading() {
return intensityFading.get();
}
/**
* Sets the intensityFading to the specified value.
*
* @param size the intensityFading to set.
* @return itself (fluent design)
*/
public R setIntensityFading(final double size) {
intensityFading.setValue(size);
return getThis();
}
public DoubleProperty intensityFadingProperty() {
return intensityFading;
}
/**
* @return true if point reduction is on (default) else false.
*/
public boolean isDrawMarker() {
return drawMarker.get();
}
/**
* @param state true -> draws markers
* @return itself (fluent design)
*/
public R setDrawMarker(final boolean state) {
drawMarker.set(state);
return getThis();
}
/**
* @return the drawMarker state
*/
public BooleanProperty drawMarkerProperty() {
return drawMarker;
}
/**
* @return true if bars from the data points to the y==0 axis shall be drawn
*/
public boolean isDrawBars() {
return drawBars.get();
}
/**
* @param state true if bars from the data points to the y==0 axis shall be drawn
* @return itself (fluent design)
*/
public R setDrawBars(final boolean state) {
drawBars.set(state);
return getThis();
}
/**
* @return the drawBars state
*/
public BooleanProperty drawBarsProperty() {
return drawBars;
}
/**
* @return true if bars drawn to the y==0 axis shall be horizontally shifted for each DataSet
*/
public boolean isShiftBar() {
return shiftBar.get();
}
/**
* @param state true if bars drawn to the y==0 axis shall be horizontally shifted for each DataSet
* @return itself (fluent design)
*/
public R setShiftBar(final boolean state) {
shiftBar.set(state);
return getThis();
}
/**
* @return the shiftBar state
*/
public BooleanProperty shiftBarProperty() {
return shiftBar;
}
/**
* Returns the shiftBarOffset.
*
* @return the shiftBarOffset.
*/
public int getShiftBarOffset() {
return shiftBarOffset.get();
}
/**
* Sets the shiftBarOffset to the specified value.
*
* @param shiftBarOffset the shiftBarOffset to set.
* @return itself (fluent design)
*/
public R setshiftBarOffset(final int shiftBarOffset) {
AssertUtils.gtEqThanZero("shiftBarOffset", shiftBarOffset);
this.shiftBarOffset.setValue(shiftBarOffset);
return getThis();
}
public IntegerProperty shiftBarOffsetProperty() {
return shiftBarOffset;
}
/**
* @return true whether the width of bars drawn to the '0' shall be dynamically to the shown axis width
*/
public boolean isDynamicBarWidth() {
return dynamicBarWidth.get();
}
/**
* @param state true whether the width of bars drawn to the '0' shall be dynamically to the shown axis width
* @return itself (fluent design)
*/
public R setDynamicBarWidth(final boolean state) {
dynamicBarWidth.set(state);
return getThis();
}
/**
* @return the dynamicBarWidth state
*/
public BooleanProperty dynamicBarWidthProperty() {
return dynamicBarWidth;
}
/**
* @return the barWidthPercentage of the total X space should be taken to paint // bars.
*/
public double getBarWidthPercentage() {
return barWidthPercentage.get();
}
/**
* @param size the barWidthPercentage of the total X space should be taken to paint
* @return itself (fluent design)
*/
public R setBarWidthPercentage(final double size) {
AssertUtils.gtEqThanZero("barWidthPercentage", size);
barWidthPercentage.setValue(size);
return getThis();
}
public DoubleProperty barWidthPercentageProperty() {
return barWidthPercentage;
}
/**
* @return the barWidth in case of constant width bards being drawn @see setDynamicBarWidth()
*/
public int getBarWidth() {
return barWidth.get();
}
/**
* @param barWidth the barWidth in case of constant width bards being drawn @see setDynamicBarWidth()
* @return itself (fluent design)
*/
public R setBarWidth(final int barWidth) {
AssertUtils.gtEqThanZero("barWidth", barWidth);
this.barWidth.setValue(barWidth);
return getThis();
}
public IntegerProperty barWidthProperty() {
return barWidth;
}
/**
* whether renderer should aim at parallelising sub-functionalities
*
* @return true if renderer is parallelising sub-functionalities
*/
public boolean isParallelImplementation() {
return parallelImplementation.get();
}
/**
* Sets whether renderer should aim at parallelising sub-functionalities
*
* @param state true if renderer is parallelising sub-functionalities
* @return itself (fluent design)
*/
public R setParallelImplementation(final boolean state) {
parallelImplementation.set(state);
return getThis();
}
/**
* Sets whether renderer should aim at parallelising sub-functionalities
*
* @return true if data points are supposed to be reduced
*/
public BooleanProperty parallelImplementationProperty() {
return parallelImplementation;
}
/**
* whether renderer should draw no, simple (point-to-point), stair-case, Bezier, ... lines
*
* @return LineStyle
*/
public LineStyle getPolyLineStyle() {
return polyLineStyleProperty().get();
}
/**
* Sets whether renderer should draw no, simple (point-to-point), stair-case, Bezier, ... lines
*
* @param style draw no, simple (point-to-point), stair-case, Bezier, ... lines
* @return itself (fluent design)
*/
public R setPolyLineStyle(final LineStyle style) {
polyLineStyleProperty().set(style);
return getThis();
}
/**
* Sets whether renderer should draw no, simple (point-to-point), stair-case, Bezier, ... lines
*
* @return property
*/
public ObjectProperty polyLineStyleProperty() {
return polyLineStyle;
}
/**
* @return true if bubbles shall be draw
*/
public boolean isDrawBubbles() {
return drawBubbles.get();
}
/**
* @param state true if bubbles shall be draw
* @return itself (fluent design)
*/
public R setDrawBubbles(final boolean state) {
drawBubbles.set(state);
return getThis();
}
/**
* @return the drawBubbles property
*/
public BooleanProperty drawBubblesProperty() {
return drawBubbles;
}
}
