AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
2e943b280e
gtk2/gtk/gtksignal.c
Elliot Lee 9508b76bd2 Initial revision
1997-11-24 22:37:52 +00:00

1323 lines
30 KiB
C
Raw Blame History

/* GTK - The GIMP Toolkit
* 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
* 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.
*
* 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.
*/
#include <stdarg.h>
#include "gtksignal.h"
#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
gtk_signal_new (const gchar *name,
GtkSignalRunType run_type,
gint object_type,
gint function_offset,
GtkSignalMarshaller marshaller,
GtkType return_val,
gint nparams,
...)
{
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)
{
signal->params = g_new (GtkType, nparams);
params = signal->params;
va_start (args, nparams);
for (i = 0; i < nparams; 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;
}
gint
gtk_signal_emit_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;
}
void
gtk_signal_emit_stop (GtkObject *object,
gint signal_type)
{
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);
}
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);
}
gint
gtk_signal_connect (GtkObject *object,
const gchar *name,
GtkSignalFunc func,
gpointer func_data)
{
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)
{
g_warning ("could not find signal type \"%s\" in the \"%s\" class ancestry",
name, gtk_type_name (GTK_OBJECT_TYPE (object)));
return 0;
}
return gtk_signal_connect_by_type (object, type, FALSE,
func, func_data, NULL,
FALSE, FALSE);
}
gint
gtk_signal_connect_after (GtkObject *object,
const gchar *name,
GtkSignalFunc func,
gpointer func_data)
{
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)
{
g_warning ("could not find signal type \"%s\" in the \"%s\" class ancestry",
name, gtk_type_name (GTK_OBJECT_TYPE (object)));
return 0;
}
return gtk_signal_connect_by_type (object, type, FALSE,
func, func_data, NULL,
TRUE, FALSE);
}
gint
gtk_signal_connect_interp (GtkObject *object,
gchar *name,
GtkCallbackMarshal func,
gpointer func_data,
GtkDestroyNotify destroy_func,
gint after)
{
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)
{
g_warning ("could not find signal type \"%s\" in the \"%s\" class ancestry",
name, gtk_type_name (GTK_OBJECT_TYPE (object)));
return 0;
}
return gtk_signal_connect_by_type (object, type, FALSE,
(GtkSignalFunc) func, func_data,
destroy_func, after, TRUE);
}
gint
gtk_signal_connect_object (GtkObject *object,
const gchar *name,
GtkSignalFunc func,
GtkObject *slot_object)
{
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)
{
g_warning ("could not find signal type \"%s\" in the \"%s\" class ancestry",
name, gtk_type_name (GTK_OBJECT_TYPE (object)));
return 0;
}
return gtk_signal_connect_by_type (object, type, TRUE,
func, slot_object, NULL,
FALSE, FALSE);
}
gint
gtk_signal_connect_object_after (GtkObject *object,
const gchar *name,
GtkSignalFunc func,
GtkObject *slot_object)
{
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)
{
g_warning ("could not find signal type \"%s\" in the \"%s\" class ancestry",
name, gtk_type_name (GTK_OBJECT_TYPE (object)));
return 0;
}
return gtk_signal_connect_by_type (object, type, TRUE,
func, slot_object, NULL,
TRUE, FALSE);
}
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)
{
if (tmp->id == anid)
{
if (prev)
prev->next = tmp->next;
else
gtk_object_set_data (object, handler_key, tmp->next);
gtk_signal_handler_destroy (tmp);
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 (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_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)
{
if (tmp->id == anid)
{
tmp->blocked = TRUE;
return;
}
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)
{
if (tmp->func_data == data)
{
tmp->blocked = TRUE;
found_one = TRUE;
}
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)
{
tmp->blocked = FALSE;
return;
}
tmp = tmp->next;
}
g_warning ("could not find handler (%d)", anid);
}
void
gtk_signal_handler_unblock_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)
{
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);
}
void
gtk_signal_handlers_destroy (GtkObject *object)
{
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;
}
gtk_object_remove_data (object, handler_key);
}
}
void
gtk_signal_default_marshaller (GtkObject *object,
GtkSignalFunc func,
gpointer func_data,
GtkArg *params)
{
GtkSignalMarshaller0 rfunc;
rfunc = (GtkSignalMarshaller0) func;
(* rfunc) (object, func_data);
}
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)
{
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 (&current_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 (&current_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;
}
}
Reference in New Issue View Git Blame Copy Permalink