| /* |
| * Copyright © 2010 Codethink Limited |
| * Copyright © 2011 Canonical Limited |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General |
| * Public License along with this library; if not, see <http://www.gnu.org/licenses/>. |
| * |
| * Authors: Ryan Lortie <desrt@desrt.ca> |
| */ |
| |
| #include "config.h" |
| |
| #include "gactiongroupexporter.h" |
| |
| #include "gdbusmethodinvocation.h" |
| #include "gremoteactiongroup.h" |
| #include "gdbusintrospection.h" |
| #include "gdbusconnection.h" |
| #include "gactiongroup.h" |
| #include "gdbuserror.h" |
| |
| /** |
| * SECTION:gactiongroupexporter |
| * @title: GActionGroup exporter |
| * @include: gio/gio.h |
| * @short_description: Export GActionGroups on D-Bus |
| * @see_also: #GActionGroup, #GDBusActionGroup |
| * |
| * These functions support exporting a #GActionGroup on D-Bus. |
| * The D-Bus interface that is used is a private implementation |
| * detail. |
| * |
| * To access an exported #GActionGroup remotely, use |
| * g_dbus_action_group_get() to obtain a #GDBusActionGroup. |
| */ |
| |
| static GVariant * |
| g_action_group_describe_action (GActionGroup *action_group, |
| const gchar *name) |
| { |
| const GVariantType *type; |
| GVariantBuilder builder; |
| gboolean enabled; |
| GVariant *state; |
| |
| g_variant_builder_init (&builder, G_VARIANT_TYPE ("(bgav)")); |
| |
| enabled = g_action_group_get_action_enabled (action_group, name); |
| g_variant_builder_add (&builder, "b", enabled); |
| |
| if ((type = g_action_group_get_action_parameter_type (action_group, name))) |
| { |
| gchar *str = g_variant_type_dup_string (type); |
| g_variant_builder_add (&builder, "g", str); |
| g_free (str); |
| } |
| else |
| g_variant_builder_add (&builder, "g", ""); |
| |
| g_variant_builder_open (&builder, G_VARIANT_TYPE ("av")); |
| if ((state = g_action_group_get_action_state (action_group, name))) |
| { |
| g_variant_builder_add (&builder, "v", state); |
| g_variant_unref (state); |
| } |
| g_variant_builder_close (&builder); |
| |
| return g_variant_builder_end (&builder); |
| } |
| |
| /* Using XML saves us dozens of relocations vs. using the introspection |
| * structure types. We only need to burn cycles and memory if we |
| * actually use the exporter -- not in every single app using GIO. |
| * |
| * It's also a lot easier to read. :) |
| * |
| * For documentation of this interface, see |
| * https://wiki.gnome.org/Projects/GLib/GApplication/DBusAPI |
| */ |
| const char org_gtk_Actions_xml[] = |
| "<node>" |
| " <interface name='org.gtk.Actions'>" |
| " <method name='List'>" |
| " <arg type='as' name='list' direction='out'/>" |
| " </method>" |
| " <method name='Describe'>" |
| " <arg type='s' name='action_name' direction='in'/>" |
| " <arg type='(bgav)' name='description' direction='out'/>" |
| " </method>" |
| " <method name='DescribeAll'>" |
| " <arg type='a{s(bgav)}' name='descriptions' direction='out'/>" |
| " </method>" |
| " <method name='Activate'>" |
| " <arg type='s' name='action_name' direction='in'/>" |
| " <arg type='av' name='parameter' direction='in'/>" |
| " <arg type='a{sv}' name='platform_data' direction='in'/>" |
| " </method>" |
| " <method name='SetState'>" |
| " <arg type='s' name='action_name' direction='in'/>" |
| " <arg type='v' name='value' direction='in'/>" |
| " <arg type='a{sv}' name='platform_data' direction='in'/>" |
| " </method>" |
| " <signal name='Changed'>" |
| " <arg type='as' name='removals'/>" |
| " <arg type='a{sb}' name='enable_changes'/>" |
| " <arg type='a{sv}' name='state_changes'/>" |
| " <arg type='a{s(bgav)}' name='additions'/>" |
| " </signal>" |
| " </interface>" |
| "</node>"; |
| |
| static GDBusInterfaceInfo *org_gtk_Actions; |
| |
| typedef struct |
| { |
| GActionGroup *action_group; |
| GDBusConnection *connection; |
| GMainContext *context; |
| gchar *object_path; |
| GHashTable *pending_changes; |
| GSource *pending_source; |
| } GActionGroupExporter; |
| |
| #define ACTION_ADDED_EVENT (1u<<0) |
| #define ACTION_REMOVED_EVENT (1u<<1) |
| #define ACTION_STATE_CHANGED_EVENT (1u<<2) |
| #define ACTION_ENABLED_CHANGED_EVENT (1u<<3) |
| |
| static gboolean |
| g_action_group_exporter_dispatch_events (gpointer user_data) |
| { |
| GActionGroupExporter *exporter = user_data; |
| GVariantBuilder removes; |
| GVariantBuilder enabled_changes; |
| GVariantBuilder state_changes; |
| GVariantBuilder adds; |
| GHashTableIter iter; |
| gpointer value; |
| gpointer key; |
| |
| g_variant_builder_init (&removes, G_VARIANT_TYPE_STRING_ARRAY); |
| g_variant_builder_init (&enabled_changes, G_VARIANT_TYPE ("a{sb}")); |
| g_variant_builder_init (&state_changes, G_VARIANT_TYPE ("a{sv}")); |
| g_variant_builder_init (&adds, G_VARIANT_TYPE ("a{s(bgav)}")); |
| |
| g_hash_table_iter_init (&iter, exporter->pending_changes); |
| while (g_hash_table_iter_next (&iter, &key, &value)) |
| { |
| guint events = GPOINTER_TO_INT (value); |
| const gchar *name = key; |
| |
| /* Adds and removes are incompatible with enabled or state |
| * changes, but we must report at least one event. |
| */ |
| g_assert (((events & (ACTION_ENABLED_CHANGED_EVENT | ACTION_STATE_CHANGED_EVENT)) == 0) != |
| ((events & (ACTION_REMOVED_EVENT | ACTION_ADDED_EVENT)) == 0)); |
| |
| if (events & ACTION_REMOVED_EVENT) |
| g_variant_builder_add (&removes, "s", name); |
| |
| if (events & ACTION_ENABLED_CHANGED_EVENT) |
| { |
| gboolean enabled; |
| |
| enabled = g_action_group_get_action_enabled (exporter->action_group, name); |
| g_variant_builder_add (&enabled_changes, "{sb}", name, enabled); |
| } |
| |
| if (events & ACTION_STATE_CHANGED_EVENT) |
| { |
| GVariant *state; |
| |
| state = g_action_group_get_action_state (exporter->action_group, name); |
| g_variant_builder_add (&state_changes, "{sv}", name, state); |
| g_variant_unref (state); |
| } |
| |
| if (events & ACTION_ADDED_EVENT) |
| { |
| GVariant *description; |
| |
| description = g_action_group_describe_action (exporter->action_group, name); |
| g_variant_builder_add (&adds, "{s@(bgav)}", name, description); |
| } |
| } |
| |
| g_hash_table_remove_all (exporter->pending_changes); |
| |
| g_dbus_connection_emit_signal (exporter->connection, NULL, exporter->object_path, |
| "org.gtk.Actions", "Changed", |
| g_variant_new ("(asa{sb}a{sv}a{s(bgav)})", |
| &removes, &enabled_changes, |
| &state_changes, &adds), |
| NULL); |
| |
| exporter->pending_source = NULL; |
| |
| return FALSE; |
| } |
| |
| static void |
| g_action_group_exporter_flush_queue (GActionGroupExporter *exporter) |
| { |
| if (exporter->pending_source) |
| { |
| g_source_destroy (exporter->pending_source); |
| g_action_group_exporter_dispatch_events (exporter); |
| g_assert (exporter->pending_source == NULL); |
| } |
| } |
| |
| static guint |
| g_action_group_exporter_get_events (GActionGroupExporter *exporter, |
| const gchar *name) |
| { |
| return (gsize) g_hash_table_lookup (exporter->pending_changes, name); |
| } |
| |
| static void |
| g_action_group_exporter_set_events (GActionGroupExporter *exporter, |
| const gchar *name, |
| guint events) |
| { |
| gboolean have_events; |
| gboolean is_queued; |
| |
| if (events != 0) |
| g_hash_table_insert (exporter->pending_changes, g_strdup (name), GINT_TO_POINTER (events)); |
| else |
| g_hash_table_remove (exporter->pending_changes, name); |
| |
| have_events = g_hash_table_size (exporter->pending_changes) > 0; |
| is_queued = exporter->pending_source != NULL; |
| |
| if (have_events && !is_queued) |
| { |
| GSource *source; |
| |
| source = g_idle_source_new (); |
| exporter->pending_source = source; |
| g_source_set_callback (source, g_action_group_exporter_dispatch_events, exporter, NULL); |
| g_source_set_name (source, "[gio] g_action_group_exporter_dispatch_events"); |
| g_source_attach (source, exporter->context); |
| g_source_unref (source); |
| } |
| |
| if (!have_events && is_queued) |
| { |
| g_source_destroy (exporter->pending_source); |
| exporter->pending_source = NULL; |
| } |
| } |
| |
| static void |
| g_action_group_exporter_action_added (GActionGroup *action_group, |
| const gchar *action_name, |
| gpointer user_data) |
| { |
| GActionGroupExporter *exporter = user_data; |
| guint event_mask; |
| |
| event_mask = g_action_group_exporter_get_events (exporter, action_name); |
| |
| /* The action is new, so we should not have any pending |
| * enabled-changed or state-changed signals for it. |
| */ |
| g_assert (~event_mask & (ACTION_STATE_CHANGED_EVENT | |
| ACTION_ENABLED_CHANGED_EVENT)); |
| |
| event_mask |= ACTION_ADDED_EVENT; |
| |
| g_action_group_exporter_set_events (exporter, action_name, event_mask); |
| } |
| |
| static void |
| g_action_group_exporter_action_removed (GActionGroup *action_group, |
| const gchar *action_name, |
| gpointer user_data) |
| { |
| GActionGroupExporter *exporter = user_data; |
| guint event_mask; |
| |
| event_mask = g_action_group_exporter_get_events (exporter, action_name); |
| |
| /* If the add event for this is still queued then just cancel it since |
| * it's gone now. |
| * |
| * If the event was freshly added, there should not have been any |
| * enabled or state changed events. |
| */ |
| if (event_mask & ACTION_ADDED_EVENT) |
| { |
| g_assert (~event_mask & ~(ACTION_STATE_CHANGED_EVENT | ACTION_ENABLED_CHANGED_EVENT)); |
| event_mask &= ~ACTION_ADDED_EVENT; |
| } |
| |
| /* Otherwise, queue a remove event. Drop any state or enabled changes |
| * that were queued before the remove. */ |
| else |
| { |
| event_mask |= ACTION_REMOVED_EVENT; |
| event_mask &= ~(ACTION_STATE_CHANGED_EVENT | ACTION_ENABLED_CHANGED_EVENT); |
| } |
| |
| g_action_group_exporter_set_events (exporter, action_name, event_mask); |
| } |
| |
| static void |
| g_action_group_exporter_action_state_changed (GActionGroup *action_group, |
| const gchar *action_name, |
| GVariant *value, |
| gpointer user_data) |
| { |
| GActionGroupExporter *exporter = user_data; |
| guint event_mask; |
| |
| event_mask = g_action_group_exporter_get_events (exporter, action_name); |
| |
| /* If it was removed, it must have been added back. Otherwise, why |
| * are we hearing about changes? |
| */ |
| g_assert (~event_mask & ACTION_REMOVED_EVENT || |
| event_mask & ACTION_ADDED_EVENT); |
| |
| /* If it is freshly added, don't also bother with the state change |
| * signal since the updated state will be sent as part of the pending |
| * add message. |
| */ |
| if (~event_mask & ACTION_ADDED_EVENT) |
| event_mask |= ACTION_STATE_CHANGED_EVENT; |
| |
| g_action_group_exporter_set_events (exporter, action_name, event_mask); |
| } |
| |
| static void |
| g_action_group_exporter_action_enabled_changed (GActionGroup *action_group, |
| const gchar *action_name, |
| gboolean enabled, |
| gpointer user_data) |
| { |
| GActionGroupExporter *exporter = user_data; |
| guint event_mask; |
| |
| event_mask = g_action_group_exporter_get_events (exporter, action_name); |
| |
| /* Reasoning as above. */ |
| g_assert (~event_mask & ACTION_REMOVED_EVENT || |
| event_mask & ACTION_ADDED_EVENT); |
| |
| if (~event_mask & ACTION_ADDED_EVENT) |
| event_mask |= ACTION_ENABLED_CHANGED_EVENT; |
| |
| g_action_group_exporter_set_events (exporter, action_name, event_mask); |
| } |
| |
| static void |
| org_gtk_Actions_method_call (GDBusConnection *connection, |
| const gchar *sender, |
| const gchar *object_path, |
| const gchar *interface_name, |
| const gchar *method_name, |
| GVariant *parameters, |
| GDBusMethodInvocation *invocation, |
| gpointer user_data) |
| { |
| GActionGroupExporter *exporter = user_data; |
| GVariant *result = NULL; |
| |
| g_action_group_exporter_flush_queue (exporter); |
| |
| if (g_str_equal (method_name, "List")) |
| { |
| gchar **list; |
| |
| list = g_action_group_list_actions (exporter->action_group); |
| result = g_variant_new ("(^as)", list); |
| g_strfreev (list); |
| } |
| |
| else if (g_str_equal (method_name, "Describe")) |
| { |
| const gchar *name; |
| GVariant *desc; |
| |
| g_variant_get (parameters, "(&s)", &name); |
| |
| if (!g_action_group_has_action (exporter->action_group, name)) |
| { |
| g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, |
| "The named action ('%s') does not exist.", name); |
| return; |
| } |
| |
| desc = g_action_group_describe_action (exporter->action_group, name); |
| result = g_variant_new ("(@(bgav))", desc); |
| } |
| |
| else if (g_str_equal (method_name, "DescribeAll")) |
| { |
| GVariantBuilder builder; |
| gchar **list; |
| gint i; |
| |
| list = g_action_group_list_actions (exporter->action_group); |
| g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{s(bgav)}")); |
| for (i = 0; list[i]; i++) |
| { |
| const gchar *name = list[i]; |
| GVariant *description; |
| |
| description = g_action_group_describe_action (exporter->action_group, name); |
| g_variant_builder_add (&builder, "{s@(bgav)}", name, description); |
| } |
| result = g_variant_new ("(a{s(bgav)})", &builder); |
| g_strfreev (list); |
| } |
| |
| else if (g_str_equal (method_name, "Activate")) |
| { |
| GVariant *parameter = NULL; |
| GVariant *platform_data; |
| GVariantIter *iter; |
| const gchar *name; |
| |
| g_variant_get (parameters, "(&sav@a{sv})", &name, &iter, &platform_data); |
| g_variant_iter_next (iter, "v", ¶meter); |
| g_variant_iter_free (iter); |
| |
| if (G_IS_REMOTE_ACTION_GROUP (exporter->action_group)) |
| g_remote_action_group_activate_action_full (G_REMOTE_ACTION_GROUP (exporter->action_group), |
| name, parameter, platform_data); |
| else |
| g_action_group_activate_action (exporter->action_group, name, parameter); |
| |
| if (parameter) |
| g_variant_unref (parameter); |
| |
| g_variant_unref (platform_data); |
| } |
| |
| else if (g_str_equal (method_name, "SetState")) |
| { |
| GVariant *platform_data; |
| const gchar *name; |
| GVariant *state; |
| |
| g_variant_get (parameters, "(&sv@a{sv})", &name, &state, &platform_data); |
| |
| if (G_IS_REMOTE_ACTION_GROUP (exporter->action_group)) |
| g_remote_action_group_change_action_state_full (G_REMOTE_ACTION_GROUP (exporter->action_group), |
| name, state, platform_data); |
| else |
| g_action_group_change_action_state (exporter->action_group, name, state); |
| |
| g_variant_unref (platform_data); |
| g_variant_unref (state); |
| } |
| |
| else |
| g_assert_not_reached (); |
| |
| g_dbus_method_invocation_return_value (invocation, result); |
| } |
| |
| static void |
| g_action_group_exporter_free (gpointer user_data) |
| { |
| GActionGroupExporter *exporter = user_data; |
| |
| g_signal_handlers_disconnect_by_func (exporter->action_group, |
| g_action_group_exporter_action_added, exporter); |
| g_signal_handlers_disconnect_by_func (exporter->action_group, |
| g_action_group_exporter_action_enabled_changed, exporter); |
| g_signal_handlers_disconnect_by_func (exporter->action_group, |
| g_action_group_exporter_action_state_changed, exporter); |
| g_signal_handlers_disconnect_by_func (exporter->action_group, |
| g_action_group_exporter_action_removed, exporter); |
| |
| g_hash_table_unref (exporter->pending_changes); |
| if (exporter->pending_source) |
| g_source_destroy (exporter->pending_source); |
| |
| g_main_context_unref (exporter->context); |
| g_object_unref (exporter->connection); |
| g_object_unref (exporter->action_group); |
| g_free (exporter->object_path); |
| |
| g_slice_free (GActionGroupExporter, exporter); |
| } |
| |
| /** |
| * g_dbus_connection_export_action_group: |
| * @connection: a #GDBusConnection |
| * @object_path: a D-Bus object path |
| * @action_group: a #GActionGroup |
| * @error: a pointer to a %NULL #GError, or %NULL |
| * |
| * Exports @action_group on @connection at @object_path. |
| * |
| * The implemented D-Bus API should be considered private. It is |
| * subject to change in the future. |
| * |
| * A given object path can only have one action group exported on it. |
| * If this constraint is violated, the export will fail and 0 will be |
| * returned (with @error set accordingly). |
| * |
| * You can unexport the action group using |
| * g_dbus_connection_unexport_action_group() with the return value of |
| * this function. |
| * |
| * The thread default main context is taken at the time of this call. |
| * All incoming action activations and state change requests are |
| * reported from this context. Any changes on the action group that |
| * cause it to emit signals must also come from this same context. |
| * Since incoming action activations and state change requests are |
| * rather likely to cause changes on the action group, this effectively |
| * limits a given action group to being exported from only one main |
| * context. |
| * |
| * Returns: the ID of the export (never zero), or 0 in case of failure |
| * |
| * Since: 2.32 |
| **/ |
| guint |
| g_dbus_connection_export_action_group (GDBusConnection *connection, |
| const gchar *object_path, |
| GActionGroup *action_group, |
| GError **error) |
| { |
| const GDBusInterfaceVTable vtable = { |
| org_gtk_Actions_method_call, NULL, NULL, { 0 } |
| }; |
| GActionGroupExporter *exporter; |
| guint id; |
| |
| if G_UNLIKELY (org_gtk_Actions == NULL) |
| { |
| GError *error = NULL; |
| GDBusNodeInfo *info; |
| |
| info = g_dbus_node_info_new_for_xml (org_gtk_Actions_xml, &error); |
| if G_UNLIKELY (info == NULL) |
| g_error ("%s", error->message); |
| org_gtk_Actions = g_dbus_node_info_lookup_interface (info, "org.gtk.Actions"); |
| g_assert (org_gtk_Actions != NULL); |
| g_dbus_interface_info_ref (org_gtk_Actions); |
| g_dbus_node_info_unref (info); |
| } |
| |
| exporter = g_slice_new (GActionGroupExporter); |
| id = g_dbus_connection_register_object (connection, object_path, org_gtk_Actions, &vtable, |
| exporter, g_action_group_exporter_free, error); |
| |
| if (id == 0) |
| { |
| g_slice_free (GActionGroupExporter, exporter); |
| return 0; |
| } |
| |
| exporter->context = g_main_context_ref_thread_default (); |
| exporter->pending_changes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); |
| exporter->pending_source = NULL; |
| exporter->action_group = g_object_ref (action_group); |
| exporter->connection = g_object_ref (connection); |
| exporter->object_path = g_strdup (object_path); |
| |
| g_signal_connect (action_group, "action-added", |
| G_CALLBACK (g_action_group_exporter_action_added), exporter); |
| g_signal_connect (action_group, "action-removed", |
| G_CALLBACK (g_action_group_exporter_action_removed), exporter); |
| g_signal_connect (action_group, "action-state-changed", |
| G_CALLBACK (g_action_group_exporter_action_state_changed), exporter); |
| g_signal_connect (action_group, "action-enabled-changed", |
| G_CALLBACK (g_action_group_exporter_action_enabled_changed), exporter); |
| |
| return id; |
| } |
| |
| /** |
| * g_dbus_connection_unexport_action_group: |
| * @connection: a #GDBusConnection |
| * @export_id: the ID from g_dbus_connection_export_action_group() |
| * |
| * Reverses the effect of a previous call to |
| * g_dbus_connection_export_action_group(). |
| * |
| * It is an error to call this function with an ID that wasn't returned |
| * from g_dbus_connection_export_action_group() or to call it with the |
| * same ID more than once. |
| * |
| * Since: 2.32 |
| **/ |
| void |
| g_dbus_connection_unexport_action_group (GDBusConnection *connection, |
| guint export_id) |
| { |
| g_dbus_connection_unregister_object (connection, export_id); |
| } |
