LabelCheckbox no longer expands vertically

It should in theory valign to middle this way, but grid layout
suffers from #1

container.go

@@ -23,13 +23,23 @@ func newContainer (layout tomo.Layout, children ...tomo.Object) *Container {
 	return this
 }
 
-// NewOuterContainer creates a new container that has padding around it.
+// NewOuterContainer creates a new container that has padding around it, as well
+// as a solid background color. It is meant to be used as a root container for a
+// window, tab pane, etc.
 func NewOuterContainer (layout tomo.Layout, children ...tomo.Object) *Container {
 	this := newContainer(layout, children...)
 	theme.Apply(this, theme.R("objects", "Container", "outer"))
 	return this
 }
 
+// NewSunkenContainer creates a new container with a sunken style and padding
+// around it. It is meant to be used as a root container for a ScrollContainer.
+func NewSunkenContainer (layout tomo.Layout, children ...tomo.Object) *Container {
+	this := newContainer(layout, children...)
+	theme.Apply(this, theme.R("objects", "Container", "sunken"))
+	return this
+}
+
 // NewInnerContainer creates a new container that has no padding around it.
 func NewInnerContainer (layout tomo.Layout, children ...tomo.Object) *Container {
 	this := newContainer(layout, children...)

dialog.go

@@ -0,0 +1,101 @@
+package objects
+
+import "image"
+import "git.tebibyte.media/tomo/tomo"
+import "git.tebibyte.media/tomo/tomo/event"
+import "git.tebibyte.media/tomo/tomo/theme"
+import "git.tebibyte.media/tomo/objects/layouts"
+
+// DialogKind defines the semantic role of a dialog window.
+type DialogKind int; const (
+	DialogInformation DialogKind = iota
+	DialogQuestion
+	DialogWarning
+	DialogError
+)
+
+// Dialog is a modal dialog window.
+type Dialog struct {
+	tomo.Window
+	controlRow tomo.ContainerBox
+}
+
+type clickable interface {
+	OnClick (func ()) event.Cookie
+}
+
+// NewDialog creates a new dialog window given a dialog kind.
+func NewDialog (kind DialogKind, parent tomo.Window, title, message string, options ...tomo.Object) (*Dialog, error) {
+	if title == "" {
+		switch kind {
+		case DialogInformation: title = "Information"
+		case DialogQuestion:    title = "Question"
+		case DialogWarning:     title = "Warning"
+		case DialogError:       title = "Error"
+		}
+	}
+
+	dialog := &Dialog { }
+	if parent == nil {
+		window, err := tomo.NewWindow(image.Rectangle { })
+		if err != nil { return nil, err }
+		dialog.Window = window
+	} else {
+		window, err := parent.NewModal(image.Rectangle { })
+		if err != nil { return nil, err }
+		dialog.Window = window
+	}
+
+	var iconId theme.Icon
+	switch kind {
+	case DialogInformation: iconId = theme.IconStatusInformation
+	case DialogQuestion:    iconId = theme.IconStatusQuestion
+	case DialogWarning:     iconId = theme.IconStatusWarning
+	case DialogError:       iconId = theme.IconStatusError
+	}
+	dialog.SetTitle(title)
+	icon := NewIcon(iconId, theme.IconSizeLarge)
+	messageText := NewLabel(message)
+	messageText.SetAlign(tomo.AlignStart, tomo.AlignMiddle)
+
+	for _, option := range options {
+		if option, ok := option.(clickable); ok {
+			option.OnClick(dialog.Close)
+		}
+	}
+	dialog.controlRow = NewInnerContainer(layouts.ContractHorizontal, options...)
+	dialog.controlRow.SetAlign(tomo.AlignEnd, tomo.AlignEnd)
+
+	dialog.SetRoot(NewOuterContainer (
+		layouts.NewGrid([]bool { true }, []bool { true, false }),
+		NewInnerContainer(layouts.ContractHorizontal, icon, messageText),
+		dialog.controlRow))
+	return dialog, nil
+}
+
+// NewDialogOk creates a new dialog window with an OK option.
+func NewDialogOk (kind DialogKind, parent tomo.Window, title, message string, onOk func ()) (*Dialog, error) {
+	okButton := NewButton("OK")
+	okButton.SetIcon(theme.IconStatusOkay)
+	okButton.OnClick(func () {
+		if onOk != nil { onOk() }
+	})
+	okButton.SetFocused(true)
+	
+	return NewDialog(kind, parent, title, message, okButton)
+}
+
+// NewDialogOkCancel creates a new dialog window with OK and Cancel options.
+func NewDialogOkCancel (kind DialogKind, parent tomo.Window, title, message string, onOk func ()) (*Dialog, error) {
+	cancelButton := NewButton("Cancel")
+	cancelButton.SetIcon(theme.IconStatusCancel)
+	
+	okButton := NewButton("OK")
+	okButton.SetIcon(theme.IconStatusOkay)
+	okButton.OnClick(func () {
+		if onOk != nil { onOk() }
+	})
+	okButton.SetFocused(true)
+
+	return NewDialog(kind, parent, title, message, cancelButton, okButton)
+}

heading.go

@@ -12,10 +12,10 @@ type Heading struct {
 }
 
 // NewHeading creates a new section heading. The level can be from 0 to 2.
-func NewHeading (level int, text string) *Label {
+func NewHeading (level int, text string) *Heading {
 	if level < 0 { level = 0 }
 	if level > 2 { level = 2 }
-	this := &Label { TextBox: tomo.NewTextBox() }
+	this := &Heading { TextBox: tomo.NewTextBox() }
 	theme.Apply(this, theme.R("objects", "Heading", fmt.Sprint(level)))
 	this.SetText(text)
 	return this

labelcheckbox.go

@@ -25,7 +25,7 @@ func NewLabelCheckbox (value bool, text string) *LabelCheckbox {
 	box.label.SetAlign(tomo.AlignStart, tomo.AlignMiddle)
 	box.Add(box.checkbox)
 	box.Add(box.label)
-	box.SetLayout(layouts.NewGrid([]bool { false, true }, []bool { true }))
+	box.SetLayout(layouts.NewGrid([]bool { false, true }, []bool { false }))
 
 	box.OnMouseUp(box.handleMouseUp)
 	box.label.OnMouseUp(box.handleMouseUp)

layouts/flow.go

@@ -0,0 +1,123 @@
+package layouts
+
+import "image"
+import "git.tebibyte.media/tomo/tomo"
+
+// Flow is a grid layout where the number of rows and columns changes depending
+// on the size of the container. It is designed to be used with an overflowing
+// container. If the container does not overflow in the correct direction, the
+// layout will behave like Contract.
+type Flow bool
+
+// FlowVertical is a vertical flow layout.
+const FlowVertical Flow = true
+
+// FlowHorizontal is a horizontal flow layout.
+const FlowHorizontal Flow = false
+
+func (flow Flow) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
+	// TODO: write down somewhere that layout minimums aren't taken into
+	// account when the respective direction is overflowed
+	return flow.fallback().MinimumSize(hints, boxes)
+}
+
+func (flow Flow) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
+	if flow.v() && !hints.OverflowY || flow.h() && !hints.OverflowX {
+		flow.fallback().Arrange(hints, boxes)
+	}
+
+	// find a minor size value that will fit all boxes
+	minorSize := 0
+	for _, box := range boxes {
+		boxSize := flow.minor(box.MinimumSize())
+		if boxSize > minorSize { minorSize = boxSize }
+	}
+	if minorSize == 0 { return }
+	minorSteps :=
+		(flow.deltaMinor(hints.Bounds) + flow.minor(hints.Gap)) /
+		(minorSize + flow.minor(hints.Gap))
+
+	// arrange
+	point := hints.Bounds.Min
+	index := 0
+	for index < len(boxes) {
+		// get a slice of boxes for this major step
+		stepIndexEnd := index + minorSteps
+		if stepIndexEnd > len(boxes) { stepIndexEnd = len(boxes) }
+		step := boxes[index:stepIndexEnd]
+		index += minorSteps
+		
+		// find a major size that will fit all boxes on this major step
+		majorSize := 0
+		for _, box := range step {
+			boxSize := flow.major(box.MinimumSize())
+			if boxSize > majorSize { majorSize = boxSize }
+		}
+		if majorSize == 0 { continue }
+
+		// arrange all boxes on this major step
+		var size image.Point
+		size = flow.incrMajor(size, majorSize)
+		size = flow.incrMinor(size, minorSize)
+		for _, box := range step {
+			bounds := image.Rectangle { Min: point, Max: point.Add(size) }
+			box.SetBounds(bounds)
+
+			point = flow.incrMinor(point, minorSize + flow.minor(hints.Gap))
+		}
+
+		if flow.v() {
+			point.Y += majorSize + hints.Gap.Y
+			point.X = hints.Bounds.Min.X
+		} else {
+			point.X += majorSize + hints.Gap.X
+			point.Y = hints.Bounds.Min.Y
+		}
+	}
+}
+
+func (flow Flow) v () bool { return flow == FlowVertical   }
+func (flow Flow) h () bool { return flow == FlowHorizontal }
+
+func (flow Flow) minor (point image.Point) int {
+	if flow.v() {
+		return point.X
+	} else {
+		return point.Y
+	}
+}
+func (flow Flow) major (point image.Point) int {
+	if flow.v() {
+		return point.Y
+	} else {
+		return point.X
+	}
+}
+func (flow Flow) incrMinor (point image.Point, delta int) image.Point {
+	if flow.v() {
+		point.X += delta
+		return point
+	} else {
+		point.Y += delta
+		return point
+	}
+}
+func (flow Flow) incrMajor (point image.Point, delta int) image.Point {
+	if flow.v() {
+		point.Y += delta
+		return point
+	} else {
+		point.X += delta
+		return point
+	}
+}
+func (flow Flow) deltaMinor (rectangle image.Rectangle) int {
+	if flow.v() {
+		return rectangle.Dx()
+	} else {
+		return rectangle.Dy()
+	}
+}
+func (flow Flow) fallback () tomo.Layout {
+	return Contract(flow)
+}

layouts/layouts.go

@@ -3,86 +3,93 @@ package layouts
 import "image"
 import "git.tebibyte.media/tomo/tomo"
 
-type Row struct { }
+// Contract is a layout that arranges boxes in a simple row or column according
+// to their minimum sizes.
+type Contract bool
 
-func (Row) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
-	dot := image.Point { }
-	for _, box := range boxes {
-		minimum := box.MinimumSize()
-		dot.X += minimum.X
-		if dot.Y < minimum.Y {
-			dot.Y = minimum.Y
+// ContractVertical is a vertical contracted layout.
+const ContractVertical Contract = true
+
+// ContractHorizontal is a horizontal contracted layout.
+const ContractHorizontal Contract = false
+
+func (contract Contract) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
+	if contract.v() {
+		dot := image.Point { }
+		for _, box := range boxes {
+			minimum := box.MinimumSize()
+			dot.Y += minimum.Y
+			if dot.X < minimum.X {
+				dot.X = minimum.X
+			}
+		}
+		dot.Y += hints.Gap.Y * (len(boxes) - 1)
+		return dot
+	} else {
+		dot := image.Point { }
+		for _, box := range boxes {
+			minimum := box.MinimumSize()
+			dot.X += minimum.X
+			if dot.Y < minimum.Y {
+				dot.Y = minimum.Y
+			}
+		}
+		dot.X += hints.Gap.X * (len(boxes) - 1)
+		return dot
+	}
+}
+
+func (contract Contract) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
+	if contract.v() {
+		dot := hints.Bounds.Min
+		for index, box := range boxes {
+			if index > 0 { dot.Y += hints.Gap.Y }
+			minimum := box.MinimumSize()
+			box.SetBounds(image.Rectangle {
+				Min: dot,
+				Max: dot.Add(image.Pt(hints.Bounds.Dx(), minimum.Y)),
+			})
+			dot.Y += minimum.Y
+		}
+		
+		height := dot.Y - hints.Bounds.Min.Y
+		offset := 0
+		
+		switch hints.AlignY {
+		case tomo.AlignMiddle:
+			offset = (hints.Bounds.Dy() - height) / 2
+		case tomo.AlignEnd:
+			offset = hints.Bounds.Dy() - height
+		}
+		for _, box := range boxes {
+			box.SetBounds(box.Bounds().Add(image.Pt(0, offset)))
+		}
+	} else {
+		dot := hints.Bounds.Min
+		for index, box := range boxes {
+			if index > 0 { dot.X += hints.Gap.X }
+			minimum := box.MinimumSize()
+			box.SetBounds(image.Rectangle {
+				Min: dot,
+				Max: dot.Add(image.Pt(minimum.X, hints.Bounds.Dy())),
+			})
+			dot.X += minimum.X
+		}
+
+		width  := dot.X - hints.Bounds.Min.X
+		offset := 0
+		
+		switch hints.AlignX {
+		case tomo.AlignMiddle:
+			offset = (hints.Bounds.Dx() - width) / 2
+		case tomo.AlignEnd:
+			offset = hints.Bounds.Dx() - width
+		}
+		for _, box := range boxes {
+			box.SetBounds(box.Bounds().Add(image.Pt(offset, 0)))
 		}
 	}
-	dot.X += hints.Gap.X * (len(boxes) - 1)
-	return dot
 }
 
-func (Row) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
-	// TODO respect alignment value
-	dot := hints.Bounds.Min
-	for index, box := range boxes {
-		if index > 0 { dot.X += hints.Gap.X }
-		minimum := box.MinimumSize()
-		box.SetBounds(image.Rectangle {
-			Min: dot,
-			Max: dot.Add(image.Pt(minimum.X, hints.Bounds.Dy())),
-		})
-		dot.X += minimum.X
-	}
-
-	width  := dot.X - hints.Bounds.Min.X
-	offset := 0
-	
-	switch hints.AlignX {
-	case tomo.AlignMiddle:
-		offset = (hints.Bounds.Dx() - width) / 2
-	case tomo.AlignEnd:
-		offset = hints.Bounds.Dx() - width
-	}
-	for _, box := range boxes {
-		box.SetBounds(box.Bounds().Add(image.Pt(offset, 0)))
-	}
-}
-
-type Column struct { }
-
-func (Column) MinimumSize (hints tomo.LayoutHints, boxes []tomo.Box) image.Point {
-	dot := image.Point { }
-	for _, box := range boxes {
-		minimum := box.MinimumSize()
-		dot.Y += minimum.Y
-		if dot.X < minimum.X {
-			dot.X = minimum.X
-		}
-	}
-	dot.Y += hints.Gap.Y * (len(boxes) - 1)
-	return dot
-}
-
-func (Column) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
-	// TODO respect alignment value
-	dot := hints.Bounds.Min
-	for index, box := range boxes {
-		if index > 0 { dot.Y += hints.Gap.Y }
-		minimum := box.MinimumSize()
-		box.SetBounds(image.Rectangle {
-			Min: dot,
-			Max: dot.Add(image.Pt(hints.Bounds.Dx(), minimum.Y)),
-		})
-		dot.Y += minimum.Y
-	}
-	
-	height := dot.Y - hints.Bounds.Min.Y
-	offset := 0
-	
-	switch hints.AlignY {
-	case tomo.AlignMiddle:
-		offset = (hints.Bounds.Dy() - height) / 2
-	case tomo.AlignEnd:
-		offset = hints.Bounds.Dy() - height
-	}
-	for _, box := range boxes {
-		box.SetBounds(box.Bounds().Add(image.Pt(0, offset)))
-	}
-}
+func (contract Contract) v () bool { return contract == ContractVertical   }
+func (contract Contract) h () bool { return contract == ContractHorizontal }

