GVariant *
photos_utils_create_zoom_target_value (gdouble delta, PhotosZoomEvent event)
{
GEnumClass *zoom_event_class = NULL; /* TODO: use g_autoptr */
GEnumValue *event_value;
GVariant *delta_value;
GVariant *event_nick_value;
GVariant *ret_val = NULL;
g_auto (GVariantBuilder) builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT);
const gchar *event_nick = "none";
g_return_val_if_fail (delta >= 0.0, NULL);
g_return_val_if_fail (event != PHOTOS_ZOOM_EVENT_NONE, NULL);
delta_value = g_variant_new_double (delta);
g_variant_builder_add (&builder, "{sv}", "delta", delta_value);
zoom_event_class = G_ENUM_CLASS (g_type_class_ref (PHOTOS_TYPE_ZOOM_EVENT));
event_value = g_enum_get_value (zoom_event_class, (gint) event);
if (event_value != NULL)
event_nick = event_value->value_nick;
event_nick_value = g_variant_new_string (event_nick);
g_variant_builder_add (&builder, "{sv}", "event", event_nick_value);
ret_val = g_variant_builder_end (&builder);
g_type_class_unref (zoom_event_class);
g_return_val_if_fail (g_variant_is_floating (ret_val), ret_val);
return ret_val;
}
static YtsMetadata *
create_message (char const *type,
GVariant *payload)
{
RestXmlNode *node;
char *payload_str;
char *payload_str_escaped;;
node = rest_xml_node_add_child (NULL, "message");
/* PONDERING need those keywords be made reserved */
rest_xml_node_add_attr (node, "type", type);
rest_xml_node_add_attr (node, "capability", SERVICE_FQC_ID);
payload_str = g_variant_print (payload, false);
/* FIXME this is just a stopgap solution to lacking g_markup_unescape_text()
* want to move to complex message bodies anywy. */
payload_str_escaped = g_uri_escape_string (payload_str, NULL, true);
rest_xml_node_add_attr (node, "payload", payload_str_escaped);
g_free (payload_str_escaped);
g_free (payload_str);
if (g_variant_is_floating (payload))
g_variant_unref (payload);
return g_object_new (YTS_TYPE_MESSAGE,
"top-level-node", node,
NULL);
}
GVariant *
ot_util_variant_take_ref (GVariant *variant)
{
#if GLIB_CHECK_VERSION(2,32,0) && !defined(OSTREE_GLIB_TARGET_MIN)
return g_variant_take_ref (variant);
#else
if (g_variant_is_floating (variant))
return g_variant_ref_sink (variant);
return variant;
#endif
}
void
yts_profile_register_proxy_return (YtsProfile *self,
char const *invocation_id,
GVariant *return_value)
{
g_return_if_fail (YTS_IS_PROFILE (self));
g_signal_emit (self, _signals[SIG_REGISTER_PROXY_RESPONSE], 0,
invocation_id, return_value);
if (g_variant_is_floating (return_value)) {
g_variant_unref (return_value);
}
}
static void
activate_action (GtkWidget *widget,
const gchar *prefix,
const gchar *action_name,
GVariant *parameter)
{
GApplication *app;
GtkWidget *toplevel;
GActionGroup *group = NULL;
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (prefix);
g_return_if_fail (action_name);
g_print ("activate!\n");
app = g_application_get_default ();
toplevel = gtk_widget_get_toplevel (widget);
while ((group == NULL) && (widget != NULL))
{
group = gtk_widget_get_action_group (widget, prefix);
widget = gtk_widget_get_parent (widget);
}
if (!group && g_str_equal (prefix, "win") && G_IS_ACTION_GROUP (toplevel))
group = G_ACTION_GROUP (toplevel);
if (!group && g_str_equal (prefix, "app") && G_IS_ACTION_GROUP (app))
group = G_ACTION_GROUP (app);
if (group)
{
if (g_action_group_has_action (group, action_name))
{
g_print ("Activating %s.%s\n", prefix, action_name);
g_action_group_activate_action (group, action_name, parameter);
return;
}
}
if (parameter && g_variant_is_floating (parameter))
{
parameter = g_variant_ref_sink (parameter);
g_variant_unref (parameter);
}
g_warning ("Failed to resolve action %s.%s", prefix, action_name);
}
/**
* g_value_take_variant:
* @value: a valid #GValue of type %G_TYPE_VARIANT
* @variant: a #GVariant, or %NULL
*
* Set the contents of a variant #GValue to @variant, and takes over
* the ownership of the caller's reference to @variant;
* the caller doesn't have to unref it any more (i.e. the reference
* count of the variant is not increased).
*
* It is a programmer error to pass a floating variant to this function.
* In particular this means that callbacks in closures, and signal handlers
* for signals of return type %G_TYPE_VARIANT, must never return floating
* variants.
*
* If you want the #GValue to hold its own reference to @variant, use
* g_value_set_variant() instead.
*
* This is an internal function introduced mainly for C marshallers.
*
* Since: 2.26
*/
void
g_value_take_variant (GValue *value,
GVariant *variant)
{
GVariant *old_variant;
g_return_if_fail (G_VALUE_HOLDS_VARIANT (value));
g_return_if_fail (variant == NULL || !g_variant_is_floating (variant));
old_variant = value->data[0].v_pointer;
value->data[0].v_pointer = variant;
if (old_variant)
g_variant_unref (old_variant);
}
static gboolean
egg_empty_state_activate_link (EggEmptyState *self,
const gchar *uri,
GtkLabel *label)
{
g_assert (EGG_IS_EMPTY_STATE (self));
g_assert (uri != NULL);
g_assert (GTK_IS_LABEL (label));
if (g_str_has_prefix (uri, "action://"))
{
g_autofree gchar *full_name = NULL;
g_autofree gchar *action_name = NULL;
g_autofree gchar *group_name = NULL;
g_autoptr(GVariant) param = NULL;
g_autoptr(GError) error = NULL;
uri += strlen ("action://");
if (g_action_parse_detailed_name (uri, &full_name, ¶m, &error))
{
const gchar *dot = strchr (full_name, '.');
if (param != NULL && g_variant_is_floating (param))
param = g_variant_ref_sink (param);
if (dot == NULL)
return FALSE;
group_name = g_strndup (full_name, dot - full_name);
action_name = g_strdup (++dot);
egg_empty_state_action (GTK_WIDGET (self),
group_name,
action_name,
param);
return TRUE;
}
else
g_warning ("%s", error->message);
}
return FALSE;
}
static gboolean
egg_empty_state_action (GtkWidget *widget,
const gchar *prefix,
const gchar *action_name,
GVariant *parameter)
{
GtkWidget *toplevel;
GApplication *app;
GActionGroup *group = NULL;
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
g_return_val_if_fail (prefix, FALSE);
g_return_val_if_fail (action_name, FALSE);
app = g_application_get_default ();
toplevel = gtk_widget_get_toplevel (widget);
while ((group == NULL) && (widget != NULL))
{
group = gtk_widget_get_action_group (widget, prefix);
widget = gtk_widget_get_parent (widget);
}
if (!group && g_str_equal (prefix, "win") && G_IS_ACTION_GROUP (toplevel))
group = G_ACTION_GROUP (toplevel);
if (!group && g_str_equal (prefix, "app") && G_IS_ACTION_GROUP (app))
group = G_ACTION_GROUP (app);
if (group && g_action_group_has_action (group, action_name))
{
g_action_group_activate_action (group, action_name, parameter);
return TRUE;
}
if (parameter && g_variant_is_floating (parameter))
{
parameter = g_variant_ref_sink (parameter);
g_variant_unref (parameter);
}
g_warning ("Failed to locate action %s.%s", prefix, action_name);
return FALSE;
}
static void
ide_run_manager_activate_action (GActionGroup *group,
const gchar *action_name,
GVariant *parameter)
{
IdeRunManager *self = (IdeRunManager *)group;
g_autoptr(GVariant) sunk = NULL;
g_assert (IDE_IS_RUN_MANAGER (self));
g_assert (action_name != NULL);
if (parameter != NULL && g_variant_is_floating (parameter))
sunk = g_variant_ref_sink (parameter);
if (FALSE) {}
else if (g_strcmp0 (action_name, "run-with-handler") == 0)
{
const gchar *handler = NULL;
if (parameter != NULL)
handler = g_variant_get_string (parameter, NULL);
/* "" translates to current handler */
if (handler && *handler)
ide_run_manager_set_handler (self, handler);
ide_run_manager_run_async (self,
NULL,
NULL,
ide_run_manager_run_action_cb,
NULL);
}
else if (g_strcmp0 (action_name, "run") == 0)
{
ide_run_manager_run_async (self,
NULL,
NULL,
ide_run_manager_run_action_cb,
NULL);
}
else if (g_strcmp0 (action_name, "stop") == 0)
{
ide_run_manager_cancel (self);
}
}
GVariant *
goa_utils_lookup_credentials_sync (GoaProvider *provider,
GoaObject *object,
GCancellable *cancellable,
GError **error)
{
gchar *password_key;
GVariant *ret;
gchar *password;
const gchar *id;
GError *sec_error = NULL;
g_return_val_if_fail (GOA_IS_PROVIDER (provider), NULL);
g_return_val_if_fail (GOA_IS_OBJECT (object) && goa_object_peek_account (object) != NULL, FALSE);
g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
ret = NULL;
password_key = NULL;
password = NULL;
id = goa_account_get_id (goa_object_peek_account (object));
password_key = g_strdup_printf ("%s:gen%d:%s",
goa_provider_get_provider_type (GOA_PROVIDER (provider)),
goa_provider_get_credentials_generation (GOA_PROVIDER (provider)),
id);
password = secret_password_lookup_sync (&secret_password_schema,
cancellable,
&sec_error,
"goa-identity", password_key,
NULL);
if (sec_error != NULL)
{
g_warning ("secret_password_lookup_sync() failed: %s", sec_error->message);
g_set_error_literal (error,
GOA_ERROR,
GOA_ERROR_FAILED, /* TODO: more specific */
_("Failed to retrieve credentials from the keyring"));
g_error_free (sec_error);
goto out;
}
else if (password == NULL)
{
g_warning ("secret_password_lookup_sync() returned NULL");
g_set_error_literal (error,
GOA_ERROR,
GOA_ERROR_FAILED, /* TODO: more specific */
_("No credentials found in the keyring"));
goto out;
}
g_debug ("Retrieved keyring credentials for id: %s", id);
ret = g_variant_parse (NULL, /* GVariantType */
password,
NULL, /* limit */
NULL, /* endptr */
error);
if (ret == NULL)
{
g_prefix_error (error, _("Error parsing result obtained from the keyring: "));
goto out;
}
if (g_variant_is_floating (ret))
g_variant_ref_sink (ret);
out:
g_free (password);
g_free (password_key);
return ret;
}
/**
* g_dbus_gvalue_to_gvariant:
* @gvalue: A #GValue to convert to a #GVariant
* @type: A #GVariantType
*
* Converts a #GValue to a #GVariant of the type indicated by the @type
* parameter.
*
* The conversion is using the following rules:
*
* - #G_TYPE_STRING: 's', 'o', 'g' or 'ay'
* - #G_TYPE_STRV: 'as', 'ao' or 'aay'
* - #G_TYPE_BOOLEAN: 'b'
* - #G_TYPE_UCHAR: 'y'
* - #G_TYPE_INT: 'i', 'n'
* - #G_TYPE_UINT: 'u', 'q'
* - #G_TYPE_INT64 'x'
* - #G_TYPE_UINT64: 't'
* - #G_TYPE_DOUBLE: 'd'
* - #G_TYPE_VARIANT: Any #GVariantType
*
* This can fail if e.g. @gvalue is of type #G_TYPE_STRING and @type
* is ['i'][G-VARIANT-TYPE-INT32:CAPS]. It will also fail for any #GType
* (including e.g. #G_TYPE_OBJECT and #G_TYPE_BOXED derived-types) not
* in the table above.
*
* Note that if @gvalue is of type #G_TYPE_VARIANT and its value is
* %NULL, the empty #GVariant instance (never %NULL) for @type is
* returned (e.g. 0 for scalar types, the empty string for string types,
* '/' for object path types, the empty array for any array type and so on).
*
* See the g_dbus_gvariant_to_gvalue() function for how to convert a
* #GVariant to a #GValue.
*
* Returns: A #GVariant (never floating) of #GVariantType @type holding
* the data from @gvalue or %NULL in case of failure. Free with
* g_variant_unref().
*
* Since: 2.30
*/
GVariant *
g_dbus_gvalue_to_gvariant (const GValue *gvalue,
const GVariantType *type)
{
GVariant *ret;
const gchar *s;
const gchar * const *as;
const gchar *empty_strv[1] = {NULL};
g_return_val_if_fail (gvalue != NULL, NULL);
g_return_val_if_fail (type != NULL, NULL);
ret = NULL;
/* @type can easily be e.g. "s" with the GValue holding a GVariant - for example this
* can happen when using the org.gtk.GDBus.C.ForceGVariant annotation with the
* gdbus-codegen(1) tool.
*/
if (G_VALUE_TYPE (gvalue) == G_TYPE_VARIANT)
{
ret = g_value_dup_variant (gvalue);
}
else
{
switch (g_variant_type_peek_string (type)[0])
{
case G_VARIANT_CLASS_BOOLEAN:
ret = g_variant_ref_sink (g_variant_new_boolean (g_value_get_boolean (gvalue)));
break;
case G_VARIANT_CLASS_BYTE:
ret = g_variant_ref_sink (g_variant_new_byte (g_value_get_uchar (gvalue)));
break;
case G_VARIANT_CLASS_INT16:
ret = g_variant_ref_sink (g_variant_new_int16 (g_value_get_int (gvalue)));
break;
case G_VARIANT_CLASS_UINT16:
ret = g_variant_ref_sink (g_variant_new_uint16 (g_value_get_uint (gvalue)));
break;
case G_VARIANT_CLASS_INT32:
ret = g_variant_ref_sink (g_variant_new_int32 (g_value_get_int (gvalue)));
break;
case G_VARIANT_CLASS_UINT32:
ret = g_variant_ref_sink (g_variant_new_uint32 (g_value_get_uint (gvalue)));
break;
case G_VARIANT_CLASS_INT64:
ret = g_variant_ref_sink (g_variant_new_int64 (g_value_get_int64 (gvalue)));
break;
case G_VARIANT_CLASS_UINT64:
ret = g_variant_ref_sink (g_variant_new_uint64 (g_value_get_uint64 (gvalue)));
break;
case G_VARIANT_CLASS_DOUBLE:
ret = g_variant_ref_sink (g_variant_new_double (g_value_get_double (gvalue)));
break;
case G_VARIANT_CLASS_STRING:
s = g_value_get_string (gvalue);
if (s == NULL)
s = "";
ret = g_variant_ref_sink (g_variant_new_string (s));
break;
case G_VARIANT_CLASS_OBJECT_PATH:
s = g_value_get_string (gvalue);
if (s == NULL)
s = "/";
ret = g_variant_ref_sink (g_variant_new_object_path (s));
break;
case G_VARIANT_CLASS_SIGNATURE:
s = g_value_get_string (gvalue);
if (s == NULL)
s = "";
ret = g_variant_ref_sink (g_variant_new_signature (s));
break;
case G_VARIANT_CLASS_ARRAY:
switch (g_variant_type_peek_string (type)[1])
{
case G_VARIANT_CLASS_BYTE:
s = g_value_get_string (gvalue);
if (s == NULL)
s = "";
ret = g_variant_ref_sink (g_variant_new_bytestring (s));
break;
case G_VARIANT_CLASS_STRING:
as = g_value_get_boxed (gvalue);
if (as == NULL)
as = empty_strv;
ret = g_variant_ref_sink (g_variant_new_strv (as, -1));
break;
case G_VARIANT_CLASS_OBJECT_PATH:
as = g_value_get_boxed (gvalue);
if (as == NULL)
as = empty_strv;
ret = g_variant_ref_sink (g_variant_new_objv (as, -1));
break;
case G_VARIANT_CLASS_ARRAY:
switch (g_variant_type_peek_string (type)[2])
{
case G_VARIANT_CLASS_BYTE:
as = g_value_get_boxed (gvalue);
if (as == NULL)
as = empty_strv;
ret = g_variant_ref_sink (g_variant_new_bytestring_array (as, -1));
break;
default:
ret = g_value_dup_variant (gvalue);
break;
}
break;
default:
ret = g_value_dup_variant (gvalue);
break;
}
break;
case G_VARIANT_CLASS_HANDLE:
case G_VARIANT_CLASS_VARIANT:
case G_VARIANT_CLASS_MAYBE:
case G_VARIANT_CLASS_TUPLE:
case G_VARIANT_CLASS_DICT_ENTRY:
ret = g_value_dup_variant (gvalue);
break;
}
}
/* Could be that the GValue is holding a NULL GVariant - in that case,
* we return an "empty" GVariant instead of a NULL GVariant
*/
if (ret == NULL)
{
GVariant *untrusted_empty;
untrusted_empty = g_variant_new_from_data (type, NULL, 0, FALSE, NULL, NULL);
ret = g_variant_ref_sink (g_variant_get_normal_form (untrusted_empty));
g_variant_unref (untrusted_empty);
}
g_assert (!g_variant_is_floating (ret));
return ret;
}