interesting
/
andlabs-ui
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Copied stack.go and grid.go to a temporary restaging area; removed the margin code from both as we no longer need it there.

This commit is contained in:
Pietro Gagliardi 2014-07-27 10:48:30 -04:00
parent e679f8c9e4
commit be8afd43c0
2 changed files with 449 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

236
redo/mergeback/grid.go Normal file
View File

@ -0,0 +1,236 @@
// 25 february 2014
package ui
import (
"fmt"
)
// A Grid arranges Controls in a two-dimensional grid.
// The height of each row and the width of each column is the maximum preferred height and width (respectively) of all the controls in that row or column (respectively).
// Controls are aligned to the top left corner of each cell.
// All Controls in a Grid maintain their preferred sizes by default; if a Control is marked as being "filling", it will be sized to fill its cell.
// Even if a Control is marked as filling, its preferred size is used to calculate cell sizes.
// One Control can be marked as "stretchy": when the Window containing the Grid is resized, the cell containing that Control resizes to take any remaining space; its row and column are adjusted accordingly (so other filling controls in the same row and column will fill to the new height and width, respectively).
// A stretchy Control implicitly fills its cell.
// All cooridnates in a Grid are given in (row,column) form with (0,0) being the top-left cell.
type Grid struct {
created bool
controls [][]Control
filling [][]bool
stretchyrow, stretchycol int
widths, heights [][]int // caches to avoid reallocating each time
rowheights, colwidths []int
}
// NewGrid creates a new Grid with the given Controls.
// NewGrid needs to know the number of Controls in a row (alternatively, the number of columns); it will determine the number in a column from the number of Controls given.
// NewGrid panics if not given a full grid of Controls.
// Example:
// grid := NewGrid(3,
// control00, control01, control02,
// control10, control11, control12,
// control20, control21, control22)
func NewGrid(nPerRow int, controls ...Control) *Grid {
if len(controls)%nPerRow != 0 {
panic(fmt.Errorf("incomplete grid given to NewGrid() (not enough controls to evenly divide %d controls into rows of %d controls each)", len(controls), nPerRow))
}
nRows := len(controls) / nPerRow
cc := make([][]Control, nRows)
cf := make([][]bool, nRows)
cw := make([][]int, nRows)
ch := make([][]int, nRows)
i := 0
for row := 0; row < nRows; row++ {
cc[row] = make([]Control, nPerRow)
cf[row] = make([]bool, nPerRow)
cw[row] = make([]int, nPerRow)
ch[row] = make([]int, nPerRow)
for x := 0; x < nPerRow; x++ {
cc[row][x] = controls[i]
i++
}
}
return &Grid{
controls: cc,
filling: cf,
stretchyrow: -1,
stretchycol: -1,
widths: cw,
heights: ch,
rowheights: make([]int, nRows),
colwidths: make([]int, nPerRow),
}
}
// SetFilling marks the given Control of the Grid as filling its cell instead of staying at its preferred size.
// This function cannot be called after the Window that contains the Grid has been created.
// It panics if the given coordinate is invalid.
func (g *Grid) SetFilling(row int, column int) {
if g.created {
panic(fmt.Errorf("Grid.SetFilling() called after window create"))
}
if row < 0 || column < 0 || row > len(g.filling) || column > len(g.filling[row]) {
panic(fmt.Errorf("coordinate (%d,%d) out of range passed to Grid.SetFilling()", row, column))
}
g.filling[row][column] = true
}
// SetStretchy marks the given Control of the Grid as stretchy.
// Stretchy implies filling.
// Only one control can be stretchy per Grid; calling SetStretchy multiple times merely changes which control is stretchy.
// This function cannot be called after the Window that contains the Grid has been created.
// It panics if the given coordinate is invalid.
func (g *Grid) SetStretchy(row int, column int) {
if g.created {
panic(fmt.Errorf("Grid.SetFilling() called after window create"))
}
if row < 0 || column < 0 || row > len(g.filling) || column > len(g.filling[row]) {
panic(fmt.Errorf("coordinate (%d,%d) out of range passed to Grid.SetStretchy()", row, column))
}
g.stretchyrow = row
g.stretchycol = column
// don't set filling here in case we call SetStretchy() multiple times; the filling is committed in make() below
}
func (g *Grid) make(window *sysData) error {
// commit filling for the stretchy control now (see SetStretchy() above)
if g.stretchyrow != -1 && g.stretchycol != -1 {
g.filling[g.stretchyrow][g.stretchycol] = true
} else if (g.stretchyrow == -1 && g.stretchycol != -1) || // sanity check
(g.stretchyrow != -1 && g.stretchycol == -1) {
panic(fmt.Errorf("internal inconsistency in Grid: stretchy (%d,%d) impossible (one component, not both, is -1/no stretchy control) in Grid.make()", g.stretchyrow, g.stretchycol))
}
for row, xcol := range g.controls {
for col, c := range xcol {
err := c.make(window)
if err != nil {
return fmt.Errorf("error adding control (%d,%d) to Grid: %v", row, col, err)
}
}
}
g.created = true
return nil
}
func (g *Grid) allocate(x int, y int, width int, height int, d *sysSizeData) (allocations []*allocation) {
max := func(a int, b int) int {
if a > b {
return a
}
return b
}
var current *allocation // for neighboring
// TODO return if nControls == 0?
// 0) inset the available rect by the needed padding
width -= (len(g.colwidths) - 1) * d.xpadding
height -= (len(g.rowheights) - 1) * d.ypadding
// 1) clear data structures
for i := range g.rowheights {
g.rowheights[i] = 0
}
for i := range g.colwidths {
g.colwidths[i] = 0
}
// 2) get preferred sizes; compute row/column sizes
for row, xcol := range g.controls {
for col, c := range xcol {
w, h := c.preferredSize(d)
g.widths[row][col] = w
g.heights[row][col] = h
g.rowheights[row] = max(g.rowheights[row], h)
g.colwidths[col] = max(g.colwidths[col], w)
}
}
// 3) handle the stretchy control
if g.stretchyrow != -1 && g.stretchycol != -1 {
for i, w := range g.colwidths {
if i != g.stretchycol {
width -= w
}
}
for i, h := range g.rowheights {
if i != g.stretchyrow {
height -= h
}
}
g.colwidths[g.stretchycol] = width
g.rowheights[g.stretchyrow] = height
}
// 4) draw
startx := x
for row, xcol := range g.controls {
current = nil // reset on new columns
for col, c := range xcol {
w := g.widths[row][col]
h := g.heights[row][col]
if g.filling[row][col] {
w = g.colwidths[col]
h = g.rowheights[row]
}
as := c.allocate(x, y, w, h, d)
if current != nil { // connect first left to first right
current.neighbor = c
}
if len(as) != 0 {
current = as[0] // next left is first subwidget
} else {
current = nil // spaces don't have allocation data
}
allocations = append(allocations, as...)
x += g.colwidths[col] + d.xpadding
}
x = startx
y += g.rowheights[row] + d.ypadding
}
return
}
// filling and stretchy are ignored for preferred size calculation
// We don't consider the margins here, but will need to in container if Window.SizeToFit() is ever made a thing. TODO
func (g *Grid) preferredSize(d *sysSizeData) (width int, height int) {
max := func(a int, b int) int {
if a > b {
return a
}
return b
}
width -= (len(g.colwidths) - 1) * d.xpadding
height -= (len(g.rowheights) - 1) * d.ypadding
// 1) clear data structures
for i := range g.rowheights {
g.rowheights[i] = 0
}
for i := range g.colwidths {
g.colwidths[i] = 0
}
// 2) get preferred sizes; compute row/column sizes
for row, xcol := range g.controls {
for col, c := range xcol {
w, h := c.preferredSize(d)
g.widths[row][col] = w
g.heights[row][col] = h
g.rowheights[row] = max(g.rowheights[row], h)
g.colwidths[col] = max(g.colwidths[col], w)
}
}
// 3) now compute
for _, w := range g.colwidths {
width += w
}
for _, h := range g.rowheights {
height += h
}
return width, height
}
func (g *Grid) commitResize(c *allocation, d *sysSizeData) {
// this is to satisfy Control; nothing to do here
}
func (g *Grid) getAuxResizeInfo(d *sysSizeData) {
// this is to satisfy Control; nothing to do here
}

