Coverage Report

Created: 2025-07-23 08:13

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