static gboolean
emit_notifications_in_idle (gpointer user_data)
{
GObject *object = G_OBJECT (user_data);
GDBusConnection *connection;
const gchar *path;
GHashTable *notification_queue;
GHashTableIter iter;
const gchar *property_name;
GVariant *value;
GVariantBuilder *builder;
GVariantBuilder *invalidated_builder;
GHashTable *pvc;
gboolean has_changes;
notification_queue = g_object_get_data (object, "gdbus-codegen-notification-queue");
path = g_object_get_data (object, "gdbus-codegen-path");
connection = g_object_get_data (object, "gdbus-codegen-connection");
pvc = g_object_get_data (object, "gdbus-codegen-pvc");
g_assert (notification_queue != NULL && path != NULL && connection != NULL && pvc != NULL);
builder = g_variant_builder_new (G_VARIANT_TYPE_ARRAY);
invalidated_builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
g_hash_table_iter_init (&iter, notification_queue);
has_changes = FALSE;
while (g_hash_table_iter_next (&iter, (gpointer) &property_name, (gpointer) &value))
{
GVariant *cached_value;
cached_value = g_hash_table_lookup (pvc, property_name);
if (cached_value == NULL || !g_variant_equal (cached_value, value))
{
g_hash_table_insert (pvc, (gpointer) property_name, (gpointer) g_variant_ref (value));
g_variant_builder_add (builder, "{sv}", property_name, value);
has_changes = TRUE;
}
}
if (has_changes)
{
g_dbus_connection_emit_signal (connection,
NULL,
path,
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
g_variant_new ("(sa{sv}as)",
"org.gnome.evolution.dataserver.CalendarFactory",
builder,
invalidated_builder),
NULL);
}
else
{
g_variant_builder_unref (builder);
g_variant_builder_unref (invalidated_builder);
}
g_hash_table_remove_all (notification_queue);
g_object_set_data (object, "gdbus-codegen-notification-idle-id", GUINT_TO_POINTER (0));
return FALSE;
}
static void
gb_color_picker_prefs_palette_row_changed (GbColorPickerPrefsPaletteRow *self,
const gchar *key,
GSettings *settings)
{
g_autoptr (GVariant) value = NULL;
gboolean active;
g_assert (GB_IS_COLOR_PICKER_PREFS_PALETTE_ROW (self));
g_assert (key != NULL);
g_assert (G_IS_SETTINGS (settings));
if (self->target == NULL)
{
gtk_widget_set_visible (GTK_WIDGET (self->image), FALSE);
return;
}
if (self->updating == TRUE)
return;
value = g_settings_get_value (settings, key);
if (g_variant_is_of_type (value, g_variant_get_type (self->target)))
{
active = (g_variant_equal (value, self->target));
gtk_widget_set_visible (GTK_WIDGET (self->image), active);
}
else
g_warning ("Value and target must be of the same type");
}
static void
gb_color_picker_prefs_palette_row_activate (GbColorPickerPrefsPaletteRow *self)
{
g_autoptr (GVariant) value = NULL;
g_assert (GB_IS_COLOR_PICKER_PREFS_PALETTE_ROW (self));
g_assert (self->target != NULL);
if (!gtk_widget_get_sensitive (GTK_WIDGET (self)) || self->settings == NULL || self->updating)
return;
value = g_settings_get_value (self->settings, self->key);
if (g_variant_is_of_type (value, g_variant_get_type (self->target)))
{
if (!g_variant_equal (value, self->target))
{
self->updating = TRUE;
g_settings_set_value (self->settings, self->key, self->target);
gtk_widget_set_visible (GTK_WIDGET (self->image), TRUE);
self->updating = FALSE;
}
}
else
g_warning ("Value and target must be of the same type");
}
static void
g_simple_action_set_state (GAction *action,
GVariant *value)
{
GSimpleAction *simple = G_SIMPLE_ACTION (action);
g_return_if_fail (value != NULL);
{
const GVariantType *state_type;
state_type = simple->priv->state ?
g_variant_get_type (simple->priv->state) : NULL;
g_return_if_fail (state_type != NULL);
g_return_if_fail (g_variant_is_of_type (value, state_type));
}
g_variant_ref_sink (value);
if (!g_variant_equal (simple->priv->state, value))
{
if (simple->priv->state)
g_variant_unref (simple->priv->state);
simple->priv->state = g_variant_ref (value);
g_object_notify (G_OBJECT (simple), "state");
}
g_variant_unref (value);
}
void deja_dup_simple_settings_set_value (DejaDupSimpleSettings* self, const gchar* k, GVariant* v) {
const gchar* _tmp0_;
GVariant* _tmp1_ = NULL;
GVariant* _tmp2_;
GVariant* _tmp3_;
gboolean _tmp4_ = FALSE;
gboolean _tmp5_;
g_return_if_fail (self != NULL);
g_return_if_fail (k != NULL);
g_return_if_fail (v != NULL);
_tmp0_ = k;
_tmp1_ = g_settings_get_value ((GSettings*) self, _tmp0_);
_tmp2_ = _tmp1_;
_tmp3_ = v;
_tmp4_ = g_variant_equal (_tmp2_, _tmp3_);
_tmp5_ = !_tmp4_;
_g_variant_unref0 (_tmp2_);
if (_tmp5_) {
const gchar* _tmp6_;
GVariant* _tmp7_;
_tmp6_ = k;
_tmp7_ = v;
g_settings_set_value (G_SETTINGS (self), _tmp6_, _tmp7_);
}
}
static int EscalateTestMockHelperProcess(int stdin_fd, int stdout_fd) {
GIOChannel *stdin_stream = g_io_channel_unix_new(stdin_fd);
GIOChannel *stdout_stream = g_io_channel_unix_new(stdout_fd);
GError *error = NULL;
gboolean success = FALSE;
g_assert(mock_helper_expected_messages);
g_assert(mock_helper_response_messages);
for (guint i = 0; i < g_strv_length(mock_helper_expected_messages); i++) {
EscalateMessage *expected = NULL;
EscalateMessage *message = NULL;
EscalateMessage *response = NULL;
expected = EscalateMessageLoad(mock_helper_expected_messages[i], &error);
g_assert_no_error(error);
g_assert(expected);
message = EscalateMessageRead(stdin_stream, &error);
g_assert_no_error(error);
g_assert(message);
if (mock_helper_response_messages[i]) {
response = EscalateMessageLoad(mock_helper_response_messages[i], &error);
g_assert_no_error(error);
g_assert(response);
}
g_assert_cmpint(expected->type, ==, message->type);
if (!g_variant_equal(expected->values, message->values)) {
gchar *variant_str = g_variant_print(expected->values, FALSE);
g_message("Expected: %s", variant_str);
g_free(variant_str);
variant_str = g_variant_print(message->values, FALSE);
g_message("Got: %s", variant_str);
g_free(variant_str);
g_error("Message values didn't match what was expected");
}
if (response) {
success = EscalateMessageWrite(response, stdout_stream, &error);
g_assert_no_error(error);
g_assert(success);
EscalateMessageUnref(response);
}
EscalateMessageUnref(expected);
EscalateMessageUnref(message);
}
g_io_channel_shutdown(stdin_stream, FALSE, NULL);
g_io_channel_shutdown(stdout_stream, FALSE, NULL);
g_io_channel_unref(stdin_stream);
g_io_channel_unref(stdout_stream);
return 0;
}
static void AssertMessage(GIOChannel *channel, const gchar *expected_str) {
GError *error = NULL;
EscalateMessage *expected = EscalateMessageLoad(expected_str, &error);
g_assert_no_error(error);
g_assert(expected);
EscalateMessage *message = EscalateMessageRead(channel, &error);
g_assert_no_error(error);
g_assert(message);
g_assert_cmpint(expected->type, ==, message->type);
g_assert(g_variant_equal(expected->values, message->values));
EscalateMessageUnref(expected);
EscalateMessageUnref(message);
}
static gboolean
_g_variant_equal0 (GVariant *a, GVariant *b)
{
gboolean ret = FALSE;
if (a == NULL && b == NULL)
{
ret = TRUE;
goto out;
}
if (a == NULL || b == NULL)
goto out;
ret = g_variant_equal (a, b);
out:
return ret;
}
static gboolean
check_single_value_domain(GVariant *value,
GVariant *domain)
{
gsize array_len = g_variant_n_children(domain);
gboolean equal = FALSE;
gsize iter;
for (iter = 0; iter < array_len && !equal; ++iter) {
GVariant *child = g_variant_get_child_value(domain, iter);
equal = g_variant_equal(value, child);
g_variant_unref(child);
}
return equal;
}
static void TestLoad(gconstpointer user_data) {
guint index = GPOINTER_TO_UINT(user_data);
GError *error = NULL;
GVariant *expected_values = CreateExampleMessageValues(index);
EscalateMessage *message = EscalateMessageLoad(example_messages[index],
&error);
g_assert_no_error(error);
g_assert(message);
g_assert_cmpint(EscalateMessageGetType(message), ==,
example_message_types[index]);
g_assert(g_variant_equal(expected_values, message->values));
g_variant_unref(expected_values);
EscalateMessageUnref(message);
}
void
gth_window_change_action_state (GthWindow *window,
const char *action_name,
gboolean value)
{
GAction *action;
GVariant *old_state;
GVariant *new_state;
action = g_action_map_lookup_action (G_ACTION_MAP (window), action_name);
g_return_if_fail (action != NULL);
old_state = g_action_get_state (action);
new_state = g_variant_new_boolean (value);
if ((old_state == NULL) || ! g_variant_equal (old_state, new_state))
g_action_change_state (action, new_state);
if (old_state != NULL)
g_variant_unref (old_state);
}
static void
remember_config_inlock (StorageProvider *provider,
const gchar *parent_path,
const gchar *child_path,
GVariant *config)
{
GHashTable *child_configs = g_hash_table_lookup (provider->remembered_configs, parent_path);
if (child_configs == NULL)
{
child_configs = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify)g_variant_unref);
g_hash_table_insert (provider->remembered_configs, g_strdup (parent_path), child_configs);
}
GVariant *old = g_hash_table_lookup (child_configs, child_path);
if (old == NULL || !g_variant_equal (old, config))
{
g_hash_table_insert (child_configs, g_strdup (child_path), g_variant_ref (config));
provider->remembered_configs_need_save = TRUE;
}
}
static void
mtn_connman_service_handle_new_property (MtnConnmanService *service,
char *key,
GVariant *value)
{
GVariant *old_value;
old_value = g_hash_table_lookup (service->priv->properties, key);
if (!old_value || !g_variant_equal (value, old_value)) {
char *name;
g_hash_table_insert (service->priv->properties,
key, value);
/* emit changed signal*/
name = g_strdup_printf ("property-changed::%s", key);
g_signal_emit_by_name (service, name, value);
g_free (name);
}
}
static void TestNew(gconstpointer user_data) {
guint index = GPOINTER_TO_UINT(user_data);
GVariantBuilder items;
GVariantBuilder env;
EscalateMessage *message = NULL;
GVariant *expected_values = CreateExampleMessageValues(index);
switch (index) {
case 0:
g_variant_builder_init(&items, G_VARIANT_TYPE_ARRAY);
g_variant_builder_add(&items, "{ims}", 2, "testuser");
g_variant_builder_init(&env, G_VARIANT_TYPE_ARRAY);
g_variant_builder_add(&env, "{ss}", "PATH", "/path");
message = EscalateMessageNew(ESCALATE_MESSAGE_TYPE_START, 1, 0,
"testuser", &items, &env);
break;
case 1:
message = EscalateMessageNew(ESCALATE_MESSAGE_TYPE_CONV_MESSAGE, 1,
"Password: "******"testpass", 0);
break;
case 3:
g_variant_builder_init(&env, G_VARIANT_TYPE_ARRAY);
g_variant_builder_add(&env, "{ss}", "PATH", "/path");
message = EscalateMessageNew(ESCALATE_MESSAGE_TYPE_FINISH, 0, &env);
break;
default:
g_error("No message available for index %d", index);
}
g_assert(message);
g_assert_cmpint(EscalateMessageGetType(message), ==,
example_message_types[index]);
g_assert(g_variant_equal(expected_values, message->values));
EscalateMessageUnref(message);
g_variant_unref(expected_values);
}
static void
mtn_connman_service_handle_new_property (MtnConnmanService *service,
char *key,
GVariant *value)
{
GVariant *old_value;
old_value = g_hash_table_lookup (service->priv->properties, key);
if (!old_value || !g_variant_equal (value, old_value)) {
char *name;
/* must use _replace here, since we need the key around afterwards */
g_hash_table_replace (service->priv->properties,
key, value);
/* emit changed signal*/
name = g_strdup_printf ("property-changed::%s", key);
g_signal_emit_by_name (service, name, value);
g_free (name);
}
}
static void TestRead(gconstpointer user_data) {
guint index = GPOINTER_TO_UINT(user_data);
gint fds [] = { 0, 0 };
GIOChannel *reader = NULL;
WriterThreadContext thread_ctx = { NULL, NULL };
GThread *thread = NULL;
GError *error = NULL;
EscalateMessage *message = NULL;
GVariant *expected_values = CreateExampleMessageValues(index);
g_assert(g_unix_open_pipe(fds, 0, NULL));
reader = g_io_channel_unix_new(fds[0]);
thread_ctx.channel = g_io_channel_unix_new(fds[1]);
thread_ctx.contents = example_messages[index];
thread = g_thread_new("Writer", (GThreadFunc) WriterThread, &thread_ctx);
g_assert(thread);
message = EscalateMessageRead(reader, &error);
g_assert_no_error(error);
g_assert(message);
g_assert_cmpint(EscalateMessageGetType(message), ==,
example_message_types[index]);
g_assert(g_variant_equal(expected_values, message->values));
EscalateMessageUnref(message);
message = EscalateMessageRead(reader, &error);
g_assert_error(error, ESCALATE_MESSAGE_ERROR, ESCALATE_MESSAGE_ERROR_EOF);
g_assert(!message);
g_error_free(error);
g_thread_join(thread);
g_variant_unref(expected_values);
g_io_channel_shutdown(reader, FALSE, NULL);
g_io_channel_unref(reader);
g_io_channel_unref(thread_ctx.channel);
}
static void
g_dbus_action_group_changed (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
GDBusActionGroup *group = user_data;
GActionGroup *g_group = user_data;
/* make sure that we've been fully initialised */
if (group->actions == NULL)
return;
if (g_str_equal (signal_name, "Changed") &&
g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(asa{sb}a{sv}a{s(bgav)})")))
{
/* Removes */
{
GVariantIter *iter;
const gchar *name;
g_variant_get_child (parameters, 0, "as", &iter);
while (g_variant_iter_next (iter, "&s", &name))
{
if (g_hash_table_lookup (group->actions, name))
{
g_hash_table_remove (group->actions, name);
g_action_group_action_removed (g_group, name);
}
}
g_variant_iter_free (iter);
}
/* Enable changes */
{
GVariantIter *iter;
const gchar *name;
gboolean enabled;
g_variant_get_child (parameters, 1, "a{sb}", &iter);
while (g_variant_iter_next (iter, "{&sb}", &name, &enabled))
{
ActionInfo *info;
info = g_hash_table_lookup (group->actions, name);
if (info && info->enabled != enabled)
{
info->enabled = enabled;
g_action_group_action_enabled_changed (g_group, name, enabled);
}
}
g_variant_iter_free (iter);
}
/* State changes */
{
GVariantIter *iter;
const gchar *name;
GVariant *state;
g_variant_get_child (parameters, 2, "a{sv}", &iter);
while (g_variant_iter_next (iter, "{&sv}", &name, &state))
{
ActionInfo *info;
info = g_hash_table_lookup (group->actions, name);
if (info && info->state && !g_variant_equal (state, info->state) &&
g_variant_is_of_type (state, g_variant_get_type (info->state)))
{
g_variant_unref (info->state);
info->state = g_variant_ref (state);
g_action_group_action_state_changed (g_group, name, state);
}
g_variant_unref (state);
}
g_variant_iter_free (iter);
}
/* Additions */
{
GVariantIter *iter;
ActionInfo *info;
g_variant_get_child (parameters, 3, "a{s(bgav)}", &iter);
while ((info = action_info_new_from_iter (iter)))
{
if (!g_hash_table_lookup (group->actions, info->name))
{
g_hash_table_insert (group->actions, info->name, info);
if (group->strict)
g_action_group_action_added (g_group, info->name);
}
else
action_info_free (info);
}
g_variant_iter_free (iter);
}
}
}
static void
update_with_variant (GPid pid,
GVariant *info,
GError *error,
gpointer user_data)
{
struct UpdateData *data = user_data;
StorageVolumeGroup *self = data->self;
GVariantIter *iter;
GHashTableIter volume_iter;
gpointer key, value;
GHashTable *new_lvs;
gboolean needs_polling = FALSE;
StorageDaemon *daemon;
gchar *path;
daemon = storage_daemon_get ();
if (!error)
volume_group_update_props (self, info, &needs_polling);
/* After basic props, publish group, if not already done */
if (self->need_publish)
{
self->need_publish = FALSE;
path = storage_util_build_object_path ("/org/freedesktop/UDisks2/lvm",
storage_volume_group_get_name (self), NULL);
storage_daemon_publish (daemon, path, FALSE, self);
g_free (path);
}
if (error)
{
g_message ("Failed to update LVM volume group %s: %s",
storage_volume_group_get_name (self), error->message);
g_object_unref (self);
return;
}
if (self->info && g_variant_equal (self->info, info))
{
g_debug ("%s updated without changes", self->name);
g_object_unref (self);
return;
}
if (self->info)
g_variant_unref (self->info);
self->info = g_variant_ref (info);
new_lvs = g_hash_table_new (g_str_hash, g_str_equal);
if (g_variant_lookup (info, "lvs", "aa{sv}", &iter))
{
GVariant *lv_info = NULL;
while (g_variant_iter_loop (iter, "@a{sv}", &lv_info))
{
const gchar *name;
StorageLogicalVolume *volume;
g_variant_lookup (lv_info, "name", "&s", &name);
update_operations (name, lv_info, &needs_polling);
if (lv_is_pvmove_volume (name))
needs_polling = TRUE;
if (!lv_is_visible (name))
continue;
volume = g_hash_table_lookup (self->logical_volumes, name);
if (volume == NULL)
{
volume = storage_logical_volume_new (self, name);
storage_logical_volume_update (volume, self, lv_info, &needs_polling);
g_hash_table_insert (self->logical_volumes, g_strdup (name), g_object_ref (volume));
}
else
storage_logical_volume_update (volume, self, lv_info, &needs_polling);
g_hash_table_insert (new_lvs, (gchar *)name, volume);
}
g_variant_iter_free (iter);
}
g_hash_table_iter_init (&volume_iter, self->logical_volumes);
while (g_hash_table_iter_next (&volume_iter, &key, &value))
{
const gchar *name = key;
StorageLogicalVolume *volume = value;
if (!g_hash_table_contains (new_lvs, name))
{
/* Volume unpublishes itself */
g_object_run_dispose (G_OBJECT (volume));
g_hash_table_iter_remove (&volume_iter);
}
}
lvm_volume_group_set_needs_polling (LVM_VOLUME_GROUP (self), needs_polling);
/* Update physical volumes. */
g_hash_table_remove_all (self->physical_volumes);
if (g_variant_lookup (info, "pvs", "aa{sv}", &iter))
{
const gchar *name;
GVariant *pv_info;
while (g_variant_iter_next (iter, "@a{sv}", &pv_info))
{
if (g_variant_lookup (pv_info, "device", "&s", &name))
g_hash_table_insert (self->physical_volumes, g_strdup (name), pv_info);
else
g_variant_unref (pv_info);
}
}
/* Make sure above is published before updating blocks to point at volume group */
update_all_blocks (self);
if (data->done)
data->done (self, data->done_user_data);
g_hash_table_destroy (new_lvs);
g_object_unref (self);
g_free (data);
}
