isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-30 03:50:47 -05:00
Code Issues Packages Projects Releases Wiki Activity
e88de5f5fd
mutter/clutter/clutter-clone.c

358 lines
9.9 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/>.
*/
/**
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
* SECTION:clutterclone
* @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,
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
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
};
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
};
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,
ClutterUnit for_height,
ClutterUnit *min_width_p,
ClutterUnit *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
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 (clone_source == NULL))
{
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,
ClutterUnit for_width,
ClutterUnit *min_height_p,
ClutterUnit *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;
if (G_UNLIKELY (clone_source == NULL))
{
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
}
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 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
ClutterActor *parent;
ClutterGeometry geom, clone_geom;
Rename ActorClone to Clone/2 Step two: rename the object and its methods. While we're at it, adhere more strictly to the coding style practises; rename :clone-source to :source; add a setter method for the :source property; take a reference on the source actor to avoid it disappearing while we're still accessing it.
2009-01-26 06:03:12 -05:00
gfloat x_scale, y_scale;
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");
[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
/* get our allocated size */
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 11:51:03 -05:00
clutter_actor_get_allocation_geometry (self, &geom);
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 06:59:39 -05:00
/* and get the allocated size of the source */
clutter_actor_get_allocation_geometry (priv->clone_source, &clone_geom);
Improves the unit test to verify more awkward scaling and some corresponding fixes This simplifies the mucking about with the model-view matrix that was previously done which improves its efficiency when scaling is necessary. Notably: There should now be no performance advantage to using ClutterCloneTexture as a special case clone actor since this method is just as efficient. The unit test was renamed to test-actor-clone.
2009-01-19 14:11:00 -05:00
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 06:59:39 -05:00
/* We need to scale what the clone-source actor paints to fill our own
* allocation...
*/
x_scale = (gfloat) geom.width / clone_geom.width;
y_scale = (gfloat) geom.height / clone_geom.height;
Improves the unit test to verify more awkward scaling and some corresponding fixes This simplifies the mucking about with the model-view matrix that was previously done which improves its efficiency when scaling is necessary. Notably: There should now be no performance advantage to using ClutterCloneTexture as a special case clone actor since this method is just as efficient. The unit test was renamed to test-actor-clone.
2009-01-19 14:11:00 -05:00
Merge branch 'generic-actor-clone' * generic-actor-clone: Remove CloneTexture from the API [tests] Clean up the Clone interactive test Rename ActorClone to Clone/2 Rename ActorClone to Clone/1 Improves the unit test to verify more awkward scaling and some corresponding fixes Implements a generic ClutterActorClone that doesn't need fbos.
2009-01-27 11:12:30 -05:00
cogl_scale (x_scale, y_scale, 1.0);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 11:51:03 -05:00
/* The final bits of magic:
* - We need to make sure that when the clone-source actor's paint method
* calls clutter_actor_get_paint_opacity, it traverses our parent not it's
* real parent.
* - We need to stop clutter_actor_paint applying the model view matrix of
* the clone source actor.
*/
[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
parent = clutter_actor_get_parent (self);
_clutter_actor_set_opacity_parent (priv->clone_source, 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
_clutter_actor_set_enable_model_view_transform (priv->clone_source, FALSE);
clutter_actor_paint (priv->clone_source);
_clutter_actor_set_enable_model_view_transform (priv->clone_source, TRUE);
_clutter_actor_set_opacity_parent (priv->clone_source, NULL);
}
[clone] Allow cloning unparented actors If the source of a ClutterClone does not have a parent actor the clone will be unable to paint it because it's missing an allocation. A simple way to fix it is to make the ClutterClone act like a "foster parent": when it is allocated it will check if the source actor has a parent and if not it will allocate the source with its preferred size.
2009-02-02 06:59:39 -05:00
static void
clutter_clone_allocate (ClutterActor *self,
const ClutterActorBox *box,
gboolean origin_changed)
{
ClutterClonePrivate *priv = CLUTTER_CLONE (self)->priv;
ClutterActorClass *parent_class;
/* chain up */
parent_class = CLUTTER_ACTOR_CLASS (clutter_clone_parent_class);
parent_class->allocate (self, box, origin_changed);
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)
{
clutter_actor_allocate_preferred_size (priv->clone_source,
origin_changed);
}
}
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
{
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
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)
{
g_object_unref (priv->clone_source);
priv->clone_source = NULL;
}
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
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;
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",
"Source",
"Specifies the actor to be cloned",
CLUTTER_TYPE_ACTOR,
G_PARAM_CONSTRUCT_ONLY |
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_SOURCE, pspec);
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 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
}
/**
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_source:
* @clone: a #ClutterClone
* @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
* Sets @source as the source actor to be cloned by @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
*
* 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
void
clutter_clone_set_source (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)
{
g_object_unref (priv->clone_source);
priv->clone_source = NULL;
}
if (source)
priv->clone_source = g_object_ref (source);
g_object_notify (G_OBJECT (clone), "source");
clutter_actor_queue_relayout (CLUTTER_ACTOR (clone));
Implements a generic ClutterActorClone that doesn't need fbos. Many use cases for clonning an actor don't require running a shader on the resulting clone image and so requiring FBOs in these cases is overkill and in-efficient as it requires kicking and synchronizing a render for each clone. This approach basically just uses the paint function of another actor to implement the painting for the clone actor with some fiddling of the model- view matrix to scale according to the different allocation box sizes of each of the actors. A simple unit test called test-actors2 was added for testing.
2009-01-17 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
/**
* clutter_clone_get_source:
* @clone: a #ClutterClone
*
* Retrieves the source #ClutterActor being cloned by @clone
*
* Return value: the actor source for the clone
*
* 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