brl/mutter
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

clutter/actor: Use stage-views list for resource scales

Browse Source 
Now that ClutterActor has a convenient API for getting the stage views
an actor is presented on, we can remove a large part of the code for
resource-scale calculation and instead rely on the stage-views list.

The way this works is a bit different from the old resource scales:
clutter_actor_get_resource_scale() always returns a scale, but this
value is only guaranteed to be correct when called from a vfunc_paint()
implementation, in all other cases the value is guessed using the scale
of the parent actor or the last valid scale. Now in case the value
previously reported by clutter_actor_get_resource_scale() turns out to
be wrong, "resource-scale-changed" will be emitted before the next paint
and the actor has a chance to update its resources.

The general idea behind this new implementation is for actors which only
need the scale during painting to continue using
clutter_actor_get_resource_scale() as they do right now, and for actors
which need the resource scale on other occasions, like during size
negotiation, to use the scale reported by
clutter_actor_get_resource_scale() but also listen to the
"resource-scale-changed" signal to eventually redo the work using the
correct scale.

The "guessing" of the scale is done with the intention of always giving
actors a scale to work with so they don't have to fall back to a scale
value the actor itself has to define, and also with the intention of
emitting the "resource-scale-changed" signal as rarely as possible, so
that when an actor is newly created, it won't have to load its resources
multiple times.

The big advantage this has over the old resource scales is that it's now
safe to call clutter_actor_get_resource_scale() from everywhere (before,
calling it from size negotiation functions would usually fail). It will
also make it a lot easier to use the resource scale for complex cases
like ClutterText without risking to get into relayout loops.

https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1276
This commit is contained in:
Jonas Dreßler 2020-04-10 01:53:38 +02:00 committed by Jonas Ådahl
parent 802b24a640
commit 4a72ac0516
1 changed files with 105 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

268
clutter/clutter/clutter-actor.c
View File

