* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
+ * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
*
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
*/
-#include <stdarg.h>
-#include "gtksignal.h"
+#include "gtksignal.h"
+#include "gtkargcollector.c"
+#include "gtkmarshal.c"
-#define MAX_PARAMS 20
-#define DONE 1
-#define RESTART 2
-#define GTK_RUN_TYPE(x) ((x) & GTK_RUN_MASK)
-
-
-typedef struct _GtkSignal GtkSignal;
-typedef struct _GtkSignalInfo GtkSignalInfo;
-typedef struct _GtkHandler GtkHandler;
-typedef struct _GtkHandlerInfo GtkHandlerInfo;
-typedef struct _GtkEmission GtkEmission;
-
-typedef void (*GtkSignalMarshaller0) (GtkObject *object,
- gpointer data);
-
-struct _GtkSignalInfo
-{
- gchar *name;
- gint object_type;
- gint signal_type;
-};
-
-struct _GtkSignal
-{
- GtkSignalInfo info;
- gint function_offset;
- GtkSignalRunType run_type;
- GtkSignalMarshaller marshaller;
- GtkType return_val;
- GtkType *params;
- gint nparams;
-};
-
-struct _GtkHandler
-{
- guint16 id;
- guint signal_type : 13;
- guint object_signal : 1;
- guint blocked : 1;
- guint after : 1;
- guint no_marshal : 1;
- GtkSignalFunc func;
- gpointer func_data;
- GtkSignalDestroy destroy_func;
- GtkHandler *next;
-};
-
-struct _GtkHandlerInfo
-{
- GtkObject *object;
- GtkSignalMarshaller marshaller;
- GtkArg *params;
- GtkType *param_types;
- GtkType return_val;
- GtkSignalRunType run_type;
- gint nparams;
- gint signal_type;
-};
-
-struct _GtkEmission
-{
- GtkObject *object;
- gint signal_type;
-};
-
-
-static void gtk_signal_init (void);
-static guint gtk_signal_hash (gint *key);
-static gint gtk_signal_compare (gint *a,
- gint *b);
-static guint gtk_signal_info_hash (GtkSignalInfo *a);
-static gint gtk_signal_info_compare (GtkSignalInfo *a,
- GtkSignalInfo *b);
-static GtkHandler* gtk_signal_handler_new (void);
-static void gtk_signal_handler_destroy (GtkHandler *handler);
-static void gtk_signal_handler_insert (GtkObject *object,
- GtkHandler *handler);
-static gint gtk_signal_real_emit (GtkObject *object,
- gint signal_type,
- va_list args);
-static GtkHandler* gtk_signal_get_handlers (GtkObject *object,
- gint signal_type);
-static gint gtk_signal_connect_by_type (GtkObject *object,
- gint signal_type,
- gint object_signal,
- GtkSignalFunc func,
- gpointer func_data,
- GtkSignalDestroy destroy_func,
- gint after,
- gint no_marshal);
-static GtkEmission* gtk_emission_new (void);
-static void gtk_emission_destroy (GtkEmission *emission);
-static void gtk_emission_add (GList **emissions,
- GtkObject *object,
- gint signal_type);
-static void gtk_emission_remove (GList **emissions,
- GtkObject *object,
- gint signal_type);
-static gint gtk_emission_check (GList *emissions,
- GtkObject *object,
- gint signal_type);
-static gint gtk_handlers_run (GtkHandler *handlers,
- GtkHandlerInfo *info,
- gint after);
-static void gtk_params_get (GtkArg *params,
- gint nparams,
- GtkType *param_types,
- GtkType return_val,
- va_list args);
-
-
-static gint initialize = TRUE;
-static GHashTable *signal_hash_table = NULL;
-static GHashTable *signal_info_hash_table = NULL;
-static gint next_signal = 1;
-static gint next_handler_id = 1;
-
-static const char *handler_key = "signal_handlers";
-
-static GMemChunk *handler_mem_chunk = NULL;
-static GMemChunk *emission_mem_chunk = NULL;
-
-static GList *current_emissions = NULL;
-static GList *stop_emissions = NULL;
-static GList *restart_emissions = NULL;
-
-static GtkSignalMarshal marshal = NULL;
-static GtkSignalDestroy destroy = NULL;
-
-
-gint
+/* the real parameter limit is of course given by GSignal, bu we need
+ * an upper limit for the implementations. so this should be adjusted
+ * with any future changes on the GSignal side of things.
+ */
+#define SIGNAL_MAX_PARAMS 12
+
+
+/* --- functions --- */
+guint
+gtk_signal_newv (const gchar *name,
+ GtkSignalRunType signal_flags,
+ GtkType object_type,
+ guint function_offset,
+ GtkSignalMarshaller marshaller,
+ GtkType return_val,
+ guint n_params,
+ GtkType *params)
+{
+ GClosure *closure;
+
+ g_return_val_if_fail (n_params < SIGNAL_MAX_PARAMS, 0);
+
+ closure = g_signal_type_cclosure_new (object_type, function_offset);
+
+ return g_signal_newv (name, object_type, signal_flags, closure, NULL, NULL, marshaller, return_val, n_params, params);
+}
+
+guint
gtk_signal_new (const gchar *name,
- GtkSignalRunType run_type,
- gint object_type,
- gint function_offset,
+ GtkSignalRunType signal_flags,
+ GtkType object_type,
+ guint function_offset,
GtkSignalMarshaller marshaller,
GtkType return_val,
- gint nparams,
+ guint n_params,
...)
{
GtkType *params;
- GtkSignal *signal;
- GtkSignalInfo info;
- gint *type;
- gint i;
- va_list args;
-
- g_return_val_if_fail (name != NULL, 0);
- g_return_val_if_fail (marshaller != NULL, 0);
- g_return_val_if_fail (nparams < 10, 0);
-
- if (initialize)
- gtk_signal_init ();
-
- info.name = (char*)name;
- info.object_type = object_type;
-
- type = g_hash_table_lookup (signal_info_hash_table, &info);
- if (type)
- {
- g_warning ("signal \"%s\" already exists in the \"%s\" class ancestry\n",
- name, gtk_type_name (object_type));
- return 0;
- }
-
- signal = g_new (GtkSignal, 1);
- signal->info.name = g_strdup(name);
- signal->info.object_type = object_type;
- signal->info.signal_type = next_signal++;
- signal->function_offset = function_offset;
- signal->run_type = run_type;
- signal->marshaller = marshaller;
- signal->return_val = return_val;
- signal->params = NULL;
- signal->nparams = nparams;
-
- g_hash_table_insert (signal_hash_table, &signal->info.signal_type, signal);
- g_hash_table_insert (signal_info_hash_table, &signal->info, &signal->info.signal_type);
-
- if (nparams > 0)
+ guint signal_id;
+
+ if (n_params)
{
- signal->params = g_new (GtkType, nparams);
- params = signal->params;
-
- va_start (args, nparams);
-
- for (i = 0; i < nparams; i++)
+ va_list args;
+ guint i;
+
+ params = g_new (GtkType, n_params);
+ va_start (args, n_params);
+ for (i = 0; i < n_params; i++)
params[i] = va_arg (args, GtkType);
-
va_end (args);
}
-
- return signal->info.signal_type;
-}
-
-gint
-gtk_signal_lookup (const gchar *name,
- gint object_type)
-{
- GtkSignalInfo info;
- gint *type;
-
- g_return_val_if_fail (name != NULL, 0);
-
- if (initialize)
- gtk_signal_init ();
-
- info.name = (char*)name;
-
- while (object_type)
- {
- info.object_type = object_type;
-
- type = g_hash_table_lookup (signal_info_hash_table, &info);
- if (type)
- return *type;
-
- object_type = gtk_type_parent (object_type);
- }
-
- return 0;
-}
-
-gchar*
-gtk_signal_name (gint signal_num)
-{
- GtkSignal *signal;
-
- signal = g_hash_table_lookup (signal_hash_table, &signal_num);
- if (signal)
- return signal->info.name;
-
- return NULL;
-}
-
-gint
-gtk_signal_emit (GtkObject *object,
- gint signal_type,
- ...)
-{
- gint return_val;
-
- va_list args;
-
- g_return_val_if_fail (object != NULL, FALSE);
-
- if (initialize)
- gtk_signal_init ();
-
- va_start (args, signal_type);
-
- return_val = gtk_signal_real_emit (object, signal_type, args);
-
- va_end (args);
-
- return return_val;
+ else
+ params = NULL;
+ signal_id = gtk_signal_newv (name,
+ signal_flags,
+ object_type,
+ function_offset,
+ marshaller,
+ return_val,
+ n_params,
+ params);
+ g_free (params);
+
+ return signal_id;
}
-gint
-gtk_signal_emit_by_name (GtkObject *object,
- const gchar *name,
- ...)
+void
+gtk_signal_emit_stop_by_name (GtkObject *object,
+ const gchar *name)
{
- gint return_val;
- gint type;
- va_list args;
-
- g_return_val_if_fail (object != NULL, FALSE);
-
- if (initialize)
- gtk_signal_init ();
-
- return_val = TRUE;
- type = gtk_signal_lookup (name, GTK_OBJECT_TYPE (object));
-
- if (type)
- {
- va_start (args, name);
-
- return_val = gtk_signal_real_emit (object, type, args);
-
- va_end (args);
- }
-
- return return_val;
+ g_return_if_fail (GTK_IS_OBJECT (object));
+
+ g_signal_stop_emission (object, g_signal_lookup (name, G_OBJECT_TYPE (object)), 0);
}
void
-gtk_signal_emit_stop (GtkObject *object,
- gint signal_type)
+gtk_signal_connect_object_while_alive (GtkObject *object,
+ const gchar *signal,
+ GtkSignalFunc func,
+ GtkObject *alive_object)
{
- g_return_if_fail (object != NULL);
- g_return_if_fail (signal_type >= 1);
-
- if (initialize)
- gtk_signal_init ();
-
- if (gtk_emission_check (current_emissions, object, signal_type))
- gtk_emission_add (&stop_emissions, object, signal_type);
+ g_return_if_fail (GTK_IS_OBJECT (object));
+
+ g_signal_connect_closure_by_id (object,
+ g_signal_lookup (signal, G_OBJECT_TYPE (object)), 0,
+ g_cclosure_new_object_swap (func, alive_object),
+ FALSE);
}
void
-gtk_signal_emit_stop_by_name (GtkObject *object,
- const gchar *name)
-{
- gint type;
-
- g_return_if_fail (object != NULL);
- g_return_if_fail (name != NULL);
-
- if (initialize)
- gtk_signal_init ();
-
- type = gtk_signal_lookup (name, GTK_OBJECT_TYPE (object));
- if (type)
- gtk_signal_emit_stop (object, type);
+gtk_signal_connect_while_alive (GtkObject *object,
+ const gchar *signal,
+ GtkSignalFunc func,
+ gpointer func_data,
+ GtkObject *alive_object)
+{
+ GClosure *closure;
+
+ g_return_if_fail (GTK_IS_OBJECT (object));
+
+ closure = g_cclosure_new (func, func_data, NULL);
+ g_object_watch_closure (G_OBJECT (alive_object), closure);
+ g_signal_connect_closure_by_id (object,
+ g_signal_lookup (signal, G_OBJECT_TYPE (object)), 0,
+ closure,
+ FALSE);
+}
+
+guint
+gtk_signal_connect_full (GtkObject *object,
+ const gchar *name,
+ GtkSignalFunc func,
+ GtkCallbackMarshal unsupported,
+ gpointer data,
+ GtkDestroyNotify destroy_func,
+ gint object_signal,
+ gint after)
+{
+ g_return_val_if_fail (GTK_IS_OBJECT (object), 0);
+ g_return_val_if_fail (unsupported == NULL, 0);
+
+ return g_signal_connect_closure_by_id (object,
+ g_signal_lookup (name, G_OBJECT_TYPE (object)), 0,
+ (object_signal
+ ? g_cclosure_new_swap
+ : g_cclosure_new) (func,
+ data,
+ (GClosureNotify) destroy_func),
+ after);
}
-gint
-gtk_signal_connect (GtkObject *object,
- const gchar *name,
- GtkSignalFunc func,
- gpointer func_data)
+void
+gtk_signal_compat_matched (GtkObject *object,
+ GtkSignalFunc func,
+ gpointer data,
+ GSignalMatchType match,
+ guint action)
{
- gint type;
-
- g_return_val_if_fail (object != NULL, 0);
-
- if (initialize)
- gtk_signal_init ();
+ guint n_handlers;
+
+ g_return_if_fail (GTK_IS_OBJECT (object));
- type = gtk_signal_lookup (name, GTK_OBJECT_TYPE (object));
- if (!type)
+ switch (action)
{
- g_warning ("could not find signal type \"%s\" in the \"%s\" class ancestry",
- name, gtk_type_name (GTK_OBJECT_TYPE (object)));
- return 0;
+ case 0: n_handlers = g_signal_handlers_disconnect_matched (object, match, 0, 0, NULL, func, data); break;
+ case 1: n_handlers = g_signal_handlers_block_matched (object, match, 0, 0, NULL, func, data); break;
+ case 2: n_handlers = g_signal_handlers_unblock_matched (object, match, 0, 0, NULL, func, data); break;
+ default: n_handlers = 0; break;
}
-
- return gtk_signal_connect_by_type (object, type, FALSE,
- func, func_data, NULL,
- FALSE, FALSE);
+
+ if (!n_handlers)
+ g_warning ("unable to find signal handler for object(%s:%p) with func(%p) and data(%p)",
+ G_OBJECT_TYPE_NAME (object), object, func, data);
}
-gint
-gtk_signal_connect_after (GtkObject *object,
- const gchar *name,
- GtkSignalFunc func,
- gpointer func_data)
+static inline gboolean
+gtk_arg_to_value (GtkArg *arg,
+ GValue *value)
{
- gint type;
-
- g_return_val_if_fail (object != NULL, 0);
-
- if (initialize)
- gtk_signal_init ();
-
- type = gtk_signal_lookup (name, GTK_OBJECT_TYPE (object));
- if (!type)
+ switch (G_TYPE_FUNDAMENTAL (arg->type))
{
- g_warning ("could not find signal type \"%s\" in the \"%s\" class ancestry",
- name, gtk_type_name (GTK_OBJECT_TYPE (object)));
- return 0;
+ case G_TYPE_CHAR: g_value_set_char (value, GTK_VALUE_CHAR (*arg)); break;
+ case G_TYPE_UCHAR: g_value_set_uchar (value, GTK_VALUE_UCHAR (*arg)); break;
+ case G_TYPE_BOOLEAN: g_value_set_boolean (value, GTK_VALUE_BOOL (*arg)); break;
+ case G_TYPE_INT: g_value_set_int (value, GTK_VALUE_INT (*arg)); break;
+ case G_TYPE_UINT: g_value_set_uint (value, GTK_VALUE_UINT (*arg)); break;
+ case G_TYPE_LONG: g_value_set_long (value, GTK_VALUE_LONG (*arg)); break;
+ case G_TYPE_ULONG: g_value_set_ulong (value, GTK_VALUE_ULONG (*arg)); break;
+ case G_TYPE_ENUM: g_value_set_enum (value, GTK_VALUE_ENUM (*arg)); break;
+ case G_TYPE_FLAGS: g_value_set_flags (value, GTK_VALUE_FLAGS (*arg)); break;
+ case G_TYPE_FLOAT: g_value_set_float (value, GTK_VALUE_FLOAT (*arg)); break;
+ case G_TYPE_DOUBLE: g_value_set_double (value, GTK_VALUE_DOUBLE (*arg)); break;
+ case G_TYPE_STRING: g_value_set_string (value, GTK_VALUE_STRING (*arg)); break;
+ case G_TYPE_BOXED: g_value_set_boxed (value, GTK_VALUE_BOXED (*arg)); break;
+ case G_TYPE_POINTER: g_value_set_pointer (value, GTK_VALUE_POINTER (*arg)); break;
+ case G_TYPE_OBJECT: g_value_set_object (value, GTK_VALUE_POINTER (*arg)); break;
+ default:
+ return FALSE;
}
-
- return gtk_signal_connect_by_type (object, type, FALSE,
- func, func_data, NULL,
- TRUE, FALSE);
+ return TRUE;
}
-gint
-gtk_signal_connect_interp (GtkObject *object,
- gchar *name,
- GtkCallbackMarshal func,
- gpointer func_data,
- GtkDestroyNotify destroy_func,
- gint after)
+static inline gboolean
+gtk_arg_static_to_value (GtkArg *arg,
+ GValue *value)
{
- gint type;
-
- g_return_val_if_fail (object != NULL, 0);
-
- if (initialize)
- gtk_signal_init ();
-
- type = gtk_signal_lookup (name, GTK_OBJECT_TYPE (object));
- if (!type)
+ switch (G_TYPE_FUNDAMENTAL (arg->type))
{
- g_warning ("could not find signal type \"%s\" in the \"%s\" class ancestry",
- name, gtk_type_name (GTK_OBJECT_TYPE (object)));
- return 0;
+ case G_TYPE_CHAR: g_value_set_char (value, GTK_VALUE_CHAR (*arg)); break;
+ case G_TYPE_UCHAR: g_value_set_uchar (value, GTK_VALUE_UCHAR (*arg)); break;
+ case G_TYPE_BOOLEAN: g_value_set_boolean (value, GTK_VALUE_BOOL (*arg)); break;
+ case G_TYPE_INT: g_value_set_int (value, GTK_VALUE_INT (*arg)); break;
+ case G_TYPE_UINT: g_value_set_uint (value, GTK_VALUE_UINT (*arg)); break;
+ case G_TYPE_LONG: g_value_set_long (value, GTK_VALUE_LONG (*arg)); break;
+ case G_TYPE_ULONG: g_value_set_ulong (value, GTK_VALUE_ULONG (*arg)); break;
+ case G_TYPE_ENUM: g_value_set_enum (value, GTK_VALUE_ENUM (*arg)); break;
+ case G_TYPE_FLAGS: g_value_set_flags (value, GTK_VALUE_FLAGS (*arg)); break;
+ case G_TYPE_FLOAT: g_value_set_float (value, GTK_VALUE_FLOAT (*arg)); break;
+ case G_TYPE_DOUBLE: g_value_set_double (value, GTK_VALUE_DOUBLE (*arg)); break;
+ case G_TYPE_STRING: g_value_set_static_string (value, GTK_VALUE_STRING (*arg)); break;
+ case G_TYPE_BOXED: g_value_set_static_boxed (value, GTK_VALUE_BOXED (*arg)); break;
+ case G_TYPE_POINTER: g_value_set_pointer (value, GTK_VALUE_POINTER (*arg)); break;
+ case G_TYPE_OBJECT: g_value_set_object (value, GTK_VALUE_POINTER (*arg)); break;
+ default:
+ return FALSE;
}
-
- return gtk_signal_connect_by_type (object, type, FALSE,
- (GtkSignalFunc) func, func_data,
- destroy_func, after, TRUE);
+ return TRUE;
}
-gint
-gtk_signal_connect_object (GtkObject *object,
- const gchar *name,
- GtkSignalFunc func,
- GtkObject *slot_object)
+static inline gboolean
+gtk_arg_set_from_value (GtkArg *arg,
+ GValue *value,
+ gboolean copy_string)
{
- gint type;
-
- g_return_val_if_fail (object != NULL, 0);
-
- if (initialize)
- gtk_signal_init ();
-
- type = gtk_signal_lookup (name, GTK_OBJECT_TYPE (object));
- if (!type)
+ switch (G_TYPE_FUNDAMENTAL (arg->type))
{
- g_warning ("could not find signal type \"%s\" in the \"%s\" class ancestry",
- name, gtk_type_name (GTK_OBJECT_TYPE (object)));
- return 0;
+ case G_TYPE_CHAR: GTK_VALUE_CHAR (*arg) = g_value_get_char (value); break;
+ case G_TYPE_UCHAR: GTK_VALUE_UCHAR (*arg) = g_value_get_uchar (value); break;
+ case G_TYPE_BOOLEAN: GTK_VALUE_BOOL (*arg) = g_value_get_boolean (value); break;
+ case G_TYPE_INT: GTK_VALUE_INT (*arg) = g_value_get_int (value); break;
+ case G_TYPE_UINT: GTK_VALUE_UINT (*arg) = g_value_get_uint (value); break;
+ case G_TYPE_LONG: GTK_VALUE_LONG (*arg) = g_value_get_long (value); break;
+ case G_TYPE_ULONG: GTK_VALUE_ULONG (*arg) = g_value_get_ulong (value); break;
+ case G_TYPE_ENUM: GTK_VALUE_ENUM (*arg) = g_value_get_enum (value); break;
+ case G_TYPE_FLAGS: GTK_VALUE_FLAGS (*arg) = g_value_get_flags (value); break;
+ case G_TYPE_FLOAT: GTK_VALUE_FLOAT (*arg) = g_value_get_float (value); break;
+ case G_TYPE_DOUBLE: GTK_VALUE_DOUBLE (*arg) = g_value_get_double (value); break;
+ case G_TYPE_BOXED: GTK_VALUE_BOXED (*arg) = g_value_get_boxed (value); break;
+ case G_TYPE_POINTER: GTK_VALUE_POINTER (*arg) = g_value_get_pointer (value); break;
+ case G_TYPE_OBJECT: GTK_VALUE_POINTER (*arg) = g_value_get_object (value); break;
+ case G_TYPE_STRING: if (copy_string)
+ GTK_VALUE_STRING (*arg) = g_value_dup_string (value);
+ else
+ GTK_VALUE_STRING (*arg) = g_value_get_string (value);
+ break;
+ default:
+ return FALSE;
}
-
- return gtk_signal_connect_by_type (object, type, TRUE,
- func, slot_object, NULL,
- FALSE, FALSE);
+ return TRUE;
}
-gint
-gtk_signal_connect_object_after (GtkObject *object,
- const gchar *name,
- GtkSignalFunc func,
- GtkObject *slot_object)
+static inline gboolean
+gtk_argloc_set_from_value (GtkArg *arg,
+ GValue *value,
+ gboolean copy_string)
{
- gint type;
-
- g_return_val_if_fail (object != NULL, 0);
-
- if (initialize)
- gtk_signal_init ();
-
- type = gtk_signal_lookup (name, GTK_OBJECT_TYPE (object));
- if (!type)
+ switch (G_TYPE_FUNDAMENTAL (arg->type))
{
- g_warning ("could not find signal type \"%s\" in the \"%s\" class ancestry",
- name, gtk_type_name (GTK_OBJECT_TYPE (object)));
- return 0;
+ case G_TYPE_CHAR: *GTK_RETLOC_CHAR (*arg) = g_value_get_char (value); break;
+ case G_TYPE_UCHAR: *GTK_RETLOC_UCHAR (*arg) = g_value_get_uchar (value); break;
+ case G_TYPE_BOOLEAN: *GTK_RETLOC_BOOL (*arg) = g_value_get_boolean (value); break;
+ case G_TYPE_INT: *GTK_RETLOC_INT (*arg) = g_value_get_int (value); break;
+ case G_TYPE_UINT: *GTK_RETLOC_UINT (*arg) = g_value_get_uint (value); break;
+ case G_TYPE_LONG: *GTK_RETLOC_LONG (*arg) = g_value_get_long (value); break;
+ case G_TYPE_ULONG: *GTK_RETLOC_ULONG (*arg) = g_value_get_ulong (value); break;
+ case G_TYPE_ENUM: *GTK_RETLOC_ENUM (*arg) = g_value_get_enum (value); break;
+ case G_TYPE_FLAGS: *GTK_RETLOC_FLAGS (*arg) = g_value_get_flags (value); break;
+ case G_TYPE_FLOAT: *GTK_RETLOC_FLOAT (*arg) = g_value_get_float (value); break;
+ case G_TYPE_DOUBLE: *GTK_RETLOC_DOUBLE (*arg) = g_value_get_double (value); break;
+ case G_TYPE_BOXED: *GTK_RETLOC_BOXED (*arg) = g_value_get_boxed (value); break;
+ case G_TYPE_POINTER: *GTK_RETLOC_POINTER (*arg) = g_value_get_pointer (value); break;
+ case G_TYPE_OBJECT: *GTK_RETLOC_POINTER (*arg) = g_value_get_object (value); break;
+ case G_TYPE_STRING: if (copy_string)
+ *GTK_RETLOC_STRING (*arg) = g_value_dup_string (value);
+ else
+ *GTK_RETLOC_STRING (*arg) = g_value_get_string (value);
+ break;
+ default:
+ return FALSE;
}
-
- return gtk_signal_connect_by_type (object, type, TRUE,
- func, slot_object, NULL,
- TRUE, FALSE);
+ return TRUE;
}
void
-gtk_signal_disconnect (GtkObject *object,
- gint anid)
-{
- GtkHandler *tmp;
- GtkHandler *prev;
-
- g_return_if_fail (object != NULL);
-
- if (initialize)
- gtk_signal_init ();
-
- prev = NULL;
- tmp = gtk_object_get_data (object, handler_key);
-
- while (tmp)
+gtk_signal_emitv (GtkObject *object,
+ guint signal_id,
+ GtkArg *args)
+{
+ GSignalQuery query;
+ GValue params[SIGNAL_MAX_PARAMS + 1] = { { 0, }, };
+ GValue rvalue = { 0, };
+ guint i;
+
+ g_return_if_fail (GTK_IS_OBJECT (object));
+
+ g_signal_query (signal_id, &query);
+ g_return_if_fail (query.signal_id != 0);
+ g_return_if_fail (g_type_is_a (GTK_OBJECT_TYPE (object), query.itype));
+ g_return_if_fail (query.n_params < SIGNAL_MAX_PARAMS);
+ if (query.n_params > 0)
+ g_return_if_fail (args != NULL);
+
+ g_value_init (params + 0, GTK_OBJECT_TYPE (object));
+ g_value_set_object (params + 0, G_OBJECT (object));
+ for (i = 0; i < query.n_params; i++)
{
- if (tmp->id == anid)
+ GValue *value = params + 1 + i;
+ GtkArg *arg = args + i;
+
+ g_value_init (value, arg->type & ~G_SIGNAL_TYPE_STATIC_SCOPE);
+ if (!gtk_arg_static_to_value (arg, value))
{
- if (prev)
- prev->next = tmp->next;
- else
- gtk_object_set_data (object, handler_key, tmp->next);
- gtk_signal_handler_destroy (tmp);
+ g_warning ("%s: failed to convert arg type `%s' to value type `%s'",
+ G_STRLOC, g_type_name (arg->type & ~G_SIGNAL_TYPE_STATIC_SCOPE),
+ g_type_name (G_VALUE_TYPE (value)));
return;
}
-
- prev = tmp;
- tmp = tmp->next;
}
-
- g_warning ("could not find handler (%d)", anid);
-}
-
-void
-gtk_signal_disconnect_by_data (GtkObject *object,
- gpointer data)
-{
- GtkHandler *start;
- GtkHandler *tmp;
- GtkHandler *prev;
- gint found_one;
-
- g_return_if_fail (object != NULL);
-
- if (initialize)
- gtk_signal_init ();
-
- prev = NULL;
- start = gtk_object_get_data (object, handler_key);
- tmp = start;
- found_one = FALSE;
-
- while (tmp)
+ if (query.return_type != G_TYPE_NONE)
+ g_value_init (&rvalue, query.return_type);
+
+ g_signal_emitv (params, signal_id, 0, &rvalue);
+
+ if (query.return_type != G_TYPE_NONE)
{
- if (tmp->func_data == data)
- {
- found_one = TRUE;
-
- if (prev)
- prev->next = tmp->next;
- else
- start = tmp->next;
-
- gtk_signal_handler_destroy (tmp);
-
- if (prev)
- {
- tmp = prev->next;
- }
- else
- {
- prev = NULL;
- tmp = start;
- }
- }
- else
- {
- prev = tmp;
- tmp = tmp->next;
- }
+ gtk_argloc_set_from_value (args + query.n_params, &rvalue, TRUE);
+ g_value_unset (&rvalue);
}
-
- gtk_object_set_data (object, handler_key, start);
-
- if (!found_one)
- g_warning ("could not find handler containing data (0x%0lX)", (long) data);
-}
-
-void
-gtk_signal_handler_block (GtkObject *object,
- gint anid)
-{
- GtkHandler *tmp;
-
- g_return_if_fail (object != NULL);
-
- if (initialize)
- gtk_signal_init ();
-
- tmp = gtk_object_get_data (object, handler_key);
-
- while (tmp)
+ for (i = 0; i < query.n_params; i++)
+ g_value_unset (params + 1 + i);
+ g_value_unset (params + 0);
+}
+
+static gboolean
+gtk_signal_collect_args (GtkArg *args,
+ guint n_args,
+ const GtkType *arg_types,
+ GtkType return_type,
+ va_list var_args)
+{
+ register GtkArg *last_arg;
+ register gboolean failed = FALSE;
+
+ for (last_arg = args + n_args; args < last_arg; args++)
{
- if (tmp->id == anid)
+ register gchar *error;
+
+ args->name = NULL;
+ args->type = *(arg_types++);
+ GTK_ARG_COLLECT_VALUE (args,
+ var_args,
+ error);
+ if (error)
{
- tmp->blocked = TRUE;
- return;
+ failed = TRUE;
+ g_warning ("gtk_signal_collect_args(): %s", error);
+ g_free (error);
}
-
- tmp = tmp->next;
}
-
- g_warning ("could not find handler (%d)", anid);
-}
-
-void
-gtk_signal_handler_block_by_data (GtkObject *object,
- gpointer data)
-{
- GtkHandler *tmp;
- gint found_one;
-
- g_return_if_fail (object != NULL);
-
- if (initialize)
- gtk_signal_init ();
-
- found_one = FALSE;
- tmp = gtk_object_get_data (object, handler_key);
-
- while (tmp)
+
+ args->type = return_type;
+ args->name = NULL;
+
+ return_type = GTK_FUNDAMENTAL_TYPE (return_type);
+ if (return_type != G_TYPE_NONE)
{
- if (tmp->func_data == data)
+ if (return_type != 0) /* FIXME: check for IS_ARG */
{
- tmp->blocked = TRUE;
- found_one = TRUE;
+ GTK_VALUE_POINTER (*args) = va_arg (var_args, gpointer);
+
+ if (GTK_VALUE_POINTER (*args) == NULL)
+ {
+ failed = TRUE;
+ g_warning ("gtk_signal_collect_args(): invalid NULL pointer for return argument type `%s'",
+ gtk_type_name (args->type));
+ }
}
-
- tmp = tmp->next;
- }
-
- if (!found_one)
- g_warning ("could not find handler containing data (0x%0lX)", (long) data);
-}
-
-void
-gtk_signal_handler_unblock (GtkObject *object,
- gint anid)
-{
- GtkHandler *tmp;
-
- g_return_if_fail (object != NULL);
-
- if (initialize)
- gtk_signal_init ();
-
- tmp = gtk_object_get_data (object, handler_key);
-
- while (tmp)
- {
- if (tmp->id == anid)
+ else
{
- tmp->blocked = FALSE;
- return;
+ failed = TRUE;
+ g_warning ("gtk_signal_collect_args(): unsupported return argument type `%s'",
+ gtk_type_name (args->type));
}
-
- tmp = tmp->next;
}
-
- g_warning ("could not find handler (%d)", anid);
+ else
+ GTK_VALUE_POINTER (*args) = NULL;
+
+ return failed;
}
+#if 0
void
-gtk_signal_handler_unblock_by_data (GtkObject *object,
- gpointer data)
+gtk_signal_emit (GtkObject *object,
+ guint signal_id,
+ ...)
{
- GtkHandler *tmp;
- gint found_one;
-
- g_return_if_fail (object != NULL);
-
- if (initialize)
- gtk_signal_init ();
-
- found_one = FALSE;
- tmp = gtk_object_get_data (object, handler_key);
-
- while (tmp)
- {
- if (tmp->func_data == data)
- {
- tmp->blocked = FALSE;
- found_one = TRUE;
- }
-
- tmp = tmp->next;
- }
-
- if (!found_one)
- g_warning ("could not find handler containing data (0x%0lX)", (long) data);
-}
+ GtkArg args[SIGNAL_MAX_PARAMS + 1];
+ GSignalQuery query;
+ gboolean abort;
+ va_list var_args;
+
+ g_return_if_fail (GTK_IS_OBJECT (object));
+
+ g_signal_query (signal_id, &query);
+ g_return_if_fail (query.signal_id != 0);
+ g_return_if_fail (query.n_params < SIGNAL_MAX_PARAMS);
+
+ va_start (var_args, signal_id);
+ abort = gtk_signal_collect_args (args,
+ query.n_params,
+ query.param_types,
+ query.return_type,
+ var_args);
+ va_end (var_args);
+
+ if (!abort)
+ gtk_signal_emitv (object, signal_id, args);
+}
+#endif
void
-gtk_signal_handlers_destroy (GtkObject *object)
+gtk_signal_emit (GtkObject *object,
+ guint signal_id,
+ ...)
{
- GtkHandler *list;
- GtkHandler *handler;
-
- list = gtk_object_get_data (object, handler_key);
- if (list)
- {
- while (list)
- {
- handler = list->next;
- gtk_signal_handler_destroy (list);
- list = handler;
- }
+ va_list var_args;
+
+ g_return_if_fail (GTK_IS_OBJECT (object));
- gtk_object_remove_data (object, handler_key);
- }
+ va_start (var_args, signal_id);
+ g_signal_emit_valist (G_OBJECT (object), signal_id, 0, var_args);
+ va_end (var_args);
}
void
-gtk_signal_default_marshaller (GtkObject *object,
- GtkSignalFunc func,
- gpointer func_data,
- GtkArg *params)
+gtk_signal_emit_by_name (GtkObject *object,
+ const gchar *name,
+ ...)
{
- GtkSignalMarshaller0 rfunc;
-
- rfunc = (GtkSignalMarshaller0) func;
-
- (* rfunc) (object, func_data);
+ GtkArg args[SIGNAL_MAX_PARAMS + 1];
+ GSignalQuery query;
+ gboolean abort;
+ va_list var_args;
+
+ g_return_if_fail (GTK_IS_OBJECT (object));
+ g_return_if_fail (name != NULL);
+
+ g_signal_query (g_signal_lookup (name, GTK_OBJECT_TYPE (object)), &query);
+ g_return_if_fail (query.signal_id != 0);
+ g_return_if_fail (query.n_params < SIGNAL_MAX_PARAMS);
+
+ va_start (var_args, name);
+ abort = gtk_signal_collect_args (args,
+ query.n_params,
+ query.param_types,
+ query.return_type,
+ var_args);
+ va_end (var_args);
+
+ if (!abort)
+ gtk_signal_emitv (object, query.signal_id, args);
}
void
-gtk_signal_set_funcs (GtkSignalMarshal marshal_func,
- GtkSignalDestroy destroy_func)
-{
- marshal = marshal_func;
- destroy = destroy_func;
-}
-
-
-static void
-gtk_signal_init ()
-{
- if (initialize)
- {
- initialize = FALSE;
- signal_hash_table = g_hash_table_new ((GHashFunc) gtk_signal_hash,
- (GCompareFunc) gtk_signal_compare);
- signal_info_hash_table = g_hash_table_new ((GHashFunc) gtk_signal_info_hash,
- (GCompareFunc) gtk_signal_info_compare);
- }
-}
-
-static guint
-gtk_signal_hash (gint *key)
-{
- return (guint) *key;
-}
-
-static gint
-gtk_signal_compare (gint *a,
- gint *b)
-{
- return (*a == *b);
-}
-
-static guint
-gtk_signal_info_hash (GtkSignalInfo *a)
-{
- return (g_string_hash (a->name) + a->object_type);
-}
-
-static gint
-gtk_signal_info_compare (GtkSignalInfo *a,
- GtkSignalInfo *b)
-{
- return ((a->object_type == b->object_type) &&
- g_string_equal (a->name, b->name));
-}
-
-static GtkHandler*
-gtk_signal_handler_new ()
-{
- GtkHandler *handler;
-
- if (!handler_mem_chunk)
- handler_mem_chunk = g_mem_chunk_new ("handler mem chunk", sizeof (GtkHandler),
- 1024, G_ALLOC_AND_FREE);
-
- handler = g_chunk_new (GtkHandler, handler_mem_chunk);
-
- handler->id = 0;
- handler->signal_type = 0;
- handler->object_signal = FALSE;
- handler->blocked = FALSE;
- handler->after = FALSE;
- handler->no_marshal = FALSE;
- handler->func = NULL;
- handler->func_data = NULL;
- handler->destroy_func = NULL;
- handler->next = NULL;
-
- return handler;
-}
-
-static void
-gtk_signal_handler_destroy (GtkHandler *handler)
-{
- if (!handler->func && destroy)
- (* destroy) (handler->func_data);
- else if (handler->destroy_func)
- (* handler->destroy_func) (handler->func_data);
- g_mem_chunk_free (handler_mem_chunk, handler);
-}
-
-static void
-gtk_signal_handler_insert (GtkObject *object,
- GtkHandler *handler)
-{
- GtkHandler *start;
- GtkHandler *tmp;
- GtkHandler *prev;
-
- start = gtk_object_get_data (object, handler_key);
- if (!start)
- {
- gtk_object_set_data (object, handler_key, handler);
- }
- else
- {
- prev = NULL;
- tmp = start;
-
- while (tmp)
- {
- if (tmp->signal_type < handler->signal_type)
- {
- if (prev)
- prev->next = handler;
- else
- gtk_object_set_data (object, handler_key, handler);
- handler->next = tmp;
- break;
- }
-
- if (!tmp->next)
- {
- tmp->next = handler;
- break;
- }
-
- prev = tmp;
- tmp = tmp->next;
- }
- }
-}
-
-static gint
-gtk_signal_real_emit (GtkObject *object,
- gint signal_type,
- va_list args)
+gtk_signal_emitv_by_name (GtkObject *object,
+ const gchar *name,
+ GtkArg *args)
{
- gint old_value;
- GtkSignal *signal;
- GtkHandler *handlers;
- GtkHandlerInfo info;
- guchar **signal_func_offset;
- gint being_destroyed;
- GtkArg params[MAX_PARAMS];
-
- g_return_val_if_fail (object != NULL, FALSE);
- g_return_val_if_fail (signal_type >= 1, TRUE);
-
- being_destroyed = GTK_OBJECT_BEING_DESTROYED (object);
- if (!GTK_OBJECT_NEED_DESTROY (object))
- {
- signal = g_hash_table_lookup (signal_hash_table, &signal_type);
- g_return_val_if_fail (signal != NULL, TRUE);
- g_return_val_if_fail (gtk_type_is_a (GTK_OBJECT_TYPE (object), signal->info.object_type), TRUE);
-
- if ((signal->run_type & GTK_RUN_NO_RECURSE) &&
- gtk_emission_check (current_emissions, object, signal_type))
- {
- gtk_emission_add (&restart_emissions, object, signal_type);
- return TRUE;
- }
-
- old_value = GTK_OBJECT_IN_CALL (object);
- GTK_OBJECT_SET_FLAGS (object, GTK_IN_CALL);
-
- gtk_params_get (params, signal->nparams, signal->params, signal->return_val, args);
-
- gtk_emission_add (¤t_emissions, object, signal_type);
-
- restart:
- if (GTK_RUN_TYPE (signal->run_type) != GTK_RUN_LAST)
- {
- signal_func_offset = (guchar**) ((guchar*) object->klass + signal->function_offset);
- if (*signal_func_offset)
- (* signal->marshaller) (object, (GtkSignalFunc) *signal_func_offset, NULL, params);
- if (GTK_OBJECT_NEED_DESTROY (object))
- goto done;
- }
-
- info.object = object;
- info.marshaller = signal->marshaller;
- info.params = params;
- info.param_types = signal->params;
- info.return_val = signal->return_val;
- info.nparams = signal->nparams;
- info.run_type = signal->run_type;
- info.signal_type = signal_type;
-
- handlers = gtk_signal_get_handlers (object, signal_type);
- switch (gtk_handlers_run (handlers, &info, FALSE))
- {
- case DONE:
- goto done;
- case RESTART:
- goto restart;
- }
-
- if (GTK_RUN_TYPE (signal->run_type) != GTK_RUN_FIRST)
- {
- signal_func_offset = (guchar**) ((guchar*) object->klass + signal->function_offset);
- if (*signal_func_offset)
- (* signal->marshaller) (object, (GtkSignalFunc) *signal_func_offset, NULL, params);
- if (being_destroyed || GTK_OBJECT_NEED_DESTROY (object))
- goto done;
- }
-
- switch (gtk_handlers_run (handlers, &info, TRUE))
- {
- case DONE:
- goto done;
- case RESTART:
- goto restart;
- }
-
- done:
- gtk_emission_remove (¤t_emissions, object, signal_type);
-
- if (signal->run_type & GTK_RUN_NO_RECURSE)
- gtk_emission_remove (&restart_emissions, object, signal_type);
-
- if (!being_destroyed && !old_value)
- GTK_OBJECT_UNSET_FLAGS (object, GTK_IN_CALL);
- }
-
- if (!being_destroyed && GTK_OBJECT_NEED_DESTROY (object) && !GTK_OBJECT_IN_CALL (object))
- {
- gtk_object_destroy (object);
- return FALSE;
- }
-
- return TRUE;
-}
-
-static GtkHandler*
-gtk_signal_get_handlers (GtkObject *object,
- gint signal_type)
-{
- GtkHandler *handlers;
-
- g_return_val_if_fail (object != NULL, NULL);
- g_return_val_if_fail (signal_type >= 1, NULL);
-
- handlers = gtk_object_get_data (object, handler_key);
-
- while (handlers)
- {
- if (handlers->signal_type == signal_type)
- return handlers;
- handlers = handlers->next;
- }
-
- return NULL;
-}
-
-static gint
-gtk_signal_connect_by_type (GtkObject *object,
- gint signal_type,
- gint object_signal,
- GtkSignalFunc func,
- gpointer func_data,
- GtkSignalDestroy destroy_func,
- gint after,
- gint no_marshal)
-{
- GtkHandler *handler;
- gint *object_signals;
- gint nsignals;
- gint found_it;
- gint i;
-
- g_return_val_if_fail (object != NULL, 0);
- g_return_val_if_fail (object->klass != NULL, 0);
- g_return_val_if_fail (object->klass->signals != NULL, 0);
-
- /* Search through the signals for this object and make
- * sure the one we are adding is valid. If it isn't then
- * issue a warning and return.
- */
- object_signals = object->klass->signals;
- nsignals = object->klass->nsignals;
- found_it = FALSE;
-
- for (i = 0; i < nsignals; i++)
- if (object_signals[i] == signal_type)
- {
- found_it = TRUE;
- break;
- }
-
- if (!found_it)
- {
- g_warning ("could not find signal (%d) in object's list of signals", signal_type);
- return 0;
- }
-
- handler = gtk_signal_handler_new ();
- handler->id = next_handler_id++;
- handler->signal_type = signal_type;
- handler->object_signal = object_signal;
- handler->func = func;
- handler->func_data = func_data;
- handler->destroy_func = destroy_func;
-
- if (after)
- handler->after = TRUE;
- handler->no_marshal = no_marshal;
-
- gtk_signal_handler_insert (object, handler);
- return handler->id;
-}
-
-static GtkEmission*
-gtk_emission_new ()
-{
- GtkEmission *emission;
-
- if (!emission_mem_chunk)
- emission_mem_chunk = g_mem_chunk_new ("emission mem chunk", sizeof (GtkEmission),
- 1024, G_ALLOC_AND_FREE);
-
- emission = g_chunk_new (GtkEmission, emission_mem_chunk);
-
- emission->object = NULL;
- emission->signal_type = 0;
-
- return emission;
-}
-
-static void
-gtk_emission_destroy (GtkEmission *emission)
-{
- g_mem_chunk_free (emission_mem_chunk, emission);
-}
-
-static void
-gtk_emission_add (GList **emissions,
- GtkObject *object,
- gint signal_type)
-{
- GtkEmission *emission;
-
- g_return_if_fail (emissions != NULL);
- g_return_if_fail (object != NULL);
-
- emission = gtk_emission_new ();
- emission->object = object;
- emission->signal_type = signal_type;
-
- *emissions = g_list_prepend (*emissions, emission);
-}
-
-static void
-gtk_emission_remove (GList **emissions,
- GtkObject *object,
- gint signal_type)
-{
- GtkEmission *emission;
- GList *tmp;
-
- g_return_if_fail (emissions != NULL);
- g_return_if_fail (object != NULL);
-
- tmp = *emissions;
- while (tmp)
- {
- emission = tmp->data;
-
- if ((emission->object == object) &&
- (emission->signal_type == signal_type))
- {
- gtk_emission_destroy (emission);
- *emissions = g_list_remove_link (*emissions, tmp);
- g_list_free (tmp);
- break;
- }
-
- tmp = tmp->next;
- }
-}
-
-static gint
-gtk_emission_check (GList *emissions,
- GtkObject *object,
- gint signal_type)
-{
- GtkEmission *emission;
- GList *tmp;
-
- g_return_val_if_fail (object != NULL, FALSE);
-
- tmp = emissions;
- while (tmp)
- {
- emission = tmp->data;
- tmp = tmp->next;
-
- if ((emission->object == object) &&
- (emission->signal_type == signal_type))
- return TRUE;
- }
- return FALSE;
-}
-
-static gint
-gtk_handlers_run (GtkHandler *handlers,
- GtkHandlerInfo *info,
- gint after)
-{
- while (handlers && (handlers->signal_type == info->signal_type))
- {
- if (!handlers->blocked && (handlers->after == after))
- {
- if (handlers->func)
- {
- if (handlers->no_marshal)
- (* (GtkCallbackMarshal)handlers->func) (info->object,
- handlers->func_data,
- info->nparams,
- info->params);
- else if (handlers->object_signal)
- (* info->marshaller) (GTK_OBJECT (handlers->func_data),
- handlers->func,
- handlers->func_data,
- info->params);
- else
- (* info->marshaller) (info->object,
- handlers->func,
- handlers->func_data,
- info->params);
- }
- else if (marshal)
- (* marshal) (info->object,
- handlers->func_data,
- info->nparams,
- info->params,
- info->param_types,
- info->return_val);
-
- if (GTK_OBJECT_NEED_DESTROY (info->object))
- return DONE;
- else if (gtk_emission_check (stop_emissions, info->object, info->signal_type))
- {
- gtk_emission_remove (&stop_emissions, info->object, info->signal_type);
-
- if (info->run_type & GTK_RUN_NO_RECURSE)
- gtk_emission_remove (&restart_emissions, info->object, info->signal_type);
- return DONE;
- }
- else if ((info->run_type & GTK_RUN_NO_RECURSE) &&
- gtk_emission_check (restart_emissions, info->object, info->signal_type))
- {
- gtk_emission_remove (&restart_emissions, info->object, info->signal_type);
- return RESTART;
- }
- }
-
- handlers = handlers->next;
- }
-
- return 0;
-}
-
-static void
-gtk_params_get (GtkArg *params,
- gint nparams,
- GtkType *param_types,
- GtkType return_val,
- va_list args)
-{
- int i;
-
- for (i = 0; i < nparams; i++)
- {
- if (param_types[i] != GTK_TYPE_NONE)
- {
- params[i].type = param_types[i];
- params[i].name = NULL;
- }
-
- switch (GTK_FUNDAMENTAL_TYPE (param_types[i]))
- {
- case GTK_TYPE_INVALID:
- break;
- case GTK_TYPE_NONE:
- break;
- case GTK_TYPE_CHAR:
- GTK_VALUE_CHAR(params[i]) = va_arg (args, gint);
- break;
- case GTK_TYPE_BOOL:
- GTK_VALUE_BOOL(params[i]) = va_arg (args, gint);
- break;
- case GTK_TYPE_INT:
- GTK_VALUE_INT(params[i]) = va_arg (args, gint);
- break;
- case GTK_TYPE_UINT:
- GTK_VALUE_UINT(params[i]) = va_arg (args, guint);
- break;
- case GTK_TYPE_ENUM:
- GTK_VALUE_ENUM(params[i]) = va_arg (args, gint);
- break;
- case GTK_TYPE_FLAGS:
- GTK_VALUE_FLAGS(params[i]) = va_arg (args, gint);
- break;
- case GTK_TYPE_LONG:
- GTK_VALUE_LONG(params[i]) = va_arg (args, glong);
- break;
- case GTK_TYPE_ULONG:
- GTK_VALUE_ULONG(params[i]) = va_arg (args, gulong);
- break;
- case GTK_TYPE_FLOAT:
- GTK_VALUE_FLOAT(params[i]) = va_arg (args, gfloat);
- break;
- case GTK_TYPE_STRING:
- GTK_VALUE_STRING(params[i]) = va_arg (args, gchar*);
- break;
- case GTK_TYPE_POINTER:
- GTK_VALUE_POINTER(params[i]) = va_arg (args, gpointer);
- break;
- case GTK_TYPE_BOXED:
- GTK_VALUE_BOXED(params[i]) = va_arg (args, gpointer);
- break;
- case GTK_TYPE_SIGNAL:
- GTK_VALUE_SIGNAL(params[i]).f = va_arg (args, GtkFunction);
- GTK_VALUE_SIGNAL(params[i]).d = va_arg (args, gpointer);
- break;
- case GTK_TYPE_FOREIGN:
- GTK_VALUE_FOREIGN(params[i]).data = va_arg (args, gpointer);
- GTK_VALUE_FOREIGN(params[i]).notify =
- va_arg (args, GtkDestroyNotify);
- break;
- case GTK_TYPE_CALLBACK:
- GTK_VALUE_CALLBACK(params[i]).marshal =
- va_arg (args, GtkCallbackMarshal);
- GTK_VALUE_CALLBACK(params[i]).data = va_arg (args, gpointer);
- GTK_VALUE_CALLBACK(params[i]).notify =
- va_arg (args, GtkDestroyNotify);
- break;
- case GTK_TYPE_C_CALLBACK:
- GTK_VALUE_C_CALLBACK(params[i]).func = va_arg (args, GtkFunction);
- GTK_VALUE_C_CALLBACK(params[i]).func_data = va_arg (args, gpointer);
- break;
- case GTK_TYPE_ARGS:
- GTK_VALUE_ARGS(params[i]).n_args = va_arg (args, int);
- GTK_VALUE_ARGS(params[i]).args = va_arg (args, GtkArg*);
- break;
- case GTK_TYPE_OBJECT:
- GTK_VALUE_OBJECT(params[i]) = va_arg (args, GtkObject*);
- g_assert (GTK_VALUE_OBJECT(params[i]) == NULL ||
- GTK_CHECK_TYPE (GTK_VALUE_OBJECT(params[i]),
- params[i].type));
- break;
- default:
- g_error ("unsupported type %s in signal arg",
- gtk_type_name (params[i].type));
- break;
- }
- }
-
- if (return_val != GTK_TYPE_NONE)
- {
- params[i].type = return_val;
- params[i].name = NULL;
- }
-
- switch (GTK_FUNDAMENTAL_TYPE (return_val))
- {
- case GTK_TYPE_INVALID:
- break;
- case GTK_TYPE_NONE:
- break;
- case GTK_TYPE_CHAR:
- params[i].d.pointer_data = va_arg (args, gchar*);
- break;
- case GTK_TYPE_BOOL:
- params[i].d.pointer_data = va_arg (args, gint*);
- break;
- case GTK_TYPE_INT:
- params[i].d.pointer_data = va_arg (args, gint*);
- break;
- case GTK_TYPE_UINT:
- params[i].d.pointer_data = va_arg (args, guint*);
- break;
- case GTK_TYPE_ENUM:
- params[i].d.pointer_data = va_arg (args, gint*);
- break;
- case GTK_TYPE_FLAGS:
- params[i].d.pointer_data = va_arg (args, gint*);
- break;
- case GTK_TYPE_LONG:
- params[i].d.pointer_data = va_arg (args, glong*);
- break;
- case GTK_TYPE_ULONG:
- params[i].d.pointer_data = va_arg (args, gulong*);
- break;
- case GTK_TYPE_FLOAT:
- params[i].d.pointer_data = va_arg (args, gfloat*);
- break;
- case GTK_TYPE_STRING:
- params[i].d.pointer_data = va_arg (args, gchar**);
- break;
- case GTK_TYPE_POINTER:
- params[i].d.pointer_data = va_arg (args, gpointer*);
- break;
- case GTK_TYPE_BOXED:
- params[i].d.pointer_data = va_arg (args, gpointer*);
- break;
- case GTK_TYPE_OBJECT:
- params[i].d.pointer_data = va_arg (args, GtkObject**);
- break;
- case GTK_TYPE_SIGNAL:
- case GTK_TYPE_FOREIGN:
- case GTK_TYPE_CALLBACK:
- case GTK_TYPE_C_CALLBACK:
- case GTK_TYPE_ARGS:
- default:
- g_error ("unsupported type %s in signal return",
- gtk_type_name (return_val));
- break;
- }
+ g_return_if_fail (GTK_IS_OBJECT (object));
+
+ gtk_signal_emitv (object, g_signal_lookup (name, GTK_OBJECT_TYPE (object)), args);
}
projects / ~andy / gtk / blobdiff