g3n-engine/gui/hboxlayout.go

// Copyright 2016 The G3N Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package gui

/*
HBoxLayout implements a panel layout which arranges the panel children horizontally.
The children can be separated by a space in pixels set by SetSpacing().
The whole group of children can be aligned horizontally by SetAlignH() which can
accept the following types of alignment:

	AlignLeft: Try to align the group of children to the left if the panel width is
	greater the the sum of the children widths + spacing.

	AlignRight: Try to align the group of children to the right if the panel width is
	greater the the sum of the children widths + spacing.

	AlignCenter: Try to align the group of children in the center if the panel width is
	greater the the sum of the children widths + spacing.

	AlignWidth - Try to align the individual children with the same same space between each other.
	Each individual child can be aligned vertically by SetLayoutParameters()

If the layout method SetMinHeight(true) is called, the panel minimum height will be the
height of the child with the largest height.
*/
type HBoxLayout struct {
	pan       IPanel
	spacing   float32
	alignH    Align
	minHeight bool
	minWidth  bool
}

// HBoxLayoutParameters specify the vertical alignment of each individual child.
type HBoxLayoutParams struct {
	Expand float32 // item expand horizontally factor (0 - no expand)
	AlignV Align   // item vertical alignment
}

// NewHBoxLayout creates and returns a pointer to a new horizontal box layout
func NewHBoxLayout() *HBoxLayout {

	bl := new(HBoxLayout)
	bl.spacing = 0
	bl.alignH = AlignLeft
	return bl
}

// SetSpacing sets the horizontal spacing between the items in pixels
// and updates the layout if possible
func (bl *HBoxLayout) SetSpacing(spacing float32) {

	bl.spacing = spacing
	bl.Recalc(bl.pan)
}

// SetAlignH sets the horizontal alignment of the whole group of items
// inside the parent panel and updates the layout if possible.
// This only has any effect if there are no expanded items.
func (bl *HBoxLayout) SetAlignH(align Align) {

	bl.alignH = align
	bl.Recalc(bl.pan)
}

// SetMinHeight sets if the panel minimum height should be the height of
// the largest of its children's height.
func (bl *HBoxLayout) SetMinHeight(state bool) {

	bl.minHeight = state
	bl.Recalc(bl.pan)
}

// SetMinWidth sets if the panel minimum width should be sum of its
// children's width plus the spacing
func (bl *HBoxLayout) SetMinWidth(state bool) {

	bl.minWidth = state
	bl.Recalc(bl.pan)
}

