static void
plugin_action_cb (GtkAction *action,
GigglePlugin *plugin)
{
char *callback_name;
GigglePluginCallback callback;
const GSignalInvocationHint *hint;
g_signal_handlers_disconnect_by_func (action, plugin_action_cb, plugin);
hint = g_signal_get_invocation_hint (action);
callback_name = plugin_get_callback_name (gtk_action_get_name (action),
g_signal_name (hint->signal_id));
callback = plugin_lookup_symbol (plugin, callback_name);
if (callback) {
g_signal_connect (action, g_signal_name (hint->signal_id),
G_CALLBACK (callback), plugin);
callback (action, plugin);
} else if (!strcmp (g_signal_name (hint->signal_id), "activate")) {
g_warning ("%s: Cannot find %s()", G_STRFUNC, callback_name);
}
g_free (callback_name);
}
static void
plugin_action_cb (GtkAction *action,
GigglePlugin *plugin)
{
char *callback_name;
GigglePluginCallback callback;
const GSignalInvocationHint *hint;
hint = g_signal_get_invocation_hint (action);
g_signal_handlers_disconnect_by_func (action, plugin_action_cb, plugin);
callback_name = plugin_get_callback_name (gtk_action_get_name (action),
g_signal_name (hint->signal_id));
callback = plugin_lookup_symbol (plugin, callback_name);
if (callback) {
g_signal_connect (action, g_signal_name (hint->signal_id),
G_CALLBACK (callback), plugin);
callback (action, plugin);
}
g_free (callback_name);
}
static void
get_type (SomeType *atype,
const char *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
GError **error)
{
SignalParserData *data = user_data;
const char *type;
const char *pointer;
char *pointer_type;
type = get_value ("type", attribute_names, attribute_values);
if (!type) {
g_set_error (error,
GOM_SIGNAL_ERROR,
GOM_SIGNAL_ERROR_MISSING_TYPE_ATTRIBUTE,
"signal \"%s\" for GType \"%s\" has a missing \"type\" attribute for <%s>",
g_signal_name (data->signal),
g_type_name (data->type),
element_name);
return;
}
pointer = strchr (type, '*');
if (pointer) {
if (strchr (pointer + 1, '*')) {
g_set_error (error,
GOM_SIGNAL_ERROR,
GOM_SIGNAL_ERROR_POINTERS_TO_POINTERS_UNSUPPORTED,
"signal \"%s\" for GType \"%s\" has a \"type\" of \"%s\" for <%s>; "
"these are not currently supported by Gom",
g_signal_name (data->signal),
g_type_name (data->type),
element_name);
return;
}
pointer_type = g_strndup (type, pointer - type);
atype->pointer = TRUE;
atype->type = g_type_from_name (pointer_type);
g_free (pointer_type);
} else {
atype->type = g_type_from_name (type);
}
}
const gchar *
get_name_of_current_signal (gpointer instance)
{
GSignalInvocationHint *ihint;
ihint = g_signal_get_invocation_hint (instance);
return g_signal_name (ihint->signal_id);
}
void connect_signals (gpointer obj)
{
guint i, n_ids = 0;
guint *ids = NULL;
GType type = G_OBJECT_TYPE (obj);
ids = g_signal_list_ids (type, &n_ids);
for (i = 0; i < n_ids; i++) {
const gchar *name = g_signal_name (ids[i]);
g_signal_connect (obj, name, G_CALLBACK (signaled), (gpointer)name);
}
}
/* SoupSession should clean up all signal handlers on a message after
* it is finished, allowing the message to be reused if desired.
* #559054
*/
static void
ensure_no_signal_handlers (SoupMessage *msg, guint *signal_ids, guint n_signal_ids)
{
int i;
for (i = 0; i < n_signal_ids; i++) {
if (g_signal_handler_find (msg, G_SIGNAL_MATCH_ID, signal_ids[i],
0, NULL, NULL, NULL)) {
debug_printf (1, " Message has handler for '%s'\n",
g_signal_name (signal_ids[i]));
errors++;
}
}
}
/* Called for close tags </foo> */
static void
signal_parser_end_element (GMarkupParseContext *context,
const gchar *element_name,
gpointer user_data,
GError **error)
{
SignalParserData *data = user_data;
if (data->type) {
if (data->signal) {
if (!strcmp (element_name, "signal")) {
g_print ("adding %s::%s\n", g_type_name (data->type), g_signal_name (data->signal));
g_hash_table_insert (signals, GINT_TO_POINTER (data->signal), data->node);
data->signal = NULL;
data->node = NULL;
}
} else if (!strcmp (element_name, "object") ||
!strcmp (element_name, "interface")) {
data->type = NULL;
}
}
}
static void
process_signals (GType type)
{
guint i, n_signals, *signal_ids;
char *camel;
comma = TRUE;
if (type == GTK_TYPE_WIDGET) {
g_print ("%sSignals = ", g_type_name (type));
comma = FALSE;
} else {
g_print ("%sSignals = %sSignals", g_type_name (type), g_type_name (g_type_parent (type)));
}
signal_ids = g_signal_list_ids (type, &n_signals);
for (i = 0; i < n_signals; i++) {
camel = camel_case (g_signal_name (signal_ids[i]));
g_print ("%sattribute on%s { text }?", COMMA, camel);
g_free (camel);
comma = TRUE;
}
g_free (signal_ids);
}
static php_mgd_closure * __class_closure_lookup(GType class_type, guint signal_id)
{
if (signal_id == 0)
return NULL;
if (__classes_hash == NULL)
return NULL;
GHashTable *closures_hash;
closures_hash = g_hash_table_lookup(__classes_hash, g_type_name(class_type));
if (!closures_hash)
return NULL;
gchar *sname = g_strdup(g_signal_name(signal_id));
g_strdelimit (sname, G_STR_DELIMITERS ":^", '_');
php_mgd_closure *pmc = g_hash_table_lookup(closures_hash, sname);
g_free(sname);
return pmc;
}
static PHP_METHOD(php_midgard_reflection_class, listSignals)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
}
_GET_RC_CE;
if (ce == NULL)
return;
array_init(return_value);
GType classtype = g_type_from_name(php_class_name_to_g_class_name(ce->name));
if (!classtype) {
return;
}
guint n_ids = 0;
guint *ids = g_signal_list_ids(classtype, &n_ids);
if (ids == NULL) {
return;
}
size_t i;
for (i = 0; i < n_ids; i++) {
zval *signalname;
MAKE_STD_ZVAL(signalname);
ZVAL_STRING(signalname, (char *) g_signal_name(ids[i]), 1);
zend_hash_next_index_insert(HASH_OF(return_value), &signalname, sizeof(zval *), NULL);
}
g_free(ids);
}
static void
pyg_signal_class_closure_marshal(GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data)
{
PyGILState_STATE state;
GObject *object;
PyObject *object_wrapper;
GSignalInvocationHint *hint = (GSignalInvocationHint *)invocation_hint;
gchar *method_name, *tmp;
PyObject *method;
PyObject *params, *ret;
guint i, len;
state = pyglib_gil_state_ensure();
g_return_if_fail(invocation_hint != NULL);
/* get the object passed as the first argument to the closure */
object = g_value_get_object(¶m_values[0]);
g_return_if_fail(object != NULL && G_IS_OBJECT(object));
/* get the wrapper for this object */
object_wrapper = pygobject_new(object);
g_return_if_fail(object_wrapper != NULL);
/* construct method name for this class closure */
method_name = g_strconcat("do_", g_signal_name(hint->signal_id), NULL);
/* convert dashes to underscores. For some reason, g_signal_name
* seems to convert all the underscores in the signal name to
dashes??? */
for (tmp = method_name; *tmp != '\0'; tmp++)
if (*tmp == '-') *tmp = '_';
method = PyObject_GetAttrString(object_wrapper, method_name);
g_free(method_name);
if (!method) {
PyErr_Clear();
Py_DECREF(object_wrapper);
pyglib_gil_state_release(state);
return;
}
Py_DECREF(object_wrapper);
/* construct Python tuple for the parameter values; don't copy boxed values
initially because we'll check after the call to see if a copy is needed. */
params = PyTuple_New(n_param_values - 1);
for (i = 1; i < n_param_values; i++) {
PyObject *item = pyg_value_as_pyobject(¶m_values[i], FALSE);
/* error condition */
if (!item) {
Py_DECREF(params);
pyglib_gil_state_release(state);
return;
}
PyTuple_SetItem(params, i - 1, item);
}
ret = PyObject_CallObject(method, params);
/* Copy boxed values if others ref them, this needs to be done regardless of
exception status. */
len = PyTuple_Size(params);
for (i = 0; i < len; i++) {
PyObject *item = PyTuple_GetItem(params, i);
if (item != NULL && PyObject_TypeCheck(item, &PyGBoxed_Type)
&& item->ob_refcnt != 1) {
PyGBoxed* boxed_item = (PyGBoxed*)item;
if (!boxed_item->free_on_dealloc) {
gpointer boxed_ptr = pyg_boxed_get_ptr (boxed_item);
pyg_boxed_set_ptr (boxed_item, g_boxed_copy (boxed_item->gtype, boxed_ptr));
boxed_item->free_on_dealloc = TRUE;
}
}
}
if (ret == NULL) {
PyErr_Print();
Py_DECREF(method);
Py_DECREF(params);
pyglib_gil_state_release(state);
return;
}
Py_DECREF(method);
Py_DECREF(params);
if (G_IS_VALUE(return_value))
pyg_value_from_pyobject(return_value, ret);
Py_DECREF(ret);
pyglib_gil_state_release(state);
}
std::string
get_signals(GType gtype, GTypeIsAPointerFunc is_a_pointer_func)
{
std::string strResult;
std::string strObjectName = g_type_name(gtype);
gpointer gclass_ref = nullptr;
gpointer ginterface_ref = nullptr;
if (G_TYPE_IS_OBJECT(gtype))
gclass_ref = g_type_class_ref(gtype); // Ensures that class_init() is called.
else if (G_TYPE_IS_INTERFACE(gtype))
ginterface_ref = g_type_default_interface_ref(gtype); // install signals.
// Get the list of signals:
guint iCount = 0;
guint* pIDs = g_signal_list_ids(gtype, &iCount);
// Loop through the list of signals:
if (pIDs)
{
for (guint i = 0; i < iCount; i++)
{
guint signal_id = pIDs[i];
// Name:
std::string strName = g_signal_name(signal_id);
strResult += "(define-signal " + strName + "\n";
strResult += " (of-object \"" + strObjectName + "\")\n";
// Other information about the signal:
GSignalQuery signalQuery = {
0, nullptr, 0, GSignalFlags(0), 0, 0, nullptr,
};
g_signal_query(signal_id, &signalQuery);
// Return type:
std::string strReturnTypeName =
get_type_name_signal(signalQuery.return_type & ~G_SIGNAL_TYPE_STATIC_SCOPE,
is_a_pointer_func); // The type is mangled with a flag. Hacky.
// bool bReturnTypeHasStaticScope = (signalQuery.return_type & G_SIGNAL_TYPE_STATIC_SCOPE) ==
// G_SIGNAL_TYPE_STATIC_SCOPE;
strResult += " (return-type \"" + strReturnTypeName + "\")\n";
// Flags:
std::string strFlags;
add_signal_flag_if(strFlags, "Run First", signalQuery, G_SIGNAL_RUN_FIRST);
add_signal_flag_if(strFlags, "Run Last", signalQuery, G_SIGNAL_RUN_LAST);
add_signal_flag_if(strFlags, "Run Cleanup", signalQuery, G_SIGNAL_RUN_CLEANUP);
add_signal_flag_if(strFlags, "No Recurse", signalQuery, G_SIGNAL_NO_RECURSE);
add_signal_flag_if(strFlags, "Action", signalQuery, G_SIGNAL_ACTION);
add_signal_flag_if(strFlags, "No Hooks", signalQuery, G_SIGNAL_NO_HOOKS);
add_signal_flag_if(strFlags, "Must Collect", signalQuery, G_SIGNAL_MUST_COLLECT);
strResult += " (flags \"" + strFlags + "\")\n";
if (signalQuery.signal_flags & G_SIGNAL_DETAILED)
strResult += " (detailed #t)\n"; // Default: not detailed
if (signalQuery.signal_flags & G_SIGNAL_DEPRECATED)
strResult += " (deprecated #t)\n"; // Default: not deprecated
// Loop through the list of parameters:
const GType* pParameters = signalQuery.param_types;
if (pParameters)
{
strResult += " (parameters\n";
for (unsigned j = 0; j < signalQuery.n_params; j++)
{
GType typeParamMangled = pParameters[j];
// Parameter name:
// We can't get the real parameter name from the GObject system. It's not registered with
// g_signal_new().
gchar* pchNum = g_strdup_printf("%d", j);
std::string strParamName = "p" + std::string(pchNum);
g_free(pchNum);
pchNum = nullptr;
// Just like above, for the return type:
std::string strTypeName =
get_type_name_signal(typeParamMangled & ~G_SIGNAL_TYPE_STATIC_SCOPE,
is_a_pointer_func); // The type is mangled with a flag. Hacky.
// bool bTypeHasStaticScope = (typeParamMangled & G_SIGNAL_TYPE_STATIC_SCOPE) ==
// G_SIGNAL_TYPE_STATIC_SCOPE;
strResult += " '(\"" + strTypeName + "\" \"" + strParamName + "\")\n";
}
strResult += " )\n"; // close (parameters
}
strResult += ")\n\n"; // close (define-signal
}
}
g_free(pIDs);
if (gclass_ref)
g_type_class_unref(gclass_ref); // to match the g_type_class_ref() above.
else if (ginterface_ref)
g_type_default_interface_unref(ginterface_ref); // for interface ref above.
return strResult;
}
int
main (int argc, char **argv)
{
gint i;
GTest *test1, *test2;
GArray *test_threads;
const gint n_threads = 1;
#ifdef SYMBIAN
g_log_set_handler (NULL, G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);
g_set_print_handler(mrtPrintHandler);
#endif /*SYMBIAN*/
g_thread_init (NULL);
#ifndef SYMBIAN
g_print ("START: %s\n", argv[0]);
#else
#ifdef VERBOSE
g_print ("START: %s\n", argv[0]);
#endif
#endif /*SYMBIAN*/
g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | g_log_set_always_fatal (G_LOG_FATAL_MASK));
g_type_init ();
test1 = g_object_new (G_TYPE_TEST, NULL);
test2 = g_object_new (G_TYPE_TEST, NULL);
g_signal_connect (test1, "notify::test-prop", G_CALLBACK (notify), NULL);
g_signal_connect (test1, "test-signal1", G_CALLBACK (notify), NULL);
g_signal_connect (test1, "test-signal2", G_CALLBACK (notify), NULL);
#ifndef SYMBIAN
test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
stopping = FALSE;
for (i = 0; i < n_threads; i++) {
GThread *thread;
thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);
g_array_append_val (test_threads, thread);
thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);
g_array_append_val (test_threads, thread);
}
g_usleep (500000);
stopping = TRUE;
g_print ("\nstopping\n");
/* join all threads */
for (i = 0; i < 2 * n_threads; i++) {
GThread *thread;
thread = g_array_index (test_threads, GThread *, i);
g_thread_join (thread);
}
g_print ("stopped:%d\n",TESTNUM);
#else
#ifdef MULTITHREAD
test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
stopping = FALSE;
TESTNUM=1;
notifynum=0;
handlernum=0;
for (i = 0; i < n_threads; i++)
{
GThread *thread;
thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);
g_array_append_val (test_threads, thread);
thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);
g_array_append_val (test_threads, thread);
}
g_usleep (500000);
stopping = TRUE;
#ifdef VERBOSE
g_print ("\nstopping\n");
#endif
/* join all threads */
for (i = 0; i < 2 * n_threads; i++)
{
GThread *thread;
thread = g_array_index (test_threads, GThread *, i);
g_thread_join (thread);
}
g_assert(notifynum != 0);
g_assert(handlernum == 0);
g_array_free (test_threads, TRUE);
#ifdef VERBOSE
g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM);
#endif
test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
stopping = FALSE;
TESTNUM=2;
notifynum=0;
handlernum=0;
for (i = 0; i < n_threads; i++)
{
GThread *thread;
thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);
g_array_append_val (test_threads, thread);
thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);
g_array_append_val (test_threads, thread);
}
g_usleep (500000);
stopping = TRUE;
#ifdef VERBOSE
g_print ("\nstopping\n");
#endif
/* join all threads */
for (i = 0; i < 2 * n_threads; i++)
{
GThread *thread;
thread = g_array_index (test_threads, GThread *, i);
g_thread_join (thread);
}
g_assert(notifynum != 0);
g_assert(handlernum != 0);
g_array_free (test_threads, TRUE);
#ifdef VERBOSE
g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM);
#endif
test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
stopping = FALSE;
TESTNUM=3;
notifynum=0;
handlernum=0;
for (i = 0; i < n_threads; i++)
{
GThread *thread;
thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);
g_array_append_val (test_threads, thread);
thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);
g_array_append_val (test_threads, thread);
}
g_usleep (5000000);
stopping = TRUE;
#ifdef VERBOSE
g_print ("\nstopping\n");
#endif
/* join all threads */
for (i = 0; i < 2 * n_threads; i++)
{
GThread *thread;
thread = g_array_index (test_threads, GThread *, i);
g_thread_join (thread);
}
g_assert(notifynum != 0);
g_assert(handlernum == 0);
g_array_free (test_threads, TRUE);
#ifdef VERBOSE
g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM);
#endif
#else /* ! MULTITHREAD*/
TESTNUM=1;
#ifdef VERBOSE
g_print ("\nStarting with TESTNUM=%d\n",TESTNUM);
#endif
notifynum=0;
handlernum=0;
run_thread(test1);
g_assert(notifynum == LOOP +1);
g_assert(handlernum ==0);
notifynum=0;
handlernum=0;
run_thread(test2);
g_assert(notifynum == 0);
g_assert(handlernum == 0);
TESTNUM=2;
#ifdef VERBOSE
g_print ("\nStarting with TESTNUM=%d\n",TESTNUM);
#endif
notifynum=0;
handlernum=0;
run_thread(test1);
g_assert(notifynum == LOOP+1);
g_assert(handlernum == LOOP+1);
notifynum=0;
handlernum=0;
run_thread(test2);
g_assert(notifynum == 0);
g_assert(handlernum == LOOP+1);
TESTNUM=3;
#ifdef VERBOSE
g_print ("\nStarting with TESTNUM=%d\n",TESTNUM);
#endif
notifynum=0;
handlernum=0;
run_thread(test1);
g_assert(notifynum == LOOP +1);
g_assert(handlernum ==0);
notifynum=0;
handlernum=0;
run_thread(test2);
g_assert(notifynum == 0);
g_assert(handlernum == 0);
g_assert(g_signal_has_handler_pending(G_OBJECT(test1),g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,TRUE)==TRUE);
g_assert(g_signal_has_handler_pending(G_OBJECT(test2),g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,TRUE)==FALSE);
g_assert(g_signal_handler_is_connected(G_OBJECT(test1),g_signal_lookup("test-signal1",G_TYPE_TEST))==TRUE);
g_assert(g_signal_handler_is_connected(G_OBJECT(test2),g_signal_lookup("test-signal2",G_TYPE_TEST))==FALSE);
handlernum=g_signal_lookup("test-signal1",G_TYPE_TEST);
#ifdef VERBOSE
g_print("Signal id: %d\n",handlernum);
#endif
g_signal_connect (test2, "test-signal1", G_CALLBACK (notify), NULL);
hookid=g_signal_add_emission_hook(handlernum,NULL,(GSignalEmissionHook) hook_function,NULL,NULL);
#ifdef VERBOSE
g_print("Hookid: %d\n",hookid);
#endif
/********************/
#ifdef TEST_STOP_EMISSION
/*
notifynum=0;
handlernum=0;
g_print("The following call stops signal emission\n");
g_signal_stop_emission(G_OBJECT(test1),g_signal_lookup("test-signal1",G_TYPE_TEST),0);
g_print("The following call should abort and it is normal\n");
run_thread(test1);
printf("Notifynum: %d and Handlernum: %d\n",notifynum,handlernum);
*/
notifynum=0;
handlernum=0;
g_signal_stop_emission_by_name(G_OBJECT(test1),"test-signal1");
//run_thread(test1);
g_print("Notifynum: %d and Handlernum: %d\n",notifynum,handlernum);
#endif /*TEST_STOP_EMISSION*/
/*******************/
handlernum=0;
g_signal_emit(G_OBJECT (test1), g_test_signals[TEST_SIGNAL1], 0, 0);
g_signal_emit(G_OBJECT (test2), g_test_signals[TEST_SIGNAL1], 0, 0);
g_assert(handlernum==2);
g_signal_remove_emission_hook(g_signal_lookup("test-signal1",G_TYPE_TEST),hookid);
#ifdef VERBOSE
g_print("Emitting signal again after removing emission hook\n");
#endif
handlernum=0;
g_signal_emit (G_OBJECT (test1), g_test_signals[TEST_SIGNAL1], 0, 0);
g_signal_emit (G_OBJECT (test2), g_test_signals[TEST_SIGNAL1], 0, 0);
g_assert(handlernum==0);
g_assert (strcmp ("test-signal1", g_signal_name (g_signal_lookup("test-signal1",G_TYPE_TEST))) == 0);
g_assert (strcmp ("test-signal2", g_signal_name (g_signal_lookup("test-signal2",G_TYPE_TEST))) == 0);
memset(&gv,0,sizeof(gv));
g_value_init(&gv,G_TYPE_OBJECT);
g_value_set_object(&gv,test1);
gi=0;
g_signal_list_ids(G_OBJECT_TYPE(test1),&gi);
g_assert(g_signal_lookup("test-signal1",G_TYPE_TEST)==gi);
notifynum=0;
g_signal_emitv (&gv, g_test_signals[TEST_SIGNAL1], 0, &gv);
g_assert(notifynum==1);
g_signal_query(g_signal_lookup("test-signal1",G_TYPE_TEST),&gq);
g_assert(strcmp("test-signal1",gq.signal_name)==0);
g_assert(g_signal_lookup("test-signal1",G_TYPE_TEST)==gq.signal_id);
g_assert(g_signal_handler_find(G_OBJECT(test1), G_SIGNAL_RUN_LAST,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,NULL,NULL)==2);
notifynum=g_signal_handlers_block_matched(G_OBJECT(test1),G_SIGNAL_MATCH_FUNC,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,(gpointer)G_CALLBACK(notify),NULL);
handlernum=g_signal_handlers_unblock_matched(G_OBJECT(test1),G_SIGNAL_MATCH_FUNC,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,(gpointer)G_CALLBACK(notify),NULL);
g_assert(notifynum==handlernum);
#endif /*MULTITHREAD*/
#ifdef VERBOSE
g_printf ("\nsignals-multithread.c: Completed all tests\n");
#endif
#endif /*SYMBIAN*/
#if SYMBIAN
testResultXml("signals-singlethread");
#endif /* EMULATOR */
return 0;
}
