isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-23 16:40:41 -05:00
Code Issues Packages Projects Releases Wiki Activity
4be7ecb836
mutter/clutter/clutter-actor-private.h

310 lines
12 KiB
C
Raw Normal View History

Add copyright notices
2010-10-21 08:13:00 -04:00
/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
#ifndef __CLUTTER_ACTOR_PRIVATE_H__
#define __CLUTTER_ACTOR_PRIVATE_H__
#include <clutter/clutter-actor.h>
G_BEGIN_DECLS
docs: Documentation fixes
2010-12-09 10:06:12 -05:00
/*< private >
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
* ClutterRedrawFlags:
* @CLUTTER_REDRAW_CLIPPED_TO_ALLOCATION: Tells clutter the maximum
* extents of what needs to be redrawn lies within the actors
* current allocation. (Only use this for 2D actors though because
* any actor with depth may be projected outside of its allocation)
*
* Flags passed to the clutter_actor_queue_redraw_with_clip ()
* function
*
* Since: 1.6
*/
typedef enum
{
CLUTTER_REDRAW_CLIPPED_TO_ALLOCATION = 1 << 0
} ClutterRedrawFlags;
docs: Documentation fixes
2010-12-09 10:06:12 -05:00
/*< private >
* ClutterActorTraverseFlags:
actor: make _clutter_actor_traverse more flexible This makes it possible to choose the traversal order; either depth first or breadth first and when visiting actors in a depth first order there is now a callback called before children are traversed and one called after. Some tasks such as unrealizing actors need to explicitly control the traversal order to maintain the invariable that all children of an actor are unrealized before we actually mark the parent as unrealized. The callbacks are now passed the relative depth in the graph of the actor being visited and instead of only being able to return a boolean to bail out of further traversal it can now do one of: continue, skip_children or break. To implement something like unrealize it's desirable to skip children that you find have already been unrealized.
2010-10-20 10:40:30 -04:00
* CLUTTER_ACTOR_TRAVERSE_DEPTH_FIRST: Traverse the graph in
* a depth first order.
* CLUTTER_ACTOR_TRAVERSE_BREADTH_FIRST: Traverse the graph in a
* breadth first order.
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
*
* Controls some options for how clutter_actor_traverse() iterates
* through the graph.
*/
Remove unnecessary duplicate name for private enumerations
2010-12-10 11:03:10 -05:00
typedef enum {
actor: make _clutter_actor_traverse more flexible This makes it possible to choose the traversal order; either depth first or breadth first and when visiting actors in a depth first order there is now a callback called before children are traversed and one called after. Some tasks such as unrealizing actors need to explicitly control the traversal order to maintain the invariable that all children of an actor are unrealized before we actually mark the parent as unrealized. The callbacks are now passed the relative depth in the graph of the actor being visited and instead of only being able to return a boolean to bail out of further traversal it can now do one of: continue, skip_children or break. To implement something like unrealize it's desirable to skip children that you find have already been unrealized.
2010-10-20 10:40:30 -04:00
CLUTTER_ACTOR_TRAVERSE_DEPTH_FIRST = 1L<<0,
CLUTTER_ACTOR_TRAVERSE_BREADTH_FIRST = 1L<<1
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
} ClutterActorTraverseFlags;
docs: Documentation fixes
2010-12-09 10:06:12 -05:00
/*< private >
actor: make _clutter_actor_traverse more flexible This makes it possible to choose the traversal order; either depth first or breadth first and when visiting actors in a depth first order there is now a callback called before children are traversed and one called after. Some tasks such as unrealizing actors need to explicitly control the traversal order to maintain the invariable that all children of an actor are unrealized before we actually mark the parent as unrealized. The callbacks are now passed the relative depth in the graph of the actor being visited and instead of only being able to return a boolean to bail out of further traversal it can now do one of: continue, skip_children or break. To implement something like unrealize it's desirable to skip children that you find have already been unrealized.
2010-10-20 10:40:30 -04:00
* ClutterActorTraverseVisitFlags:
* CLUTTER_ACTOR_TRAVERSE_VISIT_CONTINUE: Continue traversing as
* normal
* CLUTTER_ACTOR_TRAVERSE_VISIT_SKIP_CHILDREN: Don't traverse the
* children of the last visited actor. (Not applicable when using
docs: Documentation fixes
2010-12-09 10:06:12 -05:00
* %CLUTTER_ACTOR_TRAVERSE_DEPTH_FIRST_POST_ORDER since the children
actor: make _clutter_actor_traverse more flexible This makes it possible to choose the traversal order; either depth first or breadth first and when visiting actors in a depth first order there is now a callback called before children are traversed and one called after. Some tasks such as unrealizing actors need to explicitly control the traversal order to maintain the invariable that all children of an actor are unrealized before we actually mark the parent as unrealized. The callbacks are now passed the relative depth in the graph of the actor being visited and instead of only being able to return a boolean to bail out of further traversal it can now do one of: continue, skip_children or break. To implement something like unrealize it's desirable to skip children that you find have already been unrealized.
2010-10-20 10:40:30 -04:00
* are visited before having an opportunity to bail out)
* CLUTTER_ACTOR_TRAVERSE_VISIT_BREAK: Immediately bail out without
* visiting any more actors.
*
* Each time an actor is visited during a scenegraph traversal the
* ClutterTraverseCallback can return a set of flags that may affect
* the continuing traversal. It may stop traversal completely, just
* skip over children for the current actor or continue as normal.
*/
Remove unnecessary duplicate name for private enumerations
2010-12-10 11:03:10 -05:00
typedef enum {
actor: make _clutter_actor_traverse more flexible This makes it possible to choose the traversal order; either depth first or breadth first and when visiting actors in a depth first order there is now a callback called before children are traversed and one called after. Some tasks such as unrealizing actors need to explicitly control the traversal order to maintain the invariable that all children of an actor are unrealized before we actually mark the parent as unrealized. The callbacks are now passed the relative depth in the graph of the actor being visited and instead of only being able to return a boolean to bail out of further traversal it can now do one of: continue, skip_children or break. To implement something like unrealize it's desirable to skip children that you find have already been unrealized.
2010-10-20 10:40:30 -04:00
CLUTTER_ACTOR_TRAVERSE_VISIT_CONTINUE = 1L<<0,
CLUTTER_ACTOR_TRAVERSE_VISIT_SKIP_CHILDREN = 1L<<1,
CLUTTER_ACTOR_TRAVERSE_VISIT_BREAK = 1L<<2
} ClutterActorTraverseVisitFlags;
docs: Documentation fixes
2010-12-09 10:06:12 -05:00
/*< private >
actor: make _clutter_actor_traverse more flexible This makes it possible to choose the traversal order; either depth first or breadth first and when visiting actors in a depth first order there is now a callback called before children are traversed and one called after. Some tasks such as unrealizing actors need to explicitly control the traversal order to maintain the invariable that all children of an actor are unrealized before we actually mark the parent as unrealized. The callbacks are now passed the relative depth in the graph of the actor being visited and instead of only being able to return a boolean to bail out of further traversal it can now do one of: continue, skip_children or break. To implement something like unrealize it's desirable to skip children that you find have already been unrealized.
2010-10-20 10:40:30 -04:00
* ClutterTraverseCallback:
*
* The callback prototype used with clutter_actor_traverse. The
* returned flags can be used to affect the continuing traversal
* either by continuing as normal, skipping over children of an
* actor or bailing out completely.
*/
typedef ClutterActorTraverseVisitFlags (*ClutterTraverseCallback) (ClutterActor *actor,
docs: Documentation fixes
2010-12-09 10:06:12 -05:00
gint depth,
gpointer user_data);
actor: make _clutter_actor_traverse more flexible This makes it possible to choose the traversal order; either depth first or breadth first and when visiting actors in a depth first order there is now a callback called before children are traversed and one called after. Some tasks such as unrealizing actors need to explicitly control the traversal order to maintain the invariable that all children of an actor are unrealized before we actually mark the parent as unrealized. The callbacks are now passed the relative depth in the graph of the actor being visited and instead of only being able to return a boolean to bail out of further traversal it can now do one of: continue, skip_children or break. To implement something like unrealize it's desirable to skip children that you find have already been unrealized.
2010-10-20 10:40:30 -04:00
docs: Documentation fixes
2010-12-09 10:06:12 -05:00
/*< private >
* ClutterForeachCallback:
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
* @actor: The actor being iterated
* @user_data: The private data specified when starting the iteration
*
* A generic callback for iterating over actor, such as with
* _clutter_actor_foreach_child. The difference when compared to
* #ClutterCallback is that it returns a boolean so it is possible to break
* out of an iteration early.
*
* Return value: %TRUE to continue iterating or %FALSE to break iteration
* early.
*/
typedef gboolean (*ClutterForeachCallback) (ClutterActor *actor,
docs: Documentation fixes
2010-12-09 10:06:12 -05:00
gpointer user_data);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
actor: Add TransformInfo ClutterTransformInfo is a (private) ancillary data structure that contains all the decomposed transformation data, i.e. rotation angles and centers, scale factors and centers, and anchor point. This data structure is stored in the GData of the actor instance instead of the actor's private data. This change gives us: • a smaller, cleaner private data structure; • no size penalty for untransformed actors; • static constant storage for the defaults, shared across all instances; • cache locality for all the decomposed transformation data, given that the structure size is smaller. At the end of the day, the only authoritative piece of information for actor transformation is the CoglMatrix that we initialize in apply_transform() from all the decomposed parameters, and that can stay inside the private data structure of ClutterActor.
2011-12-09 09:38:25 -05:00
typedef struct _AnchorCoord AnchorCoord;
typedef struct _SizeRequest SizeRequest;
actor: Adjust the allocation prior to call allocate() ClutterActor has various properties controlling the allocation: - x-align, y-align - margin-top, margin-bottom, margin-left, margin-right These properties should adjust the ClutterActorBox passed from the parent actor to its children when calling clutter_actor_allocate(), so that the child can just allocate its children at the right origin with the right available size.
2011-11-23 13:16:29 -05:00
typedef struct _ClutterLayoutInfo ClutterLayoutInfo;
actor: Add TransformInfo ClutterTransformInfo is a (private) ancillary data structure that contains all the decomposed transformation data, i.e. rotation angles and centers, scale factors and centers, and anchor point. This data structure is stored in the GData of the actor instance instead of the actor's private data. This change gives us: • a smaller, cleaner private data structure; • no size penalty for untransformed actors; • static constant storage for the defaults, shared across all instances; • cache locality for all the decomposed transformation data, given that the structure size is smaller. At the end of the day, the only authoritative piece of information for actor transformation is the CoglMatrix that we initialize in apply_transform() from all the decomposed parameters, and that can stay inside the private data structure of ClutterActor.
2011-12-09 09:38:25 -05:00
typedef struct _ClutterTransformInfo ClutterTransformInfo;
actor: Implement implicit animatable properties Clutter is meant to be, and I quote from the README, a toolkit: for creating fast, compelling, portable, and dynamic graphical user interfaces and yet the default mode of operation for setting an actor's state on the scene graph (position, size, opacity, rotation, scaling, depth, etc.) is *not* dynamic. We assume a static UI, and then animate it. This is the wrong way to design an API for a toolkit meant to be used to create animated user interfaces. The default mode of operation should be to implicitly animate every state transition, and only allow skipping the animation if the user consciously decides to do so — i.e. the design tenet of the API should be to make The Right Thing™ by default, and make it really hard (or even impossible) to do The Wrong Thing™. So we should identify "animatable" properties, i.e. those properties that should be implicitly animated by ClutterActor, and use the animation framework we provide to tween the transitions between the current state and the desired state; the implicit animation should happen when setting these properties using the public accessors, and not through some added functionality. For instance, the following: clutter_actor_set_position (actor, newX, newY); should not make the actor jump to the (newX, newY) point; it should tween the actor's position between the current point and the desired point. Since we have to maintain backward compatibility with existing applications, we still need to mark the transitions explicitly, but we can be smart about it, and treat transition states as a stack that can be pushed and popped, e.g.: clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_position (actor, newX, newY); clutter_actor_set_opacity (actor, newOpacity); clutter_actor_restore_easing_state (actor); And we can even start stacking animations, e.g.: clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_position (actor, newX, newY); clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_easing_mode (actor, CLUTTER_LINEAR); clutter_actor_set_opacity (actor, newOpacity); clutter_actor_set_depth (actor, newDepth); clutter_actor_restore_easing_state (actor); clutter_actor_restore_easing_state (actor); And so on, and so forth. The implementation takes advantage of the newly added Transition API, which uses only ClutterTimeline sub-classes and ClutterInterval, to cut down the amount of signal emissions and memory management of object instances; as well of using the ClutterAnimatable interface for custom properties and interpolation of values.
2012-03-15 07:09:11 -04:00
typedef struct _ClutterAnimationInfo ClutterAnimationInfo;
actor: Add TransformInfo ClutterTransformInfo is a (private) ancillary data structure that contains all the decomposed transformation data, i.e. rotation angles and centers, scale factors and centers, and anchor point. This data structure is stored in the GData of the actor instance instead of the actor's private data. This change gives us: • a smaller, cleaner private data structure; • no size penalty for untransformed actors; • static constant storage for the defaults, shared across all instances; • cache locality for all the decomposed transformation data, given that the structure size is smaller. At the end of the day, the only authoritative piece of information for actor transformation is the CoglMatrix that we initialize in apply_transform() from all the decomposed parameters, and that can stay inside the private data structure of ClutterActor.
2011-12-09 09:38:25 -05:00
/* Internal helper struct to represent a point that can be stored in
either direct pixel coordinates or as a fraction of the actor's
size. It is used for the anchor point, scale center and rotation
centers. */
struct _AnchorCoord
{
gboolean is_fractional;
union
{
/* Used when is_fractional == TRUE */
struct
{
gdouble x;
gdouble y;
} fraction;
/* Use when is_fractional == FALSE */
ClutterVertex units;
} v;
};
struct _SizeRequest
{
guint age;
gfloat for_size;
gfloat min_size;
gfloat natural_size;
};
actor: Adjust the allocation prior to call allocate() ClutterActor has various properties controlling the allocation: - x-align, y-align - margin-top, margin-bottom, margin-left, margin-right These properties should adjust the ClutterActorBox passed from the parent actor to its children when calling clutter_actor_allocate(), so that the child can just allocate its children at the right origin with the right available size.
2011-11-23 13:16:29 -05:00
/*< private >
* ClutterLayoutInfo:
actor: Add basic automatic expand flags The :x-expand and :y-expand flags on ClutterActor are used to signal that an actor should expand horizontally and/or vertically - i.e. that its parent's layout management policy should try to assign extra space to the actor when allocating it. The expand flags are automatic: when set on a leaf node in the actor tree, they will bubble up through the parent and grandparents up to the top level actor; during allocation, the actors with children will lazily compute whether their children needs to expand.
2012-03-27 09:53:27 -04:00
* @fixed_pos: the fixed position of the actor
actor: Adjust the allocation prior to call allocate() ClutterActor has various properties controlling the allocation: - x-align, y-align - margin-top, margin-bottom, margin-left, margin-right These properties should adjust the ClutterActorBox passed from the parent actor to its children when calling clutter_actor_allocate(), so that the child can just allocate its children at the right origin with the right available size.
2011-11-23 13:16:29 -05:00
* @margin: the composed margin of the actor
* @x_align: the horizontal alignment, if the actor expands horizontally
* @y_align: the vertical alignment, if the actor expands vertically
actor: Add basic automatic expand flags The :x-expand and :y-expand flags on ClutterActor are used to signal that an actor should expand horizontally and/or vertically - i.e. that its parent's layout management policy should try to assign extra space to the actor when allocating it. The expand flags are automatic: when set on a leaf node in the actor tree, they will bubble up through the parent and grandparents up to the top level actor; during allocation, the actors with children will lazily compute whether their children needs to expand.
2012-03-27 09:53:27 -04:00
* @x_expand: whether the actor should expand horizontally
* @y_expand: whether the actor should expand vertically
* @minimum: the fixed minimum size
* @natural: the fixed natural size
actor: Adjust the allocation prior to call allocate() ClutterActor has various properties controlling the allocation: - x-align, y-align - margin-top, margin-bottom, margin-left, margin-right These properties should adjust the ClutterActorBox passed from the parent actor to its children when calling clutter_actor_allocate(), so that the child can just allocate its children at the right origin with the right available size.
2011-11-23 13:16:29 -05:00
*
* Ancillary layout information for an actor.
*/
struct _ClutterLayoutInfo
{
/* fixed position coordinates */
actor: Use ClutterPoint for the fixed position
2012-03-30 13:43:59 -04:00
ClutterPoint fixed_pos;
actor: Adjust the allocation prior to call allocate() ClutterActor has various properties controlling the allocation: - x-align, y-align - margin-top, margin-bottom, margin-left, margin-right These properties should adjust the ClutterActorBox passed from the parent actor to its children when calling clutter_actor_allocate(), so that the child can just allocate its children at the right origin with the right available size.
2011-11-23 13:16:29 -05:00
ClutterMargin margin;
guint x_align : 4;
guint y_align : 4;
actor: Store the fixed sizes into LayoutInfo Remove four more floats from ClutterActorPrivate. The fixed minimum and natural sizes should be stored inside the ClutterLayoutInfo structure, along with the fixed position.
2011-11-24 09:13:29 -05:00
actor: Add basic automatic expand flags The :x-expand and :y-expand flags on ClutterActor are used to signal that an actor should expand horizontally and/or vertically - i.e. that its parent's layout management policy should try to assign extra space to the actor when allocating it. The expand flags are automatic: when set on a leaf node in the actor tree, they will bubble up through the parent and grandparents up to the top level actor; during allocation, the actors with children will lazily compute whether their children needs to expand.
2012-03-27 09:53:27 -04:00
guint x_expand : 1;
guint y_expand : 1;
actor: Use ClutterSize for minimum and natural fixed sizes
2012-03-30 13:53:22 -04:00
ClutterSize minimum;
ClutterSize natural;
actor: Adjust the allocation prior to call allocate() ClutterActor has various properties controlling the allocation: - x-align, y-align - margin-top, margin-bottom, margin-left, margin-right These properties should adjust the ClutterActorBox passed from the parent actor to its children when calling clutter_actor_allocate(), so that the child can just allocate its children at the right origin with the right available size.
2011-11-23 13:16:29 -05:00
};
const ClutterLayoutInfo * _clutter_actor_get_layout_info_or_defaults (ClutterActor *self);
ClutterLayoutInfo * _clutter_actor_get_layout_info (ClutterActor *self);
Add _clutter_actor_peek_layout_info This will be needed later to get a layout_info without creating one if there is none already.
2012-06-07 10:31:22 -04:00
ClutterLayoutInfo * _clutter_actor_peek_layout_info (ClutterActor *self);
actor: Adjust the allocation prior to call allocate() ClutterActor has various properties controlling the allocation: - x-align, y-align - margin-top, margin-bottom, margin-left, margin-right These properties should adjust the ClutterActorBox passed from the parent actor to its children when calling clutter_actor_allocate(), so that the child can just allocate its children at the right origin with the right available size.
2011-11-23 13:16:29 -05:00
actor: Add TransformInfo ClutterTransformInfo is a (private) ancillary data structure that contains all the decomposed transformation data, i.e. rotation angles and centers, scale factors and centers, and anchor point. This data structure is stored in the GData of the actor instance instead of the actor's private data. This change gives us: • a smaller, cleaner private data structure; • no size penalty for untransformed actors; • static constant storage for the defaults, shared across all instances; • cache locality for all the decomposed transformation data, given that the structure size is smaller. At the end of the day, the only authoritative piece of information for actor transformation is the CoglMatrix that we initialize in apply_transform() from all the decomposed parameters, and that can stay inside the private data structure of ClutterActor.
2011-12-09 09:38:25 -05:00
struct _ClutterTransformInfo
{
/* rotation (angle and center) */
gdouble rx_angle;
AnchorCoord rx_center;
gdouble ry_angle;
AnchorCoord ry_center;
gdouble rz_angle;
AnchorCoord rz_center;
/* scaling */
gdouble scale_x;
gdouble scale_y;
AnchorCoord scale_center;
/* anchor point */
AnchorCoord anchor;
actor: Implement implicit animatable properties Clutter is meant to be, and I quote from the README, a toolkit: for creating fast, compelling, portable, and dynamic graphical user interfaces and yet the default mode of operation for setting an actor's state on the scene graph (position, size, opacity, rotation, scaling, depth, etc.) is *not* dynamic. We assume a static UI, and then animate it. This is the wrong way to design an API for a toolkit meant to be used to create animated user interfaces. The default mode of operation should be to implicitly animate every state transition, and only allow skipping the animation if the user consciously decides to do so — i.e. the design tenet of the API should be to make The Right Thing™ by default, and make it really hard (or even impossible) to do The Wrong Thing™. So we should identify "animatable" properties, i.e. those properties that should be implicitly animated by ClutterActor, and use the animation framework we provide to tween the transitions between the current state and the desired state; the implicit animation should happen when setting these properties using the public accessors, and not through some added functionality. For instance, the following: clutter_actor_set_position (actor, newX, newY); should not make the actor jump to the (newX, newY) point; it should tween the actor's position between the current point and the desired point. Since we have to maintain backward compatibility with existing applications, we still need to mark the transitions explicitly, but we can be smart about it, and treat transition states as a stack that can be pushed and popped, e.g.: clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_position (actor, newX, newY); clutter_actor_set_opacity (actor, newOpacity); clutter_actor_restore_easing_state (actor); And we can even start stacking animations, e.g.: clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_position (actor, newX, newY); clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_easing_mode (actor, CLUTTER_LINEAR); clutter_actor_set_opacity (actor, newOpacity); clutter_actor_set_depth (actor, newDepth); clutter_actor_restore_easing_state (actor); clutter_actor_restore_easing_state (actor); And so on, and so forth. The implementation takes advantage of the newly added Transition API, which uses only ClutterTimeline sub-classes and ClutterInterval, to cut down the amount of signal emissions and memory management of object instances; as well of using the ClutterAnimatable interface for custom properties and interpolation of values.
2012-03-15 07:09:11 -04:00
actor: Add :z-position and deprecate :depth The ClutterActor:depth property has always been a bit of a misnomer: actors are 2D flat surfaces, so they cannot have "depth"; the property defines the position on the Z axis. Another side effect of the :depth property is that it decides the default paint and allocation order on insertion, and that setting it will call the ClutterContainer.sort_depth_order() method. This has proven to be a fairly bad design decision that we strung along from the 0.x days, as it gives a false impression of being able to change the paint and allocation order simply by changing the position on the Z axis — something that, in reality, requires depth testing to be enabled during the paint sequence of an actor's parent. For 2.0 we need a clean break from the side effects, and a better defined interface. ClutterActor:z-position is essentially what ClutterActor:depth is, but doesn't call into ClutterContainer, and has a more apt name. https://bugzilla.gnome.org/show_bug.cgi?id=679465
2012-07-05 13:57:38 -04:00
/* z_position */
gfloat z_position;
actor: Add pivot point The pivot point is a point in normalized coordinates space around which all transformations revolve. It supercedes the anchor point and the per-transformation center points as well as the gravity settings, and tries to sort out the mess that is the modelview matrix set up in ClutterActor. https://bugzilla.gnome.org/show_bug.cgi?id=677853
2012-07-06 05:35:13 -04:00
/* transformation center */
ClutterPoint pivot;
actor: Add TransformInfo ClutterTransformInfo is a (private) ancillary data structure that contains all the decomposed transformation data, i.e. rotation angles and centers, scale factors and centers, and anchor point. This data structure is stored in the GData of the actor instance instead of the actor's private data. This change gives us: • a smaller, cleaner private data structure; • no size penalty for untransformed actors; • static constant storage for the defaults, shared across all instances; • cache locality for all the decomposed transformation data, given that the structure size is smaller. At the end of the day, the only authoritative piece of information for actor transformation is the CoglMatrix that we initialize in apply_transform() from all the decomposed parameters, and that can stay inside the private data structure of ClutterActor.
2011-12-09 09:38:25 -05:00
};
const ClutterTransformInfo * _clutter_actor_get_transform_info_or_defaults (ClutterActor *self);
ClutterTransformInfo * _clutter_actor_get_transform_info (ClutterActor *self);
actor: Implement implicit animatable properties Clutter is meant to be, and I quote from the README, a toolkit: for creating fast, compelling, portable, and dynamic graphical user interfaces and yet the default mode of operation for setting an actor's state on the scene graph (position, size, opacity, rotation, scaling, depth, etc.) is *not* dynamic. We assume a static UI, and then animate it. This is the wrong way to design an API for a toolkit meant to be used to create animated user interfaces. The default mode of operation should be to implicitly animate every state transition, and only allow skipping the animation if the user consciously decides to do so — i.e. the design tenet of the API should be to make The Right Thing™ by default, and make it really hard (or even impossible) to do The Wrong Thing™. So we should identify "animatable" properties, i.e. those properties that should be implicitly animated by ClutterActor, and use the animation framework we provide to tween the transitions between the current state and the desired state; the implicit animation should happen when setting these properties using the public accessors, and not through some added functionality. For instance, the following: clutter_actor_set_position (actor, newX, newY); should not make the actor jump to the (newX, newY) point; it should tween the actor's position between the current point and the desired point. Since we have to maintain backward compatibility with existing applications, we still need to mark the transitions explicitly, but we can be smart about it, and treat transition states as a stack that can be pushed and popped, e.g.: clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_position (actor, newX, newY); clutter_actor_set_opacity (actor, newOpacity); clutter_actor_restore_easing_state (actor); And we can even start stacking animations, e.g.: clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_position (actor, newX, newY); clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_easing_mode (actor, CLUTTER_LINEAR); clutter_actor_set_opacity (actor, newOpacity); clutter_actor_set_depth (actor, newDepth); clutter_actor_restore_easing_state (actor); clutter_actor_restore_easing_state (actor); And so on, and so forth. The implementation takes advantage of the newly added Transition API, which uses only ClutterTimeline sub-classes and ClutterInterval, to cut down the amount of signal emissions and memory management of object instances; as well of using the ClutterAnimatable interface for custom properties and interpolation of values.
2012-03-15 07:09:11 -04:00
typedef struct _AState {
guint easing_duration;
actor: Add delay to the easing state It should be possible to set up the delay of a transition, but since we start the Transition instance before returning control to the caller, we cannot use clutter_actor_get_transition() to do it without something extra-awkward, like: transition = clutter_actor_get_transition (actor, "width"); clutter_timeline_stop (transition); clutter_timeline_set_delay (transition, 1000); clutter_timeline_start (transition); for each property involved. It's much easier to add a delay to the easing state of an actor.
2012-03-15 08:24:02 -04:00
guint easing_delay;
actor: Implement implicit animatable properties Clutter is meant to be, and I quote from the README, a toolkit: for creating fast, compelling, portable, and dynamic graphical user interfaces and yet the default mode of operation for setting an actor's state on the scene graph (position, size, opacity, rotation, scaling, depth, etc.) is *not* dynamic. We assume a static UI, and then animate it. This is the wrong way to design an API for a toolkit meant to be used to create animated user interfaces. The default mode of operation should be to implicitly animate every state transition, and only allow skipping the animation if the user consciously decides to do so — i.e. the design tenet of the API should be to make The Right Thing™ by default, and make it really hard (or even impossible) to do The Wrong Thing™. So we should identify "animatable" properties, i.e. those properties that should be implicitly animated by ClutterActor, and use the animation framework we provide to tween the transitions between the current state and the desired state; the implicit animation should happen when setting these properties using the public accessors, and not through some added functionality. For instance, the following: clutter_actor_set_position (actor, newX, newY); should not make the actor jump to the (newX, newY) point; it should tween the actor's position between the current point and the desired point. Since we have to maintain backward compatibility with existing applications, we still need to mark the transitions explicitly, but we can be smart about it, and treat transition states as a stack that can be pushed and popped, e.g.: clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_position (actor, newX, newY); clutter_actor_set_opacity (actor, newOpacity); clutter_actor_restore_easing_state (actor); And we can even start stacking animations, e.g.: clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_position (actor, newX, newY); clutter_actor_save_easing_state (actor); clutter_actor_set_easing_duration (actor, 500); clutter_actor_set_easing_mode (actor, CLUTTER_LINEAR); clutter_actor_set_opacity (actor, newOpacity); clutter_actor_set_depth (actor, newDepth); clutter_actor_restore_easing_state (actor); clutter_actor_restore_easing_state (actor); And so on, and so forth. The implementation takes advantage of the newly added Transition API, which uses only ClutterTimeline sub-classes and ClutterInterval, to cut down the amount of signal emissions and memory management of object instances; as well of using the ClutterAnimatable interface for custom properties and interpolation of values.
2012-03-15 07:09:11 -04:00
ClutterAnimationMode easing_mode;
} AState;
struct _ClutterAnimationInfo
{
GArray *states;
AState *cur_state;
GHashTable *transitions;
};
const ClutterAnimationInfo * _clutter_actor_get_animation_info_or_defaults (ClutterActor *self);
ClutterAnimationInfo * _clutter_actor_get_animation_info (ClutterActor *self);
ClutterTransition * _clutter_actor_create_transition (ClutterActor *self,
GParamSpec *pspec,
...);
ClutterTransition * _clutter_actor_get_transition (ClutterActor *self,
GParamSpec *pspec);
void _clutter_actor_update_transition (ClutterActor *self,
GParamSpec *pspec,
...);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
gboolean _clutter_actor_foreach_child (ClutterActor *self,
ClutterForeachCallback callback,
docs: Documentation fixes
2010-12-09 10:06:12 -05:00
gpointer user_data);
actor: make _clutter_actor_traverse more flexible This makes it possible to choose the traversal order; either depth first or breadth first and when visiting actors in a depth first order there is now a callback called before children are traversed and one called after. Some tasks such as unrealizing actors need to explicitly control the traversal order to maintain the invariable that all children of an actor are unrealized before we actually mark the parent as unrealized. The callbacks are now passed the relative depth in the graph of the actor being visited and instead of only being able to return a boolean to bail out of further traversal it can now do one of: continue, skip_children or break. To implement something like unrealize it's desirable to skip children that you find have already been unrealized.
2010-10-20 10:40:30 -04:00
void _clutter_actor_traverse (ClutterActor *actor,
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
ClutterActorTraverseFlags flags,
actor: make _clutter_actor_traverse more flexible This makes it possible to choose the traversal order; either depth first or breadth first and when visiting actors in a depth first order there is now a callback called before children are traversed and one called after. Some tasks such as unrealizing actors need to explicitly control the traversal order to maintain the invariable that all children of an actor are unrealized before we actually mark the parent as unrealized. The callbacks are now passed the relative depth in the graph of the actor being visited and instead of only being able to return a boolean to bail out of further traversal it can now do one of: continue, skip_children or break. To implement something like unrealize it's desirable to skip children that you find have already been unrealized.
2010-10-20 10:40:30 -04:00
ClutterTraverseCallback before_children_callback,
ClutterTraverseCallback after_children_callback,
docs: Documentation fixes
2010-12-09 10:06:12 -05:00
gpointer user_data);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
ClutterActor *_clutter_actor_get_stage_internal (ClutterActor *actor);
void _clutter_actor_apply_modelview_transform (ClutterActor *self,
CoglMatrix *matrix);
actor: documents _get/apply_relative_transform_matrix Although this patch doesn't make them public, it documents the _clutter_actor_get/apply_relative_transform_matrix functions so they could easily be made public if desired. I think these API could be useful to have publicly, and I originally documented them because I thought they would be needed in the MX toolkit.
2011-06-17 13:27:45 -04:00
void _clutter_actor_apply_relative_transformation_matrix (ClutterActor *self,
ClutterActor *ancestor,
CoglMatrix *matrix);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
docs: Documentation fixes
2010-12-09 10:06:12 -05:00
void _clutter_actor_rerealize (ClutterActor *self,
ClutterCallback callback,
gpointer data);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
actor: Replace private opacity_parent with opacity_override Replace the opacity_parent with an opacity_override variable, to allow direct overriding of the paint opacity and simplify this mechanism somewhat. This also required a new private flag, in_clone_paint, to maintain the functionality of the public function clutter_actor_is_in_clone_paint()
2011-02-03 08:58:20 -05:00
void _clutter_actor_set_opacity_override (ClutterActor *self,
gint opacity);
clutter-actor: Add an internal _clutter_actor_get_opacity_override This is needed if an effect wants to temporarily override the paint opacity. It needs to be able to restore the old opacity override in the post_paint handler otherwise it would replace the effect of the opacity override from any outer effects. http://bugzilla.clutter-project.org/show_bug.cgi?id=2541
2011-03-01 14:52:43 -05:00
gint _clutter_actor_get_opacity_override (ClutterActor *self);
actor: Replace private opacity_parent with opacity_override Replace the opacity_parent with an opacity_override variable, to allow direct overriding of the paint opacity and simplify this mechanism somewhat. This also required a new private flag, in_clone_paint, to maintain the functionality of the public function clutter_actor_is_in_clone_paint()
2011-02-03 08:58:20 -05:00
void _clutter_actor_set_in_clone_paint (ClutterActor *self,
actor: Rename in_clone_paint parameter to avoid variable shadowing The 'in_clone_paint' parameter of the private function _clutter_actor_set_in_clone_paint() shadowed the private function in_clone_paint(). Rename this parameter to 'is_in_clone_paint' to remove a compiler warning.
2011-02-11 11:27:46 -05:00
gboolean is_in_clone_paint);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
void _clutter_actor_set_enable_model_view_transform (ClutterActor *self,
gboolean enable);
void _clutter_actor_set_enable_paint_unmapped (ClutterActor *self,
gboolean enable);
void _clutter_actor_set_has_pointer (ClutterActor *self,
gboolean has_pointer);
void _clutter_actor_queue_redraw_with_clip (ClutterActor *self,
ClutterRedrawFlags flags,
ClutterPaintVolume *clip_volume);
clutter-effect: Add clutter_effect_queue_rerun This adds a new public function to queue a rerun of an effect. If nothing else queues a redraw then when the effect's actor is painted the effect will be run without the CLUTTER_EFFECT_RUN_ACTOR_DIRTY flag. This allows parametrised offscreen effects to report that they need to redraw the image without having to redraw the underlying actor. This will be used to implement the 'transparency' effect of ClutterActor. If multiple redraws are queued with different effects then redrawing is started from the one that occurs last in the list of effects. Internally the function is a wrapper around the new function _clutter_actor_queue_redraw_full. This is intended to be the sole point of code for queuing redraws on an actor. It has parameters for the clip and the effect. The other two existing functions to queue a redraw (one with a clip and one without) now wrap around this function by passing a NULL effect.
2011-02-28 07:16:55 -05:00
void _clutter_actor_queue_redraw_full (ClutterActor *self,
ClutterRedrawFlags flags,
ClutterPaintVolume *volume,
ClutterEffect *effect);
Optimize culling by doing culling in eye-coordinates This implements a variation of frustum culling whereby we convert screen space clip rectangles into eye space mini-frustums so that we don't have to repeatedly transform actor paint-volumes all the way into screen coordinates to perform culling, we just have to apply the modelview transform and then determine each points distance from the planes that make up the clip frustum. By avoiding the projective transform, perspective divide and viewport scale for each point culled this makes culling much cheaper.
2011-02-01 13:32:08 -05:00
ClutterPaintVolume *_clutter_actor_get_queue_redraw_clip (ClutterActor *self);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
void _clutter_actor_set_queue_redraw_clip (ClutterActor *self,
Optimize culling by doing culling in eye-coordinates This implements a variation of frustum culling whereby we convert screen space clip rectangles into eye space mini-frustums so that we don't have to repeatedly transform actor paint-volumes all the way into screen coordinates to perform culling, we just have to apply the modelview transform and then determine each points distance from the planes that make up the clip frustum. By avoiding the projective transform, perspective divide and viewport scale for each point culled this makes culling much cheaper.
2011-02-01 13:32:08 -05:00
ClutterPaintVolume *clip_volume);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
void _clutter_actor_finish_queue_redraw (ClutterActor *self,
ClutterPaintVolume *clip);
Eliminate G_CONST_RETURN The G_CONST_RETURN define in GLib is, and has always been, a bit fuzzy. We always used it to conform to the platform, at least for public-facing API. At first I assumed it has something to do with brain-damaged compilers or with weird platforms where const was not really supported; sadly, it's something much, much worse: it's a define that can be toggled at compile-time to remove const from the signature of public API. This is a truly terrifying feature that I assume was added in the past century, and whose inception clearly had something to do with massive doses of absynthe and opium — because any other explanation would make the existence of such a feature even worse than assuming drugs had anything to do with it. Anyway, and pleasing the gods, this dubious feature is being removed/deprecated in GLib; see bug: https://bugzilla.gnome.org/show_bug.cgi?id=644611 Before deprecation, though, we should just remove its usage from the whole API. We should especially remove its usage from Cally's internals, since there it never made sense in the first place.
2011-06-07 10:49:20 -04:00
gboolean _clutter_actor_set_default_paint_volume (ClutterActor *self,
GType check_gtype,
ClutterPaintVolume *volume);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
Eliminate G_CONST_RETURN The G_CONST_RETURN define in GLib is, and has always been, a bit fuzzy. We always used it to conform to the platform, at least for public-facing API. At first I assumed it has something to do with brain-damaged compilers or with weird platforms where const was not really supported; sadly, it's something much, much worse: it's a define that can be toggled at compile-time to remove const from the signature of public API. This is a truly terrifying feature that I assume was added in the past century, and whose inception clearly had something to do with massive doses of absynthe and opium — because any other explanation would make the existence of such a feature even worse than assuming drugs had anything to do with it. Anyway, and pleasing the gods, this dubious feature is being removed/deprecated in GLib; see bug: https://bugzilla.gnome.org/show_bug.cgi?id=644611 Before deprecation, though, we should just remove its usage from the whole API. We should especially remove its usage from Cally's internals, since there it never made sense in the first place.
2011-06-07 10:49:20 -04:00
const gchar * _clutter_actor_get_debug_name (ClutterActor *self);
actor: Add a get_debug_name() private Actor method For internal usage, writing: clutter_actor_get_name (actor) != NULL ? clutter_actor_get_name (actor) : G_OBJECT_TYPE_NAME (actor) is overly verbose and does two type checks. A simple, internal method for getting the same result without type checks would be much more appreciated.
2010-11-12 13:07:44 -05:00
Don't update or use last_paint_box when painting inside a clone The last_paint_box for an actor represents its "normal" position - we shouldn't update it or use it to cull drawing if we are painting a clone of the actor. Tracking whether we are painting a clone is done by adding _clutter_actor_push/pop_clone_paint() and a global "clone paint level". http://bugzilla.clutter-project.org/show_bug.cgi?id=2396
2010-11-13 11:29:49 -05:00
void _clutter_actor_push_clone_paint (void);
void _clutter_actor_pop_clone_paint (void);
Deprecate actor id The actor's id, which is currently used to generate the pick color, should not be part of the public API: it's an internal detail of the pick implementation, and having it exposed is like punching a hole through the abstraction. http://bugzilla.clutter-project.org/show_bug.cgi?id=2633 https://bugzilla.gnome.org/show_bug.cgi?id=647876
2011-04-11 07:30:51 -04:00
guint32 _clutter_actor_get_pick_id (ClutterActor *self);
actor: Move ClutterShader-related code out of clutter-actor.c Since the code dealing with ClutterShader is pretty self-contained, now, we can safely move it outside of the main ClutterActor source file and into its own. This will allow us to just drop a bunch of files when branching for 2.0.
2011-12-18 17:52:49 -05:00
void _clutter_actor_shader_pre_paint (ClutterActor *actor,
gboolean repeat);
void _clutter_actor_shader_post_paint (ClutterActor *actor);
actor: Add private get_effective_x_align() method A method to retrieve the effective horizontal alignment of the actor, taking into consideration the text direction.
2012-03-29 11:33:53 -04:00
ClutterActorAlign _clutter_actor_get_effective_x_align (ClutterActor *self);
actor: Move event chain emission into ClutterActor By moving the function that builds the event emission chain we can avoid a bunch of checks and function calls.
2012-06-24 04:58:12 -04:00
void _clutter_actor_handle_event (ClutterActor *actor,
const ClutterEvent *event);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 07:16:05 -04:00
G_END_DECLS
#endif /* __CLUTTER_ACTOR_PRIVATE_H__ */
Reference in New Issue Copy Permalink