From a12e21612641bdcde5c45383c6e215c85d5b6212 Mon Sep 17 00:00:00 2001
From: Alexander Neumann <alexander.neumann@picos-software.com>
Date: Tue, 26 Feb 2019 17:34:51 +0100
Subject: Spacer: Add support for restricting greed locally

---
 boxlayout.go          | 10 +++++++++-
 declarative/spacer.go | 44 ++++++++++++++++++++++++++------------------
 gridlayout.go         | 20 +++++++++++---------
 spacer.go             | 30 +++++++++++++++++++++---------
 4 files changed, 67 insertions(+), 37 deletions(-)

diff --git a/boxlayout.go b/boxlayout.go
index 102e5911..be795040 100644
--- a/boxlayout.go
+++ b/boxlayout.go
@@ -208,7 +208,9 @@ func (l *BoxLayout) LayoutFlags() LayoutFlags {
 		return 0
 	}
 
-	return boxLayoutFlags(l.orientation, l.container.Children())
+	flags := boxLayoutFlags(l.orientation, l.container.Children())
+
+	return flags
 }
 
 func (l *BoxLayout) MinSize() Size {
@@ -326,6 +328,12 @@ func boxLayoutFlags(orientation Orientation, children *WidgetList) LayoutFlags {
 				continue
 			}
 
+			if s, ok := widget.(*Spacer); ok {
+				if s.greedyLocallyOnly {
+					continue
+				}
+			}
+
 			f := widget.LayoutFlags()
 			flags |= f
 			if f&ShrinkableHorz == 0 {
diff --git a/declarative/spacer.go b/declarative/spacer.go
index f6c8069c..549dd627 100644
--- a/declarative/spacer.go
+++ b/declarative/spacer.go
@@ -27,19 +27,23 @@ type HSpacer struct {
 
 	// Spacer
 
-	Size int
+	GreedyLocallyOnly bool
+	Size              int
 }
 
 func (hs HSpacer) Create(builder *Builder) (err error) {
+	var flags walk.LayoutFlags
+	if hs.Size == 0 {
+		flags = walk.ShrinkableHorz | walk.GrowableHorz | walk.GreedyHorz
+	}
+
 	var w *walk.Spacer
-	if hs.Size > 0 {
-		if w, err = walk.NewHSpacerFixed(builder.Parent(), hs.Size); err != nil {
-			return
-		}
-	} else {
-		if w, err = walk.NewHSpacer(builder.Parent()); err != nil {
-			return
-		}
+	if w, err = walk.NewSpacerWithCfg(builder.Parent(), &walk.SpacerCfg{
+		LayoutFlags:       flags,
+		SizeHint:          walk.Size{Width: hs.Size},
+		GreedyLocallyOnly: hs.GreedyLocallyOnly,
+	}); err != nil {
+		return
 	}
 
 	return builder.InitWidget(hs, w, nil)
@@ -62,19 +66,23 @@ type VSpacer struct {
 
 	// Spacer
 
-	Size int
+	GreedyLocallyOnly bool
+	Size              int
 }
 
 func (vs VSpacer) Create(builder *Builder) (err error) {
+	var flags walk.LayoutFlags
+	if vs.Size == 0 {
+		flags = walk.ShrinkableVert | walk.GrowableVert | walk.GreedyVert
+	}
+
 	var w *walk.Spacer
-	if vs.Size > 0 {
-		if w, err = walk.NewVSpacerFixed(builder.Parent(), vs.Size); err != nil {
-			return
-		}
-	} else {
-		if w, err = walk.NewVSpacer(builder.Parent()); err != nil {
-			return
-		}
+	if w, err = walk.NewSpacerWithCfg(builder.Parent(), &walk.SpacerCfg{
+		LayoutFlags:       flags,
+		SizeHint:          walk.Size{Height: vs.Size},
+		GreedyLocallyOnly: vs.GreedyLocallyOnly,
+	}); err != nil {
+		return
 	}
 
 	return builder.InitWidget(vs, w, nil)
diff --git a/gridlayout.go b/gridlayout.go
index daa00678..313c8e60 100644
--- a/gridlayout.go
+++ b/gridlayout.go
@@ -345,18 +345,20 @@ func (l *GridLayout) LayoutFlags() LayoutFlags {
 		for i := 0; i < count; i++ {
 			widget := children.At(i)
 
-			if shouldLayoutWidget(widget) {
-				wf := widget.LayoutFlags()
+			if s, ok := widget.(*Spacer); ok && s.greedyLocallyOnly || !shouldLayoutWidget(widget) {
+				continue
+			}
 
-				if wf&GreedyHorz != 0 && widget.MaxSize().Width > 0 {
-					wf &^= GreedyHorz
-				}
-				if wf&GreedyVert != 0 && widget.MaxSize().Height > 0 {
-					wf &^= GreedyVert
-				}
+			wf := widget.LayoutFlags()
 
-				flags |= wf
+			if wf&GreedyHorz != 0 && widget.MaxSize().Width > 0 {
+				wf &^= GreedyHorz
+			}
+			if wf&GreedyVert != 0 && widget.MaxSize().Height > 0 {
+				wf &^= GreedyVert
 			}
+
+			flags |= wf
 		}
 	}
 
diff --git a/spacer.go b/spacer.go
index 83e25978..de4cc8bb 100644
--- a/spacer.go
+++ b/spacer.go
@@ -14,14 +14,26 @@ func init() {
 
 type Spacer struct {
 	WidgetBase
-	sizeHint    Size
-	layoutFlags LayoutFlags
+	sizeHint          Size
+	layoutFlags       LayoutFlags
+	greedyLocallyOnly bool
 }
 
-func newSpacer(parent Container, layoutFlags LayoutFlags, sizeHint Size) (*Spacer, error) {
+type SpacerCfg struct {
+	LayoutFlags       LayoutFlags
+	SizeHint          Size
+	GreedyLocallyOnly bool
+}
+
+func NewSpacerWithCfg(parent Container, cfg *SpacerCfg) (*Spacer, error) {
+	return newSpacer(parent, cfg.LayoutFlags, cfg.SizeHint, cfg.GreedyLocallyOnly)
+}
+
+func newSpacer(parent Container, layoutFlags LayoutFlags, sizeHint Size, greedyLocallyOnly bool) (*Spacer, error) {
 	s := &Spacer{
-		layoutFlags: layoutFlags,
-		sizeHint:    sizeHint,
+		layoutFlags:       layoutFlags,
+		sizeHint:          sizeHint,
+		greedyLocallyOnly: greedyLocallyOnly,
 	}
 
 	if err := InitWidget(
@@ -37,19 +49,19 @@ func newSpacer(parent Container, layoutFlags LayoutFlags, sizeHint Size) (*Space
 }
 
 func NewHSpacer(parent Container) (*Spacer, error) {
-	return newSpacer(parent, ShrinkableHorz|ShrinkableVert|GrowableHorz|GreedyHorz, Size{})
+	return newSpacer(parent, ShrinkableHorz|ShrinkableVert|GrowableHorz|GreedyHorz, Size{}, false)
 }
 
 func NewHSpacerFixed(parent Container, width int) (*Spacer, error) {
-	return newSpacer(parent, 0, Size{width, 0})
+	return newSpacer(parent, 0, Size{width, 0}, false)
 }
 
 func NewVSpacer(parent Container) (*Spacer, error) {
-	return newSpacer(parent, ShrinkableHorz|ShrinkableVert|GrowableVert|GreedyVert, Size{})
+	return newSpacer(parent, ShrinkableHorz|ShrinkableVert|GrowableVert|GreedyVert, Size{}, false)
 }
 
 func NewVSpacerFixed(parent Container, height int) (*Spacer, error) {
-	return newSpacer(parent, 0, Size{0, height})
+	return newSpacer(parent, 0, Size{0, height}, false)
 }
 
 func (s *Spacer) LayoutFlags() LayoutFlags {
-- 
cgit v1.2.3-59-g8ed1b