x Lua script integration?
x XML loading
x	Make sure that XML files can refer to other widgets by XML files.
x		This way different widgets can use the same widget tree without copy+pasting the whole thing.

x XML with embedded Lua in text?
x	Might get weird with <, >, and other characters.

x Get Widget by name.
	!!! Get/set name.

x Cell padding.
x Focus.
  Images.
	Background images, especially.

x Text.

x Clipping.
x	REAL clipping.

x Scrollable areas.
x	Allows children to have whatever size, or...
x	Fixes one axis or the other to this widget's size.

Lists.
	Big Container with fixed row/column size.
	One axis will change sizes for this widget to expand as lists grow.
	
FUN STUFF
	Try implementing something like the Oblivion inventory UI for Lily.
x	I really hope I'm still inspired to do this later. :O

Some layout-related widgets:
x	PaddedBox
x		Just a widget with one child. Provides padding for that one child.
	Horizontal/Vertical expanding list
	
x !!!POINT OUT BLATANT XML ERRORS!!!

x have 9p size factor into minwidth/height

WindowManager (doesn't exist yet...)
	Pass mouse events to children, but if they don't eat them, use it to
	drag and switch focus anyway, as long as it hits the bounding box.

x We need more consistent rules as far as how things get sized.
x Especially for things like text, I guess.

x Stretchable row/column in container needs to respect the set
x 	width/height as a minimum?

x Maybe we need a fixSizes() that traverses the whole hierarchy.
x 	Gets called every frame. (Got implemented as children being marked dirty.)
	
Rules when doing that:
x	children must always expand to fill the size each is allowed
		Exceptions to this:
			Windows that can arbitrarily be resized and should be controlled by the user
x	container rows/columns must have minimum size equal to the largest
x		minimum size child in that row/col
x	row/cols should auto-expand to fit children like this.
	
x	should stuff also get auto-crushed down to its min size if given opportunity?
x		and should this affect row/col sizes?
x		row/cols then being just the size of the largest thing in it...
	
x MASSIVE CLEANUP

x Make it so console buffers can individually just be disabled. (ie: turn off warnings)

x Remove SDL_Thread stuff and replace with boost.

x Lua interface.
x Widget template-y stuff.

Ideas for objects:

x	AlignedBox -
x		Respects child's min width/height, but doesn't stretch it.
x		Min/Center/Max setting for each axis.
x		Child is positioned on each axis accordingly when AlignedBox is
x			bigger than child's min.
	
x	LayerBox
x		We really need this for nicer effects.
x		Contains a bunch of widgets stacked on top of each other.
x		Drawn back-to-front, but given events front-to-back.
		
	Rootbox
		Always tries to be its smallest size, but always on top of
			everything.
		Child of root object. Or something.
		Probably better just handled by a WindowManager class.

x Lua ideas: 
x	THIS IS A TERRIBLE IDEA and what was implemented is better. So I'm
x		marking it all done.
x		
x	C-style interface.
x		widgetGetBlah(widget);
x		widgetSetBlah(widget);
x		widgetGetChildByName(parent, "blah");
x		widgetGetRoot();
x		
x		widgetIsScrollable(widget); <- (Replace with whatever kind of widget.)
x		widgetScrollableSetOffsetX(widget, offsetx); <- Example of how to use functionality from specific classes.
x		
x		widgets can just be userdata, I guess.
		
x Order of stuff for Sunday:
x	Find that memory leak.	
x	Clean up current code.
x	DOCUMENT WIDGET TYPES and their XML silliness.
x	Document how containers map children to slots.
x	Make text use display lists.
x	Start on Lua API.
x	Marking text, copy+paste?

x	Document Lua API.
x		Generate documentation with wrappergen.

  Movable windows.
  Resizable widgets.
	Maybe implement this in WidgetPaddedBox and have it automatically
		make the padding area be the place to drag when reziing if it's
		enabled.
	Problem:
		Resizing on the right/bottom sides can be easy, (simple resize)
		but resizing on the left/top requires interaction with the
		parent and possible movement of that, up an unknown sized
		hierarchy of Widgets.
	Maybe make this specific to a Window/WindowManager pair of widgets?
		WindowManager can still be a child of something, allowing
		nested MDI-style layouts.



x  scrollbars
x	scrollable areas potentially know what amounts to properly add or
x		subtract on a pageup/pagedown. Maybe we should have it set
x		bigStepSize? Also make it respond to pgup/pgdown if nothing else
x		ate it.
x	scrollbox
x layerbox
x text marking/copying/pasting
x wrappergen documentation
x check/radio buttons
  joystick events
  tweens!
  handling of defaults
  "focused only" MultiParent
	Only show or give events to the focused child.
	Override switchFocus?
		Or just let it switch to the next thing...
	For tabbed stuff, for example.
	Combine with a radio button (tabs list) to switch focus.
x !!!! CHECK FOR parent/child cycles !!!!
  scale/rotate WidgetSingleParent things.
	Only rotate at 90 degree intervals, for simplicity.
		Then it's just a matter of swapping and inverting axes for display/events.
  Add some sanity to GL state.
	Big giant glPushAttrib() and reset at the start of rendering?
	Save projection matrix and set it to identity since we never use it.
		Restore it when done. Matrix stack won't work here.
	At the very least, add example boilerplate for getting started!
		I swear I'm never going to remember how to set all this crap up.
  !!! Button, and Slider need isSizeDirty() function !!!
? WidgetMultiParent probably needs isSizeDirty() that's currently in container.

Fix capslock keyrepeat bug.
	Make it recognize it and just treat it as shifted?
	Or not shifted?

