Allow using array of vertices even without textures

It's often nice to be able to draw a batch of vertices, even if these
have no texture coordinates. This add a cogl_rectangles, similar to
cogl_rectangles_with_texture_coords, only without.

Removes a hack in gles/cogl.c that was already fixed in gl/cogl.c

It removes the need to cast a CoglMatrix to a float * for transforming
a vertex manually instead of using cogl_matrix_transform_point.

[doc] Update the should_pick_paint() documentation

The should_pick_paint() method of ClutterActor is not clearly
documented.

[glx-texture-pixmap] Don't enable the texture target when binding the texture

There's no need to enable the texture target unless it is going to be
used for rendering. Enabling it directly with glEnable calls confuses
Cogl's state caching.

This is a replacement for the patch in bug 1483 which was reverted.

Revert "Use COGL to establish GL state for ClutterGLXTexturePixmap"

This reverts commit f9d996a4603bef1f52e32e99f9f69a32b7c823ba.

The change from calling glBindTexture to using the material API with
cogl_material_flush_gl_state does not always work because it doesn't
necessarily leave the active texture unit as GL_TEXTURE0. For example,
if the previously rendered texture was multi-layered then the last
thing cogl_material_flush_gl_state will do is select GL_TEXTURE1 just
to disable it.

[actor] use an epsilon whens sanity checking sizes

Clutter was complaining about netural width smaller than minimum widths
(differences around 0.0005) by using an epsilon value of 1e-4 for these
floating point comparisons, these warnings have now been silenced.

[docs] Remove unused arguments

The documentation for some X11TexturePixmap method does not reflect
the actual API.

[docs] Pick up backend-specific API

The various backend API outside from clutter-x11.h and clutter-win32.h
is documented but not picked up by gtk-doc.

Remove usage of the grave accent as quotation mark

See:

  http://www.cl.cam.ac.uk/~mgk25/ucs/quotes.html

This should make Thomas happy.

[cogl] Apply the fix from 2c1c836417 (Flush matrix before clip planes) to GLES

glClipPlane() is affected by modelview matrix so we need to flush before
calling it.

[test-cogl-vertex-buffer] Use clutter_color_from_hls instead of hsl_to_rgb

There is no need for a custom hsl to rgb converter since Clutter implements
this logic; originally it wasn't quite as optimal, but that has now been
fixed.

[clutter-color] Use a different hls->rgb algorithm + use floating point

Using test-cogl-vertex-buffer as a test case which is CPU bound due to
hls -> rgb conversions this alternative algorithm looked to be ~10%
faster when tested on an X61s Lenovo.

[docs] More information on animation queueing

Queuing an animation on an actor cannot be done from within the
::completed signal handler, because we guarantee that the Animation
instance is valid and attached to the actor it animates for the
whole duration of the signal emission chain.

In order to queue animations you have to install an idle handler
on the main loop, and call clutter_actor_animate() inside it.

The documentation should be more clear about this caveat in the
memory management of ClutterAnimations created by the animate()
family of functions.

Post-release bump to 0.9.3

[release] Release 0.9.2

Update release notes

[docs] Ignore the TimeoutInterval internal API

The TimeoutInterval API is internal, and thus should not be part
of the API reference.

[docs] Fix naming of the interval parameter

The interval parameter is now expressed in frames per second and not
in milliseconds.

Fix release date of 0.9.0

[cogl] Don't endlessly print the same warning regarding layer fallbacks

There are various constraints for when we can support multi-texturing and
when they can't be met we try and print a clear warning explaining why the
operation isn't supported, but we shouldn't endlessly repeat the warning for
every primitive of every frame. This patch fixes that.

[tests] Adds an interactive cogl vertex buffer unit test

The test is a sanity check that dynamic updating of vertex data via the cogl
vertex buffer api works and has reasonable performance. (though it can't be
considered a well designed benchmark since it wastes casual amounts of CPU
time simply choosing pretty colors.)

The code also aims to demonstrate one way of creating, updating and efficiently
drawing a quad mesh structure via the vertex buffer api which could be applied
to lots of different use cases.

[cogl-vertex-buffer] fix cogl_vertex_buffer_draw_elements prototype

This function was renamed a while ago in the .c file from
cogl_vertex_buffer_draw_range_elements  but the corresponding .h and
doc/reference/cogl changes weren't made.

[cogl-vertex-buffer] Allow querying back the number of vertices a buffer represents

This may be convenient e.g. at draw time if you are simply drawing all vertices

[cogl-vertex-buffer] Add a flush of attribute changes in the *_draw() functions

