Spinner Widget

README.md

@@ -216,6 +216,76 @@ m := NewMap()
 
 ![](img/map.png)
 
+### Spinner
+
+A Spinner is a widget that displays a numerical value along with an increment (up) button and a decrement (down)
+ button. These buttons
+allow incrementing or decrementing the value. 
+The spinner's value is limited to be between the minimum and
+maximum values, and the value increments or decrements by the step value. The initially displayed
+value is set to the minimum value, or to the bound value.
+
+All Spinner values (value, minumum, maximum, and step) are stored as float64 values. There is a format
+field that determines how the value is displayed in the Spinner widget. If the format contains "%d" or
+"%+d", the value is displayed as an integer. Other "%" formats assume you want to display the value as
+a floating point number. It is recommended that you use "%.Xf", where X is an unsigned integer, as the
+format for displaying floating point numbers.
+
+You may include other text in the format. For example, if the current value is 47.15, and you specify the
+format as "%d %%" then the displayed value will be "47 %"
+
+The most typical step value for an integer Spinner
+value would be 1, but the step value can be set to any value greater than 0 and less than or equal to the
+maximum value minus the minimum value.
+
+In addition to clicking on the up and down buttons, the spinner value can be incremented or decremented using either
+keyboard keys, or the mouse scroller or touchpad. Clicking on one of the buttons
+will modify the spinner value at any time, except when the spinner is disabled. Keyboard, scroller, and touchpad
+input only works when the spinner has focus.
+
+Here are the keyboard keys accepted by the spinner widget and their effects:
+
+| Key | Effect |
+|---|---|
+| KeyUp | Increment value by step amount |
+| + | Increment value by step amount |
+| KeyDown | Decrement value by step amount |
+| - | Decrement value by step amount |
+
+Finally, the value can be set programmatically using the `Spinner.SetValue` method.
+
+Here is simple example that creates a spinner widget:
+
+```go
+spinner := NewSpinner(2, 22, 3.14, "%.1f", valChanged)
+spinner.SetValue(6)
+```
+
+The result of executing this code is an IntSpinner widget with the following settings:
+
+| Setting | Value |
+|---|---|
+| minimum value | 2.0 |
+| maximum value | 22.0 |
+| step | 3.14 |
+| format | "%.1f" |
+|initial value | 2.0 |
+| function called on value change | valChanged |
+| value after SetValue call | 6.0 |
+
+This is what a Spinner, with the format of "%d" and that does not have focus, looks like in light theme:
+
+![](img/spinner-light.png)
+
+and this is a focused Spinner with the format of "%.1f" in dark theme:
+
+![](img/spinner-dark.png)
+
+The spinner is normally sized to the minimum width and height required to display any value between its
+minimum and maximum values, although the width and height may be controlled by the container it is included in.
+
+See the [demo](cmd/spinner_demo/main.go) program for an example of how to use the spinner widget.
+
 ### TwoStateToolbarAction
 
 A TwoStateToolbarAction displays one of two icons based on the stored state. It is similar

cmd/spinner_demo/main.go

