8862537525

Committed 27 Apr 2024 08:56PM UTC coverage: 64.85%. First build

Build # 8862537525

Build Type

Pull #4813

github

Committed by

adamantike

Commit Message

feat: Allow setting custom Layout paddings

Introduce a `LayoutOption` concept, and allow setting custom paddings
for a Layout. The `BaseLayout` struct implements the default paddings
retrieval, to reduce the amount of changes required by project
maintainers to comply with the new interface methods.

This change uses the Option pattern in case other customizations can be
added to Layouts in the future, without changing the public API.

Main motivation for this change has been Supersonic needing to copy the
entire Vbox/Hbox implementation, just to add custom paddings [1]. Also
related to feature request #1031.

[1] https://github.com/dweymouth/supersonic/blob/02d4082f3/ui/layouts/hboxcustompadding.go

Pull Request Pull Request #4813: feat: Allow setting custom Layout paddings

Run Details

106 of 142 new or added lines in 13 files covered. (74.65%)

24235 of 37371 relevant lines covered (64.85%)

777.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.72

/layout/boxlayout.go

package layout

import (
        "fyne.io/fyne/v2"
)

// NewVBoxLayout returns a vertical box layout for stacking a number of child
// canvas objects or widgets top to bottom. The objects are always displayed
// at their vertical MinSize. Use a different layout if the objects are intended
// to be larger then their vertical MinSize.
func NewVBoxLayout(options ...LayoutOption) fyne.Layout {
        l := &vBoxLayout{}
        for _, option := range options {
                option(l)
        }
        return l
}

// NewHBoxLayout returns a horizontal box layout for stacking a number of child
// canvas objects or widgets left to right. The objects are always displayed
// at their horizontal MinSize. Use a different layout if the objects are intended
// to be larger then their horizontal MinSize.
func NewHBoxLayout(options ...LayoutOption) fyne.Layout {
        l := &hBoxLayout{}
        for _, option := range options {
                option(l)
        }
        return l
}

// Declare conformity with Layout interface
var _ fyne.Layout = (*vBoxLayout)(nil)

type vBoxLayout struct {
        BaseLayout
}

// Layout is called to pack all child objects into a specified size.
// This will pack objects into a single column where each item
// is full width but the height is the minimum required.
// Any spacers added will pad the view, sharing the space if there are two or more.
func (v vBoxLayout) Layout(objects []fyne.CanvasObject, size fyne.Size) {
        spacers := 0
        visibleObjects := 0
        // Size taken up by visible objects
        total := float32(0)

        for _, child := range objects {
                if !child.Visible() {
                        continue
                }

                if isVerticalSpacer(child) {
                        spacers++
                        continue
                }

                visibleObjects++
                total += child.MinSize().Height
        }

        topPadding, _, _, _ := v.GetPaddings()

        // Amount of space not taken up by visible objects and inter-object padding
        extra := size.Height - total - (topPadding * float32(visibleObjects-1))

        // Spacers split extra space equally
        spacerSize := float32(0)
        if spacers > 0 {
                spacerSize = extra / float32(spacers)
        }

        x, y := float32(0), float32(0)
        for _, child := range objects {
                if !child.Visible() {
                        continue
                }

                if isVerticalSpacer(child) {
                        y += spacerSize
                        continue
                }
                child.Move(fyne.NewPos(x, y))

                height := child.MinSize().Height
                y += topPadding + height
                child.Resize(fyne.NewSize(size.Width, height))
        }
}

// MinSize finds the smallest size that satisfies all the child objects.
// For a BoxLayout this is the width of the widest item and the height is
// the sum of of all children combined with padding between each.
func (v vBoxLayout) MinSize(objects []fyne.CanvasObject) fyne.Size {
        minSize := fyne.NewSize(0, 0)
        addPadding := false
        topPadding, _, _, _ := v.GetPaddings()
        for _, child := range objects {
                if !child.Visible() || isVerticalSpacer(child) {
                        continue
                }

                childMin := child.MinSize()
                minSize.Width = fyne.Max(childMin.Width, minSize.Width)
                minSize.Height += childMin.Height
                if addPadding {
                        minSize.Height += topPadding
                }
                addPadding = true
        }
        return minSize
}

// Declare conformity with Layout interface
var _ fyne.Layout = (*hBoxLayout)(nil)

type hBoxLayout struct {
        BaseLayout
}