For convenience it is now valid to avoid a seperate call to
cogl_vertex_buffer_submit() and assume that the _draw() calls will do this
for you (though of course if you do this you still need to ensure the
attribute pointers remain valid until your draw call.)

Count timeline frames using the FPS instead of an integer interval

Bug 1495 - Timelines run 4% short

Previously the timelines were timed by calculating the interval
between each frame stored as an integer number of milliseconds so some
precision is lost. For example, requesting 60 frames per second gets
converted to 16 ms per frame which is actually 62.5 frames per
second. This makes the timeline shorter by 4%.

This patch merges the common code for timing from the timeout pools
and frame sources into an internal clutter-timeout-interval file. This
stores the interval directly as the FPS and counts the number of
frames that have been reached instead of the elapsed time.

[cogl] Flush matrix before clip planes

glClipPlane() is affected by modelview matrix so we need to flush
before calling it.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

[docs] Bring down the undocumented symbols to 2%

The usual pre-release documentation blitzing. Most of the remaining
symbols are either COGL or X11 specific, or dummy interface typedefs.

[animation] Enhance consistency of the Animation API

The Animation API should follow this pattern:

  - functions with an Interval as part of the arguments should have
    "interval" inside their name, e.g.:

      clutter_animation_bind_interval
      clutter_animation_update_interval

  - functions dealing with property names should have "property"
    inside their name, e.g.:

      clutter_animation_has_property
      clutter_animation_unbind_property

    - unless -

  - functions dealing with a property and its value should not
    have any modifier, e.g.:

      clutter_animation_bind

The change from update_property() to update_interval() frees up
clutter_animation_update(), to be added at a later date.

[docs] Update after Animation API changes

Rename the bind/unbind_property functions, and add the bind_interval,
completed method.

Also, add clutter_actor_get_animation().

[docs] Add description of queue_redraw

[tests] Remove unused variables

The size of the pixmap is passed by the ::size-changed signal, so
we can remove the unused w, h variables and avoid a compiler warning.

[actor] Add ::queue-redraw signal

Bug 1454 - move queue_redraw virtualization to ClutterActor

The ClutterActor::queue-redraw signal allows parent containers to
track whether their children need a redraw.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

[actor] Add :clip-to-allocation property

A common use of setting clip is to keep an actor inside its allocation;
right now to do this you have to set up a callback on notify::allocation.

There's no overhead added by sticking another bit in ClutterActor
clip-to-allocation that will clip painting to the allocation if set.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

[animation] Enhance the bind API

Bug 1419 - Add clutter_animation_bind, rename clutter_animation_bind_interval

This is a different approach from the clutter_actor_animatev
vector variant.  The single call should be even easier on
automatic bindings, since calls can be chained like:

  new Clutter.Animation({object: myactor}).bind("x", 42).bind("y", 43);

Note clutter_animation_bind_property which took a ClutterInterval
is renamed to clutter_animation_bind_interval for clarity, and to
discourage use since there are friendlier APIs about.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

[animation] Add Animation getter

If we are animating an actor using the clutter_actor_animate*() family
of functions we might want to expose a getter for the Animation instance
we are using, to avoid excessing bookkeeping.

[animation] Add an emitter for ::completed

The ::completed signal requires an emitter in case we want to stop
the animation and safely dispose it inside application code without
breaking invariants.

[docs] Clarify Animation memory management

The memory management of the ClutterAnimation instances should be
heavily documented, given its "automagical" nature, so that other
people might understand it and avoid breaking it in the future.

Merge branch 'async-texture-thread-pool'

[clutter-texture] fixed gtk-doc formatting, and init threads in test.

Fixed markup to actually work with gtk-doc, also do a g_thread_init
in the test.

[cogl-path] Minor fix to gtk-doc

Fix the parameters in cogl_path_curve_to and cogl_path_rel_curve_to to
match the actual names otherwise they won't appear correctly in the
docs.

[cogl] Avoid shadowing math.h symbols

As usual, y1 and y2 end up shadowing symbols exported by math.h.

Avoid drawing twice if relayout queues a draw

It's reasonably normal for a relayout of the stage to cause the stage
to be queued for drawing; for this reason we should do the relayout before
we clear stage->update_idle. (But want to clear update_idle() before actually
doing the redraw to handle the corner case where the draw queues another
redraw.)

Do not cause more size requisitions than necessary

Bug 1499 - clutter_actor_notify_if_geometry_changed causes sync
           layout cycles

Whenever clutter_actor_set_{width,height,x,y,size...} is used, extra
synchronous size requests are triggered in
clutter_actor_notify_if_geometry_changed.

