event: Add ClutterTouchEvent

The ClutterTouchEvent structure contains the data relative to a touch
event.

gdk: Relay scroll delta from GDK

x11: Reset scroll valuators

We need to clear up the state on enter and leave, as well as when the X
server tells us that the device has changed.

x11: Add support for scroll valuators on XInput2.2

event: Expose precise scrolling information

Some events may contain precise scrolling information coming from
devices like trackpads and touchscreens. ClutterEvent should allow
setting and getting this information.

Check for XInput 2.2 extension

[l10n]Updated Catalan (Valencian) translation

[l10n] Updated Catalan translation

Updated French translation

Updated Bulgarian translation

Updated Swedish translation

actor: Add ::transitions-completed signal

While you can get a per-transition notification of completion, it can be
convenient to also have a way to notify that all the transitions
involving an actor are complete. A simple signal triggered by the
removal of the last transition fits the bill pretty neatly.

script-parser: Fix build

Updated Czech translation

Updated Czech translation

x11/stage: fix multi-stage support

When handling Configure events from the X server we update the
internal copy of the window size. Unfortunately we may be updating the
wrong stage implementation because we use the one related to the event
translator (which is the first created stage).

This patch fix flickering/redrawning issues with multi-stage by
looking for the right stage implementation associated with an XEvent.

Signed-off-by: Lionel Landwerlin <lionel.g.landwerlin@linux.intel.com>

Updated Portuguese translation

script: Add 'context' to the translatable definitions

This should cover all the possible options.

Updated Serbian translation

actor: Avoid popping the easing state stack once too many

If restore_easing_state() is called on the last easing state on the
stack, clean up the stack, so that we don't leave stale pointers
around to later segfault on.

actor: Remove the implicit easing state save

When setting the easing mode, duration, or delay without having ever
called clutter_actor_save_easing_state(). It's confusing, and not
really nice.

In the future, we'll have a default easing state implicitly created by
the actor itself, but for the time being explicitly opting in is
preferrable.

Use G_VALUE_INIT instead of { 0, }

The macro avoids warnings from anal-retentive compilers.

Updated Lithuanian translation

Add initializer utilities for ClutterVertex

Similar to what we did for ClutterActorBox.

actor: Fix set_scale_with_gravity()

Add a scale-gravity internal setter, and make set_scale_with_gravity()
call it, along with the scale factor.

Add some utility initializers to ClutterActorBox

Updated Galician translations

osx/stage: Synthesize an enter event on show

If the pointer is inside the window frame when it's shown then we need
to synthesize and emit a NSMouseEnterEvent ourselves, as Quartz won't
do it for us.

This is a bit of a blind commit - but it's taken from an equivalent
patch that has been verified to work in GDK.

docs: Change the short description of ClutterActor

The Actor class is not abstract any more.

Annotate functionality added in 1.10

Debugging cleanups

Add some more debugging notes to the layout and paint node output.

actor: Remove an has_allocation() check

The get_content_box() method should always succeed; if the actor does
not have an allocation, we are just going to return a 0-box.

interactive/image-box: Clarify the label contents

actor: Restore a lost queue_relayout()

It got lost during a rebase conflict resolution.

Updated Polish translation

Updated British English translation

Updated POTFILES.in

Assamese translation updated

Updated Slovenian translation

Updated Spanish translation

build: Remove maintainer flags from cookbook/examples

The code should be a tad more relaxed.

po: Update POTFILES.in

Rename 'bilinear' scaling filter to 'trilinear'

Yes, it's not really the proper GL name for a linear-on-every-axis of a
texture plus linear-between-mipmap-levels minification filter, but it
has three redeeming qualities as a name:

  - LINEAR_MIPMAP_LINEAR sucks, as it introduces GL concepts like
    mipmaps in the API naming, while we're trying to avoid that;
  - people using GL already know what 'trilinear' means in this context
    without going all Khronos on their asses;
  - we're using 2D textures anyway, so 'linear on two axes and linear
    between mipmap levels' can be effectively approximated to
    'trilinear'.

I mean, if even the OpenGL official wiki says:

  Unfortunately, what most people think of as "trilinear" is not linear
  filtering of a 3D texture, but what in OpenGL terms is GL_LINEAR mag
  filter and GL_LINEAR_MIPMAP_LINEAR in the min filter in a 2D texture.
  That is, it is bilinear filtering of each appropriate mipmap level,
  and doing a third linear filter between the adjacent mipmap levels.
  Hence the term "trilinear".
                -- http://www.opengl.org/wiki/Texture