// Recalc recalculates and sets the position and sizes of all children
func (bl *HBoxLayout) Recalc(ipan IPanel) {

	// Saves the received panel
	bl.pan = ipan
	if bl.pan == nil {
		return
	}
	parent := ipan.GetPanel()
	if len(parent.Children()) == 0 {
		return
	}

	// If minHeight set, sets the panel content height to the height of the heighest child.
	newHeight := float32(0)
	if bl.minHeight {
		for _, ichild := range parent.Children() {
			child := ichild.(IPanel).GetPanel()
			if child.Height() > newHeight {
				newHeight = child.Height()
			}
		}
		if parent.ContentHeight() < newHeight {
			parent.SetContentHeight(newHeight)
		}
	}

	// If minWidth set, sets the panel content width to the sum of children widths plus spacing
	newWidth := float32(0)
	if bl.minWidth {
		for _, ichild := range parent.Children() {
			child := ichild.(IPanel).GetPanel()
			newWidth += child.Width()
		}
		// Adds spacing
		newWidth += bl.spacing * float32(len(parent.Children())-1)
		if parent.ContentWidth() < newWidth {
			parent.SetContentWidth(newWidth)
		}
	}

	// Calculates the total width, expanded width, fixed width and
	// the sum of the expand factor for all items.
	var twidth float32 = 0
	var ewidth float32 = 0
	var fwidth float32 = 0
	var texpand float32 = 0
	ecount := 0
	paramsDef := HBoxLayoutParams{Expand: 0, AlignV: AlignTop}
	for pos, obj := range parent.Children() {
		pan := obj.(IPanel).GetPanel()
		// Get item layout parameters or use default
		params := paramsDef
		if pan.layoutParams != nil {
			params = *pan.layoutParams.(*HBoxLayoutParams)
		}
		// Calculate total width
		twidth += pan.Width()
		if pos > 0 {
			twidth += bl.spacing
		}
		// Calculate width of expanded items
		if params.Expand > 0 {
			texpand += params.Expand
			ewidth += pan.Width()
			if pos > 0 {
				ewidth += bl.spacing
			}
			ecount++
			// Calculate width of fixed items
		} else {
			fwidth += pan.Width()
			if pos > 0 {
				fwidth += bl.spacing
			}
		}
	}

	// If there is at least on expanded item, all free space will be occupied
	spaceMiddle := bl.spacing
	var posX float32 = 0
	if texpand > 0 {
		// If there is free space, distribute space between expanded items
		totalSpace := parent.ContentWidth() - twidth
		if totalSpace > 0 {
			for _, obj := range parent.Children() {
				pan := obj.(IPanel).GetPanel()
				// Get item layout parameters or use default
				params := paramsDef
				if pan.layoutParams != nil {
					params = *pan.layoutParams.(*HBoxLayoutParams)
				}
				if params.Expand > 0 {
					iwidth := totalSpace * params.Expand / texpand
					pan.SetWidth(pan.Width() + iwidth)
				}
			}
			// No free space: distribute expanded items widths
		} else {
			for _, obj := range parent.Children() {
				pan := obj.(IPanel).GetPanel()
				// Get item layout parameters or use default
				params := paramsDef
				if pan.layoutParams != nil {
					params = *pan.layoutParams.(*HBoxLayoutParams)
				}
				if params.Expand > 0 {
					spacing := bl.spacing * (float32(ecount) - 1)
					iwidth := (parent.ContentWidth() - spacing - fwidth - bl.spacing) * params.Expand / texpand
					pan.SetWidth(iwidth)
				}
			}
		}
		// No expanded items: checks block horizontal alignment
	} else {
		// Calculates initial x position which depends
		// on the current horizontal alignment.
		switch bl.alignH {
		case AlignLeft:
			posX = 0
		case AlignCenter:
			posX = (parent.ContentWidth() - twidth) / 2
		case AlignRight:
			posX = parent.ContentWidth() - twidth
		case AlignWidth:
			space := parent.ContentWidth() - twidth + bl.spacing*float32(len(parent.Children())-1)
			if space < 0 {
				space = bl.spacing * float32(len(parent.Children())-1)
			}
			spaceMiddle = space / float32(len(parent.Children())+1)
			posX = spaceMiddle
		default:
			log.Fatal("HBoxLayout: invalid global horizontal alignment")
		}
	}

	// Calculates the Y position of each item considering its vertical alignment
	var posY float32
	height := parent.ContentHeight()
	for pos, obj := range parent.Children() {
		pan := obj.(IPanel).GetPanel()
		// Get item layout parameters or use default
		params := paramsDef
		if pan.layoutParams != nil {
			params = *pan.layoutParams.(*HBoxLayoutParams)
		}
		cheight := pan.Height()
		switch params.AlignV {
		case AlignTop:
			posY = 0
		case AlignCenter:
			posY = (height - cheight) / 2
		case AlignBottom:
			posY = height - cheight
		case AlignHeight:
			posY = 0
			pan.SetHeight(height)
		default:
			log.Fatal("HBoxLayout: invalid item vertical alignment")
		}
		// Sets the child position
		pan.SetPosition(posX, posY)
		// Calculates next position
		posX += pan.Width()
		if pos < len(parent.Children())-1 {
			posX += spaceMiddle
		}
	}
}