Added Windows uiGrid. Doesn't quite work yet.

2016-06-10 19:34:48 -04:00 · 2016-06-10 19:34:48 -04:00 · 554221fd66
parent 3a3b96a38e
commit 554221fd66
4 changed files with 583 additions and 469 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -7,6 +7,7 @@ cmake_minimum_required(VERSION 2.8.11)
 # 	- Haiku for haiku
 # - debian DESTDIR? https://github.com/andlabs/libui/pull/10
 # - libui-combined* needs to be deleted so that custom command can run every time
 # - add notelemetry.obj to *ALL TARGETS* on VS2015 and up - https://www.infoq.com/news/2016/06/visual-cpp-telemetry
 # the docs say we need to set this up prior to project()
 set(CMAKE_OSX_DEPLOYMENT_TARGET "10.8")
--- a/_wip/grid.go
+++ b/_wip/grid.go
@ -1,472 +1,4 @@
-// 31 august 2014
+func (g *grid) preferredSize(d *sizing) (width, height int) {}
 package ui
 import (
 	"fmt"
 )
 // Grid is a Control that arranges other Controls in a grid.
 // Grid is a very powerful container: it can position and size each Control in several ways and can (and must) have Controls added to it at any time, in any direction.
 // it can also have Controls spanning multiple rows and columns.
 //
 // Each Control in a Grid has associated "expansion" and "alignment" values in both the X and Y direction.
 // Expansion determines whether all cells in the same row/column are given whatever space is left over after figuring out how big the rest of the Grid should be.
 // Alignment determines the position of a Control relative to its cell after computing the above.
 // The special alignment Fill can be used to grow a Control to fit its cell.
 // Note that expansion and alignment are independent variables.
 // For more information on expansion and alignment, read https://developer.gnome.org/gtk3/unstable/ch28s02.html.
 type Grid interface {
 	Control
 	// Add adds a Control to the Grid.
 	// If this is the first Control in the Grid, it is merely added; nextTo should be nil.
 	// Otherwise, it is placed relative to nextTo.
 	// If nextTo is nil, it is placed next to the previously added Control.
 	// The effect of adding the same Control multiple times is undefined, as is the effect of adding a Control next to one not present in the Grid.
 	// The effect of overlapping spanning Controls is also undefined.
 	// Add panics if either xspan or yspan are zero or negative.
 	Add(control Control, nextTo Control, side Side, xexpand bool, xalign Align, yexpand bool, yalign Align, xspan int, yspan int)
 	// Padded and SetPadded get and set whether the controls of the Grid have padding between them.
 	// The size of the padding is platform-dependent.
 	Padded() bool
 	SetPadded(padded bool)
 }
 // Align represents the alignment of a Control in its cell of a Grid.
 type Align uint
 const (
 	LeftTop Align = iota
 	Center
 	RightBottom
 	Fill
 )
 // Side represents a side of a Control to add other Controls to a Grid to.
 type Side uint
 const (
 	West Side = iota
 	East
 	North
 	South
 	nSides
 )
 type grid struct {
 	controls []gridCell
 	indexof  map[Control]int
 	prev     int
 	parent	*controlParent
 	padded	bool
 	xmax int
 	ymax int
 }
 type gridCell struct {
 	control Control
 	xexpand bool
 	xalign  Align
 	yexpand bool
 	yalign  Align
 	xspan   int
 	yspan   int
 	x int
 	y int
 	finalx      int
 	finaly      int
 	finalwidth  int
 	finalheight int
 	prefwidth   int
 	prefheight  int
 }
 // NewGrid creates a new Grid with no Controls.
 func NewGrid() Grid {
 	return &grid{
 		indexof: map[Control]int{},
 	}
 }
 // ensures that all (x, y) pairs are 0-based
 // also computes g.xmax/g.ymax
 func (g *grid) reorigin() {
 	xmin := 0
 	ymin := 0
 	for i := range g.controls {
 		if g.controls[i].x < xmin {
 			xmin = g.controls[i].x
 		}
 		if g.controls[i].y < ymin {
 			ymin = g.controls[i].y
 		}
 	}
 	xmin = -xmin
 	ymin = -ymin
 	g.xmax = 0
 	g.ymax = 0
 	for i := range g.controls {
 		g.controls[i].x += xmin
 		g.controls[i].y += ymin
 		if g.xmax < g.controls[i].x+g.controls[i].xspan {
 			g.xmax = g.controls[i].x + g.controls[i].xspan
 		}
 		if g.ymax < g.controls[i].y+g.controls[i].yspan {
 			g.ymax = g.controls[i].y + g.controls[i].yspan
 		}
 	}
 }
 func (g *grid) Add(control Control, nextTo Control, side Side, xexpand bool, xalign Align, yexpand bool, yalign Align, xspan int, yspan int) {
 	if xspan <= 0 || yspan <= 0 {
 		panic(fmt.Errorf("invalid span %dx%d given to Grid.Add()", xspan, yspan))
 	}
 	cell := gridCell{
 		control: control,
 		xexpand: xexpand,
 		xalign:  xalign,
 		yexpand: yexpand,
 		yalign:  yalign,
 		xspan:   xspan,
 		yspan:   yspan,
 	}
 	if g.parent != nil {
 		control.setParent(g.parent)
 	}
 	// if this is the first control, just add it in directly
 	if len(g.controls) != 0 {
 		next := g.prev
 		if nextTo != nil {
 			next = g.indexof[nextTo]
 		}
 		switch side {
 		case West:
 			cell.x = g.controls[next].x - cell.xspan
 			cell.y = g.controls[next].y
 		case North:
 			cell.x = g.controls[next].x
 			cell.y = g.controls[next].y - cell.yspan
 		case East:
 			cell.x = g.controls[next].x + g.controls[next].xspan
 			cell.y = g.controls[next].y
 		case South:
 			cell.x = g.controls[next].x
 			cell.y = g.controls[next].y + g.controls[next].yspan
 		default:
 			panic(fmt.Errorf("invalid side %d in Grid.Add()", side))
 		}
 	}
 	g.controls = append(g.controls, cell)
 	g.prev = len(g.controls) - 1
 	g.indexof[control] = g.prev
 	g.reorigin()
 }
 func (g *grid) Padded() bool {
 	return g.padded
 }
 func (g *grid) SetPadded(padded bool) {
 	g.padded = padded
 }
 func (g *grid) setParent(p *controlParent) {
 	g.parent = p
 	for _, c := range g.controls {
 		c.control.setParent(g.parent)
 	}
 }
 func (g *grid) containerShow() {
 	for _, c := range g.controls {
 		c.control.containerShow()
 	}
 }
 func (g *grid) containerHide() {
 	for _, c := range g.controls {
 		c.control.containerHide()
 	}
 }
 // builds the topological cell grid; also makes colwidths and rowheights
 func (g *grid) mkgrid() (gg [][]int, colwidths []int, rowheights []int) {
 	gg = make([][]int, g.ymax)
 	for y := 0; y < g.ymax; y++ {
 		gg[y] = make([]int, g.xmax)
 		for x := 0; x < g.xmax; x++ {
 			gg[y][x] = -1
 		}
 	}
 	for i := range g.controls {
 		for y := g.controls[i].y; y < g.controls[i].y+g.controls[i].yspan; y++ {
 			for x := g.controls[i].x; x < g.controls[i].x+g.controls[i].xspan; x++ {
 				gg[y][x] = i
 			}
 		}
 	}
 	return gg, make([]int, g.xmax), make([]int, g.ymax)
 }
 func (g *grid) resize(x int, y int, width int, height int, d *sizing) {
 	if len(g.controls) == 0 {
 		// nothing to do
 		return
 	}
 	// -2) get this Grid's padding
 	xpadding := d.xpadding
 	ypadding := d.ypadding
 	if !g.padded {
 		xpadding = 0
 		ypadding = 0
 	}
 	// -1) discount padding from width/height
 	width -= (g.xmax - 1) * xpadding
 	height -= (g.ymax - 1) * ypadding
 	// 0) build necessary data structures
 	gg, colwidths, rowheights := g.mkgrid()
 	xexpand := make([]bool, g.xmax)
 	yexpand := make([]bool, g.ymax)
 	// 1) compute colwidths and rowheights before handling expansion
 	// we only count non-spanning controls to avoid weirdness
 	for y := 0; y < len(gg); y++ {
 		for x := 0; x < len(gg[y]); x++ {
 			i := gg[y][x]
 			if i == -1 {
 				continue
 			}
 			w, h := g.controls[i].control.preferredSize(d)
 			if g.controls[i].xspan == 1 {
 				if colwidths[x] < w {
 					colwidths[x] = w
 				}
 			}
 			if g.controls[i].yspan == 1 {
 				if rowheights[y] < h {
 					rowheights[y] = h
 				}
 			}
 			// save these for step 6
 			g.controls[i].prefwidth = w
 			g.controls[i].prefheight = h
 		}
 	}
 	// 2) figure out which rows/columns expand but not span
 	// we need to know which expanding rows/columns don't span before we can handle the ones that do
 	for i := range g.controls {
 		if g.controls[i].xexpand && g.controls[i].xspan == 1 {
 			xexpand[g.controls[i].x] = true
 		}
 		if g.controls[i].yexpand && g.controls[i].yspan == 1 {
 			yexpand[g.controls[i].y] = true
 		}
 	}
 	// 2) figure out which rows/columns expand that do span
 	// the way we handle this is simple: if none of the spanned rows/columns expand, make all rows/columns expand
 	for i := range g.controls {
 		if g.controls[i].xexpand && g.controls[i].xspan != 1 {
 			do := true
 			for x := g.controls[i].x; x < g.controls[i].x+g.controls[i].xspan; x++ {
 				if xexpand[x] {
 					do = false
 					break
 				}
 			}
 			if do {
 				for x := g.controls[i].x; x < g.controls[i].x+g.controls[i].xspan; x++ {
 					xexpand[x] = true
 				}
 			}
 		}
 		if g.controls[i].yexpand && g.controls[i].yspan != 1 {
 			do := true
 			for y := g.controls[i].y; y < g.controls[i].y+g.controls[i].yspan; y++ {
 				if yexpand[y] {
 					do = false
 					break
 				}
 			}
 			if do {
 				for y := g.controls[i].y; y < g.controls[i].y+g.controls[i].yspan; y++ {
 					yexpand[y] = true
 				}
 			}
 		}
 	}
 	// 4) compute and assign expanded widths/heights
 	nxexpand := 0
 	nyexpand := 0
 	for x, expand := range xexpand {
 		if expand {
 			nxexpand++
 		} else {
 			width -= colwidths[x]
 		}
 	}
 	for y, expand := range yexpand {
 		if expand {
 			nyexpand++
 		} else {
 			height -= rowheights[y]
 		}
 	}
 	for x, expand := range xexpand {
 		if expand {
 			colwidths[x] = width / nxexpand
 		}
 	}
 	for y, expand := range yexpand {
 		if expand {
 			rowheights[y] = height / nyexpand
 		}
 	}
 	// 5) reset the final coordinates for the next step
 	for i := range g.controls {
 		g.controls[i].finalx = 0
 		g.controls[i].finaly = 0
 		g.controls[i].finalwidth = 0
 		g.controls[i].finalheight = 0
 	}
 	// 6) compute cell positions and sizes
 	for y := 0; y < g.ymax; y++ {
 		curx := 0
 		prev := -1
 		for x := 0; x < g.xmax; x++ {
 			i := gg[y][x]
 			if i != -1 && y == g.controls[i].y { // don't repeat this step if the control spans vertically
 				if i != prev {
 					g.controls[i].finalx = curx
 				} else {
 					g.controls[i].finalwidth += xpadding
 				}
 				g.controls[i].finalwidth += colwidths[x]
 			}
 			curx += colwidths[x] + xpadding
 			prev = i
 		}
 	}
 	for x := 0; x < g.xmax; x++ {
 		cury := 0
 		prev := -1
 		for y := 0; y < g.ymax; y++ {
 			i := gg[y][x]
 			if i != -1 && x == g.controls[i].x { // don't repeat this step if the control spans horizontally
 				if i != prev {
 					g.controls[i].finaly = cury
 				} else {
 					g.controls[i].finalheight += ypadding
 				}
 				g.controls[i].finalheight += rowheights[y]
 			}
 			cury += rowheights[y] + ypadding
 			prev = i
 		}
 	}
 	// 7) everything as it stands now is set for xalign == Fill yalign == Fill; set the correct alignments
 	// this is why we saved prefwidth/prefheight above
 	for i := range g.controls {
 		if g.controls[i].xalign != Fill {
 			switch g.controls[i].xalign {
 			case RightBottom:
 				g.controls[i].finalx += g.controls[i].finalwidth - g.controls[i].prefwidth
 			case Center:
 				g.controls[i].finalx += (g.controls[i].finalwidth - g.controls[i].prefwidth) / 2
 			}
 			g.controls[i].finalwidth = g.controls[i].prefwidth // for all three
 		}
 		if g.controls[i].yalign != Fill {
 			switch g.controls[i].yalign {
 			case RightBottom:
 				g.controls[i].finaly += g.controls[i].finalheight - g.controls[i].prefheight
 			case Center:
 				g.controls[i].finaly += (g.controls[i].finalheight - g.controls[i].prefheight) / 2
 			}
 			g.controls[i].finalheight = g.controls[i].prefheight // for all three
 		}
 	}
 	// 8) and FINALLY we draw
 	for _, ycol := range gg {
 		for _, i := range ycol {
 			if i != -1 { // treat empty cells like spaces
 				g.controls[i].control.resize(
 					g.controls[i].finalx+x, g.controls[i].finaly+y,
 					g.controls[i].finalwidth, g.controls[i].finalheight, d)
 			}
 		}
 	}
 	return
 }
 func (g *grid) preferredSize(d *sizing) (width, height int) {
 	if len(g.controls) == 0 {
 		// nothing to do
 		return 0, 0
 	}
 	// -1) get this Grid's padding
 	xpadding := d.xpadding
 	ypadding := d.ypadding
 	if !g.padded {
 		xpadding = 0
 		ypadding = 0
 	}
 	// 0) build necessary data structures
 	gg, colwidths, rowheights := g.mkgrid()
 	// 1) compute colwidths and rowheights before handling expansion
 	// TODO put this in its own function (but careful about the spanning calculation in allocate())
 	for y := 0; y < len(gg); y++ {
 		for x := 0; x < len(gg[y]); x++ {
 			i := gg[y][x]
 			if i == -1 {
 				continue
 			}
 			w, h := g.controls[i].control.preferredSize(d)
 			// allot equal space in the presence of spanning to keep things sane
 			if colwidths[x] < w/g.controls[i].xspan {
 				colwidths[x] = w / g.controls[i].xspan
 			}
 			if rowheights[y] < h/g.controls[i].yspan {
 				rowheights[y] = h / g.controls[i].yspan
 			}
 			// save these for step 6
 			g.controls[i].prefwidth = w
 			g.controls[i].prefheight = h
 		}
 	}
 	// 2) compute total column width/row height
 	colwidth := 0
 	rowheight := 0
 	for _, w := range colwidths {
 		colwidth += w
 	}
 	for _, h := range rowheights {
 		rowheight += h
 	}
 	// and that's it; just account for padding
 	return colwidth + (g.xmax-1) * xpadding,
 		rowheight + (g.ymax-1) * ypadding
 }
 func (g *grid) nTabStops() int {
 	n := 0
--- a/windows/CMakeLists.txt
+++ b/windows/CMakeLists.txt
@ -30,6 +30,7 @@ list(APPEND _LIBUI_SOURCES
 	windows/fontdialog.cpp
 	windows/form.cpp
 	windows/graphemes.cpp
 	windows/grid.cpp
 	windows/group.cpp
 	windows/init.cpp
 	windows/label.cpp
--- a/windows/grid.cpp
+++ b/windows/grid.cpp
@ -0,0 +1,580 @@
 // 10 june 2016
 #include "uipriv_windows.hpp"
 // TODO compare with GTK+:
 // - what happens if you call InsertAt() twice?
 // - what happens if you call Append() twice?
 // TODOs
 // - make ALL the controls handle hidden children right
 struct gridChild {
 	uiControl *c;
 	intmax_t left;
 	intmax_t top;
 	intmax_t xspan;
 	intmax_t yspan;
 	int hexpand;
 	uiAlign halign;
 	int vexpand;
 	uiAlign valign;
 	// have these here so they don't need to be reallocated each relayout
 	intmax_t finalx, finaly;
 	intmax_t finalwidth, finalheight;
 	intmax_t minwidth, minheight;
 };
 struct uiGrid {
 	uiWindowsControl c;
 	HWND hwnd;
 	std::vector<struct gridChild *> *children;
 	std::map<uiControl *, size_t> *indexof;
 	int padded;
 	intmax_t xmin, ymin;
 	intmax_t xmax, ymax;
 };
 #define xcount(g) ((g)->xmax - (g)->xmin)
 #define ycount(g) ((g)->ymax - (g)->ymin)
 #define toxindex(g, x) ((x) - (g)->xmin)
 #define toyindex(g, y) ((y) - (g)->ymin)
 class gridLayoutData {
 	size_t ycount;
 public:
 	intmax_t **gg;		// topological map gg[y][x] = control index
 	intmax_t *colwidths;
 	intmax_t *rowheights;
 	bool *hexpand;
 	bool *vexpand;
 	gridLayoutData(uiGrid *g)
 	{
 		size_t i;
 		intmax_t x, y;
 		this->gg = new intmax_t *[ycount(g)];
 		for (y = 0; y < ycount(g); y++) {
 			this->gg[y] = new intmax_t[xcount(g)];
 			for (x = 0; x < xcount(g); x++)
 				this->gg[y][x] = -1;
 		}
 		for (i = 0; i < g->children->size(); i++) {
 			struct gridChild *gc;
 			gc = (*(g->children))[i];
 			for (y = gc->top; y < gc->top + gc->yspan; y++)
 				for (x = gc->left; x < gc->left + gc->xspan; x++)
 					this->gg[toyindex(g, y)][toxindex(g, x)] = i;
 		}
 		this->colwidths = new intmax_t[xcount(g)];
 		ZeroMemory(this->colwidths, xcount(g) * sizeof (intmax_t));
 		this->rowheights = new intmax_t[ycount(g)];
 		ZeroMemory(this->rowheights, ycount(g) * sizeof (intmax_t));
 		this->hexpand = new bool[xcount(g)];
 		ZeroMemory(this->hexpand, xcount(g) * sizeof (bool));
 		this->vexpand = new bool[ycount(g)];
 		ZeroMemory(this->vexpand, ycount(g) * sizeof (bool));
 		this->ycount = ycount(g);
 	}
 	~gridLayoutData()
 	{
 		size_t y;
 		delete[] this->hexpand;
 		delete[] this->vexpand;
 		delete[] this->colwidths;
 		delete[] this->rowheights;
 		for (y = 0; y < this->ycount; y++)
 			delete[] this->gg[y];
 		delete[] this->gg;
 	}
 };
 static void gridPadding(uiGrid *g, int *xpadding, int *ypadding)
 {
 	uiWindowsSizing sizing;
 	*xpadding = 0;
 	*ypadding = 0;
 	if (g->padded) {
 		uiWindowsGetSizing(g->hwnd, &sizing);
 		uiWindowsSizingStandardPadding(&sizing, xpadding, ypadding);
 	}
 }
 static void gridRelayout(uiGrid *g)
 {
 	RECT r;
 	intmax_t x, y, width, height;
 	gridLayoutData *ld;
 	int xpadding, ypadding;
 	intmax_t ix, iy;
 	intmax_t iwidth, iheight;
 	int i;
 	struct gridChild *gc;
 	intmax_t nhexpand, nvexpand;
 	if (g->children->size() == 0)
 		return;		// nothing to do
 	uiWindowsEnsureGetClientRect(g->hwnd, &r);
 	x = r.left;
 	y = r.top;
 	width = r.right - r.left;
 	height = r.bottom - r.top;
 	gridPadding(g, &xpadding, &ypadding);
 	ld = new gridLayoutData(g);
 	// 0) discount padding from width/height
 	width -= (xcount(g) - 1) * xpadding;
 	height -= (ycount(g) - 1) * ypadding;
 	// 1) compute colwidths and rowheights before handling expansion
 	// we only count non-spanning controls to avoid weirdness
 	for (iy = 0; iy < ycount(g); iy++)
 		for (ix = 0; ix < xcount(g); ix++) {
 			i = ld->gg[iy][ix];
 			if (i == -1)
 				continue;
 			gc = (*(g->children))[i];
 			uiWindowsControlMinimumSize(uiWindowsControl(gc->c), &iwidth, &iheight);
 			if (gc->xspan == 1)
 				if (ld->colwidths[ix] < iwidth)
 					ld->colwidths[ix] = iwidth;
 			if (gc->yspan == 1)
 				if (ld->rowheights[iy] < iheight)
 					ld->rowheights[iy] = iheight;
 			// save these for step 6
 			gc->minwidth = iwidth;
 			gc->minheight = iheight;
 		}
 	// 2) figure out which rows/columns expand but not span
 	// we need to know which expanding rows/columns don't span before we can handle the ones that do
 	for (i = 0; i < g->children->size(); i++) {
 		gc = (*(g->children))[i];
 		if (gc->hexpand && gc->xspan == 1)
 			ld->hexpand[gc->left] = true;
 		if (gc->vexpand && gc->yspan == 1)
 			ld->vexpand[gc->top] = true;
 	}
 	// 3) figure out which rows/columns expand that do span
 	// the way we handle this is simple: if none of the spanned rows/columns expand, make all rows/columns expand
 	for (i = 0; i < g->children->size(); i++) {
 		gc = (*(g->children))[i];
 		if (gc->hexpand && gc->xspan != 1) {
 			bool doit = true;
 			for (ix = gc->left; ix < gc->left + gc->xspan; ix++)
 				if (ld->hexpand[ix]) {
 					doit = false;
 					break;
 				}
 			if (doit)
 				for (ix = gc->left; ix < gc->left + gc->xspan; ix++)
 					ld->hexpand[ix] = true;
 		}
 		if (gc->vexpand && gc->yspan != 1) {
 			bool doit = true;
 			for (iy = gc->top; iy < gc->top + gc->yspan; iy++)
 				if (ld->vexpand[iy]) {
 					doit = false;
 					break;
 				}
 			if (doit)
 				for (iy = gc->top; iy < gc->top + gc->yspan; iy++)
 					ld->vexpand[iy] = true;
 		}
 	}
 	// 4) compute and assign expanded widths/heights
 	nhexpand = 0;
 	nvexpand = 0;
 	for (i = 0; i < xcount(g); i++)
 		if (ld->hexpand[i])
 			nhexpand++;
 		else
 			width -= ld->colwidths[i];
 	for (i = 0; i < ycount(g); i++)
 		if (ld->vexpand[i])
 			nvexpand++;
 		else
 			height -= ld->rowheights[i];
 	for (i = 0; i < xcount(g); i++)
 		if (ld->hexpand[i])
 			ld->colwidths[i] = width / nhexpand;
 	for (i = 0; i < ycount(g); i++)
 		if (ld->vexpand[i])
 			ld->rowheights[i] = height / nvexpand;
 	// 5) reset the final coordinates for the next step
 	for (i = 0; i < g->children->size(); i++) {
 		gc = (*(g->children))[i];
 		gc->finalx = 0;
 		gc->finaly = 0;
 		gc->finalwidth = 0;
 		gc->finalheight = 0;
 	}
 	// 6) compute cell positions and sizes
 	for (iy = 0; iy < ycount(g); y++) {
 		intmax_t curx;
 		int prev;
 		curx = 0;
 		prev = -1;
 		for (ix = 0; ix < xcount(g); ix++) {
 			i = ld->gg[iy][ix];
 			if (i != -1) {
 				gc = (*(g->children))[i];
 				if (iy == gc->top) {			// don't repeat this step if the control spans vertically
 					if (i != prev)
 						gc->finalx = curx;
 					else
 						gc->finalwidth += xpadding;
 					gc->finalwidth += ld->colwidths[ix];
 				}
 			}
 			curx += ld->colwidths[ix] + xpadding;
 			prev = i;
 		}
 	}
 	for (ix = 0; ix < xcount(g); ix++) {
 		intmax_t cury;
 		int prev;
 		cury = 0;
 		prev = -1;
 		for (iy = 0; iy < ycount(g); iy++) {
 			i = ld->gg[iy][ix];
 			if (i != -1) {
 				gc = (*(g->children))[i];
 				if (x == gc->top) {		// don't repeat this step if the control spans horizontally
 					if (i != prev)
 						gc->finaly = cury;
 					else
 						gc->finalheight += ypadding;
 					gc->finalheight += ld->rowheights[iy];
 				}
 			}
 			cury += ld->rowheights[iy] + ypadding;
 			prev = i;
 		}
 	}
 	// 7) everything as it stands now is set for xalign == Fill yalign == Fill; set the correct alignments
 	// this is why we saved minwidth/minheight above
 	for (i = 0; i < g->children->size(); i++) {
 		gc = (*(g->children))[i];
 		if (gc->halign != uiAlignFill) {
 			switch (gc->halign) {
 			case uiAlignEnd:
 				gc->finalx += gc->finalwidth - gc->minwidth;
 				break;
 			case uiAlignCenter:
 				gc->finalx += (gc->finalwidth - gc->minwidth) / 2;
 				break;
 			}
 			gc->finalwidth = gc->minwidth;		// for all three
 		}
 		if (gc->valign != uiAlignFill) {
 			switch (gc->valign) {
 			case uiAlignEnd:
 				gc->finaly += gc->finalheight - gc->minheight;
 				break;
 			case uiAlignCenter:
 				gc->finaly += (gc->finalheight - gc->minheight) / 2;
 				break;
 			}
 			gc->finalheight = gc->minheight;		// for all three
 		}
 	}
 	// 8) and FINALLY we resize
 	for (iy = 0; iy < ycount(g); iy++)
 		for (ix = 0; ix < xcount(g); ix++) {
 			i = ld->gg[iy][ix];
 			if (i != -1) {		// treat empty cells like spaces
 				gc = (*(g->children))[i];
 				uiWindowsEnsureMoveWindowDuringResize(
 					(HWND) uiControlHandle(gc->c),
 					gc->finalx,//TODO + x,
 					gc->finaly,//TODO + y,
 					gc->finalwidth,
 					gc->finalheight);
 			}
 		}
 	delete ld;
 }
 static void uiGridDestroy(uiControl *c)
 {
 	uiGrid *g = uiGrid(c);
 	for (struct gridChild *gc : *(g->children)) {
 		uiControlSetParent(gc->c, NULL);
 		uiControlDestroy(gc->c);
 		uiFree(gc);
 	}
 	delete g->indexof;
 	delete g->children;
 	uiWindowsEnsureDestroyWindow(g->hwnd);
 	uiFreeControl(uiControl(g));
 }
 uiWindowsControlDefaultHandle(uiGrid)
 uiWindowsControlDefaultParent(uiGrid)
 uiWindowsControlDefaultSetParent(uiGrid)
 uiWindowsControlDefaultToplevel(uiGrid)
 uiWindowsControlDefaultVisible(uiGrid)
 uiWindowsControlDefaultShow(uiGrid)
 uiWindowsControlDefaultHide(uiGrid)
 uiWindowsControlDefaultEnabled(uiGrid)
 uiWindowsControlDefaultEnable(uiGrid)
 uiWindowsControlDefaultDisable(uiGrid)
 static void uiGridSyncEnableState(uiWindowsControl *c, int enabled)
 {
 	uiGrid *g = uiGrid(c);
 	if (uiWindowsShouldStopSyncEnableState(uiWindowsControl(g), enabled))
 		return;
 	for (const struct gridChild *gc : *(g->children))
 		uiWindowsControlSyncEnableState(uiWindowsControl(gc->c), enabled);
 }
 uiWindowsControlDefaultSetParentHWND(uiGrid)
 static void uiGridMinimumSize(uiWindowsControl *c, intmax_t *width, intmax_t *height)
 {
 	uiGrid *g = uiGrid(c);
 	int xpadding, ypadding;
 	gridLayoutData *ld;
 	intmax_t x, y;
 	int i;
 	struct gridChild *gc;
 	intmax_t minwid, minht;
 	intmax_t colwidth, rowheight;
 	*width = 0;
 	*height = 0;
 	if (g->children->size() == 0)
 		return;		// nothing to do
 	gridPadding(g, &xpadding, &ypadding);
 	ld = new gridLayoutData(g);
 	// 1) compute colwidths and rowheights before handling expansion
 	// TODO put this in its own function (but careful about the spanning calculation in gridRelayout())
 	for (y = 0; y < ycount(g); y++)
 		for (x = 0; x < xcount(g); x++) {
 			i = ld->gg[y][x];
 			if (i == -1)
 				continue;
 			gc = (*(g->children))[i];
 			uiWindowsControlMinimumSize(uiWindowsControl(gc->c), &minwid, &minht);
 			// allot equal space in the presence of spanning to keep things sane
 			if (ld->colwidths[x] < minwid / gc->xspan)
 				ld->colwidths[x] = minwid / gc->xspan;
 			if (ld->rowheights[y] < minht / gc->yspan)
 				ld->rowheights[y] = minht / gc->yspan;
 			// save these for step 6
 			gc->minwidth = minwid;
 			gc->minheight = minht;
 		}
 	// 2) compute total column width/row height
 	colwidth = 0;
 	rowheight = 0;
 	for (x = 0; x < xcount(g); x++)
 		colwidth += ld->colwidths[x];
 	for (y = 0; y < ycount(g); y++)
 		rowheight += ld->rowheights[y];
 	// and that's it; just account for padding
 	*width = colwidth + (g->xmax-1) * xpadding;
 	*height = rowheight + (g->ymax-1) * ypadding;
 }
 static void uiGridMinimumSizeChanged(uiWindowsControl *c)
 {
 	uiGrid *g = uiGrid(c);
 	if (uiWindowsControlTooSmall(uiWindowsControl(g))) {
 		uiWindowsControlContinueMinimumSizeChanged(uiWindowsControl(g));
 		return;
 	}
 	gridRelayout(g);
 }
 uiWindowsControlDefaultLayoutRect(uiGrid)
 uiWindowsControlDefaultAssignControlIDZOrder(uiGrid)
 // must have called gridRecomputeMinMax() first
 static void gridArrangeChildren(uiGrid *g)
 {
 	LONG_PTR controlID;
 	HWND insertAfter;
 	gridLayoutData *ld;
 	bool *visited;
 	intmax_t x, y;
 	int i;
 	struct gridChild *gc;
 	if (g->children->size() == 0)
 		return;		// nothing to do
 	ld = new gridLayoutData(g);
 	controlID = 100;
 	insertAfter = NULL;
 	visited = new bool[g->children->size()];
 	ZeroMemory(visited, g->children->size() * sizeof (bool));
 	for (y = 0; y < ycount(g); y++)
 		for (x = 0; x < xcount(g); x++) {
 			i = ld->gg[y][x];
 			if (i == -1)
 				continue;
 			if (visited[i])
 				continue;
 			visited[i] = true;
 			gc = (*(g->children))[i];
 			uiWindowsControlAssignControlIDZOrder(uiWindowsControl(gc->c), &controlID, &insertAfter);
 		}
 	delete[] visited;
 	delete ld;
 }
 static void gridRecomputeMinMax(uiGrid *g)
 {
 	bool first = true;
 	for (struct gridChild *gc : *(g->children)) {
 		if (first) {
 			g->xmin = gc->left;
 			g->ymin = gc->top;
 			g->xmax = gc->left + gc->xspan;
 			g->ymax = gc->top + gc->yspan;
 			first = false;
 			continue;
 		}
 		if (g->xmin > gc->left)
 			g->xmin = gc->left;
 		if (g->ymin > gc->top)
 			g->ymin = gc->top;
 		if (g->xmax < (gc->left + gc->xspan))
 			g->xmax = gc->left + gc->xspan;
 		if (g->ymax < (gc->top + gc->yspan))
 			g->ymax = gc->top + gc->yspan;
 	}
 }
 static struct gridChild *toChild(uiControl *c, intmax_t xspan, intmax_t yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)
 {
 	struct gridChild *gc;
 	if (xspan < 0)
 		userbug("You cannot have a negative xspan in a uiGrid cell.");
 	if (yspan < 0)
 		userbug("You cannot have a negative yspan in a uiGrid cell.");
 	gc = uiNew(struct gridChild);
 	gc->c = c;
 	gc->xspan = xspan;
 	gc->yspan = yspan;
 	gc->hexpand = hexpand;
 	gc->halign = halign;
 	gc->vexpand = vexpand;
 	gc->valign = valign;
 	return gc;
 }
 static void add(uiGrid *g, struct gridChild *gc)
 {
 	uiControlSetParent(gc->c, uiControl(g));
 	uiWindowsControlSetParentHWND(uiWindowsControl(gc->c), g->hwnd);
 	g->children->push_back(gc);
 	(*(g->indexof))[gc->c] = g->children->size() - 1;
 	gridRecomputeMinMax(g);
 	gridArrangeChildren(g);
 	uiWindowsControlMinimumSizeChanged(uiWindowsControl(g));
 }
 void uiGridAppend(uiGrid *g, uiControl *c, intmax_t left, intmax_t top, intmax_t xspan, intmax_t yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)
 {
 	struct gridChild *gc;
 	gc = toChild(c, xspan, yspan, hexpand, halign, vexpand, valign);
 	gc->left = left;
 	gc->top = top;
 	add(g, gc);
 }
 // TODO decide what happens if existing is NULL
 void uiGridInsertAt(uiGrid *g, uiControl *c, uiControl *existing, uiAt at, intmax_t xspan, intmax_t yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)
 {
 	struct gridChild *gc;
 	struct gridChild *other;
 	gc = toChild(c, xspan, yspan, hexpand, halign, vexpand, valign);
 	other = (*(g->children))[(*(g->indexof))[existing]];
 	switch (at) {
 	case uiAtLeading:
 		gc->left = other->left - gc->xspan;
 		gc->top = other->top;
 		break;
 	case uiAtTop:
 		gc->left = other->left;
 		gc->top = other->top - gc->yspan;
 		break;
 	case uiAtTrailing:
 		gc->left = other->left + other->xspan;
 		gc->top = other->top;
 		break;
 	case uiAtBottom:
 		gc->left = other->left;
 		gc->top = other->top + other->yspan;
 		break;
 	// TODO add error checks to ALL enums
 	}
 	add(g, gc);
 }
 int uiGridPadded(uiGrid *g)
 {
 	return g->padded;
 }
 void uiGridSetPadded(uiGrid *g, int padded)
 {
 	g->padded = padded;
 	uiWindowsControlMinimumSizeChanged(uiWindowsControl(g));
 }
 static void onResize(uiWindowsControl *c)
 {
 	gridRelayout(uiGrid(c));
 }
 uiGrid *uiNewGrid(void)
 {
 	uiGrid *g;
 	uiWindowsNewControl(uiGrid, g);
 	g->hwnd = uiWindowsMakeContainer(uiWindowsControl(g), onResize);
 	g->children = new std::vector<struct gridChild *>;
 	g->indexof = new std::map<uiControl *, size_t>;
 	return g;
 }