Use std::unique_ptr for managing memory

Refactor Panel to create Layout internally on request

The Panel always took ownership of the layout anyway, and there seems to
be little point to replace an existing layout with a new one.

Remove unnecessary Container::create_child

Overriding the child type has been obsolete since 1b29f19.

Style and comment updates

Minor refactoring

Use size_t to represent counts and indices

Convert all list containers to vectors

Make sure classes follow the rule of 0/3/5

Clear saved input focus if the widget is removed from the container

Checking the saved focus widget's parent in focus_in can lead to use
after free if the widget was deleted in the meantime.

Rename some get functions as find because they can return null

Use the override specifier when overriding a virtual function

Remove unnecessary destructors from exception classes

Use nullptr instead of 0 for pointers

Simplify constructors with C++11

Use default member initializers, defaulted constructors and constructor
delegation.

Convert loops and iterators to use C++11 features

Fix an uninitialized variable

Add API declarations

Remove deprecated and unmaintained interfaces

Bump version

The parameterless render() function got removed from Root, breaking
source compatibility.  More changes to come.

Adjust things to conform to changes in other libraries

Emit rebuild_needed from a container when a child is added

Otherwise the flag won't properly propagate if the container itself is
already parented.

Add a signal for selection changes in Entry

Fix a bug in selection handling when deleting text

Add a progress bar widget

Refactor edit position adjustments from Entry::insert and delete

Improve Dialog staleness checks

Buttons may be activated by a navigation event.  There's now a protected
function that derived classes can call if they implement custom mechanisms
for producing a response.

Add a page size feature to Slider

Refactor all slider logic into the Slider class

Having to write the same logic twice is annoying and more prone to
errors.

Mark Entry for rebuild when cursor starts or stops blinking

Defer widget rebuild to just before they are rendered

This improves performance especially with complex widgets like Entry.

Mark List::Item as receiving navigation input

To make it consistent with the fact that it can receive focus.

Rebuild Entry when the slider is moved

Adjust protections of list item base classes

Adjust a pointer check in Container

This is semantically equivalent but more intuitive and more tolerant to
mistakes.

Improve pointer grab handling

This fixes a bug where hiding a widget with active pointer grab would
leave the grab flag set, preventing pointer events from being sent
anywere.

Implement a grid view mode for List

Add a level of indirection to decouple list rows from items

This is required to support different kinds of views like grid and
possibly tree.

Cache the items part in List

Rename Widget::on_geometry_change to on_size_change

The new name better represents its actual function.

Add a helper class for single-child list items

Use the maximum item height for autosizing List

Use a LoadableTypeRegistry to manage child types for Panel

Ensure Text always has at least one line

Otherwise coords_to_geometry may access bogus data.

Add page up/down navigation to Entry

Implement next/previous navigation in Panel

The order is the one widgets were added in, which I think should produce
a sensible result in common scenarios.

Properly handle multibyte UTF-8 in Entry and Text

Emit signal_text_changed from Entry::set_text

Use RAII to ensure consistent PartCache state

end_rebuild needs to be called even if an exception is thrown during
rebuilding.

Fix an unsigned overflow error in Text

Select list items upon navigation by default

With control pressed, only the focus is moved.

Make sure Entry::first_row stays consistent

Shrinking and then enlarging an Entry caused first_row to first be set to
the edit position, but would never be reset to zero due to the check in
slider_value_changed.  Yet the visual result was correct thanks to Text
clamping first_row independently.

Add a signal for Entry widget text changes

Add a set_modal function for Dialog

Do not navigate out of a widget holding the pointer grab

Use separate widget class for Dialog

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