then the horse has already been flogged to death, and I don't intend to
be accused of necrophilia and sadism by flogging it some more.

Prior art: every single GL tutorial in the history of ever;
CoreAnimation's scaling filter enumerations.

If people want to start using 1D or 3D textures they they are probably
going to be using Cogl API directly, and that has the GL naming scheme
for minification and magnification filters anyway.

docs: Add ClutterActorClass.paint_node() description

paint-nodes: Make part of the API internal

At least for the time being, we only expose the parts of the API that we
want to use internally and for new, out-of-tree Content implementations.

The full PaintNode tree API will be made public in 1.12 once we branch
master.

docs: Fixes for ClutterImage's API reference

Update release notes

docs: Fixes for the API reference

interactive/image-box: Remove unneeded stuff

actor: Unconditionally emit ::paint

It's a bit late in the game for changing the emission of the paint
signal with actors that use paint nodes - mostly because we have both
implicit paint nodes (background color, content) and explicit paint
nodes (the paint_node virtual).

When we branch for 1.12 we can revert this change.

po: Update POTFILES.in

paint-node: Make texture template pipeline clamp to edge

It's safer, and consistent with the rest of Clutter, to make sure that
the template pipeline we use for ClutterTextureNode has its wrap mode
set to clamp-to-edge.

image: Add set_area() method

This method allows replacing an area inside the texture data used by a
ClutterImage.

image: Add get_texture()

Allow retrieving the Cogl texture used by the ClutterImage.

actor: Fix RESIZE_ASPECT mode for the content box

Documentation fixes

interactive/image-box: Add a pure Image test, suitable for docs

interactive/image: Test ClutterImage

Load up the image content using a GdkPixbuf; this means that the test is
not compiled when --disable-gdk-pixbuf is passed.

build: Check for gdk-pixbuf

Some tests may need to load image data without going through
ClutterTexture or Cogl, so let's add a configure switch and a
conditional for gdk-pibxuf.

Update clutter.symbols

interactive/canvas: Set the scaling filters

Use the content scaling filters

Both ClutterCanvas and ClutterImage should use the minification and
magnification filters set on the actor, just like the use the content
box and the paint opacity.

actor: Add minification/magnification filters

These settings are informative, and will only be used by the eventual
content of an actor.

Add ClutterImage, and image data content

canvas: Fix single header inclusion guard

canvas: Add canvas size to the ::draw signal

Instead of requiring a call to clutter_content_get_preferred_size(), we
can simply pass the canvas size to the Canvas::draw signal.

Add ClutterCanvas, a drawing content

paint-node: Remove redundant declarations

content: Make get_preferred_size() public

conform: Skip actor-offscreen-redirect

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

conform/text-cache: Use the stage paint signal

The stage's paint signal is guaranteed to be emitted; ClutterText's
paint signal is not.

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.

paint-nodes: Fix compiler warning

interactive/content: Define the size of the text geometry

So that Clutter can decide whether or not to clip the text properly.

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.

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.

content: Make vfuncs optional

The virtual functions on the ClutterContent interface should provide
hooks for application code, not be the actual implementation.

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.

docs: Update the API reference

Add all the new symbols.

docs: Update documentation on the paint sequence

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.

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 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.

Updated Spanish translation

Assamese translation updated

Updated Galician translations

Updated Slovenian translation

Updated Polish translation

Updated POTFILES.in

animator: Fix NULL check

interactive/texture-async: Use implicit animations

actor: Remove G_SIGNAL_NO_RECURSE

As it turns out, we do end up recursing inside the ::paint signal
emission - especially inside the conformance test suite.

This thoroughly sucks - and we'll only be able to fix it properly
when we bump API for 2.0.

I should compile the changes I make

actor: Fix get_transition() method

We now store a closure, not directly a ClutterTransition instance.

doc: Reference fixes

symbols: Update

actor: Add generic transition support

ClutterActor should be able to hold all transitions, even the ones that
have been explicitly created.

This will allow to add new transitions types in the future, like the
keyframe-based one, or the transition group.

transition: Clear the animatable member when removing on complete

transition: Check the repeat count to remove on complete

We can now ask the timeline for the current repeat, and if it's the last
one, then we can safely detach the transition from the animatable
instance.

timeline: Add more state accessors

It should be possible to ask a timeline what is its duration, taking
into account eventual repeats, and which repeat is the one currently
in progress.

These two functions allow writing animations that depend on the current
state of another timeline.