SpinnerValueFactory.DoubleSpinnerValueFactory (JavaFX 25)
Description: declaration: module: javafx.controls, package: javafx.scene.control, class: SpinnerValueFactory, class: DoubleSpinnerValueFactory

# Class SpinnerValueFactory.DoubleSpinnerValueFactory

java.lang.Object
javafx.scene.control.SpinnerValueFactory<Double>
javafx.scene.control.SpinnerValueFactory.DoubleSpinnerValueFactory

Enclosing class:
  `SpinnerValueFactory<T>`

public static class SpinnerValueFactory.DoubleSpinnerValueFactory extends SpinnerValueFactory<Double>
A `SpinnerValueFactory` implementation designed to iterate through double values.

If `wrapAround` is `true`, the `DoubleSpinnerValueFactory` will step through from the maximum value to the minimum value seamlessly; that is, any step up from the maximum value is equal to the same step up from the minimum value (and vice versa). The new value after a step is `val = (val + amountToStepBy) % (max - min)`.

Note that the default `converter` is implemented simply as shown below, which may be adequate in many cases, but it is important for users to ensure that this suits their needs (and adjust when necessary). The main point to note is that this `StringConverter` embeds within it a `DecimalFormat` instance that shows the Double to two decimal places. This is used for both the toString and fromString methods:

    setConverter(new StringConverter<Double>() {
        private final DecimalFormat df = new DecimalFormat("#.##");

        @Override public String toString(Double value) {
            // If the specified value is null, return a zero-length String
            if (value == null) {
                return "";
            }

            return df.format(value);
        }

        @Override public Double fromString(String value) {
            try {
                // If the specified value is null or zero-length, return null
                if (value == null) {
                    return null;
                }

                value = value.trim();

                if (value.length() < 1) {
                    return null;
                }

                // Perform the requested parsing
                return df.parse(value).doubleValue();
            } catch (ParseException ex) {
                throw new RuntimeException(ex);
            }
        }
    });

Since:
  JavaFX 8u40

- ## Nested Class Summary

  ### Nested classes/interfaces declared in class SpinnerValueFactory

  `SpinnerValueFactory.DoubleSpinnerValueFactory, SpinnerValueFactory.IntegerSpinnerValueFactory, SpinnerValueFactory.ListSpinnerValueFactory<T>`

- ## Property Summary

  Properties
  Type
  Property
  Description
  `final DoubleProperty`
  `amountToStepBy`
  Sets the amount to increment or decrement by, per step.
  `final DoubleProperty`
  `max`
  Sets the maximum allowable value for this value factory
  `final DoubleProperty`
  `min`
  Sets the minimum allowable value for this value factory

  ### Properties declared in class SpinnerValueFactory

  `converter, value, wrapAround`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `DoubleSpinnerValueFactory(double min, double max)`
  Constructs a new DoubleSpinnerValueFactory that sets the initial value to be equal to the min value, and a default `amountToStepBy` of one.
  `DoubleSpinnerValueFactory(double min, double max, double initialValue)`
  Constructs a new DoubleSpinnerValueFactory with a default `amountToStepBy` of one.
  `DoubleSpinnerValueFactory(double min, double max, double initialValue, double amountToStepBy)`
  Constructs a new DoubleSpinnerValueFactory.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `final DoubleProperty`
  `amountToStepByProperty()`
  Sets the amount to increment or decrement by, per step.
  `void`
  `decrement(int steps)`
  Attempts to decrement the `value` by the given number of steps.
  `final double`
  `getAmountToStepBy()`
  Gets the value of the `amountToStepBy` property.
  `final double`
  `getMax()`
  Gets the value of the `max` property.
  `final double`
  `getMin()`
  Gets the value of the `min` property.
  `void`
  `increment(int steps)`
  Attempts to increment the `value` by the given number of steps.
  `final DoubleProperty`
  `maxProperty()`
  Sets the maximum allowable value for this value factory
  `final DoubleProperty`
  `minProperty()`
  Sets the minimum allowable value for this value factory
  `final void`
  `setAmountToStepBy(double value)`
  Sets the value of the `amountToStepBy` property.
  `final void`
  `setMax(double value)`
  Sets the value of the `max` property.
  `final void`
  `setMin(double value)`
  Sets the value of the `min` property.

  ### Methods declared in class SpinnerValueFactory

  `converterProperty, getConverter, getValue, isWrapAround, setConverter, setValue, setWrapAround, valueProperty, wrapAroundProperty`

  ### Methods declared in class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Property Details

  - ### min

    public final DoubleProperty minProperty
    Sets the minimum allowable value for this value factory
    See Also:
      - `getMin()`
      - `setMin(double)`
      - `minProperty()`

  - ### max

    public final DoubleProperty maxProperty
    Sets the maximum allowable value for this value factory
    See Also:
      - `getMax()`
      - `setMax(double)`
      - `maxProperty()`

  - ### amountToStepBy

    public final DoubleProperty amountToStepByProperty
    Sets the amount to increment or decrement by, per step.
    See Also:
      - `getAmountToStepBy()`
      - `setAmountToStepBy(double)`
      - `amountToStepByProperty()`

