add equalizer UI in settings dialog

ui/layouts/gridlayoutcustompadding.go

@@ -0,0 +1,157 @@
+package layouts
+
+// Forked from fyne.io/fyne/v2/layout/gridlayout.go
+
+import (
+	"math"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/theme"
+)
+
+// Declare conformity with Layout interface
+var _ fyne.Layout = (*gridLayout)(nil)
+
+type gridLayout struct {
+	Cols            int
+	Padding         float32
+	vertical, adapt bool
+}
+
+// NewAdaptiveGridLayout returns a new grid layout which uses columns when horizontal but rows when vertical.
+func NewAdaptiveGridLayout(rowcols int) fyne.Layout {
+	return &gridLayout{Cols: rowcols, adapt: true}
+}
+
+// NewGridLayout returns a grid layout arranged in a specified number of columns.
+// The number of rows will depend on how many children are in the container that uses this layout.
+func NewGridLayout(cols int) fyne.Layout {
+	return NewGridLayoutWithColumns(cols)
+}
+
+// NewGridLayoutWithColumns returns a new grid layout that specifies a column count and wrap to new rows when needed.
+func NewGridLayoutWithColumns(cols int) fyne.Layout {
+	return &gridLayout{Cols: cols}
+}
+
+// NewGridLayoutWithRows returns a new grid layout that specifies a row count that creates new rows as required.
+func NewGridLayoutWithRows(rows int) fyne.Layout {
+	return &gridLayout{Cols: rows, vertical: true}
+}
+
+func NewGridLayoutWithColumnsAndPadding(cols int, padding float32) fyne.Layout {
+	return &gridLayout{Cols: cols, Padding: padding}
+}
+
+func (g *gridLayout) horizontal() bool {
+	if g.adapt {
+		return fyne.IsHorizontal(fyne.CurrentDevice().Orientation())
+	}
+
+	return !g.vertical
+}
+
+func (g *gridLayout) countRows(objects []fyne.CanvasObject) int {
+	if g.Cols < 1 {
+		g.Cols = 1
+	}
+	count := 0
+	for _, child := range objects {
+		if child.Visible() {
+			count++
+		}
+	}
+
+	return int(math.Ceil(float64(count) / float64(g.Cols)))
+}
+
+// Get the leading (top or left) edge of a grid cell.
+// size is the ideal cell size and the offset is which col or row its on.
+func getLeading(size float64, padding float32, offset int) float32 {
+	ret := (size + float64(padding)) * float64(offset)
+
+	return float32(ret)
+}
+
+// Get the trailing (bottom or right) edge of a grid cell.
+// size is the ideal cell size and the offset is which col or row its on.
+func getTrailing(size float64, padding float32, offset int) float32 {
+	return getLeading(size, padding, offset+1) - padding
+}
+
+// Layout is called to pack all child objects into a specified size.
+// For a GridLayout this will pack objects into a table format with the number
+// of columns specified in our constructor.
+func (g *gridLayout) Layout(objects []fyne.CanvasObject, size fyne.Size) {
+	rows := g.countRows(objects)
+
+	padding := theme.Padding() + g.Padding
+	padWidth := float32(g.Cols-1) * padding
+	padHeight := float32(rows-1) * padding
+	cellWidth := float64(size.Width-padWidth) / float64(g.Cols)
+	cellHeight := float64(size.Height-padHeight) / float64(rows)
+
+	if !g.horizontal() {
+		padWidth, padHeight = padHeight, padWidth
+		cellWidth = float64(size.Width-padWidth) / float64(rows)
+		cellHeight = float64(size.Height-padHeight) / float64(g.Cols)
+	}
+
+	row, col := 0, 0
+	i := 0
+	for _, child := range objects {
+		if !child.Visible() {
+			continue
+		}
+
+		x1 := getLeading(cellWidth, padding, col)
+		y1 := getLeading(cellHeight, padding, row)
+		x2 := getTrailing(cellWidth, padding, col)
+		y2 := getTrailing(cellHeight, padding, row)
+
+		child.Move(fyne.NewPos(x1, y1))
+		child.Resize(fyne.NewSize(x2-x1, y2-y1))
+
+		if g.horizontal() {
+			if (i+1)%g.Cols == 0 {
+				row++
+				col = 0
+			} else {
+				col++
+			}
+		} else {
+			if (i+1)%g.Cols == 0 {
+				col++
+				row = 0
+			} else {
+				row++
+			}
+		}
+		i++
+	}
+}
+
+// MinSize finds the smallest size that satisfies all the child objects.
+// For a GridLayout this is the size of the largest child object multiplied by
+// the required number of columns and rows, with appropriate padding between
+// children.
+func (g *gridLayout) MinSize(objects []fyne.CanvasObject) fyne.Size {
+	rows := g.countRows(objects)
+	minSize := fyne.NewSize(0, 0)
+	for _, child := range objects {
+		if !child.Visible() {
+			continue
+		}
+
+		minSize = minSize.Max(child.MinSize())
+	}
+
+	padding := theme.Padding() + g.Padding
+	if g.horizontal() {
+		minContentSize := fyne.NewSize(minSize.Width*float32(g.Cols), minSize.Height*float32(rows))
+		return minContentSize.Add(fyne.NewSize(padding*fyne.Max(float32(g.Cols-1), 0), padding*fyne.Max(float32(rows-1), 0)))
+	}
+
+	minContentSize := fyne.NewSize(minSize.Width*float32(rows), minSize.Height*float32(g.Cols))
+	return minContentSize.Add(fyne.NewSize(padding*fyne.Max(float32(rows-1), 0), padding*fyne.Max(float32(g.Cols-1), 0)))
+}