GError*
m2db_get_snapshots(struct sqlx_sqlite3_s *sq3, const gchar *name,
gint64 version, m2_onbean_cb cb, gpointer u0)
{
GError *err = NULL;
gchar *clause = " 1 ";
GVariant *params[] = {NULL, NULL, NULL};
if (name != NULL && version >= 0) {
clause = " name = ? AND version = ? ";
params[0] = g_variant_new_string(name);
params[1] = g_variant_new_int64(version);;
} else if (name != NULL) {
clause = " name = ? ";
params[0] = g_variant_new_string(name);
} else if (version >= 0) {
clause = " version = ? ";
params[0] = g_variant_new_int64(version);
}
err = SNAPSHOTS_load(sq3->db, clause, params, cb, u0);
if (params[0] != NULL)
g_variant_unref(params[0]);
if (params[1] != NULL)
g_variant_unref(params[1]);
return err;
}
static GVariant *
handle_get_property (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *property_name,
GError **error,
gpointer user_data)
{
App *app = user_data;
GVariant *ret;
ret = NULL;
if (g_strcmp0 (property_name, "Since") == 0)
{
ret = g_variant_new_int64 (app->since);
}
else if (g_strcmp0 (property_name, "Until") == 0)
{
ret = g_variant_new_int64 (app->until);
}
else if (g_strcmp0 (property_name, "HasCalendars") == 0)
{
ret = g_variant_new_boolean (app_has_calendars (app));
}
else
{
g_assert_not_reached ();
}
return ret;
}
static int convert_meta(struct srd_proto_data *pdata, PyObject *obj)
{
long long intvalue;
double dvalue;
if (pdata->pdo->meta_type == G_VARIANT_TYPE_INT64) {
if (!PyLong_Check(obj)) {
PyErr_Format(PyExc_TypeError, "This output was registered "
"as 'int', but '%s' was passed.", obj->ob_type->tp_name);
return SRD_ERR_PYTHON;
}
intvalue = PyLong_AsLongLong(obj);
if (PyErr_Occurred())
return SRD_ERR_PYTHON;
pdata->data = g_variant_new_int64(intvalue);
} else if (pdata->pdo->meta_type == G_VARIANT_TYPE_DOUBLE) {
if (!PyFloat_Check(obj)) {
PyErr_Format(PyExc_TypeError, "This output was registered "
"as 'float', but '%s' was passed.", obj->ob_type->tp_name);
return SRD_ERR_PYTHON;
}
dvalue = PyFloat_AsDouble(obj);
if (PyErr_Occurred())
return SRD_ERR_PYTHON;
pdata->data = g_variant_new_double(dvalue);
}
return SRD_OK;
}
static void
ide_preferences_spin_button_value_changed (IdePreferencesSpinButton *self,
GParamSpec *pspec,
GtkSpinButton *spin_button)
{
GVariant *variant = NULL;
gdouble value;
g_assert (IDE_IS_PREFERENCES_SPIN_BUTTON (self));
g_assert (pspec != NULL);
g_assert (GTK_IS_SPIN_BUTTON (spin_button));
value = gtk_spin_button_get_value (spin_button);
if (g_variant_type_equal (self->type, G_VARIANT_TYPE_DOUBLE))
variant = g_variant_new_double (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT16))
variant = g_variant_new_int16 (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT16))
variant = g_variant_new_uint16 (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT32))
variant = g_variant_new_int32 (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT32))
variant = g_variant_new_uint32 (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT64))
variant = g_variant_new_int64 (value);
else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT64))
variant = g_variant_new_uint64 (value);
else
g_return_if_reached ();
g_variant_ref_sink (variant);
g_settings_set_value (self->settings, self->key, variant);
g_clear_pointer (&variant, g_variant_unref);
}
static GVariant*
_field_to_gvariant(gpointer bean, guint position)
{
gpointer pf = FIELD(bean, position);
if (!_bean_has_field(bean, position))
return g_variant_new_tuple(NULL, 0);
switch (DESCR_FIELD(bean,position)->type) {
case FT_BOOL:
return g_variant_new_byte(*((gboolean*)pf) ? 1 : 0);
case FT_INT:
return g_variant_new_int64(*((gint64*)pf));
case FT_REAL:
return g_variant_new_double(*((gdouble*)pf));
case FT_TEXT:
if (!*((gpointer*)(pf)))
return g_variant_new_tuple(NULL, 0);
return g_variant_new_string(GSTR(pf)->str);
case FT_BLOB:
if (!*((gpointer*)(pf)))
return g_variant_new_tuple(NULL, 0);
return _gba_to_gvariant(GBA(pf));
default:
g_assert_not_reached();
break;
}
g_assert_not_reached();
return NULL;
}
static GVariant *
g_settings_set_mapping_float (const GValue *value,
const GVariantType *expected_type)
{
GVariant *variant = NULL;
gdouble d;
gint64 l;
if (G_VALUE_HOLDS_DOUBLE (value))
d = g_value_get_double (value);
else
return NULL;
l = (gint64) d;
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
{
if (G_MININT16 <= l && l <= G_MAXINT16)
variant = g_variant_new_int16 ((gint16) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
{
if (0 <= l && l <= G_MAXUINT16)
variant = g_variant_new_uint16 ((guint16) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
{
if (G_MININT32 <= l && l <= G_MAXINT32)
variant = g_variant_new_int32 ((gint) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
{
if (0 <= l && l <= G_MAXUINT32)
variant = g_variant_new_uint32 ((guint) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
{
if (G_MININT64 <= l && l <= G_MAXINT64)
variant = g_variant_new_int64 ((gint64) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
{
if (0 <= l && l <= G_MAXUINT64)
variant = g_variant_new_uint64 ((guint64) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
{
if (0 <= l && l <= G_MAXUINT32)
variant = g_variant_new_handle ((guint) l);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
variant = g_variant_new_double ((gdouble) d);
return variant;
}
static GVariant *
g_settings_set_mapping_unsigned_int (const GValue *value,
const GVariantType *expected_type)
{
GVariant *variant = NULL;
guint64 u;
if (G_VALUE_HOLDS_UINT (value))
u = g_value_get_uint (value);
else if (G_VALUE_HOLDS_UINT64 (value))
u = g_value_get_uint64 (value);
else
return NULL;
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
{
if (u <= G_MAXINT16)
variant = g_variant_new_int16 ((gint16) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
{
if (u <= G_MAXUINT16)
variant = g_variant_new_uint16 ((guint16) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
{
if (u <= G_MAXINT32)
variant = g_variant_new_int32 ((gint) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
{
if (u <= G_MAXUINT32)
variant = g_variant_new_uint32 ((guint) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
{
if (u <= G_MAXINT64)
variant = g_variant_new_int64 ((gint64) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
{
if (u <= G_MAXUINT64)
variant = g_variant_new_uint64 ((guint64) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
{
if (u <= G_MAXUINT32)
variant = g_variant_new_handle ((guint) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
variant = g_variant_new_double ((gdouble) u);
return variant;
}
static void
populate_passwd_props (GHashTable *props,
struct passwd *pw)
{
if (pw == NULL)
{
variant_table_sink (props, "Id", g_variant_new_int64 (geteuid ()));
variant_table_sink (props, "Name", g_variant_new_string (""));
variant_table_sink (props, "Full", g_variant_new_string (""));
variant_table_sink (props, "Home", g_variant_new_string (""));
variant_table_sink (props, "Shell", g_variant_new_string (""));
}
else
{
variant_table_sink (props, "Id", g_variant_new_int64 (pw->pw_uid));
variant_table_sink (props, "Name", g_variant_new_string (pw->pw_name));
variant_table_sink (props, "Full", g_variant_new_string (pw->pw_gecos));
variant_table_sink (props, "Home", g_variant_new_string (pw->pw_dir));
variant_table_sink (props, "Shell", g_variant_new_string (pw->pw_shell));
}
}
GVariant *convertVariant(const QVariant &variant)
{
switch (variant.type()) {
case QVariant::Bool:
return g_variant_new_boolean(variant.toBool());
case QVariant::Char:
return g_variant_new_byte(variant.toChar().toLatin1());
case QVariant::Int:
return g_variant_new_int32(variant.toInt());
case QVariant::UInt:
return g_variant_new_uint32(variant.toUInt());
case QVariant::LongLong:
return g_variant_new_int64(variant.toLongLong());
case QVariant::ULongLong:
return g_variant_new_uint64(variant.toULongLong());
case QVariant::Double:
return g_variant_new_double(variant.toDouble());
case QVariant::String:
return g_variant_new_string(variant.toString().toUtf8().constData());
case QVariant::StringList: {
QStringList value = variant.toStringList();
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
foreach (QString item ,value)
g_variant_builder_add(builder, "s", item.toUtf8().constData());
GVariant *result = g_variant_new("as", builder);
g_variant_builder_unref(builder);
return result;
}
case QVariant::ByteArray:
return g_variant_new_bytestring(variant.toByteArray().constData());
case QVariant::Url:
return g_variant_new_string(variant.toUrl().toString().toUtf8().constData());
case QVariant::Color:
return g_variant_new_string(variant.toString().toUtf8().constData());
default: {
#ifndef QT_NO_DATASTREAM
QByteArray a;
QDataStream s(&a, QIODevice::WriteOnly);
s.setVersion(QDataStream::Qt_4_0);
s << variant;
return g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING, a.constData(),
a.size(), TRUE, NULL, NULL);
#else
Q_ASSERT(!"QConfiguration: Cannot save custom types without QDataStream support");
#endif
}
}
return 0;
}
static inline void
insert_integer_value (TrackerSparqlCursor *const cursor,
GVariantDict *const dict,
gchar const *const key,
gint const column)
{
GVariant *const value = g_variant_new_int64 (
tracker_sparql_cursor_get_integer (cursor, column)
);
g_variant_dict_insert_value (dict, key, value);
}
GVariant*
common_utils_new_variant_from_pointer(void* val)
{
gint i;
i = GPOINTER_TO_INT(val);
if (sizeof(gint) == sizeof(gint64)) {
return g_variant_new_int64(i);
}
else if (sizeof(gint) == sizeof(gint32)) {
return g_variant_new_int32(i);
}
return g_variant_new_int16(i);
}
/*
*
* Fundemental type transformations
*
*/
static GVariant *
serialize_fundamental(GvsSerializer *self, const GValue *value, gpointer unused)
{
GVariant *variant;
switch (G_VALUE_TYPE(value))
{
case G_TYPE_BOOLEAN:
variant = g_variant_new_boolean(g_value_get_boolean(value));
break;
case G_TYPE_CHAR:
variant = g_variant_new_byte(g_value_get_schar(value));
break;
case G_TYPE_DOUBLE:
variant = g_variant_new_double(g_value_get_double(value));
break;
case G_TYPE_FLOAT:
variant = g_variant_new_double(g_value_get_float(value));
break;
case G_TYPE_INT:
variant = g_variant_new_int32(g_value_get_int(value));
break;
case G_TYPE_INT64:
case G_TYPE_LONG:
variant = g_variant_new_int64(g_value_get_int64(value));
break;
case G_TYPE_STRING:
variant = g_variant_new("ms", g_value_get_string(value));
break;
case G_TYPE_UCHAR:
variant = g_variant_new_byte(g_value_get_uchar(value));
break;
case G_TYPE_UINT:
variant = g_variant_new_uint32(g_value_get_uint(value));
break;
case G_TYPE_UINT64:
case G_TYPE_ULONG:
variant = g_variant_new_uint64(g_value_get_uint64(value));
break;
case G_TYPE_VARIANT:
variant = g_value_dup_variant(value);
break;
default:
g_assert_not_reached();
break;
}
return variant;
}
void
empathy_chat_manager_call_undo_closed_chat (void)
{
gint64 action_time;
action_time = empathy_get_current_action_time ();
empathy_gen_chat_manager_proxy_new_for_bus (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE, EMPATHY_CHAT_BUS_NAME, CHAT_MANAGER_PATH,
NULL, chat_mgr_proxy_cb,
/* We can't use GINT_TO_POINTER as we won't be able to store a 64 bits
* integer on a 32 bits plateform. Use a GVariant for its convenient
* API. */
g_variant_new_int64 (action_time));
}
/**
* 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;
}
static GVariant *
get_player_property(GDBusConnection *connection,
const char *sender,
const char *object_path,
const char *interface_name,
const char *property_name,
GError **error,
XmrMprisPlugin *plugin)
{
if (g_strcmp0(object_path, MPRIS_OBJECT_NAME) != 0 ||
g_strcmp0(interface_name, MPRIS_PLAYER_INTERFACE) != 0)
{
g_set_error(error,
G_DBUS_ERROR,
G_DBUS_ERROR_NOT_SUPPORTED,
"Property %s.%s not supported",
interface_name,
property_name);
return NULL;
}
if (g_strcmp0 (property_name, "PlaybackStatus") == 0)
{
return get_playback_status(plugin);
}
else if (g_strcmp0 (property_name, "Metadata") == 0)
{
return build_metadata(plugin);
}
else if (g_strcmp0 (property_name, "Rate") == 0)
{
return g_variant_new_double(1.0);
}
else if (g_strcmp0(property_name, "Volume") == 0)
{
return g_variant_new_double(xmr_player_get_volume(plugin->player));
}
else if (g_strcmp0(property_name, "Position") == 0)
{
return g_variant_new_int64(plugin->elapsed / 1000);
}
else if (g_strcmp0 (property_name, "MinimumRate") == 0)
{
return g_variant_new_double (1.0);
}
else if (g_strcmp0 (property_name, "MaximumRate") == 0)
{
return g_variant_new_double (1.0);
}
else if (g_strcmp0 (property_name, "CanGoNext") == 0)
{
return g_variant_new_boolean(TRUE);
}
else if (g_strcmp0 (property_name, "CanGoPrevious") == 0)
{
return g_variant_new_boolean(FALSE);
}
else if (g_strcmp0 (property_name, "CanPlay") == 0)
{
return g_variant_new_boolean (TRUE);
}
else if (g_strcmp0 (property_name, "CanPause") == 0)
{
return g_variant_new_boolean(TRUE);
}
else if (g_strcmp0 (property_name, "CanSeek") == 0)
{
g_variant_new_boolean(FALSE);
}
else if (g_strcmp0(property_name, "CanControl") == 0)
{
return g_variant_new_boolean(TRUE);
}
g_set_error(error,
G_DBUS_ERROR,
G_DBUS_ERROR_NOT_SUPPORTED,
"Property %s.%s not supported",
interface_name,
property_name);
return NULL;
}
static void
handle_method_call (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
App *app = user_data;
if (g_strcmp0 (method_name, "GetEvents") == 0)
{
GVariantBuilder builder;
GHashTableIter hash_iter;
CalendarAppointment *a;
gint64 since;
gint64 until;
gboolean force_reload;
gboolean window_changed;
g_variant_get (parameters,
"(xxb)",
&since,
&until,
&force_reload);
if (until < since)
{
g_dbus_method_invocation_return_dbus_error (invocation,
"org.gnome.Shell.CalendarServer.Error.Failed",
"until cannot be before since");
goto out;
}
print_debug ("Handling GetEvents (since=%" G_GINT64_FORMAT ", until=%" G_GINT64_FORMAT ", force_reload=%s)",
since,
until,
force_reload ? "true" : "false");
window_changed = FALSE;
if (!(app->until == until && app->since == since))
{
GVariantBuilder *builder;
GVariantBuilder *invalidated_builder;
app->until = until;
app->since = since;
window_changed = TRUE;
builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
invalidated_builder = g_variant_builder_new (G_VARIANT_TYPE ("as"));
g_variant_builder_add (builder, "{sv}",
"Until", g_variant_new_int64 (app->until));
g_variant_builder_add (builder, "{sv}",
"Since", g_variant_new_int64 (app->since));
g_dbus_connection_emit_signal (app->connection,
NULL, /* destination_bus_name */
"/org/gnome/Shell/CalendarServer",
"org.freedesktop.DBus.Properties",
"PropertiesChanged",
g_variant_new ("(sa{sv}as)",
"org.gnome.Shell.CalendarServer",
builder,
invalidated_builder),
NULL); /* GError** */
}
/* reload events if necessary */
if (window_changed || force_reload || app->cache_invalid)
{
app_load_events (app);
}
/* The a{sv} is used as an escape hatch in case we want to provide more
* information in the future without breaking ABI
*/
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(sssbxxa{sv})"));
g_hash_table_iter_init (&hash_iter, app->appointments);
while (g_hash_table_iter_next (&hash_iter, NULL, (gpointer) &a))
{
GVariantBuilder extras_builder;
GSList *l;
for (l = a->occurrences; l; l = l->next)
{
CalendarOccurrence *o = l->data;
time_t start_time = o->start_time;
time_t end_time = o->end_time;
if ((start_time >= app->since &&
start_time < app->until) ||
(start_time <= app->since &&
(end_time - 1) > app->since))
{
g_variant_builder_init (&extras_builder, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&builder,
"(sssbxxa{sv})",
a->uid,
a->summary != NULL ? a->summary : "",
a->description != NULL ? a->description : "",
(gboolean) a->is_all_day,
(gint64) start_time,
(gint64) end_time,
extras_builder);
}
}
}
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("(a(sssbxxa{sv}))", &builder));
}
else
{
g_assert_not_reached ();
}
out:
;
}
static void notify_incoming_call(struct gtk_mod *mod,
struct call *call)
{
static const char *title = "Incoming call";
const char *msg = call_peeruri(call);
GtkWidget *call_menu;
GtkWidget *menu_item;
#if defined(USE_LIBNOTIFY)
NotifyNotification *notification;
if (!notify_is_initted())
return;
notification = notify_notification_new(title, msg, "baresip");
notify_notification_set_urgency(notification, NOTIFY_URGENCY_CRITICAL);
notify_notification_show(notification, NULL);
g_object_unref(notification);
#elif GLIB_CHECK_VERSION(2,40,0)
char id[64];
GVariant *target;
GNotification *notification = g_notification_new(title);
re_snprintf(id, sizeof id, "incoming-call-%p", call);
id[sizeof id - 1] = '\0';
#if GLIB_CHECK_VERSION(2,42,0)
g_notification_set_priority(notification,
G_NOTIFICATION_PRIORITY_URGENT);
#else
g_notification_set_urgent(notification, TRUE);
#endif
target = g_variant_new_int64(GPOINTER_TO_INT(call));
g_notification_set_body(notification, msg);
g_notification_add_button_with_target_value(notification,
"Answer", "app.answer", target);
g_notification_add_button_with_target_value(notification,
"Reject", "app.reject", target);
g_application_send_notification(mod->app, id, notification);
g_object_unref(notification);
#else
(void)msg;
(void)title;
#endif
/* Add incoming call to the app menu */
call_menu = gtk_menu_new();
menu_item = gtk_menu_item_new_with_mnemonic("_Incoming call");
g_object_set_data(G_OBJECT(menu_item), "call", call);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item),
call_menu);
gtk_menu_shell_prepend(GTK_MENU_SHELL(mod->app_menu), menu_item);
mod->incoming_call_menus = g_slist_append(mod->incoming_call_menus,
menu_item);
menu_item = gtk_menu_item_new_with_label(call_peeruri(call));
gtk_widget_set_sensitive(menu_item, FALSE);
gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);
menu_item = gtk_menu_item_new_with_mnemonic("_Accept");
g_object_set_data(G_OBJECT(menu_item), "call", call);
g_signal_connect(G_OBJECT(menu_item), "activate",
G_CALLBACK(menu_on_incoming_call_answer), mod);
gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);
menu_item = gtk_menu_item_new_with_mnemonic("_Reject");
g_object_set_data(G_OBJECT(menu_item), "call", call);
g_signal_connect(G_OBJECT(menu_item), "activate",
G_CALLBACK(menu_on_incoming_call_reject), mod);
gtk_menu_shell_append(GTK_MENU_SHELL(call_menu), menu_item);
}
static GVariant *
dconf_dbus_to_gv (DBusMessageIter *iter,
GError **error)
{
gint arg_type;
arg_type = dbus_message_iter_get_arg_type (iter);
switch (dbus_message_iter_get_arg_type (iter))
{
case DBUS_TYPE_BOOLEAN:
{
dbus_bool_t value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_boolean (value);
}
case DBUS_TYPE_BYTE:
{
guchar value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_byte (value);
}
case DBUS_TYPE_INT16:
{
gint16 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_int16 (value);
}
case DBUS_TYPE_UINT16:
{
guint16 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_uint16 (value);
}
case DBUS_TYPE_INT32:
{
gint32 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_int32 (value);
}
case DBUS_TYPE_UINT32:
{
guint32 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_uint32 (value);
}
case DBUS_TYPE_INT64:
{
gint64 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_int64 (value);
}
case DBUS_TYPE_UINT64:
{
guint64 value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_uint64 (value);
}
case DBUS_TYPE_DOUBLE:
{
gdouble value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_double (value);
}
case DBUS_TYPE_STRING:
{
const gchar *value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_string (value);
}
case DBUS_TYPE_OBJECT_PATH:
{
const gchar *value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_object_path (value);
}
case DBUS_TYPE_SIGNATURE:
{
const gchar *value;
dbus_message_iter_get_basic (iter, &value);
return g_variant_new_signature (value);
}
case DBUS_TYPE_VARIANT:
{
GVariantBuilder *builder;
GVariantClass class;
DBusMessageIter sub;
char *type;
GVariant *val;
dbus_message_iter_recurse (iter, &sub);
class = dbus_message_iter_get_arg_type (iter);
type = dbus_message_iter_get_signature (&sub);
builder = g_variant_builder_new (G_VARIANT_TYPE_VARIANT);
dbus_free (type);
while (dbus_message_iter_get_arg_type (&sub))
{
val = dconf_dbus_to_gv (&sub, error);
if (val == NULL)
{
g_variant_builder_cancel (builder);
goto fail;
}
g_variant_builder_add_value (builder, val);
dbus_message_iter_next (&sub);
}
return g_variant_builder_end (builder);
}
case DBUS_TYPE_ARRAY:
case DBUS_TYPE_STRUCT:
case DBUS_TYPE_DICT_ENTRY:
{
GVariantBuilder *builder;
GVariantClass class;
DBusMessageIter sub;
char *type;
GVariant *val;
dbus_message_iter_recurse (iter, &sub);
class = dbus_message_iter_get_arg_type (iter);
type = dbus_message_iter_get_signature (iter);
builder = g_variant_builder_new (G_VARIANT_TYPE (type));
dbus_free (type);
while (dbus_message_iter_get_arg_type (&sub))
{
val = dconf_dbus_to_gv (&sub, error);
if (val == NULL)
{
g_variant_builder_cancel (builder);
goto fail;
}
g_variant_builder_add_value (builder, val);
dbus_message_iter_next (&sub);
}
return g_variant_builder_end (builder);
}
default:
g_set_error (error,
G_DBUS_ERROR,
G_DBUS_ERROR_CONVERSION_FAILED,
_("Error serializing D-Bus message to GVariant. Unsupported arg type `%c' (%d)"),
arg_type,
arg_type);
goto fail;
}
g_assert_not_reached ();
fail:
return NULL;
}
static GVariant *
gconf_settings_backend_simple_gconf_value_type_to_gvariant (GConfValue *gconf_value,
const GVariantType *expected_type)
{
/* Note: it's guaranteed that the types are compatible */
GVariant *variant = NULL;
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN))
variant = g_variant_new_boolean (gconf_value_get_bool (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE))
{
int value = gconf_value_get_int (gconf_value);
if (value < 0 || value > 255)
return NULL;
variant = g_variant_new_byte (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
{
int value = gconf_value_get_int (gconf_value);
if (value < G_MINSHORT || value > G_MAXSHORT)
return NULL;
variant = g_variant_new_int16 (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
{
int value = gconf_value_get_int (gconf_value);
if (value < 0 || value > G_MAXUSHORT)
return NULL;
variant = g_variant_new_uint16 (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
variant = g_variant_new_int32 (gconf_value_get_int (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
{
int value = gconf_value_get_int (gconf_value);
if (value < 0)
return NULL;
variant = g_variant_new_uint32 (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
variant = g_variant_new_int64 ((gint64) gconf_value_get_int (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
{
int value = gconf_value_get_int (gconf_value);
if (value < 0)
return NULL;
variant = g_variant_new_uint64 (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
{
int value = gconf_value_get_int (gconf_value);
if (value < 0)
return NULL;
variant = g_variant_new_handle (value);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
variant = g_variant_new_double (gconf_value_get_float (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING))
variant = g_variant_new_string (gconf_value_get_string (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH))
variant = g_variant_new_object_path (gconf_value_get_string (gconf_value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE))
variant = g_variant_new_signature (gconf_value_get_string (gconf_value));
return variant;
}
static GVariant *
_get_player_property_cb (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *property_name,
GError **error,
gpointer user_data)
{
MexMprisPluginPrivate *priv = MEX_MPRIS_PLUGIN (user_data)->priv;
ClutterMedia *media;
GVariant *v = NULL;
if (mex_music_player_is_playing (priv->music))
media = mex_music_player_get_clutter_media (priv->music);
else
media = mex_player_get_clutter_media (priv->player);
if (g_strcmp0 ("PlaybackStatus", property_name) == 0)
{
/* Doesn't map to ClutterMedia straight away so try to emulate.
* Playback could theoretically be paused at progress 0.0 but well ...*/
gdouble progress = clutter_media_get_progress (media);
gboolean playing = clutter_media_get_playing (media);
if (playing)
v = g_variant_new_string ("Playing");
else if (progress != 0)
v = g_variant_new_string ("Paused");
else
v = g_variant_new_string ("Stopped");
}
else if (g_strcmp0 ("LoopStatus", property_name) == 0)
v = g_variant_new_string ("None");
else if (g_strcmp0 ("Rate", property_name) == 0 ||
g_strcmp0 ("MinimumRate", property_name) == 0 ||
g_strcmp0 ("MinimumRate", property_name) == 0 )
v = g_variant_new_double (1.0);
else if (g_strcmp0 ("Shuffle", property_name) == 0)
v = g_variant_new_boolean (FALSE);
else if (g_strcmp0 ("Volume", property_name) == 0)
v = g_variant_new_double (clutter_media_get_audio_volume (media));
else if (g_strcmp0 ("Position", property_name) == 0)
{
gdouble duration_s = clutter_media_get_duration (media);
gdouble progress_rel = clutter_media_get_progress (media);
gint64 position_ms = duration_s * 1000000 * progress_rel;
v = g_variant_new_int64 (position_ms);
}
else if (g_strcmp0 ("CanGoNext", property_name) == 0 ||
g_strcmp0 ("CanGoPrevious", property_name) == 0 ||
g_strcmp0 ("CanPlay", property_name) == 0 ||
g_strcmp0 ("CanControl", property_name) == 0 ||
g_strcmp0 ("CanPause", property_name) == 0)
v = g_variant_new_boolean (TRUE);
else if (g_strcmp0 ("CanSeek", property_name) == 0)
v = g_variant_new_boolean (clutter_media_get_can_seek (media));
if (v)
return v;
g_set_error (error,
G_DBUS_ERROR,
G_DBUS_ERROR_NOT_SUPPORTED,
"Property %s.%s not supported",
interface_name,
property_name);
return NULL;
}
Variant::Variant(int64_t value)
: Variant(g_variant_new_int64(value))
{}
static void update_metadata (void * data, GObject * object)
{
char * title = NULL, * artist = NULL, * album = NULL, * file = NULL;
int length = 0;
int playlist = aud_playlist_get_playing ();
int entry = (playlist >= 0) ? aud_playlist_get_position (playlist) : -1;
if (entry >= 0)
{
aud_playlist_entry_describe (playlist, entry, & title, & artist, & album, TRUE);
file = aud_playlist_entry_get_filename (playlist, entry);
length = aud_playlist_entry_get_length (playlist, entry, TRUE);
}
/* pointer comparison works for pooled strings */
if (title == last_title && artist == last_artist && album == last_album &&
file == last_file && length == last_length)
{
str_unref (title);
str_unref (artist);
str_unref (album);
str_unref (file);
return;
}
if (file != last_file)
{
if (image_file)
aud_art_unref (last_file);
image_file = file ? aud_art_get_file (file) : NULL;
}
str_unref (last_title);
str_unref (last_artist);
str_unref (last_album);
str_unref (last_file);
last_title = title;
last_artist = artist;
last_album = album;
last_file = file;
last_length = length;
GVariant * elems[7];
int nelems = 0;
if (title)
{
GVariant * key = g_variant_new_string ("xesam:title");
GVariant * str = g_variant_new_string (title);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (artist)
{
GVariant * key = g_variant_new_string ("xesam:artist");
GVariant * str = g_variant_new_string (artist);
GVariant * array = g_variant_new_array (G_VARIANT_TYPE_STRING, & str, 1);
GVariant * var = g_variant_new_variant (array);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (album)
{
GVariant * key = g_variant_new_string ("xesam:album");
GVariant * str = g_variant_new_string (album);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (file)
{
GVariant * key = g_variant_new_string ("xesam:url");
GVariant * str = g_variant_new_string (file);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (length > 0)
{
GVariant * key = g_variant_new_string ("mpris:length");
GVariant * val = g_variant_new_int64 ((int64_t) length * 1000);
GVariant * var = g_variant_new_variant (val);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
if (image_file)
{
GVariant * key = g_variant_new_string ("mpris:artUrl");
GVariant * str = g_variant_new_string (image_file);
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
}
GVariant * key = g_variant_new_string ("mpris:trackid");
GVariant * str = g_variant_new_string ("/org/mpris/MediaPlayer2/CurrentTrack");
GVariant * var = g_variant_new_variant (str);
elems[nelems ++] = g_variant_new_dict_entry (key, var);
if (! metadata_type)
metadata_type = g_variant_type_new ("{sv}");
GVariant * array = g_variant_new_array (metadata_type, elems, nelems);
g_object_set (object, "metadata", array, NULL);
}
GVariant* js_to_dbus(JSContextRef ctx, const JSValueRef jsvalue, const GVariantType* sig, JSValueRef *exception)
{
if (g_variant_type_is_array(sig)) {
GVariantBuilder builder;
g_variant_builder_init(&builder, sig);
JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue);
const GVariantType* child_sig = g_variant_type_element(sig);
if (g_variant_type_is_dict_entry(child_sig)) {
const GVariantType* key_sig = g_variant_type_first(child_sig);
const GVariantType* value_sig = g_variant_type_next(key_sig);
for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) {
if (filter_function_child(ctx, jsvalue, i)) continue;
g_variant_builder_open(&builder, child_sig);
JSValueRef key = JSValueMakeString(ctx, JSPropertyNameArrayGetNameAtIndex(array, i));
JSValueRef value = JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL);
g_variant_builder_add_value(&builder, js_to_dbus(ctx, key, key_sig, exception));
g_variant_builder_add_value(&builder, js_to_dbus(ctx, value, value_sig, exception));
g_variant_builder_close(&builder);
}
return g_variant_builder_end(&builder);
} else {
GVariantBuilder builder;
g_variant_builder_init(&builder, sig);
JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue);
const GVariantType* child_sig = g_variant_type_element(sig);
for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) {
if (filter_array_child(ctx, array, i)) continue;
g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), child_sig, exception));
}
JSPropertyNameArrayRelease(array);
return g_variant_builder_end(&builder);
}
} else if (g_variant_type_is_tuple(sig)) {
GVariantBuilder builder;
g_variant_builder_init(&builder, sig);
JSPropertyNameArrayRef array = JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue);
const GVariantType* current_sig = g_variant_type_first(sig);
for (size_t i=0; i < JSPropertyNameArrayGetCount(array); i++) {
if (filter_array_child(ctx, array, i)) continue;
g_variant_builder_add_value(&builder, js_to_dbus(ctx, JSObjectGetPropertyAtIndex(ctx, (JSObjectRef)jsvalue, i, NULL), current_sig, exception));
current_sig = g_variant_type_next(current_sig);
}
JSPropertyNameArrayRelease(array);
return g_variant_builder_end(&builder);
} else {
switch (g_variant_type_peek_string(sig)[0]) {
case 'y':
return g_variant_new_byte(JSValueToNumber(ctx, jsvalue, exception));
case 'n':
return g_variant_new_int16(JSValueToNumber(ctx, jsvalue, exception));
case 'q':
return g_variant_new_uint16(JSValueToNumber(ctx, jsvalue, exception));
case 'i':
return g_variant_new_int32(JSValueToNumber(ctx, jsvalue, exception));
case 'u':
return g_variant_new_uint32(JSValueToNumber(ctx, jsvalue, exception));
case 'x':
return g_variant_new_int64(JSValueToNumber(ctx, jsvalue, exception));
case 't':
return g_variant_new_uint64(JSValueToNumber(ctx, jsvalue, exception));
case 'd':
return g_variant_new_double(JSValueToNumber(ctx, jsvalue, exception));
case 'h':
return g_variant_new_handle(JSValueToNumber(ctx, jsvalue, exception));
case 'b':
return g_variant_new_boolean(JSValueToBoolean(ctx, jsvalue));
case 's':
{
char* v = jsvalue_to_cstr(ctx, jsvalue);
GVariant* r = g_variant_new_string(v);
g_free(v);
return r;
}
case 'v':
{
//TODO:
/*g_variant_new_variant()*/
g_assert_not_reached();
}
}
}
g_assert_not_reached();
}
static GVariant *
parse_json (JsonNode *node,
const GVariantType *type,
GError **error)
{
const GVariantType *element_type;
const gchar *str;
if (!g_variant_type_is_definite (type))
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"Indefinite type '%.*s' is not supported",
(int)g_variant_type_get_string_length (type),
g_variant_type_peek_string (type));
return NULL;
}
if (g_variant_type_is_basic (type))
{
if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_BOOLEAN, error))
return g_variant_new_boolean (json_node_get_boolean (node));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_BYTE))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error))
return g_variant_new_byte (json_node_get_int (node));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error))
return g_variant_new_int16 (json_node_get_int (node));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error))
return g_variant_new_uint16 (json_node_get_int (node));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error))
return g_variant_new_int32 (json_node_get_int (node));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error))
return g_variant_new_uint32 (json_node_get_int (node));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error))
return g_variant_new_int64 (json_node_get_int (node));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, error))
return g_variant_new_uint64 (json_node_get_int (node));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_INT64, NULL))
return g_variant_new_double (json_node_get_int (node));
else if (check_type (node, JSON_NODE_VALUE, G_TYPE_DOUBLE, error))
return g_variant_new_double (json_node_get_double (node));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error))
return g_variant_new_string (json_node_get_string (node));
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_OBJECT_PATH))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error))
{
str = json_node_get_string (node);
if (g_variant_is_object_path (str))
return g_variant_new_object_path (str);
else
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"Invalid object path '%s'", str);
return NULL;
}
}
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_SIGNATURE))
{
if (check_type (node, JSON_NODE_VALUE, G_TYPE_STRING, error))
{
str = json_node_get_string (node);
if (g_variant_is_signature (str))
return g_variant_new_signature (str);
else
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
"Invalid signature '%s'", str);
return NULL;
}
}
}
else
{
parse_not_supported (type, error);
}
}
else if (g_variant_type_is_variant (type))
{
return parse_json_variant (node, error);
}
else if (g_variant_type_is_array (type))
{
element_type = g_variant_type_element (type);
if (g_variant_type_is_dict_entry (element_type))
return parse_json_dictionary (node, element_type, error);
else
return parse_json_array (node, element_type, error);
}
else if (g_variant_type_is_tuple (type))
{
return parse_json_tuple (node, g_variant_type_first (type), error);
}
else
{
parse_not_supported (type, error);
}
return NULL;
}
