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