int main (int argc, char **argv) { GThread *thread1, *thread2; GClosure *closure; GTest *object; guint i; g_thread_init (NULL); g_print ("START: %s\n", argv[0]); g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | g_log_set_always_fatal (G_LOG_FATAL_MASK)); g_type_init (); object = g_object_new (G_TYPE_TEST, NULL); closure = g_cclosure_new (G_CALLBACK (test_signal_handler), TEST_POINTER2, destroy_data); g_signal_connect_closure (object, "test-signal1", closure, FALSE); g_signal_connect_closure (object, "test-signal2", closure, FALSE); stopping = FALSE; thread1 = g_thread_create (thread1_main, closure, TRUE, NULL); thread2 = g_thread_create (thread2_main, closure, TRUE, NULL); for (i = 0; i < 1000000; i++) { static guint count = 0; test_emissions (object); if (++count % 10000 == 0) { g_printerr (".\n"); g_thread_yield(); /* force context switch */ } } stopping = TRUE; g_print ("\nstopping\n"); /* wait for thread shutdown */ g_thread_join (thread1); g_thread_join (thread2); /* finalize object, destroy signals, run cleanup code */ g_object_unref (object); g_print ("stopped\n"); g_assert (seen_thread1 != FALSE); g_assert (seen_thread2 != FALSE); g_assert (seen_test_int1 != FALSE); g_assert (seen_test_int2 != FALSE); g_assert (seen_signal_handler != FALSE); g_assert (seen_cleanup != FALSE); return 0; }
static void seed_builder_connect_func (GtkBuilder *builder, GObject *object, const gchar *signal_name, const gchar *handler_name, GObject *connect_object, GConnectFlags flags, gpointer user_data) { SeedContext ctx; SeedObject obj, func; builder_ud *priv = (builder_ud *)user_data; GClosure *closure; ctx = priv->ctx; obj = priv->obj; func = seed_object_get_property (ctx, obj, handler_name); if (!seed_value_is_object (ctx, func) || !seed_value_is_function (ctx, func)) return; closure = seed_closure_new (ctx, func, priv->user_data, "signal handler (GtkBuilder)"); if (connect_object != NULL) g_object_watch_closure (connect_object, closure); g_signal_connect_closure (object, signal_name, closure, FALSE); }
static void g_object_connect_property (GObject *object, GParamSpec *spec, GCallback func, gpointer data, GObject *alive_object) { GClosure *closure; gchar *with_detail; DisconnectData *dd; if (is_child_property (spec)) with_detail = g_strconcat ("child-notify::", spec->name, NULL); else with_detail = g_strconcat ("notify::", spec->name, NULL); dd = g_new (DisconnectData, 1); closure = g_cclosure_new (func, data, NULL); g_closure_add_invalidate_notifier (closure, dd, signal_removed); dd->id = g_signal_connect_closure (object, with_detail, closure, FALSE); dd->instance = object; dd->alive_object = alive_object; g_object_set_data_full (G_OBJECT (alive_object), "alive-object-data", dd, disconnect_func); g_free (with_detail); }
void button_connect_callback( GtkButton* button, const Callback& callback ){ #if 1 g_signal_connect_swapped( G_OBJECT( button ), "clicked", G_CALLBACK( callback.getThunk() ), callback.getEnvironment() ); #else g_signal_connect_closure( G_OBJECT( button ), "clicked", create_cclosure( G_CALLBACK( clicked_closure_callback ), callback ), FALSE ); #endif }
nsresult nsAlertsIconListener::ShowAlert(GdkPixbuf* aPixbuf) { mNotification = notify_notification_new(mAlertTitle.get(), mAlertText.get(), nullptr, nullptr); if (!mNotification) return NS_ERROR_OUT_OF_MEMORY; if (aPixbuf) notify_notification_set_icon_from_pixbuf(mNotification, aPixbuf); NS_ADDREF(this); if (mAlertHasAction) { // What we put as the label doesn't matter here, if the action // string is "default" then that makes the entire bubble clickable // rather than creating a button. notify_notification_add_action(mNotification, "default", "Activate", notify_action_cb, this, nullptr); } // Fedora 10 calls NotifyNotification "closed" signal handlers with a // different signature, so a marshaller is used instead of a C callback to // get the user_data (this) in a parseable format. |closure| is created // with a floating reference, which gets sunk by g_signal_connect_closure(). GClosure* closure = g_closure_new_simple(sizeof(GClosure), this); g_closure_set_marshal(closure, notify_closed_marshal); mClosureHandler = g_signal_connect_closure(mNotification, "closed", closure, FALSE); gboolean result = notify_notification_show(mNotification, nullptr); return result ? NS_OK : NS_ERROR_FAILURE; }
/** * _nm_dbus_signal_connect_data: * @proxy: a #GDBusProxy * @signal_name: the D-Bus signal to connect to * @signature: (allow-none): the signal's type signature (must be a tuple) * @c_handler: the signal handler function * @data: (allow-none): data to pass to @c_handler * @destroy_data: (allow-none): closure destroy notify for @data * @connect_flags: connection flags * * Connects to the D-Bus signal @signal_name on @proxy. @c_handler must be a * void function whose first argument is a #GDBusProxy, followed by arguments * for each element of @signature, ending with a #gpointer argument for @data. * * The argument types in @c_handler correspond to the types output by * g_dbus_gvariant_to_gvalue(), except for 'ay' and 'aay'. In particular: * - both 16-bit and 32-bit integers are passed as #gint/#guint * - 'as' values are passed as #GStrv (char **) * - all other array, tuple, and dict types are passed as #GVariant * * If @signature is %NULL, then the signal's parameters will be ignored, and * @c_handler should take only the #GDBusProxy and #gpointer arguments. * * Returns: the signal handler ID, which can be used with * g_signal_handler_remove(). Beware that because of the way the signal is * connected, you will not be able to remove it with * g_signal_handlers_disconnect_by_func(), although * g_signal_handlers_disconnect_by_data() will work correctly. */ gulong _nm_dbus_signal_connect_data (GDBusProxy *proxy, const char *signal_name, const GVariantType *signature, GCallback c_handler, gpointer data, GClosureNotify destroy_data, GConnectFlags connect_flags) { NMDBusSignalData *sd; GClosure *closure; gboolean swapped = !!(connect_flags & G_CONNECT_SWAPPED); gboolean after = !!(connect_flags & G_CONNECT_AFTER); g_return_val_if_fail (G_IS_DBUS_PROXY (proxy), 0); g_return_val_if_fail (signal_name != NULL, 0); g_return_val_if_fail (signature == NULL || g_variant_type_is_tuple (signature), 0); g_return_val_if_fail (c_handler != NULL, 0); sd = g_slice_new (NMDBusSignalData); sd->signal_name = g_strdup (signal_name); sd->signature = signature; closure = (swapped ? g_cclosure_new_swap : g_cclosure_new) (c_handler, data, destroy_data); g_closure_set_marshal (closure, g_cclosure_marshal_generic); g_closure_set_meta_marshal (closure, sd, dbus_signal_meta_marshal); g_closure_add_finalize_notifier (closure, sd, dbus_signal_data_free); return g_signal_connect_closure (proxy, "g-signal", closure, after); }
guint toggle_button_connect_callback( GtkToggleButton* button, const Callback& callback ){ #if 1 guint handler = g_signal_connect_swapped( G_OBJECT( button ), "toggled", G_CALLBACK( callback.getThunk() ), callback.getEnvironment() ); #else guint handler = g_signal_connect_closure( G_OBJECT( button ), "toggled", create_cclosure( G_CALLBACK( clicked_closure_callback ), callback ), TRUE ); #endif g_object_set_data( G_OBJECT( button ), "handler", gint_to_pointer( handler ) ); return handler; }
static void _check_toplevel (AtkObject *obj) { AtkObject *root_obj; const gchar *name_string, *version_string; gint max_depth; g_print ("Start of _check_toplevel\n"); root_obj = atk_get_root(); if (!already_accessed_atk_object(root_obj)) { g_signal_connect_closure (root_obj, "children_changed::add", g_cclosure_new (G_CALLBACK (_notify_toplevel_child_added), NULL, NULL), FALSE); g_signal_connect_closure (root_obj, "children_changed::remove", g_cclosure_new (G_CALLBACK (_notify_toplevel_child_removed), NULL, NULL), FALSE); } name_string = atk_get_toolkit_name(); version_string = atk_get_toolkit_version(); g_print ("Toolkit name <%s> version <%s>\n", name_string, version_string); if (g_getenv("TEST_ACCESSIBLE_DEPTH") != NULL) max_depth = string_to_int(g_getenv("TEST_ACCESSIBLE_DEPTH")); else max_depth = 2; display_children_to_depth(root_obj, max_depth, 0, 0); g_print ("End of _check_toplevel\n"); if (!g_register_listener) { g_print("Adding global event listener on buttons\n"); g_register_listener = TRUE; g_signal_listener = atk_add_global_event_listener(_button_press_event_watcher, "Gtk:GtkButton:pressed"); } }
static void _gjs_builder_connect_func (GtkBuilder *builder, GObject *object, const gchar *signal_name, const gchar *handler_name, GObject *connect_object, GConnectFlags flags, gpointer user_data) { builder_ud *priv = (builder_ud *)user_data; JSContext *ctx = priv->ctx; JSObject *obj = priv->obj; GClosure *closure; JSObject *callable; builder_cd *cd; closure_data *c; jsval func; if (!gjs_object_get_property (ctx, obj, handler_name, &func)) return; if (!JSVAL_IS_OBJECT(func)) return; callable = JSVAL_TO_OBJECT (func); if (!JS_ObjectIsFunction(ctx, callable)) return; /* Protect from garbage collection. */ cd = g_object_get_data (G_OBJECT (builder), GJS_BUILDER_CLOSURE_KEY); if (!cd) { cd = g_new0 (builder_cd, 1); cd->context = ctx; cd->closures = NULL; g_object_set_data_full (G_OBJECT (builder), GJS_BUILDER_CLOSURE_KEY, cd, (GDestroyNotify) _builder_cd_free); } g_assert (cd->context == ctx); c = g_new0 (closure_data, 1); c->jsobj = callable; cd->closures = g_slist_prepend (cd->closures, c); JS_AddObjectRoot (ctx, &c->jsobj); closure = gjs_closure_new_for_signal (ctx, callable, "signal handler (GtkBuilder)", 0); if (connect_object != NULL) g_object_watch_closure (connect_object, closure); c->object = g_object_ref (object); c->handler_id = g_signal_connect_closure (object, signal_name, closure, FALSE); }
GtkWidget * menu_item_connect (GtkWidget * item, MenuData * item_data) { TRACE ("entering menu_item_connect"); g_return_val_if_fail (item != NULL, NULL); g_return_val_if_fail (GTK_IS_MENU_ITEM (item), NULL); g_signal_connect_closure (GTK_OBJECT (item), "activate", g_cclosure_new (GTK_SIGNAL_FUNC (activate_cb), item_data, (GClosureNotify) closure_notify), FALSE); return (item); }
/* this function connects a signal specified by 'signal_name' with the R callback embedded in a GClosure as 'user_data'. If the user data in the closure is NULL, then 'connect_object' is used as the user data for the callback. */ void S_GladeXMLConnectFuncDefault(const gchar *handler_name, GObject *object, const gchar *signal_name, const gchar *signal_data, GObject *connect_object, gboolean after, gpointer user_data) { R_CallbackData *cbdata = (R_CallbackData *)((GClosure*)user_data)->data; if (!cbdata->data) cbdata->data = toRPointer(connect_object, "GObject"); g_signal_connect_closure(object, signal_name, user_data, after); }
static GList* thunar_uca_provider_get_actions (ThunarxPreferencesProvider *preferences_provider, GtkWidget *window) { GtkAction *action; GClosure *closure; action = gtk_action_new ("ThunarUca::manage-actions", _("Configure c_ustom actions..."), _("Setup custom actions that will appear in the file managers context menus"), NULL); closure = g_cclosure_new_object_swap (G_CALLBACK (manage_actions), G_OBJECT (window)); g_signal_connect_closure (G_OBJECT (action), "activate", closure, TRUE); return g_list_prepend (NULL, action); }
gulong connect_to_signal(void* obj, gchar* name, gint64 id) { gint64 *pgint64 = (gint64*)malloc(sizeof(gint64)); *pgint64 = id; GClosure* c = g_cclosure_new_swap(G_CALLBACK(func_handler), (gpointer)pgint64, destroy_id); g_closure_set_marshal(c, simple_go_marshal); gulong handler_id = g_signal_connect_closure((gpointer)obj, name, c, TRUE); return handler_id; }
static void e_soup_ssl_trust_network_event_cb (SoupMessage *msg, GSocketClientEvent event, GIOStream *connection, gpointer user_data) { ESoupSslTrustData *handler = user_data; /* It's either a GTlsConnection or a GTcpConnection */ if (event == G_SOCKET_CLIENT_TLS_HANDSHAKING && G_IS_TLS_CONNECTION (connection)) { g_signal_connect_closure ( G_TLS_CONNECTION (connection), "accept-certificate", handler->accept_certificate_closure, FALSE); } }
/** * playerctl_player_on: * @self: an #PlayerctlPlayer * @event: the event to subscribe to * @callback: the callback to run on the event * * A convenience function for bindings to subscribe an event with a callback * * Returns: (transfer none): the #PlayerctlPlayer for chaining */ PlayerctlPlayer *playerctl_player_on(PlayerctlPlayer *self, const gchar *event, GClosure *callback, GError **err) { GError *tmp_error = NULL; if (self->priv->init_error != NULL) { g_propagate_error(err, g_error_copy(self->priv->init_error)); return self; } g_closure_ref(callback); g_closure_sink(callback); g_signal_connect_closure(self, event, callback, TRUE); return self; }
std::uint64_t IWindow::on_key_press(bool (*f)(Widget widget, _GdkEventKey *event, void *extra), void *extra) { using f_t = decltype(f); struct user_data { f_t f; void *extra; } *pass = new user_data{f, extra}; auto dtor = [](user_data *data, GClosure *) { delete data; }; auto func = [](_GtkWidget *widget, GdkEventKey *event, user_data *args) -> bool { return args->f(Widget::from(widget), event, args->extra); }; auto clos = g_cclosure_new(G_CALLBACK(+func), pass, reinterpret_cast<GClosureNotify>(+dtor)); return g_signal_connect_closure(G_OBJECT(this), "key-press-event", clos, false); }
/** * _rb_action_group_add_source_actions: * @group: a #GtkActionGroup * @shell: the #RBShell * @actions: array of GtkActionEntry structures for the action group * @num_actions: number of actions in the @actions array * * Adds actions to an action group where the action callback is * called with the current selected source. This can safely be called * multiple times on the same action group. */ void _rb_action_group_add_source_actions (GtkActionGroup *group, GObject *shell, GtkActionEntry *actions, int num_actions) { int i; for (i = 0; i < num_actions; i++) { GtkAction *action; const char *label; const char *tooltip; SourceActionData *source_action_data; if (gtk_action_group_get_action (group, actions[i].name) != NULL) { /* action was already added */ continue; } label = gtk_action_group_translate_string (group, actions[i].label); tooltip = gtk_action_group_translate_string (group, actions[i].tooltip); action = gtk_action_new (actions[i].name, label, tooltip, NULL); if (actions[i].stock_id != NULL) { g_object_set (action, "stock-id", actions[i].stock_id, NULL); if (gtk_icon_theme_has_icon (gtk_icon_theme_get_default (), actions[i].stock_id)) { g_object_set (action, "icon-name", actions[i].stock_id, NULL); } } if (actions[i].callback) { GClosure *closure; source_action_data = g_slice_new0 (SourceActionData); source_action_data->callback = (SourceActionCallback) actions[i].callback; source_action_data->shell = shell; g_object_add_weak_pointer (shell, &source_action_data->shell); closure = g_cclosure_new (G_CALLBACK (source_action_cb), source_action_data, (GClosureNotify) source_action_data_destroy); g_signal_connect_closure (action, "activate", closure, FALSE); } gtk_action_group_add_action_with_accel (group, action, actions[i].accelerator); g_object_unref (action); } }
/** * Register specified entry widget for address completion. * \param entry Address entry field. */ void address_completion_register_entry(GtkEntry *entry, gboolean allow_commas) { cm_return_if_fail(entry != NULL); cm_return_if_fail(GTK_IS_ENTRY(entry)); /* add hooked property */ g_object_set_data(G_OBJECT(entry), ENTRY_DATA_TAB_HOOK, entry); g_object_set_data(G_OBJECT(entry), ENTRY_DATA_ALLOW_COMMAS, GINT_TO_POINTER(allow_commas)); /* add keypress event */ g_signal_connect_closure (G_OBJECT(entry), "key_press_event", g_cclosure_new(G_CALLBACK(address_completion_entry_key_pressed), COMPLETION_UNIQUE_DATA, NULL), FALSE); /* magic */ }
/* Takes (method_name, handler_func) pairs and connects the handlers to the * signals on skeleton, with object as the user_data, but swapped so it comes * first in the argument list, and handling the return value automatically. */ void _nm_dbus_bind_methods (gpointer object, gpointer skeleton, ...) { va_list ap; const char *method_name; char *signal_name; GCallback handler; GClosure *closure; va_start (ap, skeleton); while ( (method_name = va_arg (ap, const char *)) && (handler = va_arg (ap, GCallback))) { signal_name = signal_name_from_method_name (method_name); closure = g_cclosure_new_swap (handler, object, NULL); g_closure_set_meta_marshal (closure, NULL, _nm_dbus_method_meta_marshal); g_signal_connect_closure (skeleton, signal_name, closure, FALSE); g_free (signal_name); } va_end (ap); }
gulong seed_gobject_signal_connect (JSContextRef ctx, const gchar * signal_name, GObject * on_obj, JSObjectRef func, JSObjectRef this_obj, JSObjectRef user_data) { GSignalQuery query; GClosure *closure; if (g_str_has_prefix (signal_name, "notify::")) g_signal_query (g_signal_lookup ("notify", G_OBJECT_TYPE (on_obj)), &query); else g_signal_query (g_signal_lookup (signal_name, G_OBJECT_TYPE (on_obj)), &query); #ifdef SEED_ENABLE_DEBUG { guint function_arity = seed_value_to_uint (ctx, seed_object_get_property (ctx, func, "length"), NULL); if (function_arity != query.n_params) { SEED_MARK (); SEED_NOTE (SIGNAL, "Connecting signal: %s. Function has arity %d, signal expects %d", query.signal_name, function_arity, query.n_params); SEED_MARK (); } } #endif closure = seed_closure_new_for_signal (ctx, func, user_data, "signal handler", query.signal_id); // This seems wrong... ((SeedClosure *) closure)->return_type = query.return_type; return g_signal_connect_closure (on_obj, signal_name, closure, FALSE); }
/* ML type: cptr -> string -> clb -> bool -> int */ EXTERNML long mgtk_signal_connect ( Pointer object , Pointer name , long clb , Bool after) { /* ML */ int res; GClosure *closure; /* printf("register id = %i\n",(int) clb); */ closure = mgtk_closure_new((gpointer) clb); res = g_signal_connect_closure (object, name, closure, after); /* g_closure_unref(closure); */ return res; }
static void track_monitor_hierarchy_changed (GtkWidget *widget, GtkWidget *previous_toplevel, TrackMonitorData *track_data) { GtkWidget *toplevel; if (previous_toplevel) { g_signal_handlers_disconnect_by_func (previous_toplevel, track_monitor_configure_event, track_data); } toplevel = gtk_widget_get_toplevel (widget); if (GTK_IS_WINDOW (toplevel)) { GClosure *closure; gint monitor; closure = g_cclosure_new (G_CALLBACK (track_monitor_configure_event), track_data, NULL); g_object_watch_closure (G_OBJECT (widget), closure); g_signal_connect_closure (toplevel, "configure-event", closure, FALSE); monitor = gimp_widget_get_monitor (toplevel); if (monitor != track_data->monitor) { track_data->monitor = monitor; track_data->callback (track_data->widget, track_data->user_data); } } }
static GtkUIManager * ui_manager_new (GtkWidget *window) { static const GtkActionEntry actions[] = { { "back", GTK_STOCK_GO_BACK, NULL, "<alt>Left", N_("Go back one page"), G_CALLBACK (back_callback) }, { "forward", GTK_STOCK_GO_FORWARD, NULL, "<alt>Right", N_("Go forward one page"), G_CALLBACK (forward_callback) }, { "reload", GTK_STOCK_REFRESH, N_("_Reload"), "<control>R", N_("Reload current page"), G_CALLBACK (reload_callback) }, { "stop", GTK_STOCK_CANCEL, N_("_Stop"), "Escape", N_("Stop loading this page"), G_CALLBACK (stop_callback) }, { "home", GTK_STOCK_HOME, NULL, "<alt>Home", N_("Go to the index page"), G_CALLBACK (home_callback) }, { "copy-location", GTK_STOCK_COPY, N_("C_opy location"), "", N_("Copy the location of this page to the clipboard"), G_CALLBACK (copy_location_callback) }, { "copy-selection", GTK_STOCK_COPY, NULL, "<control>C", NULL, G_CALLBACK (copy_selection_callback) }, { "zoom-in", GTK_STOCK_ZOOM_IN, NULL, "<control>plus", NULL, G_CALLBACK (zoom_in_callback) }, { "zoom-out", GTK_STOCK_ZOOM_OUT, NULL, "<control>minus", NULL, G_CALLBACK (zoom_out_callback) }, { "find", GTK_STOCK_FIND, NULL, "<control>F", N_("Find text in current page"), G_CALLBACK (find_callback) }, { "find-again", NULL, N_("Find _Again"), "<control>G", NULL, G_CALLBACK (find_again_callback) }, { "close", GTK_STOCK_CLOSE, NULL, "<control>W", NULL, G_CALLBACK (close_callback) }, { "quit", GTK_STOCK_QUIT, NULL, "<control>Q", NULL, G_CALLBACK (close_callback) } }; static const GtkToggleActionEntry toggle_actions[] = { { "show-index", NULL, N_("S_how Index"), "<control>I", N_("Toggle the visibility of the sidebar"), G_CALLBACK (show_index_callback), FALSE } }; GtkUIManager *ui_manager = gtk_ui_manager_new (); GtkActionGroup *group = gtk_action_group_new ("Actions"); GtkAction *action; GError *error = NULL; gtk_action_group_set_translation_domain (group, NULL); gtk_action_group_add_actions (group, actions, G_N_ELEMENTS (actions), NULL); gtk_action_group_add_toggle_actions (group, toggle_actions, G_N_ELEMENTS (toggle_actions), NULL); action = gimp_throbber_action_new ("website", "docs.gimp.org", _("Visit the GIMP documentation website"), GIMP_STOCK_USER_MANUAL); g_signal_connect_closure (action, "activate", g_cclosure_new (G_CALLBACK (website_callback), NULL, NULL), FALSE); gtk_action_group_add_action (group, action); g_object_unref (action); gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui_manager)); gtk_accel_group_lock (gtk_ui_manager_get_accel_group (ui_manager)); gtk_ui_manager_insert_action_group (ui_manager, group, -1); g_object_unref (group); gtk_ui_manager_add_ui_from_string (ui_manager, "<ui>" " <toolbar name=\"help-browser-toolbar\">" " <toolitem action=\"reload\" />" " <toolitem action=\"stop\" />" " <toolitem action=\"home\" />" " <separator name=\"space\" />" " <toolitem action=\"website\" />" " </toolbar>" " <accelerator action=\"close\" />" " <accelerator action=\"quit\" />" "</ui>", -1, &error); if (error) { g_warning ("error parsing ui: %s", error->message); g_clear_error (&error); } gtk_ui_manager_add_ui_from_string (ui_manager, "<ui>" " <popup name=\"help-browser-popup\">" " <menuitem action=\"back\" />" " <menuitem action=\"forward\" />" " <menuitem action=\"reload\" />" " <menuitem action=\"stop\" />" " <separator />" " <menuitem action=\"home\" />" " <menuitem action=\"copy-location\" />" " <menuitem action=\"show-index\" />" " <separator />" " <menuitem action=\"find\" />" " <menuitem action=\"find-again\" />" " <separator />" " <menuitem action=\"zoom-in\" />" " <menuitem action=\"zoom-out\" />" " <separator />" " <menuitem action=\"close\" />" " </popup>" "</ui>", -1, &error); if (error) { g_warning ("error parsing ui: %s", error->message); g_clear_error (&error); } gtk_ui_manager_add_ui_from_string (ui_manager, "<ui>" " <popup name=\"help-browser-copy-popup\">" " <menuitem action=\"copy-selection\" />" " </popup>" "</ui>", -1, &error); if (error) { g_warning ("error parsing ui: %s", error->message); g_clear_error (&error); } return ui_manager; }
static void about_create(void) { GtkWidget *vbox1; GtkWidget *image; GtkWidget *vbox2; GtkWidget *label; GtkWidget *button; GtkWidget *scrolledwin; GtkWidget *notebook; GtkWidget *table; char *markup; GtkWidget *confirm_area; GtkWidget *close_button; static GdkGeometry geometry; stats_text_buffer = NULL; window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "about"); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS); gtk_window_set_title(GTK_WINDOW(window), _("About Claws Mail")); gtk_container_set_border_width(GTK_CONTAINER(window), 8); gtk_widget_set_size_request(window, -1, -1); g_signal_connect(G_OBJECT(window), "size_allocate", G_CALLBACK(about_size_allocate_cb), NULL); g_signal_connect(G_OBJECT(window), "size_allocate", G_CALLBACK(about_size_allocate_cb), NULL); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(gtk_widget_hide_on_delete), NULL); g_signal_connect(G_OBJECT(window), "key_press_event", G_CALLBACK(key_pressed), NULL); if (!geometry.min_width) { geometry.min_width = 450; geometry.min_height = 500; } gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry, GDK_HINT_MIN_SIZE); gtk_window_set_default_size(GTK_WINDOW(window), prefs_common.aboutwin_width, prefs_common.aboutwin_height); gtk_widget_realize(window); vbox1 = gtk_vbox_new(FALSE, 8); gtk_container_add(GTK_CONTAINER(window), vbox1); table = gtk_table_new (2, 1, FALSE); gtk_box_pack_start(GTK_BOX(vbox1), table, FALSE, FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (table), 8); gtk_table_set_row_spacings (GTK_TABLE (table), 8); gtk_table_set_col_spacings (GTK_TABLE (table), 8); image = stock_pixmap_widget(window, STOCK_PIXMAP_CLAWS_MAIL_LOGO); gtk_table_attach (GTK_TABLE (table), image, 0, 1, 0, 1, (GtkAttachOptions) (GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); vbox2 = gtk_vbox_new (FALSE, 4); gtk_table_attach (GTK_TABLE (table), vbox2, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND), (GtkAttachOptions) (0), 0, 0); label = gtk_label_new(""); gtk_label_set_selectable(GTK_LABEL(label), TRUE); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER); gtk_box_pack_start(GTK_BOX(vbox2), label, FALSE, FALSE, 0); markup = g_markup_printf_escaped ("<span weight=\"bold\" size=\"xx-large\">Claws Mail</span>\nversion %s", VERSION_GIT_FULL); gtk_label_set_markup(GTK_LABEL(label), markup); g_free(markup); button = gtkut_get_link_btn(window, HOMEPAGE_URI, " "HOMEPAGE_URI" "); gtk_box_pack_start(GTK_BOX(vbox2), button, FALSE, FALSE, 0); #ifndef GENERIC_UMPC label = gtk_label_new (_("Copyright (C) 1999-2016\nThe Claws Mail Team\n" "and Hiroyuki Yamamoto")); gtk_label_set_selectable(GTK_LABEL(label), TRUE); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_box_pack_start(GTK_BOX(vbox2), label, FALSE, FALSE, 0); #endif notebook = gtk_notebook_new(); gtk_widget_set_size_request(notebook, -1, 220); gtk_widget_show(notebook); if ((scrolledwin = about_create_child_page_info()) != NULL) { gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolledwin, gtk_label_new_with_mnemonic(_("_Info"))); } if ((scrolledwin = about_create_child_page_authors()) != NULL) { gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolledwin, gtk_label_new_with_mnemonic(_("_Authors"))); } if ((scrolledwin = about_create_child_page_features()) != NULL) { gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolledwin, gtk_label_new_with_mnemonic(_("_Features"))); } if ((scrolledwin = about_create_child_page_license()) != NULL) { gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolledwin, gtk_label_new_with_mnemonic(_("_License"))); } if (release_notes_available() && (scrolledwin = about_create_child_page_release_notes()) != NULL) { gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolledwin, gtk_label_new_with_mnemonic(_("_Release Notes"))); } if ((scrolledwin = about_create_child_page_session_stats()) != NULL) { gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolledwin, gtk_label_new_with_mnemonic(_("_Statistics"))); } gtk_box_pack_start(GTK_BOX(vbox1), notebook, TRUE, TRUE, 0); gtkut_stock_button_set_create(&confirm_area, &close_button, GTK_STOCK_CLOSE, NULL, NULL, NULL, NULL); gtk_box_pack_end(GTK_BOX(vbox1), confirm_area, FALSE, FALSE, 4); gtk_widget_grab_default(close_button); gtk_widget_grab_focus(close_button); g_signal_connect_closure (G_OBJECT(close_button), "clicked", g_cclosure_new_swap(G_CALLBACK(gtk_widget_hide_on_delete), window, NULL), FALSE); gtk_widget_show_all(window); }
void _rb_add_display_page_actions (GActionMap *map, GObject *shell, const GActionEntry *actions, gint n_entries) { int i; for (i = 0; i < n_entries; i++) { GSimpleAction *action; const GVariantType *parameter_type; DisplayPageActionData *page_action_data; if (g_action_map_lookup_action (map, actions[i].name) != NULL) { /* action was already added */ continue; } if (actions[i].parameter_type) { parameter_type = G_VARIANT_TYPE (actions[i].parameter_type); } else { parameter_type = NULL; } if (actions[i].state) { GVariant *state; GError *error = NULL; state = g_variant_parse (NULL, actions[i].state, NULL, NULL, &error); if (state == NULL) { g_critical ("could not parse state value '%s' for action " "%s: %s", actions[i].state, actions[i].name, error->message); g_error_free (error); continue; } action = g_simple_action_new_stateful (actions[i].name, parameter_type, state); } else { action = g_simple_action_new (actions[i].name, parameter_type); } if (actions[i].activate) { GClosure *closure; page_action_data = g_slice_new0 (DisplayPageActionData); page_action_data->u.gaction = (DisplayPageActionActivateCallback) actions[i].activate; page_action_data->shell = shell; g_object_add_weak_pointer (shell, &page_action_data->shell); closure = g_cclosure_new (G_CALLBACK (display_page_action_activate_cb), page_action_data, (GClosureNotify) display_page_action_data_destroy); g_signal_connect_closure (action, "activate", closure, FALSE); } if (actions[i].change_state) { GClosure *closure; page_action_data = g_slice_new0 (DisplayPageActionData); page_action_data->u.gactionstate = (DisplayPageActionChangeStateCallback) actions[i].change_state; page_action_data->shell = shell; g_object_add_weak_pointer (shell, &page_action_data->shell); closure = g_cclosure_new (G_CALLBACK (display_page_action_change_state_cb), page_action_data, (GClosureNotify) display_page_action_data_destroy); g_signal_connect_closure (action, "change-state", closure, FALSE); } g_action_map_add_action (map, G_ACTION (action)); g_object_unref (action); } }
/** * gnome_popup_menu_attach: * @popup: A menu widget. * @widget: The widget to attach the popup menu to. * @user_data: Application specific data passed to the callback. * * Attaches the specified popup menu to the specified widget. The * menu can then be activated by pressing mouse button 3 over the * widget. When a menu item callback is invoked, the specified * user_data will be passed to it. * * This function requires the widget to have its own window * (i.e. GTK_WIDGET_NO_WINDOW (widget) == FALSE), This function will * try to set the GDK_BUTTON_PRESS_MASK flag on the widget's event * mask if it does not have it yet; if this is the case, then the * widget must not be realized for it to work. * * The popup menu can be attached to different widgets at the same * time. A reference count is kept on the popup menu; when all the * widgets it is attached to are destroyed, the popup menu will be * destroyed as well. * * Under the current implementation, setting a popup menu for a NO_WINDOW * widget and then reparenting that widget will cause Bad Things to happen. */ void gnome_popup_menu_attach (GtkWidget *popup, GtkWidget *widget, gpointer user_data) { GtkWidget *ev_widget; g_return_if_fail (popup != NULL); g_return_if_fail (GTK_IS_MENU (popup)); g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_WIDGET (widget)); if(g_object_get_data (G_OBJECT (widget), "gnome_popup_menu")) return; g_object_set_data (G_OBJECT (widget), "gnome_popup_menu", popup); /* This operation can fail if someone is trying to set a popup on e.g. an uncontained label, so we do it first. */ for(ev_widget = widget; ev_widget && GTK_WIDGET_NO_WINDOW(ev_widget); ev_widget = ev_widget->parent) { g_object_set_data (G_OBJECT (ev_widget), "gnome_popup_menu_nowindow", GUINT_TO_POINTER(1)); } g_return_if_fail (ev_widget); /* Ref/sink the popup menu so that we take "ownership" of it */ g_object_ref (G_OBJECT (popup)); gtk_object_sink (GTK_OBJECT (popup)); /* Store the user data pointer in the widget -- we will use it later when the menu has to be * invoked. */ g_object_set_data (G_OBJECT (widget), "gnome_popup_menu_attach_user_data", user_data); g_object_set_data (G_OBJECT (widget), "gnome_popup_menu", user_data); /* Prepare the widget to accept button presses -- the proper assertions will be * shouted by gtk_widget_set_events(). */ gtk_widget_add_events (ev_widget, GDK_BUTTON_PRESS_MASK | GDK_KEY_PRESS_MASK); g_signal_connect (widget, "button_press_event", G_CALLBACK (popup_button_pressed), popup); g_signal_connect (G_OBJECT (widget), "popup_menu", G_CALLBACK (popup_menu_pressed), popup); if (ev_widget != widget) { GClosure *closure; closure = g_cclosure_new (G_CALLBACK (relay_popup_button_pressed), popup, NULL); g_object_watch_closure (G_OBJECT (widget), closure); g_signal_connect_closure (ev_widget, "button_press_event", closure, FALSE); } /* This callback will unref the popup menu when the widget it is attached to gets destroyed. */ g_signal_connect (widget, "destroy", G_CALLBACK (popup_attach_widget_destroyed), popup); }
/* * create a generic query box without any entry widget */ static QueryBox * create_query_box (const gchar *title, GtkWidget *parent, GimpHelpFunc help_func, const gchar *help_id, GCallback response_callback, const gchar *icon_name, const gchar *message, const gchar *ok_button, const gchar *cancel_button, GObject *object, const gchar *signal, GCallback callback, gpointer callback_data) { QueryBox *query_box; GtkWidget *hbox = NULL; GtkWidget *label; /* make sure the object / signal passed are valid */ g_return_val_if_fail (parent == NULL || GTK_IS_WIDGET (parent), NULL); g_return_val_if_fail (object == NULL || G_IS_OBJECT (object), NULL); g_return_val_if_fail (object == NULL || signal != NULL, NULL); query_box = g_slice_new0 (QueryBox); query_box->qbox = gimp_dialog_new (title, "gimp-query-box", parent, 0, help_func, help_id, cancel_button, GTK_RESPONSE_CANCEL, ok_button, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (query_box->qbox), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); query_box->response_handler = g_signal_connect (query_box->qbox, "response", G_CALLBACK (response_callback), query_box); g_signal_connect (query_box->qbox, "destroy", G_CALLBACK (gtk_widget_destroyed), &query_box->qbox); /* if we are associated with an object, connect to the provided signal */ if (object) { GClosure *closure; closure = g_cclosure_new_swap (G_CALLBACK (query_box_cancel_callback), query_box, NULL); g_object_watch_closure (G_OBJECT (query_box->qbox), closure); g_signal_connect_closure (object, signal, closure, FALSE); } if (icon_name) { GtkWidget *content_area; GtkWidget *image; content_area = gtk_dialog_get_content_area (GTK_DIALOG (query_box->qbox)); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0); gtk_widget_show (image); } query_box->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); g_object_set_data (G_OBJECT (query_box->qbox), "gimp-query-box-vbox", query_box->vbox); if (hbox) { gtk_box_pack_start (GTK_BOX (hbox), query_box->vbox, FALSE, FALSE, 0); } else { GtkWidget *content_area; content_area = gtk_dialog_get_content_area (GTK_DIALOG (query_box->qbox)); gtk_container_set_border_width (GTK_CONTAINER (query_box->vbox), 12); gtk_box_pack_start (GTK_BOX (content_area), query_box->vbox, TRUE, TRUE, 0); } gtk_widget_show (query_box->vbox); if (message) { label = gtk_label_new (message); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (query_box->vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); } query_box->entry = NULL; query_box->object = object; query_box->callback = callback; query_box->callback_data = callback_data; return query_box; }