transition-view: Group properties by entity not component

When a property for a component is added it will now add the property
to the group for the component's entity instead of making a separate
unnamed group for the component. The properties are sorted by name
within a group and the groups are sorted so that the entity properties
are always first. Other components are just sorted by the their
address because it probably doesn't really matter what the order is as
long as it is consistent.
transition-view: Use explicit variables to track the area for nodes

Previously there was a variable to store the width of the area for the
property labels. Everything that wanted to know the position of the
area for nodes would calculate it by subtracting the width of the
labels from the total width. Instead of that there are now separate
variables for the x position and the width of the area for the nodes
so that later it will be easier to move the area.
transition-view: Separate out the dot size from the row height

The dot size is now stored in a separate variable to make it easier to
change the size.
transition-view: Make some cosmetic changes

• There is a grid shown for the nodes drawn using a repeated texture.
  The texture is generated to be the same size as the row height.

• There is some padding around the property labels.

• There is now a separator between the labels and the nodes area.

• The nodes area has a white background.

• The dots are slightly smaller with different colours.

• The labels for the objects are in bold.
ui-viewport: Align the translation to a pixel boundary

When the scale is 1.0 it will now align the translation of the
viewport to the nearest pixel. Otherwise when scrolling the transition
view the text can end up mis-aligned and it will look blurry.
rut-ui-viewport: Remove the unused update_scroll_bars function

This function is unused and instead its functionality is implemented
in position_scroll_bars(). Let's remove it to avoid confusion.
ui-viewport: Remove the public width/height setters and getters

The separate setters for the width and height have been removed and
the property has been made read only. The public functions to set and
get the size have also been converted into static functions. Instead
any other code that wants to query the size should use the sizable
interface.
scroll-bar: Add rut_scroll_bar_get_virtual_viewport

This just adds a getter for the viewport size so that later the
RutUIViewport can use it to determine how much to scroll when handling
page up/down keypresses.
ui-viewport: Don't expand the document underneath the scroll bars

Whether or not the scroll bar appears affects the total size of the
viewport. This should also affect the size of the document when the
expand properties are enabled. To make this easier to implement, the
length and viewport of the scroll bars are now configured during the
pre-paint callback instead of immediately when the document size
changes. If there is a sync widget then the scroll bars are configured
using the preferred size of the widget instead of the size of the
document. That way the actual size used for the document can depend on
the presence of the scroll bars.

The doc x and y properties have been changed so that they no longer
depend on the scroll bar position. Previously this was creating a
circular dependency. Although that would work fine, it seems simpler
to make the doc position properties simply be a proxy to retrieve the
scroll bar position. That way there is only one canonical location for
the position and we only need one bit of code to handle the clamping.
Pressing the page up and down keys now effectively just updates the
scroll bar position. This in turn causes it to scroll.
scroll-bar: Reclamp the offset when the length or viewport changes

When the length or viewport of the scroll bar changes it will now
reclamp the offset position. This fixes problems were the offset would
get into an inconsistent state and a viewport could be shown scrolled
lower than its maximum.

Additionally, the setter for the offset now checks whether the same
value is being set after it is clamped to make it more robust.
Add RutBoxLayout

This adds a simple layouting widget which places its children in a
line either horizontally or vertically. The widget fully implements
the sizable interface and tracks its children's preferred size.
ui-viewport: Add children passed in the constructor to doc not vp

The constructor for RutUIViewport takes a vararg list of children.
However it was adding these as direct children of the viewport instead
of the doc so they wouldn't actually be scrolled. This patch just
tweaks it to add them to the doc instead.
Add the inspectors to a RutBoxLayout

The widgets for the inspectors are now added to a box layout so that
they will automatically all be allocated the same horizontal width.

The list of component inspectors has been renamed to 'all_inspectors'
and now also includes the main entity inspector. This simplifies some
of the code to handle the inspectors.
Use rut_paint_graph_with_layers to paint the UI graph

rut_paint_graph_with_layers is used to allow widgets to paint in
multiple layers so that certain parts of the widget are over
everything else. The RigDropDown was trying to use this but as nothing
was setting the layer number it wouldn't actually paint anything. This
was causing an odd gap in the inspector for the light.
rut-prop-inspector: Set the label text for enum properties

RigDropDown doesn't display any label so in order for the name of the
property to be seen we need to get the property inspector to
explicitly create a label.
undo-journal: Add a destructor

This adds rig_undo_journal_free which frees all of the resources of
the undo journal.
undo-journal: Suppport an entry representing a collection of entries

There is now an undo operation that represents a collection of entries
that will be undone as if they were a single operation. The collection
is actually stored as another RigUndoJournal so that the normal
functions can be used to add to the journal. The inverse of the entry
just creates another journal with all of the inversions of the
subentries in reverse order.

This could be used for example when toggling an animated button.
Sometimes this needs to also add the initial path node when the path
is empty. It could be more convenient to use the normal path adding
operation to avoid duplicating code to handle it.
Use a subjournal to log toggling the animated state

When the animated state of a property is initially enabled it will add
a node in the path of the current transition with the current value.
Previously the undo entry for toggling the animated state was aware of
this and tracked the node's value. To reduce code duplication, this
now uses a subjournal entry with the two actions instead. They are
still undone as one single action.

This reverts commit 9a4af9d899cab8bbdb08bd79130c4d02a59db905.
transition-view: Log multiple node deletions as a single undo entry

When multiple timeline nodes are selected and the delete key is
pressed, it will now create a single entry in the undo journal using a
subjournal. That way to revert deleting all of the nodes the user only
has to press ctrl-z once instead of once for each node.
transition-view: Initialise the has_selected_nodes member

According to valgrind, this was being used unitialised.