gio/gdbusactiongroup.c

   1 /*
   2  * Copyright © 2010 Codethink Limited
   3  * Copyright © 2011 Canonical Limited
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU Lesser General Public License as published
   7  * by the Free Software Foundation; either version 2 of the licence or (at
   8  * your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Authors: Ryan Lortie <desrt@desrt.ca>
  19  */
  20
  21 #include "config.h"
  22
  23 #include "gdbusactiongroup-private.h"
  24
  25 #include "gremoteactiongroup.h"
  26 #include "gdbusconnection.h"
  27 #include "gactiongroup.h"
  28
  29 /**
  30  * SECTION:gdbusactiongroup
  31  * @title: GDBusActionGroup
  32  * @short_description: A D-Bus GActionGroup implementation
  33  * @include: gio/gio.h
  34  * @see_also: [GActionGroup exporter][gio-GActionGroup-exporter]
  35  *
  36  * #GDBusActionGroup is an implementation of the #GActionGroup
  37  * interface that can be used as a proxy for an action group
  38  * that is exported over D-Bus with g_dbus_connection_export_action_group().
  39  */
  40
  41 struct _GDBusActionGroup
  42 {
  43   GObject parent_instance;
  44
  45   GDBusConnection *connection;
  46   gchar           *bus_name;
  47   gchar           *object_path;
  48   guint            subscription_id;
  49   GHashTable      *actions;
  50
  51   /* The 'strict' flag indicates that the non-existence of at least one
  52    * action has potentially been observed through the API.  This means
  53    * that we should always emit 'action-added' signals for all new
  54    * actions.
  55    *
  56    * The user can observe the non-existence of an action by listing the
  57    * actions or by performing a query (such as parameter type) on a
  58    * non-existent action.
  59    *
  60    * If the user has no way of knowing that a given action didn't
  61    * already exist then we can skip emitting 'action-added' signals
  62    * since they have no way of knowing that it wasn't there from the
  63    * start.
  64    */
  65   gboolean         strict;
  66 };
  67
  68 typedef GObjectClass GDBusActionGroupClass;
  69
  70 typedef struct
  71 {
  72   gchar        *name;
  73   GVariantType *parameter_type;
  74   gboolean      enabled;
  75   GVariant     *state;
  76 } ActionInfo;
  77
  78 static void
  79 action_info_free (gpointer user_data)
  80 {
  81   ActionInfo *info = user_data;
  82
  83   g_free (info->name);
  84
  85   if (info->state)
  86     g_variant_unref (info->state);
  87
  88   if (info->parameter_type)
  89     g_variant_type_free (info->parameter_type);
  90
  91   g_slice_free (ActionInfo, info);
  92 }
  93
  94 static ActionInfo *
  95 action_info_new_from_iter (GVariantIter *iter)
  96 {
  97   const gchar *param_str;
  98   ActionInfo *info;
  99   gboolean enabled;
 100   GVariant *state;
 101   gchar *name;
 102
 103   if (!g_variant_iter_next (iter, "{s(b&g@av)}", &name,
 104                             &enabled, &param_str, &state))
 105     return NULL;
 106
 107   info = g_slice_new (ActionInfo);
 108   info->name = name;
 109   info->enabled = enabled;
 110
 111   if (g_variant_n_children (state))
 112     g_variant_get_child (state, 0, "v", &info->state);
 113   else
 114     info->state = NULL;
 115   g_variant_unref (state);
 116
 117   if (param_str[0])
 118     info->parameter_type = g_variant_type_copy ((GVariantType *) param_str);
 119   else
 120     info->parameter_type = NULL;
 121
 122   return info;
 123 }
 124
 125 static void g_dbus_action_group_remote_iface_init (GRemoteActionGroupInterface *iface);
 126 static void g_dbus_action_group_iface_init        (GActionGroupInterface       *iface);
 127 G_DEFINE_TYPE_WITH_CODE (GDBusActionGroup, g_dbus_action_group, G_TYPE_OBJECT,
 128   G_IMPLEMENT_INTERFACE (G_TYPE_ACTION_GROUP, g_dbus_action_group_iface_init)
 129   G_IMPLEMENT_INTERFACE (G_TYPE_REMOTE_ACTION_GROUP, g_dbus_action_group_remote_iface_init))
 130
 131 static void
 132 g_dbus_action_group_changed (GDBusConnection *connection,
 133                              const gchar     *sender,
 134                              const gchar     *object_path,
 135                              const gchar     *interface_name,
 136                              const gchar     *signal_name,
 137                              GVariant        *parameters,
 138                              gpointer         user_data)
 139 {
 140   GDBusActionGroup *group = user_data;
 141   GActionGroup *g_group = user_data;
 142
 143   /* make sure that we've been fully initialised */
 144   if (group->actions == NULL)
 145     return;
 146
 147   if (g_str_equal (signal_name, "Changed") &&
 148       g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(asa{sb}a{sv}a{s(bgav)})")))
 149     {
 150       /* Removes */
 151       {
 152         GVariantIter *iter;
 153         const gchar *name;
 154
 155         g_variant_get_child (parameters, 0, "as", &iter);
 156         while (g_variant_iter_next (iter, "&s", &name))
 157           {
 158             if (g_hash_table_lookup (group->actions, name))
 159               {
 160                 g_hash_table_remove (group->actions, name);
 161                 g_action_group_action_removed (g_group, name);
 162               }
 163           }
 164         g_variant_iter_free (iter);
 165       }
 166
 167       /* Enable changes */
 168       {
 169         GVariantIter *iter;
 170         const gchar *name;
 171         gboolean enabled;
 172
 173         g_variant_get_child (parameters, 1, "a{sb}", &iter);
 174         while (g_variant_iter_next (iter, "{&sb}", &name, &enabled))
 175           {
 176             ActionInfo *info;
 177
 178             info = g_hash_table_lookup (group->actions, name);
 179
 180             if (info && info->enabled != enabled)
 181               {
 182                 info->enabled = enabled;
 183                 g_action_group_action_enabled_changed (g_group, name, enabled);
 184               }
 185           }
 186         g_variant_iter_free (iter);
 187       }
 188
 189       /* State changes */
 190       {
 191         GVariantIter *iter;
 192         const gchar *name;
 193         GVariant *state;
 194
 195         g_variant_get_child (parameters, 2, "a{sv}", &iter);
 196         while (g_variant_iter_next (iter, "{&sv}", &name, &state))
 197           {
 198             ActionInfo *info;
 199
 200             info = g_hash_table_lookup (group->actions, name);
 201
 202             if (info && info->state && !g_variant_equal (state, info->state) &&
 203                 g_variant_is_of_type (state, g_variant_get_type (info->state)))
 204               {
 205                 g_variant_unref (info->state);
 206                 info->state = g_variant_ref (state);
 207
 208                 g_action_group_action_state_changed (g_group, name, state);
 209               }
 210
 211             g_variant_unref (state);
 212           }
 213         g_variant_iter_free (iter);
 214       }
 215
 216       /* Additions */
 217       {
 218         GVariantIter *iter;
 219         ActionInfo *info;
 220
 221         g_variant_get_child (parameters, 3, "a{s(bgav)}", &iter);
 222         while ((info = action_info_new_from_iter (iter)))
 223           {
 224             if (!g_hash_table_lookup (group->actions, info->name))
 225               {
 226                 g_hash_table_insert (group->actions, info->name, info);
 227
 228                 if (group->strict)
 229                   g_action_group_action_added (g_group, info->name);
 230               }
 231             else
 232               action_info_free (info);
 233           }
 234         g_variant_iter_free (iter);
 235       }
 236     }
 237 }
 238
 239
 240 static void
 241 g_dbus_action_group_describe_all_done (GObject      *source,
 242                                        GAsyncResult *result,
 243                                        gpointer      user_data)
 244 {
 245   GDBusActionGroup *group= user_data;
 246   GVariant *reply;
 247
 248   g_assert (group->actions == NULL);
 249   group->actions = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, action_info_free);
 250
 251   g_assert (group->connection == (gpointer) source);
 252   reply = g_dbus_connection_call_finish (group->connection, result, NULL);
 253
 254   if (reply != NULL)
 255     {
 256       GVariantIter *iter;
 257       ActionInfo *action;
 258
 259       g_variant_get (reply, "(a{s(bgav)})", &iter);
 260       while ((action = action_info_new_from_iter (iter)))
 261         {
 262           g_hash_table_insert (group->actions, action->name, action);
 263
 264           if (group->strict)
 265             g_action_group_action_added (G_ACTION_GROUP (group), action->name);
 266         }
 267       g_variant_iter_free (iter);
 268       g_variant_unref (reply);
 269     }
 270
 271   g_object_unref (group);
 272 }
 273
 274
 275 static void
 276 g_dbus_action_group_async_init (GDBusActionGroup *group)
 277 {
 278   if (group->subscription_id != 0)
 279     return;
 280
 281   group->subscription_id =
 282     g_dbus_connection_signal_subscribe (group->connection, group->bus_name, "org.gtk.Actions", "Changed", group->object_path,
 283                                         NULL, G_DBUS_SIGNAL_FLAGS_NONE, g_dbus_action_group_changed, group, NULL);
 284
 285   g_dbus_connection_call (group->connection, group->bus_name, group->object_path, "org.gtk.Actions", "DescribeAll", NULL,
 286                           G_VARIANT_TYPE ("(a{s(bgav)})"), G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 287                           g_dbus_action_group_describe_all_done, g_object_ref (group));
 288 }
 289
 290 static gchar **
 291 g_dbus_action_group_list_actions (GActionGroup *g_group)
 292 {
 293   GDBusActionGroup *group = G_DBUS_ACTION_GROUP (g_group);
 294   gchar **keys;
 295
 296   if (group->actions != NULL)
 297     {
 298       GHashTableIter iter;
 299       gint n, i = 0;
 300       gpointer key;
 301
 302       n = g_hash_table_size (group->actions);
 303       keys = g_new (gchar *, n + 1);
 304
 305       g_hash_table_iter_init (&iter, group->actions);
 306       while (g_hash_table_iter_next (&iter, &key, NULL))
 307         keys[i++] = g_strdup (key);
 308       g_assert_cmpint (i, ==, n);
 309       keys[n] = NULL;
 310     }
 311   else
 312     {
 313       g_dbus_action_group_async_init (group);
 314       keys = g_new0 (gchar *, 1);
 315     }
 316
 317   group->strict = TRUE;
 318
 319   return keys;
 320 }
 321
 322 static gboolean
 323 g_dbus_action_group_query_action (GActionGroup        *g_group,
 324                                   const gchar         *action_name,
 325                                   gboolean            *enabled,
 326                                   const GVariantType **parameter_type,
 327                                   const GVariantType **state_type,
 328                                   GVariant           **state_hint,
 329                                   GVariant           **state)
 330 {
 331   GDBusActionGroup *group = G_DBUS_ACTION_GROUP (g_group);
 332   ActionInfo *info;
 333
 334   if (group->actions != NULL)
 335     {
 336       info = g_hash_table_lookup (group->actions, action_name);
 337
 338       if (info == NULL)
 339         {
 340           group->strict = TRUE;
 341           return FALSE;
 342         }
 343
 344       if (enabled)
 345         *enabled = info->enabled;
 346
 347       if (parameter_type)
 348         *parameter_type = info->parameter_type;
 349
 350       if (state_type)
 351         *state_type = info->state ? g_variant_get_type (info->state) : NULL;
 352
 353       if (state_hint)
 354         *state_hint = NULL;
 355
 356       if (state)
 357         *state = info->state ? g_variant_ref (info->state) : NULL;
 358
 359       return TRUE;
 360     }
 361   else
 362     {
 363       g_dbus_action_group_async_init (group);
 364       group->strict = TRUE;
 365
 366       return FALSE;
 367     }
 368 }
 369
 370 static void
 371 g_dbus_action_group_activate_action_full (GRemoteActionGroup *remote,
 372                                           const gchar        *action_name,
 373                                           GVariant           *parameter,
 374                                           GVariant           *platform_data)
 375 {
 376   GDBusActionGroup *group = G_DBUS_ACTION_GROUP (remote);
 377   GVariantBuilder builder;
 378
 379   g_variant_builder_init (&builder, G_VARIANT_TYPE ("av"));
 380
 381   if (parameter)
 382     g_variant_builder_add (&builder, "v", parameter);
 383
 384   g_dbus_connection_call (group->connection, group->bus_name, group->object_path, "org.gtk.Actions", "Activate",
 385                           g_variant_new ("(sav@a{sv})", action_name, &builder, platform_data),
 386                           NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 387 }
 388
 389 static void
 390 g_dbus_action_group_change_action_state_full (GRemoteActionGroup *remote,
 391                                               const gchar        *action_name,
 392                                               GVariant           *value,
 393                                               GVariant           *platform_data)
 394 {
 395   GDBusActionGroup *group = G_DBUS_ACTION_GROUP (remote);
 396
 397   g_dbus_connection_call (group->connection, group->bus_name, group->object_path, "org.gtk.Actions", "SetState",
 398                           g_variant_new ("(sv@a{sv})", action_name, value, platform_data),
 399                           NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, NULL);
 400 }
 401
 402 static void
 403 g_dbus_action_group_change_state (GActionGroup *group,
 404                                   const gchar  *action_name,
 405                                   GVariant     *value)
 406 {
 407   g_dbus_action_group_change_action_state_full (G_REMOTE_ACTION_GROUP (group),
 408                                                 action_name, value, g_variant_new ("a{sv}", NULL));
 409 }
 410
 411 static void
 412 g_dbus_action_group_activate (GActionGroup *group,
 413                               const gchar  *action_name,
 414                               GVariant     *parameter)
 415 {
 416   g_dbus_action_group_activate_action_full (G_REMOTE_ACTION_GROUP (group),
 417                                             action_name, parameter, g_variant_new ("a{sv}", NULL));
 418 }
 419
 420 static void
 421 g_dbus_action_group_finalize (GObject *object)
 422 {
 423   GDBusActionGroup *group = G_DBUS_ACTION_GROUP (object);
 424
 425   if (group->subscription_id)
 426     g_dbus_connection_signal_unsubscribe (group->connection, group->subscription_id);
 427
 428   if (group->actions)
 429     g_hash_table_unref (group->actions);
 430
 431   g_object_unref (group->connection);
 432   g_free (group->object_path);
 433   g_free (group->bus_name);
 434
 435   G_OBJECT_CLASS (g_dbus_action_group_parent_class)
 436     ->finalize (object);
 437 }
 438
 439 static void
 440 g_dbus_action_group_init (GDBusActionGroup *group)
 441 {
 442 }
 443
 444 static void
 445 g_dbus_action_group_class_init (GDBusActionGroupClass *class)
 446 {
 447   GObjectClass *object_class = G_OBJECT_CLASS (class);
 448
 449   object_class->finalize = g_dbus_action_group_finalize;
 450 }
 451
 452 static void
 453 g_dbus_action_group_remote_iface_init (GRemoteActionGroupInterface *iface)
 454 {
 455   iface->activate_action_full = g_dbus_action_group_activate_action_full;
 456   iface->change_action_state_full = g_dbus_action_group_change_action_state_full;
 457 }
 458
 459 static void
 460 g_dbus_action_group_iface_init (GActionGroupInterface *iface)
 461 {
 462   iface->list_actions = g_dbus_action_group_list_actions;
 463   iface->query_action = g_dbus_action_group_query_action;
 464   iface->change_action_state = g_dbus_action_group_change_state;
 465   iface->activate_action = g_dbus_action_group_activate;
 466 }
 467
 468 /**
 469  * g_dbus_action_group_get:
 470  * @connection: A #GDBusConnection
 471  * @bus_name: the bus name which exports the action group
 472  * @object_path: the object path at which the action group is exported
 473  *
 474  * Obtains a #GDBusActionGroup for the action group which is exported at
 475  * the given @bus_name and @object_path.
 476  *
 477  * The thread default main context is taken at the time of this call.
 478  * All signals on the menu model (and any linked models) are reported
 479  * with respect to this context.  All calls on the returned menu model
 480  * (and linked models) must also originate from this same context, with
 481  * the thread default main context unchanged.
 482  *
 483  * This call is non-blocking.  The returned action group may or may not
 484  * already be filled in.  The correct thing to do is connect the signals
 485  * for the action group to monitor for changes and then to call
 486  * g_action_group_list_actions() to get the initial list.
 487  *
 488  * Returns: (transfer full): a #GDBusActionGroup
 489  *
 490  * Since: 2.32
 491  */
 492 GDBusActionGroup *
 493 g_dbus_action_group_get (GDBusConnection *connection,
 494                          const gchar     *bus_name,
 495                          const gchar     *object_path)
 496 {
 497   GDBusActionGroup *group;
 498
 499   group = g_object_new (G_TYPE_DBUS_ACTION_GROUP, NULL);
 500   group->connection = g_object_ref (connection);
 501   group->bus_name = g_strdup (bus_name);
 502   group->object_path = g_strdup (object_path);
 503
 504   return group;
 505 }
 506
 507 gboolean
 508 g_dbus_action_group_sync (GDBusActionGroup  *group,
 509                           GCancellable      *cancellable,
 510                           GError           **error)
 511 {
 512   GVariant *reply;
 513
 514   g_assert (group->subscription_id == 0);
 515
 516   group->subscription_id =
 517     g_dbus_connection_signal_subscribe (group->connection, group->bus_name, "org.gtk.Actions", "Changed", group->object_path,
 518                                         NULL, G_DBUS_SIGNAL_FLAGS_NONE, g_dbus_action_group_changed, group, NULL);
 519
 520   reply = g_dbus_connection_call_sync (group->connection, group->bus_name, group->object_path, "org.gtk.Actions",
 521                                        "DescribeAll", NULL, G_VARIANT_TYPE ("(a{s(bgav)})"),
 522                                        G_DBUS_CALL_FLAGS_NONE, -1, cancellable, error);
 523
 524   if (reply != NULL)
 525     {
 526       GVariantIter *iter;
 527       ActionInfo *action;
 528
 529       g_assert (group->actions == NULL);
 530       group->actions = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, action_info_free);
 531
 532       g_variant_get (reply, "(a{s(bgav)})", &iter);
 533       while ((action = action_info_new_from_iter (iter)))
 534         g_hash_table_insert (group->actions, action->name, action);
 535       g_variant_iter_free (iter);
 536       g_variant_unref (reply);
 537     }
 538
 539   return reply != NULL;
 540 }