build: Bump up the Cogl requirement

Clutter requires a new version of Cogl's API, but we never bumped the
requirement inside configure.ac.

stage: Use clutter_actor_set_allocation()

Instead of chaining up, given that we want to bypass chaining up and
just set the allocation. This also allows us to bail out of the
overridden allocate vfunc check, given that we want the default Actor
behaviour to apply - including eventual layout manager delegates.

actor: Fix the has_overridden_allocate check

docs: Add clutter_actor_set_allocation()

symbols: Add clutter_actor_set_allocation()

actor: Maintain behaviour of old allocate() implementations

The usual way to implement a container actor is to override the
allocate() virtual function, chain up, and then allocate the actor's
children.

Clutter now has the ability to delegate layout management to
ClutterLayoutManager directly; in the allocation, this is done by
checking whether the actor has children, and then call
clutter_layout_manager_allocate() from within the default implementation
of the ClutterActor::allocate() vfunc. The same vfunc that everyone, has
been chaining up to.

Whoopsie.

Well, we can check if there's a layout manager, and if it's NULL, we
bail out. Except that there's a default layout manager, and it's the
fixed layout manager, so that classes like Group and Stage work by
default.

Double whoopsie.

The fix for this scenario is a bit nasty; we have to check if the actor
class has overridden the allocate() vfunc or not, before actually
looking at the layout manager. This means that classes that override the
allocate() vfunc are expected to do everything that ClutterActor's
default implementation does - which I think it's a fair requirement to
have.

For newly written code, though, it would probably be best if we just
provided a function that does the right thing by default, and that
you're supposed to be calling from within the allocate() vfunc
implementation, if you ever chose to override it. This new function,
clutter_actor_set_allocation(), should come with a warning the size of
Texas, to avoid people thinking it's a way to override the whole "call
allocate() on each child" mechanism. Plus, it should check if we're
inside an allocation sequence, and bail out if not.

actor: Be more conservative with the default paint volume

Check the allocation, when one is being used to initialize the paint
volume.

Updated Spanish translation

build: Fix up the test rules for private deps

Thanks to diegoe for the help with testing.

Updated POTFILES.in

build: Add private deps to cflags and libs

If we go through the whole exercise of having private dependencies, we
should at least use the compiler flags and linker flags that those
dependencies give us when building Clutter.

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

actor: Add :first-child and :last-child properties

Toolkits tracking first and last children of a ClutterActor can use
these properties to get notification of hierarchy changes.

actor: Do not use ::constructed

If we want to set a default layout manager, we need to do so inside
init(), as it's not guaranteed that people subclassing Actor and
overriding ::constructed will actually chain up as they should.

interactive: Drop more deprecated classes

interactive: Use ClutterActor instead of deprecated classes

conform/actor-size: Do not use Rectangle

Use ClutterActor directly, instead.

actor: Provide a better default pick() behaviour

The default pick() behaviour does not take into consideration the
children of a ClutterActor because the existing containter actors
usually override pick(), chain up, and then paint their children.

With ClutterActor now a concrete class, though, we need a way to pick
its children without requiring a sub-class; we could simply iterate over
the children inside the default pick() implementation, but this would
lead to double painting, which is not acceptable.

A moderately gross hack is to check if the Actor instance did override
the pick() implementation, and if it is not the case, paint the children
in pick mode.

actor: Deprecate show_all()/hide_all()

The hide_all() method is pretty much pointless, as hiding an actor will
automatically prevent its children from being painted. The show_all()
method would only be marginally useful, if actors weren't set to be
visible by default when added to another actor - which was the case when
we introduced show_all() and hide_all().

Updated Spanish translation

Post-release version bump to 1.9.5

Release Clutter 1.9.4 (snapshot)

text: Fix the buffer length check on paint

script: Fix a segfault

Accessing a variable before it is being set is not a great plan.

text-buffer: Fix the Since annotations

Update the NEWS file

Add ClutterTextBuffer to the API reference

Update clutter.symbols for TextBuffer

interactive/text: Remove spurious g_object_unref()

text: Implement ClutterTextBuffer

 * Abstracts the buffer for text in ClutterText
 * Allows implementation of undo/redo.
 * Allows use of non-pageable memory for text
   in the case of sensitive passwords.
 * Implement a test with two ClutterText using the same
   buffer.

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

Updated Spanish translation

Update clutter.symbols

Updated Galician translations

Updated POTFILES.in

Fix compiler warnings

When dereferencing GArray.data to a C structure you need a double cast
from guint8* to void*, and then from void* to the actual type. This
avoids compiler warnings, especially when using clang on OSX.

docs: Move deprecated sections to the proper location

actor: Deprecated push/pop internal methods

The concept of "internal child" only meant anything when we had a
separate API for containers and actors. Now that we plugged that
particular hole, we can drop all the hacks we used to have in place
to work around its design limitations.

docs: Fixes for the API reference

actor: Add boxed margin accessors

It can be convenient to be able to set, or get, all the components of an
actor's margin at the same time; since we already have a boxed type for
storing a margin, an accessors pair based on it is not a complicated
addition to the API.

docs: Update the release notes

build: Add inclusion guards and license notices

actor: Use proper internal API

Inside the set_child_[above|below]_sibling() and set_child_at_index() we
should be using the internal API for mutating the children list, instead
of the delegate functions. This ensures that we go through a single,
well-defined code path for all operations on the list of children of
an actor.