If the get_preferred_width() and get_preferred_height() implementations
are particularly costly (e.g. ClutterText) this will result in a performance
impact.

To avoid excessive allocation or requisition cycles we use the
cached values and flags. If we don't have an allocation, we assume
that we need to notify all the properties; if we don't have a size
requisition we notify only width and height; finally, if we do have
a valid allocation we notify only on the changed values.

[deprecated] Add Effect deprecation

The ClutterEffect API has been deprecated during 0.9, so it should be
added to the deprecation macros.

Add more deprecation notices

Most of the deprecated API does not have an entry inside
clutter-deprecated.h, thus making porting a tad more difficult.

Change cogl_path_rectangle and cogl_path_round_rectangle to take x1,y1,x2,y2

This matches the changes to cogl_rectangle to improve consistency.

[README] Small typo fix

Merge branch 'cogl-client-matrix-stacks'

* cogl-client-matrix-stacks:
  Maintain the Cogl assumption that the modelview matrix is normally current
  Finish GLES{1,2} support for client side matrix stacks
  Explicitly make the modelview-matrix current in cogl_{rotate,transform,etc}
  Avoid casting CoglMatrix to a GLfloat * when calling glGetFloatv
  Removes need for casting const float * in _cogl_set_clip_planes
  Virtualize GL matrix operations and use a client-side matrix when GL is indirect

Maintain the Cogl assumption that the modelview matrix is normally current

_cogl_add_path_to_stencil_buffer and _cogl_add_stencil_clip were leaving
the projection matrix current when calling cogl_rectangle which was
upsetting _cogl_current_matrix_state_flush.

Finish GLES{1,2} support for client side matrix stacks

Adds glFrustum wrappers (GLES only accepts floats not doubles, and GLES2
needs to use our internal cogl_wrap_glFrustumf)

Adds GL_TEXTURE_MATRIX getter code in cogl_wrap_glGetFloatv

Adds a GL_TEXTURE_MATRIX define for GLES2

Use Cogl enum when making modelview-matrix current in cogl_{rotate,transform,etc}

My previous patch incorrectly used the GL enum with the _cogl_set_current_matrix
API.

Explicitly make the modelview-matrix current in cogl_{rotate,transform,etc}

Its not intended that users should use these with any other matrix mode, and
internally we now have the _cogl_current_matrix API if we need to play with
other modes.

Avoid casting CoglMatrix to a GLfloat * when calling glGetFloatv

If we later add internal flags to CoglMatrix then this code wouldn't
initialize those flags. The ways it's now done adds a redundant copy, but
if that turns out to be something worth optimizing we can look again at
using a cast but adding another way for initializing internal flags.

80 char fix

Removes need for casting (const float *) to (GLfloat *) in _cogl_set_clip_planes

This removes cogl.c:apply_matrix(), and makes cogl.c:project_vertex() use
cogl_matrix_transform_point instead.

Virtualize GL matrix operations and use a client-side matrix when GL is indirect

This is useful because sometimes we need to get the current matrix, which
is too expensive when indirect rendering.

In addition, this virtualization makes it easier to clean up the API in
the future.

[clutter-texture] updated documentation.

Rewrote documentation, with the smallest amount of documentation for
load-data-async which is considered a special case of load-async.

Merge commit 'origin/async-texture-thread-pool' into async-size

[clutter-texture] remove load-size-async property

Only have load-data-async and load-async properties, both are construct
only and the latter adds the former load-size-async behavior on top of
load-data-async.

[clutter-texture] add option to not block on size for loaded images

Added a construct time property to indicate that we do not want
to block on loading images.

[tests] Added test-texture-async

[docs] Add a bindings coding practices

When writing language bindings for Clutter some rules should be
observed to guarantee the same levels of quality across different
bindings.

[docs] Reword some of the coding practices

Update with the new fixed point and units rules. Also, fix the
grammar and clarify what to do with non-static private functions.

[tests] Animate the color during easing

The easing modes test should also tweak the color to show the
progress of the animation.

[animation] Broken fixed:: properties

This commit yesterday:

89e3e3a4cc06c10c2573f3d115c5b03ee4890524
[animation] Add vector variants for ::animate()

broke the "fixed::" attribute on properties in clutter_actor_animate(),
because the fixed:: part is still on the string when it checks to see if
it's a valid property the class knows about.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

Update shave

This update fixes a few issues:
  - the use of shave with mingw32 bash on windows,
  - fix the unmangling of libtool names
  - fix build on solaris
  - add an --enable/disable-shave configure option (while still
    defaulting to enabled)

Allow NULL for clutter_text_set_text()

