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

Implement set_size and set_position in terms of set_geometry

Restore parent to 0 if an exception occurs while setting things up

This prevents an inconsistent state from forming if something goes wrong.

Remove deprecated alias from Style loader

Check the return value of open_from_sources since it no longer throws

Ignore hidden widgets when solving a layout

At the moment this causes any constraints involving them to be ignored,
which may break constraint chains.

The entire row should be divided when initially making a column basic

Failing to do so will alter the row's meaning if the nonzero value in the
column is anything else than 1.0.

Take a Window pointer along with custom input devices

Guard against null pointers

Don't let input events that are passed to widgets go to other consumers

This was removed with event handling changes a while back, because other
changes needed to be made in libmspgui before reimplementation was
possible.

Fix a 64-bit compilation problem

Reintroduce the Resources constructor that immediately loads a file

This covers many simple use cases and avoids the need of creating a
sub-class to add sources or load data before a Root is created.

Restore ability to handle raw image files

Fix some problems with List and Dropdown

They probably still don't work perfectly, but there's bigger changes
coming when I have time.

Miscellaneous improvements for handling graphics

Allow specifying a custom spacing for a constraint

Initial implementation of middle gravity

This implementation is unsuitable for centering a group of widgets.  I
have a better one in mind, but no time to implement it now.

Bump version

Source compatibility was broken by commit 91997dd two years ago.

Update loaders to use ObjectLoader as base class

Font size loading fixes

When a font is specified, reset font size as well.

Add a font_size statement for overriding the size.

Allow Root widgets to be created with custom input devices

Implement the Layout::set_spacing function and friends

Change Style so it doesn't need a special loading function

Remove file lookup from Resources since a better mechanism exists now

Move all child widget handling into Container

This solves some problems like the slider of a list not receiving pointer
enter/leave events.  There are no obvious downsides either.  Widgets can
always override event handlers if they want to prevent something from
happening.

The event handlers are currently just combinations of those of the Panel
and Container classes.  They'll be smoothed out shortly.

Remove dead code from Panel::Child

Remove the extraneous and deprecated header component from Build file

Replace default_size -> native_size in the example font file

Use a GL::Renderer to render widgets

This eliminates a lot of texture and matrix thrashing.

Cache widget parts in meshes

This initial implementation is rather rough, but it paves the way for
using GL::Renderer.  It uses a lot of VBOs and is generally less efficient
than it could, but those will be addressed in the near future.  All
widgets haven't been tested, but the helloworld example works.

Add protected functions for manipulating widget state

Return a reference from Style::get_font

Styles always have a font, so the returned value could never be null.

Make font size a property of Style

Bind the font texture in Text::render

Add autosizing for panels

It still does a lot of unnecessary layout updates, but seems to work at
least in basic cases.

Don't try to solve if container is smaller than its margins

Attempting that would cause unsigneds to wrap around to very large values
and cause a weird solution.

Make LinearProgram robust against degenerate solutions

If the container is exactly the size required by the widgets, there will
be redundant equations, which causes a degeneracy in the phase 1 solution.

Report non-basic variables in Layout::LinearProgram as having zero value

Update layout when panel's geometry changes

Fix a crash if the linear program contains an empty column

Store autosized geom in Layout::Slot

This avoids having to autosize all widgets in the layout every time one of
them changes, and allows checking whether an update is actually needed.

Some cleanup in Layout

Improve comments of the Layout class

Add some code comments to describe how the constraints are built and how
the different parts of the simplex method work.  They don't entirely
explain the algorithm, but should help understanding the code.

Minor fixes to the documentation.

Miscellaneous other fixes

Adapt to Collection API changes

Adjust event handling to match changes in mspgui

Rework exceptions and use maputils

Update Build file with new library names and new features

Add .gitignore file, loosely based on svn:ignore

Strip copyright messages and id tags from individual files

Add some classes for automatically creating basic layouts
Some enhancements to the base Layout class

Add a Layout class to automatically position widgets within a Panel

Add a render method to Root that takes care of proper matrices

Add various constructors to Sides (semantics inspired by CSS margins)
Reduce code duplication in Alignment::apply

Avoid generating events during destruction of a widget

Add child_added/removed events to Container

Add a signal to notify when the automatic size of a widget changes

Adjust some slider checks

Implement autosize() method for most widgets
Only take content size into account if the relevant Part exists
Change List autosize() to set a height suitable for five rows
Additional methods to autosize for a set number of rows or all rows
Make sure that a Dropdown's List fits inside the Root

Loader improvements