void
netstatus_connect_signal_while_alive (gpointer object,
const char *detailed_signal,
GCallback func,
gpointer func_data,
gpointer alive_object)
{
GClosure *closure;
GType type;
guint signal_id = 0;
GQuark detail = 0;
type = G_OBJECT_TYPE (object);
if (!g_signal_parse_name (detailed_signal, type, &signal_id, &detail, FALSE))
{
g_warning (G_STRLOC ": unable to parse signal \"%s\" for type \"%s\"",
detailed_signal, g_type_name (type));
return;
}
closure = g_cclosure_new (func, func_data, NULL);
g_object_watch_closure (G_OBJECT (alive_object), closure);
g_signal_connect_closure_by_id (object, signal_id, detail, closure, FALSE);
}
static guint
nux_area_accessible_add_focus_handler(AtkComponent* component,
AtkFocusHandler handler)
{
GSignalMatchType match_type;
gulong ret;
guint signal_id;
g_return_val_if_fail(NUX_IS_AREA_ACCESSIBLE(component), 0);
match_type = (GSignalMatchType)(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC);
signal_id = g_signal_lookup("focus-event", ATK_TYPE_OBJECT);
ret = g_signal_handler_find(component, match_type, signal_id, 0, NULL,
(gpointer) handler, NULL);
if (!ret)
{
return g_signal_connect_closure_by_id(component,
signal_id, 0,
g_cclosure_new(G_CALLBACK(handler), NULL,
(GClosureNotify) NULL),
FALSE);
}
else
return 0;
}
static gboolean
gtk_tool_button_create_menu_proxy (GtkToolItem *item)
{
GtkToolButton *button = GTK_TOOL_BUTTON (item);
GtkWidget *menu_item;
GtkWidget *menu_image = NULL;
GtkStockItem stock_item;
gboolean use_mnemonic = TRUE;
const char *label;
if (_gtk_tool_item_create_menu_proxy (item))
return TRUE;
if (GTK_IS_LABEL (button->priv->label_widget))
{
label = gtk_label_get_label (GTK_LABEL (button->priv->label_widget));
use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (button->priv->label_widget));
}
else if (button->priv->label_text)
{
label = button->priv->label_text;
use_mnemonic = button->priv->use_underline;
}
else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
{
label = stock_item.label;
}
else
{
label = "";
}
if (use_mnemonic)
menu_item = gtk_image_menu_item_new_with_mnemonic (label);
else
menu_item = gtk_image_menu_item_new_with_label (label);
if (GTK_IS_IMAGE (button->priv->icon_widget))
{
menu_image = clone_image_menu_size (GTK_IMAGE (button->priv->icon_widget),
gtk_widget_get_settings (GTK_WIDGET (button)));
}
else if (button->priv->stock_id)
{
menu_image = gtk_image_new_from_stock (button->priv->stock_id, GTK_ICON_SIZE_MENU);
}
if (menu_image)
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), menu_image);
g_signal_connect_closure_by_id (menu_item,
g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
g_cclosure_new_object_swap (G_CALLBACK (gtk_button_clicked),
G_OBJECT (GTK_TOOL_BUTTON (button)->priv->button)),
FALSE);
gtk_tool_item_set_proxy_menu_item (GTK_TOOL_ITEM (button), MENU_ID, menu_item);
return TRUE;
}
/**
* Implements
* org.gnome.glib.GObject.g_signal_connect(long instance, Object handler, String name, boolean after)
* called from
* org.gnome.glib.Plumbing.connectSignal(Object instance, Signal handler, String name, boolean after)
* called from
* <generated package scope classes>.connect(Object instance, Signal handler, boolean after)
*
* This is where the magic to create a GClosure and hook it up to the GSignal
* handling mechanisms is taken care of. A reference is created to the passed
* Java object which is used as the callback when the signal is fired.
*/
JNIEXPORT void JNICALL
Java_oscats_glib_GObject_g_1signal_1connect
(
JNIEnv *env,
jclass cls,
jlong _instance,
jobject _handler,
jobject _receiver,
jstring _name,
jboolean _after
)
{
GObject* instance;
const gchar* name;
gboolean after;
guint id;
GQuark detail = 0;
GClosure* closure;
gboolean ok;
// translate instance
instance = (GObject*) _instance;
// translate the signal name
name = bindings_java_getString(env, _name);
// translate after
after = (gboolean) _after;
/*
* Lookup the signal information. We use this rather than g_signal_lookup() because
* it allows us to sidestep the issue of detailed signal names.
*/
ok = g_signal_parse_name(name, G_OBJECT_TYPE(instance), &id, &detail, TRUE);
if (!ok) {
bindings_java_throw(env, "Unknown signal name %s for object %s", name, G_OBJECT_TYPE_NAME(instance));
return;
}
closure = bindings_java_closure_new(env, _handler, (jclass) _receiver, name, id);
if (closure == NULL) {
// and an exception has already been thrown
return;
}
// returns the handler id, but we don't need it.
g_signal_connect_closure_by_id(instance, id, detail, closure, after);
// cleanup. Not really necessary as will happen automatically in a moment.
bindings_java_releaseString(name);
}
void
gtk_signal_connect_object_while_alive (GtkObject *object,
const gchar *name,
GtkSignalFunc func,
GtkObject *alive_object)
{
g_return_if_fail (GTK_IS_OBJECT (object));
g_signal_connect_closure_by_id (object,
g_signal_lookup (name, G_OBJECT_TYPE (object)), 0,
g_cclosure_new_object_swap (func, G_OBJECT (alive_object)),
FALSE);
}
static void
matewncklet_connect_while_alive (gpointer object,
const char *signal,
GCallback func,
gpointer func_data, gpointer alive_object)
{
GClosure *closure;
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);
}
void
gtk_signal_connect_while_alive (GtkObject *object,
const gchar *name,
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 (name, G_OBJECT_TYPE (object)), 0,
closure,
FALSE);
}
void ucview_info_box_add_action_widget( UCViewInfoBox *box, GtkWidget *widget, gint response_id )
{
ResponseData *rd;
guint signal_id;
g_return_if_fail( IS_UCVIEW_INFO_BOX( box ) );
g_return_if_fail( GTK_IS_WIDGET( widget ) );
rd = get_response_data( widget, TRUE );
rd->response_id = response_id;
if( GTK_IS_BUTTON( widget ) )
{
signal_id = g_signal_lookup( "clicked", GTK_TYPE_BUTTON );
}
else
{
signal_id = GTK_WIDGET_GET_CLASS( widget )->activate_signal;
}
if( signal_id )
{
GClosure *closure;
closure = g_cclosure_new_object( G_CALLBACK( action_widget_activated ), G_OBJECT( box ) );
g_signal_connect_closure_by_id( widget, signal_id, 0, closure, FALSE );
}
else
{
g_warning( "UCViewInfoBox: add_action_widget: Item not activatable" );
}
if( response_id != GTK_RESPONSE_HELP )
{
gtk_box_pack_start( GTK_BOX( box->priv->action_box ), widget, FALSE, FALSE, 12 );
}
else
{
gtk_box_pack_end( GTK_BOX( box->priv->action_box ), widget, FALSE, FALSE, 12 );
}
}
/**************************************************************************
Places a button into a dialog, taking care of setting up signals, etc.
**************************************************************************/
static void gui_dialog_pack_button(struct gui_dialog *dlg, GtkWidget *button,
int response)
{
gint signal_id;
fc_assert_ret(GTK_IS_BUTTON(button));
g_object_set_data(G_OBJECT(button), "gui-dialog-response-data",
GINT_TO_POINTER(response));
if ((signal_id = g_signal_lookup("clicked", GTK_TYPE_BUTTON))) {
GClosure *closure;
closure = g_cclosure_new_object(G_CALLBACK(action_widget_activated),
G_OBJECT(dlg->vbox));
g_signal_connect_closure_by_id(button, signal_id, 0, closure, FALSE);
}
gtk_container_add(GTK_CONTAINER(dlg->action_area), button);
gtk_size_group_add_widget(gui_action, button);
gtk_size_group_add_widget(dlg->gui_button, button);
}
gulong
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);
}
static guint
goo_canvas_item_accessible_add_focus_handler (AtkComponent *component,
AtkFocusHandler handler)
{
GSignalMatchType match_type;
GClosure *closure;
guint signal_id;
g_return_val_if_fail (GOO_IS_CANVAS_ITEM_ACCESSIBLE (component), 0);
match_type = G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC;
signal_id = g_signal_lookup ("focus-event", ATK_TYPE_OBJECT);
/* If the handler has already been added just return. */
if (g_signal_handler_find (component, match_type, signal_id, 0, NULL,
(gpointer) handler, NULL))
return 0;
closure = g_cclosure_new (G_CALLBACK (handler), NULL, (GClosureNotify) NULL);
return g_signal_connect_closure_by_id (component, signal_id, 0, closure,
FALSE);
}
static gboolean
gtk_toggle_tool_button_create_menu_proxy (GtkToolItem *item)
{
GtkToolButton *tool_button = GTK_TOOL_BUTTON (item);
GtkToggleToolButton *toggle_tool_button = GTK_TOGGLE_TOOL_BUTTON (item);
GtkWidget *menu_item = NULL;
GtkStockItem stock_item;
gboolean use_mnemonic = TRUE;
const char *label;
GtkWidget *label_widget;
const gchar *label_text;
const gchar *stock_id;
if (_gtk_tool_item_create_menu_proxy (item))
return TRUE;
label_widget = gtk_tool_button_get_label_widget (tool_button);
label_text = gtk_tool_button_get_label (tool_button);
stock_id = gtk_tool_button_get_stock_id (tool_button);
if (GTK_IS_LABEL (label_widget))
{
label = gtk_label_get_label (GTK_LABEL (label_widget));
use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (label_widget));
}
else if (label_text)
{
label = label_text;
use_mnemonic = gtk_tool_button_get_use_underline (tool_button);
}
else if (stock_id && gtk_stock_lookup (stock_id, &stock_item))
{
label = stock_item.label;
}
else
{
label = "";
}
if (use_mnemonic)
menu_item = gtk_check_menu_item_new_with_mnemonic (label);
else
menu_item = gtk_check_menu_item_new_with_label (label);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu_item),
toggle_tool_button->priv->active);
if (GTK_IS_RADIO_TOOL_BUTTON (toggle_tool_button))
{
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (menu_item),
TRUE);
}
g_signal_connect_closure_by_id (menu_item,
g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
g_cclosure_new_object (G_CALLBACK (menu_item_activated),
G_OBJECT (toggle_tool_button)),
FALSE);
gtk_tool_item_set_proxy_menu_item (item, MENU_ID, menu_item);
return TRUE;
}
static VALUE
rbclt_script_do_connect_signal (VALUE user_data)
{
AutoConnectData *data = (AutoConnectData *) user_data;
guint signal_id;
GQuark detail;
GClosure *rclosure;
if (NIL_P (data->proc))
{
ID mid;
VALUE args;
VALUE func;
if (!g_signal_parse_name (data->signal_name,
G_TYPE_FROM_INSTANCE (data->object),
&signal_id, &detail, TRUE))
rb_raise (eNoSignalError, "no such signal: %s", data->signal_name);
/* Create a method closure for the given object and method
name */
mid = rb_intern (data->handler_name);
func = rb_funcall (data->obj, id_method, 1,
rb_str_new2 (data->handler_name));
if (data->connect_object)
args = rb_ary_new3 (1, GOBJ2RVAL (data->connect_object));
else
args = data->args;
rclosure = g_rclosure_new (func, args,
rbgobj_get_signal_func (signal_id));
g_rclosure_attach ((GClosure *) rclosure, GOBJ2RVAL (data->object));
g_signal_connect_closure_by_id (data->object, signal_id, detail, rclosure,
(data->connect_flags & G_CONNECT_AFTER)
? TRUE : FALSE);
}
else
{
VALUE args;
int i;
/* Just pass the details on to the application's function to do
the actual connection */
args = rb_ary_new3 (5,
GOBJ2RVAL (data->object),
rb_str_new2 (data->signal_name),
rb_str_new2 (data->handler_name),
GOBJ2RVAL (data->connect_object),
GENUM2RVAL (data->connect_flags,
rbclt_connect_flags_get_type ()));
for (i = 0; i < RARRAY_LEN (data->args); i++)
rb_ary_push (args, RARRAY_PTR (data->args)[i]);
rb_funcall2 (data->proc, id_call, RARRAY_LEN (args), RARRAY_PTR (args));
}
return Qnil;
}
