Lines Matching defs:emission
49 * <emphasis>emission</emphasis> of a signal. Signals are introduced
53 * emission mainly involves invocation of a certain set of callbacks
69 * A signal emission consists of five stages, unless prematurely stopped:
89 * All handlers may prematurely stop a signal emission, and any number of
91 * a signal emission.
93 * of a signal emission.
98 * Second, upon emission of a %G_SIGNAL_DETAILED signal, an additional
103 * wildcard and matches any detail argument passed in to emission.
118 typedef struct _Emission Emission;
165 static inline void emission_push (Emission **emission_list_p,
166 Emission *emission);
167 static inline void emission_pop (Emission **emission_list_p,
168 Emission *emission);
169 static inline Emission* emission_find (Emission *emission_list,
229 Emission *next;
288 static Emission *g_recursive_emissions = NULL;
289 static Emission *g_restart_emissions = NULL;
689 emission_push (Emission **emission_list_p,
690 Emission *emission)
692 emission->next = *emission_list_p;
693 *emission_list_p = emission;
697 emission_pop (Emission **emission_list_p,
698 Emission *emission)
700 Emission *node, *last = NULL;
703 if (node == emission)
714 static inline Emission*
715 emission_find (Emission *emission_list,
720 Emission *emission;
722 for (emission = emission_list; emission; emission = emission->next)
723 if (emission->instance == instance &&
724 emission->ihint.signal_id == signal_id &&
725 emission->ihint.detail == detail)
726 return emission;
730 static inline Emission*
733 Emission *emission, *s = NULL, *c = NULL;
735 for (emission = g_restart_emissions; emission; emission = emission->next)
736 if (emission->instance == instance)
738 s = emission;
741 for (emission = g_recursive_emissions; emission; emission = emission->next)
742 if (emission->instance == instance)
744 c = emission;
814 * Stops a signal's current emission.
842 Emission *emission_list = node->flags & G_SIGNAL_NO_RECURSE ? g_restart_emissions : g_recursive_emissions;
843 Emission *emission = emission_find (emission_list, signal_id, detail, instance);
845 if (emission)
847 if (emission->state == EMISSION_HOOK)
848 g_warning (G_STRLOC ": emission of signal \"%s\" for instance `%p' cannot be stopped from emission hook",
850 else if (emission->state == EMISSION_RUN)
851 emission->state = EMISSION_STOP;
854 g_warning (G_STRLOC ": no emission of signal \"%s\" to stop for instance `%p'",
885 * Adds an emission hook for a signal, which will get called for any emission
916 g_warning ("%s: signal id `%u' does not support emission hooks (G_SIGNAL_NO_HOOKS flag set)", G_STRLOC, signal_id);
949 * @hook_id: the id of the emission hook, as returned by
952 * Deletes an emission hook.
1065 * Stops a signal's current emission.
1094 Emission *emission_list = node->flags & G_SIGNAL_NO_RECURSE ? g_restart_emissions : g_recursive_emissions;
1095 Emission *emission = emission_find (emission_list, signal_id, detail, instance);
1097 if (emission)
1099 if (emission->state == EMISSION_HOOK)
1100 g_warning (G_STRLOC ": emission of signal \"%s\" for instance `%p' cannot be stopped from emission hook",
1102 else if (emission->state == EMISSION_RUN)
1103 emission->state = EMISSION_STOP;
1106 g_warning (G_STRLOC ": no emission of signal \"%s\" to stop for instance `%p'",
1490 * @class_closure: The closure to invoke on signal emission; may be %NULL
1648 * @class_closure: The closure to invoke on signal emission; may be %NULL.
1718 Emission *emission;
1720 for (emission = (node.flags & G_SIGNAL_NO_RECURSE) ? g_restart_emissions : g_recursive_emissions;
1721 emission; emission = emission->next)
1722 if (emission->ihint.signal_id == node.signal_id)
1723 g_critical (G_STRLOC ": signal \"%s\" being destroyed is currently in emission (instance `%p')",
1724 node.name, emission->instance);
1836 * @instance_and_params: the argument list of the signal emission. The first
1851 Emission *emission = NULL;
1861 emission = emission_find_innermost (instance);
1862 if (emission)
1864 SignalNode *node = LOOKUP_SIGNAL_NODE (emission->ihint.signal_id);
1870 if (emission->chain_type != G_TYPE_NONE)
1872 ClassClosure *cc = signal_find_class_closure (node, emission->chain_type);
1886 g_warning ("%s: signal id `%u' cannot be chained from current emission stage for instance `%p'", G_STRLOC, node->signal_id, instance);
1893 emission->chain_type = chain_type;
1899 &emission->ihint);
1901 emission->chain_type = restore_type;
1925 Emission *emission = NULL;
1933 emission = emission_find_innermost (instance);
1934 if (emission)
1936 node = LOOKUP_SIGNAL_NODE (emission->ihint.signal_id);
1942 if (emission->chain_type != G_TYPE_NONE)
1944 ClassClosure *cc = signal_find_class_closure (node, emission->chain_type);
1958 g_warning ("%s: signal id `%u' cannot be chained from current emission stage for instance `%p'", G_STRLOC, node->signal_id, instance);
2014 emission->chain_type = chain_type;
2023 &emission->ihint);
2038 &emission->ihint);
2067 emission->chain_type = restore_type;
2076 * Returns the invocation hint of the innermost signal emission of instance.
2078 * Returns: the invocation hint of the innermost signal emission.
2083 Emission *emission = NULL;
2088 emission = emission_find_innermost (instance);
2091 return emission ? &emission->ihint : NULL;
2327 * currently ongoing emission depends on how far that emission has
2750 /* are there emission hooks pending? */
2769 /* is this a no-recurse signal already in emission? */
2779 /* none of the above, no emission required */
2785 * @instance_and_params: argument list for the signal emission. The first
2791 * @return_value: Location to store the return value of the signal emission.
2878 /* g_printerr ("omitting emission of \"%s\"\n", node->name); */
2937 /* g_printerr ("omitting emission of \"%s\"\n", node->name); */
3106 Emission emission;
3131 Emission *node = emission_find (g_restart_emissions, signal_id, detail, instance);
3150 emission.instance = instance;
3151 emission.ihint.signal_id = node->signal_id;
3152 emission.ihint.detail = detail;
3153 emission.ihint.run_type = 0;
3154 emission.state = 0;
3155 emission.chain_type = G_TYPE_NONE;
3156 emission_push ((node->flags & G_SIGNAL_NO_RECURSE) ? &g_restart_emissions : &g_recursive_emissions, &emission);
3169 emission.ihint.run_type = G_SIGNAL_RUN_FIRST;
3173 emission.state = EMISSION_RUN;
3175 emission.chain_type = G_TYPE_FROM_INSTANCE (instance);
3181 &emission.ihint);
3182 if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
3183 emission.state == EMISSION_RUN)
3184 emission.state = EMISSION_STOP;
3186 emission.chain_type = G_TYPE_NONE;
3189 if (emission.state == EMISSION_STOP)
3191 else if (emission.state == EMISSION_RESTART)
3200 emission.state = EMISSION_HOOK;
3213 need_destroy = !hook_func (&emission.ihint, node->n_params + 1, instance_and_params, hook->data);
3223 if (emission.state == EMISSION_RESTART)
3231 emission.state = EMISSION_RUN;
3251 &emission.ihint);
3252 if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
3253 emission.state == EMISSION_RUN)
3254 emission.state = EMISSION_STOP;
3258 tmp = emission.state == EMISSION_RUN ? handler->next : NULL;
3271 if (emission.state == EMISSION_STOP)
3273 else if (emission.state == EMISSION_RESTART)
3277 emission.ihint.run_type = G_SIGNAL_RUN_LAST;
3281 emission.state = EMISSION_RUN;
3283 emission.chain_type = G_TYPE_FROM_INSTANCE (instance);
3289 &emission.ihint);
3290 if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
3291 emission.state == EMISSION_RUN)
3292 emission.state = EMISSION_STOP;
3294 emission.chain_type = G_TYPE_NONE;
3297 if (emission.state == EMISSION_STOP)
3299 else if (emission.state == EMISSION_RESTART)
3307 emission.state = EMISSION_RUN;
3321 &emission.ihint);
3322 if (!accumulate (&emission.ihint, emission_return, &accu, accumulator) &&
3323 emission.state == EMISSION_RUN)
3324 emission.state = EMISSION_STOP;
3328 tmp = emission.state == EMISSION_RUN ? handler->next : NULL;
3340 if (emission.state == EMISSION_STOP)
3342 else if (emission.state == EMISSION_RESTART)
3348 emission.ihint.run_type = G_SIGNAL_RUN_CLEANUP;
3354 emission.state = EMISSION_STOP;
3356 emission.chain_type = G_TYPE_FROM_INSTANCE (instance);
3367 &emission.ihint);
3371 emission.chain_type = G_TYPE_NONE;
3373 if (emission.state == EMISSION_RESTART)
3380 emission_pop ((node->flags & G_SIGNAL_NO_RECURSE) ? &g_restart_emissions : &g_recursive_emissions, &emission);
3409 * that a return of %TRUE stops the signal emission: no further
3411 * the emission to coninue. The idea here is that a %TRUE return
