isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2025-02-18 14:14:10 +00:00
Code Issues Packages Projects Releases Wiki Activity
mutter/clutter/clutter/clutter-actor-private.h

286 lines
12 KiB
C
Raw Normal View History

Add copyright notices
2010-10-21 13:13:00 +01: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 12:16:05 +01:00
#ifndef __CLUTTER_ACTOR_PRIVATE_H__
#define __CLUTTER_ACTOR_PRIVATE_H__
#include <clutter/clutter-actor.h>
clutter: Carry accounting of grabs in the ClutterActors holding them And make it required that actors must be mapped to hold a grab. These grabs will be automatically undone when the actor is unmapped. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2068>
2021-10-28 14:04:58 +02:00
#include <clutter/clutter-grab.h>
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 12:16:05 +01:00
G_BEGIN_DECLS
docs: Documentation fixes
2010-12-09 15:06:12 +00: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 15:40:30 +01: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 12:16:05 +01:00
*
* Controls some options for how clutter_actor_traverse() iterates
* through the graph.
*/
Use a consistent style for enum braces https://gitlab.gnome.org/GNOME/mutter/merge_requests/361
2018-12-19 09:04:25 +01: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 15:40:30 +01: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 12:16:05 +01:00
} ClutterActorTraverseFlags;
docs: Documentation fixes
2010-12-09 15:06:12 +00: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 15:40:30 +01: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 15:06:12 +00: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 15:40:30 +01: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.
*/
Use a consistent style for enum braces https://gitlab.gnome.org/GNOME/mutter/merge_requests/361
2018-12-19 09:04:25 +01: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 15:40:30 +01: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 15:06:12 +00: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 15:40:30 +01: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 15:06:12 +00: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 15:40:30 +01:00
docs: Documentation fixes
2010-12-09 15:06:12 +00:00
/*< private >
* ClutterForeachCallback:
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 12:16:05 +01: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 15:06:12 +00:00
gpointer user_data);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 12:16:05 +01: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 14:38:25 +00:00
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 18:16:29 +00: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 14:38:25 +00: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 11:09:11 +00: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 14:38:25 +00:00
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 18:16:29 +00: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 14:53:27 +01: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 18:16:29 +00: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 14:53:27 +01: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 18:16:29 +00:00
*
* Ancillary layout information for an actor.
*/
struct _ClutterLayoutInfo
{
/* fixed position coordinates */
Replace ClutterPoint by graphene_point_t Remove the tests for ClutterPoint since it's corresponding code moved to private ClutterStage methods. https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 11:53:44 -03:00
graphene_point_t 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 18:16:29 +00: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 14:13:29 +00: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 14:53:27 +01:00
guint x_expand : 1;
guint y_expand : 1;
Replace ClutterSize by graphene_size_t https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 11:27:00 -03:00
graphene_size_t minimum;
graphene_size_t 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 18:16:29 +00: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 16:31:22 +02: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 18:16:29 +00: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 14:38:25 +00:00
struct _ClutterTransformInfo
{
clutter/actor: Remove rotation center https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1332
2020-06-26 18:39:14 -03:00
/* rotation */
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 14:38:25 +00:00
gdouble rx_angle;
gdouble ry_angle;
gdouble rz_angle;
/* scaling */
gdouble scale_x;
gdouble scale_y;
actor: Add scaling factor in the Z axis Having a scaling factor on the Z axis helps with projects that use fully 3D elements, like Mash. https://bugzilla.gnome.org/show_bug.cgi?id=677853
2012-07-09 10:59:13 +01:00
gdouble scale_z;
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 14:38:25 +00:00
actor: Add translation transformation We need an alternative to the translation performed by the anchor point, one that possibly applies to all three axes and is relative to the pivot-point. https://bugzilla.gnome.org/show_bug.cgi?id=677853
2012-07-06 17:31:52 +01:00
/* translation */
Replace ClutterVertex by graphene_point3d_t Pretty direct and straightforward port. This requires a GNOME Shell counterpart. In addition to that, include a progress function. https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 10:18:48 -03:00
graphene_point3d_t translation;
actor: Add translation transformation We need an alternative to the translation performed by the anchor point, one that possibly applies to all three axes and is relative to the pivot-point. https://bugzilla.gnome.org/show_bug.cgi?id=677853
2012-07-06 17:31:52 +01: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 18:57:38 +01: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 10:35:13 +01:00
/* transformation center */
Replace ClutterPoint by graphene_point_t Remove the tests for ClutterPoint since it's corresponding code moved to private ClutterStage methods. https://gitlab.gnome.org/GNOME/mutter/merge_requests/458
2019-02-20 11:53:44 -03:00
graphene_point_t pivot;
actor: Add :pivot-point-z For some transformations we need to be able to set the Z component of the pivot point. Unlike :pivot-point, the Z coordinate is not normalized because actors are 2D surfaces. https://bugzilla.gnome.org/show_bug.cgi?id=677853
2012-07-06 14:28:48 +01:00
gfloat pivot_z;
Add ClutterActor.transform The :transform property controls the modelview matrix of an actor; it can be used to set a custom modelview matrix on the actor, as opposed to the decomposed transformations (rotation, scaling, translation) provided by the ClutterActor class.
2012-07-20 16:56:43 -04:00
Replace the CoglMatrix type by graphene_matrix_t CoglMatrix already is a typedef to graphene_matrix_t. This commit simply drops the CoglMatrix type, and align parameters. There is no functional change here, it's simply a find-and-replace commit. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1439
2020-09-11 15:57:28 -03:00
graphene_matrix_t transform;
Add ClutterActor.transform The :transform property controls the modelview matrix of an actor; it can be used to set a custom modelview matrix on the actor, as opposed to the decomposed transformations (rotation, scaling, translation) provided by the ClutterActor class.
2012-07-20 16:56:43 -04:00
guint transform_set : 1;
actor: Add the :child-transform property An additional transformation that is applied to the children of an actor before their own transformations, but not to the actor itself.
2012-08-16 17:10:50 +01:00
Replace the CoglMatrix type by graphene_matrix_t CoglMatrix already is a typedef to graphene_matrix_t. This commit simply drops the CoglMatrix type, and align parameters. There is no functional change here, it's simply a find-and-replace commit. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1439
2020-09-11 15:57:28 -03:00
graphene_matrix_t child_transform;
actor: Add the :child-transform property An additional transformation that is applied to the children of an actor before their own transformations, but not to the actor itself.
2012-08-16 17:10:50 +01:00
guint child_transform_set : 1;
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 14:38:25 +00: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 11:09:11 +00: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 12:24:02 +00: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 11:09:11 +00:00
ClutterAnimationMode easing_mode;
} AState;
struct _ClutterAnimationInfo
{
GArray *states;
AState *cur_state;
GHashTable *transitions;
};
Clean up the Actor private header Reading it is getting painful.
2013-03-07 11:23:39 +00:00
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,
...);
gboolean _clutter_actor_foreach_child (ClutterActor *self,
ClutterForeachCallback callback,
gpointer user_data);
void _clutter_actor_traverse (ClutterActor *actor,
ClutterActorTraverseFlags flags,
ClutterTraverseCallback before_children_callback,
ClutterTraverseCallback after_children_callback,
gpointer user_data);
ClutterActor * _clutter_actor_get_stage_internal (ClutterActor *actor);
Replace the CoglMatrix type by graphene_matrix_t CoglMatrix already is a typedef to graphene_matrix_t. This commit simply drops the CoglMatrix type, and align parameters. There is no functional change here, it's simply a find-and-replace commit. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1439
2020-09-11 15:57:28 -03:00
void _clutter_actor_apply_modelview_transform (ClutterActor *self,
graphene_matrix_t *matrix);
void _clutter_actor_apply_relative_transformation_matrix (ClutterActor *self,
ClutterActor *ancestor,
graphene_matrix_t *matrix);
Clean up the Actor private header Reading it is getting painful.
2013-03-07 11:23:39 +00:00
void _clutter_actor_rerealize (ClutterActor *self,
ClutterCallback callback,
gpointer data);
void _clutter_actor_set_in_clone_paint (ClutterActor *self,
gboolean is_in_clone_paint);
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);
clutter/actor: Save key-focus state and unset it before destruction When clutter actors with key focus are destroyed we emit ::key-focus-out on them just after their destruction. This is against our assumption that no signal should be emitted after "::destroy" (see GNOME/mutter!769 [1]), and in fact could cause the shell to do actions that we won't ever stop on destroy callback. To avoid this to happen, use a private function to set its key-state (so we can avoid looking for the stage) and emit ::key-focus-in/out events and use this value in both clutter_actor_has_key_focus(), clutter_actor_grab_key_focus() and on unmap and destruction to unset the stage key focus before we emit the ::destroy signal. As result of this, we can now avoid to unset the key focus on actor destruction in the stage. [1] https://gitlab.gnome.org/GNOME/mutter/merge_requests/769 Fixes https://gitlab.gnome.org/GNOME/gnome-shell/issues/1704
2019-10-10 18:11:20 +02:00
void _clutter_actor_set_has_key_focus (ClutterActor *self,
gboolean has_key_focus);
clutter: Make paint volume argument const on queue_redraw*() The given paint volume is actually unmodified, there is no need to require non-const arguments when some getters actually give const paint volumes.
2018-08-15 01:12:49 +02:00
void _clutter_actor_queue_redraw_full (ClutterActor *self,
const ClutterPaintVolume *volume,
ClutterEffect *effect);
Clean up the Actor private header Reading it is getting painful.
2013-03-07 11:23:39 +00:00
clutter: Move assembling the redraw clip out of "queue-redraw" signal Putting together the redraw clip of the stage never really fitted nicely with the "queue-redraw" signal emission, it forces us to emit the signals in a batch and we also use a weird trick to get the old paint volume that's already on-screen into the final redraw clip (we call _clutter_actor_propagate_queue_redraw() on the stage). So start breaking up this association by making the stage explicitely request the redraw clip from the actor and removing the ClutterPaintVolume argument from _clutter_actor_finish_queue_redraw(). This is done by adding a private function clutter_actor_get_redraw_clip() which returns our old (currently visible) paint volume and the new paint volume. This also allows removing the check whether a full stage redraw has been queued in clutter_actor_real_queue_redraw() and we can now just stop the signal emission if a propagation happened at least once. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1511>
2020-10-19 12:21:39 +02:00
void _clutter_actor_finish_queue_redraw (ClutterActor *self);
Clean up the Actor private header Reading it is getting painful.
2013-03-07 11:23:39 +00:00
gboolean _clutter_actor_set_default_paint_volume (ClutterActor *self,
GType check_gtype,
ClutterPaintVolume *volume);
clutter/actor: Sneakily remove the g from the debug names gchar Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1700>
2021-02-04 08:50:49 +01:00
const char * _clutter_actor_get_debug_name (ClutterActor *self);
Clean up the Actor private header Reading it is getting painful.
2013-03-07 11:23:39 +00:00
void _clutter_actor_push_clone_paint (void);
void _clutter_actor_pop_clone_paint (void);
ClutterActorAlign _clutter_actor_get_effective_x_align (ClutterActor *self);
actor: Keep track of clones Instead of using signal notifications, we should be able to keep track of the clones of an actor from within ClutterActor itself, using private API. There's no point in pretending that people can actually create a Clone class out of tree, given the amount of invariants we have to punch through in order to implement a proper replicator node of the scene graph, so we can just skip the signal emissions and just do the right thing at the right time.
2013-03-07 18:09:33 +00:00
void _clutter_actor_attach_clone (ClutterActor *actor,
ClutterActor *clone);
void _clutter_actor_detach_clone (ClutterActor *actor,
ClutterActor *clone);
Bind constraints: Don't force redraws on source relayout When the source actor potentially changes size, that shouldn't necessarily result in the target actor being redrawn - it should be like when a child of a container is reallocated due to changes in its siblings or parent - it should redraw only to the extent that it is moved and resized. Privately export an internal function from clutter-actor.c to allow getting this right. https://bugzilla.gnome.org/show_bug.cgi?id=719367
2013-11-22 10:30:21 -05:00
void _clutter_actor_queue_only_relayout (ClutterActor *actor);
clutter/actor: Stop transitions in children when removing When we remove a child, we stop its transitions (animations), but we didn't stop animations on grand children. What we did, however, was to clear the stage views of the grand children, and this caused a bunch of orphaned transitions (ClutterTimeline) and accompanied warnings. Make it so that if we stop transitions, and clear stage views, also stop transitions for the grand children. Detached children don't have a way to continue animating anyway, since they have no stage view (thus frame clock) to be driven by. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2716>
2022-11-24 16:18:04 +01:00
void clutter_actor_clear_stage_views_recursive (ClutterActor *actor,
gboolean stop_transitions);
actor: Keep track of clones Instead of using signal notifications, we should be able to keep track of the clones of an actor from within ClutterActor itself, using private API. There's no point in pretending that people can actually create a Clone class out of tree, given the amount of invariants we have to punch through in order to implement a proper replicator node of the scene graph, so we can just skip the signal emissions and just do the right thing at the right time.
2013-03-07 18:09:33 +00:00
clutter/actor: Always return a resource scale in get_resource_scale() Since we now always return a resource scale, we can remove the boolean return value from clutter_actor_get_resource_scale() and _clutter_actor_get_real_resource_scale(), and instead simply return the scale. While at it, also remove the underscore from the _clutter_actor_get_real_resource_scale() private API. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1276
2020-04-10 11:41:58 +02:00
float clutter_actor_get_real_resource_scale (ClutterActor *actor);
actor: Add private getter for the active framebuffer Instead of asking every internal user to get the stage and get the active framebuffer from it, we can wrap it up ourselves, and do some sanity checks as well.
2013-12-03 12:11:43 +00:00
actor: Add internal "create textute node" function To avoid excessive copy and paste. We could even consider making it public before release.
2015-08-24 09:59:16 +01:00
ClutterPaintNode * clutter_actor_create_texture_paint_node (ClutterActor *self,
CoglTexture *texture);
clutter/actor: Update all last_paint_volumes before painting Updating the last_paint_volume while painting has proven itself to be quite prone to issues: First we had to make sure actors painted by offscreen effects get their last_paint_volumes updated correctly (see 0320649a1c50993f308344e0dd296abaad0ee6d4), and now a new issue turned up where we don't update the paint volumes while a fullscreen unredirect is happening. To stop those issues from happening and to lay the foundation for using the last_paint_volume for other things, update the last_paint_volume in a separate step before painting instead of doing it in clutter_actor_paint(). To save some resources, avoid introducing another traversal of the scenegraph and add that step into the existing step of updating the stage_views lists of actors. To properly update the paint volumes, we need to do that after finishing the queued redraws, which is why we move clutter_stage_maybe_finish_queue_redraws() to happen before the new clutter_stage_finish_layout(). Fixes https://gitlab.gnome.org/GNOME/mutter/-/issues/1699 Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1773>
2021-03-13 20:43:13 +01:00
void clutter_actor_finish_layout (ClutterActor *self,
int phase);
clutter: Add private API to support resource scale affecting layout For ClutterText, the resource scale the text is drawn with affects the size of the allocation: ClutterText will choose a font scale based on the resource scale, and that font scale can lead to a slight difference in size compared to the unscaled font. We currently handle that by queuing a relayout inside the "resource-scale-changed" signal handler. This solution is a bit problematic though since it will take one more allocation cycle until the allocation is actually updated after a scale-change, so the actor is painted using the wrong allocation for one frame. Also the current solution can lead to relayout loops in a few cases, for example if a ClutterText is located near the edge on a 1x scaled monitor and is moved to intersect a 2x scaled monitor: Now the resource scale will change to 2 and a new allocation box is calculated; if this allocation box is slightly smaller than the old one because of the new font scale, the allocation won't intersect the 2x scaled monitor again and the resource scale switches back to 1. Now the allocation gets larger again and intersects the 2x scaled monitor again. This commit introduces a way to properly support those actors: In case an actors resource scale might affect its allocation, it should call the private function clutter_actor_queue_immediate_relayout(). This will make sure the actor gets a relayout before the upcoming paint happens afte every resource scale change. Also potential relayout loops can be handled by the actors themselves using a "phase" argument that's passed to implementations of the calculate_resource_scale() vfunc. The new API is private because resource scales are not meant to be used in a way where the scale affects the allocation. With ClutterText and the current behavior of Pango, that can't be avoid though, so we need it anyway. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1276
2020-04-10 14:54:11 +02:00
void clutter_actor_queue_immediate_relayout (ClutterActor *self);
clutter/actor: Add API to get the stage-views an actor is painted on There are certain rendering techniques and optimizations, for example the unredirection of non-fullscreen windows, where information about the output/stage-view an actor is on is needed to determine whether the optimization can be enabled. So add a new method to ClutterActor that allows listing the stage-views the actor is being painted on: clutter_actor_peek_stage_views() With the way Clutter works, the only point where we can reliably get this information is during or right before the paint phase, when the layout phase of the stage has been completed and no more changes to the actors transformation matrices happen. So to get the stage views the actor is on, introduce a new step that's done on every master clock tick between layout and paint cycle: Traversing through the actor tree and updating the stage-views the mapped actors are going to be painted on. We're doing this in a separate step instead of inside clutter_actor_paint() itself for a few reasons: It keeps the code separate from the painting code, making profiling easier and issues easier to track down (hopefully), it allows for a new "stage-views-changed" signal that doesn't interfere with painting, and finally, it will make it very easy to update the resource scales in the same step in the future. Currently, this list is only invalidated on allocation changes of actors, but not on changes to the transformation matrices. That's because there's no proper API to invalidate the transformation matrices ClutterActor implementations can apply through the apply_transform() vfunc. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1196
2020-04-10 00:34:49 +02:00
clutter/actor: Add private API to get whether we're painting unmapped Add new private API to ClutterActor, returning TRUE in case the actor is being painted while unmapped. This is useful for implementations of the paint() vfunc or for signal handlers of the "notify::mapped" signal. Use this API in CallyActor to properly detect "notify::mapped" emissions while painting unmapped, this fixes detecting the case where painting-unmapped is used for screencasting. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1366
2020-07-11 12:18:59 +02:00
gboolean clutter_actor_is_painting_unmapped (ClutterActor *self);
clutter: Carry accounting of grabs in the ClutterActors holding them And make it required that actors must be mapped to hold a grab. These grabs will be automatically undone when the actor is unmapped. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2068>
2021-10-28 14:04:58 +02:00
void clutter_actor_attach_grab (ClutterActor *actor,
ClutterGrab *grab);
void clutter_actor_detach_grab (ClutterActor *actor,
ClutterGrab *grab);
clutter: Reuse GPtrArray for event emission _clutter_actor_handle_event() currently allocates a new GPtrArray on the heap for every single event emission, let's avoid this by keeping an array around in ClutterStage and reusing that. This is moving the last few bits of event emission into ClutterStage, which will be useful when we introduce implicit grabbing in subsequent commits. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2342>
2022-08-03 17:47:01 +02:00
void clutter_actor_collect_event_actors (ClutterActor *self,
ClutterActor *deepmost,
GPtrArray *actors);
clutter/actor: Introduce private function to peek actions We'll need to take a look at the actions of actors twice for every single event emission once we move emission to the stage, let's not copy around lists for that. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2342>
2022-08-03 18:39:44 +02:00
const GList * clutter_actor_peek_actions (ClutterActor *self);
clutter: Implicitly grab on button and touch event sequences We'll soon introduce a new gesture tracking framework which heavily depends on ClutterActions seeing all events of a sequence. For this to work, a larger change to event delivery is needed: Implicit grabbing of all events for button and touch press->motion->release sequences to ensure ClutterActions continue receiving events for the whole sequence. This commit takes care of that: At the start of an event sequence we collect all the event-handling actors and actions to a GArray that lives in the PointerDeviceEntry, and then deliver all events belonging to that sequence to the same actors/actions until the sequence ends. To avoid events getting pulled from under our feet when mutters event filter returns CLUTTER_EVENT_STOP, this also introduces private API (maybe_lost_implicit_grab()) on ClutterStage so that we can't end up with stale sequences. Note that this also slightly changes behavior when it comes to event delivery to actions: Because we now store actions separated from their actors, any action returning CLUTTER_EVENT_STOP now stops event propagation immediately. That was different before, where we'd emit events to all actions of the actor and only then stop propagation. Note that this isn't handling ClutterGrabs correctly right now, this will be a little tricky, so we'll take care of that in a future commit. To handle actors getting destroyed or unmapped during a grab, listen to notify::grab on the deepmost actor in the implicit grab tree. This gives us a notification when any actor inside the tree goes unmapped. Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/2342>
2022-08-03 17:57:13 +02:00
void clutter_actor_set_implicitly_grabbed (ClutterActor *actor,
gboolean is_implicitly_grabbed);
Clean up clutter-private.h/6 Move all Actor private API to a separate file.
2010-10-21 12:16:05 +01:00
G_END_DECLS
#endif /* __CLUTTER_ACTOR_PRIVATE_H__ */
Reference in New Issue Copy Permalink