1 /* GObject - GLib Type, Object, Parameter and Signal Library
2 * Copyright (C) 2000 Red Hat, Inc.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General
15 * Public License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
17 * Boston, MA 02111-1307, USA.
19 * this code is based on the original GtkSignal implementation
20 * for the Gtk+ library by Peter Mattis <petm@xcf.berkeley.edu>
28 #include "gbsearcharray.h"
29 #include "gvaluecollector.h"
33 /* pre allocation configurations
35 #define MAX_STACK_VALUES (16)
36 #define BSA_PRE_ALLOC (20)
37 #define HANDLER_PRE_ALLOC (48)
38 #define EMISSION_PRE_ALLOC (16)
40 #define REPORT_BUG "please report occourance circumstances to gtk-devel-list@gnome.org"
43 /* --- generic allocation --- */
44 /* we special case allocations generically by replacing
45 * these functions with more speed/memory aware variants
47 #ifndef DISABLE_MEM_POOLS
48 static inline gpointer
49 g_generic_node_alloc (GTrashStack **trash_stack_p,
51 guint nodes_pre_alloc)
53 gpointer node = g_trash_stack_pop (trash_stack_p);
59 nodes_pre_alloc = MAX (nodes_pre_alloc, 1);
60 block = g_malloc (sizeof_node * nodes_pre_alloc);
61 while (--nodes_pre_alloc)
63 g_trash_stack_push (trash_stack_p, block);
71 #define g_generic_node_free(trash_stack_p, node) g_trash_stack_push (trash_stack_p, node)
72 #else /* !DISABLE_MEM_POOLS */
73 #define g_generic_node_alloc(t,sizeof_node,p) g_malloc (sizeof_node)
74 #define g_generic_node_free(t,node) g_free (node)
75 #endif /* !DISABLE_MEM_POOLS */
78 /* --- typedefs --- */
79 typedef struct _SignalNode SignalNode;
80 typedef struct _SignalKey SignalKey;
81 typedef struct _Emission Emission;
82 typedef struct _Handler Handler;
83 typedef struct _HandlerList HandlerList;
84 typedef struct _HandlerMatch HandlerMatch;
94 /* --- prototypes --- */
95 static inline guint signal_id_lookup (GQuark quark,
97 static void signal_destroy_R (SignalNode *signal_node);
98 static inline HandlerList* handler_list_ensure (guint signal_id,
100 static inline HandlerList* handler_list_lookup (guint signal_id,
102 static inline Handler* handler_new (gboolean after);
103 static void handler_insert (guint signal_id,
106 static Handler* handler_lookup (gpointer instance,
109 static inline HandlerMatch* handler_match_prepend (HandlerMatch *list,
112 static inline HandlerMatch* handler_match_free1_R (HandlerMatch *node,
114 static HandlerMatch* handlers_find (gpointer instance,
115 GSignalMatchType mask,
121 gboolean one_and_only);
122 static inline void handler_ref (Handler *handler);
123 static inline void handler_unref_R (guint signal_id,
126 static inline void emission_push (Emission **emission_list_p,
130 EmissionState *state_p);
131 static inline void emission_pop (Emission **emission_list_p,
132 EmissionState *state_p);
133 static inline Emission* emission_find (Emission *emission_list,
137 static gboolean signal_emit_R (SignalNode *node,
140 GValue *return_value,
141 const GValue *instance_and_params);
144 /* --- structures --- */
147 /* permanent portion */
153 /* reinitializable portion */
158 GClosure *class_closure;
159 GSignalAccumulator accumulator;
160 GSignalCMarshaller c_marshaller;
161 GHookList *emission_hooks;
177 EmissionState *state_p;
191 guint ref_count : 16;
192 #define HANDLER_MAX_REF_COUNT (1 << 16)
193 guint block_count : 12;
194 #define HANDLER_MAX_BLOCK_COUNT (1 << 12)
209 /* --- variables --- */
210 static GBSearchArray g_signal_key_bsa = { NULL, 0, 0, 0, NULL };
211 static GHashTable *g_handler_list_bsa_ht = NULL;
212 static Emission *g_recursive_emissions = NULL;
213 static Emission *g_restart_emissions = NULL;
214 static GTrashStack *g_bsa_ts = NULL;
215 static GTrashStack *g_handler_ts = NULL;
216 static GTrashStack *g_emission_ts = NULL;
217 G_LOCK_DEFINE_STATIC (g_signal_mutex);
220 /* --- signal nodes --- */
221 static guint g_n_signal_nodes = 0;
222 static SignalNode **g_signal_nodes = NULL;
224 static inline SignalNode*
225 LOOKUP_SIGNAL_NODE (register guint signal_id)
227 if (signal_id < g_n_signal_nodes)
228 return g_signal_nodes[signal_id];
234 /* --- functions --- */
236 signal_id_lookup (GQuark quark,
239 GType *ifaces, type = itype;
245 /* try looking up signals for this type and its anchestors */
248 SignalKey *signal_key;
251 signal_key = g_bsearch_array_lookup (&g_signal_key_bsa, &key);
254 return signal_key->signal_id;
256 type = g_type_parent (type);
260 /* no luck, try interfaces it exports */
261 ifaces = g_type_interfaces (itype, &n_ifaces);
264 SignalKey *signal_key;
266 key.itype = ifaces[n_ifaces];
267 signal_key = g_bsearch_array_lookup (&g_signal_key_bsa, &key);
272 return signal_key->signal_id;
281 handler_lists_cmp (gconstpointer node1,
284 const HandlerList *hlist1 = node1, *hlist2 = node2;
286 return G_BSEARCH_ARRAY_CMP (hlist1->signal_id, hlist2->signal_id);
289 static inline HandlerList*
290 handler_list_ensure (guint signal_id,
293 GBSearchArray *hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance);
298 hlbsa = g_generic_node_alloc (&g_bsa_ts,
299 sizeof (GBSearchArray),
301 hlbsa->cmp_func = handler_lists_cmp;
302 hlbsa->sizeof_node = sizeof (HandlerList);
303 hlbsa->flags = G_BSEARCH_DEFER_SHRINK;
306 g_hash_table_insert (g_handler_list_bsa_ht, instance, hlbsa);
308 key.signal_id = signal_id;
311 return g_bsearch_array_insert (hlbsa, &key, FALSE);
314 static inline HandlerList*
315 handler_list_lookup (guint signal_id,
318 GBSearchArray *hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance);
321 key.signal_id = signal_id;
323 return hlbsa ? g_bsearch_array_lookup (hlbsa, &key) : NULL;
327 handler_lookup (gpointer instance,
331 GBSearchArray *hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance);
337 for (i = 0; i < hlbsa->n_nodes; i++)
339 HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, i);
342 for (handler = hlist->handlers; handler; handler = handler->next)
343 if (handler->id == handler_id)
346 *signal_id_p = hlist->signal_id;
356 static inline HandlerMatch*
357 handler_match_prepend (HandlerMatch *list,
363 /* yeah, we could use our own memchunk here, introducing yet more
364 * rarely used cached nodes and extra allocation overhead.
365 * instead, we use GList* nodes, since they are exactly the size
366 * we need and are already cached. g_signal_init() asserts this.
368 node = (HandlerMatch*) g_list_alloc ();
369 node->handler = handler;
371 node->d.signal_id = signal_id;
372 handler_ref (handler);
376 static inline HandlerMatch*
377 handler_match_free1_R (HandlerMatch *node,
380 HandlerMatch *next = node->next;
382 handler_unref_R (node->d.signal_id, instance, node->handler);
383 g_list_free_1 ((GList*) node);
389 handlers_find (gpointer instance,
390 GSignalMatchType mask,
396 gboolean one_and_only)
398 HandlerMatch *mlist = NULL;
400 if (mask & G_SIGNAL_MATCH_ID)
402 HandlerList *hlist = handler_list_lookup (signal_id, instance);
404 SignalNode *node = NULL;
406 if (mask & G_SIGNAL_MATCH_FUNC)
408 node = LOOKUP_SIGNAL_NODE (signal_id);
409 if (!node || !node->c_marshaller)
414 for (handler = hlist ? hlist->handlers : NULL; handler; handler = handler->next)
416 ((mask & G_SIGNAL_MATCH_DETAIL) || handler->detail == detail) &&
417 ((mask & G_SIGNAL_MATCH_CLOSURE) || handler->closure == closure) &&
418 ((mask & G_SIGNAL_MATCH_DATA) || handler->closure->data == data) &&
419 ((mask & G_SIGNAL_MATCH_UNBLOCKED) || handler->block_count == 0) &&
420 ((mask & G_SIGNAL_MATCH_FUNC) || (handler->closure->marshal == node->c_marshaller &&
421 handler->closure->meta_marshal == 0 &&
422 ((GCClosure*) handler->closure)->callback == func)))
424 mlist = handler_match_prepend (mlist, handler, signal_id);
431 GBSearchArray *hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance);
438 for (i = 0; i < hlbsa->n_nodes; i++)
440 HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, i);
441 SignalNode *node = NULL;
444 if (!(mask & G_SIGNAL_MATCH_FUNC))
446 node = LOOKUP_SIGNAL_NODE (hlist->signal_id);
447 if (!node->c_marshaller)
451 for (handler = hlist->handlers; handler; handler = handler->next)
453 ((mask & G_SIGNAL_MATCH_DETAIL) || handler->detail == detail) &&
454 ((mask & G_SIGNAL_MATCH_CLOSURE) || handler->closure == closure) &&
455 ((mask & G_SIGNAL_MATCH_DATA) || handler->closure->data == data) &&
456 ((mask & G_SIGNAL_MATCH_UNBLOCKED) || handler->block_count == 0) &&
457 ((mask & G_SIGNAL_MATCH_FUNC) || (handler->closure->marshal == node->c_marshaller &&
458 handler->closure->meta_marshal == 0 &&
459 ((GCClosure*) handler->closure)->callback == func)))
461 mlist = handler_match_prepend (mlist, handler, hlist->signal_id);
472 static inline Handler*
473 handler_new (gboolean after)
475 static guint handler_id = 1;
476 Handler *handler = g_generic_node_alloc (&g_handler_ts,
479 #ifndef G_DISABLE_CHECKS
481 g_error (G_STRLOC ": handler id overflow, %s", REPORT_BUG);
484 handler->id = handler_id++;
485 handler->prev = NULL;
486 handler->next = NULL;
488 handler->ref_count = 1;
489 handler->block_count = 0;
490 handler->after = after != FALSE;
491 handler->closure = NULL;
497 handler_ref (Handler *handler)
499 g_return_if_fail (handler->ref_count > 0);
501 #ifndef G_DISABLE_CHECKS
502 if (handler->ref_count >= HANDLER_MAX_REF_COUNT - 1)
503 g_error (G_STRLOC ": handler ref_count overflow, %s", REPORT_BUG);
506 handler->ref_count += 1;
510 handler_unref_R (guint signal_id,
514 g_return_if_fail (handler->ref_count > 0);
516 handler->ref_count -= 1;
517 if (!handler->ref_count)
520 handler->next->prev = handler->prev;
521 if (handler->prev) /* watch out for g_signal_handlers_destroy()! */
522 handler->prev->next = handler->next;
525 HandlerList *hlist = handler_list_lookup (signal_id, instance);
527 hlist->handlers = handler->next;
529 G_UNLOCK (g_signal_mutex);
530 g_closure_unref (handler->closure);
531 G_LOCK (g_signal_mutex);
532 g_generic_node_free (&g_handler_ts, handler);
537 handler_insert (guint signal_id,
543 g_assert (handler->prev == NULL && handler->next == NULL); /* paranoid */
545 hlist = handler_list_ensure (signal_id, instance);
546 if (!hlist->handlers)
547 hlist->handlers = handler;
548 else if (hlist->handlers->after && !handler->after)
550 handler->next = hlist->handlers;
551 hlist->handlers->prev = handler;
552 hlist->handlers = handler;
556 Handler *tmp = hlist->handlers;
562 while (tmp->next && !tmp->next->after)
565 tmp->next->prev = handler;
566 handler->next = tmp->next;
573 emission_push (Emission **emission_list_p,
577 EmissionState *state_p)
579 Emission *emission = g_generic_node_alloc (&g_emission_ts,
582 emission->next = *emission_list_p;
583 emission->signal_id = signal_id;
584 emission->detail = detail;
585 emission->instance = instance;
586 emission->state_p = state_p;
587 *emission_list_p = emission;
591 emission_pop (Emission **emission_list_p,
592 EmissionState *state_p)
594 Emission **loc = emission_list_p, *emission = *loc;
596 while (emission->state_p != state_p)
598 loc = &emission->next;
601 *loc = emission->next;
602 g_generic_node_free (&g_emission_ts, emission);
605 static inline Emission*
606 emission_find (Emission *emission_list,
613 for (emission = emission_list; emission; emission = emission->next)
614 if (emission->instance == instance &&
615 emission->signal_id == signal_id &&
616 emission->detail == detail)
622 signal_key_cmp (gconstpointer node1,
625 const SignalKey *key1 = node1, *key2 = node2;
627 if (key1->itype == key2->itype)
628 return G_BSEARCH_ARRAY_CMP (key1->quark, key2->quark);
630 return G_BSEARCH_ARRAY_CMP (key1->itype, key2->itype);
634 g_signal_init (void) /* sync with gtype.c */
636 G_LOCK (g_signal_mutex);
637 if (!g_n_signal_nodes)
639 /* handler_id_node_prepend() requires this */
640 g_assert (sizeof (GList) == sizeof (HandlerMatch));
642 /* setup signal key array */
643 g_signal_key_bsa.cmp_func = signal_key_cmp;
644 g_signal_key_bsa.sizeof_node = sizeof (SignalKey);
645 g_signal_key_bsa.flags = G_BSEARCH_ALIGN_POWER2; /* alloc-only */
647 /* setup handler list binary searchable array hash table (in german, that'd be one word ;) */
648 g_handler_list_bsa_ht = g_hash_table_new (g_direct_hash, NULL);
650 /* invalid (0) signal_id */
651 g_n_signal_nodes = 1;
652 g_signal_nodes = g_renew (SignalNode*, g_signal_nodes, g_n_signal_nodes);
653 g_signal_nodes[0] = NULL;
655 G_UNLOCK (g_signal_mutex);
659 _g_signals_destroy (GType itype)
663 G_LOCK (g_signal_mutex);
664 for (i = 1; i < g_n_signal_nodes; i++)
666 SignalNode *node = g_signal_nodes[i];
668 if (node->itype == itype)
671 g_warning (G_STRLOC ": signal \"%s\" of type `%s' already destroyed",
673 g_type_name (node->itype));
675 signal_destroy_R (node);
678 G_UNLOCK (g_signal_mutex);
682 g_signal_stop_emission (gpointer instance,
688 g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
689 g_return_if_fail (signal_id > 0);
691 G_LOCK (g_signal_mutex);
692 node = LOOKUP_SIGNAL_NODE (signal_id);
693 if (node && detail && !(node->flags & G_SIGNAL_DETAILED))
695 g_warning ("%s: signal id `%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
696 G_UNLOCK (g_signal_mutex);
699 if (node && g_type_is_a (G_TYPE_FROM_INSTANCE (instance), node->itype))
701 Emission *emission_list = node->flags & G_SIGNAL_NO_RECURSE ? g_restart_emissions : g_recursive_emissions;
702 Emission *emission = emission_find (emission_list, signal_id, detail, instance);
706 if (*emission->state_p == EMISSION_HOOK)
707 g_warning (G_STRLOC ": emission of signal \"%s\" for instance `%p' cannot be stopped from emission hook",
708 node->name, instance);
709 else if (*emission->state_p == EMISSION_RUN)
710 *emission->state_p = EMISSION_STOP;
713 g_warning (G_STRLOC ": no emission of signal \"%s\" to stop for instance `%p'",
714 node->name, instance);
717 g_warning ("%s: signal id `%u' is invalid for instance `%p'", G_STRLOC, signal_id, instance);
718 G_UNLOCK (g_signal_mutex);
722 signal_parse_name (const gchar *name,
725 gboolean force_quark)
727 const gchar *colon = strchr (name, ':');
732 signal_id = signal_id_lookup (g_quark_try_string (name), itype);
733 if (signal_id && detail_p)
736 else if (colon[1] == ':')
739 guint l = colon - name;
743 memcpy (buffer, name, l);
745 signal_id = signal_id_lookup (g_quark_try_string (buffer), itype);
749 gchar *signal = g_new (gchar, l + 1);
751 memcpy (signal, name, l);
753 signal_id = signal_id_lookup (g_quark_try_string (signal), itype);
757 if (signal_id && detail_p)
758 *detail_p = colon[2] ? (force_quark ? g_quark_from_string : g_quark_try_string) (colon + 2) : 0;
766 g_signal_parse_name (const gchar *detailed_signal,
770 gboolean force_detail_quark)
775 g_return_val_if_fail (detailed_signal != NULL, FALSE);
776 g_return_val_if_fail (G_TYPE_IS_INSTANTIATABLE (itype) || G_TYPE_IS_INTERFACE (itype), FALSE);
778 G_LOCK (g_signal_mutex);
779 signal_id = signal_parse_name (detailed_signal, itype, &detail, force_detail_quark);
780 G_UNLOCK (g_signal_mutex);
785 *signal_id_p = signal_id;
796 g_signal_lookup (const gchar *name,
801 g_return_val_if_fail (name != NULL, 0);
802 g_return_val_if_fail (G_TYPE_IS_INSTANTIATABLE (itype) || G_TYPE_IS_INTERFACE (itype), 0);
804 G_LOCK (g_signal_mutex);
805 signal_id = signal_id_lookup (g_quark_try_string (name), itype);
806 G_UNLOCK (g_signal_mutex);
812 g_signal_name (guint signal_id)
817 G_LOCK (g_signal_mutex);
818 node = LOOKUP_SIGNAL_NODE (signal_id);
819 name = node ? node->name : NULL;
820 G_UNLOCK (g_signal_mutex);
826 g_signal_query (guint signal_id,
831 g_return_if_fail (query != NULL);
833 G_LOCK (g_signal_mutex);
834 node = LOOKUP_SIGNAL_NODE (signal_id);
835 if (!node || node->destroyed)
836 query->signal_id = 0;
839 query->signal_id = node->signal_id;
840 query->signal_name = node->name;
841 query->itype = node->itype;
842 query->signal_flags = node->flags;
843 query->return_type = node->return_type;
844 query->n_params = node->n_params;
845 query->param_types = node->param_types;
847 G_UNLOCK (g_signal_mutex);
851 g_signal_list_ids (GType itype,
859 g_return_val_if_fail (G_TYPE_IS_INSTANTIATABLE (itype) || G_TYPE_IS_INTERFACE (itype), NULL);
860 g_return_val_if_fail (n_ids != NULL, NULL);
862 G_LOCK (g_signal_mutex);
864 keys = g_signal_key_bsa.nodes;
865 n_nodes = g_signal_key_bsa.n_nodes;
866 result = g_array_new (FALSE, FALSE, sizeof (guint));
868 for (i = 0; i < n_nodes; i++)
869 if (keys[i].itype == itype)
871 gchar *name = g_quark_to_string (keys[i].quark);
873 /* Signal names with "_" in them are aliases to the same
874 * name with "-" instead of "_".
876 if (!strchr (name, '_'))
877 g_array_append_val (result, keys[i].signal_id);
880 *n_ids = result->len;
882 G_UNLOCK (g_signal_mutex);
884 return (guint *) g_array_free (result, FALSE);
888 g_signal_new_valist (const gchar *signal_name,
890 GSignalFlags signal_flags,
891 GClosure *class_closure,
892 GSignalAccumulator accumulator,
893 GSignalCMarshaller c_marshaller,
904 param_types = g_new (GType, n_params);
906 for (i = 0; i < n_params; i++)
907 param_types[i] = va_arg (args, GType);
912 signal_id = g_signal_newv (signal_name, itype, signal_flags,
913 class_closure, accumulator, c_marshaller,
914 return_type, n_params, param_types);
915 g_free (param_types);
921 g_signal_newc (const gchar *signal_name,
923 GSignalFlags signal_flags,
925 GSignalAccumulator accumulator,
926 GSignalCMarshaller c_marshaller,
934 g_return_val_if_fail (signal_name != NULL, 0);
936 va_start (args, n_params);
938 signal_id = g_signal_new_valist (signal_name, itype, signal_flags,
939 g_signal_type_cclosure_new (itype,
941 accumulator, c_marshaller,
942 return_type, n_params, args);
950 g_signal_newv (const gchar *signal_name,
952 GSignalFlags signal_flags,
953 GClosure *class_closure,
954 GSignalAccumulator accumulator,
955 GSignalCMarshaller c_marshaller,
964 g_return_val_if_fail (signal_name != NULL, 0);
965 g_return_val_if_fail (G_TYPE_IS_INSTANTIATABLE (itype) || G_TYPE_IS_INTERFACE (itype), 0);
967 g_return_val_if_fail (param_types != NULL, 0);
968 if (return_type != G_TYPE_NONE)
969 g_return_val_if_fail (accumulator == NULL, 0);
971 name = g_strdup (signal_name);
972 g_strdelimit (name, G_STR_DELIMITERS ":^", '_'); // FIXME do character checks like for types
974 G_LOCK (g_signal_mutex);
976 signal_id = signal_id_lookup (g_quark_try_string (name), itype);
977 node = LOOKUP_SIGNAL_NODE (signal_id);
978 if (node && !node->destroyed)
980 g_warning (G_STRLOC ": signal \"%s\" already exists in the `%s' %s",
982 g_type_name (node->itype),
983 G_TYPE_IS_INTERFACE (node->itype) ? "interface" : "class ancestry");
985 G_UNLOCK (g_signal_mutex);
988 if (node && node->itype != itype)
990 g_warning (G_STRLOC ": signal \"%s\" for type `%s' was previously created for type `%s'",
993 g_type_name (node->itype));
995 G_UNLOCK (g_signal_mutex);
998 for (i = 0; i < n_params; i++)
999 if (!G_TYPE_IS_VALUE (param_types[i]) ||
1000 param_types[i] == G_TYPE_ENUM || param_types[i] == G_TYPE_FLAGS) /* FIXME: kludge */
1002 g_warning (G_STRLOC ": parameter %d of type `%s' for signal \"%s::%s\" is not a value type",
1003 i + 1, g_type_name (param_types[i]), g_type_name (itype), name);
1005 G_UNLOCK (g_signal_mutex);
1008 if (return_type != G_TYPE_NONE && !G_TYPE_IS_VALUE (return_type))
1010 g_warning (G_STRLOC ": return value of type `%s' for signal \"%s::%s\" is not a value type",
1011 g_type_name (param_types[i]), g_type_name (itype), name);
1013 G_UNLOCK (g_signal_mutex);
1017 /* setup permanent portion of signal node */
1022 signal_id = g_n_signal_nodes++;
1023 node = g_new (SignalNode, 1);
1024 node->signal_id = signal_id;
1025 g_signal_nodes = g_renew (SignalNode*, g_signal_nodes, g_n_signal_nodes);
1026 g_signal_nodes[signal_id] = node;
1027 node->itype = itype;
1030 key.quark = g_quark_from_string (node->name);
1031 key.signal_id = signal_id;
1032 g_bsearch_array_insert (&g_signal_key_bsa, &key, FALSE);
1033 g_strdelimit (node->name, "_", '-');
1034 key.quark = g_quark_from_static_string (node->name);
1035 g_bsearch_array_insert (&g_signal_key_bsa, &key, FALSE);
1037 node->destroyed = FALSE;
1039 /* setup reinitializable portion */
1040 node->flags = signal_flags & G_SIGNAL_FLAGS_MASK;
1041 node->n_params = n_params;
1042 node->param_types = g_memdup (param_types, sizeof (GType) * n_params);
1043 node->return_type = return_type;
1044 node->class_closure = class_closure ? g_closure_ref (class_closure) : NULL;
1045 node->accumulator = accumulator;
1046 node->c_marshaller = c_marshaller;
1047 node->emission_hooks = NULL;
1048 if (node->c_marshaller && class_closure && G_CLOSURE_NEEDS_MARSHAL (class_closure))
1049 g_closure_set_marshal (class_closure, node->c_marshaller);
1051 G_UNLOCK (g_signal_mutex);
1056 signal_destroy_R (SignalNode *signal_node)
1058 SignalNode node = *signal_node;
1060 signal_node->destroyed = TRUE;
1062 /* reentrancy caution, zero out real contents first */
1063 signal_node->n_params = 0;
1064 signal_node->param_types = NULL;
1065 signal_node->return_type = 0;
1066 signal_node->class_closure = NULL;
1067 signal_node->accumulator = NULL;
1068 signal_node->c_marshaller = NULL;
1069 signal_node->emission_hooks = NULL;
1071 #ifdef G_ENABLE_DEBUG
1072 /* check current emissions */
1076 for (emission = (node.flags & G_SIGNAL_NO_RECURSE) ? g_restart_emissions : g_recursive_emissions;
1077 emission; emission = emission->next)
1078 if (emission->signal_id == node.signal_id)
1079 g_critical (G_STRLOC ": signal \"%s\" being destroyed is currently in emission (instance `%p')",
1080 node.name, emission->instance);
1084 /* free contents that need to
1086 G_UNLOCK (g_signal_mutex);
1087 g_free (node.param_types);
1088 g_closure_unref (node.class_closure);
1089 if (node.emission_hooks)
1091 g_hook_list_clear (node.emission_hooks);
1092 g_free (node.emission_hooks);
1094 G_LOCK (g_signal_mutex);
1098 g_signal_connect_closure_by_id (gpointer instance,
1105 guint handler_id = 0;
1107 g_return_val_if_fail (G_TYPE_CHECK_INSTANCE (instance), 0);
1108 g_return_val_if_fail (signal_id > 0, 0);
1109 g_return_val_if_fail (closure != NULL, 0);
1111 G_LOCK (g_signal_mutex);
1112 node = LOOKUP_SIGNAL_NODE (signal_id);
1115 if (detail && !(node->flags & G_SIGNAL_DETAILED))
1116 g_warning ("%s: signal id `%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
1117 else if (!g_type_is_a (G_TYPE_FROM_INSTANCE (instance), node->itype))
1118 g_warning ("%s: signal id `%u' is invalid for instance `%p'", G_STRLOC, signal_id, instance);
1121 Handler *handler = handler_new (after);
1123 handler_id = handler->id;
1124 handler->detail = detail;
1125 handler->closure = g_closure_ref (closure);
1126 handler_insert (signal_id, instance, handler);
1127 if (node->c_marshaller && G_CLOSURE_NEEDS_MARSHAL (closure))
1128 g_closure_set_marshal (closure, node->c_marshaller);
1132 g_warning ("%s: signal id `%u' is invalid for instance `%p'", G_STRLOC, signal_id, instance);
1133 G_UNLOCK (g_signal_mutex);
1139 g_signal_connect_closure (gpointer instance,
1140 const gchar *detailed_signal,
1144 guint signal_id, handler_id = 0;
1148 g_return_val_if_fail (G_TYPE_CHECK_INSTANCE (instance), 0);
1149 g_return_val_if_fail (detailed_signal != NULL, 0);
1150 g_return_val_if_fail (closure != NULL, 0);
1152 G_LOCK (g_signal_mutex);
1153 itype = G_TYPE_FROM_INSTANCE (instance);
1154 signal_id = signal_parse_name (detailed_signal, itype, &detail, TRUE);
1157 SignalNode *node = LOOKUP_SIGNAL_NODE (signal_id);
1159 if (detail && !(node->flags & G_SIGNAL_DETAILED))
1160 g_warning ("%s: signal `%s' does not support details", G_STRLOC, detailed_signal);
1161 else if (!g_type_is_a (itype, node->itype))
1162 g_warning ("%s: signal `%s' is invalid for instance `%p'", G_STRLOC, detailed_signal, instance);
1165 Handler *handler = handler_new (after);
1167 handler_id = handler->id;
1168 handler->detail = detail;
1169 handler->closure = g_closure_ref (closure);
1170 handler_insert (signal_id, instance, handler);
1171 if (node->c_marshaller && G_CLOSURE_NEEDS_MARSHAL (handler->closure))
1172 g_closure_set_marshal (handler->closure, node->c_marshaller);
1176 g_warning ("%s: signal `%s' is invalid for instance `%p'", G_STRLOC, detailed_signal, instance);
1177 G_UNLOCK (g_signal_mutex);
1183 g_signal_connect_data (gpointer instance,
1184 const gchar *detailed_signal,
1185 GCallback c_handler,
1187 GClosureNotify destroy_data,
1191 guint signal_id, handler_id = 0;
1195 g_return_val_if_fail (G_TYPE_CHECK_INSTANCE (instance), 0);
1196 g_return_val_if_fail (detailed_signal != NULL, 0);
1197 g_return_val_if_fail (c_handler != NULL, 0);
1199 G_LOCK (g_signal_mutex);
1200 itype = G_TYPE_FROM_INSTANCE (instance);
1201 signal_id = signal_parse_name (detailed_signal, itype, &detail, TRUE);
1204 SignalNode *node = LOOKUP_SIGNAL_NODE (signal_id);
1206 if (detail && !(node->flags & G_SIGNAL_DETAILED))
1207 g_warning ("%s: signal `%s' does not support details", G_STRLOC, detailed_signal);
1208 else if (!g_type_is_a (itype, node->itype))
1209 g_warning ("%s: signal `%s' is invalid for instance `%p'", G_STRLOC, detailed_signal, instance);
1212 Handler *handler = handler_new (after);
1214 handler_id = handler->id;
1215 handler->detail = detail;
1216 handler->closure = g_closure_ref ((swapped ? g_cclosure_new_swap : g_cclosure_new) (c_handler, data, destroy_data));
1217 handler_insert (signal_id, instance, handler);
1218 if (node->c_marshaller && G_CLOSURE_NEEDS_MARSHAL (handler->closure))
1219 g_closure_set_marshal (handler->closure, node->c_marshaller);
1223 g_warning ("%s: signal `%s' is invalid for instance `%p'", G_STRLOC, detailed_signal, instance);
1224 G_UNLOCK (g_signal_mutex);
1230 g_signal_handler_block (gpointer instance,
1235 g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
1236 g_return_if_fail (handler_id > 0);
1238 G_LOCK (g_signal_mutex);
1239 handler = handler_lookup (instance, handler_id, NULL);
1242 #ifndef G_DISABLE_CHECKS
1243 if (handler->block_count >= HANDLER_MAX_BLOCK_COUNT - 1)
1244 g_error (G_STRLOC ": handler block_count overflow, %s", REPORT_BUG);
1247 handler->block_count += 1;
1250 g_warning ("%s: instance `%p' has no handler with id `%u'", G_STRLOC, instance, handler_id);
1251 G_UNLOCK (g_signal_mutex);
1255 g_signal_handler_unblock (gpointer instance,
1260 g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
1261 g_return_if_fail (handler_id > 0);
1263 G_LOCK (g_signal_mutex);
1264 handler = handler_lookup (instance, handler_id, NULL);
1267 if (handler->block_count)
1268 handler->block_count -= 1;
1270 g_warning (G_STRLOC ": handler `%u' of instance `%p' is not blocked", handler_id, instance);
1273 g_warning ("%s: instance `%p' has no handler with id `%u'", G_STRLOC, instance, handler_id);
1274 G_UNLOCK (g_signal_mutex);
1278 g_signal_handler_disconnect (gpointer instance,
1284 g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
1285 g_return_if_fail (handler_id > 0);
1287 G_LOCK (g_signal_mutex);
1288 handler = handler_lookup (instance, handler_id, &signal_id);
1292 handler->block_count = 1;
1293 handler_unref_R (signal_id, instance, handler);
1296 g_warning ("%s: instance `%p' has no handler with id `%u'", G_STRLOC, instance, handler_id);
1297 G_UNLOCK (g_signal_mutex);
1301 g_signal_handlers_destroy (gpointer instance)
1303 GBSearchArray *hlbsa;
1305 g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
1307 G_LOCK (g_signal_mutex);
1308 hlbsa = g_hash_table_lookup (g_handler_list_bsa_ht, instance);
1313 /* reentrancy caution, delete instance trace first */
1314 g_hash_table_remove (g_handler_list_bsa_ht, instance);
1316 for (i = 0; i < hlbsa->n_nodes; i++)
1318 HandlerList *hlist = g_bsearch_array_get_nth (hlbsa, i);
1319 Handler *handler = hlist->handlers;
1323 Handler *tmp = handler;
1325 handler = tmp->next;
1326 tmp->block_count = 1;
1327 /* cruel unlink, this works because _all_ handlers vanish */
1333 handler_unref_R (0, NULL, tmp);
1337 g_free (hlbsa->nodes);
1338 g_generic_node_free (&g_bsa_ts, hlbsa);
1340 G_UNLOCK (g_signal_mutex);
1344 g_signal_handler_find (gpointer instance,
1345 GSignalMatchType mask,
1352 guint handler_id = 0;
1354 g_return_val_if_fail (G_TYPE_CHECK_INSTANCE (instance), 0);
1355 g_return_val_if_fail ((mask & ~G_SIGNAL_MATCH_MASK) == 0, 0);
1357 if (mask & G_SIGNAL_MATCH_MASK)
1359 HandlerMatch *mlist;
1361 G_LOCK (g_signal_mutex);
1362 mlist = handlers_find (instance, mask, signal_id, detail, closure, func, data, TRUE);
1365 handler_id = mlist->handler->id;
1366 handler_match_free1_R (mlist, instance);
1368 G_UNLOCK (g_signal_mutex);
1375 signal_handlers_foreach_matched_R (gpointer instance,
1376 GSignalMatchType mask,
1382 void (*callback) (gpointer instance,
1385 HandlerMatch *mlist;
1386 guint n_handlers = 0;
1388 mlist = handlers_find (instance, mask, signal_id, detail, closure, func, data, FALSE);
1392 G_UNLOCK (g_signal_mutex);
1393 callback (instance, mlist->handler->id);
1394 G_LOCK (g_signal_mutex);
1395 mlist = handler_match_free1_R (mlist, instance);
1402 g_signal_handlers_block_matched (gpointer instance,
1403 GSignalMatchType mask,
1410 guint n_handlers = 0;
1412 g_return_val_if_fail (G_TYPE_CHECK_INSTANCE (instance), FALSE);
1413 g_return_val_if_fail ((mask & ~G_SIGNAL_MATCH_MASK) == 0, FALSE);
1415 if (mask & (G_SIGNAL_MATCH_CLOSURE | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA))
1417 G_LOCK (g_signal_mutex);
1418 n_handlers = signal_handlers_foreach_matched_R (instance, mask, signal_id, detail,
1419 closure, func, data,
1420 g_signal_handler_block);
1421 G_UNLOCK (g_signal_mutex);
1428 g_signal_handlers_unblock_matched (gpointer instance,
1429 GSignalMatchType mask,
1436 guint n_handlers = 0;
1438 g_return_val_if_fail (G_TYPE_CHECK_INSTANCE (instance), FALSE);
1439 g_return_val_if_fail ((mask & ~G_SIGNAL_MATCH_MASK) == 0, FALSE);
1441 if (mask & (G_SIGNAL_MATCH_CLOSURE | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA))
1443 G_LOCK (g_signal_mutex);
1444 n_handlers = signal_handlers_foreach_matched_R (instance, mask, signal_id, detail,
1445 closure, func, data,
1446 g_signal_handler_unblock);
1447 G_UNLOCK (g_signal_mutex);
1454 g_signal_handlers_disconnect_matched (gpointer instance,
1455 GSignalMatchType mask,
1462 guint n_handlers = 0;
1464 g_return_val_if_fail (G_TYPE_CHECK_INSTANCE (instance), FALSE);
1465 g_return_val_if_fail ((mask & ~G_SIGNAL_MATCH_MASK) == 0, FALSE);
1467 if (mask & (G_SIGNAL_MATCH_CLOSURE | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA))
1469 G_LOCK (g_signal_mutex);
1470 n_handlers = signal_handlers_foreach_matched_R (instance, mask, signal_id, detail,
1471 closure, func, data,
1472 g_signal_handler_disconnect);
1473 G_UNLOCK (g_signal_mutex);
1480 g_signal_has_handler_pending (gpointer instance,
1483 gboolean may_be_blocked)
1485 HandlerMatch *mlist;
1486 gboolean has_pending;
1488 g_return_val_if_fail (G_TYPE_CHECK_INSTANCE (instance), FALSE);
1489 g_return_val_if_fail (signal_id > 0, FALSE);
1491 G_LOCK (g_signal_mutex);
1494 SignalNode *node = LOOKUP_SIGNAL_NODE (signal_id);
1496 if (!(node->flags & G_SIGNAL_DETAILED))
1498 g_warning ("%s: signal id `%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
1499 G_UNLOCK (g_signal_mutex);
1503 mlist = handlers_find (instance,
1504 (G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DETAIL | (may_be_blocked ? 0 : G_SIGNAL_MATCH_UNBLOCKED)),
1505 signal_id, detail, NULL, NULL, NULL, TRUE);
1509 handler_match_free1_R (mlist, instance);
1512 has_pending = FALSE;
1513 G_UNLOCK (g_signal_mutex);
1519 g_signal_emitv (const GValue *instance_and_params,
1522 GValue *return_value)
1524 const GValue *param_values;
1529 g_return_if_fail (instance_and_params != NULL);
1530 instance = g_value_get_as_pointer (instance_and_params);
1531 g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
1532 g_return_if_fail (signal_id > 0);
1534 param_values = instance_and_params + 1;
1536 G_LOCK (g_signal_mutex);
1537 node = LOOKUP_SIGNAL_NODE (signal_id);
1538 if (!node || !g_type_is_a (G_TYPE_FROM_INSTANCE (instance), node->itype))
1540 g_warning ("%s: signal id `%u' is invalid for instance `%p'", G_STRLOC, signal_id, instance);
1541 G_UNLOCK (g_signal_mutex);
1544 #ifdef G_ENABLE_DEBUG
1545 if (detail && !(node->flags & G_SIGNAL_DETAILED))
1547 g_warning ("%s: signal id `%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
1548 G_UNLOCK (g_signal_mutex);
1551 for (i = 0; i < node->n_params; i++)
1552 if (!G_VALUE_HOLDS (param_values + i, node->param_types[i]))
1554 g_critical ("%s: value for `%s' parameter %u for signal \"%s\" is of type `%s'",
1556 g_type_name (node->param_types[i]),
1559 G_VALUE_TYPE_NAME (param_values + i));
1560 G_UNLOCK (g_signal_mutex);
1563 if (node->return_type != G_TYPE_NONE)
1567 g_critical ("%s: return value `%s' for signal \"%s\" is (NULL)",
1569 g_type_name (node->return_type),
1571 G_UNLOCK (g_signal_mutex);
1574 else if (!node->accumulator && !G_VALUE_HOLDS (return_value, node->return_type))
1576 g_critical ("%s: return value `%s' for signal \"%s\" is of type `%s'",
1578 g_type_name (node->return_type),
1580 G_VALUE_TYPE_NAME (return_value));
1581 G_UNLOCK (g_signal_mutex);
1586 return_value = NULL;
1587 #endif /* G_ENABLE_DEBUG */
1589 signal_emit_R (node, detail, instance, return_value, instance_and_params);
1590 G_UNLOCK (g_signal_mutex);
1594 g_signal_emit_valist (gpointer instance,
1599 GValue *instance_and_params, stack_values[MAX_STACK_VALUES], *free_me = NULL;
1600 GValue *param_values;
1604 g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
1605 g_return_if_fail (signal_id > 0);
1607 G_LOCK (g_signal_mutex);
1608 node = LOOKUP_SIGNAL_NODE (signal_id);
1609 if (!node || !g_type_is_a (G_TYPE_FROM_INSTANCE (instance), node->itype))
1611 g_warning ("%s: signal id `%u' is invalid for instance `%p'", G_STRLOC, signal_id, instance);
1612 G_UNLOCK (g_signal_mutex);
1615 #ifndef G_DISABLE_CHECKS
1616 if (detail && !(node->flags & G_SIGNAL_DETAILED))
1618 g_warning ("%s: signal id `%u' does not support detail (%u)", G_STRLOC, signal_id, detail);
1619 G_UNLOCK (g_signal_mutex);
1622 #endif /* !G_DISABLE_CHECKS */
1624 if (node->n_params < MAX_STACK_VALUES)
1625 instance_and_params = stack_values;
1628 free_me = g_new (GValue, node->n_params + 1);
1629 instance_and_params = free_me;
1631 param_values = instance_and_params + 1;
1632 for (i = 0; i < node->n_params; i++)
1636 param_values[i].g_type = 0;
1637 g_value_init (param_values + i, node->param_types[i]);
1638 G_VALUE_COLLECT (param_values + i, var_args, &error);
1641 g_warning ("%s: %s", G_STRLOC, error);
1644 /* we purposely leak the value here, it might not be
1645 * in a sane state if an error condition occoured
1648 g_value_unset (param_values + i);
1650 G_UNLOCK (g_signal_mutex);
1655 instance_and_params->g_type = 0;
1656 g_value_init (instance_and_params, node->itype);
1657 g_value_set_instance (instance_and_params, instance);
1658 if (node->return_type == G_TYPE_NONE)
1659 signal_emit_R (node, detail, instance, NULL, instance_and_params);
1662 GValue return_value = { 0, };
1663 gchar *error = NULL;
1665 g_value_init (&return_value, node->return_type);
1666 if (signal_emit_R (node, detail, instance, &return_value, instance_and_params))
1667 G_VALUE_LCOPY (&return_value, var_args, &error);
1669 g_value_unset (&return_value);
1672 g_warning ("%s: %s", G_STRLOC, error);
1675 /* we purposely leak the value here, it might not be
1676 * in a sane state if an error condition occoured
1680 for (i = 0; i < node->n_params; i++)
1681 g_value_unset (param_values + i);
1682 g_value_unset (instance_and_params);
1685 G_UNLOCK (g_signal_mutex);
1689 g_signal_emit (gpointer instance,
1696 va_start (var_args, detail);
1697 g_signal_emit_valist (instance, signal_id, detail, var_args);
1702 g_signal_emit_by_name (gpointer instance,
1703 const gchar *detailed_signal,
1709 g_return_if_fail (G_TYPE_CHECK_INSTANCE (instance));
1710 g_return_if_fail (detailed_signal != NULL);
1712 G_LOCK (g_signal_mutex);
1713 signal_id = signal_parse_name (detailed_signal, G_TYPE_FROM_INSTANCE (instance), &detail, TRUE);
1714 G_UNLOCK (g_signal_mutex);
1720 va_start (var_args, detailed_signal);
1721 g_signal_emit_valist (instance, signal_id, detail, var_args);
1725 g_warning ("%s: signal name `%s' is invalid for instance `%p'", G_STRLOC, detailed_signal, instance);
1729 signal_emit_R (SignalNode *node,
1732 GValue *return_value,
1733 const GValue *instance_and_params)
1735 EmissionState emission_state = 0;
1736 GSignalAccumulator accumulator;
1737 GSignalInvocationHint ihint;
1738 GClosure *class_closure;
1740 Handler *handler_list = NULL;
1741 GValue accu = { 0, };
1742 gboolean accu_used = FALSE;
1743 guint signal_id = node->signal_id;
1744 gboolean return_value_altered = FALSE;
1746 if (node->flags & G_SIGNAL_NO_RECURSE)
1748 Emission *emission = emission_find (g_restart_emissions, signal_id, detail, instance);
1752 *emission->state_p = EMISSION_RESTART;
1753 return return_value_altered;
1756 ihint.signal_id = node->signal_id;
1757 ihint.detail = detail;
1758 accumulator = node->accumulator;
1760 g_value_init (&accu, node->return_type);
1761 emission_push ((node->flags & G_SIGNAL_NO_RECURSE) ? &g_restart_emissions : &g_recursive_emissions,
1762 signal_id, detail, instance, &emission_state);
1763 class_closure = node->class_closure;
1768 handler_unref_R (signal_id, instance, handler_list);
1769 hlist = handler_list_lookup (signal_id, instance);
1770 handler_list = hlist ? hlist->handlers : NULL;
1772 handler_ref (handler_list);
1774 ihint.run_type = G_SIGNAL_RUN_FIRST;
1776 if ((node->flags & G_SIGNAL_RUN_FIRST) && class_closure)
1778 emission_state = EMISSION_RUN;
1780 G_UNLOCK (g_signal_mutex);
1784 g_value_reset (&accu);
1785 g_closure_invoke (class_closure,
1788 instance_and_params,
1790 if (!accumulator (&ihint, return_value, &accu) &&
1791 emission_state == EMISSION_RUN)
1792 emission_state = EMISSION_STOP;
1796 g_closure_invoke (class_closure,
1799 instance_and_params,
1801 G_LOCK (g_signal_mutex);
1802 return_value_altered = TRUE;
1804 if (emission_state == EMISSION_STOP)
1806 else if (emission_state == EMISSION_RESTART)
1810 if (node->emission_hooks)
1812 emission_state = EMISSION_HOOK;
1814 G_UNLOCK (g_signal_mutex);
1815 g_print ("emission_hooks()\n");
1816 G_LOCK (g_signal_mutex);
1818 if (emission_state == EMISSION_RESTART)
1824 Handler *handler = handler_list;
1826 emission_state = EMISSION_RUN;
1827 handler_ref (handler);
1834 handler_unref_R (signal_id, instance, handler_list);
1835 handler_list = handler;
1838 else if (!handler->block_count && (!handler->detail || handler->detail == detail))
1840 G_UNLOCK (g_signal_mutex);
1844 g_value_reset (&accu);
1845 g_closure_invoke (handler->closure,
1848 instance_and_params,
1850 if (!accumulator (&ihint, return_value, &accu) &&
1851 emission_state == EMISSION_RUN)
1852 emission_state = EMISSION_STOP;
1856 g_closure_invoke (handler->closure,
1859 instance_and_params,
1861 G_LOCK (g_signal_mutex);
1862 return_value_altered = TRUE;
1864 tmp = emission_state == EMISSION_RUN ? handler->next : NULL;
1867 tmp = handler->next;
1871 handler_unref_R (signal_id, instance, handler_list);
1872 handler_list = handler;
1877 if (emission_state == EMISSION_STOP)
1879 else if (emission_state == EMISSION_RESTART)
1883 ihint.run_type = G_SIGNAL_RUN_LAST;
1885 if ((node->flags & G_SIGNAL_RUN_LAST) && class_closure)
1887 emission_state = EMISSION_RUN;
1889 G_UNLOCK (g_signal_mutex);
1893 g_value_reset (&accu);
1894 g_closure_invoke (class_closure,
1897 instance_and_params,
1899 if (!accumulator (&ihint, return_value, &accu) &&
1900 emission_state == EMISSION_RUN)
1901 emission_state = EMISSION_STOP;
1905 g_closure_invoke (class_closure,
1908 instance_and_params,
1910 G_LOCK (g_signal_mutex);
1911 return_value_altered = TRUE;
1913 if (emission_state == EMISSION_STOP)
1915 else if (emission_state == EMISSION_RESTART)
1921 Handler *handler = handler_list;
1923 emission_state = EMISSION_RUN;
1924 handler_ref (handler);
1929 if (handler->after && !handler->block_count && (!handler->detail || handler->detail == detail))
1931 G_UNLOCK (g_signal_mutex);
1935 g_value_reset (&accu);
1936 g_closure_invoke (handler->closure,
1939 instance_and_params,
1941 if (!accumulator (&ihint, return_value, &accu) &&
1942 emission_state == EMISSION_RUN)
1943 emission_state = EMISSION_STOP;
1947 g_closure_invoke (handler->closure,
1950 instance_and_params,
1952 G_LOCK (g_signal_mutex);
1953 return_value_altered = TRUE;
1955 tmp = emission_state == EMISSION_RUN ? handler->next : NULL;
1958 tmp = handler->next;
1962 handler_unref_R (signal_id, instance, handler);
1967 if (emission_state == EMISSION_STOP)
1969 else if (emission_state == EMISSION_RESTART)
1975 ihint.run_type = G_SIGNAL_RUN_CLEANUP;
1977 if ((node->flags & G_SIGNAL_RUN_CLEANUP) && class_closure)
1979 gboolean need_unset = FALSE;
1981 emission_state = EMISSION_STOP;
1983 G_UNLOCK (g_signal_mutex);
1984 if (node->return_type != G_TYPE_NONE)
1988 g_value_init (&accu, node->return_type);
1992 g_value_reset (&accu);
1994 g_closure_invoke (class_closure,
1995 node->return_type != G_TYPE_NONE ? &accu : NULL,
1997 instance_and_params,
2000 g_value_unset (&accu);
2001 G_LOCK (g_signal_mutex);
2003 if (emission_state == EMISSION_RESTART)
2008 handler_unref_R (signal_id, instance, handler_list);
2010 emission_pop ((node->flags & G_SIGNAL_NO_RECURSE) ? &g_restart_emissions : &g_recursive_emissions, &emission_state);
2012 g_value_unset (&accu);
2014 return return_value_altered;
2018 /* --- compile standard marshallers --- */
2019 #include "gvaluetypes.h"
2020 #include "gmarshal.c"