Package ch.bailu.gtk.gtk

Class SpinButton

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.gobject.InitiallyUnowned
ch.bailu.gtk.gtk.Widget
ch.bailu.gtk.gtk.SpinButton
All Implemented Interfaces:
PointerInterface
public class SpinButton extends Widget
A `GtkSpinButton` is an ideal way to allow the user to set the
value of some attribute.

![An example GtkSpinButton](spinbutton.png)

Rather than having to directly type a number into a `GtkEntry`,
`GtkSpinButton` allows the user to click on one of two arrows
to increment or decrement the displayed value. A value can still be
typed in, with the bonus that it can be checked to ensure it is in a
given range.

The main properties of a `GtkSpinButton` are through an adjustment.
See the [class@Gtk.Adjustment] documentation for more details about
an adjustment's properties.

Note that `GtkSpinButton` will by default make its entry large enough
to accommodate the lower and upper bounds of the adjustment. If this
is not desired, the automatic sizing can be turned off by explicitly
setting [property@Gtk.Editable:width-chars] to a value != -1.

## Using a GtkSpinButton to get an integer

```c
// Provides a function to retrieve an integer value from a GtkSpinButton
// and creates a spin button to model percentage values.

int
grab_int_value (GtkSpinButton *button,
gpointer user_data)
{
return gtk_spin_button_get_value_as_int (button);
}

void
create_integer_spin_button (void)
{

GtkWidget *window, *button;
GtkAdjustment *adjustment;

adjustment = gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 5.0, 0.0);

window = gtk_window_new ();

// creates the spinbutton, with no decimal places
button = gtk_spin_button_new (adjustment, 1.0, 0);
gtk_window_set_child (GTK_WINDOW (window), button);

gtk_widget_show (window);
}
```

## Using a GtkSpinButton to get a floating point value

```c
// Provides a function to retrieve a floating point value from a
// GtkSpinButton, and creates a high precision spin button.

float
grab_float_value (GtkSpinButton *button,
gpointer user_data)
{
return gtk_spin_button_get_value (button);
}

void
create_floating_spin_button (void)
{
GtkWidget *window, *button;
GtkAdjustment *adjustment;

adjustment = gtk_adjustment_new (2.500, 0.0, 5.0, 0.001, 0.1, 0.0);

window = gtk_window_new ();

// creates the spinbutton, with three decimal places
button = gtk_spin_button_new (adjustment, 0.001, 3);
gtk_window_set_child (GTK_WINDOW (window), button);

gtk_widget_show (window);
}
```

# CSS nodes

```
spinbutton.horizontal
├── text
│ ├── undershoot.left
│ ╰── undershoot.right
├── button.down
╰── button.up
```

```
spinbutton.vertical
├── button.up
├── text
│ ├── undershoot.left
│ ╰── undershoot.right
╰── button.down
```

`GtkSpinButton`s main CSS node has the name spinbutton. It creates subnodes
for the entry and the two buttons, with these names. The button nodes have
the style classes .up and .down. The `GtkText` subnodes (if present) are put
below the text node. The orientation of the spin button is reflected in
the .vertical or .horizontal style class on the main node.

# Accessiblity

`GtkSpinButton` uses the %GTK_ACCESSIBLE_ROLE_SPIN_BUTTON role.

