| /* |
| * Copyright © 2013 Lars Uebernickel |
| * |
| * SPDX-License-Identifier: LGPL-2.1-or-later |
| * |
| * 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: Lars Uebernickel <lars@uebernic.de> |
| */ |
| |
| #include "config.h" |
| |
| #include "gnotification-private.h" |
| #include "gdbusutils.h" |
| #include "gicon.h" |
| #include "gaction.h" |
| #include "gioenumtypes.h" |
| |
| /** |
| * GNotification: |
| * |
| * `GNotification` is a mechanism for creating a notification to be shown |
| * to the user — typically as a pop-up notification presented by the |
| * desktop environment shell. |
| * |
| * The key difference between `GNotification` and other similar APIs is |
| * that, if supported by the desktop environment, notifications sent |
| * with `GNotification` will persist after the application has exited, |
| * and even across system reboots. |
| * |
| * Since the user may click on a notification while the application is |
| * not running, applications using `GNotification` should be able to be |
| * started as a D-Bus service, using [class@Gio.Application]. |
| * |
| * In order for `GNotification` to work, the application must have installed |
| * a `.desktop` file. For example: |
| * ``` |
| * [Desktop Entry] |
| * Name=Test Application |
| * Comment=Description of what Test Application does |
| * Exec=gnome-test-application |
| * Icon=org.gnome.TestApplication |
| * Terminal=false |
| * Type=Application |
| * Categories=GNOME;GTK;TestApplication Category; |
| * StartupNotify=true |
| * DBusActivatable=true |
| * X-GNOME-UsesNotifications=true |
| * ``` |
| * |
| * The `X-GNOME-UsesNotifications` key indicates to GNOME Control Center |
| * that this application uses notifications, so it can be listed in the |
| * Control Center’s ‘Notifications’ panel. |
| * |
| * The `.desktop` file must be named as `org.gnome.TestApplication.desktop`, |
| * where `org.gnome.TestApplication` is the ID passed to |
| * [ctor@Gio.Application.new]. |
| * |
| * User interaction with a notification (either the default action, or |
| * buttons) must be associated with actions on the application (ie: |
| * `app.` actions). It is not possible to route user interaction |
| * through the notification itself, because the object will not exist if |
| * the application is autostarted as a result of a notification being |
| * clicked. |
| * |
| * A notification can be sent with [method@Gio.Application.send_notification]. |
| * |
| * Since: 2.40 |
| **/ |
| |
| typedef GObjectClass GNotificationClass; |
| |
| struct _GNotification |
| { |
| GObject parent; |
| |
| gchar *title; |
| gchar *body; |
| GIcon *icon; |
| GNotificationPriority priority; |
| gchar *category; |
| GPtrArray *buttons; |
| gchar *default_action; |
| GVariant *default_action_target; /* (nullable) (owned), not floating */ |
| }; |
| |
| typedef struct |
| { |
| gchar *label; |
| gchar *action_name; |
| GVariant *target; |
| } Button; |
| |
| G_DEFINE_TYPE (GNotification, g_notification, G_TYPE_OBJECT) |
| |
| static void |
| button_free (gpointer data) |
| { |
| Button *button = data; |
| |
| g_free (button->label); |
| g_free (button->action_name); |
| if (button->target) |
| g_variant_unref (button->target); |
| |
| g_slice_free (Button, button); |
| } |
| |
| static void |
| g_notification_dispose (GObject *object) |
| { |
| GNotification *notification = G_NOTIFICATION (object); |
| |
| g_clear_object (¬ification->icon); |
| |
| G_OBJECT_CLASS (g_notification_parent_class)->dispose (object); |
| } |
| |
| static void |
| g_notification_finalize (GObject *object) |
| { |
| GNotification *notification = G_NOTIFICATION (object); |
| |
| g_free (notification->title); |
| g_free (notification->body); |
| g_free (notification->category); |
| g_free (notification->default_action); |
| if (notification->default_action_target) |
| g_variant_unref (notification->default_action_target); |
| g_ptr_array_free (notification->buttons, TRUE); |
| |
| G_OBJECT_CLASS (g_notification_parent_class)->finalize (object); |
| } |
| |
| static void |
| g_notification_class_init (GNotificationClass *klass) |
| { |
| GObjectClass *object_class = G_OBJECT_CLASS (klass); |
| |
| object_class->dispose = g_notification_dispose; |
| object_class->finalize = g_notification_finalize; |
| } |
| |
| static void |
| g_notification_init (GNotification *notification) |
| { |
| notification->buttons = g_ptr_array_new_full (2, button_free); |
| } |
| |
| /** |
| * g_notification_new: |
| * @title: the title of the notification |
| * |
| * Creates a new #GNotification with @title as its title. |
| * |
| * After populating @notification with more details, it can be sent to |
| * the desktop shell with g_application_send_notification(). Changing |
| * any properties after this call will not have any effect until |
| * resending @notification. |
| * |
| * Returns: a new #GNotification instance |
| * |
| * Since: 2.40 |
| */ |
| GNotification * |
| g_notification_new (const gchar *title) |
| { |
| GNotification *notification; |
| |
| g_return_val_if_fail (title != NULL, NULL); |
| |
| notification = g_object_new (G_TYPE_NOTIFICATION, NULL); |
| notification->title = g_strdup (title); |
| |
| return notification; |
| } |
| |
| /*< private > |
| * g_notification_get_title: |
| * @notification: a #GNotification |
| * |
| * Gets the title of @notification. |
| * |
| * Returns: the title of @notification |
| * |
| * Since: 2.40 |
| */ |
| const gchar * |
| g_notification_get_title (GNotification *notification) |
| { |
| g_return_val_if_fail (G_IS_NOTIFICATION (notification), NULL); |
| |
| return notification->title; |
| } |
| |
| /** |
| * g_notification_set_title: |
| * @notification: a #GNotification |
| * @title: the new title for @notification |
| * |
| * Sets the title of @notification to @title. |
| * |
| * Since: 2.40 |
| */ |
| void |
| g_notification_set_title (GNotification *notification, |
| const gchar *title) |
| { |
| g_return_if_fail (G_IS_NOTIFICATION (notification)); |
| g_return_if_fail (title != NULL); |
| |
| g_free (notification->title); |
| |
| notification->title = g_strdup (title); |
| } |
| |
| /*< private > |
| * g_notification_get_body: |
| * @notification: a #GNotification |
| * |
| * Gets the current body of @notification. |
| * |
| * Returns: (nullable): the body of @notification |
| * |
| * Since: 2.40 |
| */ |
| const gchar * |
| g_notification_get_body (GNotification *notification) |
| { |
| g_return_val_if_fail (G_IS_NOTIFICATION (notification), NULL); |
| |
| return notification->body; |
| } |
| |
| /** |
| * g_notification_set_body: |
| * @notification: a #GNotification |
| * @body: (nullable): the new body for @notification, or %NULL |
| * |
| * Sets the body of @notification to @body. |
| * |
| * Since: 2.40 |
| */ |
| void |
| g_notification_set_body (GNotification *notification, |
| const gchar *body) |
| { |
| g_return_if_fail (G_IS_NOTIFICATION (notification)); |
| g_return_if_fail (body != NULL); |
| |
| g_free (notification->body); |
| |
| notification->body = g_strdup (body); |
| } |
| |
| /*< private > |
| * g_notification_get_icon: |
| * @notification: a #GNotification |
| * |
| * Gets the icon currently set on @notification. |
| * |
| * Returns: (transfer none): the icon associated with @notification |
| * |
| * Since: 2.40 |
| */ |
| GIcon * |
| g_notification_get_icon (GNotification *notification) |
| { |
| g_return_val_if_fail (G_IS_NOTIFICATION (notification), NULL); |
| |
| return notification->icon; |
| } |
| |
| /** |
| * g_notification_set_icon: |
| * @notification: a #GNotification |
| * @icon: the icon to be shown in @notification, as a #GIcon |
| * |
| * Sets the icon of @notification to @icon. |
| * |
| * Since: 2.40 |
| */ |
| void |
| g_notification_set_icon (GNotification *notification, |
| GIcon *icon) |
| { |
| g_return_if_fail (G_IS_NOTIFICATION (notification)); |
| |
| if (notification->icon) |
| g_object_unref (notification->icon); |
| |
| notification->icon = g_object_ref (icon); |
| } |
| |
| /*< private > |
| * g_notification_get_priority: |
| * @notification: a #GNotification |
| * |
| * Returns the priority of @notification |
| * |
| * Since: 2.42 |
| */ |
| GNotificationPriority |
| g_notification_get_priority (GNotification *notification) |
| { |
| g_return_val_if_fail (G_IS_NOTIFICATION (notification), G_NOTIFICATION_PRIORITY_NORMAL); |
| |
| return notification->priority; |
| } |
| |
| /** |
| * g_notification_set_urgent: |
| * @notification: a #GNotification |
| * @urgent: %TRUE if @notification is urgent |
| * |
| * Deprecated in favor of g_notification_set_priority(). |
| * |
| * Since: 2.40 |
| * Deprecated: 2.42: Since 2.42, this has been deprecated in favour of |
| * g_notification_set_priority(). |
| */ |
| void |
| g_notification_set_urgent (GNotification *notification, |
| gboolean urgent) |
| { |
| g_return_if_fail (G_IS_NOTIFICATION (notification)); |
| |
| notification->priority = urgent ? |
| G_NOTIFICATION_PRIORITY_URGENT : |
| G_NOTIFICATION_PRIORITY_NORMAL; |
| } |
| |
| /*< private > |
| * g_notification_get_category: |
| * @notification: a #GNotification |
| * |
| * Gets the category of @notification. |
| * |
| * This will be %NULL if no category is set. |
| * |
| * Returns: (nullable): the category of @notification |
| * |
| * Since: 2.70 |
| */ |
| const gchar * |
| g_notification_get_category (GNotification *notification) |
| { |
| g_return_val_if_fail (G_IS_NOTIFICATION (notification), NULL); |
| |
| return notification->category; |
| } |
| |
| /** |
| * g_notification_set_category: |
| * @notification: a #GNotification |
| * @category: (nullable): the category for @notification, or %NULL for no category |
| * |
| * Sets the type of @notification to @category. Categories have a main |
| * type like `email`, `im` or `device` and can have a detail separated |
| * by a `.`, e.g. `im.received` or `email.arrived`. Setting the category |
| * helps the notification server to select proper feedback to the user. |
| * |
| * Standard categories are [listed in the specification](https://specifications.freedesktop.org/notification-spec/latest/ar01s06.html). |
| * |
| * Since: 2.70 |
| */ |
| void |
| g_notification_set_category (GNotification *notification, |
| const gchar *category) |
| { |
| g_return_if_fail (G_IS_NOTIFICATION (notification)); |
| g_return_if_fail (category == NULL || *category != '\0'); |
| |
| g_free (notification->category); |
| |
| notification->category = g_strdup (category); |
| } |
| |
| /** |
| * g_notification_set_priority: |
| * @notification: a #GNotification |
| * @priority: a #GNotificationPriority |
| * |
| * Sets the priority of @notification to @priority. See |
| * #GNotificationPriority for possible values. |
| */ |
| void |
| g_notification_set_priority (GNotification *notification, |
| GNotificationPriority priority) |
| { |
| g_return_if_fail (G_IS_NOTIFICATION (notification)); |
| |
| notification->priority = priority; |
| } |
| |
| /** |
| * g_notification_add_button: |
| * @notification: a #GNotification |
| * @label: label of the button |
| * @detailed_action: a detailed action name |
| * |
| * Adds a button to @notification that activates the action in |
| * @detailed_action when clicked. That action must be an |
| * application-wide action (starting with "app."). If @detailed_action |
| * contains a target, the action will be activated with that target as |
| * its parameter. |
| * |
| * See g_action_parse_detailed_name() for a description of the format |
| * for @detailed_action. |
| * |
| * Since: 2.40 |
| */ |
| void |
| g_notification_add_button (GNotification *notification, |
| const gchar *label, |
| const gchar *detailed_action) |
| { |
| gchar *action; |
| GVariant *target; |
| GError *error = NULL; |
| |
| g_return_if_fail (detailed_action != NULL); |
| |
| if (!g_action_parse_detailed_name (detailed_action, &action, &target, &error)) |
| { |
| g_warning ("%s: %s", G_STRFUNC, error->message); |
| g_error_free (error); |
| return; |
| } |
| |
| g_notification_add_button_with_target_value (notification, label, action, target); |
| |
| g_free (action); |
| if (target) |
| g_variant_unref (target); |
| } |
| |
| /** |
| * g_notification_add_button_with_target: (skip) |
| * @notification: a #GNotification |
| * @label: label of the button |
| * @action: an action name |
| * @target_format: (nullable): a #GVariant format string, or %NULL |
| * @...: positional parameters, as determined by @target_format |
| * |
| * Adds a button to @notification that activates @action when clicked. |
| * @action must be an application-wide action (it must start with "app."). |
| * |
| * If @target_format is given, it is used to collect remaining |
| * positional parameters into a #GVariant instance, similar to |
| * g_variant_new(). @action will be activated with that #GVariant as its |
| * parameter. |
| * |
| * Since: 2.40 |
| */ |
| void |
| g_notification_add_button_with_target (GNotification *notification, |
| const gchar *label, |
| const gchar *action, |
| const gchar *target_format, |
| ...) |
| { |
| va_list args; |
| GVariant *target = NULL; |
| |
| if (target_format) |
| { |
| va_start (args, target_format); |
| target = g_variant_new_va (target_format, NULL, &args); |
| va_end (args); |
| } |
| |
| g_notification_add_button_with_target_value (notification, label, action, target); |
| } |
| |
| /** |
| * g_notification_add_button_with_target_value: (rename-to g_notification_add_button_with_target) |
| * @notification: a #GNotification |
| * @label: label of the button |
| * @action: an action name |
| * @target: (nullable): a #GVariant to use as @action's parameter, or %NULL |
| * |
| * Adds a button to @notification that activates @action when clicked. |
| * @action must be an application-wide action (it must start with "app."). |
| * |
| * If @target is non-%NULL, @action will be activated with @target as |
| * its parameter. |
| * |
| * Since: 2.40 |
| */ |
| void |
| g_notification_add_button_with_target_value (GNotification *notification, |
| const gchar *label, |
| const gchar *action, |
| GVariant *target) |
| { |
| Button *button; |
| |
| g_return_if_fail (G_IS_NOTIFICATION (notification)); |
| g_return_if_fail (label != NULL); |
| g_return_if_fail (action != NULL && g_action_name_is_valid (action)); |
| |
| if (!g_str_has_prefix (action, "app.")) |
| { |
| g_warning ("%s: action '%s' does not start with 'app.'." |
| "This is unlikely to work properly.", G_STRFUNC, action); |
| } |
| |
| button = g_slice_new0 (Button); |
| button->label = g_strdup (label); |
| button->action_name = g_strdup (action); |
| |
| if (target) |
| button->target = g_variant_ref_sink (target); |
| |
| g_ptr_array_add (notification->buttons, button); |
| } |
| |
| /*< private > |
| * g_notification_get_n_buttons: |
| * @notification: a #GNotification |
| * |
| * Returns: the amount of buttons added to @notification. |
| */ |
| guint |
| g_notification_get_n_buttons (GNotification *notification) |
| { |
| return notification->buttons->len; |
| } |
| |
| /*< private > |
| * g_notification_get_button: |
| * @notification: a #GNotification |
| * @index: index of the button |
| * @label: (): return location for the button's label |
| * @action: (): return location for the button's associated action |
| * @target: (): return location for the target @action should be |
| * activated with |
| * |
| * Returns a description of a button that was added to @notification |
| * with g_notification_add_button(). |
| * |
| * @index must be smaller than the value returned by |
| * g_notification_get_n_buttons(). |
| */ |
| void |
| g_notification_get_button (GNotification *notification, |
| gint index, |
| gchar **label, |
| gchar **action, |
| GVariant **target) |
| { |
| Button *button; |
| |
| button = g_ptr_array_index (notification->buttons, index); |
| |
| if (label) |
| *label = g_strdup (button->label); |
| |
| if (action) |
| *action = g_strdup (button->action_name); |
| |
| if (target) |
| *target = button->target ? g_variant_ref (button->target) : NULL; |
| } |
| |
| /*< private > |
| * g_notification_get_button_with_action: |
| * @notification: a #GNotification |
| * @action: an action name |
| * |
| * Returns the index of the button in @notification that is associated |
| * with @action, or -1 if no such button exists. |
| */ |
| gint |
| g_notification_get_button_with_action (GNotification *notification, |
| const gchar *action) |
| { |
| guint i; |
| |
| for (i = 0; i < notification->buttons->len; i++) |
| { |
| Button *button; |
| |
| button = g_ptr_array_index (notification->buttons, i); |
| if (g_str_equal (action, button->action_name)) |
| return i; |
| } |
| |
| return -1; |
| } |
| |
| |
| /*< private > |
| * g_notification_get_default_action: |
| * @notification: a #GNotification |
| * @action: (out) (optional) (nullable) (transfer full): return location for the |
| * default action, or %NULL if unset |
| * @target: (out) (optional) (nullable) (transfer full): return location for the |
| * target of the default action, or %NULL if unset |
| * |
| * Gets the action and target for the default action of @notification. |
| * |
| * If this function returns %TRUE, @action is guaranteed to be set to a non-%NULL |
| * value (if a pointer is passed to @action). @target may still return a %NULL |
| * value, as the default action may have no target. |
| * |
| * Returns: %TRUE if @notification has a default action |
| */ |
| gboolean |
| g_notification_get_default_action (GNotification *notification, |
| gchar **action, |
| GVariant **target) |
| { |
| if (notification->default_action == NULL) |
| return FALSE; |
| |
| if (action) |
| *action = g_strdup (notification->default_action); |
| |
| if (target) |
| { |
| if (notification->default_action_target) |
| *target = g_variant_ref (notification->default_action_target); |
| else |
| *target = NULL; |
| } |
| |
| return TRUE; |
| } |
| |
| /** |
| * g_notification_set_default_action: |
| * @notification: a #GNotification |
| * @detailed_action: a detailed action name |
| * |
| * Sets the default action of @notification to @detailed_action. This |
| * action is activated when the notification is clicked on. |
| * |
| * The action in @detailed_action must be an application-wide action (it |
| * must start with "app."). If @detailed_action contains a target, the |
| * given action will be activated with that target as its parameter. |
| * See g_action_parse_detailed_name() for a description of the format |
| * for @detailed_action. |
| * |
| * When no default action is set, the application that the notification |
| * was sent on is activated. |
| * |
| * Since: 2.40 |
| */ |
| void |
| g_notification_set_default_action (GNotification *notification, |
| const gchar *detailed_action) |
| { |
| gchar *action; |
| GVariant *target; |
| GError *error = NULL; |
| |
| if (!g_action_parse_detailed_name (detailed_action, &action, &target, &error)) |
| { |
| g_warning ("%s: %s", G_STRFUNC, error->message); |
| g_error_free (error); |
| return; |
| } |
| |
| g_notification_set_default_action_and_target_value (notification, action, target); |
| |
| g_free (action); |
| if (target) |
| g_variant_unref (target); |
| } |
| |
| /** |
| * g_notification_set_default_action_and_target: (skip) |
| * @notification: a #GNotification |
| * @action: an action name |
| * @target_format: (nullable): a #GVariant format string, or %NULL |
| * @...: positional parameters, as determined by @target_format |
| * |
| * Sets the default action of @notification to @action. This action is |
| * activated when the notification is clicked on. It must be an |
| * application-wide action (it must start with "app."). |
| * |
| * If @target_format is given, it is used to collect remaining |
| * positional parameters into a #GVariant instance, similar to |
| * g_variant_new(). @action will be activated with that #GVariant as its |
| * parameter. |
| * |
| * When no default action is set, the application that the notification |
| * was sent on is activated. |
| * |
| * Since: 2.40 |
| */ |
| void |
| g_notification_set_default_action_and_target (GNotification *notification, |
| const gchar *action, |
| const gchar *target_format, |
| ...) |
| { |
| va_list args; |
| GVariant *target = NULL; |
| |
| if (target_format) |
| { |
| va_start (args, target_format); |
| target = g_variant_new_va (target_format, NULL, &args); |
| va_end (args); |
| } |
| |
| g_notification_set_default_action_and_target_value (notification, action, target); |
| } |
| |
| /** |
| * g_notification_set_default_action_and_target_value: (rename-to g_notification_set_default_action_and_target) |
| * @notification: a #GNotification |
| * @action: an action name |
| * @target: (nullable): a #GVariant to use as @action's parameter, or %NULL |
| * |
| * Sets the default action of @notification to @action. This action is |
| * activated when the notification is clicked on. It must be an |
| * application-wide action (start with "app."). |
| * |
| * If @target is non-%NULL, @action will be activated with @target as |
| * its parameter. If @target is floating, it will be consumed. |
| * |
| * When no default action is set, the application that the notification |
| * was sent on is activated. |
| * |
| * Since: 2.40 |
| */ |
| void |
| g_notification_set_default_action_and_target_value (GNotification *notification, |
| const gchar *action, |
| GVariant *target) |
| { |
| g_return_if_fail (G_IS_NOTIFICATION (notification)); |
| g_return_if_fail (action != NULL && g_action_name_is_valid (action)); |
| |
| if (!g_str_has_prefix (action, "app.")) |
| { |
| g_warning ("%s: action '%s' does not start with 'app.'." |
| "This is unlikely to work properly.", G_STRFUNC, action); |
| } |
| |
| g_free (notification->default_action); |
| g_clear_pointer (¬ification->default_action_target, g_variant_unref); |
| |
| notification->default_action = g_strdup (action); |
| |
| if (target) |
| notification->default_action_target = g_variant_ref_sink (target); |
| } |
| |
| static GVariant * |
| g_notification_serialize_button (Button *button) |
| { |
| GVariantBuilder builder; |
| |
| g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); |
| |
| g_variant_builder_add (&builder, "{sv}", "label", g_variant_new_string (button->label)); |
| g_variant_builder_add (&builder, "{sv}", "action", g_variant_new_string (button->action_name)); |
| |
| if (button->target) |
| g_variant_builder_add (&builder, "{sv}", "target", button->target); |
| |
| return g_variant_builder_end (&builder); |
| } |
| |
| static GVariant * |
| g_notification_get_priority_nick (GNotification *notification) |
| { |
| GEnumClass *enum_class; |
| GEnumValue *value; |
| GVariant *nick; |
| |
| enum_class = g_type_class_ref (G_TYPE_NOTIFICATION_PRIORITY); |
| value = g_enum_get_value (enum_class, g_notification_get_priority (notification)); |
| g_assert (value != NULL); |
| nick = g_variant_new_string (value->value_nick); |
| g_type_class_unref (enum_class); |
| |
| return nick; |
| } |
| |
| /*< private > |
| * g_notification_serialize: |
| * |
| * Serializes @notification into a floating variant of type a{sv}. |
| * |
| * Returns: the serialized @notification as a floating variant. |
| */ |
| GVariant * |
| g_notification_serialize (GNotification *notification) |
| { |
| GVariantBuilder builder; |
| |
| g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}")); |
| |
| if (notification->title) |
| g_variant_builder_add (&builder, "{sv}", "title", g_variant_new_string (notification->title)); |
| |
| if (notification->body) |
| g_variant_builder_add (&builder, "{sv}", "body", g_variant_new_string (notification->body)); |
| |
| if (notification->icon) |
| { |
| GVariant *serialized_icon; |
| |
| if ((serialized_icon = g_icon_serialize (notification->icon))) |
| { |
| g_variant_builder_add (&builder, "{sv}", "icon", serialized_icon); |
| g_variant_unref (serialized_icon); |
| } |
| } |
| |
| g_variant_builder_add (&builder, "{sv}", "priority", g_notification_get_priority_nick (notification)); |
| |
| if (notification->default_action) |
| { |
| g_variant_builder_add (&builder, "{sv}", "default-action", |
| g_variant_new_string (notification->default_action)); |
| |
| if (notification->default_action_target) |
| g_variant_builder_add (&builder, "{sv}", "default-action-target", |
| notification->default_action_target); |
| } |
| |
| if (notification->buttons->len > 0) |
| { |
| GVariantBuilder actions_builder; |
| guint i; |
| |
| g_variant_builder_init (&actions_builder, G_VARIANT_TYPE ("aa{sv}")); |
| |
| for (i = 0; i < notification->buttons->len; i++) |
| { |
| Button *button = g_ptr_array_index (notification->buttons, i); |
| g_variant_builder_add (&actions_builder, "@a{sv}", g_notification_serialize_button (button)); |
| } |
| |
| g_variant_builder_add (&builder, "{sv}", "buttons", g_variant_builder_end (&actions_builder)); |
| } |
| |
| return g_variant_builder_end (&builder); |
| } |