// Layout is called to pack all child objects into a specified size.
// For a VBoxLayout this will pack objects into a single column where each item
// is full width but the height is the minimum required.
// Any spacers added will pad the view, sharing the space if there are two or more.
func (g hBoxLayout) Layout(objects []fyne.CanvasObject, size fyne.Size) {
        spacers := 0
        visibleObjects := 0
        // Size taken up by visible objects
        total := float32(0)

        for _, child := range objects {
                if !child.Visible() {
                        continue
                }

                if isHorizontalSpacer(child) {
                        spacers++
                        continue
                }

                visibleObjects++
                total += child.MinSize().Width
        }

        _, _, leftPadding, _ := g.GetPaddings()

        // Amount of space not taken up by visible objects and inter-object padding
        extra := size.Width - total - (leftPadding * float32(visibleObjects-1))

        // Spacers split extra space equally
        spacerSize := float32(0)
        if spacers > 0 {
                spacerSize = extra / float32(spacers)
        }

        x, y := float32(0), float32(0)
        for _, child := range objects {
                if !child.Visible() {
                        continue
                }

                if isHorizontalSpacer(child) {
                        x += spacerSize
                        continue
                }
                child.Move(fyne.NewPos(x, y))

                width := child.MinSize().Width
                x += leftPadding + width
                child.Resize(fyne.NewSize(width, size.Height))
        }
}

// MinSize finds the smallest size that satisfies all the child objects.
// For a BoxLayout this is the width of the widest item and the height is
// the sum of of all children combined with padding between each.
func (g hBoxLayout) MinSize(objects []fyne.CanvasObject) fyne.Size {
        minSize := fyne.NewSize(0, 0)
        addPadding := false
        _, _, leftPadding, _ := g.GetPaddings()
        for _, child := range objects {
                if !child.Visible() || isHorizontalSpacer(child) {
                        continue
                }

                childMin := child.MinSize()
                minSize.Height = fyne.Max(childMin.Height, minSize.Height)
                minSize.Width += childMin.Width
                if addPadding {
                        minSize.Width += leftPadding
                }
                addPadding = true
        }
        return minSize
}

func isVerticalSpacer(obj fyne.CanvasObject) bool {
        spacer, ok := obj.(SpacerObject)
        return ok && spacer.ExpandVertical()
}

func isHorizontalSpacer(obj fyne.CanvasObject) bool {
        spacer, ok := obj.(SpacerObject)
        return ok && spacer.ExpandHorizontal()
}

