From 162aec7802317596395636696d919d19104e1b74 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20Dre=C3=9Fler?= Date: Fri, 10 Apr 2020 14:16:53 +0200 Subject: [PATCH 1/6] clutter: Replace ClutterActors resource-scale property with a signal We're going to refactor resource scales, making the notification of changes to the resource scale a lot more important than it is right now (we won't guarantee queried scales are correct outside the paint cycle anymore). Having a separate signal/vfunc for this will make the difference between the new clutter_actor_get_resource_scale() API (which can return a guessed value) and the notification of changes to the resource scale (which will be guaranteed to return an up-to-date value) more obvious. So replace the "resource-scale" property of ClutterActor with a "resource-scale-changed" signal that's emitted when the resource scale is recalculated. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1276 --- clutter/clutter/clutter-actor.c | 44 ++++++++++++++------------------- clutter/clutter/clutter-actor.h | 1 + clutter/clutter/clutter-text.c | 33 +++++++++---------------- 3 files changed, 32 insertions(+), 46 deletions(-) diff --git a/clutter/clutter/clutter-actor.c b/clutter/clutter/clutter-actor.c index 061d516b604..591b9db7718 100644 --- a/clutter/clutter/clutter-actor.c +++ b/clutter/clutter/clutter-actor.c @@ -924,7 +924,6 @@ enum PROP_SCALE_X, PROP_SCALE_Y, PROP_SCALE_Z, - PROP_RESOURCE_SCALE, PROP_ROTATION_ANGLE_X, /* XXX:2.0 rename to rotation-x */ PROP_ROTATION_ANGLE_Y, /* XXX:2.0 rename to rotation-y */ @@ -1005,6 +1004,7 @@ enum TOUCH_EVENT, TRANSITION_STOPPED, STAGE_VIEWS_CHANGED, + RESOURCE_SCALE_CHANGED, LAST_SIGNAL }; @@ -5375,16 +5375,6 @@ clutter_actor_get_property (GObject *object, } break; - case PROP_RESOURCE_SCALE: - if (priv->needs_compute_resource_scale) - { - if (!clutter_actor_update_resource_scale (actor)) - g_warning ("Getting invalid resource scale property"); - } - - g_value_set_float (value, priv->resource_scale); - break; - case PROP_REACTIVE: g_value_set_boolean (value, clutter_actor_get_reactive (actor)); break; @@ -6678,19 +6668,6 @@ clutter_actor_class_init (ClutterActorClass *klass) G_PARAM_STATIC_STRINGS | CLUTTER_PARAM_ANIMATABLE); - /** - * ClutterActor:resource-scale: - * - * The resource-scale of the #ClutterActor if any or -1 if not available - */ - obj_props[PROP_RESOURCE_SCALE] = - g_param_spec_float ("resource-scale", - P_("Resource Scale"), - P_("The Scaling factor for resources painting"), - -1.0f, G_MAXFLOAT, - 1.0f, - CLUTTER_PARAM_READABLE); - /** * ClutterActor:rotation-angle-x: * @@ -7981,6 +7958,23 @@ clutter_actor_class_init (ClutterActorClass *klass) NULL, NULL, NULL, G_TYPE_NONE, 0); + /** + * ClutterActor::resource-scale-changed: + * @actor: a #ClutterActor + * + * The ::resource-scale-changed signal is emitted when the resource scale + * value returned by clutter_actor_get_resource_scale() changes. + * + * This signal can be used to get notified about the correct resource scale + * when the scale had to be queried outside of the paint cycle. + */ + actor_signals[RESOURCE_SCALE_CHANGED] = + g_signal_new (I_("resource-scale-changed"), + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (ClutterActorClass, resource_scale_changed), + NULL, NULL, NULL, + G_TYPE_NONE, 0); } static void @@ -16126,7 +16120,7 @@ clutter_actor_ensure_resource_scale (ClutterActor *self) return; if (clutter_actor_update_resource_scale (self)) - g_object_notify_by_pspec (G_OBJECT (self), obj_props[PROP_RESOURCE_SCALE]); + g_signal_emit (self, actor_signals[RESOURCE_SCALE_CHANGED], 0); } gboolean diff --git a/clutter/clutter/clutter-actor.h b/clutter/clutter/clutter-actor.h index c6b375e1dc6..fac28e74cd7 100644 --- a/clutter/clutter/clutter-actor.h +++ b/clutter/clutter/clutter-actor.h @@ -296,6 +296,7 @@ struct _ClutterActorClass gboolean (* touch_event) (ClutterActor *self, ClutterTouchEvent *event); gboolean (* has_accessible) (ClutterActor *self); + void (* resource_scale_changed) (ClutterActor *self); /*< private >*/ /* padding for future expansion */ diff --git a/clutter/clutter/clutter-text.c b/clutter/clutter/clutter-text.c index 444786125b6..db20be10dff 100644 --- a/clutter/clutter/clutter-text.c +++ b/clutter/clutter/clutter-text.c @@ -187,9 +187,6 @@ struct _ClutterTextPrivate ClutterInputContentHintFlags input_hints; ClutterInputContentPurpose input_purpose; - /* Signal handler for when the :resource-scale changes */ - gulong resource_scale_changed_id; - /* bitfields */ guint alignment : 2; guint wrap : 1; @@ -922,18 +919,6 @@ clutter_text_direction_changed_cb (GObject *gobject, /* no need to queue a relayout: set_text_direction() will do that for us */ } -static void -clutter_text_resource_scale_changed_cb (GObject *gobject, - GParamSpec *pspec) -{ - ClutterText *self = CLUTTER_TEXT (gobject); - ClutterTextPrivate *priv = self->priv; - - g_clear_pointer (&priv->effective_attrs, pango_attr_list_unref); - clutter_text_dirty_cache (self); - clutter_actor_queue_relayout (CLUTTER_ACTOR (gobject)); -} - /* * clutter_text_create_layout: * @text: a #ClutterText @@ -1776,7 +1761,6 @@ clutter_text_dispose (GObject *gobject) clutter_text_dirty_cache (self); g_clear_signal_handler (&priv->direction_changed_id, self); - g_clear_signal_handler (&priv->resource_scale_changed_id, self); g_clear_signal_handler (&priv->settings_changed_id, clutter_get_default_backend ()); @@ -3066,6 +3050,17 @@ clutter_text_has_overlaps (ClutterActor *self) return clutter_text_should_draw_cursor ((ClutterText *) self); } +static void +clutter_text_resource_scale_changed (ClutterActor *actor) +{ + ClutterText *self = CLUTTER_TEXT (actor); + ClutterTextPrivate *priv = self->priv; + + g_clear_pointer (&priv->effective_attrs, pango_attr_list_unref); + clutter_text_dirty_cache (self); + clutter_actor_queue_relayout (actor); +} + static void clutter_text_im_focus (ClutterText *text) { @@ -3814,6 +3809,7 @@ clutter_text_class_init (ClutterTextClass *klass) actor_class->key_focus_in = clutter_text_key_focus_in; actor_class->key_focus_out = clutter_text_key_focus_out; actor_class->has_overlaps = clutter_text_has_overlaps; + actor_class->resource_scale_changed = clutter_text_resource_scale_changed; /** * ClutterText:buffer: @@ -4621,11 +4617,6 @@ clutter_text_init (ClutterText *self) NULL); priv->input_focus = clutter_text_input_focus_new (self); - - priv->resource_scale_changed_id = - g_signal_connect (self, "notify::resource-scale", - G_CALLBACK (clutter_text_resource_scale_changed_cb), - NULL); } /** -- GitLab From 802b24a640edbdef4ad94c20d23663800c5c0e68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20Dre=C3=9Fler?= Date: Sat, 6 Jun 2020 22:58:10 +0200 Subject: [PATCH 2/6] clutter/backend: Introduce a fallback scale set to primary monitor scale Add private API to ClutterBackend to set a fallback resource scale available to Clutter. This API will be used for "guessing" the resource-scale of ClutterActors in case the actor is not attached to a stage or not properly positioned yet. We set this value from inside mutters MetaRenderer while creating new stage-views for each logical monitor. This makes it possible to set the fallback scale to the scale of the primary monitor, which is the monitor where most ClutterActors are going to be positioned. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1276 --- clutter/clutter/clutter-backend-private.h | 8 ++++++++ clutter/clutter/clutter-backend.c | 13 +++++++++++++ src/backends/meta-renderer.c | 13 +++++++++++++ 3 files changed, 34 insertions(+) diff --git a/clutter/clutter/clutter-backend-private.h b/clutter/clutter/clutter-backend-private.h index c7c54f85be5..d5dca0d25db 100644 --- a/clutter/clutter/clutter-backend-private.h +++ b/clutter/clutter/clutter-backend-private.h @@ -53,6 +53,8 @@ struct _ClutterBackend gfloat units_per_em; gint32 units_serial; + float fallback_resource_scale; + ClutterStageWindow *stage_window; ClutterInputMethod *input_method; @@ -134,6 +136,12 @@ void clutter_set_allowed_drivers (const c CLUTTER_EXPORT ClutterStageWindow * clutter_backend_get_stage_window (ClutterBackend *backend); +CLUTTER_EXPORT +void clutter_backend_set_fallback_resource_scale (ClutterBackend *backend, + float fallback_resource_scale); + +float clutter_backend_get_fallback_resource_scale (ClutterBackend *backend); + G_END_DECLS #endif /* __CLUTTER_BACKEND_PRIVATE_H__ */ diff --git a/clutter/clutter/clutter-backend.c b/clutter/clutter/clutter-backend.c index 3cc4ca29746..20d89611541 100644 --- a/clutter/clutter/clutter-backend.c +++ b/clutter/clutter/clutter-backend.c @@ -1031,3 +1031,16 @@ clutter_backend_get_default_seat (ClutterBackend *backend) return CLUTTER_BACKEND_GET_CLASS (backend)->get_default_seat (backend); } + +void +clutter_backend_set_fallback_resource_scale (ClutterBackend *backend, + float fallback_resource_scale) +{ + backend->fallback_resource_scale = fallback_resource_scale; +} + +float +clutter_backend_get_fallback_resource_scale (ClutterBackend *backend) +{ + return backend->fallback_resource_scale; +} diff --git a/src/backends/meta-renderer.c b/src/backends/meta-renderer.c index b5cc37efbfc..e0107ec9d63 100644 --- a/src/backends/meta-renderer.c +++ b/src/backends/meta-renderer.c @@ -153,6 +153,19 @@ meta_renderer_real_rebuild_views (MetaRenderer *renderer) { MetaLogicalMonitor *logical_monitor = l->data; + if (meta_logical_monitor_is_primary (logical_monitor)) + { + ClutterBackend *clutter_backend; + float scale; + + clutter_backend = meta_backend_get_clutter_backend (backend); + scale = meta_is_stage_views_scaled () + ? meta_logical_monitor_get_scale (logical_monitor) + : 1.f; + + clutter_backend_set_fallback_resource_scale (clutter_backend, scale); + } + meta_logical_monitor_foreach_crtc (logical_monitor, create_crtc_view, renderer); -- GitLab From 4a72ac05160b2af22bcfce40b716c9c30c534906 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20Dre=C3=9Fler?= Date: Fri, 10 Apr 2020 01:53:38 +0200 Subject: [PATCH 3/6] clutter/actor: Use stage-views list for resource scales 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 --- clutter/clutter/clutter-actor.c | 264 +++++++++++++------------------- 1 file changed, 103 insertions(+), 161 deletions(-) diff --git a/clutter/clutter/clutter-actor.c b/clutter/clutter/clutter-actor.c index 591b9db7718..a31b48fa134 100644 --- a/clutter/clutter/clutter-actor.c +++ b/clutter/clutter/clutter-actor.c @@ -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) +gboolean +_clutter_actor_get_real_resource_scale (ClutterActor *self, + gfloat *resource_scale) { - ClutterActorPrivate *priv; - float resource_scale; - float old_resource_scale; - priv = self->priv; + ClutterActorPrivate *priv = self->priv; + float guessed_scale; - g_return_val_if_fail (priv->needs_compute_resource_scale, FALSE); + if (priv->resource_scale != -1.f) + { + *resource_scale = priv->resource_scale; + return TRUE; + } - old_resource_scale = priv->resource_scale; - priv->resource_scale = -1.0f; + /* If the scale hasn't been computed yet, we return a best guess */ - if (_clutter_actor_compute_resource_scale (self, &resource_scale)) + if (priv->parent != NULL) { - priv->resource_scale = resource_scale; - priv->needs_compute_resource_scale = FALSE; - - return fabsf (old_resource_scale - resource_scale) > FLT_EPSILON; + /* 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; - return FALSE; -} - -static void -clutter_actor_ensure_resource_scale (ClutterActor *self) -{ - ClutterActorPrivate *priv = self->priv; + for (l = clutter_stage_peek_stage_views (stage); l; l = l->next) + { + ClutterStageView *view = l->data; - if (!priv->needs_compute_resource_scale) - return; + max_scale = MAX (clutter_stage_view_get_scale (view), max_scale); + } - if (clutter_actor_update_resource_scale (self)) - g_signal_emit (self, actor_signals[RESOURCE_SCALE_CHANGED], 0); -} + guessed_scale = max_scale; + } + else + { + ClutterBackend *backend = clutter_get_default_backend (); -gboolean -_clutter_actor_get_real_resource_scale (ClutterActor *self, - gfloat *resource_scale) -{ - ClutterActorPrivate *priv = self->priv; + guessed_scale = clutter_backend_get_fallback_resource_scale (backend); + } - clutter_actor_ensure_resource_scale (self); + g_assert (guessed_scale >= 1.f); - if (!priv->needs_compute_resource_scale) - { - *resource_scale = priv->resource_scale; - return TRUE; - } + /* 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 = -1.0f; - return FALSE; + *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; -- GitLab From 98df2dbd0564dadc74ea8ead1be575821229dc0d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20Dre=C3=9Fler?= Date: Fri, 10 Apr 2020 11:41:58 +0200 Subject: [PATCH 4/6] 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 --- clutter/clutter/clutter-actor-private.h | 3 +- clutter/clutter/clutter-actor.c | 36 +++++++--------------- clutter/clutter/clutter-actor.h | 3 +- clutter/clutter/clutter-offscreen-effect.c | 25 ++++++--------- clutter/clutter/clutter-stage.c | 4 +-- clutter/clutter/clutter-text.c | 25 +++++---------- src/compositor/meta-window-actor.c | 6 ++-- src/tests/clutter/conform/text.c | 3 +- 8 files changed, 35 insertions(+), 70 deletions(-) diff --git a/clutter/clutter/clutter-actor-private.h b/clutter/clutter/clutter-actor-private.h index 3269f66ad43..d1adcd38f03 100644 --- a/clutter/clutter/clutter-actor-private.h +++ b/clutter/clutter/clutter-actor-private.h @@ -283,8 +283,7 @@ void _clutter_actor_queue_relayout_on_clones void _clutter_actor_queue_only_relayout (ClutterActor *actor); void clutter_actor_clear_stage_views_recursive (ClutterActor *actor); -gboolean _clutter_actor_get_real_resource_scale (ClutterActor *actor, - float *resource_scale); +float clutter_actor_get_real_resource_scale (ClutterActor *actor); ClutterPaintNode * clutter_actor_create_texture_paint_node (ClutterActor *self, CoglTexture *texture); diff --git a/clutter/clutter/clutter-actor.c b/clutter/clutter/clutter-actor.c index a31b48fa134..e6a96313991 100644 --- a/clutter/clutter/clutter-actor.c +++ b/clutter/clutter/clutter-actor.c @@ -15968,18 +15968,14 @@ clutter_actor_clear_stage_views_recursive (ClutterActor *self) NULL); } -gboolean -_clutter_actor_get_real_resource_scale (ClutterActor *self, - gfloat *resource_scale) +float +clutter_actor_get_real_resource_scale (ClutterActor *self) { ClutterActorPrivate *priv = self->priv; float guessed_scale; if (priv->resource_scale != -1.f) - { - *resource_scale = priv->resource_scale; - return TRUE; - } + return priv->resource_scale; /* If the scale hasn't been computed yet, we return a best guess */ @@ -15988,7 +15984,7 @@ _clutter_actor_get_real_resource_scale (ClutterActor *self, /* 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); + guessed_scale = clutter_actor_get_real_resource_scale (priv->parent); } else if (CLUTTER_ACTOR_IS_TOPLEVEL (self)) { @@ -16023,14 +16019,12 @@ _clutter_actor_get_real_resource_scale (ClutterActor *self, */ priv->resource_scale = guessed_scale; - *resource_scale = priv->resource_scale; - return TRUE; + return priv->resource_scale; } /** * clutter_actor_get_resource_scale: * @self: A #ClutterActor - * @resource_scale: (out): return location for the resource scale * * Retrieves the resource scale for this actor. * @@ -16060,22 +16054,14 @@ _clutter_actor_get_real_resource_scale (ClutterActor *self, * 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 + * Returns: The resource scale the actor should use for its textures */ -gboolean -clutter_actor_get_resource_scale (ClutterActor *self, - gfloat *resource_scale) +float +clutter_actor_get_resource_scale (ClutterActor *self) { - g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE); - g_return_val_if_fail (resource_scale != NULL, FALSE); - - if (_clutter_actor_get_real_resource_scale (self, resource_scale)) - { - *resource_scale = ceilf (*resource_scale); - return TRUE; - } + g_return_val_if_fail (CLUTTER_IS_ACTOR (self), 1.f); - return FALSE; + return ceilf (clutter_actor_get_real_resource_scale (self)); } static gboolean @@ -16172,7 +16158,7 @@ update_resource_scale (ClutterActor *self) /* 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(). + * clutter_actor_get_real_resource_scale(). */ if (old_resource_scale == -1.f) return; diff --git a/clutter/clutter/clutter-actor.h b/clutter/clutter/clutter-actor.h index fac28e74cd7..9f795f6d3fb 100644 --- a/clutter/clutter/clutter-actor.h +++ b/clutter/clutter/clutter-actor.h @@ -588,8 +588,7 @@ gboolean clutter_actor_get_paint_box ClutterActorBox *box); CLUTTER_EXPORT -gboolean clutter_actor_get_resource_scale (ClutterActor *self, - gfloat *resource_scale); +float clutter_actor_get_resource_scale (ClutterActor *self); CLUTTER_EXPORT gboolean clutter_actor_has_overlaps (ClutterActor *self); diff --git a/clutter/clutter/clutter-offscreen-effect.c b/clutter/clutter/clutter-offscreen-effect.c index a3b4b9d991c..75174ef1042 100644 --- a/clutter/clutter/clutter-offscreen-effect.c +++ b/clutter/clutter/clutter-offscreen-effect.c @@ -238,8 +238,8 @@ clutter_offscreen_effect_pre_paint (ClutterEffect *effect, gfloat stage_width, stage_height; gfloat target_width = -1, target_height = -1; CoglFramebuffer *framebuffer; - gfloat resource_scale; - gfloat ceiled_resource_scale; + float resource_scale; + float ceiled_resource_scale; graphene_point3d_t local_offset; gfloat old_viewport[4]; @@ -254,17 +254,11 @@ clutter_offscreen_effect_pre_paint (ClutterEffect *effect, stage = _clutter_actor_get_stage_internal (priv->actor); clutter_actor_get_size (stage, &stage_width, &stage_height); - if (_clutter_actor_get_real_resource_scale (priv->actor, &resource_scale)) - { - ceiled_resource_scale = ceilf (resource_scale); - stage_width *= ceiled_resource_scale; - stage_height *= ceiled_resource_scale; - } - else - { - /* We are sure we have a resource scale set to a good value at paint */ - g_assert_not_reached (); - } + resource_scale = clutter_actor_get_real_resource_scale (priv->actor); + + ceiled_resource_scale = ceilf (resource_scale); + stage_width *= ceiled_resource_scale; + stage_height *= ceiled_resource_scale; /* Get the minimal bounding box for what we want to paint, relative to the * parent of priv->actor. Note that we may actually be painting a clone of @@ -417,8 +411,9 @@ clutter_offscreen_effect_paint_texture (ClutterOffscreenEffect *effect, */ cogl_framebuffer_get_modelview_matrix (framebuffer, &modelview); - if (clutter_actor_get_resource_scale (priv->actor, &resource_scale) && - resource_scale != 1.0f) + resource_scale = clutter_actor_get_resource_scale (priv->actor); + + if (resource_scale != 1.0f) { float paint_scale = 1.0f / resource_scale; cogl_matrix_scale (&modelview, paint_scale, paint_scale, 1); diff --git a/clutter/clutter/clutter-stage.c b/clutter/clutter/clutter-stage.c index 4f64df66e61..99d21844127 100644 --- a/clutter/clutter/clutter-stage.c +++ b/clutter/clutter/clutter-stage.c @@ -3822,9 +3822,7 @@ clutter_stage_get_capture_final_size (ClutterStage *stage, clutter_actor_get_allocation_box (CLUTTER_ACTOR (stage), &alloc); clutter_actor_box_get_size (&alloc, &stage_width, &stage_height); - if (!_clutter_actor_get_real_resource_scale (CLUTTER_ACTOR (stage), - &max_scale)) - return FALSE; + max_scale = clutter_actor_get_real_resource_scale (CLUTTER_ACTOR (stage)); if (out_width) *out_width = (gint) roundf (stage_width * max_scale); diff --git a/clutter/clutter/clutter-text.c b/clutter/clutter/clutter-text.c index db20be10dff..b9241d7c426 100644 --- a/clutter/clutter/clutter-text.c +++ b/clutter/clutter/clutter-text.c @@ -595,9 +595,7 @@ ensure_effective_pango_scale_attribute (ClutterText *self) float resource_scale; ClutterTextPrivate *priv = self->priv; - if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale) || - resource_scale == 1.0) - return; + resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (self)); if (priv->effective_attrs != NULL) { @@ -1122,8 +1120,7 @@ maybe_create_text_layout_with_resource_scale (ClutterText *text, { float resource_scale; - if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (text), &resource_scale)) - return NULL; + resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (text)); return create_text_layout_with_scale (text, allocation_width, @@ -1155,8 +1152,7 @@ clutter_text_coords_to_position (ClutterText *self, g_return_val_if_fail (CLUTTER_IS_TEXT (self), 0); - if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale)) - return 0; + resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (self)); /* Take any offset due to scrolling into account, and normalize * the coordinates to PangoScale units @@ -1284,8 +1280,7 @@ clutter_text_position_to_coords (ClutterText *self, g_return_val_if_fail (CLUTTER_IS_TEXT (self), FALSE); - if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale)) - return FALSE; + resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (self)); ret = clutter_text_position_to_coords_internal (self, position, x, y, line_height); @@ -2625,8 +2620,7 @@ clutter_text_paint (ClutterActor *self, !clutter_text_should_draw_cursor (text)) return; - if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (self), &resource_scale)) - return; + resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (self)); clutter_actor_box_scale (&alloc, resource_scale); clutter_actor_box_get_size (&alloc, &alloc_width, &alloc_height); @@ -2858,8 +2852,7 @@ clutter_text_get_paint_volume (ClutterActor *self, if (!clutter_actor_has_allocation (self)) return FALSE; - if (!clutter_actor_get_resource_scale (self, &resource_scale)) - return FALSE; + resource_scale = clutter_actor_get_resource_scale (self); _clutter_paint_volume_init_static (&priv->paint_volume, self); @@ -2916,8 +2909,7 @@ clutter_text_get_preferred_width (ClutterActor *self, gfloat layout_width; gfloat resource_scale; - if (!clutter_actor_get_resource_scale (self, &resource_scale)) - resource_scale = 1; + resource_scale = clutter_actor_get_resource_scale (self); layout = clutter_text_create_layout (text, -1, -1); pango_layout_get_extents (layout, NULL, &logical_rect); @@ -2973,8 +2965,7 @@ clutter_text_get_preferred_height (ClutterActor *self, gfloat layout_height; gfloat resource_scale; - if (!clutter_actor_get_resource_scale (self, &resource_scale)) - resource_scale = 1; + resource_scale = clutter_actor_get_resource_scale (self); if (priv->single_line_mode) for_width = -1; diff --git a/src/compositor/meta-window-actor.c b/src/compositor/meta-window-actor.c index e23b426a911..b35d90d2474 100644 --- a/src/compositor/meta-window-actor.c +++ b/src/compositor/meta-window-actor.c @@ -1301,8 +1301,7 @@ meta_window_actor_blit_to_framebuffer (MetaScreenCastWindow *screen_cast_window, if (width == 0 || height == 0) return FALSE; - if (!clutter_actor_get_resource_scale (actor, &resource_scale)) - return FALSE; + resource_scale = clutter_actor_get_resource_scale (actor); clutter_actor_inhibit_culling (actor); @@ -1460,8 +1459,7 @@ meta_window_actor_get_image (MetaWindowActor *self, if (width == 0 || height == 0) goto out; - if (!clutter_actor_get_resource_scale (actor, &resource_scale)) - goto out; + resource_scale = clutter_actor_get_resource_scale (actor); width = ceilf (width * resource_scale); height = ceilf (height * resource_scale); diff --git a/src/tests/clutter/conform/text.c b/src/tests/clutter/conform/text.c index e1b0cae438b..304fa1dd4c7 100644 --- a/src/tests/clutter/conform/text.c +++ b/src/tests/clutter/conform/text.c @@ -475,8 +475,7 @@ validate_markup_attributes (ClutterText *text, PangoAttrFloat *scale = (PangoAttrFloat*) a; float resource_scale; - if (!clutter_actor_get_resource_scale (CLUTTER_ACTOR (text), &resource_scale)) - resource_scale = 1.0; + resource_scale = clutter_actor_get_resource_scale (CLUTTER_ACTOR (text)); g_assert_cmpfloat (scale->value, ==, resource_scale); g_slist_free_full (attributes, (GDestroyNotify) pango_attribute_destroy); -- GitLab From 280429bac862b4fdbc3c094c0c034ce58642864e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20Dre=C3=9Fler?= Date: Fri, 10 Apr 2020 14:54:11 +0200 Subject: [PATCH 5/6] 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 --- clutter/clutter/clutter-actor-private.h | 5 ++- clutter/clutter/clutter-actor.c | 57 +++++++++++++++++++------ clutter/clutter/clutter-actor.h | 2 + clutter/clutter/clutter-stage-private.h | 2 + clutter/clutter/clutter-stage.c | 39 +++++++++++++++-- 5 files changed, 87 insertions(+), 18 deletions(-) diff --git a/clutter/clutter/clutter-actor-private.h b/clutter/clutter/clutter-actor-private.h index d1adcd38f03..16ab012b6f6 100644 --- a/clutter/clutter/clutter-actor-private.h +++ b/clutter/clutter/clutter-actor-private.h @@ -288,7 +288,10 @@ float clutter_actor_get_real_resource_scale ClutterPaintNode * clutter_actor_create_texture_paint_node (ClutterActor *self, CoglTexture *texture); -void clutter_actor_update_stage_views (ClutterActor *self); +void clutter_actor_update_stage_views (ClutterActor *self, + int phase); + +void clutter_actor_queue_immediate_relayout (ClutterActor *self); G_END_DECLS diff --git a/clutter/clutter/clutter-actor.c b/clutter/clutter/clutter-actor.c index e6a96313991..86ffe2f1f06 100644 --- a/clutter/clutter/clutter-actor.c +++ b/clutter/clutter/clutter-actor.c @@ -5903,6 +5903,25 @@ clutter_actor_real_has_overlaps (ClutterActor *self) return TRUE; } +static float +clutter_actor_real_calculate_resource_scale (ClutterActor *self, + int phase) +{ + ClutterActorPrivate *priv = self->priv; + GList *l; + float new_resource_scale = -1.f; + + 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); + } + + return new_resource_scale; +} + static void clutter_actor_real_destroy (ClutterActor *actor) { @@ -5988,6 +6007,7 @@ clutter_actor_class_init (ClutterActorClass *klass) klass->get_accessible = clutter_actor_real_get_accessible; klass->get_paint_volume = clutter_actor_real_get_paint_volume; klass->has_overlaps = clutter_actor_real_has_overlaps; + klass->calculate_resource_scale = clutter_actor_real_calculate_resource_scale; klass->paint = clutter_actor_real_paint; klass->destroy = clutter_actor_real_destroy; @@ -16131,20 +16151,14 @@ out: } static void -update_resource_scale (ClutterActor *self) +update_resource_scale (ClutterActor *self, + int phase) { 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; + float new_resource_scale, old_resource_scale; - new_resource_scale = MAX (clutter_stage_view_get_scale (view), - new_resource_scale); - } + new_resource_scale = + CLUTTER_ACTOR_GET_CLASS (self)->calculate_resource_scale (self, phase); if (priv->resource_scale == new_resource_scale) return; @@ -16168,7 +16182,8 @@ update_resource_scale (ClutterActor *self) } void -clutter_actor_update_stage_views (ClutterActor *self) +clutter_actor_update_stage_views (ClutterActor *self, + gboolean use_max_scale) { ClutterActorPrivate *priv = self->priv; ClutterActor *child; @@ -16181,12 +16196,12 @@ clutter_actor_update_stage_views (ClutterActor *self) return; update_stage_views (self); - update_resource_scale (self); + update_resource_scale (self, use_max_scale); priv->needs_update_stage_views = FALSE; for (child = priv->first_child; child; child = child->priv->next_sibling) - clutter_actor_update_stage_views (child); + clutter_actor_update_stage_views (child, use_max_scale); } /** @@ -19710,3 +19725,17 @@ clutter_actor_has_accessible (ClutterActor *actor) return TRUE; } + +void +clutter_actor_queue_immediate_relayout (ClutterActor *self) +{ + ClutterStage *stage; + + g_return_if_fail (CLUTTER_IS_ACTOR (self)); + + clutter_actor_queue_relayout (self); + + stage = CLUTTER_STAGE (_clutter_actor_get_stage_internal (self)); + if (stage) + clutter_stage_set_actor_needs_immediate_relayout (stage); +} diff --git a/clutter/clutter/clutter-actor.h b/clutter/clutter/clutter-actor.h index 9f795f6d3fb..67d327b5b46 100644 --- a/clutter/clutter/clutter-actor.h +++ b/clutter/clutter/clutter-actor.h @@ -297,6 +297,8 @@ struct _ClutterActorClass ClutterTouchEvent *event); gboolean (* has_accessible) (ClutterActor *self); void (* resource_scale_changed) (ClutterActor *self); + float (* calculate_resource_scale) (ClutterActor *self, + int phase); /*< private >*/ /* padding for future expansion */ diff --git a/clutter/clutter/clutter-stage-private.h b/clutter/clutter/clutter-stage-private.h index 5d785b644aa..2ce0cd05b59 100644 --- a/clutter/clutter/clutter-stage-private.h +++ b/clutter/clutter/clutter-stage-private.h @@ -136,6 +136,8 @@ void clutter_stage_queue_actor_relayout (ClutterStage *stage, GList * clutter_stage_get_views_for_rect (ClutterStage *stage, const graphene_rect_t *rect); +void clutter_stage_set_actor_needs_immediate_relayout (ClutterStage *stage); + G_END_DECLS #endif /* __CLUTTER_STAGE_PRIVATE_H__ */ diff --git a/clutter/clutter/clutter-stage.c b/clutter/clutter/clutter-stage.c index 99d21844127..8d3fc8b8009 100644 --- a/clutter/clutter/clutter-stage.c +++ b/clutter/clutter/clutter-stage.c @@ -146,6 +146,7 @@ struct _ClutterStagePrivate guint min_size_changed : 1; guint motion_events_enabled : 1; guint stage_was_relayout : 1; + guint actor_needs_immediate_relayout : 1; }; enum @@ -1354,8 +1355,34 @@ static void update_actor_stage_views (ClutterStage *stage) { ClutterActor *actor = CLUTTER_ACTOR (stage); + ClutterStagePrivate *priv = stage->priv; + int phase; + + COGL_TRACE_BEGIN_SCOPED (ClutterStageUpdateActorStageViews, + "Actor stage-views"); + + /* If an actor needs an immediate relayout because its resource scale + * changed, we give it another chance to allocate correctly before + * the paint. + * + * We're doing the whole thing twice and pass the phase to + * clutter_actor_update_stage_views() to allow actors to detect loops: + * If the resource scale changes again after the relayout, the new + * allocation of an actor probably moved the actor onto another stage + * view, so if an actor sees phase == 1, it can choose a "final" scale. + */ + for (phase = 0; phase < 2; phase++) + { + clutter_actor_update_stage_views (actor, phase); - clutter_actor_update_stage_views (actor); + if (!priv->actor_needs_immediate_relayout) + break; + + priv->actor_needs_immediate_relayout = FALSE; + _clutter_stage_maybe_relayout (actor); + } + + g_warn_if_fail (!priv->actor_needs_immediate_relayout); } /** @@ -1405,9 +1432,7 @@ _clutter_stage_do_update (ClutterStage *stage) if (stage_was_relayout) pointers = _clutter_stage_check_updated_pointers (stage); - COGL_TRACE_BEGIN (ClutterStageUpdateActorStageViews, "Actor stage-views"); update_actor_stage_views (stage); - COGL_TRACE_END (ClutterStageUpdateActorStageViews); COGL_TRACE_BEGIN (ClutterStagePaint, "Paint"); @@ -4115,3 +4140,11 @@ clutter_stage_get_views_for_rect (ClutterStage *stage, return views_for_rect; } + +void +clutter_stage_set_actor_needs_immediate_relayout (ClutterStage *stage) +{ + ClutterStagePrivate *priv = stage->priv; + + priv->actor_needs_immediate_relayout = TRUE; +} -- GitLab From c5159e318441ddca79566d872ec781afe5a79dc5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jonas=20Dre=C3=9Fler?= Date: Fri, 29 May 2020 17:28:50 +0200 Subject: [PATCH 6/6] clutter/text: Enable relayout on resource-scale changes ClutterText needs a new allocation on resource-scale changes, which we added proper support for in the last commit, so use that API for ClutterText. https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1276 --- clutter/clutter/clutter-text.c | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-) diff --git a/clutter/clutter/clutter-text.c b/clutter/clutter/clutter-text.c index b9241d7c426..2fef356cd32 100644 --- a/clutter/clutter/clutter-text.c +++ b/clutter/clutter/clutter-text.c @@ -3041,15 +3041,31 @@ clutter_text_has_overlaps (ClutterActor *self) return clutter_text_should_draw_cursor ((ClutterText *) self); } +static float +clutter_text_calculate_resource_scale (ClutterActor *actor, + int phase) +{ + ClutterActorClass *parent_class = CLUTTER_ACTOR_CLASS (clutter_text_parent_class); + float new_resource_scale; + + new_resource_scale = parent_class->calculate_resource_scale (actor, phase); + + if (phase == 1) + return MAX (new_resource_scale, clutter_actor_get_real_resource_scale (actor)); + + return new_resource_scale; +} + static void clutter_text_resource_scale_changed (ClutterActor *actor) { - ClutterText *self = CLUTTER_TEXT (actor); - ClutterTextPrivate *priv = self->priv; + ClutterText *text = CLUTTER_TEXT (actor); + ClutterTextPrivate *priv = text->priv; g_clear_pointer (&priv->effective_attrs, pango_attr_list_unref); - clutter_text_dirty_cache (self); - clutter_actor_queue_relayout (actor); + clutter_text_dirty_cache (text); + + clutter_actor_queue_immediate_relayout (actor); } static void @@ -3800,6 +3816,7 @@ clutter_text_class_init (ClutterTextClass *klass) actor_class->key_focus_in = clutter_text_key_focus_in; actor_class->key_focus_out = clutter_text_key_focus_out; actor_class->has_overlaps = clutter_text_has_overlaps; + actor_class->calculate_resource_scale = clutter_text_calculate_resource_scale; actor_class->resource_scale_changed = clutter_text_resource_scale_changed; /** -- GitLab