cally: Use the Actor API instead of ClutterContainer

Cally is doing a bunch of list traversals through the list returned by
ClutterContainer.get_children(); this means a traversal already, plus
a bunch of allocations. We can do better than that, now that we have
a proper graph iteration API inside ClutterActor.

actor: Add replace_child() method

A simple method that atomically replaces a child actor with another one.

actor: Deprecate the old parent modifiers

The old API should not be used in newly written code; we have better
methods for setting up and modifying the scene graph, now.

conform/actor-graph: Add lower/raise units

Check that the lower_bottom(), lower(), raise(), and raise_top()
methods work as intended.

conform: Add a suite for the Actor scene graph API

Verify that insertion and removal maintain a stable graph, with pointers
to the various children. This should help out tracking regressions in
the scene graph API.

actor: Fix child insertion issues

The insert_child_at_index, insert_below and insert_above messed up the
first and last child pointers in various cases. This commit fixes all
the instances of first and last child pointers being stale or set to
NULL.

Port remaining layout managers to the new child iteration API

TableLayout and FlowLayout now use the ClutterActor API for iterating
over the children of an actor.

Begin porting layout managers to the new child iteration API

Instead of getting the list of children to iterate over it, let's use
the newly added child iteration API; this should save us a bunch of
allocations, as well as indirections.

Ported: ClutterBinLayout and ClutterBoxLayout.

actor: Add children iteration methods

Instead of requiring every consumer of the ClutterActor API that wishes
to iterate over the children of an actor to use the get_children()
method, we should provide an iteration API directly inside ClutterActor
itself.

actor: Define the scene structure inside Actor

Instead of storing the list of children, let's turn Actor inside a
proper node of a tree.

This change adds the following members to the Actor private data
structure:

  first_child
  last_child
  prev_sibling
  next_sibling

and removes the "children" GList from it; iteration is performed through
the direct pointers to the siblings and children.

This change makes removal, insertion before a sibling, and insertion
after a sibling constant time operations, but it still retains the
feature of ClutterActor.add_child() to build the list of children while
taking into account the depth set on the newly added child, to allow the
default painter's algorithm we employ inside the paint() implementation
to at least try and cope with the :depth property (albeit in a fairly
naïve way). Changes in the :depth property will not change the paint
sequence any more: this functionality will be restored later.

actor: Use a cairo_rectangle_t instead of a ridiculous array

Make the code maintainable and readable.

actor: Document fields of ClutterActorPrivate

The private data structure members could do with more comments
documenting what they do.

actor: Add TransformInfo

ClutterTransformInfo is a (private) ancillary data structure that
contains all the decomposed transformation data, i.e. rotation angles
and centers, scale factors and centers, and anchor point. This data
structure is stored in the GData of the actor instance instead of the
actor's private data. This change gives us:

  • a smaller, cleaner private data structure;
  • no size penalty for untransformed actors;
  • static constant storage for the defaults, shared across all
    instances;
  • cache locality for all the decomposed transformation data,
    given that the structure size is smaller.

At the end of the day, the only authoritative piece of information for
actor transformation is the CoglMatrix that we initialize in
apply_transform() from all the decomposed parameters, and that can stay
inside the private data structure of ClutterActor.

docs: Update the release notes

actor: Tweak the underallocation warning

There are only two kinds of actors that allow underallocations,
according to the API contract:

  • ClutterStage, as it is a viewport and it doesn't have an implicit
    minimum size;

  • Actors using the CLUTTER_ACTOR_NO_LAYOUT escape hatch, which allows
    them to bail out from our layout management policies.

The warning about underallocations should take these two exceptions
under consideration.

Deprecate ClutterRectangle

A ClutterActor with a background color set covers 99% of the use cases
for a Rectangle.

Deprecate ClutterGroup

The Group functionality is now provided by ClutterActor.

Sadly, we need to keep the ClutterGroup structure definition in the
non-deprecated header because ClutterStage inherits from Group - an API
wart that was never fixed during the 0.x cycles, and that we'll have to
keep around until we can break API.

Deprecate ClutterBox

ClutterBox functionality has been implemented by ClutterActor, and
proxied by the Box subclass; with the removal of the abstract bit on
ClutterActor, we can safely deprecated ClutterBox.

cally: Do not use Group API