As a convenience, if NULL is passed for the text argument of
clutter_text_set_text() (and for consistency,
clutter_text_set_markup()), treat that the same as "".

[group] Output the group name when debugging paint

Bug 1480 - Clutter groups don't output their name when
           CLUTTER_DEBUG=paint

This is a really useful thing to do debugging-wise - as you can see
istantly when (and if) clutter objects are being drawn - as often
there's quite a hierarchy of objects in groups.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

Add (out) annotations for ClutterActor

Add missing (out) annotations to the doc comments for ClutterActor methods
with multiple return values.

Fix the definition of clutter_actor_get_allocation_vertices() to be
consistent with the declaration and have verts[4] rather than verts[].x

http://bugzilla.openedhand.com/show_bug.cgi?id=1481

[text] Insertion of multi-byte characters broken

Bug 1501 - clutter_text_insert_text not working right with non-onebyte
           character

In clutter_text_insert_text(), the position is expressed in characters, not
in bytes.

Actually, it turns out to be working on bytes, so when there are already
multi-byte character in the text buffer, insert text at the position after
the multi-byte character will not work right.

Also, the position is not updated after the insert work is done.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

[text] Crash when multi-byte utf8 text exceeds max_length

Bug 1500 - [Patch] clutter_text crash with non one-byte utf8 text exceed
           max_length

In clutter_text_set_text_internal(), when text length in character is greater
than max_length, and there are multi-byte character in it, then the new text
string buffer is not malloc()'ed with right length. This will cause the app to
crash with segmention fault.

Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>

[docs] Document the commit message format

Clutter uses the standard git format for commit messages:

        short description
        <newline>
        long description...

And everyone asking for their patches or trees to be merged upstream
should conform to the same commit messages format, just like they
should conform to the coding style.

[docs] Calling g_object_ref() will not dispose an object

The right way to dispose a PangoContext is to call g_object_unref(),
not g_object_ref().

[color] Fixed HLS to RGB conversion

The fixed-point values are converted to integers, which obviously
messes up the conversion. Instead, they should be converted to
floating point values before normalizing to bytes for the assignment
to ClutterColor components.

Remove use of $(builddir)

$(builddir) isn't always defined in earlier versions of Automake
(although I can't track down exactly which version it appeared
in). According to the autoconf docs it is "rigorously equal to `.'" so
we might as well not use it.

[cogl] Initialize all members of CoglContext

Some members of CoglContext still escape initialization.

[cogl] Initialize boolean flag in CoglContext

The private CoglContext is created using g_malloc() and not
zeroed; this means we have to initialize the values we are
going to check, to avoid hitting garbage.

Thanks to Tommi Komulainen.

Fix out of tree builds

Commit a383929 added the $(srcdir) prefix to all of the source files
but some files are generated by the configure script and other make
rules so they actually live in $(builddir). Out-of-tree builds
therefore broke.

Change the default size of thread pool from 3 to 1

Concurrently decoding three image files can stall animations even on a
dual core system, reducing to 1 concurrent image decoding thread.

[animation] Add vector variants for ::animate()

Bug 1438 - Implicit Animation API could use animatev variants

The clutter_actor_animate* family of functions use va_lists to
handle the property/value pairs for the final state of the
animation.

Language bindings have problems with variadic arguments functions,
and usually prefer vector-based API which allow a greater level
of control and conversion from native data types.

For each variadic arguments function in the clutter_actor_animate*
family there should be a vector-based version that takes:

  - the number of property/value pairs
  - a constant array of constant strings
  - an array of GValues

Most of the internal implementation can be refactored from the
current one, thus both the var_args and the vector entry points
share a common implementation of the code; then, both versions
of the API are just loops over a list of arguments.

Based on a patch by: Robert Carr <carrr@rpi.edu>

[docs] Update API reference

The API reference was still listing some symbols that have been
removed.

[docs] Remove ClutterFixed from the documentation

Now that ClutterFixed has finally gone the way of the Dodo, we
can safely remove it from the API reference as well.

[cogl] Fix hardcoded paths in the pc file

The commit 24ce193836 fixed the Clutter pkg-config file. Since
COGL now ships its own, we need to fix that as well.

[fixed] Remove ClutterFixed API

Since the switch from fixed point to floating point, and the introduction
of CoglFixed, ClutterFixed has been typedef'd into a float. This makes
ClutterFixed the worst fixed point API ever.

Now that Clutter has been migrated to CoglFixed and gfloat whenever needed,
ClutterFixed can be safely removed.

The only thing that Clutter should still provide is ClutterParamSpecFixed,
for installing fixed point properties into GObject classes.