Deprecate the old raise/lower API

We have a replacement in ClutterActor, now.

The old ClutterContainer API needs to be deprecated, and the raise() and
lower() virtual functions need a default implementation, so we can check
for implementations overriding them, by using the diagnostic mode like
we do for add(), remove(), and foreach().

The sort_depth_order() virtual function just doesn't do anything, as it
should have been made ages ago.

The Actor wrappers for the Container methods also need to be deprecated.

actor: Add new methods for changing the paint sequence

ClutterActor provides four methods for changing the paint sequence order
of its children:

  raise_top()
  raise()
  lower()
  lower_bottom()

The first and last one being just wrappers around raise() and lower(),
respectively. These methods have various issues: they omit the parent,
preferring to retrieve it from the actor passed as the first argument;
this does not match the new style of API introduced to operate on the
list of children of an actor.

Additionally, the raise() and lower() methods of ClutterActor call into
the Container interface, and are not really aptly named (raise() in
particular collides with the completely unrelated 'raise' keyword in
Python, and usually needs to be wrapped in order to be used at all).

Furthermore, we need public methods that Container can call from its
default implementation, as well as methods to port current Container
implementations.

Finally, since we have insert_child_at_index(), we should also have an
equivalent set_child_at_index() as well.

actor: Use flags to control add/remove child

The internal versions of add_child() and remove_child() currently use
boolean arguments to control things like the ChildMeta instances and
the emissions of signals; using more than one boolean argument is an
indication that you need flags to avoid readability issues, as well as
providing a way to add new behaviours without a combinatorial explosion
of arguments, later on.

actor: Remove automagic "expand" flag

I don't feel comfortable with this feature, and its implementation
still has too many rough edges. We can safely punt it for now, and
introduce it at a later point, as it doesn't block existing features
or API.

table-layout: Override compute_expand()

The TableLayout has two expansion flags that need to be taken into
consideration when computing the Actor expansion flags.

box-layout: Override compute_expand()

ClutterBoxLayout has an expansion flag, and we need to take that into
consideration when computing the Actor expansion flags.

actor: Ask the LayoutManager to compute the expansion flags

If an actor has a layout manager, we want to involve the delegate object
into the lazy computation of the expansion flags state.

layout-manager: Add compute_expand() vfunc

This virtual function will let layout managers with legacy expansion
flags be able to influence the lazy computation of the expansion flags
on ClutterActor.

actor: Paint the background color in the paint class handler

We need to paint the background color in the default class handler for
two reasons: it's logically appropriate, and we don't want actor
subclasses overriding the ::paint class handler to change behaviour only
because somebody decided to set the background color.

docs: Update the release notes

docs: Clean up ClutterContainer's description

The API to add/remove/iterate over children is in ClutterActor, now.

container: Add diagnostic warnings for deprecated vfuncs

The old add(), remove(), and foreach() virtual functions are deprecated;
ClutterContainer should warn if the public API detects that the vfuncs
have been overridden.

Strictly speaking, it's still legal to override those vfuncs: you can
chain up to the default vtable, or you could just provide an equivalent
implementation. The goal is to avoid having to override the Container
interface, until we can safely deprecate it and remove it in Clutter
2.0.

container: Provide default implementation of vfuncs

Instead of making ClutterActor implement the basic add/remove/foreach
virtual functions of ClutterContainer, we can simply do that from
within the ClutterContainer implementation.

container: Deprecate more methods

The get_children(), foreach(), and foreach_with_internals() methods and
virtual functions are superceded by the Actor API, and should not be
used in newly written code.

group: Use Actor.remove_all_children()

To implement the remove_all() method.

cally: Use Actor.get_children()

Instead of the Container method, given that the new get_children() gives
us more actors by default.

tests/interactive: Add a simple test for Actor

It's meant to be xincluded in the API reference.

actor: Add some debug spew

docs: Update the Actor API reference

Given the size and scope of the changes in ClutterActor, we ought to
rewrite the overall description of what an actor is, what it does, and
how are you supposed to use it and subclass it.

Deprecate Container add() and remove() methods

This will make things interesting.

We have better replacements in ClutterActor, that do The Right Thing™
instead of deferring control and requiring reimplementation in every
single container actor.

actor: Add remove_all_children()

A simple method for removing all children of an actor in one fell swoop.

docs: Clarify the Actor's iterator API behaviour

It should be noted in the documentation that it is not safe to operate
on the list of children of an Actor while iterating over it.

actor: Provide a proper implementation of replace_child()

The correct sequence of actions should be remove(old) → insert(new), not
insert(new) → remove(old). We can implement a simple delegate insertion
functions to insert the new child between the previous and next siblings
of the old child.

While we're at it, let's also add a unit test for replace_child().

actor: Fix get_paint_volume() default implementation

Providing a default get_paint_volume() that takes into account the
children of an actor was a goal of the whole First Apocalypse; if we
make all the containers rely on it, and yet we return a FALSE value
(meaning: we don't have a valid paint volume) even when we do have it,
then we are going to break the whole machinery, though.

stage: Use the Actor iteration API

Remove usage of Actor/Container.get_children()

ClutterBox and ClutterGroup are still using the get_children() method
instead of the child iteration API.

actor: Simplify first/last child updates

Drop some more ClutterContainer.get_children() uses

fixed-layout: Use the Actor iteration API

Forgot to migrate the FixedLayout layout manager like we did for the
other layout managers provided by Clutter.

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.