void
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++)
{
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))
{
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;
}
}
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)
{
gtk_argloc_set_from_value (args + query.n_params, &rvalue, TRUE);
g_value_unset (&rvalue);
}
for (i = 0; i < query.n_params; i++)
g_value_unset (params + 1 + i);
g_value_unset (params + 0);
}
void ok_cb (GtkWidget *w, void *v)
{
gboolean edit=TRUE;
GtkWidget *widget;
GtkType type;
GSList *current = widgets;
while (current) {
edit=TRUE;
widget = (GtkWidget *)current->data;
current = current->next;
type = GTK_OBJECT_TYPE(widget);
if (type == gtk_entry_get_type())
output_entry(widget);
if (type == gtk_text_get_type())
output_text(widget,&edit);
if (type == gtk_combo_get_type())
output_combo(widget);
if (type == gtk_check_button_get_type())
output_check_button(widget);
if (type == gtk_option_menu_get_type())
output_option_menu(widget);
/* if there are more widgets with output values, separate them */
if (current && edit) {
putchar ('\v');
}
}
quit(RETURN_OK);
}
AtkObject *
gal_a11y_e_cell_registry_get_object (GalA11yECellRegistry *registry,
ETableItem *item,
ECellView *cell_view,
AtkObject *parent,
int model_col,
int view_col,
int row)
{
GalA11yECellRegistryFunc func = NULL;
GType type;
if (registry == NULL) {
init_default_registry ();
registry = default_registry;
}
type = GTK_OBJECT_TYPE (cell_view->ecell);
while (func == NULL && type != 0) {
func = g_hash_table_lookup (registry->priv->table, GINT_TO_POINTER (type));
type = g_type_parent (type);
}
if (func)
return func (item, cell_view, parent, model_col, view_col, row);
else
return gal_a11y_e_cell_new (item, cell_view, parent, model_col, view_col, row);
}
void
gtk_signal_emitv_by_name (GtkObject *object,
const gchar *name,
GtkArg *args)
{
g_return_if_fail (GTK_IS_OBJECT (object));
gtk_signal_emitv (object, g_signal_lookup (name, GTK_OBJECT_TYPE (object)), args);
}
void
gtk_signal_emit_by_name (GtkObject *object,
const gchar *name,
...)
{
GSignalQuery query;
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);
va_start (var_args, name);
g_signal_emit_valist (G_OBJECT (object), query.signal_id, 0, var_args);
va_end (var_args);
}
static void
sp_knot_holder_debug (GtkObject *object, gpointer data)
{
g_print ("sp-knot-holder-debug: [type=%s] [data=%s]\n", gtk_type_name (GTK_OBJECT_TYPE(object)), (const gchar *)data);
}
/* String the names the type of the widget */
gchar *c_gtk_type_name (GtkWidget *op) {
return (gtk_type_name (GTK_OBJECT_TYPE (op)));
}
static void
gv_tool_real_activate(GvTool *tool, GvViewArea *view)
{
GvToolClass *klass;
if (tool->view)
{
g_warning("gv_tool_activate(): tool %s is already active on a view",
gtk_type_name(GTK_OBJECT_TYPE(tool)));
return;
}
tool->view = view;
gtk_object_ref(GTK_OBJECT(view));
klass = (GvToolClass*)gtk_type_class(GTK_OBJECT_TYPE(tool));
/* This could be done through an indirect function call which
emits a tool signal. Probably better but more overhead... */
if (klass->draw)
{
gtk_signal_connect_object(GTK_OBJECT(view), "gldraw",
GTK_SIGNAL_FUNC(klass->draw),
GTK_OBJECT(tool));
}
if (klass->button_press)
{
gtk_signal_connect_object(GTK_OBJECT(view), "button-press-event",
GTK_SIGNAL_FUNC(klass->button_press),
GTK_OBJECT(tool));
}
if (klass->button_release)
{
gtk_signal_connect_object(GTK_OBJECT(view), "button-release-event",
GTK_SIGNAL_FUNC(klass->button_release),
GTK_OBJECT(tool));
}
if (klass->motion_notify)
{
gtk_signal_connect_object(GTK_OBJECT(view), "motion-notify-event",
GTK_SIGNAL_FUNC(klass->motion_notify),
GTK_OBJECT(tool));
}
if (klass->key_press)
{
gtk_signal_connect_object(GTK_OBJECT(view), "key-press-event",
GTK_SIGNAL_FUNC(klass->key_press),
GTK_OBJECT(tool));
}
if (klass->enter_notify)
{
gtk_signal_connect_object(GTK_OBJECT(view), "enter-notify-event",
GTK_SIGNAL_FUNC(klass->enter_notify),
GTK_OBJECT(tool));
}
if (klass->leave_notify)
{
gtk_signal_connect_object(GTK_OBJECT(view), "leave-notify-event",
GTK_SIGNAL_FUNC(klass->leave_notify),
GTK_OBJECT(tool));
}
/* Install cursor for this tool */
if (GTK_WIDGET_REALIZED(GTK_WIDGET(view)))
{
gdk_window_set_cursor(GTK_WIDGET(view)->window, tool->cursor);
}
}
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
}
static void
gimp_unit_menu_class_init (GimpUnitMenuClass *class)
{
GtkObjectClass *object_class;
object_class = (GtkObjectClass*) class;
parent_class = gtk_type_class (gtk_option_menu_get_type ());
gimp_unit_menu_signals[UNIT_CHANGED] =
gtk_signal_new ("unit_changed",
GTK_RUN_FIRST,
GTK_OBJECT_TYPE( object_class ),
GTK_SIGNAL_OFFSET (GimpUnitMenuClass,
unit_changed),
gtk_signal_default_marshaller, GTK_TYPE_NONE, 0);
#if GTK_MAJOR_VERSION < 2
gtk_object_class_add_signals (object_class, gimp_unit_menu_signals,
LAST_SIGNAL);
#endif
class->unit_changed = NULL;
object_class->destroy = gimp_unit_menu_destroy;
}
static void
static int
_object_signal_connect(ClipMachine *cm, gboolean after)
{
C_object *cobj = _fetch_co_arg(cm);
SignalTable *sig_table = NULL;
int ret=-1;
CHECKCOBJ(cobj,GTK_IS_OBJECT(cobj->object));
CHECKARG2(2,CHARACTER_t,NUMERIC_t);
CHECKARG2(3,PCODE_t,CCODE_t);
if (_clip_parinfo(cm,2) == CHARACTER_t)
{
sig_table = _sig_table_by_name(cobj->type, _clip_parc(cm,2));
}
else
sig_table = _sig_table_by_id(cobj->type, _clip_parni(cm,2));
if (sig_table && sig_table->sigfunction)
{
GtkSignalFunc sfunc = sig_table->sigfunction;
gchar *signame = sig_table->signame;
long sid = sig_table->sigid;
int sigfound = g_signal_lookup(signame, GTK_OBJECT_TYPE(cobj->object));
int extra_sigfound = _extra_signal_lookup(signame, GTK_OBJECT_TYPE(cobj->object));
C_signal *cs = 0;
//printf ("object %s signame %s \n", cobj->type_name, signame);
if (sigfound || extra_sigfound || sid < 1000) /* sid<1000 - event */
{
if (!cobj->siglist)
{
cobj->siglist = NEW(C_signal);
cs = cobj->siglist;
}
else
{
for (cs = cobj->siglist; cs && cs->next; cs = cs->next);
cs->next = NEW(C_signal);
cs = cs->next;
}
cs->co = cobj;
cs->signame = sig_table->signame;
cs->sigid = sig_table->sigid;
_clip_mclone(cm, &cs->cfunc, _clip_spar(cm,3));
}
if (sigfound)
{
if (after)
{
ret = g_signal_connect_after(GTK_OBJECT(cobj->object),
signame,GSF(sfunc),cs);
}
else
{
ret = g_signal_connect(GTK_OBJECT(cobj->object),
signame,GSF(sfunc),cs);
}
}
}
_clip_retni(cm,ret);
return 0;
err:
_clip_retni(cm,ret);
return 1;
}