- ## Constructor Details

  - ### DoubleSpinnerValueFactory

    public DoubleSpinnerValueFactory(double min, double max)
    Constructs a new DoubleSpinnerValueFactory that sets the initial value to be equal to the min value, and a default `amountToStepBy` of one.
    Parameters:
      `min` - The minimum allowed double value for the Spinner.
      `max` - The maximum allowed double value for the Spinner.

  - ### DoubleSpinnerValueFactory

    public DoubleSpinnerValueFactory(double min, double max, double initialValue)
    Constructs a new DoubleSpinnerValueFactory with a default `amountToStepBy` of one.
    Parameters:
      `min` - The minimum allowed double value for the Spinner.
      `max` - The maximum allowed double value for the Spinner.
      `initialValue` - The value of the Spinner when first instantiated, must be within the bounds of the min and max arguments, or else the min value will be used.

  - ### DoubleSpinnerValueFactory

    public DoubleSpinnerValueFactory(double min, double max, double initialValue, double amountToStepBy)
    Constructs a new DoubleSpinnerValueFactory.
    Parameters:
      `min` - The minimum allowed double value for the Spinner.
      `max` - The maximum allowed double value for the Spinner.
      `initialValue` - The value of the Spinner when first instantiated, must be within the bounds of the min and max arguments, or else the min value will be used.
      `amountToStepBy` - The amount to increment or decrement by, per step.

- ## Method Details

  - ### setMin

    public final void setMin(double value)
    Sets the value of the `min` property.
    Property description:
      Sets the minimum allowable value for this value factory
    Parameters:
      `value` - the value for the `min` property
    See Also:
      - `getMin()`
      - `minProperty()`

  - ### getMin

    public final double getMin()
    Gets the value of the `min` property.
    Property description:
      Sets the minimum allowable value for this value factory
    Returns:
      the value of the `min` property
    See Also:
      - `setMin(double)`
      - `minProperty()`

  - ### minProperty

    public final DoubleProperty minProperty()
    Sets the minimum allowable value for this value factory
    Returns:
      the minimum allowable value for this value factory
    See Also:
      - `getMin()`
      - `setMin(double)`

  - ### setMax

    public final void setMax(double value)
    Sets the value of the `max` property.
    Property description:
      Sets the maximum allowable value for this value factory
    Parameters:
      `value` - the value for the `max` property
    See Also:
      - `getMax()`
      - `maxProperty()`

  - ### getMax

    public final double getMax()
    Gets the value of the `max` property.
    Property description:
      Sets the maximum allowable value for this value factory
    Returns:
      the value of the `max` property
    See Also:
      - `setMax(double)`
      - `maxProperty()`

  - ### maxProperty

    public final DoubleProperty maxProperty()
    Sets the maximum allowable value for this value factory
    Returns:
      the maximum allowable value for this value factory
    See Also:
      - `getMax()`
      - `setMax(double)`

  - ### setAmountToStepBy

    public final void setAmountToStepBy(double value)
    Sets the value of the `amountToStepBy` property.
    Property description:
      Sets the amount to increment or decrement by, per step.
    Parameters:
      `value` - the value for the `amountToStepBy` property
    See Also:
      - `getAmountToStepBy()`
      - `amountToStepByProperty()`

  - ### getAmountToStepBy

    public final double getAmountToStepBy()
    Gets the value of the `amountToStepBy` property.
    Property description:
      Sets the amount to increment or decrement by, per step.
    Returns:
      the value of the `amountToStepBy` property
    See Also:
      - `setAmountToStepBy(double)`
      - `amountToStepByProperty()`

  - ### amountToStepByProperty

    public final DoubleProperty amountToStepByProperty()
    Sets the amount to increment or decrement by, per step.
    Returns:
      the amount to increment or decrement by, per step
    See Also:
      - `getAmountToStepBy()`
      - `setAmountToStepBy(double)`

  - ### decrement

    public void decrement(int steps)
    Attempts to decrement the `value` by the given number of steps.
    Specified by:
      `decrement` in class `SpinnerValueFactory<Double>`
    Parameters:
      `steps` - The number of decrements that should be performed on the value. If the number is negative, the call is equivalent to calling `SpinnerValueFactory.increment(int)` with the absolute value of `steps`.

  - ### increment

    public void increment(int steps)
    Attempts to increment the `value` by the given number of steps.
    Specified by:
      `increment` in class `SpinnerValueFactory<Double>`
    Parameters:
      `steps` - The number of increments that should be performed on the value. If the number is negative, the call is equivalent to calling `SpinnerValueFactory.decrement(int)` with the absolute number of `steps`.