Remember the last input focus of a Container and restore it when focused

Some more interfaces to support integrating Entry with other components

Avoid duplicating the logic in Entry::get_selection

Collapse the two implementations of Entry::set_edit_position

Use the public functions also in internal edit operations of Entry

Refactor visible height calculation in Entry and Text

It's now contained in a common function to ensure it's calculated the
same way in both.

Improve vertical positioning of text

Applying alignment to only the number of lines that fit in the widget
results in a more consistent position.

Add some editing functions to Entry

Interpret shift+tab as NAV_PREVIOUS

Add modifier state enum

This was supposed to be in 6e5db3e

Implement a selection feature in Entry widget

Handle home and end keys in Entry widget

Pass modifier state to key_press and key_release functions

Add an event handler to allow containers to reach to focus changes

Only focus widgets if the container is focused

This prevents issues where a widget could be focused before it's added
to a rooted hierarchy, presenting inconsistent focus state.

Make the entry widget cursor blink

If the cursor part has different graphics for normal and active states,
it will toggle between those every half a second while the widget is
focused.

Add a system for animating widgets

Add a flag to make widgets in a LinearArrangement the same size

Update deprecated things

Change Root::render to use the passed in Renderer

Add nameless child keywords for Panel

Additionally, use a template specialization rather than separate function
for a child which is itself a Panel.

Allow overriding the spacing between two widgets in LinearArrangement

Change the Resources reference in Root to non-const

It might be necessary to load textures on the fly.

Add a datafile statement to set an icon for an Image

Update Renderer matrix manipulation calls

Explicitly require sigc++-2.0

Inherit Root from GL::Renderable

This allows better integration with GL::Pipeline and the new GL::View
class.

Focus entry widget on touch press

Add lexical conversion for the centering constraints

Rewrite Panel navigation logic so it makes more sense

Rather than calculating distances between widget centers it now considers
the closeness of their edges.  It's not perfect but better than before.

Add centering constraints to Layout

Add support for displaying named icons in an Image widget

Only pass key and navigation events to enabled widgets

It would be even better to not allow them to be focused in the first
place, but that raises issues such as where to put the focus if the
focused widget gets disabled.  So this will have to do.

Pass List::focus_in to base class

It sets the FOCUS flag in state, which is then checked to determine
whether to focus items.

Implement touch interactions for List

It wasn't working on touchscreens at all because the touch events were
passed to the list items by Container and not converted into mouse events
for the list itself to process.

Fix an incorrectly positioned graphic

Improve list focus management

Now that containers no longer get an implicit navigation event when
focused, list must take care of focusing the correct item itself.

Move navigation logic from Container to Panel

A number of widgets inherit from Container because they have internal
sub-widgets, but have their own navigation logic.  Panel is the user-
visible generic container.

Don't pass events to an invisible root widget

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