isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-12 14:20:17 +00:00
Code Issues Packages Projects Releases Wiki Activity
9b7579d916
mutter/clutter/clutter-clone.c

397 lines
11 KiB
C
Raw Normal View History

Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2008 Intel Corporation.
*
* Authored By: Robert Bragg <robert@linux.intel.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/**
[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.
2009-03-16 15:00:55 +00:00
* SECTION:clutter-clone
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
* @short_description: An actor that displays a clone of a source actor
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
*
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
* #ClutterClone is a #ClutterActor which draws with the paint
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
* function of another actor, scaled to fit its own allocation.
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
*
* #ClutterClone can be used to efficiently clone any other actor.
*
* <note><para>This is different from clutter_texture_new_from_actor()
* which requires support for FBOs in the underlying GL
* implementation.</para></note>
*
* #ClutterClone is available since Clutter 1.0
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
*/
Remove CloneTexture from the API ClutterClone supercedes ClutterCloneTexture, since it can clone every kind of actor -- including composite ones. This is another "brain surgery with a shotgun" kind of commit: it removes CloneTexture and updates every test case using CloneTexture to ClutterClone. The API fallout is minimal, luckily for us.
2009-01-27 15:18:45 +00:00
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "clutter-color.h"
Rename ActorClone to Clone/1 Step one of the ActorClone -> Clone renaming: rename the files.
2009-01-26 10:32:53 +00:00
#include "clutter-clone.h"
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
#include "clutter-debug.h"
#include "clutter-main.h"
#include "clutter-private.h"
#include "cogl/cogl.h"
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
G_DEFINE_TYPE (ClutterClone, clutter_clone, CLUTTER_TYPE_ACTOR);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
enum
{
PROP_0,
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
PROP_SOURCE
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
};
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
#define CLUTTER_CLONE_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_CLONE, ClutterClonePrivate))
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
struct _ClutterClonePrivate
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
ClutterActor *clone_source;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
};
[clone] Redraw when the source changes Bug 1484 - Redraw ClutterClone when the source changes, even for !visible sources Connect to ::queue-redraw on the clone source and queue a redraw. This allows redrawing the Clone when the source changes, even in case of a non visible source actor. http://bugzilla.openedhand.com/show_bug.cgi?id=1484 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-02-27 19:43:47 +00:00
static void clutter_clone_set_source_internal (ClutterClone *clone,
ClutterActor *source);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
static void
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
clutter_clone_get_preferred_width (ClutterActor *self,
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
ClutterClonePrivate *priv = CLUTTER_CLONE (self)->priv;
ClutterActor *clone_source = priv->clone_source;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
if (clone_source == NULL)
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
{
if (min_width_p)
*min_width_p = 0;
if (natural_width_p)
*natural_width_p = 0;
}
else
clutter_actor_get_preferred_width (clone_source,
for_height,
min_width_p,
natural_width_p);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
}
static void
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
clutter_clone_get_preferred_height (ClutterActor *self,
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
ClutterClonePrivate *priv = CLUTTER_CLONE (self)->priv;
ClutterActor *clone_source = priv->clone_source;
Remove Units from the public API With the recent change to internal floating point values, ClutterUnit has become a redundant type, defined to be a float. All integer entry points are being internally converted to floating point values to be passed to the GL pipeline with the least amount of conversion. ClutterUnit is thus exposed as just a "pixel with fractionary bits", and not -- as users might think -- as generic, resolution and device independent units. not that it was the case, but a definitive amount of people was convinced it did provide this "feature", and was flummoxed about the mere existence of this type. So, having ClutterUnit exposed in the public API doubles the entry points and has the following disadvantages: - we have to maintain twice the amount of entry points in ClutterActor - we still do an integer-to-float implicit conversion - we introduce a weird impedance between pixels and "pixels with fractionary bits" - language bindings will have to choose what to bind, and resort to manually overriding the API + *except* for language bindings based on GObject-Introspection, as they cannot do manual overrides, thus will replicate the entire set of entry points For these reason, we should coalesces every Actor entry point for pixels and for ClutterUnit into a single entry point taking a float, like: void clutter_actor_set_x (ClutterActor *self, gfloat x); void clutter_actor_get_size (ClutterActor *self, gfloat *width, gfloat *height); gfloat clutter_actor_get_height (ClutterActor *self); etc. The issues I have identified are: - we'll have a two cases of compiler warnings: - printf() format of the return values from %d to %f - clutter_actor_get_size() taking floats instead of unsigned ints - we'll have a problem with varargs when passing an integer instead of a floating point value, except on 64bit platforms where the size of a float is the same as the size of an int To be clear: the *intent* of the API should not change -- we still use pixels everywhere -- but: - we remove ambiguity in the API with regard to pixels and units - we remove entry points we get to maintain for the whole 1.0 version of the API - we make things simpler to bind for both manual language bindings and automatic (gobject-introspection based) ones - we have the simplest API possible while still exposing the capabilities of the underlying GL implementation
2009-05-06 15:44:47 +00:00
if (clone_source == NULL)
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
{
if (min_height_p)
*min_height_p = 0;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
if (natural_height_p)
*natural_height_p = 0;
}
else
clutter_actor_get_preferred_height (clone_source,
for_width,
min_height_p,
natural_height_p);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
}
static void
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
clutter_clone_paint (ClutterActor *self)
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
ClutterClone *clone = CLUTTER_CLONE (self);
ClutterClonePrivate *priv = clone->priv;
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 11:59:39 +00:00
ClutterGeometry geom, clone_geom;
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
gfloat x_scale, y_scale;
[clone] Allow painting hidden source actors With the introduction of the map/unmap flags and the split of the visible state from the mapped state we require that every part of a scene graph branch is mapped in order to be painted. This breaks the ability of a ClutterClone to paint an hidden source actor. In order to fix this we need to introduce an override flag, similar in spirit to the current modelview and paint opacity overrides that Clone is already using. The override flag, when set, will force a temporary map on a Clone source (and its children).
2009-05-01 11:33:42 +00:00
gboolean was_unmapped = FALSE;
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
if (G_UNLIKELY (priv->clone_source == NULL))
return;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
CLUTTER_NOTE (PAINT,
"painting clone actor '%s'",
clutter_actor_get_name (self) ? clutter_actor_get_name (self)
: "unknown");
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 11:59:39 +00:00
/* get our allocated size */
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
clutter_actor_get_allocation_geometry (self, &geom);
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 11:59:39 +00:00
/* and get the allocated size of the source */
clutter_actor_get_allocation_geometry (priv->clone_source, &clone_geom);
Improves the unit test to verify more awkward scaling and some corresponding fixes This simplifies the mucking about with the model-view matrix that was previously done which improves its efficiency when scaling is necessary. Notably: There should now be no performance advantage to using ClutterCloneTexture as a special case clone actor since this method is just as efficient. The unit test was renamed to test-actor-clone.
2009-01-19 19:11:00 +00:00
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 11:59:39 +00:00
/* We need to scale what the clone-source actor paints to fill our own
* allocation...
*/
x_scale = (gfloat) geom.width / clone_geom.width;
y_scale = (gfloat) geom.height / clone_geom.height;
Improves the unit test to verify more awkward scaling and some corresponding fixes This simplifies the mucking about with the model-view matrix that was previously done which improves its efficiency when scaling is necessary. Notably: There should now be no performance advantage to using ClutterCloneTexture as a special case clone actor since this method is just as efficient. The unit test was renamed to test-actor-clone.
2009-01-19 19:11:00 +00:00
Merge branch 'generic-actor-clone' * generic-actor-clone: Remove CloneTexture from the API [tests] Clean up the Clone interactive test Rename ActorClone to Clone/2 Rename ActorClone to Clone/1 Improves the unit test to verify more awkward scaling and some corresponding fixes Implements a generic ClutterActorClone that doesn't need fbos.
2009-01-27 16:12:30 +00:00
cogl_scale (x_scale, y_scale, 1.0);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
/* The final bits of magic:
[clutter-clone] Override the parent opacity to self not self->parent The opacity of the source actor when painted from the clone should be combined with the opacity of the clone as well as the clone's parents, instead of just the parents.
2009-02-04 00:14:16 +00:00
* - We need to make sure that when the clone-source actor's paint
* method calls clutter_actor_get_paint_opacity, it traverses to
* us and our parent not it's real parent.
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
* - We need to stop clutter_actor_paint applying the model view matrix of
* the clone source actor.
*/
[clutter-clone] Override the parent opacity to self not self->parent The opacity of the source actor when painted from the clone should be combined with the opacity of the clone as well as the clone's parents, instead of just the parents.
2009-02-04 00:14:16 +00:00
_clutter_actor_set_opacity_parent (priv->clone_source, self);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
_clutter_actor_set_enable_model_view_transform (priv->clone_source, FALSE);
[clone] Allow painting hidden source actors With the introduction of the map/unmap flags and the split of the visible state from the mapped state we require that every part of a scene graph branch is mapped in order to be painted. This breaks the ability of a ClutterClone to paint an hidden source actor. In order to fix this we need to introduce an override flag, similar in spirit to the current modelview and paint opacity overrides that Clone is already using. The override flag, when set, will force a temporary map on a Clone source (and its children).
2009-05-01 11:33:42 +00:00
if (!CLUTTER_ACTOR_IS_MAPPED (priv->clone_source))
{
_clutter_actor_set_enable_paint_unmapped (priv->clone_source, TRUE);
was_unmapped = TRUE;
}
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
clutter_actor_paint (priv->clone_source);
[clone] Allow painting hidden source actors With the introduction of the map/unmap flags and the split of the visible state from the mapped state we require that every part of a scene graph branch is mapped in order to be painted. This breaks the ability of a ClutterClone to paint an hidden source actor. In order to fix this we need to introduce an override flag, similar in spirit to the current modelview and paint opacity overrides that Clone is already using. The override flag, when set, will force a temporary map on a Clone source (and its children).
2009-05-01 11:33:42 +00:00
if (was_unmapped)
_clutter_actor_set_enable_paint_unmapped (priv->clone_source, FALSE);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
_clutter_actor_set_enable_model_view_transform (priv->clone_source, TRUE);
_clutter_actor_set_opacity_parent (priv->clone_source, NULL);
}
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 11:59:39 +00:00
static void
[actor] Use flags to control allocations Instead of passing a boolean value, the ::allocate virtual function should use a bitmask and flags. This gives us room for expansion without breaking API/ABI, and allows to encode more information to the allocation process instead of just changes of absolute origin.
2009-06-03 13:02:06 +00:00
clutter_clone_allocate (ClutterActor *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 11:59:39 +00:00
{
ClutterClonePrivate *priv = CLUTTER_CLONE (self)->priv;
ClutterActorClass *parent_class;
/* chain up */
parent_class = CLUTTER_ACTOR_CLASS (clutter_clone_parent_class);
[actor] Use flags to control allocations Instead of passing a boolean value, the ::allocate virtual function should use a bitmask and flags. This gives us room for expansion without breaking API/ABI, and allows to encode more information to the allocation process instead of just changes of absolute origin.
2009-06-03 13:02:06 +00:00
parent_class->allocate (self, box, flags);
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 11:59:39 +00:00
if (G_UNLIKELY (priv->clone_source == NULL))
return;
/* we act like a "foster parent" for the source we are cloning;
* if the source has not been parented we have to force an
* allocation on it, so that we can paint it correctly from
* within out paint() implementation. since the actor does not
* have a parent, and thus it won't be painted by the usual
* paint cycle, we can safely give it as much size as it requires
*/
if (clutter_actor_get_parent (priv->clone_source) == NULL)
[actor] Use flags to control allocations Instead of passing a boolean value, the ::allocate virtual function should use a bitmask and flags. This gives us room for expansion without breaking API/ABI, and allows to encode more information to the allocation process instead of just changes of absolute origin.
2009-06-03 13:02:06 +00:00
clutter_actor_allocate_preferred_size (priv->clone_source, flags);
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 11:59:39 +00:00
}
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
static void
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
clutter_clone_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
ClutterClone *clone = CLUTTER_CLONE (gobject);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
switch (prop_id)
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
case PROP_SOURCE:
clutter_clone_set_source (clone, g_value_get_object (value));
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
break;
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
default:
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
break;
}
}
static void
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
clutter_clone_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
ClutterClonePrivate *priv = CLUTTER_CLONE (gobject)->priv;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
switch (prop_id)
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
case PROP_SOURCE:
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
g_value_set_object (value, priv->clone_source);
break;
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
default:
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
break;
}
}
static void
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
clutter_clone_dispose (GObject *gobject)
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
[clone] Redraw when the source changes Bug 1484 - Redraw ClutterClone when the source changes, even for !visible sources Connect to ::queue-redraw on the clone source and queue a redraw. This allows redrawing the Clone when the source changes, even in case of a non visible source actor. http://bugzilla.openedhand.com/show_bug.cgi?id=1484 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-02-27 19:43:47 +00:00
clutter_clone_set_source_internal (CLUTTER_CLONE (gobject), NULL);
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
G_OBJECT_CLASS (clutter_clone_parent_class)->dispose (gobject);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
}
static void
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
clutter_clone_class_init (ClutterCloneClass *klass)
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
GParamSpec *pspec = NULL;
g_type_class_add_private (gobject_class, sizeof (ClutterClonePrivate));
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
actor_class->paint = clutter_clone_paint;
actor_class->get_preferred_width = clutter_clone_get_preferred_width;
actor_class->get_preferred_height = clutter_clone_get_preferred_height;
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 11:59:39 +00:00
actor_class->allocate = clutter_clone_allocate;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
gobject_class->dispose = clutter_clone_dispose;
gobject_class->set_property = clutter_clone_set_property;
gobject_class->get_property = clutter_clone_get_property;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
/**
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
* ClutterClone:source:
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
*
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
* This property specifies the source actor being cloned.
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
*
* Since: 1.0
*/
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
pspec = g_param_spec_object ("source",
Mark property strings for translation Both the nick and the blurb fields should be translatable, for UI builders and other introspection-based tools.
2010-06-03 11:57:50 +00:00
P_("Source"),
P_("Specifies the actor to be cloned"),
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
CLUTTER_TYPE_ACTOR,
clone: Set :source as CONSTRUCT The :source property for ClutterClone is a constructor property, but it most definitely is not a constructor-only one.
2009-10-22 12:48:49 +00:00
G_PARAM_CONSTRUCT |
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_SOURCE, pspec);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
}
static void
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
clutter_clone_init (ClutterClone *self)
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
ClutterClonePrivate *priv;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
self->priv = priv = CLUTTER_CLONE_GET_PRIVATE (self);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
priv->clone_source = NULL;
}
/**
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
* clutter_clone_new:
* @source: a #ClutterActor, or %NULL
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
*
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
* Creates a new #ClutterActor which clones @source/
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
*
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
* Return value: the newly created #ClutterClone
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
*
* Since: 1.0
*/
ClutterActor *
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
clutter_clone_new (ClutterActor *source)
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
return g_object_new (CLUTTER_TYPE_CLONE, "source", source, NULL);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
}
[clone] Redraw when the source changes Bug 1484 - Redraw ClutterClone when the source changes, even for !visible sources Connect to ::queue-redraw on the clone source and queue a redraw. This allows redrawing the Clone when the source changes, even in case of a non visible source actor. http://bugzilla.openedhand.com/show_bug.cgi?id=1484 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-02-27 19:43:47 +00:00
static void
clone_source_queue_redraw_cb (ClutterActor *source,
ClutterActor *origin,
ClutterClone *clone)
{
clutter_actor_queue_redraw (CLUTTER_ACTOR (clone));
}
Add ::queue-relayout signal to ClutterActor for ClutterClone ClutterClone bases its preferred size on the preferred size of the source actor, so it needs to invalid its cached preferred size when the preferred size of the source actor changes. In order for this to work, we need to have notification when the size of the source actor changes, so add a ::queue-relayout signal to ClutterActor. Then connect to this from ClutterClone and queue a relayout on the clone when a relayout is queued on the source. http://bugzilla.openedhand.com/show_bug.cgi?id=1755 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-08-08 01:16:04 +00:00
static void
clone_source_queue_relayout_cb (ClutterActor *source,
ClutterClone *clone)
{
clutter_actor_queue_relayout (CLUTTER_ACTOR (clone));
}
[clone] Redraw when the source changes Bug 1484 - Redraw ClutterClone when the source changes, even for !visible sources Connect to ::queue-redraw on the clone source and queue a redraw. This allows redrawing the Clone when the source changes, even in case of a non visible source actor. http://bugzilla.openedhand.com/show_bug.cgi?id=1484 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-02-27 19:43:47 +00:00
static void
clutter_clone_set_source_internal (ClutterClone *clone,
ClutterActor *source)
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
{
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
ClutterClonePrivate *priv;
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
g_return_if_fail (CLUTTER_IS_CLONE (clone));
g_return_if_fail (source == NULL || CLUTTER_IS_ACTOR (source));
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
priv = clone->priv;
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
if (priv->clone_source)
{
[clone] Redraw when the source changes Bug 1484 - Redraw ClutterClone when the source changes, even for !visible sources Connect to ::queue-redraw on the clone source and queue a redraw. This allows redrawing the Clone when the source changes, even in case of a non visible source actor. http://bugzilla.openedhand.com/show_bug.cgi?id=1484 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-02-27 19:43:47 +00:00
g_signal_handlers_disconnect_by_func (priv->clone_source,
(void *) clone_source_queue_redraw_cb,
clone);
Add ::queue-relayout signal to ClutterActor for ClutterClone ClutterClone bases its preferred size on the preferred size of the source actor, so it needs to invalid its cached preferred size when the preferred size of the source actor changes. In order for this to work, we need to have notification when the size of the source actor changes, so add a ::queue-relayout signal to ClutterActor. Then connect to this from ClutterClone and queue a relayout on the clone when a relayout is queued on the source. http://bugzilla.openedhand.com/show_bug.cgi?id=1755 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-08-08 01:16:04 +00:00
g_signal_handlers_disconnect_by_func (priv->clone_source,
(void *) clone_source_queue_relayout_cb,
clone);
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
g_object_unref (priv->clone_source);
priv->clone_source = NULL;
}
if (source)
[clone] Redraw when the source changes Bug 1484 - Redraw ClutterClone when the source changes, even for !visible sources Connect to ::queue-redraw on the clone source and queue a redraw. This allows redrawing the Clone when the source changes, even in case of a non visible source actor. http://bugzilla.openedhand.com/show_bug.cgi?id=1484 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-02-27 19:43:47 +00:00
{
priv->clone_source = g_object_ref (source);
g_signal_connect (priv->clone_source, "queue-redraw",
G_CALLBACK (clone_source_queue_redraw_cb), clone);
Add ::queue-relayout signal to ClutterActor for ClutterClone ClutterClone bases its preferred size on the preferred size of the source actor, so it needs to invalid its cached preferred size when the preferred size of the source actor changes. In order for this to work, we need to have notification when the size of the source actor changes, so add a ::queue-relayout signal to ClutterActor. Then connect to this from ClutterClone and queue a relayout on the clone when a relayout is queued on the source. http://bugzilla.openedhand.com/show_bug.cgi?id=1755 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-08-08 01:16:04 +00:00
g_signal_connect (priv->clone_source, "queue-relayout",
G_CALLBACK (clone_source_queue_relayout_cb), clone);
[clone] Redraw when the source changes Bug 1484 - Redraw ClutterClone when the source changes, even for !visible sources Connect to ::queue-redraw on the clone source and queue a redraw. This allows redrawing the Clone when the source changes, even in case of a non visible source actor. http://bugzilla.openedhand.com/show_bug.cgi?id=1484 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-02-27 19:43:47 +00:00
}
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
g_object_notify (G_OBJECT (clone), "source");
clutter_actor_queue_relayout (CLUTTER_ACTOR (clone));
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 16:51:03 +00:00
}
[clone] Redraw when the source changes Bug 1484 - Redraw ClutterClone when the source changes, even for !visible sources Connect to ::queue-redraw on the clone source and queue a redraw. This allows redrawing the Clone when the source changes, even in case of a non visible source actor. http://bugzilla.openedhand.com/show_bug.cgi?id=1484 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-02-27 19:43:47 +00:00
/**
* clutter_clone_set_source:
* @clone: a #ClutterClone
* @source: a #ClutterActor, or %NULL
*
* Sets @source as the source actor to be cloned by @clone.
*
* Since: 1.0
*/
void
clutter_clone_set_source (ClutterClone *clone,
ClutterActor *source)
{
g_return_if_fail (CLUTTER_IS_CLONE (clone));
g_return_if_fail (source == NULL || CLUTTER_IS_ACTOR (source));
clutter_clone_set_source_internal (clone, source);
clutter_actor_queue_relayout (CLUTTER_ACTOR (clone));
}
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
/**
* clutter_clone_get_source:
* @clone: a #ClutterClone
*
* Retrieves the source #ClutterActor being cloned by @clone
*
Add gobject-introspection annotations Add annotations such as (transfer-none) (out) (element-type ClutterActor), and so forth to the doc comments as appropriate. The annotations added here are a combination of the annotations previously in gir-repository for Clutter and annotations found in a review of all return values with that were being parsed with a transfer of "full". http://bugzilla.openedhand.com/show_bug.cgi?id=1452 Signed-off-by: Emmanuele Bassi <ebassi@linux.intel.com>
2009-02-17 00:25:20 +00:00
* Return value: (transfer none): the actor source for the clone
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
*
* Since: 1.0
*/
ClutterActor *
Fix typo in the :clone getter method The :clone property getter method, clutter_clone_get_source(), was defined using the wrong name of clutter_clone_get_clone_source().
2009-01-27 20:06:58 +00:00
clutter_clone_get_source (ClutterClone *clone)
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 11:03:12 +00:00
{
g_return_val_if_fail (CLUTTER_IS_CLONE (clone), NULL);
return clone->priv->clone_source;
}
Reference in New Issue Copy Permalink