scrollbar.go

@@ -98,9 +98,9 @@ func (this *Scrollbar) SetValue (value float64) {
 	position    := trackLength * value
 	point       := this.layout.linked.ContentBounds().Min
 	if this.layout.vertical {
-		point.Y = int(position)
+		point.Y = -int(position)
 	} else {
-		point.X = int(position)
+		point.X = -int(position)
 	}
 	this.layout.linked.ScrollTo(point)
 	
@@ -173,15 +173,15 @@ func (this *Scrollbar) handleMouseDown (button input.Button) {
 		}
 	case input.ButtonMiddle:
 		if above {
-			this.scrollBy(-this.pageSize())
-		} else {
 			this.scrollBy(this.pageSize())
+		} else {
+			this.scrollBy(-this.pageSize())
 		}
 	case input.ButtonRight:
 		if above {
-			this.scrollBy(-this.stepSize())
-		} else {
 			this.scrollBy(this.stepSize())
+		} else {
+			this.scrollBy(-this.stepSize())
 		}
 	}
 }
@@ -200,7 +200,7 @@ func (this *Scrollbar) handleScroll (x, y float64) {
 	if this.layout.linked == nil { return }
 	this.layout.linked.ScrollTo (
 		this.layout.linked.ContentBounds().Min.
-		Add(image.Pt(int(x), int(y))))
+		Sub(image.Pt(int(x), int(y))))
 }
 
 func (this *Scrollbar) drag () {
@@ -327,7 +327,7 @@ func (this scrollbarLayout) Arrange (hints tomo.LayoutHints, boxes []tomo.Box) {
 	} else {
 		handleOffset = image.Pt(int(handlePosition), 0)
 	}
-	handle = handle.Add(handleOffset).Add(gutter.Min)
+	handle = handle.Sub(handleOffset).Add(gutter.Min)
 	
 	// place handle
 	boxes[0].SetBounds(handle)

scrollcontainer.go

@@ -104,11 +104,34 @@ func (this *ScrollContainer) SetRoot (root tomo.ContentBox) {
 	}
 }
 
