2006-06-13 13:17:45 +00:00
|
|
|
/*
|
|
|
|
* Clutter.
|
|
|
|
*
|
|
|
|
* An OpenGL based 'interactive canvas' library.
|
|
|
|
*
|
|
|
|
* Authored By Matthew Allum <mallum@openedhand.com>
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006 OpenedHand
|
|
|
|
*
|
|
|
|
* 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, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2006-06-21 22:34:25 +00:00
|
|
|
* SECTION:clutter-actor
|
2007-10-12 08:17:00 +00:00
|
|
|
* @short_description: Base abstract class for all visual stage actors.
|
|
|
|
*
|
2007-06-16 20:58:00 +00:00
|
|
|
* #ClutterActor is a base abstract class for all visual elements on the
|
|
|
|
* stage. Every object that must appear on the main #ClutterStage must also
|
|
|
|
* be a #ClutterActor, either by using one of the classes provided by
|
|
|
|
* Clutter, or by implementing a new #ClutterActor subclass.
|
2007-10-09 23:45:49 +00:00
|
|
|
*
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
* Actor Transformations
|
2007-11-28 12:23:31 +00:00
|
|
|
* The OpenGL modelview matrix for the actor is constructed from the actor
|
|
|
|
* settings by the following order of operations:
|
|
|
|
* <orderedlist>
|
|
|
|
* <listitem><para>Translation by actor x, y coords,</para></listitem>
|
|
|
|
* <listitem><para>Scaling by scale_x, scale_y,</para></listitem>
|
|
|
|
* <listitem><para>Negative translation by anchor point x, y,</para>
|
|
|
|
* </listitem>
|
|
|
|
* <listitem><para>Rotation around z axis,</para></listitem>
|
|
|
|
* <listitem><para>Rotation around y axis,</para></listitem>
|
|
|
|
* <listitem><para>Rotation around x axis,</para></listitem>
|
|
|
|
* <listitem><para>Translation by actor depth (z),</para></listitem>
|
2007-12-17 15:47:19 +00:00
|
|
|
* <listitem><para>Clip stencil is applied (not an operation on the matrix
|
|
|
|
* as such, but done as part of the transform set up).</para>
|
2007-11-28 12:23:31 +00:00
|
|
|
* </listitem>
|
|
|
|
* </orderedlist>
|
2007-10-09 23:45:49 +00:00
|
|
|
*
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
* Event handling
|
2007-10-10 14:51:25 +00:00
|
|
|
* <orderedlist>
|
|
|
|
* <listitem><para>Actors emit pointer events if set reactive, see
|
|
|
|
* clutter_actor_set_reactive()</para></listitem>
|
2007-11-18 23:24:55 +00:00
|
|
|
* <listitem><para>The stage is always reactive</para></listitem>
|
2007-10-15 16:50:59 +00:00
|
|
|
* <listitem><para>Events are handled by connecting signal handlers to
|
|
|
|
* the numerous event signal types.</para></listitem>
|
2007-10-10 14:51:25 +00:00
|
|
|
* <listitem><para>Event handlers must return %TRUE if they handled
|
2007-11-23 17:12:27 +00:00
|
|
|
* the event and wish to block the event emission chain, or %FALSE
|
2007-10-10 14:51:25 +00:00
|
|
|
* if the emission chain must continue</para></listitem>
|
|
|
|
* <listitem><para>Keyboard events are emitted if actor has focus, see
|
2007-11-23 17:12:27 +00:00
|
|
|
* clutter_stage_set_key_focus()</para></listitem>
|
|
|
|
* <listitem><para>Motion events (motion, enter, leave) are not emitted
|
|
|
|
* if clutter_set_motion_events_enabled() is called with %FALSE.
|
|
|
|
* See clutter_set_motion_events_enabled() documentation for more
|
|
|
|
* information.</para></listitem>
|
|
|
|
* <listitem><para>Once emitted, an event emission chain has two
|
2007-10-15 16:50:59 +00:00
|
|
|
* phases: capture and bubble. A emitted event starts in the capture
|
2007-11-23 17:12:27 +00:00
|
|
|
* phase beginning at the stage and traversing every child actor until
|
|
|
|
* the event source actor is reached. The emission then enters the bubble
|
|
|
|
* phase, traversing back up the chain via parents until it reaches the
|
|
|
|
* stage. Any event handler can abort this chain by returning
|
2007-11-28 12:23:31 +00:00
|
|
|
* %TRUE (meaning "event handled").</para></listitem>
|
2007-12-17 15:47:19 +00:00
|
|
|
* <listitem><para>Pointer events will 'pass through' non reactive
|
|
|
|
* overlapping actors.</para></listitem>
|
2007-10-25 14:36:37 +00:00
|
|
|
* </orderedlist>
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
|
2007-11-23 13:11:10 +00:00
|
|
|
/**
|
|
|
|
* CLUTTER_ACTOR_IS_MAPPED:
|
|
|
|
* @e: a #ClutterActor
|
|
|
|
*
|
|
|
|
* Evaluates to %TRUE if the %CLUTTER_ACTOR_MAPPED flag is set.
|
|
|
|
*
|
|
|
|
* Since: 0.2
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* CLUTTER_ACTOR_IS_REALIZED:
|
|
|
|
* @e: a #ClutterActor
|
|
|
|
*
|
|
|
|
* Evaluates to %TRUE if the %CLUTTER_ACTOR_REALIZED flag is set.
|
|
|
|
*
|
|
|
|
* Since: 0.2
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* CLUTTER_ACTOR_IS_VISIBLE:
|
|
|
|
* @e: a #ClutterActor
|
|
|
|
*
|
|
|
|
* Evaluates to %TRUE if the actor is both realized and mapped.
|
|
|
|
*
|
|
|
|
* Since: 0.2
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* CLUTTER_ACTOR_IS_REACTIVE:
|
|
|
|
* @e: a #ClutterActor
|
|
|
|
*
|
|
|
|
* Evaluates to %TRUE if the %CLUTTER_ACTOR_REACTIVE flag is set.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* CLUTTER_ACTOR_SET_FLAGS:
|
|
|
|
* @e: a #ClutterActor
|
|
|
|
* @f: the flags to set
|
|
|
|
*
|
|
|
|
* Sets flags on the given #ClutterActor
|
|
|
|
*
|
|
|
|
* Since: 0.2
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* CLUTTER_ACTOR_UNSET_FLAGS:
|
|
|
|
* @e: a #ClutterActor
|
|
|
|
* @f: the flags to unset
|
|
|
|
*
|
|
|
|
* Unsets flags on the given #ClutterActor
|
|
|
|
*
|
|
|
|
* Since: 0.2
|
|
|
|
*/
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
2006-06-13 13:17:45 +00:00
|
|
|
#include "config.h"
|
2007-10-12 08:17:00 +00:00
|
|
|
#endif
|
2006-06-13 13:17:45 +00:00
|
|
|
|
|
|
|
#include "clutter-actor.h"
|
2007-06-07 14:41:35 +00:00
|
|
|
#include "clutter-container.h"
|
2006-06-13 13:17:45 +00:00
|
|
|
#include "clutter-main.h"
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
#include "clutter-enum-types.h"
|
2007-10-25 14:36:37 +00:00
|
|
|
#include "clutter-scriptable.h"
|
|
|
|
#include "clutter-script.h"
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
#include "clutter-marshal.h"
|
2006-06-13 13:17:45 +00:00
|
|
|
#include "clutter-private.h"
|
2006-12-04 16:26:35 +00:00
|
|
|
#include "clutter-debug.h"
|
2007-05-22 09:31:40 +00:00
|
|
|
#include "clutter-units.h"
|
2007-04-27 21:13:06 +00:00
|
|
|
#include "cogl.h"
|
2006-06-13 13:17:45 +00:00
|
|
|
|
|
|
|
static guint32 __id = 0;
|
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
#define CLUTTER_ACTOR_GET_PRIVATE(obj) \
|
|
|
|
(G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_ACTOR, ClutterActorPrivate))
|
|
|
|
|
2007-12-03 16:29:18 +00:00
|
|
|
typedef struct _ShaderData ShaderData;
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
struct _ClutterActorPrivate
|
|
|
|
{
|
2007-05-22 09:31:40 +00:00
|
|
|
ClutterActorBox coords;
|
2007-05-18 07:30:06 +00:00
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
ClutterGeometry clip; /* FIXME: Should be Units */
|
2007-04-27 21:13:06 +00:00
|
|
|
guint has_clip : 1;
|
|
|
|
ClutterFixed rxang, ryang, rzang; /* Rotation*/
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
ClutterUnit rzx, rzy, rxy, rxz, ryx, ryz;
|
2007-11-29 13:47:37 +00:00
|
|
|
ClutterUnit z;
|
2007-04-27 21:13:06 +00:00
|
|
|
guint8 opacity;
|
|
|
|
ClutterActor *parent_actor;
|
|
|
|
gchar *name;
|
|
|
|
ClutterFixed scale_x, scale_y;
|
|
|
|
guint32 id; /* Unique ID */
|
2007-12-03 16:29:18 +00:00
|
|
|
|
|
|
|
ShaderData *shader_data;
|
2007-11-28 12:23:31 +00:00
|
|
|
ClutterUnit anchor_x, anchor_y;
|
2006-06-13 13:17:45 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
enum
|
|
|
|
{
|
|
|
|
PROP_0,
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
|
|
|
|
PROP_NAME,
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
PROP_X,
|
|
|
|
PROP_Y,
|
|
|
|
PROP_WIDTH,
|
|
|
|
PROP_HEIGHT,
|
2007-10-12 12:42:54 +00:00
|
|
|
PROP_DEPTH,
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
PROP_CLIP,
|
|
|
|
PROP_HAS_CLIP,
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
PROP_OPACITY,
|
2007-09-27 21:38:38 +00:00
|
|
|
PROP_VISIBLE,
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
PROP_REACTIVE,
|
|
|
|
|
2007-09-27 21:38:38 +00:00
|
|
|
PROP_SCALE_X,
|
2007-10-17 16:43:46 +00:00
|
|
|
PROP_SCALE_Y,
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
|
|
|
|
PROP_ROTATION_ANGLE_X,
|
|
|
|
PROP_ROTATION_ANGLE_Y,
|
|
|
|
PROP_ROTATION_ANGLE_Z,
|
|
|
|
PROP_ROTATION_CENTER_X,
|
|
|
|
PROP_ROTATION_CENTER_Y,
|
|
|
|
PROP_ROTATION_CENTER_Z
|
2006-06-13 13:17:45 +00:00
|
|
|
};
|
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
enum
|
|
|
|
{
|
|
|
|
SHOW,
|
|
|
|
HIDE,
|
|
|
|
DESTROY,
|
2006-11-20 12:02:24 +00:00
|
|
|
PARENT_SET,
|
2007-11-07 16:40:30 +00:00
|
|
|
FOCUS_IN,
|
|
|
|
FOCUS_OUT,
|
2007-10-09 23:45:49 +00:00
|
|
|
|
2007-08-13 20:48:01 +00:00
|
|
|
EVENT,
|
2007-11-07 16:40:30 +00:00
|
|
|
CAPTURED_EVENT,
|
2007-08-13 20:48:01 +00:00
|
|
|
BUTTON_PRESS_EVENT,
|
|
|
|
BUTTON_RELEASE_EVENT,
|
|
|
|
SCROLL_EVENT,
|
|
|
|
KEY_PRESS_EVENT,
|
|
|
|
KEY_RELEASE_EVENT,
|
|
|
|
MOTION_EVENT,
|
2007-10-09 23:45:49 +00:00
|
|
|
ENTER_EVENT,
|
|
|
|
LEAVE_EVENT,
|
2007-11-07 16:40:30 +00:00
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
LAST_SIGNAL
|
|
|
|
};
|
|
|
|
|
|
|
|
static guint actor_signals[LAST_SIGNAL] = { 0, };
|
|
|
|
|
2007-11-30 09:27:10 +00:00
|
|
|
static void clutter_scriptable_iface_init (ClutterScriptableIface *iface);
|
2007-09-27 21:38:38 +00:00
|
|
|
|
2007-11-30 09:27:10 +00:00
|
|
|
static void _clutter_actor_apply_modelview_transform (ClutterActor *self);
|
|
|
|
static void _clutter_actor_apply_modelview_transform_recursive (ClutterActor *self);
|
|
|
|
|
2007-12-03 16:29:18 +00:00
|
|
|
static void clutter_actor_shader_pre_paint (ClutterActor *actor,
|
|
|
|
gboolean repeat);
|
|
|
|
static void clutter_actor_shader_post_paint (ClutterActor *actor);
|
|
|
|
static void destroy_shader_data (ClutterActor *self);
|
|
|
|
|
2007-11-30 09:27:10 +00:00
|
|
|
G_DEFINE_ABSTRACT_TYPE_WITH_CODE (ClutterActor,
|
|
|
|
clutter_actor,
|
|
|
|
G_TYPE_INITIALLY_UNOWNED,
|
|
|
|
G_IMPLEMENT_INTERFACE (CLUTTER_TYPE_SCRIPTABLE,
|
|
|
|
clutter_scriptable_iface_init));
|
2007-09-27 21:38:38 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
static gboolean
|
|
|
|
redraw_update_idle (gpointer data)
|
|
|
|
{
|
|
|
|
ClutterMainContext *ctx = CLUTTER_CONTEXT();
|
|
|
|
|
|
|
|
if (ctx->update_idle)
|
|
|
|
{
|
|
|
|
g_source_remove (ctx->update_idle);
|
|
|
|
ctx->update_idle = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
clutter_redraw ();
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2006-12-12 20:20:04 +00:00
|
|
|
static void
|
|
|
|
clutter_actor_real_show (ClutterActor *self)
|
|
|
|
{
|
|
|
|
if (!CLUTTER_ACTOR_IS_VISIBLE (self))
|
|
|
|
{
|
|
|
|
if (!CLUTTER_ACTOR_IS_REALIZED (self))
|
|
|
|
clutter_actor_realize (self);
|
|
|
|
|
2007-11-26 12:07:25 +00:00
|
|
|
/* the mapped flag on the top-level actors is set by the
|
|
|
|
* per-backend implementation because it might be asynchronous
|
|
|
|
*/
|
|
|
|
if (!(CLUTTER_PRIVATE_FLAGS (self) & CLUTTER_ACTOR_IS_TOPLEVEL))
|
|
|
|
CLUTTER_ACTOR_SET_FLAGS (self, CLUTTER_ACTOR_MAPPED);
|
2006-12-12 20:20:04 +00:00
|
|
|
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (self))
|
|
|
|
clutter_actor_queue_redraw (self);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_show
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
2007-10-12 08:17:00 +00:00
|
|
|
* Flags a clutter actor to be displayed. An actor not shown will not
|
2006-06-13 13:17:45 +00:00
|
|
|
* appear on the display.
|
|
|
|
**/
|
|
|
|
void
|
|
|
|
clutter_actor_show (ClutterActor *self)
|
|
|
|
{
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
if (!CLUTTER_ACTOR_IS_VISIBLE (self))
|
|
|
|
{
|
|
|
|
g_object_ref (self);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-12-12 20:20:04 +00:00
|
|
|
g_signal_emit (self, actor_signals[SHOW], 0);
|
|
|
|
g_object_notify (G_OBJECT (self), "visible");
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-12-12 20:20:04 +00:00
|
|
|
g_object_unref (self);
|
|
|
|
}
|
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-12-12 20:20:04 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_show_all:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
*
|
2007-10-12 08:17:00 +00:00
|
|
|
* Call show() on all children of a actor (if any).
|
2006-12-12 20:20:04 +00:00
|
|
|
*
|
|
|
|
* Since: 0.2
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_show_all (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorClass *klass;
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-12-12 20:20:04 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-12-12 20:20:04 +00:00
|
|
|
klass = CLUTTER_ACTOR_GET_CLASS (self);
|
|
|
|
if (klass->show_all)
|
|
|
|
klass->show_all (self);
|
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-12-12 20:20:04 +00:00
|
|
|
void
|
|
|
|
clutter_actor_real_hide (ClutterActor *self)
|
|
|
|
{
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (self))
|
|
|
|
{
|
2007-11-26 12:07:25 +00:00
|
|
|
/* see comment in clutter_actor_real_show() on why we don't set
|
|
|
|
* the mapped flag on the top-level actors
|
|
|
|
*/
|
|
|
|
if (!(CLUTTER_PRIVATE_FLAGS (self) & CLUTTER_ACTOR_IS_TOPLEVEL))
|
|
|
|
CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_MAPPED);
|
|
|
|
|
2006-12-12 20:20:04 +00:00
|
|
|
clutter_actor_queue_redraw (self);
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_hide
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
2007-10-12 08:17:00 +00:00
|
|
|
* Flags a clutter actor to be hidden. An actor not shown will not
|
2006-06-13 13:17:45 +00:00
|
|
|
* appear on the display.
|
|
|
|
**/
|
|
|
|
void
|
|
|
|
clutter_actor_hide (ClutterActor *self)
|
|
|
|
{
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (self))
|
|
|
|
{
|
|
|
|
g_object_ref (self);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-08-13 20:48:01 +00:00
|
|
|
if (CLUTTER_ACTOR_IS_REACTIVE(self))
|
|
|
|
; /* FIXME: decrease global reactive count */
|
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
g_signal_emit (self, actor_signals[HIDE], 0);
|
|
|
|
g_object_notify (G_OBJECT (self), "visible");
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
g_object_unref (self);
|
2007-10-12 08:17:00 +00:00
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2006-12-12 20:20:04 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_hide_all:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
*
|
2007-08-05 13:37:49 +00:00
|
|
|
* Call hide() on all child actors (if any).
|
2006-12-12 20:20:04 +00:00
|
|
|
*
|
|
|
|
* Since: 0.2
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_hide_all (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorClass *klass;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
klass = CLUTTER_ACTOR_GET_CLASS (self);
|
|
|
|
if (klass->hide_all)
|
|
|
|
klass->hide_all (self);
|
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_realize
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Creates any underlying graphics resources needed by the actor to be
|
2007-10-12 08:17:00 +00:00
|
|
|
* displayed.
|
2006-06-13 13:17:45 +00:00
|
|
|
**/
|
|
|
|
void
|
|
|
|
clutter_actor_realize (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorClass *klass;
|
|
|
|
|
|
|
|
if (CLUTTER_ACTOR_IS_REALIZED (self))
|
|
|
|
return;
|
|
|
|
|
|
|
|
CLUTTER_ACTOR_SET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
|
|
|
|
|
|
|
|
klass = CLUTTER_ACTOR_GET_CLASS (self);
|
|
|
|
|
|
|
|
if (klass->realize)
|
|
|
|
(klass->realize) (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-06-22 13:05:45 +00:00
|
|
|
* clutter_actor_unrealize
|
2006-06-13 13:17:45 +00:00
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Frees up any underlying graphics resources needed by the actor to be
|
2007-10-12 08:17:00 +00:00
|
|
|
* displayed.
|
2006-06-13 13:17:45 +00:00
|
|
|
**/
|
|
|
|
void
|
|
|
|
clutter_actor_unrealize (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorClass *klass;
|
|
|
|
|
|
|
|
if (!CLUTTER_ACTOR_IS_REALIZED (self))
|
|
|
|
return;
|
|
|
|
|
|
|
|
CLUTTER_ACTOR_UNSET_FLAGS (self, CLUTTER_ACTOR_REALIZED);
|
|
|
|
|
|
|
|
klass = CLUTTER_ACTOR_GET_CLASS (self);
|
|
|
|
|
|
|
|
if (klass->unrealize)
|
|
|
|
(klass->unrealize) (self);
|
|
|
|
}
|
|
|
|
|
2007-11-18 23:24:55 +00:00
|
|
|
static void
|
|
|
|
clutter_actor_real_pick (ClutterActor *self,
|
|
|
|
const ClutterColor *color)
|
|
|
|
{
|
|
|
|
if (clutter_actor_should_pick_paint (self))
|
|
|
|
{
|
|
|
|
cogl_color (color);
|
|
|
|
cogl_rectangle (0,
|
|
|
|
0,
|
|
|
|
clutter_actor_get_width(self),
|
|
|
|
clutter_actor_get_height(self));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-28 18:49:34 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_pick:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @color: A #ClutterColor
|
|
|
|
*
|
2007-11-18 23:24:55 +00:00
|
|
|
* Renders a silhouette of the actor in supplied color. Used internally for
|
|
|
|
* mapping pointer events to actors.
|
2007-05-28 18:49:34 +00:00
|
|
|
*
|
2007-10-12 08:17:00 +00:00
|
|
|
* This function should not never be called directly by applications.
|
2007-11-28 12:23:31 +00:00
|
|
|
*
|
2007-11-18 23:24:55 +00:00
|
|
|
* Subclasses overiding this method should call
|
2007-12-17 17:45:49 +00:00
|
|
|
* clutter_actor_should_pick_paint() to decide if to render there
|
2007-11-18 23:24:55 +00:00
|
|
|
* silhouette but in any case should still recursively call pick for
|
|
|
|
* any children.
|
|
|
|
*
|
|
|
|
* Since 0.4
|
2007-05-28 18:49:34 +00:00
|
|
|
**/
|
2007-10-12 08:17:00 +00:00
|
|
|
void
|
|
|
|
clutter_actor_pick (ClutterActor *self,
|
2007-05-28 18:49:34 +00:00
|
|
|
const ClutterColor *color)
|
|
|
|
{
|
2007-11-18 23:24:55 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
g_return_if_fail (color != NULL);
|
2007-05-28 18:49:34 +00:00
|
|
|
|
2007-11-18 23:24:55 +00:00
|
|
|
CLUTTER_ACTOR_GET_CLASS (self)->pick(self, color);
|
|
|
|
}
|
2007-05-28 18:49:34 +00:00
|
|
|
|
2007-11-18 23:24:55 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_should_pick_paint:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Utility call for subclasses overiding the pick method.
|
|
|
|
*
|
|
|
|
* This function should not never be called directly by applications.
|
|
|
|
*
|
2007-12-17 17:45:49 +00:00
|
|
|
* Return value: %TRUE if the actor should paint its silhouette,
|
|
|
|
* %FALSE otherwise
|
2007-11-18 23:24:55 +00:00
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_actor_should_pick_paint (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterMainContext *context;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
|
|
|
|
|
|
|
|
context = clutter_context_get_default ();
|
|
|
|
|
2007-12-17 17:45:49 +00:00
|
|
|
if (CLUTTER_ACTOR_IS_MAPPED (self) &&
|
|
|
|
(G_UNLIKELY (context->pick_mode == CLUTTER_PICK_ALL) ||
|
|
|
|
CLUTTER_ACTOR_IS_REACTIVE (self)))
|
2007-11-18 23:24:55 +00:00
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
return FALSE;
|
2007-05-28 18:49:34 +00:00
|
|
|
}
|
|
|
|
|
2007-05-31 09:29:12 +00:00
|
|
|
/*
|
|
|
|
* Utility functions for manipulating transformation matrix
|
|
|
|
*
|
|
|
|
* Matrix: 4x4 of ClutterFixed
|
|
|
|
*/
|
2007-12-15 14:36:27 +00:00
|
|
|
#define M(m,row,col) (m)[(col) * 4 + (row)]
|
2007-05-31 09:29:12 +00:00
|
|
|
|
|
|
|
/* Transform point (x,y,z) by matrix */
|
|
|
|
static void
|
2007-06-12 11:42:29 +00:00
|
|
|
mtx_transform (ClutterFixed m[16],
|
|
|
|
ClutterFixed *x, ClutterFixed *y, ClutterFixed *z,
|
|
|
|
ClutterFixed *w)
|
2007-05-31 09:29:12 +00:00
|
|
|
{
|
2007-06-12 11:42:29 +00:00
|
|
|
ClutterFixed _x, _y, _z, _w;
|
2007-05-31 09:29:12 +00:00
|
|
|
_x = *x;
|
|
|
|
_y = *y;
|
|
|
|
_z = *z;
|
2007-06-12 11:42:29 +00:00
|
|
|
_w = *w;
|
2007-05-31 09:29:12 +00:00
|
|
|
|
2007-06-15 09:53:07 +00:00
|
|
|
/* We care lot about precission here, so have to use QMUL */
|
2007-06-12 11:42:29 +00:00
|
|
|
*x = CFX_QMUL (M (m,0,0), _x) + CFX_QMUL (M (m,0,1), _y) +
|
|
|
|
CFX_QMUL (M (m,0,2), _z) + CFX_QMUL (M (m,0,3), _w);
|
2007-05-31 09:29:12 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
*y = CFX_QMUL (M (m,1,0), _x) + CFX_QMUL (M (m,1,1), _y) +
|
|
|
|
CFX_QMUL (M (m,1,2), _z) + CFX_QMUL (M (m,1,3), _w);
|
2007-05-31 09:29:12 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
*z = CFX_QMUL (M (m,2,0), _x) + CFX_QMUL (M (m,2,1), _y) +
|
|
|
|
CFX_QMUL (M (m,2,2), _z) + CFX_QMUL (M (m,2,3), _w);
|
2007-05-31 09:29:12 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
*w = CFX_QMUL (M (m,3,0), _x) + CFX_QMUL (M (m,3,1), _y) +
|
|
|
|
CFX_QMUL (M (m,3,2), _z) + CFX_QMUL (M (m,3,3), _w);
|
2007-06-01 11:43:53 +00:00
|
|
|
|
2007-06-15 09:53:07 +00:00
|
|
|
/* Specially for Matthew: was going to put a comment here, but could not
|
|
|
|
* think of anything at all to say ;)
|
|
|
|
*/
|
2007-05-31 17:11:09 +00:00
|
|
|
}
|
|
|
|
|
2007-12-15 14:36:27 +00:00
|
|
|
#undef M
|
|
|
|
|
2007-06-15 09:53:07 +00:00
|
|
|
/* Applies the transforms associated with this actor and its ancestors,
|
|
|
|
* retrieves the resulting OpenGL modelview matrix, and uses the matrix
|
|
|
|
* to transform the supplied point
|
|
|
|
*/
|
2007-06-01 16:20:57 +00:00
|
|
|
static void
|
2007-10-12 08:17:00 +00:00
|
|
|
clutter_actor_transform_point (ClutterActor *actor,
|
2007-06-12 11:42:29 +00:00
|
|
|
ClutterUnit *x,
|
|
|
|
ClutterUnit *y,
|
|
|
|
ClutterUnit *z,
|
|
|
|
ClutterUnit *w)
|
2007-06-01 16:20:57 +00:00
|
|
|
{
|
2007-06-12 11:42:29 +00:00
|
|
|
ClutterFixed mtx[16];
|
|
|
|
ClutterActorPrivate *priv;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
|
2007-06-01 16:20:57 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
priv = actor->priv;
|
2007-06-01 16:20:57 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
cogl_push_matrix();
|
|
|
|
_clutter_actor_apply_modelview_transform_recursive (actor);
|
|
|
|
|
|
|
|
cogl_get_modelview_matrix (mtx);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
mtx_transform (mtx, x, y, z, w);
|
|
|
|
|
|
|
|
cogl_pop_matrix();
|
2007-06-01 16:20:57 +00:00
|
|
|
}
|
|
|
|
|
2007-07-01 16:44:24 +00:00
|
|
|
/* Help macros to scale from OpenGL <-1,1> coordinates system to our
|
2007-06-15 09:53:07 +00:00
|
|
|
* X-window based <0,window-size> coordinates
|
|
|
|
*/
|
2007-12-17 17:45:49 +00:00
|
|
|
#define MTX_GL_SCALE_X(x,w,v1,v2) (CFX_MUL (((CFX_DIV ((x), (w)) + CFX_ONE) >> 1), (v1)) + (v2))
|
|
|
|
#define MTX_GL_SCALE_Y(y,w,v1,v2) ((v1) - CFX_MUL (((CFX_DIV ((y), (w)) + CFX_ONE) >> 1), (v1)) + (v2))
|
|
|
|
#define MTX_GL_SCALE_Z(z,w,v1,v2) (MTX_GL_SCALE_X ((z), (w), (v1), (v2)))
|
2007-06-12 11:42:29 +00:00
|
|
|
|
2007-05-31 17:11:09 +00:00
|
|
|
/**
|
2007-06-27 15:10:52 +00:00
|
|
|
* clutter_actor_apply_transform_to_point:
|
2007-05-31 17:11:09 +00:00
|
|
|
* @self: A #ClutterActor
|
2007-07-02 09:21:58 +00:00
|
|
|
* @point: A point as #ClutterVertex
|
|
|
|
* @vertex: The translated #ClutterVertex
|
2007-05-31 17:11:09 +00:00
|
|
|
*
|
2007-07-02 09:21:58 +00:00
|
|
|
* Transforms point in coordinates relative to the actor
|
2007-10-12 08:17:00 +00:00
|
|
|
* into screen coordiances with the current actor tranform
|
2007-09-27 21:38:38 +00:00
|
|
|
* (i.e. scale, rotation etc)
|
2007-05-31 17:11:09 +00:00
|
|
|
*
|
|
|
|
* Since: 0.4
|
|
|
|
**/
|
|
|
|
void
|
2007-07-02 09:21:58 +00:00
|
|
|
clutter_actor_apply_transform_to_point (ClutterActor *self,
|
|
|
|
ClutterVertex *point,
|
|
|
|
ClutterVertex *vertex)
|
2007-06-12 11:42:29 +00:00
|
|
|
{
|
|
|
|
ClutterFixed mtx_p[16];
|
|
|
|
ClutterFixed v[4];
|
|
|
|
ClutterFixed w = CFX_ONE;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-05-31 17:11:09 +00:00
|
|
|
|
2007-06-15 09:53:07 +00:00
|
|
|
/* First we tranform the point using the OpenGL modelview matrix */
|
2007-07-02 09:21:58 +00:00
|
|
|
clutter_actor_transform_point (self, &point->x, &point->y, &point->z, &w);
|
2007-05-31 18:22:41 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
cogl_get_projection_matrix (mtx_p);
|
|
|
|
cogl_get_viewport (v);
|
2007-06-15 09:53:07 +00:00
|
|
|
|
|
|
|
/* Now, transform it again with the projection matrix */
|
2007-07-02 09:21:58 +00:00
|
|
|
mtx_transform (mtx_p, &point->x, &point->y, &point->z, &w);
|
2007-05-31 17:11:09 +00:00
|
|
|
|
2007-06-15 09:53:07 +00:00
|
|
|
/* Finaly translate from OpenGL coords to window coords */
|
2007-12-17 17:45:49 +00:00
|
|
|
vertex->x = MTX_GL_SCALE_X (point->x, w, v[2], v[0]);
|
|
|
|
vertex->y = MTX_GL_SCALE_Y (point->y, w, v[3], v[1]);
|
|
|
|
vertex->z = MTX_GL_SCALE_Z (point->z, w, v[2], v[0]);
|
2007-05-31 17:11:09 +00:00
|
|
|
}
|
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
/* Recursively tranform supplied vertices with the tranform for the current
|
2007-06-15 09:53:07 +00:00
|
|
|
* actor and all its ancestors (like clutter_actor_transform_point() but
|
|
|
|
* for all the vertices in one go).
|
2007-06-12 11:42:29 +00:00
|
|
|
*/
|
|
|
|
static void
|
|
|
|
clutter_actor_transform_vertices (ClutterActor * self,
|
|
|
|
ClutterVertex verts[4],
|
|
|
|
ClutterFixed w[4])
|
2007-05-31 17:11:09 +00:00
|
|
|
{
|
|
|
|
ClutterFixed mtx[16];
|
2007-06-12 11:42:29 +00:00
|
|
|
ClutterFixed _x, _y, _z, _w;
|
2007-05-31 17:11:09 +00:00
|
|
|
ClutterActorPrivate *priv;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-05-31 17:11:09 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
priv = self->priv;
|
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
cogl_push_matrix();
|
|
|
|
_clutter_actor_apply_modelview_transform_recursive (self);
|
2007-06-01 16:20:57 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
cogl_get_modelview_matrix (mtx);
|
2007-05-31 09:29:12 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
_x = 0;
|
|
|
|
_y = 0;
|
|
|
|
_z = 0;
|
|
|
|
_w = CFX_ONE;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
mtx_transform (mtx, &_x, &_y, &_z, &_w);
|
2007-05-31 09:29:12 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
verts[0].x = _x;
|
|
|
|
verts[0].y = _y;
|
|
|
|
verts[0].z = _z;
|
|
|
|
w[0] = _w;
|
2007-05-31 09:29:12 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
_x = priv->coords.x2 - priv->coords.x1;
|
|
|
|
_y = 0;
|
|
|
|
_z = 0;
|
|
|
|
_w = CFX_ONE;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
mtx_transform (mtx, &_x, &_y, &_z, &_w);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
verts[1].x = _x;
|
|
|
|
verts[1].y = _y;
|
|
|
|
verts[1].z = _z;
|
|
|
|
w[1] = _w;
|
|
|
|
|
|
|
|
_x = 0;
|
|
|
|
_y = priv->coords.y2 - priv->coords.y1;
|
|
|
|
_z = 0;
|
|
|
|
_w = CFX_ONE;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
mtx_transform (mtx, &_x, &_y, &_z, &_w);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
verts[2].x = _x;
|
|
|
|
verts[2].y = _y;
|
|
|
|
verts[2].z = _z;
|
|
|
|
w[2] = _w;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
_x = priv->coords.x2 - priv->coords.x1;
|
|
|
|
_y = priv->coords.y2 - priv->coords.y1;
|
|
|
|
_z = 0;
|
|
|
|
_w = CFX_ONE;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
mtx_transform (mtx, &_x, &_y, &_z, &_w);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
verts[3].x = _x;
|
|
|
|
verts[3].y = _y;
|
|
|
|
verts[3].z = _z;
|
|
|
|
w[3] = _w;
|
2007-05-31 09:29:12 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
cogl_pop_matrix();
|
2007-05-31 09:29:12 +00:00
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
2007-06-27 15:10:52 +00:00
|
|
|
* clutter_actor_get_vertices:
|
2006-06-13 13:17:45 +00:00
|
|
|
* @self: A #ClutterActor
|
2007-06-12 11:42:29 +00:00
|
|
|
* @verts: Pointer to a location of an array of 4 #ClutterVertex where to
|
|
|
|
* store the result.
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2007-11-21 23:25:30 +00:00
|
|
|
* Calculates the tranformed screen coordinates of the four corners of
|
2007-11-21 23:25:56 +00:00
|
|
|
* the actor; the returned vertices relate to the ClutterActorBox
|
2007-11-21 23:25:30 +00:00
|
|
|
* coordinates as follows:
|
2007-06-27 15:10:42 +00:00
|
|
|
*
|
2007-08-15 19:50:31 +00:00
|
|
|
* v[0] contains (x1, y1)
|
|
|
|
* v[1] contains (x2, y1)
|
|
|
|
* v[2] contains (x1, y2)
|
|
|
|
* v[3] contains (x2, y2)
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2007-06-12 11:42:29 +00:00
|
|
|
* Since: 0.4
|
2006-06-13 13:17:45 +00:00
|
|
|
**/
|
|
|
|
void
|
2007-07-01 16:44:24 +00:00
|
|
|
clutter_actor_get_vertices (ClutterActor *self,
|
|
|
|
ClutterVertex verts[4])
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2007-06-12 11:42:29 +00:00
|
|
|
ClutterFixed mtx_p[16];
|
|
|
|
ClutterFixed v[4];
|
|
|
|
ClutterFixed w[4];
|
|
|
|
ClutterActorPrivate *priv;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-06-12 11:42:29 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
priv = self->priv;
|
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
clutter_actor_transform_vertices (self, verts, w);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
cogl_get_projection_matrix (mtx_p);
|
|
|
|
cogl_get_viewport (v);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
mtx_transform (mtx_p,
|
|
|
|
&verts[0].x,
|
|
|
|
&verts[0].y,
|
|
|
|
&verts[0].z,
|
|
|
|
&w[0]);
|
|
|
|
|
2007-06-15 09:53:07 +00:00
|
|
|
verts[0].x = MTX_GL_SCALE_X (verts[0].x, w[0], v[2], v[0]);
|
2007-06-13 11:20:10 +00:00
|
|
|
verts[0].y = MTX_GL_SCALE_Y (verts[0].y, w[0], v[3], v[1]);
|
2007-06-15 09:53:07 +00:00
|
|
|
verts[0].z = MTX_GL_SCALE_Z (verts[0].z, w[0], v[2], v[0]);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
mtx_transform (mtx_p,
|
|
|
|
&verts[1].x,
|
|
|
|
&verts[1].y,
|
|
|
|
&verts[1].z,
|
|
|
|
&w[1]);
|
|
|
|
|
2007-06-15 09:53:07 +00:00
|
|
|
verts[1].x = MTX_GL_SCALE_X (verts[1].x, w[1], v[2], v[0]);
|
2007-06-13 11:20:10 +00:00
|
|
|
verts[1].y = MTX_GL_SCALE_Y (verts[1].y, w[1], v[3], v[1]);
|
2007-06-15 09:53:07 +00:00
|
|
|
verts[1].z = MTX_GL_SCALE_Z (verts[1].z, w[1], v[2], v[0]);
|
2007-06-12 11:42:29 +00:00
|
|
|
|
|
|
|
mtx_transform (mtx_p,
|
|
|
|
&verts[2].x,
|
|
|
|
&verts[2].y,
|
|
|
|
&verts[2].z,
|
|
|
|
&w[2]);
|
|
|
|
|
2007-06-15 09:53:07 +00:00
|
|
|
verts[2].x = MTX_GL_SCALE_X (verts[2].x, w[2], v[2], v[0]);
|
2007-06-13 11:20:10 +00:00
|
|
|
verts[2].y = MTX_GL_SCALE_Y (verts[2].y, w[2], v[3], v[1]);
|
2007-06-15 09:53:07 +00:00
|
|
|
verts[2].z = MTX_GL_SCALE_Z (verts[2].z, w[2], v[2], v[0]);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
mtx_transform (mtx_p,
|
|
|
|
&verts[3].x,
|
|
|
|
&verts[3].y,
|
|
|
|
&verts[3].z,
|
|
|
|
&w[3]);
|
|
|
|
|
2007-06-15 09:53:07 +00:00
|
|
|
verts[3].x = MTX_GL_SCALE_X (verts[3].x, w[3], v[2], v[0]);
|
2007-06-13 11:20:10 +00:00
|
|
|
verts[3].y = MTX_GL_SCALE_Y (verts[3].y, w[3], v[3], v[1]);
|
2007-06-15 09:53:07 +00:00
|
|
|
verts[3].z = MTX_GL_SCALE_Z (verts[3].z, w[3], v[2], v[0]);
|
2007-06-12 11:42:29 +00:00
|
|
|
}
|
|
|
|
|
2007-06-15 09:53:07 +00:00
|
|
|
/* Applies the transforms associated with this actor to the
|
|
|
|
* OpenGL modelview matrix.
|
|
|
|
*
|
|
|
|
* This function does not push/pop matrix; it is the responsibility
|
|
|
|
* of the caller to do so as appropriate
|
|
|
|
*/
|
2007-09-27 21:38:38 +00:00
|
|
|
static void
|
2007-06-12 11:42:29 +00:00
|
|
|
_clutter_actor_apply_modelview_transform (ClutterActor * self)
|
|
|
|
{
|
|
|
|
ClutterActorPrivate *priv = self->priv;
|
2007-11-28 12:23:31 +00:00
|
|
|
ClutterActor *parent;
|
|
|
|
|
|
|
|
parent = clutter_actor_get_parent (self);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-11-28 12:23:31 +00:00
|
|
|
if (parent != NULL)
|
2006-09-20 18:38:08 +00:00
|
|
|
{
|
2007-11-29 13:47:37 +00:00
|
|
|
cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->coords.x1),
|
|
|
|
CLUTTER_UNITS_TO_FIXED (priv->coords.y1),
|
|
|
|
0);
|
2006-09-20 18:38:08 +00:00
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-06-27 11:34:43 +00:00
|
|
|
/*
|
|
|
|
* because the rotation involves translations, we must scale before
|
|
|
|
* applying the rotations (if we apply the scale after the rotations,
|
|
|
|
* the translations included in the rotation are not scaled and so the
|
|
|
|
* entire object will move on the screen as a result of rotating it).
|
|
|
|
*/
|
|
|
|
if (priv->scale_x != CFX_ONE ||
|
|
|
|
priv->scale_y != CFX_ONE)
|
|
|
|
{
|
|
|
|
cogl_scale (priv->scale_x, priv->scale_y);
|
|
|
|
}
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-27 11:34:43 +00:00
|
|
|
if (priv->rzang)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2007-11-29 13:47:37 +00:00
|
|
|
cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->rzx),
|
|
|
|
CLUTTER_UNITS_TO_FIXED (priv->rzy),
|
|
|
|
0);
|
|
|
|
|
2007-04-27 21:13:06 +00:00
|
|
|
cogl_rotatex (priv->rzang, 0, 0, CFX_ONE);
|
2007-11-29 13:47:37 +00:00
|
|
|
|
|
|
|
cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->rzx),
|
|
|
|
CLUTTER_UNITS_TO_FIXED (-priv->rzy),
|
|
|
|
0);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
if (priv->ryang)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2007-11-29 13:47:37 +00:00
|
|
|
cogl_translatex (CLUTTER_UNITS_TO_FIXED (priv->ryx),
|
|
|
|
0,
|
|
|
|
CLUTTER_UNITS_TO_FIXED (priv->z + priv->ryz));
|
|
|
|
|
2007-04-27 21:13:06 +00:00
|
|
|
cogl_rotatex (priv->ryang, 0, CFX_ONE, 0);
|
2007-11-29 13:47:37 +00:00
|
|
|
|
|
|
|
cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->ryx),
|
|
|
|
0,
|
|
|
|
CLUTTER_UNITS_TO_FIXED (-(priv->z + priv->ryz)));
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
if (priv->rxang)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2007-11-29 13:47:37 +00:00
|
|
|
cogl_translatex (0,
|
|
|
|
CLUTTER_UNITS_TO_FIXED (priv->rxy),
|
|
|
|
CLUTTER_UNITS_TO_FIXED (priv->z + priv->rxz));
|
|
|
|
|
2007-06-15 23:15:34 +00:00
|
|
|
cogl_rotatex (priv->rxang, CFX_ONE, 0, 0);
|
2007-11-29 13:47:37 +00:00
|
|
|
|
|
|
|
cogl_translatex (0,
|
|
|
|
CLUTTER_UNITS_TO_FIXED (-priv->rxy),
|
|
|
|
CLUTTER_UNITS_TO_FIXED (-(priv->z + priv->rxz)));
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2007-12-10 08:15:10 +00:00
|
|
|
if (parent && (priv->anchor_x || priv->anchor_y))
|
|
|
|
{
|
|
|
|
cogl_translatex (CLUTTER_UNITS_TO_FIXED (-priv->anchor_x),
|
|
|
|
CLUTTER_UNITS_TO_FIXED (-priv->anchor_y),
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
if (priv->z)
|
2007-11-29 13:47:37 +00:00
|
|
|
cogl_translatex (0, 0, priv->z);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
if (priv->has_clip)
|
2007-05-28 18:49:34 +00:00
|
|
|
cogl_clip_set (&(priv->clip));
|
2007-06-12 11:42:29 +00:00
|
|
|
}
|
|
|
|
|
2007-06-15 09:53:07 +00:00
|
|
|
/* Recursively applies the transforms associated with this actor and
|
|
|
|
* its ancestors to the OpenGL modelview matrix.
|
|
|
|
*
|
|
|
|
* This function does not push/pop matrix; it is the responsibility
|
|
|
|
* of the caller to do so as appropriate
|
|
|
|
*/
|
2007-09-27 21:38:38 +00:00
|
|
|
static void
|
2007-06-12 11:42:29 +00:00
|
|
|
_clutter_actor_apply_modelview_transform_recursive (ClutterActor * self)
|
|
|
|
{
|
|
|
|
ClutterActor * parent;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
parent = clutter_actor_get_parent (self);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
if (parent)
|
|
|
|
_clutter_actor_apply_modelview_transform_recursive (parent);
|
2007-07-30 07:27:14 +00:00
|
|
|
|
|
|
|
_clutter_actor_apply_modelview_transform (self);
|
2007-06-12 11:42:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_paint:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Renders the actor to display.
|
|
|
|
*
|
2007-10-12 08:17:00 +00:00
|
|
|
* This function should not be called directly by applications instead
|
|
|
|
* #clutter_actor_queue_redraw should be used to queue paints.
|
2007-06-12 11:42:29 +00:00
|
|
|
**/
|
|
|
|
void
|
|
|
|
clutter_actor_paint (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
ClutterActorClass *klass;
|
|
|
|
ClutterMainContext *context;
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
priv = self->priv;
|
|
|
|
|
|
|
|
if (!CLUTTER_ACTOR_IS_REALIZED (self))
|
|
|
|
{
|
|
|
|
CLUTTER_NOTE (PAINT, "Attempting realize via paint()");
|
|
|
|
clutter_actor_realize(self);
|
|
|
|
|
|
|
|
if (!CLUTTER_ACTOR_IS_REALIZED (self))
|
|
|
|
{
|
|
|
|
CLUTTER_NOTE (PAINT, "Attempt failed, aborting paint");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
context = clutter_context_get_default ();
|
|
|
|
klass = CLUTTER_ACTOR_GET_CLASS (self);
|
|
|
|
|
|
|
|
cogl_push_matrix();
|
|
|
|
|
|
|
|
_clutter_actor_apply_modelview_transform (self);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-08-13 20:48:01 +00:00
|
|
|
if (G_UNLIKELY(context->pick_mode != CLUTTER_PICK_NONE))
|
2007-05-28 18:49:34 +00:00
|
|
|
{
|
2007-07-12 10:15:19 +00:00
|
|
|
gint r, g, b;
|
2007-05-28 18:49:34 +00:00
|
|
|
ClutterColor col;
|
|
|
|
guint32 id;
|
2007-01-04 19:56:01 +00:00
|
|
|
|
2007-11-18 23:24:55 +00:00
|
|
|
id = clutter_actor_get_gid (self);
|
|
|
|
|
|
|
|
cogl_get_bitmasks (&r, &g, &b, NULL);
|
|
|
|
|
|
|
|
/* Encode the actor id into a color, taking into account bpp */
|
|
|
|
col.red = ((id >> (g+b)) & (0xff>>(8-r)))<<(8-r);
|
|
|
|
col.green = ((id >> b) & (0xff>>(8-g))) << (8-g);
|
|
|
|
col.blue = (id & (0xff>>(8-b)))<<(8-b);
|
|
|
|
col.alpha = 0xff;
|
2007-11-28 12:23:31 +00:00
|
|
|
|
2007-11-18 23:24:55 +00:00
|
|
|
/* Actor will then paint silhouette of itself in supplied
|
|
|
|
* color. See clutter_stage_get_actor_at_pos() for where
|
|
|
|
* picking is enabled.
|
|
|
|
*/
|
|
|
|
clutter_actor_pick (self, &col);
|
2007-05-28 18:49:34 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2007-12-03 16:29:18 +00:00
|
|
|
clutter_actor_shader_pre_paint (self, FALSE);
|
2007-12-11 14:49:41 +00:00
|
|
|
|
|
|
|
if (G_LIKELY (klass->paint))
|
|
|
|
klass->paint (self);
|
|
|
|
|
2007-12-03 16:29:18 +00:00
|
|
|
clutter_actor_shader_post_paint (self);
|
2006-08-13 23:55:52 +00:00
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-03-22 18:21:59 +00:00
|
|
|
if (priv->has_clip)
|
2007-05-28 18:49:34 +00:00
|
|
|
cogl_clip_unset();
|
2006-08-13 23:55:52 +00:00
|
|
|
|
2007-04-27 21:13:06 +00:00
|
|
|
cogl_pop_matrix();
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2007-11-23 17:12:27 +00:00
|
|
|
static void
|
|
|
|
clutter_actor_real_request_coords (ClutterActor *self,
|
|
|
|
ClutterActorBox *box)
|
|
|
|
{
|
|
|
|
self->priv->coords = *box;
|
|
|
|
}
|
|
|
|
|
2007-05-22 09:31:40 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_request_coords:
|
|
|
|
* @self: A #ClutterActor
|
2007-11-23 17:12:27 +00:00
|
|
|
* @box: A #ClutterActorBox with the new coordinates, in ClutterUnits
|
2007-05-22 09:31:40 +00:00
|
|
|
*
|
2007-11-23 17:12:27 +00:00
|
|
|
* Requests new untransformed coordinates for the bounding box of
|
|
|
|
* a #ClutterActor. The coordinates must be relative to the current
|
|
|
|
* parent of the actor.
|
2007-05-22 09:31:40 +00:00
|
|
|
*
|
2007-11-23 17:12:27 +00:00
|
|
|
* This function should not be called directly by applications;
|
|
|
|
* instead, the various position/geometry methods should be used.
|
|
|
|
*
|
|
|
|
* Note: Actors overriding the ClutterActor::request_coords() virtual
|
|
|
|
* function should always chain up to the parent class request_coords()
|
|
|
|
* method. Actors should override this function only if they need to
|
|
|
|
* recompute some internal state or need to reposition their evental
|
|
|
|
* children.
|
|
|
|
*/
|
2006-06-13 13:17:45 +00:00
|
|
|
void
|
2007-05-22 09:31:40 +00:00
|
|
|
clutter_actor_request_coords (ClutterActor *self,
|
|
|
|
ClutterActorBox *box)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2007-11-23 17:12:27 +00:00
|
|
|
ClutterActorPrivate *priv;
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
gboolean x_change, y_change, width_change, height_change;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-11-15 17:35:47 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
g_return_if_fail (box != NULL);
|
|
|
|
|
2007-11-23 17:12:27 +00:00
|
|
|
priv = self->priv;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-11-23 17:12:27 +00:00
|
|
|
/* avoid calling request coords if the coordinates did not change */
|
|
|
|
x_change = (priv->coords.x1 != box->x1);
|
|
|
|
y_change = (priv->coords.y1 != box->y1);
|
|
|
|
width_change = ((priv->coords.x2 - priv->coords.x1) != (box->x2 - box->x1));
|
|
|
|
height_change = ((priv->coords.y2 - priv->coords.y1) != (box->y2 - box->y1));
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-08-29 19:09:43 +00:00
|
|
|
if (x_change || y_change || width_change || height_change)
|
|
|
|
{
|
2007-11-23 17:12:27 +00:00
|
|
|
g_object_ref (self);
|
|
|
|
g_object_freeze_notify (G_OBJECT (self));
|
|
|
|
|
|
|
|
CLUTTER_ACTOR_GET_CLASS (self)->request_coords (self, box);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-08-29 19:09:43 +00:00
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (self))
|
|
|
|
clutter_actor_queue_redraw (self);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-08-29 19:09:43 +00:00
|
|
|
if (x_change)
|
|
|
|
g_object_notify (G_OBJECT (self), "x");
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-08-29 19:09:43 +00:00
|
|
|
if (y_change)
|
|
|
|
g_object_notify (G_OBJECT (self), "y");
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-08-29 19:09:43 +00:00
|
|
|
if (width_change)
|
|
|
|
g_object_notify (G_OBJECT (self), "width");
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-08-29 19:09:43 +00:00
|
|
|
if (height_change)
|
|
|
|
g_object_notify (G_OBJECT (self), "height");
|
2007-04-19 15:24:04 +00:00
|
|
|
|
|
|
|
g_object_thaw_notify (G_OBJECT (self));
|
|
|
|
g_object_unref (self);
|
2006-08-29 19:09:43 +00:00
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-06-13 23:24:59 +00:00
|
|
|
* clutter_actor_query_coords:
|
2006-06-13 13:17:45 +00:00
|
|
|
* @self: A #ClutterActor
|
2007-05-22 09:31:40 +00:00
|
|
|
* @box: A location to store the actors #ClutterActorBox co-ordinates
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Requests the untransformed co-ordinates (in ClutterUnits) for the
|
|
|
|
* #ClutterActor relative to any parent.
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2007-10-12 08:17:00 +00:00
|
|
|
* This function should not be called directly by applications instead
|
2006-06-13 13:17:45 +00:00
|
|
|
* the various position/geometry methods should be used.
|
|
|
|
**/
|
|
|
|
void
|
2007-06-13 23:24:59 +00:00
|
|
|
clutter_actor_query_coords (ClutterActor *self,
|
|
|
|
ClutterActorBox *box)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
|
|
|
ClutterActorClass *klass;
|
|
|
|
|
2007-11-15 17:35:47 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
g_return_if_fail (box != NULL);
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
klass = CLUTTER_ACTOR_GET_CLASS (self);
|
|
|
|
|
2007-05-22 09:31:40 +00:00
|
|
|
box->x1 = self->priv->coords.x1;
|
|
|
|
box->y1 = self->priv->coords.y1;
|
|
|
|
box->x2 = self->priv->coords.x2;
|
|
|
|
box->y2 = self->priv->coords.y2;
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-06-13 23:24:59 +00:00
|
|
|
if (klass->query_coords)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2007-10-12 08:17:00 +00:00
|
|
|
/* FIXME: This is kind of a cludge - we pass out *private*
|
2006-06-13 13:17:45 +00:00
|
|
|
* co-ords down to any subclasses so they can modify
|
|
|
|
* we then resync any changes. Needed for group class.
|
|
|
|
* Need to figure out nicer way.
|
|
|
|
*/
|
2007-06-13 23:24:59 +00:00
|
|
|
klass->query_coords(self, box);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-05-22 09:31:40 +00:00
|
|
|
self->priv->coords.x1 = box->x1;
|
2007-10-12 08:17:00 +00:00
|
|
|
self->priv->coords.y1 = box->y1;
|
|
|
|
self->priv->coords.x2 = box->x2;
|
|
|
|
self->priv->coords.y2 = box->y2;
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
static void
|
|
|
|
clutter_actor_set_property (GObject *object,
|
2007-06-14 15:29:52 +00:00
|
|
|
guint prop_id,
|
2007-10-12 08:17:00 +00:00
|
|
|
const GValue *value,
|
2007-06-14 15:29:52 +00:00
|
|
|
GParamSpec *pspec)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
ClutterActor *actor;
|
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
|
|
|
|
actor = CLUTTER_ACTOR(object);
|
|
|
|
priv = actor->priv;
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
switch (prop_id)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
|
|
|
case PROP_X:
|
2007-11-15 17:35:47 +00:00
|
|
|
clutter_actor_set_x (actor, g_value_get_int (value));
|
2006-06-13 13:17:45 +00:00
|
|
|
break;
|
|
|
|
case PROP_Y:
|
2007-11-15 17:35:47 +00:00
|
|
|
clutter_actor_set_y (actor, g_value_get_int (value));
|
2006-06-13 13:17:45 +00:00
|
|
|
break;
|
|
|
|
case PROP_WIDTH:
|
2007-11-15 17:35:47 +00:00
|
|
|
clutter_actor_set_width (actor, g_value_get_int (value));
|
2006-06-13 13:17:45 +00:00
|
|
|
break;
|
|
|
|
case PROP_HEIGHT:
|
2007-11-15 17:35:47 +00:00
|
|
|
clutter_actor_set_height (actor, g_value_get_int (value));
|
2006-06-13 13:17:45 +00:00
|
|
|
break;
|
2007-10-12 12:42:54 +00:00
|
|
|
case PROP_DEPTH:
|
|
|
|
clutter_actor_set_depth (actor, g_value_get_int (value));
|
|
|
|
break;
|
2006-06-13 13:17:45 +00:00
|
|
|
case PROP_OPACITY:
|
|
|
|
clutter_actor_set_opacity (actor, g_value_get_uchar (value));
|
|
|
|
break;
|
|
|
|
case PROP_NAME:
|
|
|
|
clutter_actor_set_name (actor, g_value_get_string (value));
|
|
|
|
break;
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
case PROP_VISIBLE:
|
|
|
|
if (g_value_get_boolean (value) == TRUE)
|
|
|
|
clutter_actor_show (actor);
|
|
|
|
else
|
|
|
|
clutter_actor_hide (actor);
|
|
|
|
break;
|
2007-09-27 21:38:38 +00:00
|
|
|
case PROP_SCALE_X:
|
2007-10-12 08:17:00 +00:00
|
|
|
clutter_actor_set_scalex
|
2007-09-27 21:38:38 +00:00
|
|
|
(actor,
|
|
|
|
CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value)),
|
|
|
|
priv->scale_y);
|
|
|
|
break;
|
|
|
|
case PROP_SCALE_Y:
|
2007-10-12 08:17:00 +00:00
|
|
|
clutter_actor_set_scalex
|
2007-09-27 21:38:38 +00:00
|
|
|
(actor,
|
|
|
|
priv->scale_x,
|
|
|
|
CLUTTER_FLOAT_TO_FIXED (g_value_get_double (value)));
|
|
|
|
break;
|
2006-07-06 18:12:19 +00:00
|
|
|
case PROP_CLIP:
|
|
|
|
{
|
|
|
|
ClutterGeometry *geom = g_value_get_boxed (value);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-07-06 18:12:19 +00:00
|
|
|
clutter_actor_set_clip (actor,
|
|
|
|
geom->x, geom->y,
|
|
|
|
geom->width, geom->height);
|
|
|
|
}
|
|
|
|
break;
|
2007-10-17 16:43:46 +00:00
|
|
|
case PROP_REACTIVE:
|
2007-11-15 17:35:47 +00:00
|
|
|
clutter_actor_set_reactive (actor, g_value_get_boolean (value));
|
2007-10-17 16:43:46 +00:00
|
|
|
break;
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
case PROP_ROTATION_ANGLE_X:
|
|
|
|
clutter_actor_set_rotation (actor,
|
|
|
|
CLUTTER_X_AXIS,
|
|
|
|
g_value_get_double (value),
|
|
|
|
0, priv->rxy, priv->rxz);
|
|
|
|
break;
|
|
|
|
case PROP_ROTATION_ANGLE_Y:
|
|
|
|
clutter_actor_set_rotation (actor,
|
|
|
|
CLUTTER_Y_AXIS,
|
|
|
|
g_value_get_double (value),
|
|
|
|
priv->ryx, 0, priv->ryz);
|
|
|
|
break;
|
|
|
|
case PROP_ROTATION_ANGLE_Z:
|
|
|
|
clutter_actor_set_rotation (actor,
|
|
|
|
CLUTTER_Z_AXIS,
|
|
|
|
g_value_get_double (value),
|
|
|
|
priv->rzx, priv->rzy, 0);
|
|
|
|
break;
|
|
|
|
case PROP_ROTATION_CENTER_X:
|
|
|
|
{
|
|
|
|
ClutterVertex *center;
|
|
|
|
|
|
|
|
center = g_value_get_boxed (value);
|
|
|
|
clutter_actor_set_rotationx (actor,
|
|
|
|
CLUTTER_X_AXIS,
|
|
|
|
priv->rxang,
|
|
|
|
0,
|
|
|
|
CLUTTER_UNITS_TO_DEVICE (center->y),
|
|
|
|
CLUTTER_UNITS_TO_DEVICE (center->z));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PROP_ROTATION_CENTER_Y:
|
|
|
|
{
|
|
|
|
ClutterVertex *center;
|
|
|
|
|
|
|
|
center = g_value_get_boxed (value);
|
|
|
|
clutter_actor_set_rotationx (actor,
|
|
|
|
CLUTTER_X_AXIS,
|
|
|
|
priv->ryang,
|
|
|
|
CLUTTER_UNITS_TO_DEVICE (center->x),
|
|
|
|
0,
|
|
|
|
CLUTTER_UNITS_TO_DEVICE (center->z));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PROP_ROTATION_CENTER_Z:
|
|
|
|
{
|
|
|
|
ClutterVertex *center;
|
|
|
|
|
|
|
|
center = g_value_get_boxed (value);
|
|
|
|
clutter_actor_set_rotationx (actor,
|
|
|
|
CLUTTER_X_AXIS,
|
|
|
|
priv->rzang,
|
|
|
|
CLUTTER_UNITS_TO_DEVICE (center->x),
|
|
|
|
CLUTTER_UNITS_TO_DEVICE (center->y),
|
|
|
|
0);
|
|
|
|
}
|
|
|
|
break;
|
2006-06-13 13:17:45 +00:00
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
static void
|
|
|
|
clutter_actor_get_property (GObject *object,
|
2006-06-13 13:17:45 +00:00
|
|
|
guint prop_id,
|
2007-10-12 08:17:00 +00:00
|
|
|
GValue *value,
|
2006-06-13 13:17:45 +00:00
|
|
|
GParamSpec *pspec)
|
|
|
|
{
|
|
|
|
ClutterActor *actor;
|
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
|
|
|
|
actor = CLUTTER_ACTOR(object);
|
|
|
|
priv = actor->priv;
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
switch (prop_id)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
|
|
|
case PROP_X:
|
|
|
|
g_value_set_int (value, clutter_actor_get_x (actor));
|
|
|
|
break;
|
|
|
|
case PROP_Y:
|
|
|
|
g_value_set_int (value, clutter_actor_get_y (actor));
|
|
|
|
break;
|
|
|
|
case PROP_WIDTH:
|
|
|
|
g_value_set_int (value, clutter_actor_get_width (actor));
|
|
|
|
break;
|
|
|
|
case PROP_HEIGHT:
|
|
|
|
g_value_set_int (value, clutter_actor_get_height (actor));
|
|
|
|
break;
|
2007-10-12 12:42:54 +00:00
|
|
|
case PROP_DEPTH:
|
|
|
|
g_value_set_int (value, clutter_actor_get_depth (actor));
|
|
|
|
break;
|
2006-06-13 13:17:45 +00:00
|
|
|
case PROP_OPACITY:
|
|
|
|
g_value_set_uchar (value, priv->opacity);
|
|
|
|
break;
|
|
|
|
case PROP_NAME:
|
|
|
|
g_value_set_string (value, priv->name);
|
|
|
|
break;
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
case PROP_VISIBLE:
|
|
|
|
g_value_set_boolean (value,
|
|
|
|
(CLUTTER_ACTOR_IS_VISIBLE (actor) != FALSE));
|
|
|
|
break;
|
2006-07-06 18:12:19 +00:00
|
|
|
case PROP_HAS_CLIP:
|
|
|
|
g_value_set_boolean (value, priv->has_clip);
|
|
|
|
break;
|
|
|
|
case PROP_CLIP:
|
|
|
|
g_value_set_boxed (value, &(priv->clip));
|
|
|
|
break;
|
2007-09-27 21:38:38 +00:00
|
|
|
case PROP_SCALE_X:
|
|
|
|
g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->scale_x));
|
|
|
|
break;
|
|
|
|
case PROP_SCALE_Y:
|
|
|
|
g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->scale_y));
|
|
|
|
break;
|
2007-10-17 16:43:46 +00:00
|
|
|
case PROP_REACTIVE:
|
|
|
|
g_value_set_boolean (value,
|
|
|
|
(CLUTTER_ACTOR_IS_REACTIVE (actor) != FALSE));
|
|
|
|
break;
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
case PROP_ROTATION_ANGLE_X:
|
|
|
|
g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->rxang));
|
|
|
|
break;
|
|
|
|
case PROP_ROTATION_ANGLE_Y:
|
|
|
|
g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->ryang));
|
|
|
|
break;
|
|
|
|
case PROP_ROTATION_ANGLE_Z:
|
|
|
|
g_value_set_double (value, CLUTTER_FIXED_TO_DOUBLE (priv->rzang));
|
|
|
|
break;
|
|
|
|
case PROP_ROTATION_CENTER_X:
|
|
|
|
{
|
|
|
|
ClutterVertex center = { 0, };
|
|
|
|
|
|
|
|
center.y = priv->rxy;
|
|
|
|
center.z = priv->rxz;
|
|
|
|
|
|
|
|
g_value_set_boxed (value, ¢er);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PROP_ROTATION_CENTER_Y:
|
|
|
|
{
|
|
|
|
ClutterVertex center = { 0, };
|
|
|
|
|
|
|
|
center.x = priv->ryx;
|
|
|
|
center.z = priv->ryz;
|
|
|
|
|
|
|
|
g_value_set_boxed (value, ¢er);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PROP_ROTATION_CENTER_Z:
|
|
|
|
{
|
|
|
|
ClutterVertex center = { 0, };
|
|
|
|
|
|
|
|
center.x = priv->rzx;
|
|
|
|
center.y = priv->rzy;
|
|
|
|
|
|
|
|
g_value_set_boxed (value, ¢er);
|
|
|
|
}
|
|
|
|
break;
|
2006-06-13 13:17:45 +00:00
|
|
|
default:
|
|
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
static void
|
2006-06-13 13:17:45 +00:00
|
|
|
clutter_actor_dispose (GObject *object)
|
|
|
|
{
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
ClutterActor *self = CLUTTER_ACTOR (object);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-11-27 11:05:26 +00:00
|
|
|
CLUTTER_NOTE (MISC, "Disposing of object (id=%d) of type `%s' (ref_count:%d)",
|
2006-11-22 20:52:27 +00:00
|
|
|
self->priv->id,
|
2007-11-27 11:05:26 +00:00
|
|
|
g_type_name (G_OBJECT_TYPE (self)),
|
|
|
|
object->ref_count);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-12-03 16:29:18 +00:00
|
|
|
destroy_shader_data (self);
|
|
|
|
|
2007-10-17 16:43:46 +00:00
|
|
|
if (!(CLUTTER_PRIVATE_FLAGS (self) & CLUTTER_ACTOR_IN_DESTRUCTION))
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
CLUTTER_SET_PRIVATE_FLAGS (self, CLUTTER_ACTOR_IN_DESTRUCTION);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
g_signal_emit (self, actor_signals[DESTROY], 0);
|
|
|
|
|
|
|
|
CLUTTER_UNSET_PRIVATE_FLAGS (self, CLUTTER_ACTOR_IN_DESTRUCTION);
|
|
|
|
}
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
G_OBJECT_CLASS (clutter_actor_parent_class)->dispose (object);
|
|
|
|
}
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
static void
|
2006-06-13 13:17:45 +00:00
|
|
|
clutter_actor_finalize (GObject *object)
|
|
|
|
{
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
ClutterActor *actor = CLUTTER_ACTOR (object);
|
|
|
|
|
2007-11-27 11:05:26 +00:00
|
|
|
CLUTTER_NOTE (MISC, "Finalize object (id=%d) of type `%s'",
|
|
|
|
actor->priv->id,
|
|
|
|
g_type_name (G_OBJECT_TYPE (actor)));
|
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
g_free (actor->priv->name);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
G_OBJECT_CLASS (clutter_actor_parent_class)->finalize (object);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_actor_class_init (ClutterActorClass *klass)
|
|
|
|
{
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
|
|
|
|
object_class->set_property = clutter_actor_set_property;
|
|
|
|
object_class->get_property = clutter_actor_get_property;
|
|
|
|
object_class->dispose = clutter_actor_dispose;
|
|
|
|
object_class->finalize = clutter_actor_finalize;
|
|
|
|
|
|
|
|
g_type_class_add_private (klass, sizeof (ClutterActorPrivate));
|
|
|
|
|
2006-11-20 12:02:24 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor:x:
|
|
|
|
*
|
|
|
|
* X coordinate of the actor.
|
|
|
|
*/
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_X,
|
|
|
|
g_param_spec_int ("x",
|
|
|
|
"X co-ord",
|
|
|
|
"X co-ord of actor",
|
2006-12-13 09:44:05 +00:00
|
|
|
-G_MAXINT, G_MAXINT,
|
2006-11-20 12:02:24 +00:00
|
|
|
0,
|
2006-12-04 16:26:35 +00:00
|
|
|
CLUTTER_PARAM_READWRITE));
|
2006-11-20 12:02:24 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor:y:
|
|
|
|
*
|
|
|
|
* Y coordinate of the actor.
|
|
|
|
*/
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_Y,
|
|
|
|
g_param_spec_int ("y",
|
|
|
|
"Y co-ord",
|
|
|
|
"Y co-ord of actor",
|
2006-12-13 09:44:05 +00:00
|
|
|
-G_MAXINT, G_MAXINT,
|
2006-11-20 12:02:24 +00:00
|
|
|
0,
|
2006-12-04 16:26:35 +00:00
|
|
|
CLUTTER_PARAM_READWRITE));
|
2006-11-20 12:02:24 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor:width:
|
|
|
|
*
|
|
|
|
* Width of the actor (in pixels).
|
|
|
|
*/
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_WIDTH,
|
|
|
|
g_param_spec_int ("width",
|
|
|
|
"Width",
|
|
|
|
"Width of actor in pixels",
|
|
|
|
0, G_MAXINT,
|
|
|
|
0,
|
2006-12-04 16:26:35 +00:00
|
|
|
CLUTTER_PARAM_READWRITE));
|
2006-11-20 12:02:24 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor:height:
|
|
|
|
*
|
|
|
|
* Height of the actor (in pixels).
|
|
|
|
*/
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_HEIGHT,
|
|
|
|
g_param_spec_int ("height",
|
|
|
|
"Height",
|
|
|
|
"Height of actor in pixels",
|
|
|
|
0, G_MAXINT,
|
|
|
|
0,
|
2006-12-04 16:26:35 +00:00
|
|
|
CLUTTER_PARAM_READWRITE));
|
2007-10-12 12:42:54 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor:depth:
|
|
|
|
*
|
|
|
|
* Depth of the actor.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_DEPTH,
|
|
|
|
g_param_spec_int ("depth",
|
|
|
|
"Depth",
|
|
|
|
"Depth of actor",
|
|
|
|
-G_MAXINT, G_MAXINT,
|
|
|
|
0,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
2006-11-20 12:02:24 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor:opacity:
|
|
|
|
*
|
|
|
|
* Opacity of the actor.
|
|
|
|
*/
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_OPACITY,
|
|
|
|
g_param_spec_uchar ("opacity",
|
|
|
|
"Opacity",
|
|
|
|
"Opacity of actor",
|
|
|
|
0, 0xff,
|
|
|
|
0xff,
|
2007-11-20 16:05:56 +00:00
|
|
|
CLUTTER_PARAM_READWRITE));
|
2006-11-20 12:02:24 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor:visible:
|
|
|
|
*
|
|
|
|
* Whether the actor is visible or not.
|
|
|
|
*/
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_VISIBLE,
|
|
|
|
g_param_spec_boolean ("visible",
|
|
|
|
"Visible",
|
|
|
|
"Whether the actor is visible or not",
|
|
|
|
FALSE,
|
2006-12-04 16:26:35 +00:00
|
|
|
CLUTTER_PARAM_READWRITE));
|
2007-10-17 16:43:46 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor:reactive:
|
|
|
|
*
|
|
|
|
* Whether the actor is reactive to events or not.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_REACTIVE,
|
|
|
|
g_param_spec_boolean ("reactive",
|
|
|
|
"Reactive",
|
|
|
|
"Whether the actor is reactive to events or not",
|
|
|
|
FALSE,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
2006-11-20 12:02:24 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor:has-clip:
|
|
|
|
*
|
|
|
|
* Whether the actor has the clip property set or not.
|
|
|
|
*/
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_HAS_CLIP,
|
|
|
|
g_param_spec_boolean ("has-clip",
|
|
|
|
"Has Clip",
|
|
|
|
"Whether the actor has a clip set or not",
|
|
|
|
FALSE,
|
2006-12-04 16:26:35 +00:00
|
|
|
CLUTTER_PARAM_READABLE));
|
2006-11-20 12:02:24 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor:clip:
|
|
|
|
*
|
|
|
|
* The clip region for the actor.
|
|
|
|
*/
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_CLIP,
|
|
|
|
g_param_spec_boxed ("clip",
|
|
|
|
"Clip",
|
|
|
|
"The clip region for the actor",
|
|
|
|
CLUTTER_TYPE_GEOMETRY,
|
2006-12-04 16:26:35 +00:00
|
|
|
CLUTTER_PARAM_READWRITE));
|
2006-11-20 12:02:24 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor:name:
|
|
|
|
*
|
|
|
|
* The name of the actor.
|
|
|
|
*
|
|
|
|
* Since: 0.2
|
|
|
|
*/
|
|
|
|
g_object_class_install_property (object_class,
|
|
|
|
PROP_NAME,
|
|
|
|
g_param_spec_string ("name",
|
|
|
|
"Name",
|
|
|
|
"Name of the actor",
|
|
|
|
NULL,
|
2006-12-04 16:26:35 +00:00
|
|
|
CLUTTER_PARAM_READWRITE));
|
2007-09-27 21:38:38 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor::scale-x:
|
|
|
|
*
|
|
|
|
* The horizontal scale of the actor
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
2007-10-12 08:17:00 +00:00
|
|
|
g_object_class_install_property
|
2007-09-27 21:38:38 +00:00
|
|
|
(object_class,
|
|
|
|
PROP_SCALE_X,
|
|
|
|
g_param_spec_double ("scale-x",
|
|
|
|
"Scale-X",
|
|
|
|
"Scale X",
|
|
|
|
0.0,
|
|
|
|
G_MAXDOUBLE,
|
|
|
|
1.0,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
|
|
|
/**
|
|
|
|
* ClutterActor::scale-y:
|
|
|
|
*
|
|
|
|
* The vertical scale of the actor
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
2007-10-12 08:17:00 +00:00
|
|
|
g_object_class_install_property
|
2007-09-27 21:38:38 +00:00
|
|
|
(object_class,
|
|
|
|
PROP_SCALE_Y,
|
|
|
|
g_param_spec_double ("scale-y",
|
|
|
|
"Scale-Y",
|
|
|
|
"Scale Y",
|
|
|
|
0.0,
|
|
|
|
G_MAXDOUBLE,
|
|
|
|
1.0,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor::rotation-angle-x:
|
|
|
|
*
|
|
|
|
* The rotation angle on the X axis.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
g_object_class_install_property
|
|
|
|
(object_class,
|
|
|
|
PROP_ROTATION_ANGLE_X,
|
|
|
|
g_param_spec_double ("rotation-angle-x",
|
|
|
|
"Rotation Angle X",
|
|
|
|
"The rotation angle on the X axis",
|
|
|
|
0.0,
|
|
|
|
G_MAXDOUBLE,
|
|
|
|
0.0,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
|
|
|
/**
|
|
|
|
* ClutterActor::rotation-angle-y:
|
|
|
|
*
|
|
|
|
* The rotation angle on the Y axis.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
g_object_class_install_property
|
|
|
|
(object_class,
|
|
|
|
PROP_ROTATION_ANGLE_Y,
|
|
|
|
g_param_spec_double ("rotation-angle-y",
|
|
|
|
"Rotation Angle Y",
|
|
|
|
"The rotation angle on the Y axis",
|
|
|
|
0.0,
|
|
|
|
G_MAXDOUBLE,
|
|
|
|
0.0,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
|
|
|
/**
|
|
|
|
* ClutterActor::rotation-angle-z:
|
|
|
|
*
|
|
|
|
* The rotation angle on the Z axis.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
g_object_class_install_property
|
|
|
|
(object_class,
|
|
|
|
PROP_ROTATION_ANGLE_Z,
|
|
|
|
g_param_spec_double ("rotation-angle-z",
|
|
|
|
"Rotation Angle Z",
|
|
|
|
"The rotation angle on the Z axis",
|
|
|
|
0.0,
|
|
|
|
G_MAXDOUBLE,
|
|
|
|
0.0,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
|
|
|
/**
|
|
|
|
* ClutterActor::rotation-center-x:
|
|
|
|
*
|
|
|
|
* The rotation center on the X axis.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
g_object_class_install_property
|
|
|
|
(object_class,
|
|
|
|
PROP_ROTATION_CENTER_X,
|
|
|
|
g_param_spec_boxed ("rotation-center-x",
|
|
|
|
"Rotation Center X",
|
|
|
|
"The rotation center on the X axis",
|
|
|
|
CLUTTER_TYPE_VERTEX,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
|
|
|
/**
|
|
|
|
* ClutterActor::rotation-center-y:
|
|
|
|
*
|
|
|
|
* The rotation center on the Y axis.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
g_object_class_install_property
|
|
|
|
(object_class,
|
|
|
|
PROP_ROTATION_CENTER_Y,
|
|
|
|
g_param_spec_boxed ("rotation-center-y",
|
|
|
|
"Rotation Center Y",
|
|
|
|
"The rotation center on the Y axis",
|
|
|
|
CLUTTER_TYPE_VERTEX,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
|
|
|
/**
|
|
|
|
* ClutterActor::rotation-center-z:
|
|
|
|
*
|
|
|
|
* The rotation center on the Z axis.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
g_object_class_install_property
|
|
|
|
(object_class,
|
|
|
|
PROP_ROTATION_CENTER_Z,
|
|
|
|
g_param_spec_boxed ("rotation-center-z",
|
|
|
|
"Rotation Center Z",
|
|
|
|
"The rotation center on the Z axis",
|
|
|
|
CLUTTER_TYPE_VERTEX,
|
|
|
|
CLUTTER_PARAM_READWRITE));
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-07-06 18:55:46 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor::destroy:
|
|
|
|
* @actor: the object which received the signal
|
|
|
|
*
|
|
|
|
* The ::destroy signal is emitted when an actor is destroyed,
|
|
|
|
* either by direct invocation of clutter_actor_destroy() or
|
|
|
|
* when the #ClutterGroup that contains the actor is destroyed.
|
|
|
|
*
|
2006-11-20 12:02:24 +00:00
|
|
|
* Since: 0.2
|
2006-07-06 18:55:46 +00:00
|
|
|
*/
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
actor_signals[DESTROY] =
|
|
|
|
g_signal_new ("destroy",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_CLEANUP | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, destroy),
|
|
|
|
NULL, NULL,
|
|
|
|
clutter_marshal_VOID__VOID,
|
|
|
|
G_TYPE_NONE, 0);
|
2006-07-06 18:55:46 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor::show:
|
|
|
|
* @actor: the object which received the signal
|
|
|
|
*
|
|
|
|
* The ::show signal is emitted when an actor becomes visible.
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2006-11-20 12:02:24 +00:00
|
|
|
* Since: 0.2
|
2006-07-06 18:55:46 +00:00
|
|
|
*/
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
actor_signals[SHOW] =
|
|
|
|
g_signal_new ("show",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_FIRST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, show),
|
|
|
|
NULL, NULL,
|
|
|
|
clutter_marshal_VOID__VOID,
|
|
|
|
G_TYPE_NONE, 0);
|
2006-07-06 18:55:46 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor::hide:
|
|
|
|
* @actor: the object which received the signal
|
|
|
|
*
|
|
|
|
* The ::hide signal is emitted when an actor is no longer visible.
|
|
|
|
*
|
2006-11-20 12:02:24 +00:00
|
|
|
* Since: 0.2
|
2006-07-06 18:55:46 +00:00
|
|
|
*/
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
actor_signals[HIDE] =
|
|
|
|
g_signal_new ("hide",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_FIRST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, hide),
|
|
|
|
NULL, NULL,
|
|
|
|
clutter_marshal_VOID__VOID,
|
2006-11-20 12:02:24 +00:00
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
/**
|
|
|
|
* ClutterActor::parent-set:
|
|
|
|
* @actor: the object which received the signal
|
|
|
|
* @old_parent: the previous parent of the actor, or %NULL
|
|
|
|
*
|
|
|
|
* This signal is emitted when the parent of the actor changes.
|
|
|
|
*
|
|
|
|
* Since: 0.2
|
|
|
|
*/
|
|
|
|
actor_signals[PARENT_SET] =
|
|
|
|
g_signal_new ("parent-set",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, parent_set),
|
|
|
|
NULL, NULL,
|
|
|
|
clutter_marshal_VOID__OBJECT,
|
|
|
|
G_TYPE_NONE, 1,
|
|
|
|
CLUTTER_TYPE_ACTOR);
|
2006-12-12 20:20:04 +00:00
|
|
|
|
2007-08-13 20:48:01 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor::event:
|
|
|
|
* @actor: the actor which received the event
|
|
|
|
* @event: a #ClutterEvent
|
|
|
|
*
|
|
|
|
* The ::event signal is emitted each time and event is received
|
2007-12-17 15:47:19 +00:00
|
|
|
* by the @actor. This signal will be emitted on every actor,
|
|
|
|
* following the hierarchy chain, until it reaches the top-level
|
|
|
|
* container (the #ClutterStage).
|
2007-08-13 20:48:01 +00:00
|
|
|
*
|
2007-10-02 14:03:36 +00:00
|
|
|
* Return value: %TRUE if the event has been handled by the actor,
|
|
|
|
* or %FALSE to continue the emission.
|
|
|
|
*
|
2007-08-13 20:48:01 +00:00
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
actor_signals[EVENT] =
|
|
|
|
g_signal_new ("event",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, event),
|
2007-10-02 14:03:36 +00:00
|
|
|
_clutter_boolean_handled_accumulator, NULL,
|
|
|
|
clutter_marshal_BOOLEAN__BOXED,
|
|
|
|
G_TYPE_BOOLEAN, 1,
|
2007-08-13 20:48:01 +00:00
|
|
|
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
|
|
/**
|
|
|
|
* ClutterActor::button-press-event:
|
|
|
|
* @actor: the actor which received the event
|
|
|
|
* @event: a #ClutterButtonEvent
|
|
|
|
*
|
|
|
|
* The ::button-press-event signal is emitted each time a mouse button
|
|
|
|
* is pressed on @actor.
|
|
|
|
*
|
2007-10-02 14:03:36 +00:00
|
|
|
* Return value: %TRUE if the event has been handled by the actor,
|
|
|
|
* or %FALSE to continue the emission.
|
|
|
|
*
|
2007-08-13 20:48:01 +00:00
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
actor_signals[BUTTON_PRESS_EVENT] =
|
|
|
|
g_signal_new ("button-press-event",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, button_press_event),
|
2007-10-02 14:03:36 +00:00
|
|
|
_clutter_boolean_handled_accumulator, NULL,
|
|
|
|
clutter_marshal_BOOLEAN__BOXED,
|
|
|
|
G_TYPE_BOOLEAN, 1,
|
2007-08-13 20:48:01 +00:00
|
|
|
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
|
|
/**
|
|
|
|
* ClutterActor::button-release-event:
|
|
|
|
* @actor: the actor which received the event
|
|
|
|
* @event: a #ClutterButtonEvent
|
|
|
|
*
|
|
|
|
* The ::button-release-event signal is emitted each time a mouse button
|
|
|
|
* is released on @actor.
|
|
|
|
*
|
2007-10-02 14:03:36 +00:00
|
|
|
* Return value: %TRUE if the event has been handled by the actor,
|
|
|
|
* or %FALSE to continue the emission.
|
|
|
|
*
|
2007-08-13 20:48:01 +00:00
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
actor_signals[BUTTON_RELEASE_EVENT] =
|
|
|
|
g_signal_new ("button-release-event",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, button_release_event),
|
2007-10-02 14:03:36 +00:00
|
|
|
_clutter_boolean_handled_accumulator, NULL,
|
|
|
|
clutter_marshal_BOOLEAN__BOXED,
|
|
|
|
G_TYPE_BOOLEAN, 1,
|
2007-08-13 20:48:01 +00:00
|
|
|
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
|
|
/**
|
|
|
|
* ClutterActor::scroll-event:
|
|
|
|
* @actor: the actor which received the event
|
|
|
|
* @event: a #ClutterScrollEvent
|
|
|
|
*
|
|
|
|
* The ::scroll-event signal is emitted each time a the mouse is
|
|
|
|
* scrolled on @actor
|
|
|
|
*
|
2007-10-02 14:03:36 +00:00
|
|
|
* Return value: %TRUE if the event has been handled by the actor,
|
|
|
|
* or %FALSE to continue the emission.
|
2007-08-13 20:48:01 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
actor_signals[SCROLL_EVENT] =
|
|
|
|
g_signal_new ("scroll-event",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, scroll_event),
|
2007-10-02 14:03:36 +00:00
|
|
|
_clutter_boolean_handled_accumulator, NULL,
|
|
|
|
clutter_marshal_BOOLEAN__BOXED,
|
|
|
|
G_TYPE_BOOLEAN, 1,
|
2007-08-13 20:48:01 +00:00
|
|
|
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
|
|
/**
|
|
|
|
* ClutterActor::key-press-event:
|
|
|
|
* @actor: the actor which received the event
|
|
|
|
* @event: a #ClutterKeyEvent
|
|
|
|
*
|
|
|
|
* The ::key-press-event signal is emitted each time a keyboard button
|
|
|
|
* is pressed on @actor.
|
|
|
|
*
|
2007-10-02 14:03:36 +00:00
|
|
|
* Return value: %TRUE if the event has been handled by the actor,
|
|
|
|
* or %FALSE to continue the emission.
|
|
|
|
*
|
2007-08-13 20:48:01 +00:00
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
actor_signals[KEY_PRESS_EVENT] =
|
|
|
|
g_signal_new ("key-press-event",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, key_press_event),
|
2007-10-02 14:03:36 +00:00
|
|
|
_clutter_boolean_handled_accumulator, NULL,
|
|
|
|
clutter_marshal_BOOLEAN__BOXED,
|
|
|
|
G_TYPE_BOOLEAN, 1,
|
2007-08-13 20:48:01 +00:00
|
|
|
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
|
|
/**
|
|
|
|
* ClutterActor::key-release-event:
|
|
|
|
* @actor: the actor which received the event
|
|
|
|
* @event: a #ClutterKeyEvent
|
|
|
|
*
|
|
|
|
* The ::key-release-event signal is emitted each time a keyboard button
|
|
|
|
* is released on @actor.
|
|
|
|
*
|
2007-10-02 14:03:36 +00:00
|
|
|
* Return value: %TRUE if the event has been handled by the actor,
|
|
|
|
* or %FALSE to continue the emission.
|
|
|
|
*
|
2007-08-13 20:48:01 +00:00
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
actor_signals[KEY_RELEASE_EVENT] =
|
|
|
|
g_signal_new ("key-release-event",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, key_release_event),
|
2007-10-02 14:03:36 +00:00
|
|
|
_clutter_boolean_handled_accumulator, NULL,
|
|
|
|
clutter_marshal_BOOLEAN__BOXED,
|
|
|
|
G_TYPE_BOOLEAN, 1,
|
2007-08-13 20:48:01 +00:00
|
|
|
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
|
|
/**
|
|
|
|
* ClutterActor::motion-event:
|
|
|
|
* @actor: the actor which received the event
|
|
|
|
* @event: a #ClutterMotionEvent
|
|
|
|
*
|
|
|
|
* The ::motion-event signal is emitted each time the mouse pointer is
|
|
|
|
* moved on @actor.
|
|
|
|
*
|
2007-10-02 14:03:36 +00:00
|
|
|
* Return value: %TRUE if the event has been handled by the actor,
|
|
|
|
* or %FALSE to continue the emission.
|
|
|
|
*
|
2007-08-13 20:48:01 +00:00
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
actor_signals[MOTION_EVENT] =
|
|
|
|
g_signal_new ("motion-event",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, motion_event),
|
2007-10-02 14:03:36 +00:00
|
|
|
_clutter_boolean_handled_accumulator, NULL,
|
|
|
|
clutter_marshal_BOOLEAN__BOXED,
|
|
|
|
G_TYPE_BOOLEAN, 1,
|
2007-08-13 20:48:01 +00:00
|
|
|
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ClutterActor::focus-in:
|
|
|
|
* @actor: the actor which now has key focus
|
|
|
|
*
|
|
|
|
* The ::focus-in signal is emitted when @actor recieves key focus.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
actor_signals[FOCUS_IN] =
|
|
|
|
g_signal_new ("focus-in",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, focus_in),
|
|
|
|
NULL, NULL,
|
|
|
|
clutter_marshal_VOID__VOID,
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ClutterActor::focus-out:
|
|
|
|
* @actor: the actor which now has key focus
|
|
|
|
*
|
|
|
|
* The ::focus-out signal is emitted when @actor loses key focus.
|
|
|
|
*
|
2007-10-09 23:45:49 +00:00
|
|
|
* Since: 0.6
|
2007-08-13 20:48:01 +00:00
|
|
|
*/
|
|
|
|
actor_signals[FOCUS_OUT] =
|
|
|
|
g_signal_new ("focus-out",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, focus_out),
|
|
|
|
NULL, NULL,
|
|
|
|
clutter_marshal_VOID__VOID,
|
|
|
|
G_TYPE_NONE, 0);
|
|
|
|
|
2007-10-09 23:45:49 +00:00
|
|
|
/**
|
2007-10-10 14:29:29 +00:00
|
|
|
* ClutterActor::enter-event:
|
2007-10-09 23:45:49 +00:00
|
|
|
* @actor: the actor which the pointer has entered.
|
2007-12-17 15:47:19 +00:00
|
|
|
* @event: a #ClutterCrossingEvent
|
2007-10-09 23:45:49 +00:00
|
|
|
*
|
2007-10-12 08:17:00 +00:00
|
|
|
* The ::enter-event signal is emitted when the pointer enters the @actor
|
2007-10-09 23:45:49 +00:00
|
|
|
*
|
2007-12-17 15:47:19 +00:00
|
|
|
* Return value: %TRUE if the event has been handled by the actor,
|
|
|
|
* or %FALSE to continue the emission.
|
|
|
|
*
|
2007-10-09 23:45:49 +00:00
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
actor_signals[ENTER_EVENT] =
|
|
|
|
g_signal_new ("enter-event",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
2007-11-07 16:40:30 +00:00
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, enter_event),
|
2007-10-10 13:04:34 +00:00
|
|
|
_clutter_boolean_handled_accumulator, NULL,
|
|
|
|
clutter_marshal_BOOLEAN__BOXED,
|
|
|
|
G_TYPE_BOOLEAN, 1,
|
|
|
|
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
|
2007-10-09 23:45:49 +00:00
|
|
|
|
|
|
|
/**
|
2007-10-10 14:29:29 +00:00
|
|
|
* ClutterActor::leave-event:
|
2007-10-09 23:45:49 +00:00
|
|
|
* @actor: the actor which the pointer has left
|
2007-12-17 15:47:19 +00:00
|
|
|
* @event: a #ClutterCrossingEvent
|
2007-10-09 23:45:49 +00:00
|
|
|
*
|
2007-10-10 14:29:29 +00:00
|
|
|
* The ::leave-event signal is emitted when the pointer leaves the @actor.
|
2007-10-09 23:45:49 +00:00
|
|
|
*
|
2007-12-17 15:47:19 +00:00
|
|
|
* Return value: %TRUE if the event has been handled by the actor,
|
|
|
|
* or %FALSE to continue the emission.
|
|
|
|
*
|
2007-10-09 23:45:49 +00:00
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
actor_signals[LEAVE_EVENT] =
|
|
|
|
g_signal_new ("leave-event",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
2007-11-07 16:40:30 +00:00
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, leave_event),
|
2007-10-10 13:04:34 +00:00
|
|
|
_clutter_boolean_handled_accumulator, NULL,
|
|
|
|
clutter_marshal_BOOLEAN__BOXED,
|
|
|
|
G_TYPE_BOOLEAN, 1,
|
|
|
|
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
|
2007-10-09 23:45:49 +00:00
|
|
|
|
2007-10-10 13:04:34 +00:00
|
|
|
/**
|
|
|
|
* ClutterActor::captured-event:
|
2007-12-17 15:47:19 +00:00
|
|
|
* @actor: the actor which received the signal
|
|
|
|
* @event: a #ClutterEvent
|
2007-10-10 13:04:34 +00:00
|
|
|
*
|
2007-10-10 14:29:29 +00:00
|
|
|
* The ::captured-event signal is emitted when an event is captured
|
2007-12-17 15:47:19 +00:00
|
|
|
* by Clutter. This signal will be emitted starting from the top-level
|
|
|
|
* container (the #ClutterStage) to the actor which received the event
|
|
|
|
* going down the hierarchy. This signal can be used to intercept every
|
|
|
|
* event before the specialized events (like
|
|
|
|
* ClutterActor::button-press-event or ::key-released-event) are
|
|
|
|
* emitted.
|
|
|
|
*
|
|
|
|
* Return value: %TRUE if the event has been handled by the actor,
|
|
|
|
* or %FALSE to continue the emission.
|
2007-10-10 13:04:34 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
2007-11-07 16:40:30 +00:00
|
|
|
actor_signals[CAPTURED_EVENT] =
|
2007-10-10 13:04:34 +00:00
|
|
|
g_signal_new ("captured-event",
|
|
|
|
G_TYPE_FROM_CLASS (object_class),
|
|
|
|
G_SIGNAL_RUN_LAST,
|
2007-11-07 16:40:30 +00:00
|
|
|
G_STRUCT_OFFSET (ClutterActorClass, captured_event),
|
2007-10-10 13:04:34 +00:00
|
|
|
_clutter_boolean_handled_accumulator, NULL,
|
|
|
|
clutter_marshal_BOOLEAN__BOXED,
|
|
|
|
G_TYPE_BOOLEAN, 1,
|
|
|
|
CLUTTER_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
|
2007-08-13 20:48:01 +00:00
|
|
|
|
2006-12-12 20:20:04 +00:00
|
|
|
klass->show = clutter_actor_real_show;
|
|
|
|
klass->show_all = clutter_actor_show;
|
|
|
|
klass->hide = clutter_actor_real_hide;
|
|
|
|
klass->hide_all = clutter_actor_hide;
|
2007-11-18 23:24:55 +00:00
|
|
|
klass->pick = clutter_actor_real_pick;
|
2007-11-23 17:12:27 +00:00
|
|
|
klass->request_coords = clutter_actor_real_request_coords;
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_actor_init (ClutterActor *self)
|
|
|
|
{
|
2007-10-02 14:45:40 +00:00
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
ClutterActorBox box = { 0, };
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
self->priv = priv = CLUTTER_ACTOR_GET_PRIVATE (self);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-10-02 14:45:40 +00:00
|
|
|
priv->parent_actor = NULL;
|
|
|
|
priv->has_clip = FALSE;
|
|
|
|
priv->opacity = 0xff;
|
|
|
|
priv->id = __id++;
|
|
|
|
priv->scale_x = CFX_ONE;
|
|
|
|
priv->scale_y = CFX_ONE;
|
2007-12-03 16:29:18 +00:00
|
|
|
priv->shader_data = NULL;
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-10-02 14:45:40 +00:00
|
|
|
clutter_actor_request_coords (self, &box);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_destroy:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
*
|
|
|
|
* Destroys an actor. When an actor is destroyed, it will break any
|
|
|
|
* references it holds to other objects. If the actor is inside a
|
2007-08-13 17:01:07 +00:00
|
|
|
* container, the actor will be removed.
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
*
|
2007-08-13 17:01:07 +00:00
|
|
|
* When you destroy a container its children will be destroyed as well.
|
2007-11-23 11:20:14 +00:00
|
|
|
*
|
|
|
|
* Note: you cannot destroy the #ClutterStage returned by
|
|
|
|
* clutter_stage_get_default().
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_destroy (ClutterActor *self)
|
|
|
|
{
|
2007-11-23 11:20:14 +00:00
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
2007-11-23 11:20:14 +00:00
|
|
|
if (CLUTTER_PRIVATE_FLAGS (self) & CLUTTER_ACTOR_IS_TOPLEVEL)
|
|
|
|
{
|
|
|
|
g_warning ("Calling clutter_actor_destroy() on an actor of type `%s' "
|
|
|
|
"is not possible. This is usually an application bug.",
|
|
|
|
g_type_name (G_OBJECT_TYPE (self)));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv = self->priv;
|
|
|
|
|
|
|
|
if (priv->parent_actor)
|
2007-10-17 16:43:46 +00:00
|
|
|
{
|
2007-11-23 11:20:14 +00:00
|
|
|
ClutterActor *parent = priv->parent_actor;
|
2007-10-17 16:43:46 +00:00
|
|
|
|
|
|
|
if (CLUTTER_IS_CONTAINER (parent))
|
|
|
|
{
|
|
|
|
g_object_ref (self);
|
|
|
|
clutter_container_remove_actor (CLUTTER_CONTAINER (parent), self);
|
|
|
|
}
|
|
|
|
else
|
2007-11-23 11:20:14 +00:00
|
|
|
priv->parent_actor = NULL;
|
2007-10-17 16:43:46 +00:00
|
|
|
}
|
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
if (!(CLUTTER_PRIVATE_FLAGS (self) & CLUTTER_ACTOR_IN_DESTRUCTION))
|
|
|
|
g_object_run_dispose (G_OBJECT (self));
|
2007-11-27 11:05:26 +00:00
|
|
|
|
|
|
|
g_object_unref (self);
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_queue_redraw:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
2007-10-12 08:17:00 +00:00
|
|
|
* Queues up a redraw of an actor and any children. The redraw occurs
|
|
|
|
* once the main loop becomes idle (after the current batch of events
|
2006-06-13 13:17:45 +00:00
|
|
|
* has been processed, roughly).
|
|
|
|
*
|
|
|
|
* Applications rarely need to call this as redraws are handled automatically
|
2007-10-12 08:17:00 +00:00
|
|
|
* by modification functions.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_queue_redraw (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterMainContext *ctx = CLUTTER_CONTEXT();
|
|
|
|
|
|
|
|
if (!ctx->update_idle)
|
|
|
|
{
|
2007-08-08 10:20:14 +00:00
|
|
|
CLUTTER_TIMESTAMP (SCHEDULER, "Adding idle source for actor: %p", self);
|
|
|
|
|
|
|
|
ctx->update_idle =
|
|
|
|
clutter_threads_add_idle_full (G_PRIORITY_DEFAULT + 10,
|
2007-10-12 08:17:00 +00:00
|
|
|
redraw_update_idle,
|
2007-08-08 10:20:14 +00:00
|
|
|
NULL, NULL);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_set_geometry:
|
|
|
|
* @self: A #ClutterActor
|
2006-07-06 18:55:46 +00:00
|
|
|
* @geometry: A #ClutterGeometry
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Sets the actors untransformed geometry in pixels relative to any
|
|
|
|
* parent actor.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
clutter_actor_set_geometry (ClutterActor *self,
|
2006-07-06 18:55:46 +00:00
|
|
|
const ClutterGeometry *geometry)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
2007-05-22 09:31:40 +00:00
|
|
|
box.x1 = CLUTTER_UNITS_FROM_INT (geometry->x);
|
|
|
|
box.y1 = CLUTTER_UNITS_FROM_INT (geometry->y);
|
|
|
|
box.x2 = CLUTTER_UNITS_FROM_INT (geometry->x + geometry->width);
|
|
|
|
box.y2 = CLUTTER_UNITS_FROM_INT (geometry->y + geometry->height);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
clutter_actor_request_coords (self, &box);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_get_geometry:
|
|
|
|
* @self: A #ClutterActor
|
2006-07-06 18:55:46 +00:00
|
|
|
* @geometry: A location to store actors #ClutterGeometry
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Gets the actors untransformed geometry in pixels relative to any
|
|
|
|
* parent actor.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
clutter_actor_get_geometry (ClutterActor *self,
|
2006-07-06 18:55:46 +00:00
|
|
|
ClutterGeometry *geometry)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-13 23:24:59 +00:00
|
|
|
clutter_actor_query_coords (self, &box);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
geometry->x = CLUTTER_UNITS_TO_DEVICE (box.x1);
|
|
|
|
geometry->y = CLUTTER_UNITS_TO_DEVICE (box.y1);
|
|
|
|
geometry->width = CLUTTER_UNITS_TO_DEVICE (box.x2 - box.x1);
|
|
|
|
geometry->height = CLUTTER_UNITS_TO_DEVICE (box.y2 - box.y1);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_get_coords:
|
|
|
|
* @self: A #ClutterActor
|
2007-07-26 11:04:04 +00:00
|
|
|
* @x_1: A location to store actors left position, or %NULL.
|
|
|
|
* @y_1: A location to store actors top position, or %NULL.
|
|
|
|
* @x_2: A location to store actors right position, or %NULL.
|
|
|
|
* @y_2: A location to store actors bottom position, or %NULL.
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2007-10-12 08:17:00 +00:00
|
|
|
* Gets the actors untransformed bounding rectangle co-ordinates in pixels
|
|
|
|
* relative to any parent actor.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_get_coords (ClutterActor *self,
|
2007-07-26 11:04:04 +00:00
|
|
|
gint *x_1,
|
|
|
|
gint *y_1,
|
|
|
|
gint *x_2,
|
|
|
|
gint *y_2)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2007-05-22 09:31:40 +00:00
|
|
|
ClutterActorBox box;
|
2006-06-13 13:17:45 +00:00
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-13 23:24:59 +00:00
|
|
|
clutter_actor_query_coords (self, &box);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-07-26 11:04:04 +00:00
|
|
|
if (x_1)
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
*x_1 = CLUTTER_UNITS_TO_DEVICE (box.x1);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-07-26 11:04:04 +00:00
|
|
|
if (y_1)
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
*y_1 = CLUTTER_UNITS_TO_DEVICE (box.y1);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-07-26 11:04:04 +00:00
|
|
|
if (x_2)
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
*x_2 = CLUTTER_UNITS_TO_DEVICE (box.x2);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-07-26 11:04:04 +00:00
|
|
|
if (y_2)
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
*y_2 = CLUTTER_UNITS_TO_DEVICE (box.y2);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_set_position
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @x: New left position of actor in pixels.
|
|
|
|
* @y: New top position of actor in pixels.
|
|
|
|
*
|
|
|
|
* Sets the actors position in pixels relative to any
|
2007-10-12 08:17:00 +00:00
|
|
|
* parent actor.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_position (ClutterActor *self,
|
2006-11-20 12:02:24 +00:00
|
|
|
gint x,
|
|
|
|
gint y)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2007-05-22 09:31:40 +00:00
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
2007-06-13 23:24:59 +00:00
|
|
|
clutter_actor_query_coords (self, &box);
|
2007-05-22 09:31:40 +00:00
|
|
|
|
|
|
|
box.x2 += (CLUTTER_UNITS_FROM_INT (x) - box.x1);
|
|
|
|
box.y2 += (CLUTTER_UNITS_FROM_INT (y) - box.y1);
|
|
|
|
|
|
|
|
box.x1 = CLUTTER_UNITS_FROM_INT (x);
|
|
|
|
box.y1 = CLUTTER_UNITS_FROM_INT (y);
|
|
|
|
|
|
|
|
clutter_actor_request_coords (self, &box);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2007-11-28 15:31:41 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_positionu
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @x: New left position of actor in #ClutterUnit
|
|
|
|
* @y: New top position of actor in #ClutterUnit
|
|
|
|
*
|
|
|
|
* Sets the actors position in #ClutterUnit relative to any
|
|
|
|
* parent actor.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_positionu (ClutterActor *self,
|
|
|
|
ClutterUnit x,
|
|
|
|
ClutterUnit y)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
|
|
|
box.x2 += (x - box.x1);
|
|
|
|
box.y2 += (y - box.y1);
|
|
|
|
|
|
|
|
box.x1 = x;
|
|
|
|
box.y1 = y;
|
|
|
|
|
|
|
|
clutter_actor_request_coords (self, &box);
|
|
|
|
}
|
|
|
|
|
2006-11-15 21:19:01 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_move_by
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @dx: Distance to move Actor on X axis.
|
|
|
|
* @dy: Distance to move Actor on Y axis.
|
|
|
|
*
|
2007-10-12 08:17:00 +00:00
|
|
|
* Moves an actor by specified distance relative to
|
2007-06-22 15:16:40 +00:00
|
|
|
* current position in pixels.
|
2006-11-15 21:19:01 +00:00
|
|
|
*
|
|
|
|
* Since: 0.2
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_move_by (ClutterActor *self,
|
|
|
|
gint dx,
|
|
|
|
gint dy)
|
|
|
|
{
|
2007-05-22 09:31:40 +00:00
|
|
|
ClutterActorBox box;
|
|
|
|
gint32 dxu = CLUTTER_UNITS_FROM_INT (dx);
|
|
|
|
gint32 dyu = CLUTTER_UNITS_FROM_INT (dy);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-11-15 21:19:01 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
2007-06-13 23:24:59 +00:00
|
|
|
clutter_actor_query_coords (self, &box);
|
2006-11-15 21:19:01 +00:00
|
|
|
|
2007-05-22 09:31:40 +00:00
|
|
|
box.x2 += dxu;
|
|
|
|
box.y2 += dyu;
|
|
|
|
box.x1 += dxu;
|
|
|
|
box.y1 += dyu;
|
2006-11-15 21:19:01 +00:00
|
|
|
|
2007-05-22 09:31:40 +00:00
|
|
|
clutter_actor_request_coords (self, &box);
|
2006-11-15 21:19:01 +00:00
|
|
|
}
|
|
|
|
|
2007-11-15 17:35:47 +00:00
|
|
|
/* local inline version, without type checking to be used by
|
|
|
|
* set_width() and set_height(). if one of the dimensions is < 0
|
|
|
|
* it will not be changed
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
clutter_actor_set_size_internal (ClutterActor *self,
|
|
|
|
gint width,
|
|
|
|
gint height)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
|
|
|
if (width > 0)
|
|
|
|
box.x2 = box.x1 + CLUTTER_UNITS_FROM_INT (width);
|
|
|
|
|
|
|
|
if (height > 0)
|
|
|
|
box.y2 = box.y1 + CLUTTER_UNITS_FROM_INT (height);
|
|
|
|
|
|
|
|
clutter_actor_request_coords (self, &box);
|
|
|
|
}
|
|
|
|
|
2007-11-28 15:31:41 +00:00
|
|
|
/* local inline unit version, without type checking to be used by
|
|
|
|
* set_width() and set_height(). if one of the dimensions is < 0
|
|
|
|
* it will not be changed
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
clutter_actor_set_size_internalu (ClutterActor *self,
|
|
|
|
ClutterUnit width,
|
|
|
|
ClutterUnit height)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
|
|
|
if (width > 0)
|
|
|
|
box.x2 = box.x1 + width;
|
|
|
|
|
|
|
|
if (height > 0)
|
|
|
|
box.y2 = box.y1 + height;
|
|
|
|
|
|
|
|
clutter_actor_request_coords (self, &box);
|
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_size
|
|
|
|
* @self: A #ClutterActor
|
2007-11-15 17:35:47 +00:00
|
|
|
* @width: New width of actor in pixels, or -1
|
|
|
|
* @height: New height of actor in pixels, or -1
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2007-11-15 17:35:47 +00:00
|
|
|
* Sets the actors size in pixels. If @width and/or @height are -1 the
|
|
|
|
* actor will assume the same size of its bounding box.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_size (ClutterActor *self,
|
2006-11-20 12:02:24 +00:00
|
|
|
gint width,
|
|
|
|
gint height)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
2007-11-15 17:35:47 +00:00
|
|
|
clutter_actor_set_size_internal (self, width, height);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2007-11-28 15:31:41 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_sizeu
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @width: New width of actor in #ClutterUnit, or -1
|
|
|
|
* @height: New height of actor in #ClutterUnit, or -1
|
|
|
|
*
|
|
|
|
* Sets the actors size in #ClutterUnit. If @width and/or @height are -1 the
|
|
|
|
* actor will assume the same size of its bounding box.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_sizeu (ClutterActor *self,
|
|
|
|
ClutterUnit width,
|
|
|
|
ClutterUnit height)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_set_size_internalu (self, width, height);
|
|
|
|
}
|
|
|
|
|
2006-12-13 18:12:09 +00:00
|
|
|
/**
|
2006-12-12 20:20:04 +00:00
|
|
|
* clutter_actor_get_size:
|
2006-11-15 21:19:01 +00:00
|
|
|
* @self: A #ClutterActor
|
2006-11-17 18:45:31 +00:00
|
|
|
* @width: Location to store width if non NULL.
|
|
|
|
* @height: Location to store height if non NULL.
|
2006-11-15 21:19:01 +00:00
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Gets the size of an actor in pixels ignoring any scaling factors.
|
2006-11-15 21:19:01 +00:00
|
|
|
*
|
|
|
|
* Since: 0.2
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_get_size (ClutterActor *self,
|
|
|
|
guint *width,
|
|
|
|
guint *height)
|
|
|
|
{
|
2007-10-02 14:45:40 +00:00
|
|
|
ClutterActorBox box;
|
|
|
|
|
2006-11-15 21:19:01 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
2007-10-02 14:45:40 +00:00
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
2006-11-15 21:19:01 +00:00
|
|
|
if (width)
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
*width = CLUTTER_UNITS_TO_DEVICE (box.x2 - box.x1);
|
2006-11-20 12:02:24 +00:00
|
|
|
|
2006-11-15 21:19:01 +00:00
|
|
|
if (height)
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
*height = CLUTTER_UNITS_TO_DEVICE (box.y2 - box.y1);
|
2006-11-15 21:19:01 +00:00
|
|
|
}
|
|
|
|
|
2007-12-07 15:49:54 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_sizeu:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @width: Location to store width if non NULL.
|
|
|
|
* @height: Location to store height if non NULL.
|
|
|
|
*
|
|
|
|
* Gets the size of an actor in #ClutterUnit<!-- -->s ignoring any scaling
|
|
|
|
* factors.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_get_sizeu (ClutterActor *self,
|
|
|
|
ClutterUnit *width,
|
|
|
|
ClutterUnit *height)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
|
|
|
if (width)
|
|
|
|
*width = box.x2 - box.x1;
|
|
|
|
|
|
|
|
if (height)
|
|
|
|
*height = box.y2 - box.y1;
|
|
|
|
}
|
|
|
|
|
2007-11-15 17:35:47 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_position:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @x: return location for the X coordinate, or %NULL
|
|
|
|
* @y: return location for the Y coordinate, or %NULL
|
|
|
|
*
|
|
|
|
* Retrieves the position of an actor.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_get_position (ClutterActor *self,
|
|
|
|
gint *x,
|
|
|
|
gint *y)
|
|
|
|
{
|
|
|
|
ClutterActorBox box = { 0, };
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
|
|
|
if (x)
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
*x = CLUTTER_UNITS_TO_DEVICE (box.x1);
|
2007-11-15 17:35:47 +00:00
|
|
|
|
|
|
|
if (y)
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
*y = CLUTTER_UNITS_TO_DEVICE (box.y1);
|
2007-11-15 17:35:47 +00:00
|
|
|
}
|
|
|
|
|
2007-12-07 15:49:54 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_positionu:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @x: return location for the X coordinate, or %NULL
|
|
|
|
* @y: return location for the Y coordinate, or %NULL
|
|
|
|
*
|
|
|
|
* Retrieves the position of an actor in #ClutterUnit<!-- -->s.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_get_positionu (ClutterActor *self,
|
|
|
|
ClutterUnit *x,
|
|
|
|
ClutterUnit *y)
|
|
|
|
{
|
|
|
|
ClutterActorBox box = { 0, };
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
|
|
|
if (x)
|
|
|
|
*x = box.x1;
|
|
|
|
|
|
|
|
if (y)
|
|
|
|
*y = box.y1;
|
|
|
|
}
|
|
|
|
|
2007-05-23 10:47:35 +00:00
|
|
|
/*
|
2007-05-22 09:31:40 +00:00
|
|
|
* clutter_actor_get_abs_position_units
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @x: Location to store x position if non NULL.
|
|
|
|
* @y: Location to store y position if non NULL.
|
|
|
|
*
|
|
|
|
* Gets the absolute position of an actor in clutter units relative
|
|
|
|
* to the stage.
|
|
|
|
*
|
|
|
|
* Since: 0.4
|
|
|
|
*/
|
2007-05-23 10:47:35 +00:00
|
|
|
static void
|
2007-05-22 09:31:40 +00:00
|
|
|
clutter_actor_get_abs_position_units (ClutterActor *self,
|
|
|
|
gint32 *x,
|
|
|
|
gint32 *y)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2007-07-02 09:21:58 +00:00
|
|
|
ClutterVertex v1;
|
|
|
|
ClutterVertex v2;
|
2007-07-28 17:11:39 +00:00
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-07-02 09:21:58 +00:00
|
|
|
v1.x = v1.y = v1.z = 0;
|
|
|
|
clutter_actor_apply_transform_to_point (self, &v1, &v2);
|
|
|
|
|
2007-07-28 17:11:39 +00:00
|
|
|
if (x)
|
|
|
|
*x = v2.x;
|
|
|
|
if (y)
|
|
|
|
*y = v2.y;
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2007-05-18 07:30:06 +00:00
|
|
|
/**
|
2007-05-23 10:47:35 +00:00
|
|
|
* clutter_actor_get_abs_position
|
2007-05-18 07:30:06 +00:00
|
|
|
* @self: A #ClutterActor
|
2007-05-23 10:47:35 +00:00
|
|
|
* @x: Location to store x position if non NULL.
|
|
|
|
* @y: Location to store y position if non NULL.
|
2007-05-18 07:30:06 +00:00
|
|
|
*
|
2007-05-23 10:47:35 +00:00
|
|
|
* Gets the absolute position of an actor in pixels relative
|
|
|
|
* to the stage.
|
2007-05-18 07:30:06 +00:00
|
|
|
*/
|
|
|
|
void
|
2007-05-23 10:47:35 +00:00
|
|
|
clutter_actor_get_abs_position (ClutterActor *self,
|
2007-07-28 17:11:39 +00:00
|
|
|
gint *x,
|
|
|
|
gint *y)
|
2007-05-18 07:30:06 +00:00
|
|
|
{
|
2007-07-28 17:11:39 +00:00
|
|
|
ClutterUnit xu, yu;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
xu = yu = 0;
|
2007-05-23 10:47:35 +00:00
|
|
|
clutter_actor_get_abs_position_units (self, &xu, &yu);
|
|
|
|
|
2007-07-28 17:11:39 +00:00
|
|
|
if (x)
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
*x = CLUTTER_UNITS_TO_DEVICE (xu);
|
2007-07-28 17:11:39 +00:00
|
|
|
if (y)
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
*y = CLUTTER_UNITS_TO_DEVICE (yu);
|
2007-05-18 07:30:06 +00:00
|
|
|
}
|
|
|
|
|
2007-05-23 10:47:35 +00:00
|
|
|
/*
|
2007-05-22 09:31:40 +00:00
|
|
|
* clutter_actor_get_abs_size_units:
|
2006-08-29 19:09:43 +00:00
|
|
|
* @self: A #ClutterActor
|
2006-12-12 20:20:04 +00:00
|
|
|
* @width: Location to store width if non NULL.
|
|
|
|
* @height: Location to store height if non NULL.
|
2006-08-29 19:09:43 +00:00
|
|
|
*
|
2007-05-22 09:31:40 +00:00
|
|
|
* Gets the absolute size of an actor in clutter units taking into account
|
|
|
|
* an scaling factors.
|
|
|
|
*
|
2007-06-14 08:17:13 +00:00
|
|
|
* Note: When the actor (or one of its ancestors) is rotated around the x or y
|
|
|
|
* axis, it no longer appears as on the stage as a rectangle, but as a generic
|
|
|
|
* quadrangle; in that case this function returns the size of the smallest
|
|
|
|
* rectangle that encapsulates the entire quad. Please note that in this case
|
|
|
|
* no assumptions can be made about the relative position of this envelope to
|
|
|
|
* the absolute position of the actor, as returned by
|
|
|
|
* clutter_actor_get_abs_position() - if you need this information, you need
|
2007-06-27 15:10:52 +00:00
|
|
|
* to use clutter_actor_get_vertices() to get the coords of the actual
|
2007-06-14 08:17:13 +00:00
|
|
|
* quadrangle.
|
|
|
|
*
|
2007-05-22 09:31:40 +00:00
|
|
|
* Since: 0.4
|
2006-08-29 19:09:43 +00:00
|
|
|
*/
|
2007-05-23 10:47:35 +00:00
|
|
|
static void
|
2007-05-22 09:31:40 +00:00
|
|
|
clutter_actor_get_abs_size_units (ClutterActor *self,
|
|
|
|
gint32 *width,
|
|
|
|
gint32 *height)
|
2006-08-29 19:09:43 +00:00
|
|
|
{
|
2007-06-14 08:17:13 +00:00
|
|
|
ClutterVertex v[4];
|
|
|
|
ClutterFixed x_min, x_max, y_min, y_max;
|
|
|
|
gint i;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-27 15:10:52 +00:00
|
|
|
clutter_actor_get_vertices (self, v);
|
2006-08-29 19:09:43 +00:00
|
|
|
|
2007-06-14 08:17:13 +00:00
|
|
|
x_min = x_max = v[0].x;
|
|
|
|
y_min = y_max = v[0].y;
|
2006-08-29 19:09:43 +00:00
|
|
|
|
2007-06-14 08:17:13 +00:00
|
|
|
for (i = 1; i < sizeof(v)/sizeof(v[0]); ++i)
|
2006-08-29 19:09:43 +00:00
|
|
|
{
|
2007-06-14 08:17:13 +00:00
|
|
|
if (v[i].x < x_min)
|
|
|
|
x_min = v[i].x;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-14 08:17:13 +00:00
|
|
|
if (v[i].x > x_max)
|
|
|
|
x_max = v[i].x;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-14 08:17:13 +00:00
|
|
|
if (v[i].y < y_min)
|
|
|
|
y_min = v[i].y;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-14 08:17:13 +00:00
|
|
|
if (v[i].y > y_max)
|
|
|
|
y_max = v[i].y;
|
2007-05-18 07:30:06 +00:00
|
|
|
}
|
2007-06-14 08:17:13 +00:00
|
|
|
|
|
|
|
*width = x_max - x_min;
|
|
|
|
*height = y_max - y_min;
|
2007-05-18 07:30:06 +00:00
|
|
|
}
|
|
|
|
|
2007-05-23 10:47:35 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_abs_size:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @width: Location to store width if non NULL.
|
|
|
|
* @height: Location to store height if non NULL.
|
|
|
|
*
|
|
|
|
* Gets the absolute size of an actor taking into account
|
|
|
|
* an scaling factors
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_get_abs_size (ClutterActor *self,
|
|
|
|
guint *width,
|
|
|
|
guint *height)
|
|
|
|
{
|
|
|
|
gint32 wu, hu;
|
|
|
|
clutter_actor_get_abs_size_units (self, &wu, &hu);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
*width = CLUTTER_UNITS_TO_DEVICE (wu);
|
|
|
|
*height = CLUTTER_UNITS_TO_DEVICE (hu);
|
2007-05-23 10:47:35 +00:00
|
|
|
}
|
|
|
|
|
2006-08-29 19:09:43 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_width
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Retrieves the actors width ignoring any scaling factors.
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
|
|
|
* Return value: The actor width in pixels
|
|
|
|
**/
|
|
|
|
guint
|
|
|
|
clutter_actor_get_width (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-13 23:24:59 +00:00
|
|
|
clutter_actor_query_coords (self, &box);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
return CLUTTER_UNITS_TO_DEVICE (box.x2 - box.x1);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2007-11-28 15:31:41 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_widthu
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Retrieves the actors width ignoring any scaling factors.
|
|
|
|
*
|
|
|
|
* Return value: The actor width in #ClutterUnit
|
|
|
|
*
|
|
|
|
* since: 0.6
|
|
|
|
**/
|
|
|
|
ClutterUnit
|
|
|
|
clutter_actor_get_widthu (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
|
|
|
|
|
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
|
|
|
return box.x2 - box.x1;
|
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_height
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Retrieves the actors height ignoring any scaling factors.
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2006-06-13 13:17:45 +00:00
|
|
|
* Return value: The actor height in pixels
|
|
|
|
**/
|
|
|
|
guint
|
|
|
|
clutter_actor_get_height (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-06-13 23:24:59 +00:00
|
|
|
clutter_actor_query_coords (self, &box);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
return CLUTTER_UNITS_TO_DEVICE (box.y2 - box.y1);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2007-11-28 15:31:41 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_heightu
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Retrieves the actors height ignoring any scaling factors.
|
|
|
|
*
|
|
|
|
* Return value: The actor height in #ClutterUnit
|
|
|
|
*
|
|
|
|
* since: 0.6
|
|
|
|
**/
|
|
|
|
ClutterUnit
|
|
|
|
clutter_actor_get_heightu (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
|
|
|
|
|
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
|
|
|
return box.y2 - box.y1;
|
|
|
|
}
|
|
|
|
|
2007-01-04 19:56:01 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_width
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @width: Requested new width for actor
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2007-01-04 19:56:01 +00:00
|
|
|
* Requests a new width for actor
|
|
|
|
*
|
2007-11-28 15:31:41 +00:00
|
|
|
* since: 0.2
|
2007-01-04 19:56:01 +00:00
|
|
|
**/
|
|
|
|
void
|
2007-11-15 17:35:47 +00:00
|
|
|
clutter_actor_set_width (ClutterActor *self,
|
|
|
|
guint width)
|
2007-01-04 19:56:01 +00:00
|
|
|
{
|
2007-11-15 17:35:47 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_set_size_internal (self, width, -1);
|
2007-01-04 19:56:01 +00:00
|
|
|
}
|
|
|
|
|
2007-11-28 15:31:41 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_widthu
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @width: Requested new width for actor in #ClutterUnit
|
|
|
|
*
|
|
|
|
* Requests a new width for actor
|
|
|
|
*
|
|
|
|
* since: 0.6
|
|
|
|
**/
|
|
|
|
void
|
|
|
|
clutter_actor_set_widthu (ClutterActor *self,
|
|
|
|
ClutterUnit width)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_set_size_internalu (self, width, -1);
|
|
|
|
}
|
|
|
|
|
2007-01-04 19:56:01 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_height
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @height: Requested new height for actor
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2007-01-04 19:56:01 +00:00
|
|
|
* Requests a new height for actor
|
|
|
|
*
|
2007-11-28 15:31:41 +00:00
|
|
|
* since: 0.2
|
2007-01-04 19:56:01 +00:00
|
|
|
**/
|
|
|
|
void
|
2007-11-15 17:35:47 +00:00
|
|
|
clutter_actor_set_height (ClutterActor *self,
|
|
|
|
guint height)
|
2007-01-04 19:56:01 +00:00
|
|
|
{
|
2007-11-15 17:35:47 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_set_size_internal (self, -1, height);
|
2007-01-04 19:56:01 +00:00
|
|
|
}
|
|
|
|
|
2007-11-28 15:31:41 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_heightu
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @height: Requested new height for actor in #ClutterUnit
|
|
|
|
*
|
|
|
|
* Requests a new height for actor
|
|
|
|
*
|
|
|
|
* since: 0.6
|
|
|
|
**/
|
|
|
|
void
|
|
|
|
clutter_actor_set_heightu (ClutterActor *self,
|
|
|
|
ClutterUnit height)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_set_size_internalu (self, -1, height);
|
|
|
|
}
|
|
|
|
|
2007-11-15 17:35:47 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_x:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @x: the actors position on the X axis
|
|
|
|
*
|
|
|
|
* Sets the actor's x position relative to its parent.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_x (ClutterActor *self,
|
|
|
|
gint x)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_set_position (self,
|
|
|
|
x,
|
|
|
|
clutter_actor_get_y (self));
|
|
|
|
}
|
|
|
|
|
2007-11-28 15:31:41 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_xu:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @x: the actors position on the X axis in #ClutterUnit
|
|
|
|
*
|
|
|
|
* Sets the actor's x position relative to its parent.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_xu (ClutterActor *self,
|
|
|
|
ClutterUnit x)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_set_positionu (self,
|
|
|
|
x,
|
|
|
|
clutter_actor_get_yu (self));
|
|
|
|
}
|
|
|
|
|
2007-11-15 17:35:47 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_y:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @y: the actors position on the Y axis
|
|
|
|
*
|
|
|
|
* Sets the actor's y position relative to its parent.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_y (ClutterActor *self,
|
|
|
|
gint y)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_set_position (self,
|
|
|
|
clutter_actor_get_x (self),
|
|
|
|
y);
|
|
|
|
}
|
2007-01-04 19:56:01 +00:00
|
|
|
|
2007-11-28 15:31:41 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_yu:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @y: the actors position on the Y axis in #ClutterUnit
|
|
|
|
*
|
|
|
|
* Sets the actor's y position relative to its parent.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_yu (ClutterActor *self,
|
|
|
|
ClutterUnit y)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_set_positionu (self,
|
|
|
|
clutter_actor_get_xu (self),
|
|
|
|
y);
|
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_x
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Retrieves the actors x position relative to any parent.
|
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Return value: The actor x position in pixels ignoring any tranforms
|
|
|
|
* (i.e scaling, rotation).
|
2006-06-13 13:17:45 +00:00
|
|
|
**/
|
|
|
|
gint
|
|
|
|
clutter_actor_get_x (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
|
|
|
|
|
2007-06-13 23:24:59 +00:00
|
|
|
clutter_actor_query_coords (self, &box);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
return CLUTTER_UNITS_TO_DEVICE (box.x1);
|
2007-05-18 07:30:06 +00:00
|
|
|
}
|
|
|
|
|
2007-11-28 15:31:41 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_xu
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Retrieves the actors x position relative to any parent, in #ClutterUnit
|
|
|
|
*
|
|
|
|
* Return value: The actor x position in #ClutterUnit ignoring any tranforms
|
|
|
|
* (i.e scaling, rotation).
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
**/
|
|
|
|
ClutterUnit
|
|
|
|
clutter_actor_get_xu (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
|
|
|
|
|
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
|
|
|
return box.x1;
|
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_y:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Retrieves the actors y position relative to any parent.
|
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Return value: The actor y position in pixels ignoring any tranforms
|
|
|
|
* (i.e scaling, rotation).
|
2006-06-13 13:17:45 +00:00
|
|
|
**/
|
|
|
|
gint
|
|
|
|
clutter_actor_get_y (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
|
|
|
|
|
2007-06-13 23:24:59 +00:00
|
|
|
clutter_actor_query_coords (self, &box);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
return CLUTTER_UNITS_TO_DEVICE (box.y1);
|
2007-05-18 07:30:06 +00:00
|
|
|
}
|
|
|
|
|
2007-11-28 15:31:41 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_yu:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Retrieves the actors y position relative to any parent, in #ClutterUnit
|
|
|
|
*
|
|
|
|
* Return value: The actor y position in #ClutterUnit ignoring any tranforms
|
|
|
|
* (i.e scaling, rotation).
|
|
|
|
**/
|
|
|
|
ClutterUnit
|
|
|
|
clutter_actor_get_yu (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorBox box;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
|
|
|
|
|
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
|
|
|
return box.y1;
|
|
|
|
}
|
|
|
|
|
2006-08-29 19:09:43 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_scalex:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @scale_x: #ClutterFixed factor to scale actor by horizontally.
|
|
|
|
* @scale_y: #ClutterFixed factor to scale actor by vertically.
|
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Scales an actor with fixed point parameters.
|
2006-08-29 19:09:43 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_scalex (ClutterActor *self,
|
|
|
|
ClutterFixed scale_x,
|
|
|
|
ClutterFixed scale_y)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
2007-09-27 21:38:38 +00:00
|
|
|
g_object_ref (self);
|
|
|
|
g_object_freeze_notify (G_OBJECT (self));
|
|
|
|
|
2007-10-02 14:45:40 +00:00
|
|
|
self->priv->scale_x = scale_x;
|
2007-09-27 21:38:38 +00:00
|
|
|
g_object_notify (G_OBJECT (self), "scale-x");
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-10-02 14:45:40 +00:00
|
|
|
self->priv->scale_y = scale_y;
|
2007-09-27 21:38:38 +00:00
|
|
|
g_object_notify (G_OBJECT (self), "scale-y");
|
|
|
|
|
|
|
|
g_object_thaw_notify (G_OBJECT (self));
|
|
|
|
g_object_unref (self);
|
|
|
|
|
2006-08-29 19:09:43 +00:00
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (self))
|
|
|
|
clutter_actor_queue_redraw (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_set_scale:
|
|
|
|
* @self: A #ClutterActor
|
2007-06-22 15:16:40 +00:00
|
|
|
* @scale_x: double factor to scale actor by horizontally.
|
|
|
|
* @scale_y: double factor to scale actor by vertically.
|
2006-12-13 18:12:09 +00:00
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Scales an actor with floating point parameters.
|
2006-12-13 18:12:09 +00:00
|
|
|
*
|
|
|
|
* Since: 0.2
|
2006-08-29 19:09:43 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_scale (ClutterActor *self,
|
|
|
|
double scale_x,
|
|
|
|
double scale_y)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
clutter_actor_set_scalex (self,
|
|
|
|
CLUTTER_FLOAT_TO_FIXED (scale_x),
|
|
|
|
CLUTTER_FLOAT_TO_FIXED (scale_y));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-12-12 20:20:04 +00:00
|
|
|
* clutter_actor_get_scalex:
|
2006-08-29 19:09:43 +00:00
|
|
|
* @self: A #ClutterActor
|
2007-06-22 15:16:40 +00:00
|
|
|
* @scale_x: Location to store horizonal fixed scale factor if non NULL.
|
|
|
|
* @scale_y: Location to store vertical fixed scale factor if non NULL.
|
2006-08-29 19:09:43 +00:00
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Retrieves an actors scale in fixed point.
|
2006-12-12 20:20:04 +00:00
|
|
|
*
|
|
|
|
* Since: 0.2
|
2006-08-29 19:09:43 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_get_scalex (ClutterActor *self,
|
|
|
|
ClutterFixed *scale_x,
|
|
|
|
ClutterFixed *scale_y)
|
|
|
|
{
|
|
|
|
if (scale_x)
|
|
|
|
*scale_x = self->priv->scale_x;
|
|
|
|
|
|
|
|
if (scale_y)
|
|
|
|
*scale_y = self->priv->scale_y;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-12-12 20:20:04 +00:00
|
|
|
* clutter_actor_get_scale:
|
2006-08-29 19:09:43 +00:00
|
|
|
* @self: A #ClutterActor
|
2007-06-22 15:16:40 +00:00
|
|
|
* @scale_x: Location to store horizonal float scale factor if non NULL.
|
|
|
|
* @scale_y: Location to store vertical float scale factor if non NULL.
|
2006-08-29 19:09:43 +00:00
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Retrieves an actors scale in floating point.
|
2006-12-12 20:20:04 +00:00
|
|
|
*
|
|
|
|
* Since: 0.2
|
2006-08-29 19:09:43 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_get_scale (ClutterActor *self,
|
2006-11-20 12:02:24 +00:00
|
|
|
gdouble *scale_x,
|
|
|
|
gdouble *scale_y)
|
2006-08-29 19:09:43 +00:00
|
|
|
{
|
|
|
|
if (scale_x)
|
2006-11-20 12:02:24 +00:00
|
|
|
*scale_x = CLUTTER_FIXED_TO_FLOAT (self->priv->scale_x);
|
2006-08-29 19:09:43 +00:00
|
|
|
|
|
|
|
if (scale_y)
|
2006-11-20 12:02:24 +00:00
|
|
|
*scale_y = CLUTTER_FIXED_TO_FLOAT (self->priv->scale_y);
|
2006-08-29 19:09:43 +00:00
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_opacity:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @opacity: New opacity value for actor.
|
|
|
|
*
|
2007-12-09 08:47:11 +00:00
|
|
|
* Sets the actors opacity, with zero being completely transparent and
|
|
|
|
* 255 (0xff) as fully opaque.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_opacity (ClutterActor *self,
|
2007-05-22 09:31:40 +00:00
|
|
|
guint8 opacity)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
self->priv->opacity = opacity;
|
|
|
|
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (self))
|
|
|
|
clutter_actor_queue_redraw (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_get_opacity:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Retrieves the actors opacity.
|
|
|
|
*
|
|
|
|
* Return value: The actor opacity value.
|
|
|
|
*/
|
|
|
|
guint8
|
|
|
|
clutter_actor_get_opacity (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActor *parent;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
|
|
|
|
|
|
|
|
parent = self->priv->parent_actor;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-01-04 19:56:01 +00:00
|
|
|
/* Factor in the actual actors opacity with parents */
|
2006-06-13 13:17:45 +00:00
|
|
|
if (parent && clutter_actor_get_opacity (parent) != 0xff)
|
2007-01-07 00:36:41 +00:00
|
|
|
return (clutter_actor_get_opacity(parent) * self->priv->opacity) / 0xff;
|
2006-06-13 13:17:45 +00:00
|
|
|
|
|
|
|
return self->priv->opacity;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_set_name:
|
|
|
|
* @self: A #ClutterActor
|
2006-07-06 18:55:46 +00:00
|
|
|
* @name: Textual tag to apply to actor
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
|
|
|
* Sets a textual tag to the actor.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_name (ClutterActor *self,
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
const gchar *name)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-11-20 12:02:24 +00:00
|
|
|
g_object_ref (self);
|
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
g_free (self->priv->name);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-11-20 12:02:24 +00:00
|
|
|
if (name && name[0] != '\0')
|
|
|
|
self->priv->name = g_strdup(name);
|
|
|
|
|
|
|
|
g_object_notify (G_OBJECT (self), "name");
|
|
|
|
g_object_unref (self);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_get_name:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
2006-06-22 13:05:45 +00:00
|
|
|
* Retrieves the name of @self.
|
|
|
|
*
|
2006-06-13 13:17:45 +00:00
|
|
|
* Return value: pointer to textual tag for the actor. The
|
|
|
|
* returned string is owned by the actor and should not
|
|
|
|
* be modified or freed.
|
|
|
|
*/
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
G_CONST_RETURN gchar *
|
2006-06-13 13:17:45 +00:00
|
|
|
clutter_actor_get_name (ClutterActor *self)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
return self->priv->name;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-11-14 11:43:18 +00:00
|
|
|
* clutter_actor_get_gid:
|
2006-06-13 13:17:45 +00:00
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
2006-06-21 23:02:20 +00:00
|
|
|
* Retrieves the unique id for @self.
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2006-06-13 13:17:45 +00:00
|
|
|
* Return value: Globally unique value for object instance.
|
2007-11-14 11:43:18 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
guint32
|
2007-11-14 11:43:18 +00:00
|
|
|
clutter_actor_get_gid (ClutterActor *self)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
return self->priv->id;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_set_depth:
|
|
|
|
* @self: a #ClutterActor
|
2006-06-21 23:02:20 +00:00
|
|
|
* @depth: Z co-ord
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Sets the Z co-ordinate of @self to @depth. The Units of which are dependant
|
2007-10-12 08:17:00 +00:00
|
|
|
* on the perspective setup.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_depth (ClutterActor *self,
|
2006-11-20 12:02:24 +00:00
|
|
|
gint depth)
|
2007-11-29 13:47:37 +00:00
|
|
|
{
|
|
|
|
clutter_actor_set_depthu (self, CLUTTER_UNITS_FROM_DEVICE (depth));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_set_depthu:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @depth: Z co-ord in #ClutterUnit
|
|
|
|
*
|
|
|
|
* Sets the Z co-ordinate of @self to @depth in #ClutterUnit, the Units of
|
|
|
|
* which are dependant on the perspective setup.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_depthu (ClutterActor *self,
|
|
|
|
ClutterUnit depth)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2006-12-12 20:20:04 +00:00
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
priv = self->priv;
|
2007-11-28 12:23:31 +00:00
|
|
|
|
2007-10-12 12:42:54 +00:00
|
|
|
if (priv->z != depth)
|
|
|
|
{
|
|
|
|
/* Sets Z value. - FIXME: should invert ?*/
|
|
|
|
priv->z = depth;
|
|
|
|
|
|
|
|
if (priv->parent_actor && CLUTTER_IS_CONTAINER (priv->parent_actor))
|
|
|
|
{
|
|
|
|
ClutterContainer *parent;
|
|
|
|
|
|
|
|
/* We need to resort the container stacking order as to
|
|
|
|
* correctly render alpha values.
|
|
|
|
*
|
|
|
|
* FIXME: This is sub optimal. maybe queue the the sort
|
|
|
|
* before stacking
|
|
|
|
*/
|
|
|
|
parent = CLUTTER_CONTAINER (priv->parent_actor);
|
|
|
|
clutter_container_sort_depth_order (parent);
|
|
|
|
}
|
2006-12-12 20:20:04 +00:00
|
|
|
|
2007-10-12 12:42:54 +00:00
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (self))
|
|
|
|
clutter_actor_queue_redraw (self);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-10-12 12:42:54 +00:00
|
|
|
g_object_notify (G_OBJECT (self), "depth");
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_get_depth:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
*
|
|
|
|
* Retrieves the depth of @self.
|
|
|
|
*
|
|
|
|
* Return value: the depth of a #ClutterActor
|
|
|
|
*/
|
|
|
|
gint
|
|
|
|
clutter_actor_get_depth (ClutterActor *self)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), -1);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-11-29 13:47:37 +00:00
|
|
|
return CLUTTER_UNITS_TO_DEVICE (self->priv->z);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_get_depthu:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
*
|
|
|
|
* Retrieves the depth of @self.
|
|
|
|
*
|
|
|
|
* Return value: the depth of a #ClutterActor in #ClutterUnit
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
ClutterUnit
|
|
|
|
clutter_actor_get_depthu (ClutterActor *self)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), -1);
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
return self->priv->z;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-11-18 15:36:04 +00:00
|
|
|
* clutter_actor_set_rotationx:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @axis: the axis of rotation
|
2007-11-19 11:43:20 +00:00
|
|
|
* @angle: the angle of rotation
|
2007-11-18 15:36:04 +00:00
|
|
|
* @x: X coordinate of the rotation center
|
|
|
|
* @y: Y coordinate of the rotation center
|
|
|
|
* @z: Z coordinate of the rotation center
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2007-11-18 15:36:04 +00:00
|
|
|
* Sets the rotation angle of @self around the given axis.
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2007-11-18 15:36:04 +00:00
|
|
|
* This function is the fixed point variant of clutter_actor_set_rotation().
|
2007-06-26 11:35:33 +00:00
|
|
|
*
|
2007-11-18 15:36:04 +00:00
|
|
|
* Since: 0.6
|
2007-06-26 11:35:33 +00:00
|
|
|
*/
|
|
|
|
void
|
2007-11-18 15:36:04 +00:00
|
|
|
clutter_actor_set_rotationx (ClutterActor *self,
|
|
|
|
ClutterRotateAxis axis,
|
2007-11-19 11:43:20 +00:00
|
|
|
ClutterFixed angle,
|
2007-11-18 15:36:04 +00:00
|
|
|
gint x,
|
|
|
|
gint y,
|
|
|
|
gint z)
|
2007-06-26 11:35:33 +00:00
|
|
|
{
|
2007-11-18 15:36:04 +00:00
|
|
|
ClutterActorPrivate *priv;
|
2007-06-26 11:35:33 +00:00
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-11-18 15:36:04 +00:00
|
|
|
priv = self->priv;
|
2007-06-26 11:35:33 +00:00
|
|
|
|
2007-11-18 15:36:04 +00:00
|
|
|
switch (axis)
|
|
|
|
{
|
|
|
|
case CLUTTER_X_AXIS:
|
|
|
|
priv->rxang = angle;
|
2007-11-29 13:47:37 +00:00
|
|
|
priv->rxy = CLUTTER_UNITS_FROM_DEVICE (y);
|
|
|
|
priv->rxz = CLUTTER_UNITS_FROM_DEVICE (z);
|
2007-11-18 15:36:04 +00:00
|
|
|
break;
|
2007-06-26 11:35:33 +00:00
|
|
|
|
2007-11-18 15:36:04 +00:00
|
|
|
case CLUTTER_Y_AXIS:
|
|
|
|
priv->ryang = angle;
|
2007-11-29 13:47:37 +00:00
|
|
|
priv->ryx = CLUTTER_UNITS_FROM_DEVICE (x);
|
|
|
|
priv->ryz = CLUTTER_UNITS_FROM_DEVICE (z);
|
2007-11-18 15:36:04 +00:00
|
|
|
break;
|
2007-06-26 11:35:33 +00:00
|
|
|
|
2007-11-18 15:36:04 +00:00
|
|
|
case CLUTTER_Z_AXIS:
|
|
|
|
priv->rzang = angle;
|
2007-11-29 13:47:37 +00:00
|
|
|
priv->rzx = CLUTTER_UNITS_FROM_DEVICE (x);
|
|
|
|
priv->rzy = CLUTTER_UNITS_FROM_DEVICE (y);
|
2007-11-18 15:36:04 +00:00
|
|
|
break;
|
|
|
|
}
|
2007-06-26 11:35:33 +00:00
|
|
|
|
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (self))
|
|
|
|
clutter_actor_queue_redraw (self);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2007-11-18 15:36:04 +00:00
|
|
|
* clutter_actor_set_rotation:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @axis: the axis of rotation
|
2007-11-19 11:43:20 +00:00
|
|
|
* @angle: the angle of rotation
|
2007-11-18 15:36:04 +00:00
|
|
|
* @x: X coordinate of the rotation center
|
|
|
|
* @y: Y coordinate of the rotation center
|
|
|
|
* @z: Z coordinate of the rotation center
|
2007-06-26 11:35:33 +00:00
|
|
|
*
|
2007-11-18 15:36:04 +00:00
|
|
|
* Sets the rotation angle of @self around the given axis.
|
2007-07-24 17:34:06 +00:00
|
|
|
*
|
2007-12-17 17:45:49 +00:00
|
|
|
* The rotation center coordinates used depend on the value of @axis:
|
2007-11-18 15:36:04 +00:00
|
|
|
* <itemizedlist>
|
|
|
|
* <listitem><para>%CLUTTER_X_AXIS requires @y and @z</para></listitem>
|
|
|
|
* <listitem><para>%CLUTTER_Y_AXIS requires @x and @z</para></listitem>
|
|
|
|
* <listitem><para>%CLUTTER_Z_AXIS requires @x and @y</para></listitem>
|
|
|
|
* </itemizedlist>
|
2007-07-24 17:34:06 +00:00
|
|
|
*
|
2007-12-17 17:45:49 +00:00
|
|
|
* The rotation coordinates are relative to the anchor point of the
|
|
|
|
* actor, set using clutter_actor_set_anchor_point(). If no anchor
|
|
|
|
* point is set, the upper left corner is assumed as the origin.
|
|
|
|
*
|
2007-11-18 15:36:04 +00:00
|
|
|
* Since: 0.6
|
2007-06-26 11:35:33 +00:00
|
|
|
*/
|
2007-11-18 15:36:04 +00:00
|
|
|
void
|
|
|
|
clutter_actor_set_rotation (ClutterActor *self,
|
|
|
|
ClutterRotateAxis axis,
|
2007-11-19 11:43:20 +00:00
|
|
|
gdouble angle,
|
2007-11-18 15:36:04 +00:00
|
|
|
gint x,
|
|
|
|
gint y,
|
|
|
|
gint z)
|
2007-06-26 11:35:33 +00:00
|
|
|
{
|
2007-11-18 15:36:04 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-07-24 17:34:06 +00:00
|
|
|
|
2007-11-19 11:43:20 +00:00
|
|
|
clutter_actor_set_rotationx (self, axis,
|
|
|
|
CLUTTER_FLOAT_TO_FIXED (angle),
|
2007-11-18 15:36:04 +00:00
|
|
|
x, y, z);
|
2007-06-26 11:35:33 +00:00
|
|
|
}
|
|
|
|
|
2007-08-01 13:11:43 +00:00
|
|
|
/**
|
2007-11-18 15:36:04 +00:00
|
|
|
* clutter_actor_get_rotationx:
|
2007-08-01 13:11:43 +00:00
|
|
|
* @self: a #ClutterActor
|
2007-11-18 15:36:04 +00:00
|
|
|
* @axis: the axis of rotation
|
|
|
|
* @x: return value for the X coordinate of the center of rotation
|
|
|
|
* @y: return value for the Y coordinate of the center of rotation
|
|
|
|
* @z: return value for the Z coordinate of the center of rotation
|
2007-08-01 13:11:43 +00:00
|
|
|
*
|
2007-11-18 15:36:04 +00:00
|
|
|
* Retrieves the angle and center of rotation on the given axis,
|
|
|
|
* set using clutter_actor_set_rotation().
|
2007-08-01 13:11:43 +00:00
|
|
|
*
|
2007-11-18 15:36:04 +00:00
|
|
|
* This function is the fixed point variant of clutter_actor_get_rotation().
|
2007-07-24 17:34:06 +00:00
|
|
|
*
|
2007-11-18 15:36:04 +00:00
|
|
|
* Return value: the angle of rotation as a fixed point value.
|
2007-07-24 17:34:06 +00:00
|
|
|
*
|
2007-11-18 15:36:04 +00:00
|
|
|
* Since: 0.6
|
2007-06-26 11:35:33 +00:00
|
|
|
*/
|
|
|
|
ClutterFixed
|
2007-11-18 15:36:04 +00:00
|
|
|
clutter_actor_get_rotationx (ClutterActor *self,
|
|
|
|
ClutterRotateAxis axis,
|
|
|
|
gint *x,
|
|
|
|
gint *y,
|
|
|
|
gint *z)
|
2007-06-26 11:35:33 +00:00
|
|
|
{
|
2007-11-18 15:36:04 +00:00
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
ClutterFixed retval = 0;
|
|
|
|
|
2007-06-26 11:35:33 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0);
|
2007-08-01 13:11:43 +00:00
|
|
|
|
2007-11-18 15:36:04 +00:00
|
|
|
priv = self->priv;
|
2007-06-26 11:35:33 +00:00
|
|
|
|
2007-11-18 15:36:04 +00:00
|
|
|
switch (axis)
|
|
|
|
{
|
|
|
|
case CLUTTER_X_AXIS:
|
|
|
|
retval = priv->rxang;
|
|
|
|
if (y)
|
2007-11-29 13:47:37 +00:00
|
|
|
*y = CLUTTER_UNITS_TO_DEVICE (priv->rxy);
|
2007-11-18 15:36:04 +00:00
|
|
|
if (z)
|
2007-11-29 13:47:37 +00:00
|
|
|
*z = CLUTTER_UNITS_TO_DEVICE (priv->rxz);
|
2007-11-18 15:36:04 +00:00
|
|
|
break;
|
2007-08-01 13:11:43 +00:00
|
|
|
|
2007-11-18 15:36:04 +00:00
|
|
|
case CLUTTER_Y_AXIS:
|
|
|
|
retval = priv->ryang;
|
|
|
|
if (x)
|
2007-11-29 13:47:37 +00:00
|
|
|
*x = CLUTTER_UNITS_TO_DEVICE (priv->ryx);
|
2007-11-18 15:36:04 +00:00
|
|
|
if (z)
|
2007-11-29 13:47:37 +00:00
|
|
|
*z = CLUTTER_UNITS_TO_DEVICE (priv->ryz);
|
2007-11-18 15:36:04 +00:00
|
|
|
break;
|
2007-08-01 13:11:43 +00:00
|
|
|
|
2007-11-18 15:36:04 +00:00
|
|
|
case CLUTTER_Z_AXIS:
|
|
|
|
retval = priv->rzang;
|
|
|
|
if (x)
|
2007-11-29 13:47:37 +00:00
|
|
|
*x = CLUTTER_UNITS_TO_DEVICE (priv->rzx);
|
2007-11-18 15:36:04 +00:00
|
|
|
if (y)
|
2007-11-29 13:47:37 +00:00
|
|
|
*y = CLUTTER_UNITS_TO_DEVICE (priv->rzy);
|
2007-11-18 15:36:04 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return retval;
|
2007-06-26 11:35:33 +00:00
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2007-08-01 13:11:43 +00:00
|
|
|
/**
|
2007-11-18 15:36:04 +00:00
|
|
|
* clutter_actor_get_rotation:
|
2007-08-01 13:11:43 +00:00
|
|
|
* @self: a #ClutterActor
|
2007-11-18 15:36:04 +00:00
|
|
|
* @axis: the axis of rotation
|
|
|
|
* @x: return value for the X coordinate of the center of rotation
|
|
|
|
* @y: return value for the Y coordinate of the center of rotation
|
|
|
|
* @z: return value for the Z coordinate of the center of rotation
|
2007-08-01 13:11:43 +00:00
|
|
|
*
|
2007-11-18 15:36:04 +00:00
|
|
|
* Retrieves the angle and center of rotation on the given axis,
|
|
|
|
* set using clutter_actor_set_angle().
|
2007-08-01 13:11:43 +00:00
|
|
|
*
|
2007-12-17 17:45:49 +00:00
|
|
|
* The coordinates of the center returned by this function depend on
|
|
|
|
* the axis passed.
|
2007-08-01 13:11:43 +00:00
|
|
|
*
|
2007-11-18 15:36:04 +00:00
|
|
|
* Return value: the angle of rotation.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
2007-08-01 13:11:43 +00:00
|
|
|
*/
|
|
|
|
gdouble
|
2007-11-18 15:36:04 +00:00
|
|
|
clutter_actor_get_rotation (ClutterActor *self,
|
|
|
|
ClutterRotateAxis axis,
|
|
|
|
gint *x,
|
|
|
|
gint *y,
|
|
|
|
gint *z)
|
2007-08-01 13:11:43 +00:00
|
|
|
{
|
2007-11-18 15:36:04 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 0.0);
|
2007-08-01 13:11:43 +00:00
|
|
|
|
2007-11-18 15:36:04 +00:00
|
|
|
return CLUTTER_FIXED_TO_FLOAT (clutter_actor_get_rotationx (self,
|
|
|
|
axis,
|
|
|
|
x, y, z));
|
2007-08-01 13:11:43 +00:00
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_clip:
|
|
|
|
* @self: A #ClutterActor
|
2006-06-21 23:02:20 +00:00
|
|
|
* @xoff: X offset of the clip rectangle
|
|
|
|
* @yoff: Y offset of the clip rectangle
|
|
|
|
* @width: Width of the clip rectangle
|
|
|
|
* @height: Height of the clip rectangle
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2007-12-17 15:08:43 +00:00
|
|
|
* Sets clip area in pixels for @self. The clip area is always computed
|
|
|
|
* from the upper left corner of the actor, even if the anchor point is
|
|
|
|
* set otherwise.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_clip (ClutterActor *self,
|
2007-10-12 08:17:00 +00:00
|
|
|
gint xoff,
|
|
|
|
gint yoff,
|
|
|
|
gint width,
|
2006-07-06 18:12:19 +00:00
|
|
|
gint height)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
|
|
|
ClutterGeometry *clip;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
clip = &(self->priv->clip);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
clip->x = xoff;
|
|
|
|
clip->y = yoff;
|
|
|
|
clip->width = width;
|
|
|
|
clip->height = height;
|
|
|
|
|
|
|
|
self->priv->has_clip = TRUE;
|
2006-07-06 18:12:19 +00:00
|
|
|
|
|
|
|
g_object_notify (G_OBJECT (self), "has-clip");
|
|
|
|
g_object_notify (G_OBJECT (self), "clip");
|
2007-10-12 08:17:00 +00:00
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_remove_clip
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* Removes clip area in pixels from @self.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_remove_clip (ClutterActor *self)
|
|
|
|
{
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
self->priv->has_clip = FALSE;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-07-06 18:12:19 +00:00
|
|
|
g_object_notify (G_OBJECT (self), "has-clip");
|
2007-10-12 08:17:00 +00:00
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-07-06 18:12:19 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_has_clip:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
*
|
|
|
|
* Gets whether the actor has a clip set or not.
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2006-07-06 18:12:19 +00:00
|
|
|
* Return value: %TRUE if the actor has a clip set.
|
2006-07-06 18:55:46 +00:00
|
|
|
*
|
|
|
|
* Since: 0.1.1
|
2006-07-06 18:12:19 +00:00
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_actor_has_clip (ClutterActor *self)
|
|
|
|
{
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
|
|
|
|
|
|
|
|
return self->priv->has_clip;
|
|
|
|
}
|
|
|
|
|
2007-11-15 17:35:47 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_get_clip:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @xoff: return location for the X offset of the clip rectangle, or %NULL
|
|
|
|
* @yoff: return location for the Y offset of the clip rectangle, or %NULL
|
|
|
|
* @width: return location for the width of the clip rectangle, or %NULL
|
|
|
|
* @height: return location for the height of the clip rectangle, or %NULL
|
|
|
|
*
|
|
|
|
* Gets the clip area for @self, in pixels.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_get_clip (ClutterActor *self,
|
|
|
|
gint *xoff,
|
|
|
|
gint *yoff,
|
|
|
|
gint *width,
|
|
|
|
gint *height)
|
|
|
|
{
|
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
ClutterGeometry clip = { 0, };
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
priv = self->priv;
|
|
|
|
|
|
|
|
if (!priv->has_clip)
|
|
|
|
return;
|
|
|
|
|
|
|
|
clip = priv->clip;
|
|
|
|
|
|
|
|
if (xoff)
|
|
|
|
*xoff = clip.x;
|
|
|
|
if (yoff)
|
|
|
|
*yoff = clip.y;
|
|
|
|
if (width)
|
|
|
|
*width = clip.width;
|
|
|
|
if (height)
|
|
|
|
*height = clip.height;
|
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_parent:
|
|
|
|
* @self: A #ClutterActor
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
* @parent: A new #ClutterActor parent
|
2006-06-13 13:17:45 +00:00
|
|
|
*
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
* Sets the parent of @self to @parent. The opposite function is
|
|
|
|
* clutter_actor_unparent().
|
2007-10-12 08:17:00 +00:00
|
|
|
*
|
2007-06-22 15:16:40 +00:00
|
|
|
* This function should not be used by applications but by custom
|
|
|
|
* 'composite' actor sub classes.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_parent (ClutterActor *self,
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
ClutterActor *parent)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2007-10-08 16:18:33 +00:00
|
|
|
ClutterMainContext *clutter_context;
|
|
|
|
|
|
|
|
clutter_context = clutter_context_get_default ();
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (parent));
|
|
|
|
g_return_if_fail (self != parent);
|
2007-10-08 16:18:33 +00:00
|
|
|
g_return_if_fail (clutter_context != NULL);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
if (self->priv->parent_actor != NULL)
|
|
|
|
{
|
|
|
|
g_warning ("Cannot set a parent on an actor which has a parent.\n"
|
|
|
|
"You must use clutter_actor_unparent() first.\n");
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (CLUTTER_PRIVATE_FLAGS (self) & CLUTTER_ACTOR_IS_TOPLEVEL)
|
|
|
|
{
|
|
|
|
g_warning ("Cannot set a parent on a toplevel actor\n");
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
g_hash_table_insert (clutter_context->actor_hash,
|
2007-11-14 11:43:18 +00:00
|
|
|
GUINT_TO_POINTER (clutter_actor_get_gid (self)),
|
2007-10-08 16:18:33 +00:00
|
|
|
(gpointer)self);
|
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
g_object_ref_sink (self);
|
2006-06-13 13:17:45 +00:00
|
|
|
self->priv->parent_actor = parent;
|
2006-11-20 12:02:24 +00:00
|
|
|
g_signal_emit (self, actor_signals[PARENT_SET], 0, NULL);
|
|
|
|
|
|
|
|
if (CLUTTER_ACTOR_IS_REALIZED (self->priv->parent_actor))
|
|
|
|
clutter_actor_realize (self);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
if (CLUTTER_ACTOR_IS_VISIBLE (self->priv->parent_actor) &&
|
|
|
|
CLUTTER_ACTOR_IS_VISIBLE (self))
|
2006-11-20 12:02:24 +00:00
|
|
|
{
|
|
|
|
clutter_actor_queue_redraw (self);
|
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_get_parent:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
2006-06-21 23:02:20 +00:00
|
|
|
* Retrieves the parent of @self.
|
|
|
|
*
|
2006-06-13 13:17:45 +00:00
|
|
|
* Return Value: The #ClutterActor parent or NULL
|
|
|
|
*/
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
ClutterActor *
|
2006-06-13 13:17:45 +00:00
|
|
|
clutter_actor_get_parent (ClutterActor *self)
|
|
|
|
{
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), NULL);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
return self->priv->parent_actor;
|
|
|
|
}
|
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_unparent:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
*
|
|
|
|
* This function should not be used in applications. It should be called by
|
2007-08-13 17:01:07 +00:00
|
|
|
* implementations of container actors, to dissociate a child from the
|
|
|
|
* container.
|
2006-07-06 18:55:46 +00:00
|
|
|
*
|
|
|
|
* Since: 0.1.1
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_unparent (ClutterActor *self)
|
|
|
|
{
|
2006-11-20 12:02:24 +00:00
|
|
|
ClutterActor *old_parent;
|
2007-10-08 16:18:33 +00:00
|
|
|
ClutterMainContext *clutter_context;
|
|
|
|
|
|
|
|
clutter_context = clutter_context_get_default ();
|
2006-11-20 12:02:24 +00:00
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-10-08 16:18:33 +00:00
|
|
|
g_return_if_fail (clutter_context != NULL);
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
|
|
|
|
if (self->priv->parent_actor == NULL)
|
|
|
|
return;
|
|
|
|
|
2006-11-16 00:24:23 +00:00
|
|
|
/* just hide the actor if we are reparenting it */
|
|
|
|
if (CLUTTER_ACTOR_IS_REALIZED (self))
|
|
|
|
{
|
|
|
|
if (CLUTTER_PRIVATE_FLAGS (self) & CLUTTER_ACTOR_IN_REPARENT)
|
|
|
|
clutter_actor_hide (self);
|
|
|
|
else
|
|
|
|
clutter_actor_unrealize (self);
|
|
|
|
}
|
|
|
|
|
2006-11-20 12:02:24 +00:00
|
|
|
old_parent = self->priv->parent_actor;
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
self->priv->parent_actor = NULL;
|
2006-11-20 12:02:24 +00:00
|
|
|
g_signal_emit (self, actor_signals[PARENT_SET], 0, old_parent);
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
g_hash_table_remove (clutter_context->actor_hash,
|
2007-11-14 11:43:18 +00:00
|
|
|
GUINT_TO_POINTER (clutter_actor_get_gid (self)));
|
2007-10-08 16:18:33 +00:00
|
|
|
|
2006-07-06 Emmanuele Bassi <ebassi@openedhand.com>
Big rework of the actor management semantics: now ClutterActor
objects behave like GtkObjects - that is they have an initial
"floating" reference that gets "sunk" when they are added to
a ClutterGroup. This makes a group responsible of de-allocating
each actor inside it, so you just have to destroy the group to
get every child actor destroyed. Also, now you can do:
clutter_group_add (group, clutter_video_texture_new ());
without having to care about reference counting and explicit
unreffing.
* clutter/clutter-private.h: Add private flags setter and
getter macros.
* clutter/clutter-actor.h:
* clutter/clutter-actor.c: Clean up; inherit from GInitiallyUnowned;
add a "visible" property; add the "destroy", "show" and "hide"
signals to ClutterActorClass.
(clutter_actor_show), (clutter_actor_hide): Refactor a bit; emit
the "show" and "hide" signals.
(clutter_actor_set_property), (clutter_actor_get_property),
(clutter_actor_class_init): Implement the "visible" property; add
signals.
(clutter_actor_finalize): Do not leak the actor's name, if it is
set.
(clutter_actor_dispose): Emit the "destroy" signal here.
(clutter_actor_init): Sink the initial floating flag if needed.
(clutter_actor_destroy): Add a function to explicitely destroy
a ClutterActor.
(clutter_actor_set_parent), (clutter_actor_get_parent),
(clutter_actor_unparent): Make set_parent require a valid parent;
add unparent; check on get_parent; ref_sink the actor when
setting its parent and unref it when unsetting it. Probably we'll
need a function that does reparenting as unparent+set_parent in
a single shot.
* clutter/clutter-group.h:
* clutter/clutter-group.c (clutter_group_dispose),
(clutter_group_finalize), (clutter_group_add),
(clutter_group_remove): Make the group destroy its children when
disposing it; clean up, and use the newly-available
clutter_actor_unparent().
* clutter/clutter-stage.h:
* clutter/clutter-stage.c (clutter_stage_init): ClutterStage is
a top-level actor; clean up.
* clutter/clutter-video-texture.h:
* clutter/clutter-video-texture.c: Clean up.
* examples/super-oh.c:
* examples/test.c:
* examples/video-player.c:
* examples/test-text.c:
* examples/video-cube.c: Remove the g_object_unref() call, as the
ClutterStage object is destroyed on clutter_main_quit().
2006-07-06 17:52:57 +00:00
|
|
|
g_object_unref (self);
|
|
|
|
}
|
|
|
|
|
2006-11-16 00:24:23 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_reparent:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @new_parent: the new #ClutterActor parent
|
|
|
|
*
|
|
|
|
* This function resets the parent actor of @self. It is
|
|
|
|
* logically equivalent to calling clutter_actory_unparent()
|
|
|
|
* and clutter_actor_set_parent().
|
|
|
|
*
|
2006-11-20 12:02:24 +00:00
|
|
|
* Since: 0.2
|
2006-11-16 00:24:23 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_reparent (ClutterActor *self,
|
|
|
|
ClutterActor *new_parent)
|
|
|
|
{
|
2007-06-07 14:41:35 +00:00
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
|
2006-11-16 00:24:23 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (new_parent));
|
|
|
|
g_return_if_fail (self != new_parent);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2006-11-16 00:24:23 +00:00
|
|
|
if (CLUTTER_PRIVATE_FLAGS (self) & CLUTTER_ACTOR_IS_TOPLEVEL)
|
|
|
|
{
|
|
|
|
g_warning ("Cannot set a parent on a toplevel actor\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2007-06-07 14:41:35 +00:00
|
|
|
priv = self->priv;
|
|
|
|
|
|
|
|
if (priv->parent_actor != new_parent)
|
2006-11-16 00:24:23 +00:00
|
|
|
{
|
2006-11-20 12:02:24 +00:00
|
|
|
ClutterActor *old_parent;
|
|
|
|
|
2006-11-16 00:24:23 +00:00
|
|
|
/* if the actor and the parent have already been realized,
|
|
|
|
* mark the actor as reparenting, so that clutter_actor_unparent()
|
|
|
|
* just hides the actor instead of unrealize it.
|
|
|
|
*/
|
|
|
|
if (CLUTTER_ACTOR_IS_REALIZED (self) &&
|
|
|
|
CLUTTER_ACTOR_IS_REALIZED (new_parent))
|
|
|
|
{
|
|
|
|
CLUTTER_SET_PRIVATE_FLAGS (self, CLUTTER_ACTOR_IN_REPARENT);
|
|
|
|
}
|
|
|
|
|
2007-06-07 14:41:35 +00:00
|
|
|
old_parent = priv->parent_actor;
|
2006-11-20 12:02:24 +00:00
|
|
|
|
2006-11-16 00:24:23 +00:00
|
|
|
g_object_ref (self);
|
2007-06-07 14:41:35 +00:00
|
|
|
|
2007-06-22 15:16:40 +00:00
|
|
|
/* FIXME: below assumes only containers can reparent */
|
2007-10-17 16:43:46 +00:00
|
|
|
if (CLUTTER_IS_CONTAINER (priv->parent_actor))
|
|
|
|
clutter_container_remove_actor (CLUTTER_CONTAINER (priv->parent_actor),
|
|
|
|
self);
|
|
|
|
else
|
|
|
|
priv->parent_actor = NULL;
|
|
|
|
|
|
|
|
if (CLUTTER_IS_CONTAINER (new_parent))
|
|
|
|
clutter_container_add_actor (CLUTTER_CONTAINER (new_parent), self);
|
|
|
|
else
|
|
|
|
priv->parent_actor = new_parent;
|
2007-06-07 14:41:35 +00:00
|
|
|
|
2006-11-16 00:24:23 +00:00
|
|
|
g_object_unref (self);
|
|
|
|
|
|
|
|
if (CLUTTER_PRIVATE_FLAGS (self) & CLUTTER_ACTOR_IN_REPARENT)
|
|
|
|
{
|
|
|
|
CLUTTER_UNSET_PRIVATE_FLAGS (self, CLUTTER_ACTOR_IN_REPARENT);
|
|
|
|
|
|
|
|
clutter_actor_queue_redraw (self);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_raise:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @below: A #ClutterActor to raise above.
|
|
|
|
*
|
2006-06-21 23:02:20 +00:00
|
|
|
* Puts @self above @below.
|
2006-06-13 13:17:45 +00:00
|
|
|
* Both actors must have the same parent.
|
|
|
|
*/
|
|
|
|
void
|
2006-11-20 12:02:24 +00:00
|
|
|
clutter_actor_raise (ClutterActor *self,
|
|
|
|
ClutterActor *below)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2006-11-20 12:02:24 +00:00
|
|
|
ClutterActor *parent;
|
2006-06-13 13:17:45 +00:00
|
|
|
|
2006-11-20 12:02:24 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
parent = clutter_actor_get_parent (self);
|
|
|
|
if (!parent)
|
|
|
|
{
|
2007-08-13 17:01:07 +00:00
|
|
|
g_warning ("Actor of type %s is not inside a container",
|
2006-11-20 12:02:24 +00:00
|
|
|
g_type_name (G_OBJECT_TYPE (self)));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (below)
|
|
|
|
{
|
|
|
|
if (parent != clutter_actor_get_parent (below))
|
|
|
|
{
|
|
|
|
g_warning ("Actor of type %s is not in the same "
|
2007-08-13 17:01:07 +00:00
|
|
|
"container of actor of type %s",
|
2006-11-20 12:02:24 +00:00
|
|
|
g_type_name (G_OBJECT_TYPE (self)),
|
|
|
|
g_type_name (G_OBJECT_TYPE (below)));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-08-14 08:01:33 +00:00
|
|
|
clutter_container_raise_child (CLUTTER_CONTAINER (parent), self, below);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_lower:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
* @above: A #ClutterActor to lower below
|
|
|
|
*
|
2006-06-21 23:02:20 +00:00
|
|
|
* Puts @self below @above.
|
2006-06-13 13:17:45 +00:00
|
|
|
* Both actors must have the same parent.
|
|
|
|
*/
|
|
|
|
void
|
2006-11-20 12:02:24 +00:00
|
|
|
clutter_actor_lower (ClutterActor *self,
|
|
|
|
ClutterActor *above)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2006-11-20 12:02:24 +00:00
|
|
|
ClutterActor *parent;
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR(self));
|
|
|
|
|
2006-11-20 12:02:24 +00:00
|
|
|
parent = clutter_actor_get_parent (self);
|
|
|
|
if (!parent)
|
2006-06-13 13:17:45 +00:00
|
|
|
{
|
2007-08-13 17:01:07 +00:00
|
|
|
g_warning ("Actor of type %s is not inside a container",
|
2006-11-20 12:02:24 +00:00
|
|
|
g_type_name (G_OBJECT_TYPE (self)));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (above)
|
|
|
|
{
|
|
|
|
if (parent != clutter_actor_get_parent (above))
|
|
|
|
{
|
|
|
|
g_warning ("Actor of type %s is not in the same "
|
2007-08-13 17:01:07 +00:00
|
|
|
"container of actor of type %s",
|
2006-11-20 12:02:24 +00:00
|
|
|
g_type_name (G_OBJECT_TYPE (self)),
|
|
|
|
g_type_name (G_OBJECT_TYPE (above)));
|
|
|
|
return;
|
|
|
|
}
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
2007-08-14 08:01:33 +00:00
|
|
|
clutter_container_lower_child (CLUTTER_CONTAINER (parent), self, above);
|
2006-06-13 13:17:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2006-06-22 13:05:45 +00:00
|
|
|
* clutter_actor_raise_top:
|
2006-06-13 13:17:45 +00:00
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
2006-06-21 23:02:20 +00:00
|
|
|
* Raises @self to the top.
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_raise_top (ClutterActor *self)
|
|
|
|
{
|
|
|
|
clutter_actor_raise (self, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_lower_bottom:
|
|
|
|
* @self: A #ClutterActor
|
|
|
|
*
|
|
|
|
* Lowers @self to the bottom.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_lower_bottom (ClutterActor *self)
|
|
|
|
{
|
|
|
|
clutter_actor_lower (self, NULL);
|
|
|
|
}
|
|
|
|
|
2007-10-12 08:17:00 +00:00
|
|
|
/*
|
2007-08-13 20:48:01 +00:00
|
|
|
* Event handling
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_event:
|
|
|
|
* @actor: a #ClutterActor
|
|
|
|
* @event: a #ClutterEvent
|
2007-10-10 13:04:34 +00:00
|
|
|
* @capture: TRUE if event in in capture phase, FALSE otherwise.
|
2007-08-13 20:48:01 +00:00
|
|
|
*
|
|
|
|
* This function is used to emit an event on the main stage.
|
|
|
|
* You should rarely need to use this function, except for
|
|
|
|
* synthetising events.
|
|
|
|
*
|
2007-10-10 14:51:25 +00:00
|
|
|
* Return value: the return value from the signal emission: %TRUE
|
|
|
|
* if the actor handled the event, or %FALSE if the event was
|
|
|
|
* not handled
|
2007-08-13 20:48:01 +00:00
|
|
|
*
|
2007-08-15 19:50:31 +00:00
|
|
|
* Since: 0.6
|
2007-08-13 20:48:01 +00:00
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_actor_event (ClutterActor *actor,
|
2007-10-10 13:04:34 +00:00
|
|
|
ClutterEvent *event,
|
|
|
|
gboolean capture)
|
2007-08-13 20:48:01 +00:00
|
|
|
{
|
2007-10-10 14:29:29 +00:00
|
|
|
gboolean retval = FALSE;
|
2007-08-13 20:48:01 +00:00
|
|
|
gint signal_num = -1;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), FALSE);
|
|
|
|
g_return_val_if_fail (event != NULL, FALSE);
|
|
|
|
|
|
|
|
g_object_ref (actor);
|
2007-10-10 13:04:34 +00:00
|
|
|
|
|
|
|
if (capture)
|
|
|
|
{
|
2007-11-07 16:40:30 +00:00
|
|
|
g_signal_emit (actor, actor_signals[CAPTURED_EVENT], 0,
|
2007-10-10 14:29:29 +00:00
|
|
|
event,
|
|
|
|
&retval);
|
2007-10-10 13:04:34 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-10-02 14:03:36 +00:00
|
|
|
g_signal_emit (actor, actor_signals[EVENT], 0, event, &retval);
|
2007-08-13 20:48:01 +00:00
|
|
|
|
2007-10-02 14:03:36 +00:00
|
|
|
if (!retval)
|
2007-08-13 20:48:01 +00:00
|
|
|
{
|
2007-10-02 14:03:36 +00:00
|
|
|
switch (event->type)
|
2007-10-10 13:04:34 +00:00
|
|
|
{
|
|
|
|
case CLUTTER_NOTHING:
|
|
|
|
break;
|
|
|
|
case CLUTTER_BUTTON_PRESS:
|
|
|
|
signal_num = BUTTON_PRESS_EVENT;
|
|
|
|
break;
|
|
|
|
case CLUTTER_BUTTON_RELEASE:
|
|
|
|
signal_num = BUTTON_RELEASE_EVENT;
|
|
|
|
break;
|
|
|
|
case CLUTTER_SCROLL:
|
|
|
|
signal_num = SCROLL_EVENT;
|
|
|
|
break;
|
|
|
|
case CLUTTER_KEY_PRESS:
|
|
|
|
signal_num = KEY_PRESS_EVENT;
|
|
|
|
break;
|
|
|
|
case CLUTTER_KEY_RELEASE:
|
|
|
|
signal_num = KEY_RELEASE_EVENT;
|
|
|
|
break;
|
|
|
|
case CLUTTER_MOTION:
|
|
|
|
signal_num = MOTION_EVENT;
|
|
|
|
break;
|
|
|
|
case CLUTTER_ENTER:
|
|
|
|
signal_num = ENTER_EVENT;
|
|
|
|
break;
|
|
|
|
case CLUTTER_LEAVE:
|
|
|
|
signal_num = LEAVE_EVENT;
|
|
|
|
break;
|
|
|
|
case CLUTTER_DELETE:
|
|
|
|
case CLUTTER_DESTROY_NOTIFY:
|
|
|
|
case CLUTTER_CLIENT_MESSAGE:
|
|
|
|
default:
|
|
|
|
signal_num = -1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-10-02 14:03:36 +00:00
|
|
|
if (signal_num != -1)
|
2007-10-12 08:17:00 +00:00
|
|
|
g_signal_emit (actor, actor_signals[signal_num], 0,
|
2007-10-10 13:04:34 +00:00
|
|
|
event, &retval);
|
2007-08-13 20:48:01 +00:00
|
|
|
}
|
|
|
|
|
2007-10-10 14:29:29 +00:00
|
|
|
out:
|
2007-08-13 20:48:01 +00:00
|
|
|
g_object_unref (actor);
|
|
|
|
|
2007-10-02 14:03:36 +00:00
|
|
|
return retval;
|
2007-08-13 20:48:01 +00:00
|
|
|
}
|
|
|
|
|
2007-10-10 16:02:54 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_reactive:
|
|
|
|
* @actor: a #ClutterActor
|
2007-11-15 17:35:47 +00:00
|
|
|
* @reactive: whether the actor should be reactive to events
|
2007-10-10 16:02:54 +00:00
|
|
|
*
|
|
|
|
* Sets @actor as reactive. Reactive actors will receive events.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
2007-08-13 20:48:01 +00:00
|
|
|
void
|
2007-11-15 17:35:47 +00:00
|
|
|
clutter_actor_set_reactive (ClutterActor *actor,
|
|
|
|
gboolean reactive)
|
2007-08-13 20:48:01 +00:00
|
|
|
{
|
2007-08-15 19:50:31 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
|
|
|
|
|
2007-11-15 17:35:47 +00:00
|
|
|
if (reactive == CLUTTER_ACTOR_IS_REACTIVE (actor))
|
|
|
|
return;
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-11-15 17:35:47 +00:00
|
|
|
if (reactive)
|
|
|
|
CLUTTER_ACTOR_SET_FLAGS (actor, CLUTTER_ACTOR_REACTIVE);
|
|
|
|
else
|
|
|
|
CLUTTER_ACTOR_UNSET_FLAGS (actor, CLUTTER_ACTOR_REACTIVE);
|
2007-08-13 20:48:01 +00:00
|
|
|
}
|
|
|
|
|
2007-10-10 16:02:54 +00:00
|
|
|
/**
|
2007-11-15 17:35:47 +00:00
|
|
|
* clutter_actor_get_reactive:
|
2007-10-10 16:02:54 +00:00
|
|
|
* @actor: a #ClutterActor
|
|
|
|
*
|
|
|
|
* Checks whether @actor is marked as reactive.
|
|
|
|
*
|
|
|
|
* Return value: %TRUE if the actor is reactive
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
2007-08-13 20:48:01 +00:00
|
|
|
gboolean
|
2007-11-15 17:35:47 +00:00
|
|
|
clutter_actor_get_reactive (ClutterActor *actor)
|
2007-08-13 20:48:01 +00:00
|
|
|
{
|
2007-08-15 19:50:31 +00:00
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (actor), FALSE);
|
2007-10-12 08:17:00 +00:00
|
|
|
|
2007-10-10 16:02:54 +00:00
|
|
|
return CLUTTER_ACTOR_IS_REACTIVE (actor);
|
2007-08-13 20:48:01 +00:00
|
|
|
}
|
|
|
|
|
2007-11-28 12:23:31 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_anchor_point:
|
2007-11-28 14:16:37 +00:00
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @anchor_x: X coordinate of the anchor point
|
|
|
|
* @anchor_y: Y coordinate of the anchor point
|
2007-11-28 12:23:31 +00:00
|
|
|
*
|
|
|
|
* Sets an anchor point for the @actor. The anchor point is a point in the
|
2007-11-28 14:16:37 +00:00
|
|
|
* coordinate space of an actor to which the actor position within its
|
|
|
|
* parent is relative; the default is (0, 0), i.e. the top-left corner of
|
|
|
|
* the actor.
|
2007-11-28 12:23:31 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_anchor_point (ClutterActor *self,
|
2007-11-28 14:16:37 +00:00
|
|
|
gint anchor_x,
|
|
|
|
gint anchor_y)
|
2007-11-28 12:23:31 +00:00
|
|
|
{
|
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
priv = self->priv;
|
|
|
|
|
|
|
|
priv->anchor_x = CLUTTER_UNITS_FROM_DEVICE (anchor_x);
|
|
|
|
priv->anchor_y = CLUTTER_UNITS_FROM_DEVICE (anchor_y);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_get_anchor_point:
|
2007-11-28 14:16:37 +00:00
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @anchor_x: return location for the X coordinate of the anchor point
|
|
|
|
* @anchor_y: return location for the y coordinate of the anchor point
|
2007-11-28 12:23:31 +00:00
|
|
|
*
|
2007-11-28 14:16:37 +00:00
|
|
|
* Gets the current anchor point of the @actor in pixels.
|
2007-11-28 12:23:31 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_get_anchor_point (ClutterActor *self,
|
2007-11-28 14:16:37 +00:00
|
|
|
gint *anchor_x,
|
|
|
|
gint *anchor_y)
|
2007-11-28 12:23:31 +00:00
|
|
|
{
|
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
priv = self->priv;
|
|
|
|
|
|
|
|
if (anchor_x)
|
|
|
|
*anchor_x = CLUTTER_UNITS_TO_DEVICE (priv->anchor_x);
|
|
|
|
|
|
|
|
if (anchor_y)
|
|
|
|
*anchor_y = CLUTTER_UNITS_TO_DEVICE (priv->anchor_y);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_set_anchor_pointu:
|
2007-11-28 14:16:37 +00:00
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @anchor_x: X coordinate of the anchor point, in #ClutterUnit<!-- -->s
|
|
|
|
* @anchor_y: Y coordinate of the anchor point, in #ClutterUnit<!-- -->s
|
2007-11-28 12:23:31 +00:00
|
|
|
*
|
2007-11-28 14:16:37 +00:00
|
|
|
* Sets an anchor point for the @self. The anchor point is a point in the
|
|
|
|
* coordinate space of an actor to which the actor position within its
|
|
|
|
* parent is relative; the default is (0, 0), i.e. the top-left corner
|
|
|
|
* of the actor.
|
2007-11-28 12:23:31 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_set_anchor_pointu (ClutterActor *self,
|
2007-11-28 14:16:37 +00:00
|
|
|
ClutterUnit anchor_x,
|
|
|
|
ClutterUnit anchor_y)
|
2007-11-28 12:23:31 +00:00
|
|
|
{
|
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
priv = self->priv;
|
|
|
|
|
|
|
|
priv->anchor_x = anchor_x;
|
|
|
|
priv->anchor_y = anchor_y;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_get_anchor_pointu:
|
2007-11-28 14:16:37 +00:00
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @anchor_x: return location for the X coordinace of the anchor point
|
|
|
|
* @anchor_y: return location for the X coordinace of the anchor point
|
2007-11-28 12:23:31 +00:00
|
|
|
*
|
2007-11-28 14:16:37 +00:00
|
|
|
* Gets the current anchor point of the @actor in #ClutterUnit<!-- -->s.
|
2007-11-28 12:23:31 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
clutter_actor_get_anchor_pointu (ClutterActor *self,
|
2007-11-28 14:16:37 +00:00
|
|
|
ClutterUnit *anchor_x,
|
|
|
|
ClutterUnit *anchor_y)
|
2007-11-28 12:23:31 +00:00
|
|
|
{
|
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
priv = self->priv;
|
|
|
|
|
|
|
|
if (anchor_x)
|
|
|
|
*anchor_x = priv->anchor_x;
|
|
|
|
|
|
|
|
if (anchor_y)
|
|
|
|
*anchor_y = priv->anchor_y;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* clutter_actor_set_anchor_point_from_gravity:
|
2007-11-28 14:16:37 +00:00
|
|
|
* @self: a #ClutterActor
|
2007-11-28 12:23:31 +00:00
|
|
|
* @gravity: #ClutterGravity.
|
|
|
|
*
|
|
|
|
* Sets an anchor point the actor based on the given gravity (this is a
|
2007-11-28 14:16:37 +00:00
|
|
|
* convenience function wrapping clutter_actor_set_anchor_point()).
|
2007-11-28 12:23:31 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
void
|
2007-11-28 14:16:37 +00:00
|
|
|
clutter_actor_set_anchor_point_from_gravity (ClutterActor *self,
|
|
|
|
ClutterGravity gravity)
|
2007-11-28 12:23:31 +00:00
|
|
|
{
|
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
ClutterActorBox box;
|
|
|
|
ClutterUnit w, h, x, y;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
|
|
|
|
|
|
|
priv = self->priv;
|
|
|
|
|
|
|
|
clutter_actor_query_coords (self, &box);
|
|
|
|
|
|
|
|
x = 0;
|
|
|
|
y = 0;
|
|
|
|
w = box.x2 - box.x1;
|
|
|
|
h = box.y2 - box.y1;
|
|
|
|
|
|
|
|
switch (gravity)
|
|
|
|
{
|
|
|
|
case CLUTTER_GRAVITY_NORTH:
|
|
|
|
x = w/2;
|
|
|
|
break;
|
|
|
|
case CLUTTER_GRAVITY_SOUTH:
|
|
|
|
x = w/2;
|
|
|
|
y = h;
|
|
|
|
break;
|
|
|
|
case CLUTTER_GRAVITY_EAST:
|
|
|
|
x = w;
|
|
|
|
y = h/2;
|
|
|
|
break;
|
|
|
|
case CLUTTER_GRAVITY_NORTH_EAST:
|
|
|
|
x = w;
|
|
|
|
break;
|
|
|
|
case CLUTTER_GRAVITY_SOUTH_EAST:
|
|
|
|
x = w;
|
|
|
|
y = h;
|
|
|
|
break;
|
|
|
|
case CLUTTER_GRAVITY_SOUTH_WEST:
|
|
|
|
y = h;
|
|
|
|
break;
|
|
|
|
case CLUTTER_GRAVITY_WEST:
|
|
|
|
y = h/2;
|
|
|
|
break;
|
|
|
|
case CLUTTER_GRAVITY_CENTER:
|
|
|
|
x = w/2;
|
|
|
|
y = h/2;
|
|
|
|
break;
|
|
|
|
case CLUTTER_GRAVITY_NONE:
|
|
|
|
case CLUTTER_GRAVITY_NORTH_WEST:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->anchor_x = x;
|
|
|
|
priv->anchor_y = y;
|
|
|
|
}
|
|
|
|
|
2007-11-30 09:27:10 +00:00
|
|
|
typedef enum
|
|
|
|
{
|
|
|
|
PARSE_X,
|
|
|
|
PARSE_Y,
|
|
|
|
PARSE_WIDTH,
|
|
|
|
PARSE_HEIGHT
|
|
|
|
} ParseDimension;
|
|
|
|
|
|
|
|
static ClutterUnit
|
2007-11-30 14:36:07 +00:00
|
|
|
parse_units (ClutterActor *self,
|
|
|
|
ParseDimension dimension,
|
2007-11-30 09:27:10 +00:00
|
|
|
JsonNode *node)
|
|
|
|
{
|
|
|
|
GValue value = { 0, };
|
|
|
|
ClutterUnit retval = 0;
|
|
|
|
|
|
|
|
if (JSON_NODE_TYPE (node) != JSON_NODE_VALUE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
json_node_get_value (node, &value);
|
|
|
|
|
|
|
|
if (G_VALUE_HOLDS (&value, G_TYPE_INT))
|
|
|
|
{
|
|
|
|
gint pixels = g_value_get_int (&value);
|
|
|
|
|
|
|
|
retval = CLUTTER_UNITS_FROM_DEVICE (pixels);
|
|
|
|
}
|
|
|
|
else if (G_VALUE_HOLDS (&value, G_TYPE_STRING))
|
|
|
|
{
|
|
|
|
gint64 val;
|
|
|
|
gchar *end;
|
|
|
|
|
|
|
|
val = g_ascii_strtoll (g_value_get_string (&value), &end, 10);
|
|
|
|
|
|
|
|
/* assume pixels */
|
|
|
|
if (*end == '\0')
|
|
|
|
{
|
|
|
|
retval = CLUTTER_UNITS_FROM_DEVICE (val);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp (end, "px") == 0)
|
|
|
|
{
|
|
|
|
retval = CLUTTER_UNITS_FROM_DEVICE (val);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp (end, "mm") == 0)
|
|
|
|
{
|
|
|
|
retval = CLUTTER_UNITS_FROM_MM (val);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp (end, "pt") == 0)
|
|
|
|
{
|
|
|
|
retval = CLUTTER_UNITS_FROM_POINTS (val);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (end[0] == '%' && end[1] == '\0')
|
|
|
|
{
|
2007-11-30 14:36:07 +00:00
|
|
|
if (CLUTTER_PRIVATE_FLAGS (self) & CLUTTER_ACTOR_IS_TOPLEVEL)
|
|
|
|
{
|
|
|
|
g_warning ("Unable to set percentage of %s on a top-level "
|
|
|
|
"actor of type `%s'",
|
|
|
|
(dimension == PARSE_X || dimension == PARSE_WIDTH) ? "width"
|
|
|
|
: "height",
|
|
|
|
g_type_name (G_OBJECT_TYPE (self)));
|
|
|
|
retval = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2007-11-30 09:27:10 +00:00
|
|
|
if (dimension == PARSE_X || dimension == PARSE_WIDTH)
|
|
|
|
retval = CLUTTER_UNITS_FROM_STAGE_WIDTH_PERCENTAGE (val);
|
|
|
|
else
|
|
|
|
retval = CLUTTER_UNITS_FROM_STAGE_HEIGHT_PERCENTAGE (val);
|
|
|
|
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_warning ("Invalid value `%s': integers, strings or floating point "
|
|
|
|
"values can be used for the x, y, width and height "
|
|
|
|
"properties. Valid modifiers for strings are `px', 'mm' "
|
|
|
|
"and '%%'.",
|
|
|
|
g_value_get_string (&value));
|
|
|
|
|
|
|
|
retval = 0;
|
|
|
|
}
|
|
|
|
else if (G_VALUE_HOLDS (&value, G_TYPE_DOUBLE))
|
|
|
|
{
|
2007-11-30 14:36:07 +00:00
|
|
|
gint val;
|
2007-12-05 14:54:15 +00:00
|
|
|
|
2007-11-30 14:36:07 +00:00
|
|
|
if (CLUTTER_PRIVATE_FLAGS (self) & CLUTTER_ACTOR_IS_TOPLEVEL)
|
|
|
|
{
|
|
|
|
g_warning ("Unable to set percentage of %s on a top-level "
|
|
|
|
"actor of type `%s'",
|
|
|
|
(dimension == PARSE_X || dimension == PARSE_WIDTH) ? "width"
|
|
|
|
: "height",
|
|
|
|
g_type_name (G_OBJECT_TYPE (self)));
|
|
|
|
retval = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
val = CLAMP (g_value_get_double (&value) * 100, 0, 100);
|
2007-11-30 09:27:10 +00:00
|
|
|
|
|
|
|
if (dimension == PARSE_X || dimension == PARSE_WIDTH)
|
|
|
|
retval = CLUTTER_UNITS_FROM_STAGE_WIDTH_PERCENTAGE (val);
|
|
|
|
else
|
|
|
|
retval = CLUTTER_UNITS_FROM_STAGE_HEIGHT_PERCENTAGE (val);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
g_warning ("Invalid value of type `%s': integers, strings of floating "
|
|
|
|
"point values can be used for the x, y, width and height "
|
|
|
|
"properties.",
|
|
|
|
g_type_name (G_VALUE_TYPE (&value)));
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
g_value_unset (&value);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
typedef struct {
|
|
|
|
ClutterRotateAxis axis;
|
|
|
|
|
|
|
|
gdouble angle;
|
|
|
|
|
|
|
|
ClutterUnit center_x;
|
|
|
|
ClutterUnit center_y;
|
|
|
|
ClutterUnit center_z;
|
|
|
|
} RotationInfo;
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
parse_rotation_array (ClutterActor *actor,
|
|
|
|
JsonNode *node,
|
|
|
|
RotationInfo *info)
|
|
|
|
{
|
|
|
|
JsonArray *array = json_node_get_array (node);
|
|
|
|
JsonNode *element;
|
|
|
|
|
|
|
|
if (json_array_get_length (array) != 2)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
/* angle */
|
|
|
|
element = json_array_get_element (array, 0);
|
|
|
|
if (JSON_NODE_TYPE (element) == JSON_NODE_VALUE)
|
|
|
|
info->angle = json_node_get_double (element);
|
|
|
|
else
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
/* center */
|
|
|
|
element = json_array_get_element (array, 1);
|
|
|
|
if (JSON_NODE_TYPE (element) == JSON_NODE_ARRAY)
|
|
|
|
{
|
|
|
|
JsonArray *array = json_node_get_array (element);
|
|
|
|
|
|
|
|
if (json_array_get_length (array) != 2)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
switch (info->axis)
|
|
|
|
{
|
|
|
|
case CLUTTER_X_AXIS:
|
|
|
|
info->center_y = parse_units (actor, PARSE_Y,
|
|
|
|
json_array_get_element (array, 0));
|
|
|
|
info->center_z = parse_units (actor, PARSE_Y,
|
|
|
|
json_array_get_element (array, 1));
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
case CLUTTER_Y_AXIS:
|
|
|
|
info->center_x = parse_units (actor, PARSE_X,
|
|
|
|
json_array_get_element (array, 0));
|
|
|
|
info->center_z = parse_units (actor, PARSE_X,
|
|
|
|
json_array_get_element (array, 1));
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
case CLUTTER_Z_AXIS:
|
|
|
|
info->center_x = parse_units (actor, PARSE_X,
|
|
|
|
json_array_get_element (array, 0));
|
|
|
|
info->center_y = parse_units (actor, PARSE_Y,
|
|
|
|
json_array_get_element (array, 1));
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
parse_rotation (ClutterActor *actor,
|
|
|
|
JsonNode *node,
|
|
|
|
RotationInfo *info)
|
|
|
|
{
|
|
|
|
JsonArray *array;
|
|
|
|
guint len, i;
|
|
|
|
gboolean retval = FALSE;
|
|
|
|
|
|
|
|
if (JSON_NODE_TYPE (node) != JSON_NODE_ARRAY)
|
|
|
|
{
|
|
|
|
g_warning ("Invalid node of type `%s' found, expecting an array",
|
|
|
|
json_node_type_name (node));
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
array = json_node_get_array (node);
|
|
|
|
len = json_array_get_length (array);
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
{
|
|
|
|
JsonNode *element = json_array_get_element (array, i);
|
|
|
|
JsonObject *object;
|
|
|
|
JsonNode *member;
|
|
|
|
|
|
|
|
if (JSON_NODE_TYPE (element) != JSON_NODE_OBJECT)
|
|
|
|
{
|
|
|
|
g_warning ("Invalid node of type `%s' found, expecting an object",
|
|
|
|
json_node_type_name (element));
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
object = json_node_get_object (element);
|
|
|
|
|
|
|
|
if (json_object_has_member (object, "x-axis"))
|
|
|
|
{
|
|
|
|
member = json_object_get_member (object, "x-axis");
|
|
|
|
|
|
|
|
info->axis = CLUTTER_X_AXIS;
|
|
|
|
|
|
|
|
if (JSON_NODE_TYPE (member) == JSON_NODE_VALUE)
|
|
|
|
{
|
|
|
|
info->angle = json_node_get_double (member);
|
|
|
|
retval = TRUE;
|
|
|
|
}
|
|
|
|
else if (JSON_NODE_TYPE (member) == JSON_NODE_ARRAY)
|
|
|
|
retval = parse_rotation_array (actor, member, info);
|
|
|
|
else
|
|
|
|
retval = FALSE;
|
|
|
|
}
|
|
|
|
else if (json_object_has_member (object, "y-axis"))
|
|
|
|
{
|
|
|
|
member = json_object_get_member (object, "y-axis");
|
|
|
|
|
|
|
|
info->axis = CLUTTER_Y_AXIS;
|
|
|
|
|
|
|
|
if (JSON_NODE_TYPE (member) == JSON_NODE_VALUE)
|
|
|
|
{
|
|
|
|
info->angle = json_node_get_double (member);
|
|
|
|
retval = TRUE;
|
|
|
|
}
|
|
|
|
else if (JSON_NODE_TYPE (member) == JSON_NODE_ARRAY)
|
|
|
|
retval = parse_rotation_array (actor, member, info);
|
|
|
|
else
|
|
|
|
retval = FALSE;
|
|
|
|
}
|
|
|
|
else if (json_object_has_member (object, "z-axis"))
|
|
|
|
{
|
|
|
|
member = json_object_get_member (object, "z-axis");
|
|
|
|
|
|
|
|
info->axis = CLUTTER_Z_AXIS;
|
|
|
|
|
|
|
|
if (JSON_NODE_TYPE (member) == JSON_NODE_VALUE)
|
|
|
|
{
|
|
|
|
info->angle = json_node_get_double (member);
|
|
|
|
retval = TRUE;
|
|
|
|
}
|
|
|
|
else if (JSON_NODE_TYPE (member) == JSON_NODE_ARRAY)
|
|
|
|
retval = parse_rotation_array (actor, member, info);
|
|
|
|
else
|
|
|
|
retval = FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2007-11-30 09:27:10 +00:00
|
|
|
static gboolean
|
|
|
|
clutter_actor_parse_custom_node (ClutterScriptable *scriptable,
|
|
|
|
ClutterScript *script,
|
|
|
|
GValue *value,
|
|
|
|
const gchar *name,
|
|
|
|
JsonNode *node)
|
|
|
|
{
|
2007-11-30 14:36:07 +00:00
|
|
|
ClutterActor *actor = CLUTTER_ACTOR (scriptable);
|
2007-11-30 09:27:10 +00:00
|
|
|
gboolean retval = FALSE;
|
|
|
|
|
|
|
|
if ((name[0] == 'x' && name[1] == '\0') ||
|
|
|
|
(name[0] == 'y' && name[1] == '\0') ||
|
|
|
|
(strcmp (name, "width") == 0) ||
|
|
|
|
(strcmp (name, "height") == 0))
|
|
|
|
{
|
|
|
|
ClutterUnit units;
|
|
|
|
ParseDimension dimension;
|
|
|
|
|
|
|
|
if (name[0] == 'x')
|
|
|
|
dimension = PARSE_X;
|
|
|
|
else if (name[0] == 'y')
|
|
|
|
dimension = PARSE_Y;
|
|
|
|
else if (name[0] == 'w')
|
|
|
|
dimension = PARSE_WIDTH;
|
|
|
|
else
|
|
|
|
dimension = PARSE_HEIGHT;
|
|
|
|
|
2007-11-30 14:36:07 +00:00
|
|
|
units = parse_units (actor, dimension, node);
|
2007-11-30 09:27:10 +00:00
|
|
|
|
|
|
|
/* convert back to pixels */
|
|
|
|
g_value_init (value, G_TYPE_INT);
|
|
|
|
g_value_set_int (value, CLUTTER_UNITS_TO_DEVICE (units));
|
|
|
|
|
|
|
|
retval = TRUE;
|
|
|
|
}
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
else if (strcmp (name, "rotation") == 0)
|
|
|
|
{
|
|
|
|
RotationInfo *info;
|
|
|
|
|
|
|
|
info = g_slice_new0 (RotationInfo);
|
|
|
|
retval = parse_rotation (actor, node, info);
|
|
|
|
|
|
|
|
if (retval)
|
|
|
|
{
|
|
|
|
g_value_init (value, G_TYPE_POINTER);
|
|
|
|
g_value_set_pointer (value, info);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
g_slice_free (RotationInfo, info);
|
|
|
|
}
|
2007-11-30 09:27:10 +00:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
static void
|
|
|
|
clutter_actor_set_custom_property (ClutterScriptable *scriptable,
|
|
|
|
ClutterScript *script,
|
|
|
|
const gchar *name,
|
|
|
|
const GValue *value)
|
|
|
|
{
|
|
|
|
if (strcmp (name, "rotation") == 0)
|
|
|
|
{
|
|
|
|
RotationInfo *info;
|
|
|
|
|
|
|
|
if (!G_VALUE_HOLDS (value, G_TYPE_POINTER))
|
|
|
|
return;
|
|
|
|
|
|
|
|
info = g_value_get_pointer (value);
|
|
|
|
|
|
|
|
clutter_actor_set_rotation (CLUTTER_ACTOR (scriptable),
|
|
|
|
info->axis, info->angle,
|
|
|
|
CLUTTER_UNITS_TO_DEVICE (info->center_x),
|
|
|
|
CLUTTER_UNITS_TO_DEVICE (info->center_y),
|
|
|
|
CLUTTER_UNITS_TO_DEVICE (info->center_z));
|
|
|
|
|
|
|
|
g_slice_free (RotationInfo, info);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
g_object_set_property (G_OBJECT (scriptable), name, value);
|
|
|
|
}
|
|
|
|
|
2007-11-30 09:27:10 +00:00
|
|
|
static void
|
|
|
|
clutter_scriptable_iface_init (ClutterScriptableIface *iface)
|
|
|
|
{
|
|
|
|
iface->parse_custom_node = clutter_actor_parse_custom_node;
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
iface->set_custom_property = clutter_actor_set_custom_property;
|
2007-11-30 09:27:10 +00:00
|
|
|
}
|
|
|
|
|
2007-12-05 14:54:15 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_transform_stage_point
|
|
|
|
* @self: A #ClutterActor
|
2007-12-07 15:49:54 +00:00
|
|
|
* @x: x screen coordinate of the point to unproject, in #ClutterUnit<!-- -->s
|
|
|
|
* @y: y screen coordinate of the point to unproject, in #ClutterUnit<!-- -->s
|
|
|
|
* @x_out: return location for the unprojected x coordinance, in
|
|
|
|
* #ClutterUnit<!-- -->s
|
|
|
|
* @y_out: return location for the unprojected y coordinance, in
|
|
|
|
* #ClutterUnit<!-- -->s
|
2007-12-05 14:54:15 +00:00
|
|
|
*
|
2007-12-07 15:49:54 +00:00
|
|
|
* The function translates point with screen coordinates (@x, @y) to
|
|
|
|
* coordinates relative to the actor, i.e. it can be used to translate
|
|
|
|
* screen events from global screen coordinates into local coordinates.
|
2007-12-05 14:54:15 +00:00
|
|
|
*
|
|
|
|
* The conversion can fail, notably if the transform stack results in the
|
|
|
|
* actor being projected on the screen as a mere line.
|
|
|
|
*
|
2007-12-07 15:49:54 +00:00
|
|
|
* The conversion should not be expected to be pixel-perfect due to the
|
|
|
|
* nature of the operation. In general the error grows when the skewing
|
|
|
|
* of the actor rectangle on screen increases.
|
|
|
|
*
|
|
|
|
* Note: This function is fairly computationally intensive.
|
2007-12-05 14:54:15 +00:00
|
|
|
*
|
2007-12-07 15:49:54 +00:00
|
|
|
* Return value: %TRUE if conversion was successful.
|
2007-12-05 14:54:15 +00:00
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
clutter_actor_transform_stage_point (ClutterActor *self,
|
|
|
|
ClutterUnit x,
|
|
|
|
ClutterUnit y,
|
|
|
|
ClutterUnit *x_out,
|
|
|
|
ClutterUnit *y_out)
|
|
|
|
{
|
|
|
|
ClutterVertex v[4];
|
|
|
|
ClutterFixed ST[3][3];
|
|
|
|
ClutterFixed RQ[3][3];
|
|
|
|
int du, dv, xi, yi;
|
|
|
|
ClutterFixed xf, yf, wf, px, py, det;
|
|
|
|
ClutterActorPrivate *priv;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
|
|
|
|
|
|
|
|
priv = self->priv;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This implementation is based on the quad -> quad projection algorithm
|
|
|
|
* described by Paul Heckbert in
|
|
|
|
*
|
|
|
|
* http://www.cs.cmu.edu/~ph/texfund/texfund.pdf
|
|
|
|
*
|
|
|
|
* and the sample implementaion at http://www.cs.cmu.edu/~ph/src/texfund/.
|
|
|
|
*
|
|
|
|
* Our texture is a rectangle with origin [0,0], so we are mapping from quad
|
|
|
|
* to rectangle only, which significantly simplifies things; the function
|
|
|
|
* calls have been unrolled, and most of the math is done in fixed point.
|
|
|
|
*/
|
|
|
|
|
|
|
|
clutter_actor_get_vertices (self, v);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Keeping these as ints simplifies the multiplication (no significant loss
|
|
|
|
* of precission here).
|
|
|
|
*/
|
|
|
|
du = CLUTTER_UNITS_TO_DEVICE (priv->coords.x2 - priv->coords.x1);
|
|
|
|
dv = CLUTTER_UNITS_TO_DEVICE (priv->coords.y2 - priv->coords.y1);
|
|
|
|
|
|
|
|
if (!du || !dv)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
#define FP2FX CLUTTER_FLOAT_TO_FIXED
|
|
|
|
#define FX2FP CLUTTER_FIXED_TO_DOUBLE
|
|
|
|
#define FP2INT CLUTTER_FLOAT_TO_INT
|
|
|
|
#define DET2X(a,b, c,d) (CFX_QMUL(a,d) - CFX_QMUL(b,c))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* First, find mapping from unit uv square to xy quadrilateral; this
|
|
|
|
* equivalent to the pmap_square_quad() functions in the sample
|
|
|
|
* implementation, which we can simplify, since our target is always
|
|
|
|
* a rectangle.
|
|
|
|
*/
|
|
|
|
px = v[0].x - v[1].x + v[3].x - v[2].x;
|
|
|
|
py = v[0].y - v[1].y + v[3].y - v[2].y;
|
|
|
|
|
|
|
|
if (!px && !py)
|
|
|
|
{ /* affine transform */
|
|
|
|
RQ[0][0] = v[1].x - v[0].x;
|
|
|
|
RQ[1][0] = v[3].x - v[1].x;
|
|
|
|
RQ[2][0] = v[0].x;
|
|
|
|
RQ[0][1] = v[1].y - v[0].y;
|
|
|
|
RQ[1][1] = v[3].y - v[1].y;
|
|
|
|
RQ[2][1] = v[0].y;
|
|
|
|
RQ[0][2] = 0;
|
|
|
|
RQ[1][2] = 0;
|
|
|
|
RQ[2][2] = CFX_ONE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ /* projective transform */
|
|
|
|
ClutterFixed dx1, dx2, dy1, dy2, del;
|
|
|
|
|
|
|
|
dx1 = v[1].x - v[3].x;
|
|
|
|
dx2 = v[2].x - v[3].x;
|
|
|
|
dy1 = v[1].y - v[3].y;
|
|
|
|
dy2 = v[2].y - v[3].y;
|
|
|
|
|
|
|
|
del = DET2X (dx1,dx2, dy1,dy2);
|
|
|
|
|
|
|
|
if (!del)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The division here needs to be done in floating point for
|
|
|
|
* precisions reasons.
|
|
|
|
*/
|
|
|
|
RQ[0][2] = FP2FX (FX2FP (DET2X (px,dx2, py,dy2) / FX2FP (del)));
|
|
|
|
RQ[1][2] = FP2FX (FX2FP (DET2X (dx1,px, dy1,py) / FX2FP (del)));
|
|
|
|
RQ[1][2] = CFX_DIV (DET2X(dx1,px, dy1,py), del);
|
|
|
|
RQ[2][2] = CFX_ONE;
|
|
|
|
RQ[0][0] = v[1].x - v[0].x + CFX_QMUL (RQ[0][2], v[1].x);
|
|
|
|
RQ[1][0] = v[2].x - v[0].x + CFX_QMUL (RQ[1][2], v[2].x);
|
|
|
|
RQ[2][0] = v[0].x;
|
|
|
|
RQ[0][1] = v[1].y - v[0].y + CFX_QMUL (RQ[0][2], v[1].y);
|
|
|
|
RQ[1][1] = v[2].y - v[0].y + CFX_QMUL (RQ[1][2], v[2].y);
|
|
|
|
RQ[2][1] = v[0].y;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now combine with transform from our rectangle (u0,v0,u1,v1) to unit
|
|
|
|
* square. Since our rectangle is based at 0,0 we only need to scale.
|
|
|
|
*/
|
|
|
|
RQ[0][0] /= du;
|
|
|
|
RQ[1][0] /= dv;
|
|
|
|
RQ[0][1] /= du;
|
|
|
|
RQ[1][1] /= dv;
|
|
|
|
RQ[0][2] /= du;
|
|
|
|
RQ[1][2] /= dv;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now RQ is transform from uv rectangle to xy quadrilateral; we need an
|
|
|
|
* inverse of that.
|
|
|
|
*/
|
|
|
|
ST[0][0] = DET2X(RQ[1][1], RQ[1][2], RQ[2][1], RQ[2][2]);
|
|
|
|
ST[1][0] = DET2X(RQ[1][2], RQ[1][0], RQ[2][2], RQ[2][0]);
|
|
|
|
ST[2][0] = DET2X(RQ[1][0], RQ[1][1], RQ[2][0], RQ[2][1]);
|
|
|
|
ST[0][1] = DET2X(RQ[2][1], RQ[2][2], RQ[0][1], RQ[0][2]);
|
|
|
|
ST[1][1] = DET2X(RQ[2][2], RQ[2][0], RQ[0][2], RQ[0][0]);
|
|
|
|
ST[2][1] = DET2X(RQ[2][0], RQ[2][1], RQ[0][0], RQ[0][1]);
|
|
|
|
ST[0][2] = DET2X(RQ[0][1], RQ[0][2], RQ[1][1], RQ[1][2]);
|
|
|
|
ST[1][2] = DET2X(RQ[0][2], RQ[0][0], RQ[1][2], RQ[1][0]);
|
|
|
|
ST[2][2] = DET2X(RQ[0][0], RQ[0][1], RQ[1][0], RQ[1][1]);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check the resutling martix is OK.
|
|
|
|
*/
|
|
|
|
det = CFX_QMUL (RQ[0][0], ST[0][0]) + CFX_QMUL (RQ[0][1], ST[0][1]) +
|
|
|
|
CFX_QMUL (RQ[0][2], ST[0][2]);
|
|
|
|
|
|
|
|
if (!det)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now transform our point with the ST matrix; the notional w coordiance
|
|
|
|
* is 1, hence the last part is simply added.
|
|
|
|
*/
|
|
|
|
xi = CLUTTER_UNITS_TO_DEVICE (x);
|
|
|
|
yi = CLUTTER_UNITS_TO_DEVICE (y);
|
|
|
|
|
|
|
|
xf = xi*ST[0][0] + yi*ST[1][0] + ST[2][0];
|
|
|
|
yf = xi*ST[0][1] + yi*ST[1][1] + ST[2][1];
|
|
|
|
wf = xi*ST[0][2] + yi*ST[1][2] + ST[2][2];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The division needs to be done in floating point for precission reasons.
|
|
|
|
*/
|
|
|
|
*x_out = CLUTTER_UNITS_FROM_FLOAT (FX2FP (xf) / FX2FP (wf));
|
|
|
|
*y_out = CLUTTER_UNITS_FROM_FLOAT (FX2FP (yf) / FX2FP (wf));
|
|
|
|
|
|
|
|
#undef FP2FX
|
|
|
|
#undef FX2FP
|
|
|
|
#undef FP2INT
|
|
|
|
#undef DET2X
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/*
|
2007-10-25 14:36:37 +00:00
|
|
|
* ClutterGeometry
|
2006-06-13 13:17:45 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
static ClutterGeometry*
|
|
|
|
clutter_geometry_copy (const ClutterGeometry *geometry)
|
|
|
|
{
|
2007-10-25 14:36:37 +00:00
|
|
|
ClutterGeometry *result = g_slice_new (ClutterGeometry);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
|
|
|
*result = *geometry;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-10-25 14:36:37 +00:00
|
|
|
static void
|
|
|
|
clutter_geometry_free (ClutterGeometry *geometry)
|
|
|
|
{
|
|
|
|
if (G_LIKELY (geometry))
|
|
|
|
g_slice_free (ClutterGeometry, geometry);
|
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
GType
|
|
|
|
clutter_geometry_get_type (void)
|
|
|
|
{
|
|
|
|
static GType our_type = 0;
|
|
|
|
|
2007-11-28 14:16:37 +00:00
|
|
|
if (G_UNLIKELY (our_type == 0))
|
|
|
|
our_type =
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
g_boxed_type_register_static (I_("ClutterGeometry"),
|
2007-11-28 14:16:37 +00:00
|
|
|
(GBoxedCopyFunc) clutter_geometry_copy,
|
|
|
|
(GBoxedFreeFunc) clutter_geometry_free);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
|
|
|
return our_type;
|
|
|
|
}
|
|
|
|
|
2007-05-31 09:29:12 +00:00
|
|
|
/*
|
|
|
|
* ClutterVertices
|
|
|
|
*/
|
|
|
|
|
2007-07-04 09:17:10 +00:00
|
|
|
static ClutterVertex *
|
2007-06-12 11:42:29 +00:00
|
|
|
clutter_vertex_copy (const ClutterVertex *vertex)
|
2007-05-31 09:29:12 +00:00
|
|
|
{
|
2007-10-25 14:36:37 +00:00
|
|
|
ClutterVertex *result = g_slice_new (ClutterVertex);
|
2007-05-31 09:29:12 +00:00
|
|
|
|
2007-06-12 11:42:29 +00:00
|
|
|
*result = *vertex;
|
2007-05-31 09:29:12 +00:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-10-25 14:36:37 +00:00
|
|
|
static void
|
|
|
|
clutter_vertex_free (ClutterVertex *vertex)
|
|
|
|
{
|
|
|
|
if (G_UNLIKELY (vertex))
|
|
|
|
g_slice_free (ClutterVertex, vertex);
|
|
|
|
}
|
|
|
|
|
2007-05-31 09:29:12 +00:00
|
|
|
GType
|
2007-06-12 11:42:29 +00:00
|
|
|
clutter_vertex_get_type (void)
|
2007-05-31 09:29:12 +00:00
|
|
|
{
|
|
|
|
static GType our_type = 0;
|
|
|
|
|
2007-11-28 14:16:37 +00:00
|
|
|
if (G_UNLIKELY (our_type == 0))
|
|
|
|
our_type =
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
g_boxed_type_register_static (I_("ClutterVertex"),
|
2007-11-28 14:16:37 +00:00
|
|
|
(GBoxedCopyFunc) clutter_vertex_copy,
|
|
|
|
(GBoxedFreeFunc) clutter_vertex_free);
|
2007-05-31 09:29:12 +00:00
|
|
|
|
|
|
|
return our_type;
|
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
/*
|
|
|
|
* ClutterActorBox
|
|
|
|
*/
|
|
|
|
static ClutterActorBox *
|
|
|
|
clutter_actor_box_copy (const ClutterActorBox *box)
|
|
|
|
{
|
2007-10-25 14:36:37 +00:00
|
|
|
ClutterActorBox *result = g_slice_new (ClutterActorBox);
|
2006-06-13 13:17:45 +00:00
|
|
|
|
|
|
|
*result = *box;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2007-10-25 14:36:37 +00:00
|
|
|
static void
|
|
|
|
clutter_actor_box_free (ClutterActorBox *box)
|
|
|
|
{
|
|
|
|
if (G_LIKELY (box))
|
|
|
|
g_slice_free (ClutterActorBox, box);
|
|
|
|
}
|
|
|
|
|
2006-06-13 13:17:45 +00:00
|
|
|
GType
|
|
|
|
clutter_actor_box_get_type (void)
|
|
|
|
{
|
|
|
|
static GType our_type = 0;
|
|
|
|
|
2007-11-28 14:16:37 +00:00
|
|
|
if (G_UNLIKELY (our_type == 0))
|
|
|
|
our_type =
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
g_boxed_type_register_static (I_("ClutterActorBox"),
|
2007-11-28 14:16:37 +00:00
|
|
|
(GBoxedCopyFunc) clutter_actor_box_copy,
|
|
|
|
(GBoxedFreeFunc) clutter_actor_box_free);
|
2006-06-13 13:17:45 +00:00
|
|
|
return our_type;
|
|
|
|
}
|
2007-12-03 16:29:18 +00:00
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
|
|
|
|
typedef struct _BoxedFloat BoxedFloat;
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
|
2007-12-03 16:29:18 +00:00
|
|
|
struct _BoxedFloat
|
|
|
|
{
|
|
|
|
gfloat value;
|
|
|
|
};
|
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
static void
|
|
|
|
boxed_float_free (gpointer data)
|
|
|
|
{
|
|
|
|
if (G_LIKELY (data))
|
|
|
|
g_slice_free (BoxedFloat, data);
|
|
|
|
}
|
|
|
|
|
2007-12-03 16:29:18 +00:00
|
|
|
struct _ShaderData
|
|
|
|
{
|
|
|
|
ClutterShader *shader;
|
|
|
|
GHashTable *float1f_hash; /*< list of values that should be set
|
|
|
|
* on the shader before each paint cycle
|
|
|
|
*/
|
|
|
|
};
|
|
|
|
|
|
|
|
static void
|
|
|
|
destroy_shader_data (ClutterActor *self)
|
|
|
|
{
|
|
|
|
ClutterActorPrivate *actor_priv = self->priv;
|
|
|
|
ShaderData *shader_data = actor_priv->shader_data;
|
|
|
|
|
|
|
|
if (!shader_data)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (shader_data->shader)
|
|
|
|
{
|
|
|
|
g_object_unref (shader_data->shader);
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
shader_data->shader = NULL;
|
2007-12-03 16:29:18 +00:00
|
|
|
}
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
|
2007-12-03 16:29:18 +00:00
|
|
|
if (shader_data->float1f_hash)
|
|
|
|
{
|
|
|
|
g_hash_table_destroy (shader_data->float1f_hash);
|
|
|
|
shader_data->float1f_hash = NULL;
|
|
|
|
}
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
|
2007-12-03 16:29:18 +00:00
|
|
|
g_free (shader_data);
|
|
|
|
actor_priv->shader_data = NULL;
|
|
|
|
}
|
|
|
|
|
2007-12-15 14:36:27 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_apply_shader:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @shader: a #ClutterShader or %NULL
|
|
|
|
*
|
|
|
|
* Sets the #ClutterShader to be applied on @self.
|
|
|
|
*
|
|
|
|
* Return value: %TRUE if the shader was successfully applied
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
gboolean
|
|
|
|
clutter_actor_apply_shader (ClutterActor *self,
|
|
|
|
ClutterShader *shader)
|
2007-12-03 16:29:18 +00:00
|
|
|
{
|
|
|
|
ClutterActorPrivate *actor_priv;
|
|
|
|
ShaderData *shader_data;
|
|
|
|
|
|
|
|
g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
g_return_val_if_fail (shader == NULL || CLUTTER_IS_SHADER (shader), FALSE);
|
2007-12-05 14:54:15 +00:00
|
|
|
|
2007-12-03 16:29:18 +00:00
|
|
|
actor_priv = self->priv;
|
|
|
|
shader_data = actor_priv->shader_data;
|
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
if (!shader_data)
|
2007-12-03 16:29:18 +00:00
|
|
|
{
|
|
|
|
actor_priv->shader_data = shader_data = g_new0 (ShaderData, 1);
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
shader_data->float1f_hash =
|
|
|
|
g_hash_table_new_full (g_str_hash, g_str_equal,
|
|
|
|
g_free,
|
|
|
|
boxed_float_free);
|
2007-12-03 16:29:18 +00:00
|
|
|
}
|
|
|
|
if (shader_data->shader)
|
|
|
|
{
|
|
|
|
g_object_unref (shader_data->shader);
|
|
|
|
shader_data->shader = NULL;
|
|
|
|
}
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
|
|
|
|
if (shader)
|
|
|
|
shader_data->shader = g_object_ref (shader);
|
|
|
|
|
2007-12-11 14:49:41 +00:00
|
|
|
clutter_actor_queue_redraw (self);
|
|
|
|
|
2007-12-03 16:29:18 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
set_each_param (gpointer key,
|
|
|
|
gpointer value,
|
|
|
|
gpointer user_data)
|
2007-12-03 16:29:18 +00:00
|
|
|
{
|
|
|
|
ClutterShader *shader = CLUTTER_SHADER (user_data);
|
|
|
|
BoxedFloat *box = value;
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
|
2007-12-03 16:29:18 +00:00
|
|
|
clutter_shader_set_uniform_1f (shader, key, box->value);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_actor_shader_pre_paint (ClutterActor *actor,
|
|
|
|
gboolean repeat)
|
|
|
|
{
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
ClutterActorPrivate *priv;
|
2007-12-03 16:29:18 +00:00
|
|
|
ShaderData *shader_data;
|
|
|
|
ClutterShader *shader;
|
|
|
|
ClutterMainContext *context;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
|
2007-12-05 14:54:15 +00:00
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
priv = actor->priv;
|
|
|
|
shader_data = priv->shader_data;
|
2007-12-03 16:29:18 +00:00
|
|
|
|
|
|
|
if (!shader_data)
|
|
|
|
return;
|
|
|
|
|
|
|
|
context = clutter_context_get_default ();
|
|
|
|
shader = shader_data->shader;
|
|
|
|
|
|
|
|
if (shader)
|
|
|
|
{
|
2007-12-11 14:49:41 +00:00
|
|
|
clutter_shader_set_is_enabled (shader, TRUE);
|
2007-12-03 16:29:18 +00:00
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
g_hash_table_foreach (shader_data->float1f_hash, set_each_param, shader);
|
2007-12-03 16:29:18 +00:00
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
if (!repeat)
|
|
|
|
context->shaders = g_slist_prepend (context->shaders, actor);
|
2007-12-03 16:29:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
clutter_actor_shader_post_paint (ClutterActor *actor)
|
|
|
|
{
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
ClutterActorPrivate *priv;
|
2007-12-03 16:29:18 +00:00
|
|
|
ShaderData *shader_data;
|
|
|
|
ClutterShader *shader;
|
|
|
|
ClutterMainContext *context;
|
|
|
|
|
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
|
2007-12-05 14:54:15 +00:00
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
priv = actor->priv;
|
|
|
|
shader_data = priv->shader_data;
|
2007-12-03 16:29:18 +00:00
|
|
|
|
|
|
|
if (!shader_data)
|
|
|
|
return;
|
|
|
|
|
|
|
|
context = clutter_context_get_default ();
|
|
|
|
shader = shader_data->shader;
|
|
|
|
|
|
|
|
if (shader)
|
|
|
|
{
|
2007-12-11 14:49:41 +00:00
|
|
|
clutter_shader_set_is_enabled (shader, FALSE);
|
2007-12-03 16:29:18 +00:00
|
|
|
|
|
|
|
context->shaders = g_slist_remove (context->shaders, actor);
|
|
|
|
if (context->shaders)
|
|
|
|
{
|
|
|
|
/* call pre-paint again, this time with the second argument being
|
|
|
|
* TRUE, indicating that we are reapplying the shader and thus
|
|
|
|
* should not be prepended to the stack
|
|
|
|
*/
|
|
|
|
clutter_actor_shader_pre_paint (context->shaders->data, TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-15 14:36:27 +00:00
|
|
|
/**
|
|
|
|
* clutter_actor_set_shader_param:
|
|
|
|
* @self: a #ClutterActor
|
|
|
|
* @param: the name of the parameter
|
|
|
|
* @value: the value of the parameter
|
|
|
|
*
|
|
|
|
* Sets the value for a named parameter of the shader applied
|
|
|
|
* to @actor.
|
|
|
|
*
|
|
|
|
* Since: 0.6
|
|
|
|
*/
|
2007-12-03 16:29:18 +00:00
|
|
|
void
|
2007-12-15 14:36:27 +00:00
|
|
|
clutter_actor_set_shader_param (ClutterActor *self,
|
2007-12-03 16:29:18 +00:00
|
|
|
const gchar *param,
|
|
|
|
gfloat value)
|
|
|
|
{
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
ClutterActorPrivate *priv;
|
2007-12-03 16:29:18 +00:00
|
|
|
ShaderData *shader_data;
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
BoxedFloat *box;
|
2007-12-03 16:29:18 +00:00
|
|
|
|
2007-12-15 14:36:27 +00:00
|
|
|
g_return_if_fail (CLUTTER_IS_ACTOR (self));
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
g_return_if_fail (param != NULL);
|
2007-12-05 14:54:15 +00:00
|
|
|
|
2007-12-15 14:36:27 +00:00
|
|
|
priv = self->priv;
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
shader_data = priv->shader_data;
|
2007-12-03 16:29:18 +00:00
|
|
|
|
|
|
|
if (!shader_data)
|
|
|
|
return;
|
|
|
|
|
2007-12-10 Emmanuele Bassi <ebassi@openedhand.com>
* clutter/clutter-actor.c:
(clutter_actor_set_property),
(clutter_actor_get_property),
(clutter_actor_class_init): Add the rotation-* properties,
controlling the rotation angle and center on each axis. (#614)
(parse_rotation_array), (parse_rotation),
(clutter_actor_parse_custom_node),
(clutter_actor_set_custom_property),
(clutter_scriptable_iface_init): Add a new "rotation" custom
property for expressing the rotation along each axis in a
compact way:
"rotation" : [
{ "x-axis" : [ <angle>, [ <y>, <z> ] ] },
{ "y-axis" : [ <angle>, [ <x>, <z> ] ] },
{ "z-axis" : [ <angle>, [ <x>, <y> ] ] }
]
(clutter_geometry_get_type),(clutter_vertex_get_type),
(clutter_actor_box_get_type): Use the I_() macro instead of
directly calling g_intern_static_string().
* clutter/clutter-entry.c (clutter_entry_request_coords):
* clutter/clutter-label.c (clutter_label_ensure_layout),
(clutter_label_request_coords): Use CLUTTER_UNITS_FROM_DEVICE()
instead of CLUTTER_UNITS_FROM_INT(), as "device" means "pixels".
* clutter/clutter-private.h: Add the I_() macro for intern
static strings.
* tests/test-script.json: Test the newly added "rotation"
custom property.
2007-12-10 11:01:10 +00:00
|
|
|
box = g_slice_new (BoxedFloat);
|
2007-12-03 16:29:18 +00:00
|
|
|
box->value = value;
|
|
|
|
g_hash_table_insert (shader_data->float1f_hash, g_strdup (param), box);
|
|
|
|
}
|