Add RowWrap layout

Author: ErikKalkoken

layout/rowwrap.go

@@ -0,0 +1,72 @@
+package layout
+
+import (
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/theme"
+)
+
+type rowWrapLayout struct {
+	rowCount int
+}
+
+// NewRowWrapLayout returns a layout that dynamically arranges objects
+// with the same height in rows and wraps them as necessary.
+//
+// Object visibility is supported.
+//
+// Since: 2.7
+func NewRowWrapLayout() *rowWrapLayout {
+	return &rowWrapLayout{}
+}
+
+var _ fyne.Layout = (*rowWrapLayout)(nil)
+
+func (l *rowWrapLayout) MinSize(objects []fyne.CanvasObject) fyne.Size {
+	if len(objects) == 0 {
+		return fyne.NewSize(0, 0)
+	}
+	rows := l.rowCount
+	if rows == 0 {
+		rows = 1
+	}
+	rowHeight := objects[0].MinSize().Height
+	var w float32
+	for _, o := range objects {
+		size := o.MinSize()
+		w = max(w, size.Width)
+	}
+	s := fyne.NewSize(w, rowHeight*float32(rows)+theme.Padding()*float32(rows-1))
+	return s
+}
+
+func (l *rowWrapLayout) Layout(objects []fyne.CanvasObject, containerSize fyne.Size) {
+	if len(objects) == 0 {
+		return
+	}
+	padding := theme.Padding()
+	rowHeight := objects[0].MinSize().Height
+	pos := fyne.NewPos(0, 0)
+	rows := 1
+	for _, o := range objects {
+		if !o.Visible() {
+			continue
+		}
+		size := o.MinSize()
+		o.Resize(size)
+		w := size.Width + padding
+		if pos.X+w > containerSize.Width {
+			pos = fyne.NewPos(0, float32(rows)*(rowHeight+padding))
+			rows++
+		}
+		o.Move(pos)
+		pos = pos.Add(fyne.NewPos(w, 0))
+	}
+	l.rowCount = rows
+}
+
+func max(a, b float32) float32 {
+	if a < b {
+		return b
+	}
+	return a
+}

layout/rowwrap_test.go

@@ -0,0 +1,133 @@
+package layout_test
+
+import (
+	"image/color"
+	"testing"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/layout"
+	"fyne.io/fyne/v2/theme"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRowWrapLayout_Layout(t *testing.T) {
+	t.Run("should arrange objects in a row and wrap overflow objects into next row", func(t *testing.T) {
+		// given
+		h := float32(10)
+		o1 := canvas.NewRectangle(color.Opaque)
+		o1.SetMinSize(fyne.NewSize(30, h))
+		o2 := canvas.NewRectangle(color.Opaque)
+		o2.SetMinSize(fyne.NewSize(80, h))
+		o3 := canvas.NewRectangle(color.Opaque)
+		o3.SetMinSize(fyne.NewSize(50, h))
+
+		containerSize := fyne.NewSize(125, 125)
+		container := &fyne.Container{
+			Objects: []fyne.CanvasObject{o1, o2, o3},
+		}
+		container.Resize(containerSize)
+
+		// when
+		layout.NewRowWrapLayout().Layout(container.Objects, containerSize)
+
+		// then
+		p := theme.Padding()
+		assert.Equal(t, fyne.NewPos(0, 0), o1.Position())
+		assert.Equal(t, fyne.NewPos(o1.Size().Width+p, 0), o2.Position())
+		assert.Equal(t, fyne.NewPos(0, o1.Size().Height+p), o3.Position())
+	})
+	t.Run("should do nothing when container is empty", func(t *testing.T) {
+		containerSize := fyne.NewSize(125, 125)
+		container := &fyne.Container{}
+		container.Resize(containerSize)
+
+		// when
+		layout.NewRowWrapLayout().Layout(container.Objects, containerSize)
+	})
+	t.Run("should ignore hidden objects", func(t *testing.T) {
+		// given
+		h := float32(10)
+		o1 := canvas.NewRectangle(color.Opaque)
+		o1.SetMinSize(fyne.NewSize(30, h))
+		o2 := canvas.NewRectangle(color.Opaque)
+		o2.SetMinSize(fyne.NewSize(80, h))
+		o2.Hide()
+		o3 := canvas.NewRectangle(color.Opaque)
+		o3.SetMinSize(fyne.NewSize(50, h))
+
+		containerSize := fyne.NewSize(125, 125)
+		container := &fyne.Container{
+			Objects: []fyne.CanvasObject{o1, o2, o3},
+		}
+		container.Resize(containerSize)
+
+		// when
+		layout.NewRowWrapLayout().Layout(container.Objects, containerSize)
+
+		// then
+		p := theme.Padding()
+		assert.Equal(t, fyne.NewPos(0, 0), o1.Position())
+		assert.Equal(t, fyne.NewPos(o1.Size().Width+p, 0), o3.Position())
+	})
+}
+
+func TestRowWrapLayout_MinSize(t *testing.T) {
+	t.Run("should return min size of single object when container has only one", func(t *testing.T) {
+		// given
+		o := canvas.NewRectangle(color.Opaque)
+		o.SetMinSize(fyne.NewSize(10, 10))
+		container := container.NewWithoutLayout(o)
+		layout := layout.NewRowWrapLayout()
+
+		// when/then
+		minSize := layout.MinSize(container.Objects)
+
+		// then
+		assert.Equal(t, o.MinSize(), minSize)
+	})
+	t.Run("should return size 0 when container is empty", func(t *testing.T) {
+		// given
+		container := container.NewWithoutLayout()
+		layout := layout.NewRowWrapLayout()
+
+		// when/then
+		minSize := layout.MinSize(container.Objects)
+
+		// then
+		assert.Equal(t, fyne.NewSize(0, 0), minSize)
+	})
+	t.Run("should initially return height of first object and width of widest object", func(t *testing.T) {
+		// given
+		h := float32(10)
+		o1 := canvas.NewRectangle(color.Opaque)
+		o1.SetMinSize(fyne.NewSize(10, h))
+		o2 := canvas.NewRectangle(color.Opaque)
+		o2.SetMinSize(fyne.NewSize(20, h))
+		container := container.NewWithoutLayout(o1, o2)
+		layout := layout.NewRowWrapLayout()
+
+		// when/then
+		minSize := layout.MinSize(container.Objects)
+
+		// then
+		assert.Equal(t, fyne.NewSize(20, h), minSize)
+	})
+	t.Run("should return height of arranged objects after layout was calculated", func(t *testing.T) {
+		// given
+		h := float32(10)
+		o1 := canvas.NewRectangle(color.Opaque)
+		o1.SetMinSize(fyne.NewSize(10, h))
+		o2 := canvas.NewRectangle(color.Opaque)
+		o2.SetMinSize(fyne.NewSize(20, h))
+		container := container.New(layout.NewRowWrapLayout(), o1, o2)
+		container.Resize(fyne.NewSize(15, 50))
+
+		// when/then
+		minSize := container.MinSize()
+
+		// then
+		assert.Equal(t, fyne.NewSize(o2.Size().Width, (o1.Size().Height*2)+theme.Padding()), minSize)
+	})
+}