/*
*
* 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;
}
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;
}
void mooshi_initialized(SooshiState *state, gpointer user_data)
{
AppState *s = (AppState*)user_data;
g_info("Mooshimeter initialized!");
sooshi_node_subscribe(state, sooshi_node_find(state, "BAT_V", NULL), battery_update, user_data);
sooshi_node_subscribe(state, sooshi_node_find(state, "CH1:VALUE", NULL), channel1_update, user_data);
sooshi_node_subscribe(state, sooshi_node_find(state, "CH2:VALUE", NULL), channel2_update, user_data);
SooshiNode *sampling_trigger = sooshi_node_find(state, "SAMPLING:TRIGGER", NULL);
SooshiNode *sampling_rate = sooshi_node_find(state, "SAMPLING:RATE", NULL);
SooshiNode *sampling_depth = sooshi_node_find(state, "SAMPLING:DEPTH", NULL);
fill_combo_box_with_children(s->trigger, sampling_trigger);
fill_combo_box_with_children(s->sample_rate, sampling_rate);
fill_combo_box_with_children(s->sample_depth, sampling_depth);
sooshi_node_subscribe(state, sampling_trigger, sample_config_update, s->trigger);
sooshi_node_subscribe(state, sampling_rate, sample_config_update, s->sample_rate);
sooshi_node_subscribe(state, sampling_depth, sample_config_update, s->sample_depth);
g_signal_connect(s->trigger, "changed", G_CALLBACK(sample_config_changed), s);
g_signal_connect(s->sample_rate, "changed", G_CALLBACK(sample_config_changed), s);
g_signal_connect(s->sample_depth, "changed", G_CALLBACK(sample_config_changed), s);
sooshi_node_choose(state, sooshi_node_find(state, "SAMPLING:TRIGGER:CONTINUOUS", NULL));
sooshi_node_choose(state, sooshi_node_find(state, "CH2:MAPPING:VOLTAGE", NULL));
sooshi_node_choose(state, sooshi_node_find(state, "CH2:ANALYSIS:MEAN", NULL));
sooshi_node_set_value(state, sooshi_node_find(state, "CH2:RANGE_I", NULL), g_variant_new_byte(0), TRUE);
}
static int reverse_map(uint8_t u, const uint8_t *arr, int n)
{
GVariant *v = g_variant_new_byte(u);
int i = find_in_array(v, G_VARIANT_TYPE_BYTE, arr, n);
g_variant_unref(v);
return i;
}
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;
}
GVariant*
_gba_to_gvariant(GByteArray *gba)
{
guint8 *b;
size_t i, max;
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (b=gba->data,max=gba->len,i=0; i<max ;i++)
g_variant_builder_add_value(builder, g_variant_new_byte(b[i]));
GVariant *result = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
return result;
}
GVariant*
_gb_to_gvariant(GBytes *gb)
{
gsize max;
gconstpointer b = g_bytes_get_data(gb, &max);
const guint8 *b8 = b;
GVariantBuilder *builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (gsize i=0; i<max ;i++)
g_variant_builder_add_value(builder, g_variant_new_byte(b8[i]));
GVariant *result = g_variant_builder_end(builder);
g_variant_builder_unref(builder);
return result;
}
static void
eog_application_add_platform_data (GApplication *application,
GVariantBuilder *builder)
{
EogApplication *app = EOG_APPLICATION (application);
G_APPLICATION_CLASS (eog_application_parent_class)->add_platform_data (application,
builder);
if (app->flags) {
g_variant_builder_add (builder, "{sv}",
"eog-application-startup-flags",
g_variant_new_byte (app->flags));
}
}
static GVariant *
bytes_serialize(GvsSerializer *self, const GValue *value, gpointer unused)
{
gsize size, i;
const guint8 *data;
GVariantBuilder builder;
data = g_bytes_get_data(g_value_get_boxed(value), &size);
/* Hmmm, g_variant_new_bytestring for some reason wants the incoming
* data to be nul-terminated, which of course a generic chunk of data
* in the form of bytes might not be. So we have to manually go through
* and create the byte array ourselves. */
g_variant_builder_init(&builder, G_VARIANT_TYPE_BYTESTRING);
for (i = 0; i < size; i++)
{
g_variant_builder_add_value(&builder, g_variant_new_byte(data[i]));
}
return g_variant_builder_end(&builder);
}
static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel *ch,
const struct sr_channel_group *cg)
{
(void) cg;
struct dev_context *const devc = sdi->priv;
switch (id) {
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(devc->cur_samplerate);
break;
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples_show);
break;
case SR_CONF_LIMIT_MSEC:
*data = g_variant_new_uint64(devc->limit_msec);
break;
case SR_CONF_DEVICE_MODE:
*data = g_variant_new_int16(sdi->mode);
break;
case SR_CONF_TEST:
*data = g_variant_new_boolean(FALSE);
break;
case SR_CONF_INSTANT:
*data = g_variant_new_boolean(devc->instant);
break;
case SR_CONF_PATTERN_MODE:
*data = g_variant_new_string(pattern_strings[devc->sample_generator]);
break;
case SR_CONF_MAX_HEIGHT:
*data = g_variant_new_string(maxHeights[devc->max_height]);
break;
case SR_CONF_MAX_HEIGHT_VALUE:
*data = g_variant_new_byte(devc->max_height);
break;
case SR_CONF_VPOS:
*data = g_variant_new_double(ch->vpos);
break;
case SR_CONF_VDIV:
*data = g_variant_new_uint64(ch->vdiv);
break;
case SR_CONF_FACTOR:
*data = g_variant_new_uint64(ch->vfactor);
break;
case SR_CONF_TIMEBASE:
*data = g_variant_new_uint64(devc->timebase);
break;
case SR_CONF_COUPLING:
*data = g_variant_new_byte(ch->coupling);
break;
case SR_CONF_TRIGGER_VALUE:
*data = g_variant_new_byte(ch->trig_value);
break;
case SR_CONF_EN_CH:
*data = g_variant_new_uint64(ch->enabled);
break;
case SR_CONF_DATALOCK:
*data = g_variant_new_boolean(devc->data_lock);
break;
case SR_CONF_MAX_DSO_SAMPLERATE:
*data = g_variant_new_uint64(DEMO_MAX_DSO_SAMPLERATE);
break;
case SR_CONF_MAX_DSO_SAMPLELIMITS:
*data = g_variant_new_uint64(DEMO_MAX_DSO_DEPTH);
break;
case SR_CONF_MAX_LOGIC_SAMPLERATE:
*data = g_variant_new_uint64(DEMO_MAX_LOGIC_SAMPLERATE);
break;
case SR_CONF_MAX_LOGIC_SAMPLELIMITS:
*data = g_variant_new_uint64(DEMO_MAX_LOGIC_DEPTH);
break;
case SR_CONF_RLE_SAMPLELIMITS:
*data = g_variant_new_uint64(DEMO_MAX_LOGIC_DEPTH);
break;
case SR_CONF_DSO_BITS:
*data = g_variant_new_byte(devc->dso_bits);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
GVariant *
g_settings_set_mapping (const GValue *value,
const GVariantType *expected_type,
gpointer user_data)
{
gchar *type_string;
if (G_VALUE_HOLDS_BOOLEAN (value))
{
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN))
return g_variant_new_boolean (g_value_get_boolean (value));
}
else if (G_VALUE_HOLDS_CHAR (value) ||
G_VALUE_HOLDS_UCHAR (value))
{
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE))
{
if (G_VALUE_HOLDS_CHAR (value))
return g_variant_new_byte (g_value_get_char (value));
else
return g_variant_new_byte (g_value_get_uchar (value));
}
}
else if (G_VALUE_HOLDS_INT (value) ||
G_VALUE_HOLDS_INT64 (value))
return g_settings_set_mapping_int (value, expected_type);
else if (G_VALUE_HOLDS_DOUBLE (value))
return g_settings_set_mapping_float (value, expected_type);
else if (G_VALUE_HOLDS_UINT (value) ||
G_VALUE_HOLDS_UINT64 (value))
return g_settings_set_mapping_unsigned_int (value, expected_type);
else if (G_VALUE_HOLDS_STRING (value))
{
if (g_value_get_string (value) == NULL)
return NULL;
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING))
return g_variant_new_string (g_value_get_string (value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTESTRING))
return g_variant_new_bytestring (g_value_get_string (value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH))
return g_variant_new_object_path (g_value_get_string (value));
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE))
return g_variant_new_signature (g_value_get_string (value));
}
else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
{
if (g_value_get_boxed (value) == NULL)
return NULL;
return g_variant_new_strv ((const gchar **) g_value_get_boxed (value),
-1);
}
else if (G_VALUE_HOLDS_ENUM (value))
{
GEnumValue *enumval;
GEnumClass *eclass;
/* GParamSpecEnum holds a ref on the class so we just peek... */
eclass = g_type_class_peek (G_VALUE_TYPE (value));
enumval = g_enum_get_value (eclass, g_value_get_enum (value));
if (enumval)
return g_variant_new_string (enumval->value_nick);
else
return NULL;
}
else if (G_VALUE_HOLDS_FLAGS (value))
{
GVariantBuilder builder;
GFlagsValue *flagsval;
GFlagsClass *fclass;
guint flags;
fclass = g_type_class_peek (G_VALUE_TYPE (value));
flags = g_value_get_flags (value);
g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
while (flags)
{
flagsval = g_flags_get_first_value (fclass, flags);
if (flagsval == NULL)
{
g_variant_builder_clear (&builder);
return NULL;
}
g_variant_builder_add (&builder, "s", flagsval->value_nick);
flags &= ~flagsval->value;
}
return g_variant_builder_end (&builder);
}
type_string = g_variant_type_dup_string (expected_type);
g_critical ("No GSettings bind handler for type \"%s\".", type_string);
g_free (type_string);
return NULL;
}
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;
}
Variant::Variant(unsigned char value)
: Variant(g_variant_new_byte(value))
{}
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 int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel *ch,
const struct sr_channel_group *cg)
{
struct session_vdev *vdev;
switch (id) {
case SR_CONF_SAMPLERATE:
if (sdi) {
vdev = sdi->priv;
*data = g_variant_new_uint64(vdev->samplerate);
} else
return SR_ERR;
break;
case SR_CONF_LIMIT_SAMPLES:
if (sdi) {
vdev = sdi->priv;
*data = g_variant_new_uint64(vdev->total_samples);
} else
return SR_ERR;
break;
case SR_CONF_TIMEBASE:
if (sdi) {
vdev = sdi->priv;
*data = g_variant_new_uint64(vdev->timebase);
} else
return SR_ERR;
break;
case SR_CONF_EN_CH:
if (sdi && ch) {
*data = g_variant_new_boolean(ch->enabled);
} else
return SR_ERR;
break;
case SR_CONF_COUPLING:
if (sdi && ch) {
*data = g_variant_new_byte(ch->coupling);
} else
return SR_ERR;
break;
case SR_CONF_VDIV:
if (sdi && ch) {
*data = g_variant_new_uint64(ch->vdiv);
} else
return SR_ERR;
break;
case SR_CONF_FACTOR:
if (sdi && ch) {
*data = g_variant_new_uint64(ch->vfactor);
} else
return SR_ERR;
break;
case SR_CONF_VPOS:
if (sdi && ch) {
*data = g_variant_new_double(ch->vpos);
} else
return SR_ERR;
break;
case SR_CONF_MAX_DSO_SAMPLERATE:
if (!sdi)
return SR_ERR;
*data = g_variant_new_uint64(vdev->samplerate);
break;
case SR_CONF_MAX_DSO_SAMPLELIMITS:
if (!sdi)
return SR_ERR;
*data = g_variant_new_uint64(vdev->total_samples);
break;
default:
return SR_ERR_ARG;
}
return SR_OK;
}
/**
* Load the session from the specified filename.
*
* @param filename The name of the session file to load. Must not be NULL.
*
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments,
* SR_ERR_MALLOC upon memory allocation errors, or SR_ERR upon
* other errors.
*/
SR_API int sr_session_load(const char *filename)
{
GKeyFile *kf;
GPtrArray *capturefiles;
struct zip *archive;
struct zip_file *zf;
struct zip_stat zs;
struct sr_dev_inst *sdi;
struct sr_channel *probe;
int ret, devcnt, i, j, k;
uint16_t probenum;
uint64_t tmp_u64, total_probes, enabled_probes;
uint16_t p;
char **sections, **keys, *metafile, *val, s[11];
char probename[SR_MAX_PROBENAME_LEN + 1];
int mode = LOGIC;
int channel_type = SR_CHANNEL_LOGIC;
double tmp_double;
if (!filename) {
sr_err("%s: filename was NULL", __func__);
return SR_ERR_ARG;
}
if (!(archive = zip_open(filename, 0, &ret))) {
sr_dbg("Failed to open session file: zip error %d", ret);
return SR_ERR;
}
/* read "metadata" */
if (zip_stat(archive, "header", 0, &zs) == -1) {
sr_dbg("Not a valid DSView data file.");
return SR_ERR;
}
if (!(metafile = g_try_malloc(zs.size))) {
sr_err("%s: metafile malloc failed", __func__);
return SR_ERR_MALLOC;
}
zf = zip_fopen_index(archive, zs.index, 0);
zip_fread(zf, metafile, zs.size);
zip_fclose(zf);
kf = g_key_file_new();
if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) {
sr_dbg("Failed to parse metadata.");
return SR_ERR;
}
sr_session_new();
devcnt = 0;
capturefiles = g_ptr_array_new_with_free_func(g_free);
sections = g_key_file_get_groups(kf, NULL);
for (i = 0; sections[i]; i++) {
if (!strcmp(sections[i], "version"))
/* nothing really interesting in here yet */
continue;
if (!strncmp(sections[i], "header", 6)) {
/* device section */
sdi = NULL;
enabled_probes = total_probes = 0;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) {
val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
if (!strcmp(keys[j], "device mode")) {
mode = strtoull(val, NULL, 10);
} else if (!strcmp(keys[j], "capturefile")) {
sdi = sr_dev_inst_new(mode, devcnt, SR_ST_ACTIVE, NULL, NULL, NULL);
sdi->driver = &session_driver;
if (devcnt == 0)
/* first device, init the driver */
sdi->driver->init(NULL);
sr_dev_open(sdi);
sr_session_dev_add(sdi);
sdi->driver->config_set(SR_CONF_SESSIONFILE,
g_variant_new_bytestring(filename), sdi, NULL, NULL);
sdi->driver->config_set(SR_CONF_CAPTUREFILE,
g_variant_new_bytestring(val), sdi, NULL, NULL);
g_ptr_array_add(capturefiles, val);
} else if (!strcmp(keys[j], "samplerate")) {
sr_parse_sizestring(val, &tmp_u64);
sdi->driver->config_set(SR_CONF_SAMPLERATE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "unitsize")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "total samples")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_LIMIT_SAMPLES,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "hDiv")) {
tmp_u64 = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_TIMEBASE,
g_variant_new_uint64(tmp_u64), sdi, NULL, NULL);
} else if (!strcmp(keys[j], "total probes")) {
total_probes = strtoull(val, NULL, 10);
sdi->driver->config_set(SR_CONF_CAPTURE_NUM_PROBES,
g_variant_new_uint64(total_probes), sdi, NULL, NULL);
channel_type = (mode == DSO) ? SR_CHANNEL_DSO :
(mode == ANALOG) ? SR_CHANNEL_ANALOG : SR_CHANNEL_LOGIC;
for (p = 0; p < total_probes; p++) {
snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p);
if (!(probe = sr_channel_new(p, channel_type, FALSE,
probename)))
return SR_ERR;
sdi->channels = g_slist_append(sdi->channels, probe);
}
} else if (!strncmp(keys[j], "probe", 5)) {
if (!sdi)
continue;
enabled_probes++;
tmp_u64 = strtoul(keys[j]+5, NULL, 10);
/* sr_session_save() */
sr_dev_probe_name_set(sdi, tmp_u64, val);
sr_dev_probe_enable(sdi, tmp_u64, TRUE);
} else if (!strncmp(keys[j], "trigger", 7)) {
probenum = strtoul(keys[j]+7, NULL, 10);
sr_dev_trigger_set(sdi, probenum, val);
} else if (!strncmp(keys[j], "enable", 6)) {
probenum = strtoul(keys[j]+6, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_EN_CH,
g_variant_new_boolean(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "coupling", 8)) {
probenum = strtoul(keys[j]+8, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_COUPLING,
g_variant_new_byte(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vDiv", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_VDIV,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vFactor", 7)) {
probenum = strtoul(keys[j]+7, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_FACTOR,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "vPos", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_double = strtod(val, NULL);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_VPOS,
g_variant_new_double(tmp_double), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "period", 6)) {
probenum = strtoul(keys[j]+6, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_PERIOD,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "pcnt", 4)) {
probenum = strtoul(keys[j]+4, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_PCNT,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "max", 3)) {
probenum = strtoul(keys[j]+3, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_MAX,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
} else if (!strncmp(keys[j], "min", 3)) {
probenum = strtoul(keys[j]+3, NULL, 10);
tmp_u64 = strtoull(val, NULL, 10);
if (probenum < g_slist_length(sdi->channels)) {
probe = g_slist_nth(sdi->channels, probenum)->data;
sdi->driver->config_set(SR_CONF_STATUS_MIN,
g_variant_new_uint64(tmp_u64), sdi, probe, NULL);
}
}
}
g_strfreev(keys);
}
devcnt++;
}
g_strfreev(sections);
g_key_file_free(kf);
return SR_OK;
}
/**
* 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;
}
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;
}
