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

clutter/actor: Remove the queue-redraw signal

Browse Source 
The "queue-redraw" signal is not used anywhere in Clutter and we now
also removed the vfunc implementation of the stage. So stop emitting it
and remove it, but keep the propagate_queue_redraw infrastructure to
make sure clones still get their redraws queued.

Part-of: <https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1511>
This commit is contained in:
Jonas Dreßler 2020-10-19 16:48:53 +02:00 committed by Marge Bot
parent ce4c297cea
commit 1cd386551d
2 changed files with 22 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -977,7 +977,6 @@ enum
PICK,
REALIZE,
UNREALIZE,
QUEUE_REDRAW,
QUEUE_RELAYOUT,
EVENT,
CAPTURED_EVENT,
@ -2605,82 +2604,41 @@ static void
_clutter_actor_propagate_queue_redraw (ClutterActor *self,
ClutterActor *origin)
{
gboolean stop = FALSE;
/* no point in queuing a redraw on a destroyed actor */
if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
return;
/* NB: We can't bail out early here if the actor is hidden in case
* the actor bas been cloned. In this case the clone will need to
* receive the signal so it can queue its own redraw.
*/
while (self)
{
/* no point in queuing a redraw on a destroyed actor */
if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
break;
_clutter_actor_queue_redraw_on_clones (self);
/* calls klass->queue_redraw in default handler */
if (g_signal_has_handler_pending (self, actor_signals[QUEUE_REDRAW],
0, TRUE))
/* If the queue redraw is coming from a child then the actor has
become dirty and any queued effect is no longer valid */
if (self != origin)
{
g_signal_emit (self, actor_signals[QUEUE_REDRAW], 0, origin, &stop);
}
else
{
stop = CLUTTER_ACTOR_GET_CLASS (self)->queue_redraw (self, origin);
self->priv->is_dirty = TRUE;
self->priv->effect_to_redraw = NULL;
}
if (stop)
/* If the actor isn't visible, we still had to emit the signal
* to allow for a ClutterClone, but the appearance of the parent
* won't change so we don't have to propagate up the hierarchy.
*/
if (!CLUTTER_ACTOR_IS_VISIBLE (self))
break;
/* We guarantee that we will propagate a queue-redraw up the tree
* at least once so that all clones can get notified.
*/
if (self->priv->propagated_one_redraw)
break;
self->priv->propagated_one_redraw = TRUE;
self = self->priv->parent;
}
}
static gboolean
clutter_actor_real_queue_redraw (ClutterActor *self,
ClutterActor *origin)
{
CLUTTER_NOTE (PAINT, "Redraw queued on '%s' (from: '%s')",
_clutter_actor_get_debug_name (self),
origin != NULL ? _clutter_actor_get_debug_name (origin)
: "same actor");
/* no point in queuing a redraw on a destroyed actor */
if (CLUTTER_ACTOR_IN_DESTRUCTION (self))
return TRUE;
/* If the queue redraw is coming from a child then the actor has
become dirty and any queued effect is no longer valid */
if (self != origin)
{
self->priv->is_dirty = TRUE;
self->priv->effect_to_redraw = NULL;
}
/* If the actor isn't visible, we still had to emit the signal
* to allow for a ClutterClone, but the appearance of the parent
* won't change so we don't have to propagate up the hierarchy.
*/
if (!CLUTTER_ACTOR_IS_VISIBLE (self))
return TRUE;
/* We guarantee that we will propagate a queue-redraw signal up
* the tree at least once so that it's possible to implement a
* container that tracks which of its children have queued a
* redraw.
*/
if (self->priv->propagated_one_redraw)
return TRUE;
self->priv->propagated_one_redraw = TRUE;
/* notify parents, if they are all visible eventually we'll
* queue redraw on the stage, which queues the redraw idle.
*/
return FALSE;
}
static inline gboolean
clutter_actor_needs_relayout (ClutterActor *self)
{
@ -5959,7 +5917,6 @@ clutter_actor_class_init (ClutterActorClass *klass)
klass->get_preferred_width = clutter_actor_real_get_preferred_width;
klass->get_preferred_height = clutter_actor_real_get_preferred_height;
klass->allocate = clutter_actor_real_allocate;
klass->queue_redraw = clutter_actor_real_queue_redraw;
klass->queue_relayout = clutter_actor_real_queue_relayout;
klass->apply_transform = clutter_actor_real_apply_transform;
klass->get_accessible = clutter_actor_real_get_accessible;
@ -7345,73 +7302,6 @@ clutter_actor_class_init (ClutterActorClass *klass)
G_TYPE_NONE, 1,
CLUTTER_TYPE_ACTOR);
/**
* ClutterActor::queue-redraw:
* @actor: the actor we're bubbling the redraw request through
* @origin: the actor which initiated the redraw request
* @volume: paint volume to redraw
*
* The ::queue_redraw signal is emitted when clutter_actor_queue_redraw()
* is called on @origin.
*
* The default implementation for #ClutterActor chains up to the
* parent actor and queues a redraw on the parent, thus "bubbling"
* the redraw queue up through the actor graph. The default
* implementation for #ClutterStage queues a clutter_stage_ensure_redraw()
* in a main loop idle handler.
*
* Note that the @origin actor may be the stage, or a container; it
* does not have to be a leaf node in the actor graph.
*
* Toolkits embedding a #ClutterStage which require a redraw and
* relayout cycle can stop the emission of this signal using the
* GSignal API, redraw the UI and then call clutter_stage_ensure_redraw()
* themselves, like:
*
* |[<!-- language="C" -->
* static void
* on_redraw_complete (gpointer data)
* {
* ClutterStage *stage = data;
*
* // execute the Clutter drawing pipeline
* clutter_stage_ensure_redraw (stage);
* }
*
* static void
* on_stage_queue_redraw (ClutterStage *stage)
* {
* // this prevents the default handler to run
* g_signal_stop_emission_by_name (stage, "queue-redraw");
*
* // queue a redraw with the host toolkit and call
* // a function when the redraw has been completed
* queue_a_redraw (G_CALLBACK (on_redraw_complete), stage);
* }
* ]|
*
* Note: This signal is emitted before the Clutter paint
* pipeline is executed. If you want to know when the pipeline has
* been completed you should use clutter_threads_add_repaint_func()
* or clutter_threads_add_repaint_func_full().
*
* Since: 1.0
*/
actor_signals[QUEUE_REDRAW] =
g_signal_new (I_("queue-redraw"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST |
G_SIGNAL_NO_HOOKS,
G_STRUCT_OFFSET (ClutterActorClass, queue_redraw),
g_signal_accumulator_true_handled,
NULL,
_clutter_marshal_BOOLEAN__OBJECT,
G_TYPE_BOOLEAN, 1,
CLUTTER_TYPE_ACTOR);
g_signal_set_va_marshaller (actor_signals[QUEUE_REDRAW],
G_TYPE_FROM_CLASS (object_class),
_clutter_marshal_BOOLEAN__OBJECTv);
/**
* ClutterActor::queue-relayout:
* @actor: the actor being queued for relayout
@ -8039,11 +7929,6 @@ _clutter_actor_queue_redraw_full (ClutterActor *self,
* wrapper for this function. Additionally, an effect can queue a
* redraw by wrapping this function in clutter_effect_queue_repaint().
*
* This function will emit the "queue-redraw" signal for each actor
* up the actor-tree, allowing to track redraws queued by children
* or to queue a redraw of a different actor (like a clone) in
* response to this one.
*
* This functions queues an entry in a list associated with the
* stage which is a list of actors that queued a redraw while
* updating the timelines, performing layouting and processing other

4
clutter/clutter/clutter-actor.h
View File

@ -187,7 +187,6 @@ struct _ClutterActor
* chain up to the parent's implementation
* @pick: virtual function, used to draw an outline of the actor with
* the given color
* @queue_redraw: class handler for #ClutterActor::queue-redraw
* @event: class handler for #ClutterActor::event
* @button_press_event: class handler for #ClutterActor::button-press-event
* @button_release_event: class handler for
@ -239,9 +238,6 @@ struct _ClutterActorClass
void (* pick) (ClutterActor *actor,
ClutterPickContext *pick_context);
gboolean (* queue_redraw) (ClutterActor *actor,
ClutterActor *leaf_that_queued);
/* size negotiation */
void (* get_preferred_width) (ClutterActor *self,
gfloat for_height,