Avoids a deprecation warning.

actor: Make Actor instantiatable

ClutterActor now has all the API and capabilities for being a concrete
class:

  - layout management, through delegation
  - container implementation and API
  - background color

This means that a simple scene can be built straight out of actors
without using subclasses except for the Stage.

This is the first step towards the deprecation of most of the Actor
subclasses provided by Clutter.

group: Proxy last few methods to Actor

At this point, ClutterGroup is basically just a shim layer on top of
ClutterActor.

actor: Provide more children methods

Add a getter for the number of children, as well as a method to retrieve
the child at a given index.

group: Use the default get_paint_volume()

ClutterActor does everything we did, and more.

actor: Provide a better get_paint_volume() implementation

ClutterActor can do better by default than just giving up immediately.

An actor can check for the clip region, and for its children's paint
volume, for instance.

Just these two should give us a better default implementation for newly
written code.

flow-layout: Fix minimum size request

The minimum preferred size of a Flow layout manager is the size of a
column or a row, as the whole point of the layout policy enforced by
the Flow layout manager is to reflow when needed.

box: Proxy the Actor's background color properties

ClutterBox's color and color-set properties can be implemented as
proxies for the ClutterActor's newly added background-color and
background-color-set properties, respectively.

This also allows us to get rid of the paint() implementation inside
ClutterBox altogether.

actor: Background color

Each actor should have a background color property, disabled by default.

This property allows us to cover 99% of the use cases for
ClutterRectangle, and brings us one step closer to being able to
instantiate ClutterActor directly.

actor: Cosmetic fixes to internal add/remove child

Avoid code duplication all over the place.

conform/layout: Remove last Container.add_actor() usage

Use clutter_actor_add_child(), now that Stage falls back to the default
implementation of Container provided by the Actor class.

group: Use the default paint() implementation

ClutterActor's paint implementation is perfectly fine for ClutterGroup:
it paints the actor's children, which is exactly what ClutteGroup does.

actor: Minor cosmetic fixes to the header

group: Do not override Container

Let ClutterActor do all the work.

actor: Make Actor.add_child and Container.add_actor idempotent

And make sure that overriding Container and calling
clutter_actor_add_child() will result in the same sequence of operations
as the current set_parent()+queue_relayout()+signal_emit pattern.

Existing containers can continue using:

        clutter_actor_set_parent (child, CLUTTER_ACTOR (container));
        clutter_actor_queue_relayout (CLUTTER_ACTOR (container));
        g_signal_emit_by_name (container, "actor-added", child);

and newly written containers overriding Container.add() can simply call:

        clutter_actor_add_child (CLUTTER_ACTOR (container), child);

instead.

actor: Do not leak the layout manager

box: Drop Container interface overrides

And defer as much as possible to ClutterActor's default implementation
for basically everything.

actor: Implement Container::sort_depth_order

There's no reason this vfunc should be left out.

actor: Add child insertion methods

We should allow inserting children at given indices, and at given
stacking positions (relative or not to other children).

conform: Begin a test suite for layout options

A simple sampling check to validate that we're painting the right thing
at the right place.

actor: Adjust the preferred size too

Don't adjust just the allocation: we need to adjust the preferred size
of the actor to account for the margin.

actor: Maintain invariants in add_child/remove_child

We need to queue a relayout when removing a visible child from a visible
parent.

We also need to insert the child at the right position (depending on the
depth) so that newly added actors will be painted on top.

actor: More cleanups to the Private data structure

Try to document it properly. We can also remove some things that are
properly encapsulated through functions, like the redraw clip volume.

actor: Store the fixed sizes into LayoutInfo

Remove four more floats from ClutterActorPrivate.

The fixed minimum and natural sizes should be stored inside the
ClutterLayoutInfo structure, along with the fixed position.

actor: Update the underallocations check

Add a failsafe against a NULL parent, to avoid a segfault when calling
clutter_actor_allocate() on the Stage.

We also need to deal with floating point values: straight comparison is
not going to cut it.

actor: Adjust the allocation prior to call allocate()

ClutterActor has various properties controlling the allocation:

  - x-align, y-align
  - margin-top, margin-bottom, margin-left, margin-right

These properties should adjust the ClutterActorBox passed from the
parent actor to its children when calling clutter_actor_allocate(),
so that the child can just allocate its children at the right origin
with the right available size.

