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; }