@@ -0,0 +1,98 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+
+	"fyne.io/fyne/v2/app"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/data/binding"
+	"fyne.io/fyne/v2/widget"
+	xwidget "fyne.io/x/fyne/widget"
+)
+
+var spinnerDisabled bool
+var data binding.Float = binding.NewFloat()
+var s1 *xwidget.Spinner
+var s5 *xwidget.Spinner
+var bs *widget.Button
+
+func main() {
+	a := app.New()
+
+	ls1 := widget.NewLabel("Value set in Spinner 1:")
+	s1ValueLabel := widget.NewLabel("")
+	ls2 := widget.NewLabel("Data value bound to Spinner 2:")
+	dataValueLabel := widget.NewLabel("")
+	data.AddListener(binding.NewDataListener(func() {
+		val, err := data.Get()
+		if err != nil {
+			return
+		}
+		dataValueLabel.Text = fmt.Sprintf("%d", int(val))
+		dataValueLabel.Refresh()
+	}))
+
+	ls5 := widget.NewLabel("Value set in Spinner 5:")
+	s5ValueLabel := widget.NewLabel("")
+	floatData := binding.NewFloat()
+	floatData.AddListener(binding.NewDataListener(func() {
+		val, err := floatData.Get()
+		if err != nil {
+			return
+		}
+		s5ValueLabel.Text = strconv.FormatFloat(val, 'f', 3, 64)
+		s5ValueLabel.Refresh()
+	}))
+	c6 := container.NewHBox(ls5, s5ValueLabel)
+
+	c2 := container.NewGridWithColumns(2, ls1, s1ValueLabel, ls2, dataValueLabel)
+	l1 := widget.NewLabel("Spinner 1 (0, 100, 1, \"%d %%\"):")
+	s1 = xwidget.NewSpinner(0, 100, 1, "%d %%", nil)
+	s1.OnChanged = func(val float64) {
+		s1ValueLabel.Text = fmt.Sprintf("%d %%", int(s1.GetValue()))
+		s1ValueLabel.Refresh()
+	}
+	// OnChanged has to be called here to display initial value in s1ValueLabel.
+	s1.OnChanged(s1.GetValue())
+	l2 := widget.NewLabel("Spinner 2 With Data (-2, 16, 3, \"%+d\"):")
+	s2 := xwidget.NewSpinnerWithData(-2, 16, 3, "%+d", data)
+	c := container.NewGridWithColumns(2, l1, s1)
+	c1 := container.NewHBox(l2, s2)
+	l3 := widget.NewLabel("Uninitialized Spinner 3:")
+	s3 := xwidget.NewSpinnerUninitialized("%d")
+	c3 := container.NewHBox(l3, s3)
+	b := widget.NewButton("Disable Spinner 1", func() {})
+	b.OnTapped = func() {
+		spinnerDisabled = !spinnerDisabled
+		if spinnerDisabled {
+			s1.Disable()
+			b.SetText("Enable Spinner 1")
+		} else {
+			s1.Enable()
+			b.SetText("Disable Spinner 1")
+		}
+	}
+	bs = widget.NewButton("Initialize Spinner 3", func() {
+		s3.SetMinMaxStep(1, 10, 1)
+		l3.Text = "Initialized Spinner 3 (1, 10, 1, \"%d\"):"
+		l3.Refresh()
+		s3.Enable()
+		bs.Disable()
+	})
+	bs1 := widget.NewButton("Set Spinner 1 to 5", func() { s1.SetValue(5) })
+	bs2 := widget.NewButton("Set Spinner 3 bound value to 12", func() { data.Set(12) })
+
+	l4 := widget.NewLabel("Spinner 4 (-1., 400., 10.3, \"%+.1f\"):")
+	s4 := xwidget.NewSpinner(-1., 400., 10.3, "%.1f", nil)
+	c4 := container.NewHBox(l4, s4)
+
+	l5 := widget.NewLabel("Spinner 5 (0., 16., 3.215, \"%.2f\")")
+	s5 = xwidget.NewSpinnerWithData(0., 16., 3.215, "%.2f", floatData)
+	c5 := container.NewHBox(l5, s5)
+
+	v := container.NewVBox(c, c1, c3, b, bs, c2, bs1, bs2, c4, c5, c6)
+	w := a.NewWindow("SpinnerDemo")
+	w.SetContent(v)
+	w.ShowAndRun()
+}

widget/binder_helper.go

@@ -0,0 +1,79 @@
+package widget
+
+// This file is a direct copy of widget/binder_helper.go in fyne version 2.5.3.
+
+import (
+	"sync"
+	"sync/atomic"
+
+	"fyne.io/fyne/v2/data/binding"
+)
+
+// basicBinder stores a DataItem and a function to be called when it changes.
+// It provides a convenient way to replace data and callback independently.
+type basicBinder struct {
+	callback atomic.Pointer[func(binding.DataItem)]
+
+	dataListenerPairLock sync.RWMutex
+	dataListenerPair     annotatedListener // access guarded by dataListenerPairLock
+}
+
+// Bind replaces the data item whose changes are tracked by the callback function.
+func (binder *basicBinder) Bind(data binding.DataItem) {
+	listener := binding.NewDataListener(func() { // NB: listener captures `data` but always calls the up-to-date callback
+		f := binder.callback.Load()
+		if f == nil || *f == nil {
+			return
+		}
+
+		(*f)(data)
+	})
+	data.AddListener(listener)
+	listenerInfo := annotatedListener{
+		data:     data,
+		listener: listener,
+	}
+
+	binder.dataListenerPairLock.Lock()
+	binder.unbindLocked()
+	binder.dataListenerPair = listenerInfo
+	binder.dataListenerPairLock.Unlock()
+}
+
+// CallWithData passes the currently bound data item as an argument to the
+// provided function.
+func (binder *basicBinder) CallWithData(f func(data binding.DataItem)) {
+	binder.dataListenerPairLock.RLock()
+	data := binder.dataListenerPair.data
+	binder.dataListenerPairLock.RUnlock()
+	f(data)
+}
+
+// SetCallback replaces the function to be called when the data changes.
+func (binder *basicBinder) SetCallback(f func(data binding.DataItem)) {
+	binder.callback.Store(&f)
+}
+
+// Unbind requests the callback to be no longer called when the previously bound
+// data item changes.
+func (binder *basicBinder) Unbind() {
+	binder.dataListenerPairLock.Lock()
+	binder.unbindLocked()
+	binder.dataListenerPairLock.Unlock()
+}
+
+// unbindLocked expects the caller to hold dataListenerPairLock.
+func (binder *basicBinder) unbindLocked() {
+	previousListener := binder.dataListenerPair
+	binder.dataListenerPair = annotatedListener{nil, nil}
+
+	if previousListener.listener == nil || previousListener.data == nil {
+		return
+	}
+	previousListener.data.RemoveListener(previousListener.listener)
+}
+
+type annotatedListener struct {
+	data     binding.DataItem
+	listener binding.DataListener
+}