@ -854,7 +854,6 @@ struct _ClutterActorPrivate
guint needs_y_expand : 1;
guint needs_paint_volume_update : 1;
guint had_effects_on_last_paint_volume_update : 1;
guint needs_compute_resource_scale : 1;
guint absolute_origin_changed : 1;
guint needs_update_stage_views : 1;
};
@ -1075,8 +1074,6 @@ static void clutter_actor_set_child_transform_internal (ClutterActor *sel
static void clutter_actor_realize_internal (ClutterActor *self);
static void clutter_actor_unrealize_internal (ClutterActor *self);
static gboolean clutter_actor_update_resource_scale (ClutterActor *self);
static void clutter_actor_ensure_resource_scale (ClutterActor *self);
static void clutter_actor_push_in_cloned_branch (ClutterActor *self,
gulong count);
@ -1618,8 +1615,6 @@ clutter_actor_real_map (ClutterActor *self)
queue_update_stage_views (self);
}
clutter_actor_ensure_resource_scale (self);
/* notify on parent mapped before potentially mapping
* children, so apps see a top-down notification.
*/
@ -2530,7 +2525,6 @@ clutter_actor_notify_if_geometry_changed (ClutterActor *self,
static void
absolute_allocation_changed (ClutterActor *actor)
{
actor->priv->needs_compute_resource_scale = TRUE;
queue_update_stage_views (actor);
}
@ -3731,8 +3725,6 @@ clutter_actor_paint (ClutterActor *self,
if (!CLUTTER_ACTOR_IS_MAPPED (self))
return;
clutter_actor_ensure_resource_scale (self);
actor_node = clutter_actor_node_new (self);
root_node = clutter_paint_node_ref (actor_node);
@ -4014,8 +4006,6 @@ clutter_actor_pick (ClutterActor *actor,
if (!CLUTTER_ACTOR_IS_MAPPED (actor))
return;
clutter_actor_ensure_resource_scale (actor);
/* mark that we are in the paint process */
CLUTTER_SET_PRIVATE_FLAGS (actor, CLUTTER_IN_PICK);
@ -4342,10 +4332,7 @@ clutter_actor_remove_child_internal (ClutterActor *self,
clutter_actor_clear_stage_views_recursive (child);
if (emit_parent_set && !CLUTTER_ACTOR_IN_DESTRUCTION (child))
{
child->priv->needs_compute_resource_scale = TRUE;
g_signal_emit (child, actor_signals[PARENT_SET], 0, self);
}
g_signal_emit (child, actor_signals[PARENT_SET], 0, self);
/* if the child was mapped then we need to relayout ourselves to account
* for the removed child
@ -7994,7 +7981,6 @@ clutter_actor_init (ClutterActor *self)
priv->needs_height_request = TRUE;
priv->needs_allocation = TRUE;
priv->needs_paint_volume_update = TRUE;
priv->needs_compute_resource_scale = TRUE;
priv->needs_update_stage_views = TRUE;
priv->cached_width_age = 1;
@ -11895,10 +11881,7 @@ clutter_actor_add_child_internal (ClutterActor *self,
}
if (emit_parent_set)
{
child->priv->needs_compute_resource_scale = TRUE;
g_signal_emit (child, actor_signals[PARENT_SET], 0, NULL);
}
g_signal_emit (child, actor_signals[PARENT_SET], 0, NULL);
if (check_state)
{
@ -15958,107 +15941,6 @@ clutter_actor_get_paint_box (ClutterActor *self,
return TRUE;
}
static gboolean
_clutter_actor_get_resource_scale_for_rect (ClutterActor *self,
graphene_rect_t *bounding_rect,
float *resource_scale)
{
ClutterActor *stage;
g_autoptr (GList) views = NULL;
GList *l;
float max_scale = 0;
stage = _clutter_actor_get_stage_internal (self);
if (!stage)
return FALSE;
views = clutter_stage_get_views_for_rect (CLUTTER_STAGE (stage),
bounding_rect);
if (!views)
return FALSE;
for (l = views; l; l = l->next)
{
ClutterStageView *view = l->data;
max_scale = MAX (clutter_stage_view_get_scale (view), max_scale);
}
*resource_scale = max_scale;
return TRUE;
}
static gboolean
_clutter_actor_compute_resource_scale (ClutterActor *self,
float *resource_scale)
{
graphene_rect_t bounding_rect;
ClutterActorPrivate *priv = self->priv;
if (CLUTTER_ACTOR_IN_DESTRUCTION (self) ||
CLUTTER_ACTOR_IN_PREF_SIZE (self) ||
!clutter_actor_is_mapped (self))
{
return FALSE;
}
clutter_actor_get_transformed_position (self,
&bounding_rect.origin.x,
&bounding_rect.origin.y);
clutter_actor_get_transformed_size (self,
&bounding_rect.size.width,
&bounding_rect.size.height);
if (bounding_rect.size.width == 0.0 ||
bounding_rect.size.height == 0.0 ||
!_clutter_actor_get_resource_scale_for_rect (self,
&bounding_rect,
resource_scale))
{
if (priv->parent)
{
gboolean in_clone_paint;
gboolean was_parent_in_clone_paint;
gboolean was_parent_unmapped;
gboolean was_parent_paint_unmapped;
gboolean ret;
in_clone_paint = clutter_actor_is_in_clone_paint (self);
was_parent_unmapped = !clutter_actor_is_mapped (priv->parent);
was_parent_in_clone_paint =
clutter_actor_is_in_clone_paint (priv->parent);
was_parent_paint_unmapped = priv->parent->priv->enable_paint_unmapped;
if (in_clone_paint && was_parent_unmapped)
{
_clutter_actor_set_in_clone_paint (priv->parent, TRUE);
_clutter_actor_set_enable_paint_unmapped (priv->parent, TRUE);
}
ret = _clutter_actor_compute_resource_scale (priv->parent,
resource_scale);
if (in_clone_paint && was_parent_unmapped)
{
_clutter_actor_set_in_clone_paint (priv->parent,
was_parent_in_clone_paint);
_clutter_actor_set_enable_paint_unmapped (priv->parent,
was_parent_paint_unmapped);
}
return ret;
}
else
{
return FALSE;
}
}
return TRUE;
}
static ClutterActorTraverseVisitFlags
clear_stage_views_cb (ClutterActor *actor,
int depth,
@ -16067,7 +15949,6 @@ clear_stage_views_cb (ClutterActor *actor,
g_autoptr (GList) old_stage_views = NULL;
actor->priv->needs_update_stage_views = TRUE;
actor->priv->needs_compute_resource_scale = TRUE;
old_stage_views = g_steal_pointer (&actor->priv->stage_views);
@ -16087,58 +15968,63 @@ clutter_actor_clear_stage_views_recursive (ClutterActor *self)
NULL);
}
static gboolean
clutter_actor_update_resource_scale (ClutterActor *self)
{
ClutterActorPrivate *priv;
float resource_scale;
float old_resource_scale;
priv = self->priv;
g_return_val_if_fail (priv->needs_compute_resource_scale, FALSE);
old_resource_scale = priv->resource_scale;
priv->resource_scale = -1.0f;
if (_clutter_actor_compute_resource_scale (self, &resource_scale))
{
priv->resource_scale = resource_scale;
priv->needs_compute_resource_scale = FALSE;
return fabsf (old_resource_scale - resource_scale) > FLT_EPSILON;
}
return FALSE;
}
static void
clutter_actor_ensure_resource_scale (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
if (!priv->needs_compute_resource_scale)
return;
if (clutter_actor_update_resource_scale (self))
g_signal_emit (self, actor_signals[RESOURCE_SCALE_CHANGED], 0);
}
gboolean
_clutter_actor_get_real_resource_scale (ClutterActor *self,
gfloat *resource_scale)
{
ClutterActorPrivate *priv = self->priv;
float guessed_scale;
clutter_actor_ensure_resource_scale (self);
if (!priv->needs_compute_resource_scale)
if (priv->resource_scale != -1.f)
{
*resource_scale = priv->resource_scale;
return TRUE;
}
*resource_scale = -1.0f;
return FALSE;
/* If the scale hasn't been computed yet, we return a best guess */
if (priv->parent != NULL)
{
/* If the scale hasn't been calculated yet, assume this actor is located
* inside its parents box and go up the hierarchy.
*/
_clutter_actor_get_real_resource_scale (priv->parent, &guessed_scale);
}
else if (CLUTTER_ACTOR_IS_TOPLEVEL (self))
{
/* This must be the first allocation cycle and the resource scale of
* the stage has not been updated yet, so return it manually.
*/
GList *l;
ClutterStage *stage = CLUTTER_STAGE (self);
float max_scale = -1.f;
for (l = clutter_stage_peek_stage_views (stage); l; l = l->next)
{
ClutterStageView *view = l->data;
max_scale = MAX (clutter_stage_view_get_scale (view), max_scale);
}
guessed_scale = max_scale;
}
else
{
ClutterBackend *backend = clutter_get_default_backend ();
guessed_scale = clutter_backend_get_fallback_resource_scale (backend);
}
g_assert (guessed_scale >= 1.f);
/* Always return this value until we compute the correct one later.
* If our guess turns out to be wrong, we'll emit "resource-scale-changed"
* and correct it before painting.
*/
priv->resource_scale = guessed_scale;
*resource_scale = priv->resource_scale;
return TRUE;
}
/**
@ -16146,7 +16032,7 @@ _clutter_actor_get_real_resource_scale (ClutterActor *self,
* @self: A #ClutterActor
* @resource_scale: (out): return location for the resource scale
*
* Retrieves the resource scale for this actor, if available.
* Retrieves the resource scale for this actor.
*
* The resource scale refers to the scale the actor should use for its resources.
* For example if an actor draws a a picture of size 100 x 100 in the stage
@ -16156,6 +16042,24 @@ _clutter_actor_get_real_resource_scale (ClutterActor *self,
* The resource scale is determined by calculating the highest #ClutterStageView
* scale the actor will get painted on.
*
* Note that the scale returned by this function is only guaranteed to be
* correct when queried during the paint cycle, in all other cases this
* function will only return a best guess. If your implementation really
* needs to get a resource scale outside of the paint cycle, make sure to
* subscribe to the "resource-scale-changed" signal to get notified about
* the new, correct resource scale before painting.
*
* Also avoid getting the resource scale for actors that are not attached
* to a stage. There's no sane way for Clutter to guess which #ClutterStageView
* the actor is going to be painted on, so you'll probably end up receiving
* the "resource-scale-changed" signal and having to rebuild your resources.
*
* The best guess this function may return is usually just the last resource
* scale the actor got painted with. If this resource scale couldn't be found
* because the actor was never painted so far or Clutter was unable to
* determine its position and size, this function will return the resource
* scale of a parent.
*
* Returns: TRUE if resource scale is set for the actor, otherwise FALSE
*/
gboolean
@ -16240,6 +16144,43 @@ out:
}
}
static void
update_resource_scale (ClutterActor *self)
{
ClutterActorPrivate *priv = self->priv;
GList *l;
float new_resource_scale = -1.f;
float old_resource_scale;
for (l = priv->stage_views; l; l = l->next)
{
ClutterStageView *view = l->data;
new_resource_scale = MAX (clutter_stage_view_get_scale (view),
new_resource_scale);
}
if (priv->resource_scale == new_resource_scale)
return;
/* If the actor moved out of the stage, simply keep the last scale */
if (new_resource_scale == -1.f)
return;
old_resource_scale = priv->resource_scale;
priv->resource_scale = new_resource_scale;
/* Never notify the initial change, otherwise, to be consistent,
* we'd also have to notify if we guessed correctly in
* _clutter_actor_get_real_resource_scale().
*/
if (old_resource_scale == -1.f)
return;
if (ceilf (old_resource_scale) != ceilf (priv->resource_scale))
g_signal_emit (self, actor_signals[RESOURCE_SCALE_CHANGED], 0);
}
void
clutter_actor_update_stage_views (ClutterActor *self)
{
@ -16254,6 +16195,7 @@ clutter_actor_update_stage_views (ClutterActor *self)
return;
update_stage_views (self);
update_resource_scale (self);
priv->needs_update_stage_views = FALSE;