Updated POTFILES.in
Updated Polish translation
Updated Slovenian translation
Updated Galician translations
Assamese translation updated
Updated Spanish translation
Add PaintNode, an element on the render object tree

Now that we have a proper scene graph API, we should split out the
rendering part from the logical and event handling part.

ClutterPaintNode is a lightweight fundamental type that encodes only the
paint operations: pipeline state and geometry. At its most simple, is a
way to structure setting up the programmable pipeline using a
CoglPipeline, and submitting Cogl primitives. The important take away
from this API is that you are not allowed to call Cogl API like
cogl_set_source() or cogl_primitive_draw() directly.

The interesting approach to this is that, in the future, we should be
able to move to a purely retained mode: we will decide which actors need
to be painted, they will update their own branch of the render graph,
and we'll take the render graph and build all the rendering commands
from that.

For the 1.x API, we will have to maintain invariants and the existing
behaviour, but as soon as we can break API, the old paint signal will
just go away, and Actors will only be allowed to manipulate the render
tree.
actor: Add paint_node virtual function

The ::paint-node virtual inside ClutterActor is what we want people to
use when painting their actors.

Right now, it's a new code path, that gets called while painting; the
paint_node() implementation should only paint the actor itself, and not
its children — they will get their own paint_node() called when needed.

Internally, ClutterActor will automatically create a dummy PaintNode and
paint the background color; then control will be handed out to the
implementation on the class. This is required to maintain compatibility
with the old ::paint signal emission.

Once we are able to get rid of the paint (and pick) sequences, we'll
switch to a fully retained render tree.
Add ClutterContent

ClutterContent is an interface for creating delegate objects that handle
what an actor is going to paint.

Since they are a newly added type, they only hook into the new PaintNode
based API.

The position and size of the content is controlled in part by the
content's own preferred size, and by the ClutterContentGravity
enumeration.
docs: Update documentation on the paint sequence
docs: Update the API reference

Add all the new symbols.
paint-node: Use JSON-GLib for debug serialization

Instead of our homegrown string building; this at least ensures that
we're generating proper data, instead of random strings. Plus, using
JsonNode and JsonBuilder, we can ask the PaintNode subclasses to
serialize themselves in a sensible way.
content: Make vfuncs optional

The virtual functions on the ClutterContent interface should provide
hooks for application code, not be the actual implementation.
content: Turn attached and detached into signals

The attached and detached virtual functions are now informative, and not
normative - which means it's a good idea to provide them as signals.
paint-nodes: Use logical extents for the TextNode::draw

When we decide if we ought to clip, we should use the logical extents of
the PangoLayout, just like we do for ClutterText.
interactive/content: Define the size of the text geometry

So that Clutter can decide whether or not to clip the text properly.
paint-nodes: Fix compiler warning
actor: Make paint_node() and ::paint mutually exclusive

The ::paint signal is the old way to paint an actor; the paint_node()
virtual function is the new way. It's still not possible to traverse the
whole scene graph and build a render tree of PaintNode instances, but
with this change we simultaneously cut out the ::paint signal emission
from the critical path for actors that are using the new PaintNode-based
API, and we retain backward compatibility in the interim period between
1.10 and 2.0.
conform/text-cache: Use the stage paint signal

The stage's paint signal is guaranteed to be emitted; ClutterText's
paint signal is not.
conform: Skip actor-offscreen-redirect

Until we figure out a way to make it succeed even without the paint
signal emission.