213
redo/mergeback/stack.go Normal file
View File

@ -0,0 +1,213 @@
// 13 february 2014
package ui
import (
"fmt"
)
type orientation bool
const (
horizontal orientation = false
vertical orientation = true
)
// A Stack stacks controls horizontally or vertically within the Stack's parent.
// A horizontal Stack gives all controls the same height and their preferred widths.
// A vertical Stack gives all controls the same width and their preferred heights.
// Any extra space at the end of a Stack is left blank.
// Some controls may be marked as "stretchy": when the Window they are in changes size, stretchy controls resize to take up the remaining space after non-stretchy controls are laid out. If multiple controls are marked stretchy, they are alloted equal distribution of the remaining space.
type Stack struct {
created bool
orientation orientation
controls []Control
stretchy []bool
width, height []int // caches to avoid reallocating these each time
}
func newStack(o orientation, controls ...Control) *Stack {
return &Stack{
orientation: o,
controls: controls,
stretchy: make([]bool, len(controls)),
width: make([]int, len(controls)),
height: make([]int, len(controls)),
}
}
// NewHorizontalStack creates a new Stack that arranges the given Controls horizontally.
func NewHorizontalStack(controls ...Control) *Stack {
return newStack(horizontal, controls...)
}
// NewVerticalStack creates a new Stack that arranges the given Controls vertically.
func NewVerticalStack(controls ...Control) *Stack {
return newStack(vertical, controls...)
}
// SetStretchy marks a control in a Stack as stretchy. This cannot be called once the Window containing the Stack has been created.
// It panics if index is out of range.
func (s *Stack) SetStretchy(index int) {
if s.created {
panic("call to Stack.SetStretchy() after Stack has been created")
}
if index < 0 || index > len(s.stretchy) {
panic(fmt.Errorf("index %d out of range in Stack.SetStretchy()", index))
}
s.stretchy[index] = true
}
func (s *Stack) make(window *sysData) error {
for i, c := range s.controls {
err := c.make(window)
if err != nil {
return fmt.Errorf("error adding control %d to Stack: %v", i, err)
}
}
s.created = true
return nil
}
func (s *Stack) allocate(x int, y int, width int, height int, d *sysSizeData) (allocations []*allocation) {
var stretchywid, stretchyht int
var current *allocation // for neighboring
if len(s.controls) == 0 { // do nothing if there's nothing to do
return nil
}
// 0) inset the available rect by the needed padding
if s.orientation == horizontal {
width -= (len(s.controls) - 1) * d.xpadding
} else {
height -= (len(s.controls) - 1) * d.ypadding
}
// 1) get height and width of non-stretchy controls; figure out how much space is alloted to stretchy controls
stretchywid = width
stretchyht = height
nStretchy := 0
for i, c := range s.controls {
if s.stretchy[i] {
nStretchy++
continue
}
w, h := c.preferredSize(d)
if s.orientation == horizontal { // all controls have same height
s.width[i] = w
s.height[i] = height
stretchywid -= w
} else { // all controls have same width
s.width[i] = width
s.height[i] = h
stretchyht -= h
}
}
// 2) figure out size of stretchy controls
if nStretchy != 0 {
if s.orientation == horizontal { // split rest of width
stretchywid /= nStretchy
} else { // split rest of height
stretchyht /= nStretchy
}
}
for i := range s.controls {
if !s.stretchy[i] {
continue
}
s.width[i] = stretchywid
s.height[i] = stretchyht
}
// 3) now actually place controls
for i, c := range s.controls {
as := c.allocate(x, y, s.width[i], s.height[i], d)
if s.orientation == horizontal { // no vertical neighbors
if current != nil { // connect first left to first right
current.neighbor = c
}
if len(as) != 0 {
current = as[0] // next left is first subwidget
} else {
current = nil // spaces don't have allocation data
}
}
allocations = append(allocations, as...)
if s.orientation == horizontal {
x += s.width[i] + d.xpadding
} else {
y += s.height[i] + d.ypadding
}
}
return allocations
}
// The preferred size of a Stack is the sum of the preferred sizes of non-stretchy controls + (the number of stretchy controls * the largest preferred size among all stretchy controls).
// We don't consider the margins here, but will need to in container if Window.SizeToFit() is ever made a thing. TODO
func (s *Stack) preferredSize(d *sysSizeData) (width int, height int) {
max := func(a int, b int) int {
if a > b {
return a
}
return b
}
var nStretchy int
var maxswid, maxsht int
if len(s.controls) == 0 { // no controls, so return emptiness
return 0, 0
}
if s.orientation == horizontal {
width = (len(s.controls) - 1) * d.xpadding
} else {
height = (len(s.controls) - 1) * d.ypadding
}
for i, c := range s.controls {
w, h := c.preferredSize(d)
if s.stretchy[i] {
nStretchy++
maxswid = max(maxswid, w)
maxsht = max(maxsht, h)
}
if s.orientation == horizontal { // max vertical size
if !s.stretchy[i] {
width += w
}
height = max(height, h)
} else {
width = max(width, w)
if !s.stretchy[i] {
height += h
}
}
}
if s.orientation == horizontal {
width += nStretchy * maxswid
} else {
height += nStretchy * maxsht
}
return
}
func (s *Stack) commitResize(c *allocation, d *sysSizeData) {
// this is to satisfy Control; nothing to do here
}
func (s *Stack) getAuxResizeInfo(d *sysSizeData) {
// this is to satisfy Control; nothing to do here
}
// Space returns a null Control intended for padding layouts with blank space.
// It appears to its owner as a Control of 0x0 size.
//
// For a Stack, Space can be used to insert spaces in the beginning or middle of Stacks (Stacks by nature handle spaces at the end themselves). In order for this to work properly, make the Space stretchy.
//
// For a Grid, Space can be used to have an empty cell. A stretchy Grid cell with a Space can be used to anchor the perimeter of a Grid to the respective Window edges without making one of the other controls stretchy instead (leaving empty space in the Window otherwise). Otherwise, you do not need to do anything special for the Space to work (though remember that an entire row or column of Spaces will appear as having height or width zero, respectively, unless one is marked as stretchy).
//
// The value returned from Space() may or may not be unique.
func Space() Control {
return space
}
// As above, a Stack with no controls draws nothing and reports no errors; its parent will still size it properly if made stretchy.
var space Control = newStack(horizontal)