brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
12f80db8b8
mutter/clutter/clutter-clone.c

435 lines
12 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 11:51:03 -05: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 11:00:55 -04: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 10:18:45 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 10:18:45 -05: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 11:51:03 -05: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 10:18:45 -05: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 11:51:03 -05: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 05:32:53 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05:00
enum
{
PROP_0,
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 05:20:32 -04:00
PROP_SOURCE,
PROP_LAST
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 11:51:03 -05:00
};
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 05:20:32 -04:00
static GParamSpec *obj_props[PROP_LAST];
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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 14:43:47 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:44:47 -04: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 11:44:47 -04: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:44:47 -04: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 11:51:03 -05: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 06:03:12 -05: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 11:44:47 -04: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05:00
}
clone: scale src with apply_transform not cogl_scale Since a ClutterClone may be allocated a different size than its source actor we need to apply a scale factor before painting the source actor. We were manually using cogl_scale to do this in clutter_clone_paint but really this kind of thing is best handled in an implementation of the apply_transform virtual so Clutter can be aware of the transform for other purposes, such as input transformations. Also we want to provide an implementation of the get_paint_volume virtual where Clutter will also expect to be able to use the apply_transform virtual to transform the volume into its parent's coordinate space.
2010-09-10 21:31:03 -04:00
static void
clutter_clone_apply_transform (ClutterActor *self, CoglMatrix *matrix)
{
ClutterClonePrivate *priv = CLUTTER_CLONE (self)->priv;
ClutterGeometry geom;
ClutterGeometry source_geom;
gfloat x_scale;
gfloat y_scale;
/* First chain up and apply all the standard ClutterActor
* transformations... */
CLUTTER_ACTOR_CLASS (clutter_clone_parent_class)->apply_transform (self,
matrix);
/* get our allocated size */
clutter_actor_get_allocation_geometry (self, &geom);
/* and get the allocated size of the source */
clutter_actor_get_allocation_geometry (priv->clone_source, &source_geom);
/* We need to scale what the clone-source actor paints to fill our own
* allocation...
*/
x_scale = (gfloat) geom.width / source_geom.width;
y_scale = (gfloat) geom.height / source_geom.height;
cogl_matrix_scale (matrix, x_scale, y_scale, x_scale);
}
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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05:00
ClutterClone *clone = CLUTTER_CLONE (self);
ClutterClonePrivate *priv = clone->priv;
[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 07:33:42 -04: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 06:03:12 -05: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 11:51:03 -05:00
CLUTTER_NOTE (PAINT,
"painting clone actor '%s'",
clutter_actor_get_name (self) ? clutter_actor_get_name (self)
: "unknown");
/* 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-03 19:14:16 -05: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 11:51:03 -05: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-03 19:14:16 -05: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 11:51:03 -05: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 07:33:42 -04: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 11:51:03 -05: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 07:33:42 -04: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 11:51:03 -05:00
_clutter_actor_set_enable_model_view_transform (priv->clone_source, TRUE);
_clutter_actor_set_opacity_parent (priv->clone_source, NULL);
}
clone: Implement get_paint_volume virtual To allow Clutter to queue clipped redraws when a clone actor changes we need to be able to report a paint volume for clone actors. This patch makes ClutterClones query the paint volume of their source actor and masquerade it as their own volume.
2010-09-10 21:39:23 -04:00
gboolean
clutter_clone_get_paint_volume (ClutterActor *self,
ClutterPaintVolume *volume)
{
ClutterClonePrivate *priv = CLUTTER_CLONE (self)->priv;
const ClutterPaintVolume *source_volume;
/* query the volume of the source actor and simply masquarade it as
* the clones volume... */
source_volume = clutter_actor_get_paint_volume (priv->clone_source);
if (!source_volume)
return FALSE;
_clutter_paint_volume_set_from_volume (volume, source_volume);
_clutter_paint_volume_set_reference_actor (volume, self);
return TRUE;
}
[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 06:59:39 -05: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 09:02:06 -04: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 06:59:39 -05: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 09:02:06 -04: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 06:59:39 -05: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 09:02:06 -04: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 06:59:39 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 14:43:47 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05:00
clone: scale src with apply_transform not cogl_scale Since a ClutterClone may be allocated a different size than its source actor we need to apply a scale factor before painting the source actor. We were manually using cogl_scale to do this in clutter_clone_paint but really this kind of thing is best handled in an implementation of the apply_transform virtual so Clutter can be aware of the transform for other purposes, such as input transformations. Also we want to provide an implementation of the get_paint_volume virtual where Clutter will also expect to be able to use the apply_transform virtual to transform the volume into its parent's coordinate space.
2010-09-10 21:31:03 -04:00
actor_class->apply_transform = clutter_clone_apply_transform;
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 06:03:12 -05:00
actor_class->paint = clutter_clone_paint;
clone: Implement get_paint_volume virtual To allow Clutter to queue clipped redraws when a clone actor changes we need to be able to report a paint volume for clone actors. This patch makes ClutterClones query the paint volume of their source actor and masquerade it as their own volume.
2010-09-10 21:39:23 -04:00
actor_class->get_paint_volume = clutter_clone_get_paint_volume;
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 06:03:12 -05:00
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 06:59:39 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 07:57:50 -04: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 06:03:12 -05: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 08:48:49 -04: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 06:03:12 -05:00
CLUTTER_PARAM_READWRITE);
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 05:20:32 -04:00
obj_props[PROP_SOURCE] = pspec;
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 06:03:12 -05:00
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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 14:43:47 -05: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-07 21:16:04 -04: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 14:43:47 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 11:51:03 -05: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 06:03:12 -05: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 14:43:47 -05: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-07 21:16:04 -04: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 06:03:12 -05: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 14:43:47 -05: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-07 21:16:04 -04: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 14:43:47 -05: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 06:03:12 -05:00
Conditionally use g_object_notify_by_pspec This adds a wrapper macro to clutter-private that will use g_object_notify_by_pspec if it's compiled against a version of GLib that is sufficiently new. Otherwise it will notify by the property name as before by extracting the name from the pspec. The objects can then store a static array of GParamSpecs and notify using those as suggested in the documentation for g_object_notify_by_pspec. Note that the name of the variable used for storing the array of GParamSpecs is obj_props instead of properties as used in the documentation because some places in Clutter uses 'properties' as the name of a local variable. Mose of the classes in Clutter have been converted using the script in the bug report. Some classes have not been modified even though the script picked them up as described here: json-generator: We probably don't want to modify the internal copy of JSON behaviour-depth: rectangle: score: stage-manager: These aren't using the separate GParamSpec* variable style. blur-effect: win32/device-manager: Don't actually define any properties even though it has the enum. box-layout: flow-layout: Have some per-child properties that don't work automatically with the script. clutter-model: The script gets confused with ClutterModelIter stage: Script gets confused because PROP_USER_RESIZE doesn't match "user-resizable" test-layout: Don't really want to modify the tests http://bugzilla.clutter-project.org/show_bug.cgi?id=2150
2010-06-21 05:20:32 -04:00
_clutter_notify_by_pspec (G_OBJECT (clone), obj_props[PROP_SOURCE]);
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 06:03:12 -05:00
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 11:51:03 -05: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 14:43:47 -05: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 06:03:12 -05: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-16 19:25:20 -05: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 06:03:12 -05: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 15:06:58 -05: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 06:03:12 -05:00
{
g_return_val_if_fail (CLUTTER_IS_CLONE (clone), NULL);
return clone->priv->clone_source;
}
Reference in New Issue Copy Permalink