glib/gio/gactiongroupexporter.c
Matthias Clasen cd22e1967d Describe the org.gtk.Actions interface
Even though we consider the interface to be an implementation
detail, we should have internal documentation for the interface.
2011-12-08 18:05:12 -05:00

718 lines
24 KiB
C

/*
* Copyright © 2010 Codethink Limited
* Copyright © 2011 Canonical Limited
*
* This program 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 of the licence 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, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* Authors: Ryan Lortie <desrt@desrt.ca>
*/
#include "config.h"
#include "gactiongroupexporter.h"
#include "gdbusmethodinvocation.h"
#include "gdbusintrospection.h"
#include "gdbusconnection.h"
#include "gactiongroup.h"
#include "gapplication.h"
#include "gdbuserror.h"
/**
* SECTION:gactiongroupexporter
* @title: GActionGroup exporter
* @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_new() to obtain a #GDBusActionGroup.
*/
G_GNUC_INTERNAL 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);
}
/* The org.gtk.Actions interface
* =============================
*
* This interface describes a group of actions.
*
* Each action:
* - has a unique string name
* - can be activated
* - optionally has a parameter type that must be given to the activation
* - has an enabled state that may be true or false
* - optionally has a state which can change value, but not type
*
* Methods
* -------
*
* List :: () → (as)
*
* Lists the names of the actions exported at this object path.
*
* Describe :: (s) → (bgav)
*
* Describes a single action, or a given name.
*
* The return value has the following components:
* b: specifies if the action is currently enabled. This is
* a hint that attempting to interact with the action will
* produce no effect.
* g: specifies the optional parameter type. If not "",
* the string specifies the type of argument that must
* be passed to the activation.
* av: specifies the optional state. If not empty, the array
* contains the current value of the state as a variant
*
* DescribeAll :: () → (a{s(bgav)})
*
* Describes all actions in a single round-trip.
*
* The dictionary maps action name strings to their descriptions
* (in the format discussed above).
*
* Activate :: (sava{sv}) → ()
*
* Requests activation of the named action.
*
* The action is named by the first parameter (s).
*
* If the action activation requires a parameter then this parameter
* must be given in the second parameter (av). If there is no parameter
* to be specified, the array must be empty.
*
* The final parameter (a{sv}) is a list of "platform data".
*
* This method is not guaranteed to have any particular effect. The
* implementation may take some action (including changing the state
* of the action, if it is stateful) or it may take none at all. In
* particular, callers should expect their request to be completely
* ignored when the enabled flag is false (but even this is not
* guaranteed).
*
* SetState :: (sva{sv}) → ()
*
* Requests the state of an action to be changed to the given value.
*
* The action is named by the first parameter (s).
*
* The requested new state is given in the second parameter (v).
* It must be equal in type to the existing state.
*
* The final parameter (a{sv}) is a list of "platform data".
*
* This method is not guaranteed to have any particular effect.
* The implementation of an action can choose to ignore the requested
* state change, or choose to change its state to something else or
* to trigger other side effects. In particular, callers should expect
* their request to be completely ignored when the enabled flag is
* false (but even this is not guaranteed).
*
* Signals
* -------
*
* Changed :: (asa{sb}a{sv}a{s(bgav)})
*
* Signals that some change has occured to the action group.
*
* Four separate types of changes are possible, and the 4 parameters
* of the change signal reflect these possibilities:
* as: a list of removed actions
* a{sb}: a list of actions that had their enabled flag changed
* a{sv}: a list of actions that had their state changed
* a{s(bgav)}: a list of new actions added in the same format as
* the return value of the DescribeAll method
*/
/* 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. :)
*/
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;
static GHashTable *exported_groups;
typedef struct
{
GActionGroup *action_group;
GDBusConnection *connection;
gchar *object_path;
guint registration_id;
GHashTable *pending_changes;
guint pending_id;
gulong signal_ids[4];
} 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_id = 0;
return FALSE;
}
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_id > 0;
if (have_events && !is_queued)
exporter->pending_id = g_idle_add (g_action_group_exporter_dispatch_events, exporter);
if (!have_events && is_queued)
{
g_source_remove (exporter->pending_id);
exporter->pending_id = 0;
}
}
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
g_action_group_exporter_pre_emit (GActionGroupExporter *exporter,
GVariant *platform_data)
{
if (G_IS_APPLICATION (exporter->action_group))
G_APPLICATION_GET_CLASS (exporter->action_group)
->before_emit (G_APPLICATION (exporter->action_group), platform_data);
}
static void
g_action_group_exporter_post_emit (GActionGroupExporter *exporter,
GVariant *platform_data)
{
if (G_IS_APPLICATION (exporter->action_group))
G_APPLICATION_GET_CLASS (exporter->action_group)
->after_emit (G_APPLICATION (exporter->action_group), platform_data);
}
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;
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);
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", &parameter);
g_variant_iter_free (iter);
g_action_group_exporter_pre_emit (exporter, platform_data);
g_action_group_activate_action (exporter->action_group, name, parameter);
g_action_group_exporter_post_emit (exporter, platform_data);
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);
g_action_group_exporter_pre_emit (exporter, platform_data);
g_action_group_change_action_state (exporter->action_group, name, state);
g_action_group_exporter_post_emit (exporter, platform_data);
g_variant_unref (platform_data);
g_variant_unref (state);
}
else
g_assert_not_reached ();
g_dbus_method_invocation_return_value (invocation, result);
}
/**
* g_action_group_dbus_export_start:
* @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 action group can only be exported on one object path and an
* object path can only have one action group exported on it. If either
* constraint is violated, the export will fail and %FALSE will be
* returned (with @error set accordingly).
*
* Use g_action_group_dbus_export_stop() to stop exporting @action_group,
* or g_action_group_dbus_export_query() to find out if and where a given
* action group is exported.
*
* Returns: %TRUE if the export is successful, or %FALSE (with @error
* set) in the event of a failure.
**/
gboolean
g_action_group_dbus_export_start (GDBusConnection *connection,
const gchar *object_path,
GActionGroup *action_group,
GError **error)
{
const GDBusInterfaceVTable vtable = {
org_gtk_Actions_method_call
};
GActionGroupExporter *exporter;
if G_UNLIKELY (exported_groups == NULL)
exported_groups = g_hash_table_new (NULL, NULL);
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);
}
if G_UNLIKELY (g_hash_table_lookup (exported_groups, action_group))
{
g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_FILE_EXISTS,
"The given GActionGroup has already been exported");
return FALSE;
}
exporter = g_slice_new (GActionGroupExporter);
exporter->registration_id = g_dbus_connection_register_object (connection, object_path, org_gtk_Actions,
&vtable, exporter, NULL, error);
if (exporter->registration_id == 0)
{
g_slice_free (GActionGroupExporter, exporter);
return FALSE;
}
g_hash_table_insert (exported_groups, action_group, exporter);
exporter->pending_changes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
exporter->pending_id = 0;
exporter->action_group = g_object_ref (action_group);
exporter->connection = g_object_ref (connection);
exporter->object_path = g_strdup (object_path);
exporter->signal_ids[0] =
g_signal_connect (action_group, "action-added",
G_CALLBACK (g_action_group_exporter_action_added), exporter);
exporter->signal_ids[1] =
g_signal_connect (action_group, "action-removed",
G_CALLBACK (g_action_group_exporter_action_removed), exporter);
exporter->signal_ids[2] =
g_signal_connect (action_group, "action-state-changed",
G_CALLBACK (g_action_group_exporter_action_state_changed), exporter);
exporter->signal_ids[3] =
g_signal_connect (action_group, "action-enabled-changed",
G_CALLBACK (g_action_group_exporter_action_enabled_changed), exporter);
return TRUE;
}
/**
* g_action_group_dbus_export_stop:
* @action_group: a #GActionGroup
*
* Stops the export of @action_group.
*
* This reverses the effect of a previous call to
* g_action_group_dbus_export_start() for @action_group.
*
* Returns: %TRUE if an export was stopped or %FALSE if @action_group
* was not exported in the first place
**/
gboolean
g_action_group_dbus_export_stop (GActionGroup *action_group)
{
GActionGroupExporter *exporter;
gint i;
if G_UNLIKELY (exported_groups == NULL)
return FALSE;
exporter = g_hash_table_lookup (exported_groups, action_group);
if G_UNLIKELY (exporter == NULL)
return FALSE;
g_dbus_connection_unregister_object (exporter->connection, exporter->registration_id);
for (i = 0; i < G_N_ELEMENTS (exporter->signal_ids); i++)
g_signal_handler_disconnect (exporter->action_group, exporter->signal_ids[i]);
g_object_unref (exporter->connection);
g_object_unref (exporter->action_group);
g_free (exporter->object_path);
g_slice_free (GActionGroupExporter, exporter);
return TRUE;
}
/**
* g_action_group_dbus_export_query:
* @action_group: a #GActionGroup
* @connection: (out): the #GDBusConnection used for exporting
* @object_path: (out): the object path used for exporting
*
* Queries if and where @action_group is exported.
*
* If @action_group is exported, %TRUE is returned. If @connection is
* non-%NULL then it is set to the #GDBusConnection used for the export.
* If @object_path is non-%NULL then it is set to the object path.
*
* If the @action_group is not exported, %FALSE is returned and
* @connection and @object_path remain unmodified.
*
* Returns: %TRUE if @action_group was exported, else %FALSE
**/
gboolean
g_action_group_dbus_export_query (GActionGroup *action_group,
GDBusConnection **connection,
const gchar **object_path)
{
GActionGroupExporter *exporter;
if (exported_groups == NULL)
return FALSE;
exporter = g_hash_table_lookup (exported_groups, action_group);
if (exporter == NULL)
return FALSE;
if (connection)
*connection = exporter->connection;
if (object_path)
*object_path = exporter->object_path;
return TRUE;
}