The ClutterFixed symbols have been entirely removed from the API.

[units] Add more conversion functions

A GValue containing a ClutterUnit should be transformable into a
GValue holding an integer, a floating point value or a fixed point
value.

This means adding more transformation functions when registering
the ClutterUnit GType.

[tests] Use floats, not ClutterFixed

The COGL API expects floats, not ClutterFixed, so we need
to use the right type when calling it.

[text] Convert units to the right type

The COGL API expects a floating point value, so Units should be
converted to floats, not to ClutterFixed.

[texture] Fix ClutterFixed usage

Do not use ClutterFixed and its macros inside the Texture.

[stage] Coalesce fog and perspective API

The fog and perspective API is currently split in two parts:

  - the floating point version, using values

  - the fixed point version, using structures

The relative properties are using the structure types, since they
are meant to set multiple values at the same time. Instead of
using bare values, the whole API should be coalesced into two
simple calls using structures to match the GObject properties.

Thus:

  clutter_stage_set_fog (ClutterStage*, const ClutterFog*)
  clutter_stage_get_fog (ClutterStage*, ClutterFog*)

  clutter_stage_set_perspective (ClutterStage*, const ClutterPerspective*)
  clutter_stage_get_perspective (ClutterStage*, ClutterPerspective*)

Which supercedes the fixed point and floating point variants.

More importantly, both ClutterFog and ClutterPerspective should
using floating point values, since that's what get passed to
COGL anyway.

ClutterFog should also drop the "density" member, since ClutterStage
only allows linear fog; non-linear fog distribution can be achieved
using a signal handler and calling cogl_set_fog() directly; this keeps
the API compact yet extensible.

Finally, there is no ClutterStage:fog so it should be added.

[interval] Update fixed-point handling

Do not use ClutterFixed when dealing with fixed point values. Use
CoglFixed instead.

[tests] Test CoglFixed, not ClutterFixed

We really want to test the CoglFixed implementation, not the
to-be-deprecated ClutterFixed one.

[cogl-fixed] Implement the CoglFixed fundamental GType

The type machinery for CoglFixed should be implemented by COGL
itself, now that COGL exports the GType of its types.

This allows moving most of what ClutterFixed did directly to
CoglFixed where it belongs.

Move ClutterTimeline to CoglFixed

The ClutterTimeline::get_progressx() method should return a
CoglFixed, now that ClutterFixed is being deprecated.

Move ClutterBehaviourRotate to CoglFixed

Remove the wrong usage of ClutterFixed and use CoglFixed instead
in the API and the implementation.

Move ClutterBehaviourEllipse to CoglFixed

Remove the wrong usage of ClutterFixed, and use CoglFixed instead
in the API and the implementation.

Move BehaviourScale to CoglFixed

ClutterFixed as a type is going away, superceded by CoglFixed. The
fixed point entry points in the API should be ported to the
CoglFixed type so that they are useful again.

[cogl-fixed] Add a double-to-fixed conversion macro

Since the conversion of a floating point value to a fixed point
value is already done in double precision we can safely expose
a macro that converts a double precision floating point value to
a CoglFixed one.

[docs] Note that grabs are evil

Grabs are an entirely evil way to override the whole event delivery
machinery that Clutter has in place.

A pointer grab can be effectively replaced by a much more reliable
::captured-event signal handler, for instance.

Sometimes, grabs are a necessary evil -- and that is why Clutter
exposes them in the API; that should not fool anyone into thinking
that they should be used unless strictly necessary.

[docs] Clarify clutter_actor_animate() behaviour

When calling clutter_actor_animate() on an actor that is being
currently animated the default behaviour is to update the duration
of the animation; the easing mode; update all the common properties;
and finally add the new properties.

This:

  clutter_actor_animate (actor, 500, CLUTTER_LINEAR,
                         "width", 100,
                         "height", 100,
                         NULL);

  clutter_actor_animate (actor, 250, CLUTTER_EASE_IN_CUBIC,
                         "x", 100,
                         "y", 100,
                         "height", 200,
                         NULL);

Is logically equivalent to:

  clutter_actor_animate (actor, 250, CLUTTER_EASE_IN_CUBIC,
                         "x", 100,
                         "y", 100,
                         "width", 100,
                         "height", 200,
                         NULL);

The documentation of the function should be slightly more verbose
in describing the default behaviour.

[build] Various fixes for distcheck

The generation of the GObject introspection data has broken
the distcheck phase.

The location of the header and source files should always be
depending on the $(top_srcdir) and $(srcdir) variables,
respectively; the special handling of the COGL API inside the
GIR generation should also take those two variables into
account.