Merge.

Author: rj

align.go

@@ -87,18 +87,7 @@ func (*alignElement) Kind() *base.Kind {
 }
 
 func (w *alignElement) Layout(bc base.Constraints) base.Size {
-	if w.child == nil {
-		size := base.Size{}
-		if bc.HasBoundedWidth() {
-			size.Width = base.Inf
-		}
-		if bc.HasBoundedHeight() {
-			size.Height = base.Inf
-		}
-		return bc.Constrain(size)
-	}
-
-	size := w.child.Layout(bc.Loosen())
+	size := base.Layout(w.child, bc.Loosen())
 	w.childSize = size
 	if w.widthFactor > 0 {
 		size.Width = base.Length(float64(size.Width) * w.widthFactor)

base/constraints.go

@@ -1,7 +1,7 @@
 package base
 
 const (
-	// Inf is a sentinel value indicating an unbounded width or height.
+	// Inf is a sentinel value indicating an unbounded (or infinite) length.
 	Inf Length = 0x7fffffff
 )
 
@@ -30,31 +30,32 @@ func max(a, b Length) Length {
 //
 // A sentinel value can be used to indicate that the maximum size for a
 // dimension is infinite.  The constraints on that dimension are called
-// 'unbounded'.  If the constraints on a dimension are both tight and unbounded,
-// the dimension is 'expanding'.
+// 'unbounded'.
 //
 // (This type is similar to BoxConstraints type in flutter library rendering)
 type Constraints struct {
 	Min, Max Size
 }
 
-// Expand creates box constraints that force elements to expand to as large as
-// possible.  The constraints for both width and height will be tight and
+// Expand creates box constraints that allows elements to expand to as large as
+// possible.  The constraints for both width and height will be loose and
 // unbounded.
 func Expand() Constraints {
-	return Constraints{Size{Inf, Inf}, Size{Inf, Inf}}
+	return Constraints{Size{0, 0}, Size{Inf, Inf}}
 }
 
 // ExpandHeight creates box constraints with a fixed width and that forces
-// elements to expand to as high as possible.
+// elements to expand to as high as possible.  The constraint for width will
+// be tight.  The constraint for height will be loose and unbounded.
 func ExpandHeight(width Length) Constraints {
-	return Constraints{Size{width, Inf}, Size{width, Inf}}
+	return Constraints{Size{width, 0}, Size{width, Inf}}
 }
 
 // ExpandWidth creates box constraints with a fixed height and that forces
-// elements to expand to as wide as possible.
+// elements to expand to as wide as possible.  The constraint for width will
+// be loose and unbounded.  The constraint for height will be tight.
 func ExpandWidth(height Length) Constraints {
-	return Constraints{Size{Inf, height}, Size{Inf, height}}
+	return Constraints{Size{0, height}, Size{Inf, height}}
 }
 
 // Loose creates box constraints that forbid sizes larger than the given size.
@@ -198,12 +199,15 @@ func (bc Constraints) IsNormalized() bool {
 }
 
 // IsSatisfiedBy returns true if the passed size satisfies the both the width
-// and height constraints.
+// and height constraints.  Additionally, both width and height must be finite
+// (i.e. not equal to the sentinal value Inf).
 func (bc Constraints) IsSatisfiedBy(size Size) bool {
 	return bc.Min.Width <= size.Width &&
 		size.Width <= bc.Max.Width &&
 		bc.Min.Height <= size.Height &&
-		size.Height <= bc.Max.Height
+		size.Height <= bc.Max.Height &&
+		size.Width != Inf &&
+		size.Height != Inf
 }
 
 // IsTight returns true if both the width and height are tightly constrained.

base/constraints_test.go

@@ -10,9 +10,9 @@ func TestConstraints(t *testing.T) {
 		isNormalized, isTight, hasTightWidth, hasTightHeight bool
 		isBounded, hasBoundedWidth, hasBoundedHeight         bool
 	}{
-		{Expand(), true, true, true, true, false, false, false},
-		{ExpandHeight(10 * DIP), true, true, true, true, false, true, false},
-		{ExpandWidth(10 * DIP), true, true, true, true, false, false, true},
+		{Expand(), true, false, false, false, false, false, false},
+		{ExpandHeight(10 * DIP), true, false, true, false, false, true, false},
+		{ExpandWidth(10 * DIP), true, false, false, true, false, false, true},
 		{Loose(Size{10 * DIP, 15 * DIP}), true, false, false, false, true, true, true},
 		{Tight(Size{10 * DIP, 15 * DIP}), true, true, true, true, true, true, true},
 		{TightWidth(10 * DIP), true, false, true, false, false, true, false},
@@ -202,21 +202,23 @@ func TestConstraints_IsSatisfiedBy(t *testing.T) {
 }
 
 func TestConstraints_Tighten(t *testing.T) {
+	size1 := Size{10 * DIP, 10 * DIP}
+
 	cases := []struct {
 		in   Constraints
 		size Size
 		out  Constraints
 		outH Constraints
 		outV Constraints
 	}{
-		{Expand(), Size{10 * DIP, 10 * DIP}, Expand(), Expand(), Expand()},
-		{ExpandHeight(10 * DIP), Size{10 * DIP, 10 * DIP}, ExpandHeight(10 * DIP), ExpandHeight(10 * DIP), ExpandHeight(10 * DIP)},
-		{ExpandWidth(10 * DIP), Size{10 * DIP, 10 * DIP}, ExpandWidth(10 * DIP), ExpandWidth(10 * DIP), ExpandWidth(10 * DIP)},
-		{Loose(Size{20 * DIP, 25 * DIP}), Size{10 * DIP, 10 * DIP}, Tight(Size{10 * DIP, 10 * DIP}), Constraints{Size{0, 10 * DIP}, Size{20 * DIP, 10 * DIP}}, Constraints{Size{10 * DIP, 0}, Size{10 * DIP, 25 * DIP}}},
+		{Expand(), size1, Tight(size1), ExpandWidth(size1.Height), ExpandHeight(size1.Width)},
+		{ExpandHeight(10 * DIP), size1, Tight(size1), Tight(size1), ExpandHeight(10 * DIP)},
+		{ExpandWidth(10 * DIP), size1, Tight(size1), ExpandWidth(10 * DIP), Tight(size1)},
+		{Loose(Size{20 * DIP, 25 * DIP}), size1, Tight(size1), Constraints{Size{0, 10 * DIP}, Size{20 * DIP, 10 * DIP}}, Constraints{Size{10 * DIP, 0}, Size{10 * DIP, 25 * DIP}}},
 		{Loose(Size{20 * DIP, 25 * DIP}), Size{30 * DIP, 30 * DIP}, Tight(Size{20 * DIP, 25 * DIP}), Constraints{Size{0, 25 * DIP}, Size{20 * DIP, 25 * DIP}}, Constraints{Size{20 * DIP, 0}, Size{20 * DIP, 25 * DIP}}},
-		{Tight(Size{10 * DIP, 15 * DIP}), Size{10 * DIP, 10 * DIP}, Tight(Size{10 * DIP, 15 * DIP}), Tight(Size{10 * DIP, 15 * DIP}), Tight(Size{10 * DIP, 15 * DIP})},
-		{TightWidth(15 * DIP), Size{10 * DIP, 10 * DIP}, Tight(Size{15 * DIP, 10 * DIP}), Tight(Size{15 * DIP, 10 * DIP}), TightWidth(15 * DIP)},
-		{TightHeight(15 * DIP), Size{10 * DIP, 10 * DIP}, Tight(Size{10 * DIP, 15 * DIP}), TightHeight(15 * DIP), Tight(Size{10 * DIP, 15 * DIP})},
+		{Tight(Size{10 * DIP, 15 * DIP}), size1, Tight(Size{10 * DIP, 15 * DIP}), Tight(Size{10 * DIP, 15 * DIP}), Tight(Size{10 * DIP, 15 * DIP})},
+		{TightWidth(15 * DIP), size1, Tight(Size{15 * DIP, 10 * DIP}), Tight(Size{15 * DIP, 10 * DIP}), TightWidth(15 * DIP)},
+		{TightHeight(15 * DIP), size1, Tight(Size{10 * DIP, 15 * DIP}), TightHeight(15 * DIP), Tight(Size{10 * DIP, 15 * DIP})},
 	}
 
 	for i, v := range cases {

base/diff.go

@@ -123,6 +123,27 @@ func DiffChildren(parent Control, lhs []Element, rhs []Widget) ([]Element, error
 	return lhs, nil
 }
 
+// Layout will layout a non-nil element, otherwise is will return a default
+// size respecting the layout contraints.
+func Layout(elem Element, bc Constraints) Size {
+	if elem == nil {
+		if bc.IsBounded() {
+			return bc.Max
+		} else if bc.HasBoundedWidth() {
+			return Size{bc.Max.Width, bc.Min.Height}
+		} else if bc.HasBoundedHeight() {
+			return Size{bc.Min.Width, bc.Max.Height}
+		}
+		return bc.Min
+	}
+
+	size := elem.Layout(bc)
+	if !bc.IsSatisfiedBy(size) {
+		panic("Error in element layout, size does not satisfy constraints")
+	}
+	return size
+}
+
 // Mount will try to mount a non-nil widget, otherwise it returns nil for the
 // element.
 func Mount(parent Control, widget Widget) (Element, error) {

base/diff_test.go

@@ -45,8 +45,8 @@ func (m *mockElement) Kind() *Kind {
 	return m.kind
 }
 
-func (m *mockElement) Layout(Constraints) Size {
-	return Size{}
+func (m *mockElement) Layout(bc Constraints) Size {
+	return bc.Constrain(Size{})
 }
 func (m *mockElement) MinIntrinsicHeight(width Length) Length {
 	return 0
@@ -288,6 +288,33 @@ func TestDiffChildren(t *testing.T) {
 	}
 }
 
+func TestLayout(t *testing.T) {
+	size1 := Size{96 * DIP, 2 * 96 * DIP}
+	cases := []struct {
+		in  Element
+		bc  Constraints
+		out Size
+	}{
+		{nil, Tight(size1), size1},
+		{nil, Loose(size1), size1},
+		{nil, TightWidth(size1.Width), Size{size1.Width, 0}},
+		{nil, TightHeight(size1.Height), Size{0, size1.Height}},
+		{nil, Expand(), Size{}},
+		{&mockElement{}, Tight(size1), size1},
+		{&mockElement{}, Loose(size1), Size{}},
+		{&mockElement{}, TightWidth(size1.Width), Size{size1.Width, 0}},
+		{&mockElement{}, TightHeight(size1.Height), Size{0, size1.Height}},
+		{&mockElement{}, Expand(), Size{}},
+	}
+
+	for i, v := range cases {
+		out := Layout(v.in, v.bc)
+		if out != v.out {
+			t.Errorf("Case %d: Returned size does not match, got %v, want %v", i, out, v.out)
+		}
+	}
+}
+
 func TestMount(t *testing.T) {
 	kind1 := NewKind("bitbucket.org/rj/goey/base.Mock1")
 	kind2 := NewKind("bitbucket.org/rj/goey/base.Mock2")

decoration.go

@@ -21,7 +21,7 @@ type Decoration struct {
 	Stroke color.RGBA  // Stroke colour used to draw outline.
 	Insets Insets      // Space between border of the decoration and the child element.
 	Radius base.Length // Radius of the widgets corners.
-	Child  base.Widget // Child.
+	Child  base.Widget // Child widget.
 }
 
 // Kind returns the concrete type for use in the Widget interface.
@@ -45,12 +45,8 @@ func (w *decorationElement) Layout(bc base.Constraints) base.Size {
 	hinset := w.insets.Left + w.insets.Right
 	vinset := w.insets.Top + w.insets.Bottom
 
-	if w.child == nil {
-		return bc.Constrain(base.Size{hinset, vinset})
-	}
-
 	innerConstraints := bc.Inset(hinset, vinset)
-	w.childSize = w.child.Layout(innerConstraints)
+	w.childSize = base.Layout(w.child, innerConstraints)
 	return base.Size{
 		w.childSize.Width + hinset,
 		w.childSize.Height + vinset,

example/controls/main.go

@@ -25,7 +25,7 @@ func main() {
 }
 
 func createWindow() error {
-	w, err := goey.NewWindow("Example", renderWindow())
+	w, err := goey.NewWindow("Controls", renderWindow())
 	if err != nil {
 		return err
 	}
@@ -39,57 +39,85 @@ func updateWindow() {
 }
 
 func renderWindow() base.Widget {
-	// Fixed part at top
-	widgets := []base.Widget{
-		&goey.Checkbox{Text: "Show text of lorem ipsum.", Value: showLorem, OnChange: func(ok bool) {
-			showLorem = ok
-			updateWindow()
-		}},
-		&goey.HR{},
-	}
-
-	// Depends
-	if showLorem {
-		widgets = append(widgets,
-			&goey.P{Text: lorem},
-		)
-	} else {
-		widgets = append(widgets,
-			&goey.P{Text: "This is a paragraph, but without much text.", Align: goey.JustifyCenter},
-			&goey.Label{Text: "Text input:"},
-			&goey.TextInput{Value: "Some input...", Placeholder: "Type some text here.  And some more.  And something really long.",
-				OnChange: func(v string) { println("text input ", v) }, OnEnterKey: func(v string) { println("t1* ", v) }},
-			&goey.Label{Text: "Password input:"},
-			&goey.TextInput{Value: "", Placeholder: "Don't share", Password: true,
-				OnChange: func(v string) { println("password input ", v) }},
-			&goey.Label{Text: "Integer input:"},
-			&goey.IntInput{Value: 3, Placeholder: "Please enter a number",
-				OnChange: func(v int64) { println("int input ", v) }},
-			&goey.Label{Text: "Date input:"},
-			&goey.DateInput{Value: time.Now().Add(24 * time.Hour),
-				OnChange: func(v time.Time) { println("date input: ", v.String()) }},
-			&goey.HR{},
-			&goey.HBox{Children: []base.Widget{
-				&goey.Button{Text: "C1", Default: true},
-				&goey.Button{Text: "C2"},
-			}},
-			&goey.HBox{Children: []base.Widget{
-				&goey.Button{Text: "D1"},
-				&goey.Button{Text: "D2", Disabled: true},
-				&goey.Button{Text: "D3"},
+	widget := &goey.Tabs{
+		Insets: goey.DefaultInsets(),
+		Children: []goey.TabItem{
+			{
+				Caption: "Input",
+				Child: &goey.VBox{
+					Children: []base.Widget{
+						&goey.Label{Text: "Text input:"},
+						&goey.TextInput{Value: "Some input...", Placeholder: "Type some text here.  And some more.  And something really long.",
+							OnChange: func(v string) { println("text input ", v) }, OnEnterKey: func(v string) { println("t1* ", v) }},
+						&goey.Label{Text: "Password input:"},
+						&goey.TextInput{Value: "", Placeholder: "Don't share", Password: true,
+							OnChange: func(v string) { println("password input ", v) }},
+						&goey.Label{Text: "Integer input:"},
+						&goey.IntInput{Value: 3, Placeholder: "Please enter a number",
+							OnChange: func(v int64) { println("int input ", v) }},
+						&goey.Label{Text: "Date input:"},
+						&goey.DateInput{Value: time.Now().Add(24 * time.Hour),
+							OnChange: func(v time.Time) { println("date input: ", v.String()) }},
+						&goey.Label{Text: "Select input (combobox):"},
+						&goey.SelectInput{Items: []string{"Choice 1", "Choice 2", "Choice 3"},
+							OnChange: func(v int) { println("select input: ", v) }},
+						&goey.Label{Text: "Number input:"},
+						&goey.Slider{Value: 25, Min: 0, Max: 100,
+							OnChange: func(v float64) { println("slider input: ", v) }},
+						&goey.HR{},
+						&goey.Expand{Child: &goey.TextArea{Value: "", Placeholder: "Room to write",
+							OnChange: func(v string) { println("text area: ", v) },
+						}},
+					},
+				},
 			},
-				AlignMain: goey.MainEnd,
+			{
+				Caption: "Buttons",
+				Child: &goey.VBox{
+					Children: []base.Widget{
+						&goey.HBox{Children: []base.Widget{
+							&goey.Button{Text: "Left 1", Default: true},
+							&goey.Button{Text: "Left 2"},
+						}},
+						&goey.HBox{
+							Children: []base.Widget{
+								&goey.Button{Text: "Center"},
+							},
+							AlignMain: goey.MainCenter,
+						},
+						&goey.HBox{
+							Children: []base.Widget{
+								&goey.Button{Text: "D1"},
+								&goey.Button{Text: "D2", Disabled: true},
+								&goey.Button{Text: "D3"},
+							},
+							AlignMain: goey.MainEnd,
+						},
+						&goey.HR{},
+						&goey.Label{Text: "Check boxes:"},
+						&goey.Checkbox{Value: true, Text: "Please click on the checkbox A",
+							OnChange: func(v bool) { println("check box input: ", v) }},
+						&goey.Checkbox{Text: "Please click on the checkbox B",
+							OnChange: func(v bool) { println("check box input: ", v) }},
+					},
+				},
 			},
-			&goey.HR{},
-			&goey.SelectInput{Items: []string{"Choice 1", "Choice 2", "Choice 3"},
-				OnChange: func(v int) { println("select input: ", v) }},
-			&goey.TextArea{Value: "", Placeholder: "Room to write",
-				OnChange: func(v string) { println("text area: ", v) }},
-		)
+			{
+				Caption: "Lorem",
+				Child: &goey.VBox{
+					Children: []base.Widget{
+						&goey.P{Text: lorem, Align: goey.JustifyFull},
+						&goey.P{Text: "This is a paragraph, but without much text.", Align: goey.JustifyLeft},
+						&goey.P{Text: "This is a paragraph, but without much text.", Align: goey.JustifyCenter},
+						&goey.P{Text: "This is a paragraph, but without much text.", Align: goey.JustifyRight},
+					},
+					AlignMain: goey.MainCenter,
+				},
+			},
+		},
 	}
-
 	return &goey.Padding{
 		Insets: goey.DefaultInsets(),
-		Child:  &goey.VBox{Children: widgets},
+		Child:  widget,
 	}
 }

example/threebuttons/main.go

@@ -109,7 +109,7 @@ func render() base.Widget {
 			OnFocus: onfocus(1),
 			OnBlur:  onblur(1),
 		},
-		&goey.Button{Text: "Cyel main axis align",
+		&goey.Button{Text: "Cycle main axis align",
 			OnClick: cycleMainAxisAlign,
 			OnFocus: onfocus(2),
 			OnBlur:  onblur(2),

hbox.go

@@ -143,9 +143,7 @@ func (w *hboxElement) Layout(bc base.Constraints) base.Size {
 			for i, v := range w.childrenInfo {
 				if v.flex > 0 {
 					oldWidth := v.size.Width
-					fbc := base.TightWidth(v.size.Width + extraWidth.Scale(v.flex, w.totalFlex))
-					fbc.Min.Height = cbc.Min.Height
-					fbc.Max.Height = cbc.Max.Height
+					fbc := cbc.TightenWidth(v.size.Width + extraWidth.Scale(v.flex, w.totalFlex))
 					size := w.children[i].Layout(fbc)
 					w.childrenInfo[i].size = size
 					w.totalWidth += size.Width - oldWidth