forked from AuroraMiddleware/gtk
1317 lines
30 KiB
C
1317 lines
30 KiB
C
/* 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 (¤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++)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|