+// SetValue sets the horizontal and vertical scrollbar values where 0 is all the
+// way to the left/top, and 1 is all the way to the right/bottom.
+func (this *ScrollContainer) SetValue (x, y float64) {
+	if this.layout.horizontal != nil {
+		this.layout.horizontal.SetValue(x)
+	}
+	if this.layout.vertical != nil {
+		this.layout.vertical.SetValue(y)
+	}
+}
+
+// Value returns the horizontal and vertical scrollbar values where 0 is all the
+// way to the left/top, and 1 is all the way to the right/bottom.
+func (this *ScrollContainer) Value () (x, y float64) {
+	if this.layout.horizontal != nil {
+		x = this.layout.horizontal.Value()
+	}
+	if this.layout.vertical != nil {
+		y = this.layout.vertical.Value()
+	}
+	return x, y
+}
+
 func (this *ScrollContainer) handleScroll (x, y float64) {
 	if this.layout.root == nil { return }
 	this.layout.root.ScrollTo (
 		this.layout.root.ContentBounds().Min.
-		Add(image.Pt(int(x), int(y))))
+		Sub(image.Pt(int(x), int(y))))
 }
 
 type scrollContainerLayout struct {

slider.go

@@ -13,6 +13,7 @@ type Slider struct {
 	layout     sliderLayout
 	dragging   bool
 	dragOffset image.Point
+	step       float64
 
 	on struct {
 		slide event.FuncBroadcaster
@@ -34,6 +35,7 @@ func newSlider (orient string, value float64) *Slider {
 		layout: sliderLayout {
 			vertical: orient == "vertical",
 		},
+		step: 0.05,
 	}
 
 	this.Add(this.handle)
@@ -49,6 +51,7 @@ func newSlider (orient string, value float64) *Slider {
 	this.OnMouseDown(this.handleMouseDown)
 	this.OnMouseUp(this.handleMouseUp)
 	this.OnMouseMove(this.handleMouseMove)
+	this.OnScroll(this.handleScroll)
 	theme.Apply(this.handle, theme.R("objects", "SliderHandle", orient))
 	theme.Apply(this,        theme.R("objects", "Slider", orient))
 	return this
@@ -98,16 +101,20 @@ func (this *Slider) handleKeyDown (key input.Key, numpad bool) {
 		} else {
 			this.SetValue(this.Value() - increment)
 		}
+		this.on.slide.Broadcast()
 	case input.KeyDown, input.KeyRight:
 		if this.Modifiers().Alt {
 			this.SetValue(1)
 		} else {
 			this.SetValue(this.Value() + increment)
 		}
+		this.on.slide.Broadcast()
 	case input.KeyHome:
 		this.SetValue(0)
+		this.on.slide.Broadcast()
 	case input.KeyEnd:
 		this.SetValue(1)
+		this.on.slide.Broadcast()
 	}
 }
 
@@ -145,10 +152,10 @@ func (this *Slider) handleMouseDown (button input.Button) {
 		}
 	case input.ButtonRight:
 		if above {
-			this.SetValue(this.Value() - 0.05)
+			this.SetValue(this.Value() - this.step)
 			this.on.slide.Broadcast()
 		} else {
-			this.SetValue(this.Value() + 0.05)
+			this.SetValue(this.Value() + this.step)
 			this.on.slide.Broadcast()
 		}
 	}
@@ -164,6 +171,12 @@ func (this *Slider) handleMouseMove () {
 	this.drag()
 }
 
+func (this *Slider) handleScroll (x, y float64) {
+	delta := (x + y) * 0.005
+	this.SetValue(this.Value() + delta)
+	this.on.slide.Broadcast()
+}
+
 func (this *Slider) drag () {
 	pointer := this.MousePosition().Sub(this.dragOffset)
 	gutter  := this.InnerBounds()