actor: Clean up property installation

actor: Add margin properties

The actor class should be able to hold the margin offsets like it does
for expand and alignment flags.

Instead of filling the private data structure with data, we should be
able to use an ancillary data structure, given that all this data is
optional and might never be set in the first place.

actor: Add [xy]-align

Allow an actor to define how it should occupy the extra space given to
by its parent during the allocation.

actor: Provide Container::raise/lower implementations

actor: Remove is-a(Container) checks

All actors are now Container implementations, so there's no need to add
a type check.

actor: Add [xy]-expand properties

box: Defer to ClutterActor

Use the default implementation inside ClutterActor instead of our own,
wherever possible.

actor: Default to a fixed layout manager

In case no layout manager was set during construction, we fall back to a
FixedLayout. The FixedLayout has the property of making the fixed
positioning and sizing API, as well as the various Constraints, work
out of the box.

actor: Add :layout-manager

Now that ClutterActor implements the Container contract we can actually
defer the size negotiation to a ClutterLayoutManager directly from the
default implementation of the Actor's virtual functions.

actor: Provide a default Container implementation

We can provide most of the ClutterContainer implementation directly
within ClutterActor — basically removing the need of having the
Container interface in the first place. For backward compatibility
reasons we can keep the interface, but let Actor implement it directly.

Do not use set_parent()/unparent() internally

Use add_child()/remove_child() instead.

actor: Provide add/remove child and get children methods

Let's try and move away from the reverse implicit scene graph build API,
which we mutuated from GTK+, towards a more traditional node/child API.

The set_parent()/unparent() API is confusing, unless you know the
history; having a add_child()/remove_child() methods pair makes it more
explicit.

We can easily implement the old set_parent()/unparent() pair in terms of
the newly add_child()/remove_child() one.

Remove use of CoglVector3

Cogl has removed the CoglVector3 type in favour of directly using an
array of 3 floats.

Reviewed-by: Robert Bragg <robert@linux.intel.com>

actor: Clean up the debug node for out-of-band transforms

Enclose the check inside a #ifdef CLUTTER_ENABLE_DEBUG ... #endif, so
that we can compile it out; also, use g_string_append() instead of the
g_string_append_printf() function, given that we're just concatenating
strings.

Updated Galician translations

clutter.modules: Bump json-glib

backend: Remove ClutterBackend::redraw

The ::redraw virtual function was a throwback from olden times, and has
been thoroughly replaced by the equivalent vfunc on the StageWindow
interface. We can safely remove it, now, and simplify the flow of the
redraw code inside ClutterStage.

gesture-action: Protect against NULL pointers

gesture-action: Use the event propagation macros

docs: Add the ::destroy change in the release notes

Given that I had to fix code inside Clutter that did not check for NULL
pointers, I assume other people may experience the same issues.

text: Use the event and source symbolic macros

Instead of boolean values.

drop-action: Use the event propagation macros

drag-action: Use the new event propagation macros

deform-effect: Check against NULL pointers

Do not try to disconnect signal handlers from NULL pointers.

click-action: Use the new symbolic event propagation macros

click-action: Be resilient against NULL pointers

Do not try to disconnect signal handlers from NULL pointers.

build: Remove a bunch of useless checks

Some pkg-config dependencies are still there from the days when Cogl
was in tree - and even then, they barely made sense.

build: Fix the private pkg-config requirements

Private pkg-config requirements are conditional.

wayland: Pull gdk-pixbuf in a private dependency

This means it will get tested for explicitly as well as appearing in the
Requires.private section of the pkg-config file.

build: Add infrastructure for inserting Requires.private into pkg-config files

wayland: Attach cursor buffer to input device when it enters the surface

The Wayland semantics mean that we must attach a buffer to the input device
when the pointer enters the surface to provide a cursor.

wayland: Load a buffer from well known location for the cursor

Semantic changes to Wayland means that we cannot rely on the compositor
setting a pointer buffer for us if set it to nil. The first part of fixing
this is to create an shm buffer containing the bytes for our cursor.

The best way to do this currently is to load the cursor from the well known
location where weston instals its cursor images. The code to implemente this
was derivedlifted from the Wayland backend in GTK+.