https://docs.gtk.org/gtk4/class.SpinButton.html

  • Field Details

  • Constructor Details

    • SpinButton

      public SpinButton(PointerContainer pointer)

    • SpinButton

      public SpinButton(@Nullable Adjustment adjustment, double climb_rate, int digits)
      Creates a new `GtkSpinButton`.
      Parameters:
      adjustment - the `GtkAdjustment` that this spin button should use
      climb_rate - specifies by how much the rate of change in the value will accelerate if you continue to hold down an up/down button or arrow key
      digits - the number of decimal places to display

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • newWithRangeSpinButton

      public static SpinButton newWithRangeSpinButton(double min, double max, double step)
      Creates a new `GtkSpinButton` with the given properties.

      This is a convenience constructor that allows creation
      of a numeric `GtkSpinButton` without manually creating
      an adjustment. The value is initially set to the minimum
      value and a page increment of 10 * @step is the default.
      The precision of the spin button is equivalent to the
      precision of @step.

      Note that the way in which the precision is derived works
      best if @step is a power of ten. If the resulting precision
      is not suitable for your needs, use
      [method@Gtk.SpinButton.set_digits] to correct it.
      Parameters:
      min - Minimum allowable value
      max - Maximum allowable value
      step - Increment added or subtracted by spinning the widget
      Returns:
      The new `GtkSpinButton`

    • configure

      public void configure(@Nullable Adjustment adjustment, double climb_rate, int digits)
      Changes the properties of an existing spin button.

      The adjustment, climb rate, and number of decimal places
      are updated accordingly.
      Parameters:
      adjustment - a `GtkAdjustment` to replace the spin button’s existing adjustment, or %NULL to leave its current adjustment unchanged
      climb_rate - the new climb rate
      digits - the number of decimal places to display in the spin button

    • getAdjustment

      public Adjustment getAdjustment()
      Get the adjustment associated with a `GtkSpinButton`.
      Returns:
      the `GtkAdjustment` of @spin_button

    • getClimbRate

      public double getClimbRate()
      Returns the acceleration rate for repeated changes.
      Returns:
      the acceleration rate

    • getDigits

      public int getDigits()
      Fetches the precision of @spin_button.
      Returns:
      the current precision

    • getNumeric

      public boolean getNumeric()
      Returns whether non-numeric text can be typed into the spin button.
      Returns:
      %TRUE if only numeric text can be entered

    • getSnapToTicks

      public boolean getSnapToTicks()
      Returns whether the values are corrected to the nearest step.
      Returns:
      %TRUE if values are snapped to the nearest step

    • getUpdatePolicy

      public int getUpdatePolicy()
      Gets the update behavior of a spin button.

      See [method@Gtk.SpinButton.set_update_policy].
      Returns:
      the current update policy

    • getValue

      public double getValue()
      Get the value in the @spin_button.
      Returns:
      the value of @spin_button

    • getValueAsInt

      public int getValueAsInt()
      Get the value @spin_button represented as an integer.
      Returns:
      the value of @spin_button

    • getWrap

      public boolean getWrap()
      Returns whether the spin button’s value wraps around to the
      opposite limit when the upper or lower limit of the range is
      exceeded.
      Returns:
      %TRUE if the spin button wraps around

    • setAdjustment

      public void setAdjustment(@Nonnull Adjustment adjustment)
      Replaces the `GtkAdjustment` associated with @spin_button.
      Parameters:
      adjustment - a `GtkAdjustment` to replace the existing adjustment

    • setClimbRate

      public void setClimbRate(double climb_rate)
      Sets the acceleration rate for repeated changes when you
      hold down a button or key.
      Parameters:
      climb_rate - the rate of acceleration, must be >= 0

    • setDigits

      public void setDigits(int digits)
      Set the precision to be displayed by @spin_button.

      Up to 20 digit precision is allowed.
      Parameters:
      digits - the number of digits after the decimal point to be displayed for the spin button’s value

    • setIncrements

      public void setIncrements(double step, double page)
      Sets the step and page increments for spin_button.

      This affects how quickly the value changes when
      the spin button’s arrows are activated.
      Parameters:
      step - increment applied for a button 1 press.
      page - increment applied for a button 2 press.

    • setNumeric

      public void setNumeric(boolean numeric)
      Sets the flag that determines if non-numeric text can be typed
      into the spin button.
      Parameters:
      numeric - flag indicating if only numeric entry is allowed

    • setRange

      public void setRange(double min, double max)
      Sets the minimum and maximum allowable values for @spin_button.

      If the current value is outside this range, it will be adjusted
      to fit within the range, otherwise it will remain unchanged.
      Parameters:
      min - minimum allowable value
      max - maximum allowable value

    • setSnapToTicks

      public void setSnapToTicks(boolean snap_to_ticks)
      Sets the policy as to whether values are corrected to the
      nearest step increment when a spin button is activated after
      providing an invalid value.
      Parameters:
      snap_to_ticks - a flag indicating if invalid values should be corrected

    • setUpdatePolicy

      public void setUpdatePolicy(int policy)
      Sets the update behavior of a spin button.

      This determines whether the spin button is always
      updated or only when a valid value is set.
      Parameters:
      policy - a `GtkSpinButtonUpdatePolicy` value

    • setValue

      public void setValue(double value)
      Sets the value of @spin_button.
      Parameters:
      value - the new value

    • setWrap

      public void setWrap(boolean wrap)
      Sets the flag that determines if a spin button value wraps
      around to the opposite limit when the upper or lower limit
      of the range is exceeded.
      Parameters:
      wrap - a flag indicating if wrapping behavior is performed

    • spin

      public void spin(int direction, double increment)
      Increment or decrement a spin button’s value in a specified
      direction by a specified amount.
      Parameters:
      direction - a `GtkSpinType` indicating the direction to spin
      increment - step increment to apply in the specified direction

    • update

      public void update()
      Manually force an update of the spin button.

    • onChangeValue

      public SignalHandler onChangeValue(SpinButton.OnChangeValue signal)
      Connect to signal "change-value".
      See SpinButton.OnChangeValue.onChangeValue(int) for signal description.
      Field SIGNAL_ON_CHANGE_VALUE contains original signal name and can be used as resource reference.
      Parameters:
      signal - callback function (lambda).
      Returns:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • onInput

      public SignalHandler onInput(SpinButton.OnInput signal)
      Connect to signal "input".
      See SpinButton.OnInput.onInput(ch.bailu.gtk.type.Pointer) for signal description.
      Field SIGNAL_ON_INPUT contains original signal name and can be used as resource reference.
      Parameters:
      signal - callback function (lambda).
      Returns:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • onOutput

      public SignalHandler onOutput(SpinButton.OnOutput signal)
      Connect to signal "output".
      See SpinButton.OnOutput.onOutput() for signal description.
      Field SIGNAL_ON_OUTPUT contains original signal name and can be used as resource reference.
      Parameters:
      signal - callback function (lambda).
      Returns:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • onValueChanged

      public SignalHandler onValueChanged(SpinButton.OnValueChanged signal)
      Connect to signal "value-changed".
      See SpinButton.OnValueChanged.onValueChanged() for signal description.
      Field SIGNAL_ON_VALUE_CHANGED contains original signal name and can be used as resource reference.
      Parameters:
      signal - callback function (lambda).
      Returns:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • onWrapped

      public SignalHandler onWrapped(SpinButton.OnWrapped signal)
      Connect to signal "wrapped".
      See SpinButton.OnWrapped.onWrapped() for signal description.
      Field SIGNAL_ON_WRAPPED contains original signal name and can be used as resource reference.
      Parameters:
      signal - callback function (lambda).
      Returns:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • asAccessible

      public Accessible asAccessible()
      Implements interface Accessible. Call this to get access to interface functions.
      Overrides:
      asAccessible in class Widget
      Returns:
      Accessible

    • asBuildable

      public Buildable asBuildable()
      Implements interface Buildable. Call this to get access to interface functions.
      Overrides:
      asBuildable in class Widget
      Returns:
      Buildable

    • asCellEditable

      public CellEditable asCellEditable()
      Implements interface CellEditable. Call this to get access to interface functions.
      Returns:
      CellEditable

    • asConstraintTarget

      public ConstraintTarget asConstraintTarget()
      Implements interface ConstraintTarget. Call this to get access to interface functions.
      Overrides:
      asConstraintTarget in class Widget
      Returns:
      ConstraintTarget

    • asEditable

      public Editable asEditable()
      Implements interface Editable. Call this to get access to interface functions.
      Returns:
      Editable

    • asOrientable

      public Orientable asOrientable()
      Implements interface Orientable. Call this to get access to interface functions.
      Returns:
      Orientable

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()