Dynamic number of widgets in a container

[Pitrified]

Hello,

I'm trying to create a layout with a dynamic number of widgets in it.
The number of widgets will be small and will change slowly, being able to do so at startup would be ok if needed.

An app like this does what I need, except for the hard coded layout of course:

package main

import (
	"fmt"

	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/widget"
)

func main() {

	a := app.New()
	w := a.NewWindow("Hello")

	// create the buttons
	someButtons := make([]*widget.Button, 5)
	for i := range someButtons {
		i := i // save local copy to use in closure
		someButtons[i] = widget.NewButton(
			fmt.Sprintf("B%d", i),
			func() { buttonCB(i) },
		)
	}

	// create a container with the buttons
	contBtn := container.NewHBox(
		someButtons[0],
		someButtons[1],
		someButtons[2],
		someButtons[3],
		someButtons[4],
	)

	w.SetContent(contBtn)
	w.ShowAndRun()

}

// Clicked one of the buttons.
func buttonCB(whichBtn int) {
	fmt.Printf("Clicked %d\n", whichBtn)
}

I tried something like this:

container.NewHBox(someButtons...)

but I get the following error: cannot use someButtons (variable of type []*"fyne.io/fyne/v2/widget".Button) as []fyne.CanvasObject value in argument to container.NewHBox.

Is there a workaround?

Thank you very much,
Peter

[Jacalz]

The typing system in Go does unfortunately not seem to be smart enough to tell that a slice of a fyne.Widgets also is a slice of fyne.CanvasObject. To make it work, you can change your button slice to use fyne.CanvasObject.

[Pitrified]

Thank you very much for your answer, it pointed me in the direction of a solution I rather like.

The slice of CanvasObject does work as advertised:

someCO := make([]fyne.CanvasObject, 5)
for i := range someCO {
    i := i // save local copy to use in closure
    someCO[i] = widget.NewButton(fmt.Sprintf("CO%d", i), func() { buttonCB(i) })
}
contCOBtn := container.NewHBox(someCO...)

but then trying to access a button-specific field fails, requiring a type assertion:

// fails:
// someCO[0].Importance undefined (type fyne.CanvasObject has no field or method Importance)
someCO[0].Importance = widget.HighImportance

// works
someCO[1].(*widget.Button).Importance = widget.HighImportance

Rather than declaring the slice as a []fyne.CanvasObject, we can keep it as a slice of buttons, and implement a function that does the conversion to CanvasObject before packing the widgets.
Using generics we can let any - wait for it - CanvasObject be a valid input to the function:

func NewHBoxGen[T fyne.CanvasObject](objects ...T) *fyne.Container {
	objCO := make([]fyne.CanvasObject, len(objects))
	for i := range objCO {
		objCO[i] = fyne.CanvasObject(objects[i])
	}
	return container.NewHBox(objCO...)
}

and just use it directly as the type arg is inferred:

contBtn := NewHBoxGen(someButtons...)

someLabels := make([]*widget.Label, 5)
for i := range someLabels {
    someLabels[i] = widget.NewLabel(fmt.Sprintf("L%d", i))
}
contLab := NewHBoxGen(someLabels...)

By moving the conversion in a helper function we can easily extend this behaviour to all the containers:

func toCO[T fyne.CanvasObject](objects ...T) []fyne.CanvasObject {
	objCO := make([]fyne.CanvasObject, len(objects))
	for i := range objCO {
		objCO[i] = fyne.CanvasObject(objects[i])
	}
	return objCO
}

func NewHBoxGen[T fyne.CanvasObject](objects ...T) *fyne.Container {
	return container.NewHBox(toCO(objects...)...)
}

func NewVBoxGen[T fyne.CanvasObject](objects ...T) *fyne.Container {
	return container.NewVBox(toCO(objects...)...)
}

Or you can call the helper function directly:

contBtn := container.NewHBox(toCO(someButtons...)...)

There is a small overhead related to the slice conversion, but as I said in my use case the slices are short and stable, so I'm quite happy with this solution, so thank you again.

Cheers!

[andydotxyz]

There is nothing wrong with the type assertion, your code knows that it will not fail.
It is more common to reference single widgets in a typed variable and aggregate to a []fyne.CanvasObject only to pass to the container. There are not that many usages where you want to index into a slice of generic objects to work on a widget state.

The helper method you describe would require twice as much memory as the type conversion does, though you can certainly have that in your code if you find it useful. Because we support older Go versions it is not possible to use generics in any Fyne code at this time (or in the near future).

[Pitrified]

The type assertion looked weird to me so it's good to know it's a valid pattern, thank you