Prevent .po file updates on simple 'make'

https://bugzilla.gnome.org/show_bug.cgi?id=661128

Updated Bulgarian translation

osx: Use Lucida Grande as the default font

Instead of falling back to the generic "Sans".

actor: Change the point of emission of ::destroy

Currently, we're emitting the ClutterActor::destroy at the end of the
dispose implementation - right before we chain up to the parent
implementation.

The point of emission makes the ::destroy signal handlers able to just
use the actor pointer - as the actor state will have been mostly cleared
by the time application can run. This (undocumented) behaviour severely
limits the amount of things you can do inside a ::destroy signal
handler, thus making the ::destroy signal just a weird weak reference,
instead of a proper way to break application reference cycles.

Given that this change relaxes some of the conditions, this change
should be safe - obviously, if anything happens, we'll back it out; the
conformance and interactive tests confirm that, for common patterns of
usage, this change does not break existing code.

actor: Use g_clear_object()

GLib has a nice, atomic object clearing function that allows us to drop
code looking like:

  if (priv->object != NULL)
    {
      g_object_unref (priv->object);
      priv->object = NULL;
    }

from the ::dispose implementation.

docs: Add event propagation symbolic constants

configure: Clean up help and configuration summary

Move Perspective and Fog definitions to clutter-types.h

Since we reference the types from multiple files.

docs/cookbook: Mention the event control macros

Now that we have symbolic names for event propagation values for signal
handlers, we ought to mention them in the cookbook.

Add symbolic constants for event propagation

I always have to think twice before returning a value from an event
signal handler, and I've been writing them for the past 10 years, so
it's conceivable that application developers that start with Clutter
will find them confusing as well.

Simple symbolic names should be easier to use.

docs: Update the release notes

stage: Deprecate :use-fog and :fog

The depth cueing through GL fog has been broken for a long while, now.

The fog-related API in Clutter is ridiculously limited, and harks back
to simpler times; the ClutterFog structure is not enough to express all
the GL fog machinery, and required application code to connect to the
Stage's paint implementation and drop into Cogl directly.

Additionally, the fixed pipeline fog machinery in GL simply does not
work with premultiplied alpha, unless you use a shader - and in that
case it would only work for textures. Let's deprecate it, and just
don't do anything if somebody has the brilliant idea of setting the
:use-fog property to TRUE.

box: Remove the sentinel annotation

Sadly, we need to remove the G_GNUC_NULL_TERMINATED annotation from
ClutterBox packing API; the compiler will otherwise emit a warning
for perfectly legal statements like:

  clutter_box_pack (box, child, NULL);

because of the missing sentinel.

See also: g_object_new().

docs: Document CLUTTER_ENABLE_DIAGNOSTIC

Add a note in the API reference.

Add diagnostic mode

GLib has a "diagnostic mode" switch that can be checked to enable debug
messages on deprecated properties and signals, as these are purely
run-time constructs, and as such cannot be caught by compiler warnings.
The diagnostic mode is toggled by a simple environment variable, and
can be used to ease porting of application code.

We can use something similar to mark deprecated virtual functions and
other run-time constructs; to avoid collisions, we should use our own
environment variable, CLUTTER_ENABLE_DIAGNOSTIC.

Updated Norwegian bokmål translation

clutter-text: Fix memory leak

Updated Slovenian translation

Visual C++ 2008 projects update

Refines things a little bit from the last Visual C++ 2008 project updates.

Update Visual C++ 2010 Projects

Disable deprecation warning messages for the accessibility, performance
and micro-bench programs.

Update Visual C++ 2008 Projects

Turn off the deprecation warnings for the accessibility, performance
and micro-bench programs.

Update clutter.symbols...

...For the addition of queue_redraw_with_clip (commit f0a246cd)

wayland/surface: Use queue_redraw_with_clip()

Just like the X11 texture-pixmap actor.

https://bugzilla.gnome.org/show_bug.cgi?id=660997

x11/texture-pixmap: Use ClutterActor.queue_redraw_with_clip()

Instead of using a PaintVolume for a 2D region, and an internal
function, use the newly added queue_redraw_with_clip() method.

This removes the last bit of internal API usage in the
ClutterX11TexturePixmap actor.

https://bugzilla.gnome.org/show_bug.cgi?id=660997