Branch data Line data Source code
1 : : /* GObject - GLib Type, Object, Parameter and Signal Library
2 : : *
3 : : * Copyright (C) 2015-2022 Christian Hergert <christian@hergert.me>
4 : : * Copyright (C) 2015 Garrett Regier <garrettregier@gmail.com>
5 : : *
6 : : * This library is free software; you can redistribute it and/or
7 : : * modify it under the terms of the GNU Lesser General Public
8 : : * License as published by the Free Software Foundation; either
9 : : * version 2.1 of the License, or (at your option) any later version.
10 : : *
11 : : * This library is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 : : * Lesser General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU Lesser General
17 : : * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 : : *
19 : : * SPDX-License-Identifier: LGPL-2.1-or-later
20 : : */
21 : :
22 : : #include "config.h"
23 : : #include "glib.h"
24 : : #include "glibintl.h"
25 : :
26 : : #include "gparamspecs.h"
27 : : #include "gsignalgroup.h"
28 : : #include "gvaluetypes.h"
29 : :
30 : : /**
31 : : * GSignalGroup:
32 : : *
33 : : * `GSignalGroup` manages a collection of signals on a `GObject`.
34 : : *
35 : : * `GSignalGroup` simplifies the process of connecting many signals to a `GObject`
36 : : * as a group. As such there is no API to disconnect a signal from the group.
37 : : *
38 : : * In particular, this allows you to:
39 : : *
40 : : * - Change the target instance, which automatically causes disconnection
41 : : * of the signals from the old instance and connecting to the new instance.
42 : : * - Block and unblock signals as a group
43 : : * - Ensuring that blocked state transfers across target instances.
44 : : *
45 : : * One place you might want to use such a structure is with `GtkTextView` and
46 : : * `GtkTextBuffer`. Often times, you'll need to connect to many signals on
47 : : * `GtkTextBuffer` from a `GtkTextView` subclass. This allows you to create a
48 : : * signal group during instance construction, simply bind the
49 : : * `GtkTextView:buffer` property to `GSignalGroup:target` and connect
50 : : * all the signals you need. When the `GtkTextView:buffer` property changes
51 : : * all of the signals will be transitioned correctly.
52 : : *
53 : : * Since: 2.72
54 : : */
55 : :
56 : : struct _GSignalGroup
57 : : {
58 : : GObject parent_instance;
59 : :
60 : : GWeakRef target_ref;
61 : : GRecMutex mutex;
62 : : GPtrArray *handlers;
63 : : GType target_type;
64 : : gssize block_count;
65 : :
66 : : guint has_bound_at_least_once : 1;
67 : : };
68 : :
69 : : typedef struct _GSignalGroupClass
70 : : {
71 : : GObjectClass parent_class;
72 : :
73 : : void (*bind) (GSignalGroup *self,
74 : : GObject *target);
75 : : } GSignalGroupClass;
76 : :
77 : : typedef struct
78 : : {
79 : : GSignalGroup *group;
80 : : gulong handler_id;
81 : : GClosure *closure;
82 : : guint signal_id;
83 : : GQuark signal_detail;
84 : : guint connect_after : 1;
85 : : } SignalHandler;
86 : :
87 [ + + + - : 449 : G_DEFINE_TYPE (GSignalGroup, g_signal_group, G_TYPE_OBJECT)
+ + ]
88 : :
89 : : typedef enum
90 : : {
91 : : PROP_TARGET = 1,
92 : : PROP_TARGET_TYPE,
93 : : LAST_PROP
94 : : } GSignalGroupProperty;
95 : :
96 : : enum
97 : : {
98 : : BIND,
99 : : UNBIND,
100 : : LAST_SIGNAL
101 : : };
102 : :
103 : : static GParamSpec *properties[LAST_PROP];
104 : : static guint signals[LAST_SIGNAL];
105 : :
106 : : static void
107 : 14 : g_signal_group_set_target_type (GSignalGroup *self,
108 : : GType target_type)
109 : : {
110 : 14 : g_assert (G_IS_SIGNAL_GROUP (self));
111 : 14 : g_assert (g_type_is_a (target_type, G_TYPE_OBJECT));
112 : :
113 : 14 : self->target_type = target_type;
114 : :
115 : : /* The class must be created at least once for the signals
116 : : * to be registered, otherwise g_signal_parse_name() will fail
117 : : */
118 [ + + ]: 14 : if (G_TYPE_IS_INTERFACE (target_type))
119 : : {
120 [ + - ]: 1 : if (g_type_default_interface_peek (target_type) == NULL)
121 : 1 : g_type_default_interface_unref (g_type_default_interface_ref (target_type));
122 : : }
123 : : else
124 : : {
125 [ + + ]: 13 : if (g_type_class_peek (target_type) == NULL)
126 : 1 : g_type_class_unref (g_type_class_ref (target_type));
127 : : }
128 : 14 : }
129 : :
130 : : static void
131 : 67 : g_signal_group_gc_handlers (GSignalGroup *self)
132 : : {
133 : : guint i;
134 : :
135 : 67 : g_assert (G_IS_SIGNAL_GROUP (self));
136 : :
137 : : /*
138 : : * Remove any handlers for which the closures have become invalid. We do
139 : : * this cleanup lazily to avoid situations where we could have disposal
140 : : * active on both the signal group and the peer object.
141 : : */
142 : :
143 [ + + ]: 313 : for (i = self->handlers->len; i > 0; i--)
144 : : {
145 : 246 : const SignalHandler *handler = g_ptr_array_index (self->handlers, i - 1);
146 : :
147 : 246 : g_assert (handler != NULL);
148 : 246 : g_assert (handler->closure != NULL);
149 : :
150 [ + + ]: 246 : if (handler->closure->is_invalid)
151 : 4 : g_ptr_array_remove_index (self->handlers, i - 1);
152 : : }
153 : 67 : }
154 : :
155 : : static void
156 : 5 : g_signal_group__target_weak_notify (gpointer data,
157 : : GObject *where_object_was)
158 : : {
159 : 5 : GSignalGroup *self = data;
160 : : guint i;
161 : :
162 : 5 : g_assert (G_IS_SIGNAL_GROUP (self));
163 : 5 : g_assert (where_object_was != NULL);
164 : :
165 : 5 : g_rec_mutex_lock (&self->mutex);
166 : :
167 : 5 : g_weak_ref_set (&self->target_ref, NULL);
168 : :
169 [ + + ]: 29 : for (i = 0; i < self->handlers->len; i++)
170 : : {
171 : 24 : SignalHandler *handler = g_ptr_array_index (self->handlers, i);
172 : :
173 : 24 : handler->handler_id = 0;
174 : : }
175 : :
176 : 5 : g_signal_emit (self, signals[UNBIND], 0);
177 : 5 : g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TARGET]);
178 : :
179 : 5 : g_rec_mutex_unlock (&self->mutex);
180 : 5 : }
181 : :
182 : : static void
183 : 41 : g_signal_group_bind_handler (GSignalGroup *self,
184 : : SignalHandler *handler,
185 : : GObject *target)
186 : : {
187 : : gssize i;
188 : :
189 : 41 : g_assert (self != NULL);
190 : 41 : g_assert (G_IS_OBJECT (target));
191 : 41 : g_assert (handler != NULL);
192 : 41 : g_assert (handler->signal_id != 0);
193 : 41 : g_assert (handler->closure != NULL);
194 : 41 : g_assert (handler->closure->is_invalid == 0);
195 : 41 : g_assert (handler->handler_id == 0);
196 : :
197 : 82 : handler->handler_id = g_signal_connect_closure_by_id (target,
198 : : handler->signal_id,
199 : : handler->signal_detail,
200 : : handler->closure,
201 : 41 : handler->connect_after);
202 : :
203 : 41 : g_assert (handler->handler_id != 0);
204 : :
205 [ + + ]: 57 : for (i = 0; i < self->block_count; i++)
206 : 16 : g_signal_handler_block (target, handler->handler_id);
207 : 41 : }
208 : :
209 : : static void
210 : 12 : g_signal_group_bind (GSignalGroup *self,
211 : : GObject *target)
212 : : {
213 : : GObject *hold;
214 : : guint i;
215 : :
216 : 12 : g_assert (G_IS_SIGNAL_GROUP (self));
217 : 12 : g_assert (!target || G_IS_OBJECT (target));
218 : :
219 [ + + ]: 12 : if (target == NULL)
220 : 1 : return;
221 : :
222 : 11 : self->has_bound_at_least_once = TRUE;
223 : :
224 : 11 : hold = g_object_ref (target);
225 : :
226 : 11 : g_weak_ref_set (&self->target_ref, hold);
227 : 11 : g_object_weak_ref (hold, g_signal_group__target_weak_notify, self);
228 : :
229 : 11 : g_signal_group_gc_handlers (self);
230 : :
231 [ + + ]: 52 : for (i = 0; i < self->handlers->len; i++)
232 : : {
233 : 41 : SignalHandler *handler = g_ptr_array_index (self->handlers, i);
234 : :
235 : 41 : g_signal_group_bind_handler (self, handler, hold);
236 : : }
237 : :
238 : 11 : g_signal_emit (self, signals [BIND], 0, hold);
239 : :
240 : 11 : g_object_unref (hold);
241 : : }
242 : :
243 : : static void
244 : 12 : g_signal_group_unbind (GSignalGroup *self)
245 : : {
246 : : GObject *target;
247 : : guint i;
248 : :
249 : 12 : g_return_if_fail (G_IS_SIGNAL_GROUP (self));
250 : :
251 : 12 : target = g_weak_ref_get (&self->target_ref);
252 : :
253 : : /*
254 : : * Target may be NULL by this point, as we got notified of its destruction.
255 : : * However, if we're early enough, we may get a full reference back and can
256 : : * cleanly disconnect our connections.
257 : : */
258 : :
259 [ + + ]: 12 : if (target != NULL)
260 : : {
261 : 6 : g_weak_ref_set (&self->target_ref, NULL);
262 : :
263 : : /*
264 : : * Let go of our weak reference now that we have a full reference
265 : : * for the life of this function.
266 : : */
267 : 6 : g_object_weak_unref (target,
268 : : g_signal_group__target_weak_notify,
269 : : self);
270 : : }
271 : :
272 : 12 : g_signal_group_gc_handlers (self);
273 : :
274 [ + + ]: 52 : for (i = 0; i < self->handlers->len; i++)
275 : : {
276 : : SignalHandler *handler;
277 : : gulong handler_id;
278 : :
279 : 40 : handler = g_ptr_array_index (self->handlers, i);
280 : :
281 : 40 : g_assert (handler != NULL);
282 : 40 : g_assert (handler->signal_id != 0);
283 : 40 : g_assert (handler->closure != NULL);
284 : :
285 : 40 : handler_id = handler->handler_id;
286 : 40 : handler->handler_id = 0;
287 : :
288 : : /*
289 : : * If @target is NULL, we lost a race to cleanup the weak
290 : : * instance and the signal connections have already been
291 : : * finalized and therefore nothing to do.
292 : : */
293 : :
294 [ + + + - ]: 40 : if (target != NULL && handler_id != 0)
295 : 16 : g_signal_handler_disconnect (target, handler_id);
296 : : }
297 : :
298 : 12 : g_signal_emit (self, signals [UNBIND], 0);
299 : :
300 [ + + ]: 12 : g_clear_object (&target);
301 : : }
302 : :
303 : : static gboolean
304 : 27 : g_signal_group_check_target_type (GSignalGroup *self,
305 : : gpointer target)
306 : : {
307 [ + + ]: 27 : if ((target != NULL) &&
308 [ + + + - ]: 12 : !g_type_is_a (G_OBJECT_TYPE (target), self->target_type))
309 : : {
310 : 1 : g_critical ("Failed to set GSignalGroup of target type %s "
311 : : "using target %p of type %s",
312 : : g_type_name (self->target_type),
313 : : target, G_OBJECT_TYPE_NAME (target));
314 : 1 : return FALSE;
315 : : }
316 : :
317 : 26 : return TRUE;
318 : : }
319 : :
320 : : /**
321 : : * g_signal_group_block:
322 : : * @self: the #GSignalGroup
323 : : *
324 : : * Blocks all signal handlers managed by @self so they will not
325 : : * be called during any signal emissions. Must be unblocked exactly
326 : : * the same number of times it has been blocked to become active again.
327 : : *
328 : : * This blocked state will be kept across changes of the target instance.
329 : : *
330 : : * Since: 2.72
331 : : */
332 : : void
333 : 22 : g_signal_group_block (GSignalGroup *self)
334 : : {
335 : : GObject *target;
336 : : guint i;
337 : :
338 : 22 : g_return_if_fail (G_IS_SIGNAL_GROUP (self));
339 : 22 : g_return_if_fail (self->block_count >= 0);
340 : :
341 : 22 : g_rec_mutex_lock (&self->mutex);
342 : :
343 : 22 : self->block_count++;
344 : :
345 : 22 : target = g_weak_ref_get (&self->target_ref);
346 : :
347 [ + + ]: 22 : if (target == NULL)
348 : 1 : goto unlock;
349 : :
350 [ + + ]: 189 : for (i = 0; i < self->handlers->len; i++)
351 : : {
352 : 168 : const SignalHandler *handler = g_ptr_array_index (self->handlers, i);
353 : :
354 : 168 : g_assert (handler != NULL);
355 : 168 : g_assert (handler->signal_id != 0);
356 : 168 : g_assert (handler->closure != NULL);
357 : 168 : g_assert (handler->handler_id != 0);
358 : :
359 : 168 : g_signal_handler_block (target, handler->handler_id);
360 : : }
361 : :
362 : 21 : g_object_unref (target);
363 : :
364 : 22 : unlock:
365 : 22 : g_rec_mutex_unlock (&self->mutex);
366 : : }
367 : :
368 : : /**
369 : : * g_signal_group_unblock:
370 : : * @self: the #GSignalGroup
371 : : *
372 : : * Unblocks all signal handlers managed by @self so they will be
373 : : * called again during any signal emissions unless it is blocked
374 : : * again. Must be unblocked exactly the same number of times it
375 : : * has been blocked to become active again.
376 : : *
377 : : * Since: 2.72
378 : : */
379 : : void
380 : 22 : g_signal_group_unblock (GSignalGroup *self)
381 : : {
382 : : GObject *target;
383 : : guint i;
384 : :
385 : 22 : g_return_if_fail (G_IS_SIGNAL_GROUP (self));
386 : 22 : g_return_if_fail (self->block_count > 0);
387 : :
388 : 22 : g_rec_mutex_lock (&self->mutex);
389 : :
390 : 22 : self->block_count--;
391 : :
392 : 22 : target = g_weak_ref_get (&self->target_ref);
393 [ + + ]: 22 : if (target == NULL)
394 : 1 : goto unlock;
395 : :
396 [ + + ]: 189 : for (i = 0; i < self->handlers->len; i++)
397 : : {
398 : 168 : const SignalHandler *handler = g_ptr_array_index (self->handlers, i);
399 : :
400 : 168 : g_assert (handler != NULL);
401 : 168 : g_assert (handler->signal_id != 0);
402 : 168 : g_assert (handler->closure != NULL);
403 : 168 : g_assert (handler->handler_id != 0);
404 : :
405 : 168 : g_signal_handler_unblock (target, handler->handler_id);
406 : : }
407 : :
408 : 21 : g_object_unref (target);
409 : :
410 : 22 : unlock:
411 : 22 : g_rec_mutex_unlock (&self->mutex);
412 : : }
413 : :
414 : : /**
415 : : * g_signal_group_dup_target:
416 : : * @self: the #GSignalGroup
417 : : *
418 : : * Gets the target instance used when connecting signals.
419 : : *
420 : : * Returns: (nullable) (transfer full) (type GObject): The target instance
421 : : *
422 : : * Since: 2.72
423 : : */
424 : : gpointer
425 : 89 : g_signal_group_dup_target (GSignalGroup *self)
426 : : {
427 : : GObject *target;
428 : :
429 : 89 : g_return_val_if_fail (G_IS_SIGNAL_GROUP (self), NULL);
430 : :
431 : 89 : g_rec_mutex_lock (&self->mutex);
432 : 89 : target = g_weak_ref_get (&self->target_ref);
433 : 89 : g_rec_mutex_unlock (&self->mutex);
434 : :
435 : 89 : return target;
436 : : }
437 : :
438 : : /**
439 : : * g_signal_group_set_target:
440 : : * @self: the #GSignalGroup.
441 : : * @target: (nullable) (type GObject) (transfer none): The target instance used
442 : : * when connecting signals.
443 : : *
444 : : * Sets the target instance used when connecting signals. Any signal
445 : : * that has been registered with g_signal_group_connect_object() or
446 : : * similar functions will be connected to this object.
447 : : *
448 : : * If the target instance was previously set, signals will be
449 : : * disconnected from that object prior to connecting to @target.
450 : : *
451 : : * Since: 2.72
452 : : */
453 : : void
454 : 14 : g_signal_group_set_target (GSignalGroup *self,
455 : : gpointer target)
456 : : {
457 : : GObject *object;
458 : :
459 : 14 : g_return_if_fail (G_IS_SIGNAL_GROUP (self));
460 : :
461 : 14 : g_rec_mutex_lock (&self->mutex);
462 : :
463 : 14 : object = g_weak_ref_get (&self->target_ref);
464 : :
465 [ + + ]: 14 : if (object == (GObject *)target)
466 : 1 : goto cleanup;
467 : :
468 [ + + ]: 13 : if (!g_signal_group_check_target_type (self, target))
469 : 1 : goto cleanup;
470 : :
471 : : /* Only emit unbind if we've ever called bind */
472 [ + + ]: 12 : if (self->has_bound_at_least_once)
473 : 4 : g_signal_group_unbind (self);
474 : :
475 : 12 : g_signal_group_bind (self, target);
476 : :
477 : 12 : g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_TARGET]);
478 : :
479 : 14 : cleanup:
480 [ + + ]: 14 : g_clear_object (&object);
481 : 14 : g_rec_mutex_unlock (&self->mutex);
482 : : }
483 : :
484 : : static void
485 : 30 : signal_handler_free (gpointer data)
486 : : {
487 : 30 : SignalHandler *handler = data;
488 : :
489 [ + - ]: 30 : if (handler->closure != NULL)
490 : 30 : g_closure_invalidate (handler->closure);
491 : :
492 : 30 : handler->handler_id = 0;
493 : 30 : handler->signal_id = 0;
494 : 30 : handler->signal_detail = 0;
495 [ + - ]: 30 : g_clear_pointer (&handler->closure, g_closure_unref);
496 : 30 : g_slice_free (SignalHandler, handler);
497 : 30 : }
498 : :
499 : : static void
500 : 14 : g_signal_group_constructed (GObject *object)
501 : : {
502 : 14 : GSignalGroup *self = (GSignalGroup *)object;
503 : : GObject *target;
504 : :
505 : 14 : g_rec_mutex_lock (&self->mutex);
506 : :
507 : 14 : target = g_weak_ref_get (&self->target_ref);
508 [ - + ]: 14 : if (!g_signal_group_check_target_type (self, target))
509 : 0 : g_signal_group_set_target (self, NULL);
510 : :
511 : 14 : G_OBJECT_CLASS (g_signal_group_parent_class)->constructed (object);
512 : :
513 [ - + ]: 14 : g_clear_object (&target);
514 : :
515 : 14 : g_rec_mutex_unlock (&self->mutex);
516 : 14 : }
517 : :
518 : : static void
519 : 14 : g_signal_group_dispose (GObject *object)
520 : : {
521 : 14 : GSignalGroup *self = (GSignalGroup *)object;
522 : :
523 : 14 : g_rec_mutex_lock (&self->mutex);
524 : :
525 : 14 : g_signal_group_gc_handlers (self);
526 : :
527 [ + + ]: 14 : if (self->has_bound_at_least_once)
528 : 8 : g_signal_group_unbind (self);
529 : :
530 [ + - ]: 14 : g_clear_pointer (&self->handlers, g_ptr_array_unref);
531 : :
532 : 14 : g_rec_mutex_unlock (&self->mutex);
533 : :
534 : 14 : G_OBJECT_CLASS (g_signal_group_parent_class)->dispose (object);
535 : 14 : }
536 : :
537 : : static void
538 : 14 : g_signal_group_finalize (GObject *object)
539 : : {
540 : 14 : GSignalGroup *self = (GSignalGroup *)object;
541 : :
542 : 14 : g_weak_ref_clear (&self->target_ref);
543 : 14 : g_rec_mutex_clear (&self->mutex);
544 : :
545 : 14 : G_OBJECT_CLASS (g_signal_group_parent_class)->finalize (object);
546 : 14 : }
547 : :
548 : : static void
549 : 5 : g_signal_group_get_property (GObject *object,
550 : : guint prop_id,
551 : : GValue *value,
552 : : GParamSpec *pspec)
553 : : {
554 : 5 : GSignalGroup *self = G_SIGNAL_GROUP (object);
555 : :
556 [ + + - ]: 5 : switch ((GSignalGroupProperty) prop_id)
557 : : {
558 : 3 : case PROP_TARGET:
559 : 3 : g_value_take_object (value, g_signal_group_dup_target (self));
560 : 3 : break;
561 : :
562 : 2 : case PROP_TARGET_TYPE:
563 : 2 : g_value_set_gtype (value, self->target_type);
564 : 2 : break;
565 : :
566 : 0 : default:
567 : 0 : G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
568 : : }
569 : 5 : }
570 : :
571 : : static void
572 : 15 : g_signal_group_set_property (GObject *object,
573 : : guint prop_id,
574 : : const GValue *value,
575 : : GParamSpec *pspec)
576 : : {
577 : 15 : GSignalGroup *self = G_SIGNAL_GROUP (object);
578 : :
579 [ + + - ]: 15 : switch ((GSignalGroupProperty) prop_id)
580 : : {
581 : 1 : case PROP_TARGET:
582 : 1 : g_signal_group_set_target (self, g_value_get_object (value));
583 : 1 : break;
584 : :
585 : 14 : case PROP_TARGET_TYPE:
586 : 14 : g_signal_group_set_target_type (self, g_value_get_gtype (value));
587 : 14 : break;
588 : :
589 : 0 : default:
590 : 0 : G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
591 : : }
592 : 15 : }
593 : :
594 : : static void
595 : 3 : g_signal_group_class_init (GSignalGroupClass *klass)
596 : : {
597 : 3 : GObjectClass *object_class = G_OBJECT_CLASS (klass);
598 : :
599 : 3 : object_class->constructed = g_signal_group_constructed;
600 : 3 : object_class->dispose = g_signal_group_dispose;
601 : 3 : object_class->finalize = g_signal_group_finalize;
602 : 3 : object_class->get_property = g_signal_group_get_property;
603 : 3 : object_class->set_property = g_signal_group_set_property;
604 : :
605 : : /**
606 : : * GSignalGroup:target
607 : : *
608 : : * The target instance used when connecting signals.
609 : : *
610 : : * Since: 2.72
611 : : */
612 : 3 : properties[PROP_TARGET] =
613 : 3 : g_param_spec_object ("target",
614 : : "Target",
615 : : "The target instance used when connecting signals.",
616 : : G_TYPE_OBJECT,
617 : : (G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS));
618 : :
619 : : /**
620 : : * GSignalGroup:target-type
621 : : *
622 : : * The #GType of the target property.
623 : : *
624 : : * Since: 2.72
625 : : */
626 : 3 : properties[PROP_TARGET_TYPE] =
627 : 3 : g_param_spec_gtype ("target-type",
628 : : "Target Type",
629 : : "The GType of the target property.",
630 : : G_TYPE_OBJECT,
631 : : (G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS));
632 : :
633 : 3 : g_object_class_install_properties (object_class, LAST_PROP, properties);
634 : :
635 : : /**
636 : : * GSignalGroup::bind:
637 : : * @self: the #GSignalGroup
638 : : * @instance: a #GObject containing the new value for #GSignalGroup:target
639 : : *
640 : : * This signal is emitted when #GSignalGroup:target is set to a new value
641 : : * other than %NULL. It is similar to #GObject::notify on `target` except it
642 : : * will not emit when #GSignalGroup:target is %NULL and also allows for
643 : : * receiving the #GObject without a data-race.
644 : : *
645 : : * Since: 2.72
646 : : */
647 : 3 : signals[BIND] =
648 : 3 : g_signal_new ("bind",
649 : : G_TYPE_FROM_CLASS (klass),
650 : : G_SIGNAL_RUN_LAST,
651 : : 0,
652 : : NULL, NULL, NULL,
653 : : G_TYPE_NONE,
654 : : 1,
655 : : G_TYPE_OBJECT);
656 : :
657 : : /**
658 : : * GSignalGroup::unbind:
659 : : * @self: a #GSignalGroup
660 : : *
661 : : * This signal is emitted when the target instance of @self is set to a
662 : : * new #GObject.
663 : : *
664 : : * This signal will only be emitted if the previous target of @self is
665 : : * non-%NULL.
666 : : *
667 : : * Since: 2.72
668 : : */
669 : 3 : signals[UNBIND] =
670 : 3 : g_signal_new ("unbind",
671 : : G_TYPE_FROM_CLASS (klass),
672 : : G_SIGNAL_RUN_LAST,
673 : : 0,
674 : : NULL, NULL, NULL,
675 : : G_TYPE_NONE,
676 : : 0);
677 : 3 : }
678 : :
679 : : static void
680 : 14 : g_signal_group_init (GSignalGroup *self)
681 : : {
682 : 14 : g_rec_mutex_init (&self->mutex);
683 : 14 : self->handlers = g_ptr_array_new_with_free_func (signal_handler_free);
684 : 14 : self->target_type = G_TYPE_OBJECT;
685 : 14 : }
686 : :
687 : : /**
688 : : * g_signal_group_new:
689 : : * @target_type: the #GType of the target instance.
690 : : *
691 : : * Creates a new #GSignalGroup for target instances of @target_type.
692 : : *
693 : : * Returns: (transfer full): a new #GSignalGroup
694 : : *
695 : : * Since: 2.72
696 : : */
697 : : GSignalGroup *
698 : 14 : g_signal_group_new (GType target_type)
699 : : {
700 : 14 : g_return_val_if_fail (g_type_is_a (target_type, G_TYPE_OBJECT), NULL);
701 : :
702 : 13 : return g_object_new (G_TYPE_SIGNAL_GROUP,
703 : : "target-type", target_type,
704 : : NULL);
705 : : }
706 : :
707 : : static gboolean
708 : 32 : g_signal_group_connect_closure_ (GSignalGroup *self,
709 : : const gchar *detailed_signal,
710 : : GClosure *closure,
711 : : gboolean after)
712 : : {
713 : : GObject *target;
714 : : SignalHandler *handler;
715 : : guint signal_id;
716 : : GQuark signal_detail;
717 : :
718 : 32 : g_return_val_if_fail (G_IS_SIGNAL_GROUP (self), FALSE);
719 : 32 : g_return_val_if_fail (detailed_signal != NULL, FALSE);
720 : 32 : g_return_val_if_fail (closure != NULL, FALSE);
721 : :
722 [ + + ]: 32 : if (!g_signal_parse_name (detailed_signal, self->target_type,
723 : : &signal_id, &signal_detail, TRUE))
724 : : {
725 : 1 : g_critical ("Invalid signal name “%s”", detailed_signal);
726 : 1 : return FALSE;
727 : : }
728 : :
729 : 31 : g_rec_mutex_lock (&self->mutex);
730 : :
731 [ + + ]: 31 : if (self->has_bound_at_least_once)
732 : : {
733 : 1 : g_critical ("Cannot add signals after setting target");
734 : 1 : g_rec_mutex_unlock (&self->mutex);
735 : 1 : return FALSE;
736 : : }
737 : :
738 : 30 : handler = g_slice_new0 (SignalHandler);
739 : 30 : handler->group = self;
740 : 30 : handler->signal_id = signal_id;
741 : 30 : handler->signal_detail = signal_detail;
742 : 30 : handler->closure = g_closure_ref (closure);
743 : 30 : handler->connect_after = after;
744 : :
745 : 30 : g_closure_sink (closure);
746 : :
747 : 30 : g_ptr_array_add (self->handlers, handler);
748 : :
749 : 30 : target = g_weak_ref_get (&self->target_ref);
750 : :
751 [ - + ]: 30 : if (target != NULL)
752 : : {
753 : 0 : g_signal_group_bind_handler (self, handler, target);
754 : 0 : g_object_unref (target);
755 : : }
756 : :
757 : : /* Lazily remove any old handlers on connect */
758 : 30 : g_signal_group_gc_handlers (self);
759 : :
760 : 30 : g_rec_mutex_unlock (&self->mutex);
761 : 30 : return TRUE;
762 : : }
763 : :
764 : : /**
765 : : * g_signal_group_connect_closure:
766 : : * @self: a #GSignalGroup
767 : : * @detailed_signal: a string of the form `signal-name` with optional `::signal-detail`
768 : : * @closure: (not nullable): the closure to connect.
769 : : * @after: whether the handler should be called before or after the
770 : : * default handler of the signal.
771 : : *
772 : : * Connects @closure to the signal @detailed_signal on #GSignalGroup:target.
773 : : *
774 : : * You cannot connect a signal handler after #GSignalGroup:target has been set.
775 : : *
776 : : * Since: 2.74
777 : : */
778 : : void
779 : 6 : g_signal_group_connect_closure (GSignalGroup *self,
780 : : const gchar *detailed_signal,
781 : : GClosure *closure,
782 : : gboolean after)
783 : : {
784 : 6 : g_signal_group_connect_closure_ (self, detailed_signal, closure, after);
785 : 6 : }
786 : :
787 : : static void
788 : 27 : g_signal_group_connect_full (GSignalGroup *self,
789 : : const gchar *detailed_signal,
790 : : GCallback c_handler,
791 : : gpointer data,
792 : : GClosureNotify notify,
793 : : GConnectFlags flags,
794 : : gboolean is_object)
795 : : {
796 : : GClosure *closure;
797 : :
798 : 27 : g_return_if_fail (c_handler != NULL);
799 : 26 : g_return_if_fail (!is_object || G_IS_OBJECT (data));
800 : :
801 [ + + ]: 26 : if ((flags & G_CONNECT_SWAPPED) != 0)
802 : 3 : closure = g_cclosure_new_swap (c_handler, data, notify);
803 : : else
804 : 23 : closure = g_cclosure_new (c_handler, data, notify);
805 : :
806 [ + + ]: 26 : if (is_object)
807 : : {
808 : : /* Set closure->is_invalid when data is disposed. We only track this to avoid
809 : : * reconnecting in the future. However, we do a round of cleanup when ever we
810 : : * connect a new object or the target changes to GC the old handlers.
811 : : */
812 : 4 : g_object_watch_closure (data, closure);
813 : : }
814 : :
815 [ + + ]: 26 : if (!g_signal_group_connect_closure_ (self,
816 : : detailed_signal,
817 : : closure,
818 : 26 : (flags & G_CONNECT_AFTER) != 0))
819 : 2 : g_closure_unref (closure);
820 : : }
821 : :
822 : : /**
823 : : * g_signal_group_connect_object: (skip)
824 : : * @self: a #GSignalGroup
825 : : * @detailed_signal: a string of the form `signal-name` with optional `::signal-detail`
826 : : * @c_handler: (scope notified): the #GCallback to connect
827 : : * @object: (not nullable) (transfer none): the #GObject to pass as data to @c_handler calls
828 : : * @flags: #GConnectFlags for the signal connection
829 : : *
830 : : * Connects @c_handler to the signal @detailed_signal on #GSignalGroup:target.
831 : : *
832 : : * Ensures that the @object stays alive during the call to @c_handler
833 : : * by temporarily adding a reference count. When the @object is destroyed
834 : : * the signal handler will automatically be removed.
835 : : *
836 : : * You cannot connect a signal handler after #GSignalGroup:target has been set.
837 : : *
838 : : * Since: 2.72
839 : : */
840 : : void
841 : 4 : g_signal_group_connect_object (GSignalGroup *self,
842 : : const gchar *detailed_signal,
843 : : GCallback c_handler,
844 : : gpointer object,
845 : : GConnectFlags flags)
846 : : {
847 : 4 : g_return_if_fail (G_IS_OBJECT (object));
848 : :
849 : 4 : g_signal_group_connect_full (self, detailed_signal, c_handler, object, NULL,
850 : : flags, TRUE);
851 : : }
852 : :
853 : : /**
854 : : * g_signal_group_connect_data:
855 : : * @self: a #GSignalGroup
856 : : * @detailed_signal: a string of the form "signal-name::detail"
857 : : * @c_handler: (scope notified) (closure data) (destroy notify): the #GCallback to connect
858 : : * @data: the data to pass to @c_handler calls
859 : : * @notify: function to be called when disposing of @self
860 : : * @flags: the flags used to create the signal connection
861 : : *
862 : : * Connects @c_handler to the signal @detailed_signal
863 : : * on the target instance of @self.
864 : : *
865 : : * You cannot connect a signal handler after #GSignalGroup:target has been set.
866 : : *
867 : : * Since: 2.72
868 : : */
869 : : void
870 : 3 : g_signal_group_connect_data (GSignalGroup *self,
871 : : const gchar *detailed_signal,
872 : : GCallback c_handler,
873 : : gpointer data,
874 : : GClosureNotify notify,
875 : : GConnectFlags flags)
876 : : {
877 : 3 : g_signal_group_connect_full (self, detailed_signal, c_handler, data, notify,
878 : : flags, FALSE);
879 : 3 : }
880 : :
881 : : /**
882 : : * g_signal_group_connect: (skip)
883 : : * @self: a #GSignalGroup
884 : : * @detailed_signal: a string of the form "signal-name::detail"
885 : : * @c_handler: (scope notified): the #GCallback to connect
886 : : * @data: the data to pass to @c_handler calls
887 : : *
888 : : * Connects @c_handler to the signal @detailed_signal
889 : : * on the target instance of @self.
890 : : *
891 : : * You cannot connect a signal handler after #GSignalGroup:target has been set.
892 : : *
893 : : * Since: 2.72
894 : : */
895 : : void
896 : 14 : g_signal_group_connect (GSignalGroup *self,
897 : : const gchar *detailed_signal,
898 : : GCallback c_handler,
899 : : gpointer data)
900 : : {
901 : 14 : g_signal_group_connect_full (self, detailed_signal, c_handler, data, NULL,
902 : : 0, FALSE);
903 : 14 : }
904 : :
905 : : /**
906 : : * g_signal_group_connect_after: (skip)
907 : : * @self: a #GSignalGroup
908 : : * @detailed_signal: a string of the form "signal-name::detail"
909 : : * @c_handler: (scope notified): the #GCallback to connect
910 : : * @data: the data to pass to @c_handler calls
911 : : *
912 : : * Connects @c_handler to the signal @detailed_signal
913 : : * on the target instance of @self.
914 : : *
915 : : * The @c_handler will be called after the default handler of the signal.
916 : : *
917 : : * You cannot connect a signal handler after #GSignalGroup:target has been set.
918 : : *
919 : : * Since: 2.72
920 : : */
921 : : void
922 : 3 : g_signal_group_connect_after (GSignalGroup *self,
923 : : const gchar *detailed_signal,
924 : : GCallback c_handler,
925 : : gpointer data)
926 : : {
927 : 3 : g_signal_group_connect_full (self, detailed_signal, c_handler,
928 : : data, NULL, G_CONNECT_AFTER, FALSE);
929 : 3 : }
930 : :
931 : : /**
932 : : * g_signal_group_connect_swapped:
933 : : * @self: a #GSignalGroup
934 : : * @detailed_signal: a string of the form "signal-name::detail"
935 : : * @c_handler: (scope async): the #GCallback to connect
936 : : * @data: the data to pass to @c_handler calls
937 : : *
938 : : * Connects @c_handler to the signal @detailed_signal
939 : : * on the target instance of @self.
940 : : *
941 : : * The instance on which the signal is emitted and @data
942 : : * will be swapped when calling @c_handler.
943 : : *
944 : : * You cannot connect a signal handler after #GSignalGroup:target has been set.
945 : : *
946 : : * Since: 2.72
947 : : */
948 : : void
949 : 3 : g_signal_group_connect_swapped (GSignalGroup *self,
950 : : const gchar *detailed_signal,
951 : : GCallback c_handler,
952 : : gpointer data)
953 : : {
954 : 3 : g_signal_group_connect_full (self, detailed_signal, c_handler, data, NULL,
955 : : G_CONNECT_SWAPPED, FALSE);
956 : 3 : }
|
