Implement keyboard navigation for most widgets

Add a border around the focused widget in the basic skin

Allow an empty graphic to be specified in part definitions

It can be used to cancel out a graphic for specific states.

Refactor the traversal logic out of List::check_view_range

It'll be useful for other things as well.

Add an input method subsystem

It's necessary for implementing keyboard navigation and virtual keyboards.

Make keyboard event handlers indicate whether the event was handled

Reorder event handling functions

Use a larger font for the basic skin

A 10-pixel font is rather tiny.  The old font file was also lacking some
metrics.

Add another example application to demonstrate various widgets

Make sure gravity can't overpower expand

Move the helloworld example into a subdirectory

Rudimentary touchscreen support

There are no touch-specific interactions yet, but this allows input to
work with a touchscreen.

Make some functions const that by all rights should be

Fix exception description

Make func a normal argument of Text::process_lines

There isn't any real reason for it to be a template argument.

Clear dropdown text if the associated list selection is cleared

This is currently impossible to do by interacting with the widget, but
may happen if the selected item is removed.

Add a selection_cleared signal to List

Implement mouse wheel scrolling in List

If the active list item is refreshed, mark it as such

Use a shader for rendering if available

Use a Camera rather than direct matrix manipulation

Use triangle strips instead of quads

Style and comment fixes

Always set column widths on the item itself

A newly created item gets parented to the List before it appears in its
item array.  As such, the loop inside the if block won't reach it.

Fix line processing in Text to match autosizing

Improve Dropdown list management

Having the list marked as visible when it shouldn't be could cause trouble
in some corner cases.

There's no need to resize the list if it isn't visible.

Fix list positioning logic in Dropdown

Properly account for margins in sliders

Move some more common slider code to the base class

Fix a case where rebuild was called recursively

Add consistency checks to PartCache

Reuse meshes in PartCache to avoid buffer create/delete spam

Fix a segfault when refreshing an item in a list with MultiColumnItems

Don't rebuild on state change if there are no visual changes

Refactor list item positioning code

This fixes a bug where scrolling didn't quite work properly until each
item had been visible at least once.

Refactor child positioning logic

Avoid segfault with a single multi-column item

Add a list item class to manage multiple columns

Support floating widgets in layouts

An arrangement class that automatically makes widgets floating is also
added.

Fix some more inefficient autosizes

Better method of implementing zero gravity

Add getters for layout margin and spacings

Fix list autosizing logic

Make autosize_special const and add a const autosize overload

This should reduce useless back-and-forth resizing of widgets in several
common patterns.

Minor style fixes

Make widgets non-copyable

Remove obsolete inside checks

Make the DISABLED state actually do something

Make List::set_selected_index a no-op if that item was already selected

Support different font colors in different states

Add a shortcut for defining normal graphic

Add some utility functions for dealing with widget hierarchy

Add datafile statement for image widgets

Ensure that list items are autosized properly in all cases

Retain position when autosizing widget

Fix an uninitialized variable

Use a different approach for custom item widgets

Subclassed widgets can't be loaded from datafiles without providing custom
statements.  Dropdown doesn't allow changing the type of the List either.

Fix a comparison that let an off-by-one error in

Refresh list items one at a time

A blanket update doesn't work so well with items as widgets.

Recreate list items when setting data

Some new datafile keywords

Unify the behavior of value change signals

All widgets with such signals now emit them if the value is changed
programmatically, but only if it actually changed.

Add getter for Panel::layout

This is necessary for certain operations on a panel loaded from a
datafile.

Properly set expand flags in LinearArrangement

Fix some alignment issues in LinearArrangement

The slack column counter needs to be outside the slot loop

Add a function to find the index of an item in ListDataStore

Add DragHandle widget

Don't trigger widget rebuild if only its position changes

Refactor widget autosizing

Widget::autosize is no longer virtual.  Instead there's autosize_special,
which handles one part at a time.  This way all the important checks and
finalisations are done in one place.

Add a persistent view size attribute to List

Improve widget part caching

A single mesh can now hold multiple parts if they share the same texture.

Autosize all items in a List

Some fixes to the Build file

Avoid autosizing widgets with no style

Don't divide by zero when autosizing a List with no items

Add a Stack arrangement

Add a packing attribute to consider a widget even if it's hidden

Allow loading generic layout properties from datafiles

Support widget expansion in linear layouts

Combine common parts of Column and Row into LinearArrangement

Add some sanity checks to arrangements

Support specifying layouts in datafiles

Support loading dialog action buttons

Replace the derived layout classes with a more flexible design

The new Arrangement interface allows multiple arrangements to be used in
a single layout.  They can even be nested, with a sub-arrangement acting
like a single slot of its parent.

Use DerivedObjectLoader for widget loaders

Remove the Table widget

The layout system made it rather useless, and it suffered from similar
styling problems as List did before widget-based items.

Add constraint types that allow flexible spacing between widgets

Smarter way of complementing constraint types

Properly filter out duplicate constraints

Turn List items into widgets

This takes somewhat more resources, but offers much greader flexibility.
Items can be styled more freely and can contain pretty much anything.

Refactor pointer event handling in Container

More flexible storage for Lsit and Dropdown items

In many cases these widgets are used to pick an object.  Previously, the
calling code needed to explicitly maintain synchronization between the
objects and list contents.  This change allows the list to actually hold
pointers to the objects, making the retrieval of the selected object
vastly easier.

Add keywords to specify horizontal / vertical sides at once

Add properties to Entry for specifying autosize dimensions

Consider part margins when autosizing

Don't accept characters in Entry if there hasn't been a key press first

This rectifies a problem where a program reacts to a key press event by
focusing an Entry, which then receives the associated character event.

Set expand flag in Row and Column layouts on all widgets

Avoid putting tooltip label in layout

Comment and style updates