1	package layout
2
3	import (
4	"fyne.io/fyne/v2"
5	)
6
7	// NewVBoxLayout returns a vertical box layout for stacking a number of child
8	// canvas objects or widgets top to bottom. The objects are always displayed
9	// at their vertical MinSize. Use a different layout if the objects are intended
10	// to be larger then their vertical MinSize.
11	func NewVBoxLayout(options ...LayoutOption) fyne.Layout {	6✔
12	l := &vBoxLayout{}	6✔
13	for _, option := range options {	6✔
NEW 14	option(l)	×
NEW 15	}	×
16	return l	6✔
17	}
18
19	// NewHBoxLayout returns a horizontal box layout for stacking a number of child
20	// canvas objects or widgets left to right. The objects are always displayed
21	// at their horizontal MinSize. Use a different layout if the objects are intended
22	// to be larger then their horizontal MinSize.
23	func NewHBoxLayout(options ...LayoutOption) fyne.Layout {	7✔
24	l := &hBoxLayout{}	7✔
25	for _, option := range options {	7✔
NEW 26	option(l)	×
NEW 27	}	×
28	return l	7✔
29	}
30
31	// Declare conformity with Layout interface
32	var _ fyne.Layout = (*vBoxLayout)(nil)
33
34	type vBoxLayout struct {
35	BaseLayout
36	}
37
38	// Layout is called to pack all child objects into a specified size.
39	// This will pack objects into a single column where each item
40	// is full width but the height is the minimum required.
41	// Any spacers added will pad the view, sharing the space if there are two or more.
42	func (v vBoxLayout) Layout(objects []fyne.CanvasObject, size fyne.Size) {	6✔
43	spacers := 0	6✔
44	visibleObjects := 0	6✔
45	// Size taken up by visible objects	6✔
46	total := float32(0)	6✔
47		6✔
48	for _, child := range objects {	26✔
49	if !child.Visible() {	21✔
50	continue	1✔
51	}
52
53	if isVerticalSpacer(child) {	21✔
54	spacers++	2✔
55	continue	2✔
56	}
57
58	visibleObjects++	17✔
59	total += child.MinSize().Height	17✔
60	}
61
62	topPadding, _, _, _ := v.GetPaddings()	6✔
63		6✔
64	// Amount of space not taken up by visible objects and inter-object padding	6✔
65	extra := size.Height - total - (topPadding * float32(visibleObjects-1))	6✔
66		6✔
67	// Spacers split extra space equally	6✔
68	spacerSize := float32(0)	6✔
69	if spacers > 0 {	8✔
70	spacerSize = extra / float32(spacers)	2✔
71	}	2✔
72
73	x, y := float32(0), float32(0)	6✔
74	for _, child := range objects {	26✔
75	if !child.Visible() {	21✔
76	continue	1✔
77	}
78
79	if isVerticalSpacer(child) {	21✔
80	y += spacerSize	2✔
81	continue	2✔
82	}
83	child.Move(fyne.NewPos(x, y))	17✔
84		17✔
85	height := child.MinSize().Height	17✔
86	y += topPadding + height	17✔
87	child.Resize(fyne.NewSize(size.Width, height))	17✔
88	}
89	}
90
91	// MinSize finds the smallest size that satisfies all the child objects.
92	// For a BoxLayout this is the width of the widest item and the height is
93	// the sum of of all children combined with padding between each.
94	func (v vBoxLayout) MinSize(objects []fyne.CanvasObject) fyne.Size {	9✔
95	minSize := fyne.NewSize(0, 0)	9✔
96	addPadding := false	9✔
97	topPadding, _, _, _ := v.GetPaddings()	9✔
98	for _, child := range objects {	38✔
99	if !child.Visible() \|\| isVerticalSpacer(child) {	33✔
100	continue	4✔
101	}
102
103	childMin := child.MinSize()	25✔
104	minSize.Width = fyne.Max(childMin.Width, minSize.Width)	25✔
105	minSize.Height += childMin.Height	25✔
106	if addPadding {	41✔
107	minSize.Height += topPadding	16✔
108	}	16✔
109	addPadding = true	25✔
110	}
111	return minSize	9✔
112	}
113
114	// Declare conformity with Layout interface
115	var _ fyne.Layout = (*hBoxLayout)(nil)
116
117	type hBoxLayout struct {
118	BaseLayout
119	}
120
121	// Layout is called to pack all child objects into a specified size.
122	// For a VBoxLayout this will pack objects into a single column where each item
123	// is full width but the height is the minimum required.
124	// Any spacers added will pad the view, sharing the space if there are two or more.
125	func (g hBoxLayout) Layout(objects []fyne.CanvasObject, size fyne.Size) {	8✔
126	spacers := 0	8✔
127	visibleObjects := 0	8✔
128	// Size taken up by visible objects	8✔
129	total := float32(0)	8✔
130		8✔
131	for _, child := range objects {	36✔
132	if !child.Visible() {	30✔
133	continue	2✔
134	}
135
136	if isHorizontalSpacer(child) {	30✔
137	spacers++	4✔
138	continue	4✔
139	}
140
141	visibleObjects++	22✔
142	total += child.MinSize().Width	22✔
143	}
144
145	_, _, leftPadding, _ := g.GetPaddings()	8✔
146		8✔
147	// Amount of space not taken up by visible objects and inter-object padding	8✔
148	extra := size.Width - total - (leftPadding * float32(visibleObjects-1))	8✔
149		8✔
150	// Spacers split extra space equally	8✔
151	spacerSize := float32(0)	8✔
152	if spacers > 0 {	12✔
153	spacerSize = extra / float32(spacers)	4✔
154	}	4✔
155
156	x, y := float32(0), float32(0)	8✔
157	for _, child := range objects {	36✔
158	if !child.Visible() {	30✔
159	continue	2✔
160	}
161
162	if isHorizontalSpacer(child) {	30✔
163	x += spacerSize	4✔
164	continue	4✔
165	}
166	child.Move(fyne.NewPos(x, y))	22✔
167		22✔
168	width := child.MinSize().Width	22✔
169	x += leftPadding + width	22✔
170	child.Resize(fyne.NewSize(width, size.Height))	22✔
171	}
172	}
173
174	// MinSize finds the smallest size that satisfies all the child objects.
175	// For a BoxLayout this is the width of the widest item and the height is
176	// the sum of of all children combined with padding between each.
177	func (g hBoxLayout) MinSize(objects []fyne.CanvasObject) fyne.Size {	9✔
178	minSize := fyne.NewSize(0, 0)	9✔
179	addPadding := false	9✔
180	_, _, leftPadding, _ := g.GetPaddings()	9✔
181	for _, child := range objects {	38✔
182	if !child.Visible() \|\| isHorizontalSpacer(child) {	33✔
183	continue	4✔
184	}
185
186	childMin := child.MinSize()	25✔
187	minSize.Height = fyne.Max(childMin.Height, minSize.Height)	25✔
188	minSize.Width += childMin.Width	25✔
189	if addPadding {	41✔
190	minSize.Width += leftPadding	16✔
191	}	16✔
192	addPadding = true	25✔
193	}
194	return minSize	9✔
195	}
196
197	func isVerticalSpacer(obj fyne.CanvasObject) bool {	65✔
198	spacer, ok := obj.(SpacerObject)	65✔
199	return ok && spacer.ExpandVertical()	65✔
200	}	65✔
201
202	func isHorizontalSpacer(obj fyne.CanvasObject) bool {	79✔
203	spacer, ok := obj.(SpacerObject)	79✔
204	return ok && spacer.ExpandHorizontal()	79✔
205	}	79✔

fyne-io / fyne / 8862537525

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous