static GVariant *
set_contrast_mapping (const GValue *value,
const GVariantType *expected_type,
gpointer user_data)
{
gboolean hc;
GSettings *settings = user_data;
GVariant *ret = NULL;
hc = g_value_get_boolean (value);
if (hc)
{
ret = g_variant_new_string (HIGH_CONTRAST_THEME);
g_settings_set_string (settings, KEY_ICON_THEME, HIGH_CONTRAST_THEME);
}
else
{
g_settings_reset (settings, KEY_GTK_THEME);
g_settings_reset (settings, KEY_ICON_THEME);
}
return ret;
}
void
nm_dhcp4_config_set_options (NMDhcp4Config *self,
GHashTable *options)
{
NMDhcp4ConfigPrivate *priv = NM_DHCP4_CONFIG_GET_PRIVATE (self);
GHashTableIter iter;
const char *key, *value;
GVariantBuilder builder;
g_return_if_fail (NM_IS_DHCP4_CONFIG (self));
g_return_if_fail (options != NULL);
g_variant_unref (priv->options);
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
g_hash_table_iter_init (&iter, options);
while (g_hash_table_iter_next (&iter, (gpointer) &key, (gpointer) &value))
g_variant_builder_add (&builder, "{sv}", key, g_variant_new_string (value));
priv->options = g_variant_builder_end (&builder);
g_variant_ref_sink (priv->options);
g_object_notify (G_OBJECT (self), NM_DHCP4_CONFIG_OPTIONS);
}
static void to_json_dict_iter(const char *key, GVariant *obj, void *opaque)
{
ToJsonIterState *s = opaque;
GVariant *qkey;
int j;
if (s->count)
g_string_append(s->str, ", ");
if (s->pretty) {
g_string_append_c(s->str, '\n');
for (j = 0 ; j < s->indent ; j++)
g_string_append(s->str, " ");
}
qkey = g_variant_new_string(key);
to_json(qkey, s->str, s->pretty, s->indent);
g_variant_unref(qkey);
g_string_append(s->str, ": ");
to_json(obj, s->str, s->pretty, s->indent);
s->count++;
}
static int config_get(int key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_probe_group *probe_group)
{
struct dev_context *devc = sdi->priv;
(void)probe_group;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_LIMIT_MSEC:
*data = g_variant_new_uint64(devc->limit_msec);
break;
case SR_CONF_DATA_SOURCE:
*data = g_variant_new_string(data_sources[devc->data_source]);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static void
_forward_clicked(void *_data, Evas_Object * obj, void *event_info)
{
(void) obj;
(void) event_info;
char *content;
GHashTable *options;
struct MessageShowViewData *view = (struct MessageShowViewData *) _data;
evas_object_hide(view->hv);
options = g_hash_table_new_full(g_str_hash, g_str_equal,
NULL, common_utils_variant_unref);
content = elm_entry_markup_to_utf8(elm_object_text_get(view->content));
if (content) {
g_hash_table_insert(options, "Content",
g_variant_ref_sink(g_variant_new_string(content)));
free(content);
}
phoneui_messages_message_new(options);
}
static GVariant*
pd_color_to_string_mapping (const GValue *value,
const GVariantType *expected_type,
gpointer user_data)
{
GVariant *variant = NULL;
GdkColor *color;
gchar *hex_val;
g_return_val_if_fail (G_VALUE_TYPE (value) == GDK_TYPE_COLOR, NULL);
g_return_val_if_fail (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING), NULL);
color = g_value_get_boxed (value);
hex_val = g_strdup_printf ("#%02X%02X%02X",
color->red / 256,
color->green / 256,
color->blue / 256);
variant = g_variant_new_string (hex_val);
g_free (hex_val);
return variant;
}
gboolean
nm_supplicant_interface_request_scan (NMSupplicantInterface *self, const GPtrArray *ssids)
{
NMSupplicantInterfacePrivate *priv;
GVariantBuilder builder;
guint i;
g_return_val_if_fail (NM_IS_SUPPLICANT_INTERFACE (self), FALSE);
priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
/* Scan parameters */
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&builder, "{sv}", "Type", g_variant_new_string ("active"));
if (ssids) {
GVariantBuilder ssids_builder;
g_variant_builder_init (&ssids_builder, G_VARIANT_TYPE_BYTESTRING_ARRAY);
for (i = 0; i < ssids->len; i++) {
GByteArray *ssid = g_ptr_array_index (ssids, i);
g_variant_builder_add (&ssids_builder, "@ay",
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
ssid->data, ssid->len, 1));
}
g_variant_builder_add (&builder, "{sv}", "SSIDs", g_variant_builder_end (&ssids_builder));
}
g_dbus_proxy_call (priv->iface_proxy,
"Scan",
g_variant_new ("(a{sv})", &builder),
G_DBUS_CALL_FLAGS_NONE,
-1,
priv->other_cancellable,
(GAsyncReadyCallback) scan_request_cb,
self);
return TRUE;
}
Glib::VariantBase ConfigKey::parse_string(string value) const
{
GVariant *variant;
uint64_t p, q;
switch (data_type()->id())
{
case SR_T_UINT64:
check(sr_parse_sizestring(value.c_str(), &p));
variant = g_variant_new_uint64(p);
break;
case SR_T_STRING:
variant = g_variant_new_string(value.c_str());
break;
case SR_T_BOOL:
variant = g_variant_new_boolean(sr_parse_boolstring(value.c_str()));
break;
case SR_T_FLOAT:
variant = g_variant_new_double(stod(value));
break;
case SR_T_RATIONAL_PERIOD:
check(sr_parse_period(value.c_str(), &p, &q));
variant = g_variant_new("(tt)", p, q);
break;
case SR_T_RATIONAL_VOLT:
check(sr_parse_voltage(value.c_str(), &p, &q));
variant = g_variant_new("(tt)", p, q);
break;
case SR_T_INT32:
variant = g_variant_new_int32(stoi(value));
break;
default:
throw Error(SR_ERR_BUG);
}
return Glib::VariantBase(variant, false);
}
static void
state_cell_edited (GtkCellRendererCombo *cell,
const gchar *path_str,
const gchar *new_text,
GtkTreeModel *model)
{
GActionGroup *group;
GAction *action;
gchar *name;
GtkTreePath *path;
GtkTreeIter iter;
group = g_object_get_data (G_OBJECT (model), "group");
path = gtk_tree_path_new_from_string (path_str);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, 0, &name, -1);
action = g_action_map_lookup_action (G_ACTION_MAP (group), name);
g_simple_action_set_state (G_SIMPLE_ACTION (action), g_variant_new_string (new_text));
gtk_tree_model_row_changed (model, path, &iter);
g_free (name);
gtk_tree_path_free (path);
}
static void
load_applet_into_window (const char *title,
const char *prefs_path,
guint size,
guint orientation)
{
GtkWidget *container;
GtkWidget *applet_window;
GVariantBuilder builder;
container = mate_panel_applet_container_new ();
applet_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
//FIXME: we could set the window icon with the applet icon
gtk_window_set_title (GTK_WINDOW (applet_window), title);
gtk_container_add (GTK_CONTAINER (applet_window), container);
gtk_widget_show (container);
g_signal_connect (container, "applet-broken",
G_CALLBACK (applet_broken_cb),
applet_window);
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
g_variant_builder_add (&builder, "{sv}",
"prefs-path", g_variant_new_string (prefs_path));
g_variant_builder_add (&builder, "{sv}",
"size", g_variant_new_uint32 (size));
g_variant_builder_add (&builder, "{sv}",
"orient", g_variant_new_uint32 (orientation));
mate_panel_applet_container_add (MATE_PANEL_APPLET_CONTAINER (container),
gtk_widget_get_screen (applet_window),
title, NULL,
(GAsyncReadyCallback)applet_activated_cb,
applet_window,
g_variant_builder_end (&builder));
}
void
nautilus_application_notify_unmount_done (NautilusApplication *application,
const gchar *message)
{
if (application->priv->unmount_notify) {
notify_notification_close (application->priv->unmount_notify, NULL);
g_clear_object (&application->priv->unmount_notify);
}
if (message != NULL) {
NotifyNotification *unplug;
gchar **strings;
strings = g_strsplit (message, "\n", 0);
unplug = notify_notification_new (strings[0], strings[1],
"media-removable");
notify_notification_set_hint (unplug,
"desktop-entry", g_variant_new_string ("nautilus"));
notify_notification_show (unplug, NULL);
g_object_unref (unplug);
g_strfreev (strings);
}
}
static void
mate_panel_applet_frame_dbus_change_background (MatePanelAppletFrame *frame,
PanelBackgroundType type)
{
MatePanelAppletFrameDBus *dbus_frame = MATE_PANEL_APPLET_FRAME_DBUS (frame);
char *bg_str;
bg_str = _mate_panel_applet_frame_get_background_string (
frame, PANEL_WIDGET (gtk_widget_get_parent (GTK_WIDGET (frame))), type);
if (bg_str != NULL) {
if (dbus_frame->priv->bg_cancellable)
g_cancellable_cancel (dbus_frame->priv->bg_cancellable);
dbus_frame->priv->bg_cancellable = g_cancellable_new ();
mate_panel_applet_container_child_set (dbus_frame->priv->container,
"background",
g_variant_new_string (bg_str),
dbus_frame->priv->bg_cancellable,
container_child_background_set,
dbus_frame);
g_free (bg_str);
}
}
void InspectorClient::storeSetting(const String& key, const String& value)
{
if (shouldIgnoreSetting(key))
return;
GSettings* settings = inspectorGSettings();
if (!settings)
return;
PlatformRefPtr<GVariant> variant(0);
// Set the key with the appropriate type, and also avoid setting
// unknown keys to avoid aborting the execution.
if (key == "resourceTrackingEnabled" || key == "xhrMonitor"
|| key == "debuggerEnabled" || key == "profilerEnabled")
variant = adoptPlatformRef(variantFromTruthString(value));
else if (key == "frontendSettings")
variant = adoptPlatformRef(g_variant_new_string(value.utf8().data()));
if (!variant)
return;
g_settings_set_value(settings, toGSettingName(key).utf8().data(), variant.get());
}
GVariant * CAGattDescriptorGetProperties(GattDescriptor1 * descriptor)
{
/**
* Create a variant containing the @c GattDescriptor1 properties,
* of the form @c a{sa{sv}}.
*
* @note We don't care about the "Value" property here since it is
* automatically made available by BlueZ on the client
* side.
*/
/*
Populate the property table, and create the variant to be
embedded in the results of the
org.freedesktop.Dbus.ObjectManager.GetManagedObjects() method
call.
*/
CADBusSkeletonProperty const properties[] = {
{ "UUID",
g_variant_new_string(
gatt_descriptor1_get_uuid(descriptor)) },
{ "Characteristic",
g_variant_new_object_path(
gatt_descriptor1_get_characteristic(descriptor)) },
{ "Flags",
g_variant_new_strv(
gatt_descriptor1_get_flags(descriptor),
-1) }
};
return
CAMakePropertyDictionary(
BLUEZ_GATT_DESCRIPTOR_INTERFACE,
properties,
sizeof(properties) / sizeof(properties[0]));
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
const GVariantType *gvtype;
unsigned int i;
int cmd, ret;
char *s;
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
if (cg) {
/*
* These options only apply to channel groups with a single
* channel -- they're per-channel settings for the device.
*/
/*
* Config keys are handled below depending on whether a channel
* group was provided by the frontend. However some of these
* take a CG on one PPS but not on others. Check the device's
* profile for that here, and NULL out the channel group as needed.
*/
for (i = 0; i < devc->device->num_devopts; i++) {
if (devc->device->devopts[i] == key) {
cg = NULL;
break;
}
}
}
gvtype = NULL;
cmd = -1;
switch (key) {
case SR_CONF_ENABLED:
gvtype = G_VARIANT_TYPE_BOOLEAN;
cmd = SCPI_CMD_GET_OUTPUT_ENABLED;
break;
case SR_CONF_VOLTAGE:
gvtype = G_VARIANT_TYPE_DOUBLE;
cmd = SCPI_CMD_GET_MEAS_VOLTAGE;
break;
case SR_CONF_VOLTAGE_TARGET:
gvtype = G_VARIANT_TYPE_DOUBLE;
cmd = SCPI_CMD_GET_VOLTAGE_TARGET;
break;
case SR_CONF_OUTPUT_FREQUENCY:
gvtype = G_VARIANT_TYPE_DOUBLE;
cmd = SCPI_CMD_GET_MEAS_FREQUENCY;
break;
case SR_CONF_OUTPUT_FREQUENCY_TARGET:
gvtype = G_VARIANT_TYPE_DOUBLE;
cmd = SCPI_CMD_GET_FREQUENCY_TARGET;
break;
case SR_CONF_CURRENT:
gvtype = G_VARIANT_TYPE_DOUBLE;
cmd = SCPI_CMD_GET_MEAS_CURRENT;
break;
case SR_CONF_CURRENT_LIMIT:
gvtype = G_VARIANT_TYPE_DOUBLE;
cmd = SCPI_CMD_GET_CURRENT_LIMIT;
break;
case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED:
gvtype = G_VARIANT_TYPE_BOOLEAN;
cmd = SCPI_CMD_GET_OVER_VOLTAGE_PROTECTION_ENABLED;
break;
case SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE:
gvtype = G_VARIANT_TYPE_BOOLEAN;
cmd = SCPI_CMD_GET_OVER_VOLTAGE_PROTECTION_ACTIVE;
break;
case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
gvtype = G_VARIANT_TYPE_DOUBLE;
cmd = SCPI_CMD_GET_OVER_VOLTAGE_PROTECTION_THRESHOLD;
break;
case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
gvtype = G_VARIANT_TYPE_BOOLEAN;
cmd = SCPI_CMD_GET_OVER_CURRENT_PROTECTION_ENABLED;
break;
case SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE:
gvtype = G_VARIANT_TYPE_BOOLEAN;
cmd = SCPI_CMD_GET_OVER_CURRENT_PROTECTION_ACTIVE;
break;
case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
gvtype = G_VARIANT_TYPE_DOUBLE;
cmd = SCPI_CMD_GET_OVER_CURRENT_PROTECTION_THRESHOLD;
break;
case SR_CONF_OVER_TEMPERATURE_PROTECTION:
gvtype = G_VARIANT_TYPE_BOOLEAN;
cmd = SCPI_CMD_GET_OVER_TEMPERATURE_PROTECTION;
break;
case SR_CONF_REGULATION:
gvtype = G_VARIANT_TYPE_STRING;
cmd = SCPI_CMD_GET_OUTPUT_REGULATION;
}
if (!gvtype)
return SR_ERR_NA;
if (cg)
select_channel(sdi, cg->channels->data);
ret = scpi_cmd_resp(sdi, devc->device->commands, data, gvtype, cmd);
if (cmd == SCPI_CMD_GET_OUTPUT_REGULATION) {
/*
* The Rigol DP800 series return CV/CC/UR, Philips PM2800
* return VOLT/CURR. We always return a GVariant string in
* the Rigol notation.
*/
if ((ret = sr_scpi_get_string(sdi->conn, NULL, &s)) != SR_OK)
return ret;
if (!strcmp(s, "CV") || !strcmp(s, "VOLT")) {
*data = g_variant_new_string("CV");
} else if (!strcmp(s, "CC") || !strcmp(s, "CURR")) {
*data = g_variant_new_string("CC");
} else if (!strcmp(s, "UR")) {
*data = g_variant_new_string("UR");
} else {
sr_dbg("Unknown response to SCPI_CMD_GET_OUTPUT_REGULATION: %s", s);
ret = SR_ERR_DATA;
}
g_free(s);
}
return ret;
}
static int config_get(uint32_t key, GVariant **data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
struct dev_context *devc;
int ret;
float fvalue;
(void)cg;
devc = sdi->priv;
/*
* These features/keys are not supported by the hardware:
* - SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE
* - SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD
* - SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE
* - SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD
* - SR_CONF_ENABLED (state cannot be queried, only set)
*/
ret = SR_OK;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
case SR_CONF_LIMIT_MSEC:
return sr_sw_limits_config_get(&devc->limits, key, data);
case SR_CONF_REGULATION:
*data = g_variant_new_string("CC"); /* Always CC mode. */
break;
case SR_CONF_VOLTAGE:
if (reloadpro_get_voltage_current(sdi, &fvalue, NULL) < 0)
return SR_ERR;
*data = g_variant_new_double(fvalue);
break;
case SR_CONF_CURRENT:
if (reloadpro_get_voltage_current(sdi, NULL, &fvalue) < 0)
return SR_ERR;
*data = g_variant_new_double(fvalue);
break;
case SR_CONF_CURRENT_LIMIT:
if (reloadpro_get_current_limit(sdi, &fvalue) == SR_OK)
*data = g_variant_new_double(fvalue);
break;
case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED:
*data = g_variant_new_boolean(TRUE); /* Always on. */
break;
case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
*data = g_variant_new_boolean(TRUE); /* Always on. */
break;
case SR_CONF_OVER_TEMPERATURE_PROTECTION:
*data = g_variant_new_boolean(TRUE); /* Always on. */
break;
case SR_CONF_OVER_TEMPERATURE_PROTECTION_ACTIVE:
*data = g_variant_new_boolean(devc->otp_active);
break;
case SR_CONF_UNDER_VOLTAGE_CONDITION:
*data = g_variant_new_boolean(TRUE); /* Always on. */
break;
case SR_CONF_UNDER_VOLTAGE_CONDITION_ACTIVE:
*data = g_variant_new_boolean(devc->uvc_active);
break;
default:
return SR_ERR_NA;
}
return ret;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
struct sr_channel *ch;
const char *tmp_str;
uint64_t samplerate;
int analog_channel = -1;
float smallest_diff = INFINITY;
int idx = -1;
unsigned i;
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
/* If a channel group is specified, it must be a valid one. */
if (cg && !g_slist_find(sdi->channel_groups, cg)) {
sr_err("Invalid channel group specified.");
return SR_ERR;
}
if (cg) {
ch = g_slist_nth_data(cg->channels, 0);
if (!ch)
return SR_ERR;
if (ch->type == SR_CHANNEL_ANALOG) {
if (ch->name[2] < '1' || ch->name[2] > '4')
return SR_ERR;
analog_channel = ch->name[2] - '1';
}
}
switch (key) {
case SR_CONF_NUM_HDIV:
*data = g_variant_new_int32(devc->model->series->num_horizontal_divs);
break;
case SR_CONF_NUM_VDIV:
*data = g_variant_new_int32(devc->num_vdivs);
break;
case SR_CONF_DATA_SOURCE:
if (devc->data_source == DATA_SOURCE_LIVE)
*data = g_variant_new_string("Live");
else if (devc->data_source == DATA_SOURCE_MEMORY)
*data = g_variant_new_string("Memory");
else
*data = g_variant_new_string("Segmented");
break;
case SR_CONF_SAMPLERATE:
if (devc->data_source == DATA_SOURCE_LIVE) {
samplerate = analog_frame_size(sdi) /
(devc->timebase * devc->model->series->num_horizontal_divs);
*data = g_variant_new_uint64(samplerate);
} else {
sr_dbg("Unknown data source: %d.", devc->data_source);
return SR_ERR_NA;
}
break;
case SR_CONF_TRIGGER_SOURCE:
if (!strcmp(devc->trigger_source, "ACL"))
tmp_str = "AC Line";
else if (!strcmp(devc->trigger_source, "CHAN1"))
tmp_str = "CH1";
else if (!strcmp(devc->trigger_source, "CHAN2"))
tmp_str = "CH2";
else if (!strcmp(devc->trigger_source, "CHAN3"))
tmp_str = "CH3";
else if (!strcmp(devc->trigger_source, "CHAN4"))
tmp_str = "CH4";
else
tmp_str = devc->trigger_source;
*data = g_variant_new_string(tmp_str);
break;
case SR_CONF_TRIGGER_SLOPE:
if (!strncmp(devc->trigger_slope, "POS", 3)) {
tmp_str = "r";
} else if (!strncmp(devc->trigger_slope, "NEG", 3)) {
tmp_str = "f";
} else {
sr_dbg("Unknown trigger slope: '%s'.", devc->trigger_slope);
return SR_ERR_NA;
}
*data = g_variant_new_string(tmp_str);
break;
case SR_CONF_TRIGGER_LEVEL:
*data = g_variant_new_double(devc->trigger_level);
break;
case SR_CONF_TIMEBASE:
for (i = 0; i < devc->num_timebases; i++) {
float tb = (float)devc->timebases[i][0] / devc->timebases[i][1];
float diff = fabs(devc->timebase - tb);
if (diff < smallest_diff) {
smallest_diff = diff;
idx = i;
}
}
if (idx < 0) {
sr_dbg("Negative timebase index: %d.", idx);
return SR_ERR_NA;
}
*data = g_variant_new("(tt)", devc->timebases[idx][0],
devc->timebases[idx][1]);
break;
case SR_CONF_VDIV:
if (analog_channel < 0) {
sr_dbg("Negative analog channel: %d.", analog_channel);
return SR_ERR_NA;
}
for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
float vdiv = (float)vdivs[i][0] / vdivs[i][1];
float diff = fabs(devc->vdiv[analog_channel] - vdiv);
if (diff < smallest_diff) {
smallest_diff = diff;
idx = i;
}
}
if (idx < 0) {
sr_dbg("Negative vdiv index: %d.", idx);
return SR_ERR_NA;
}
*data = g_variant_new("(tt)", vdivs[idx][0], vdivs[idx][1]);
break;
case SR_CONF_COUPLING:
if (analog_channel < 0) {
sr_dbg("Negative analog channel: %d.", analog_channel);
return SR_ERR_NA;
}
*data = g_variant_new_string(devc->coupling[analog_channel]);
break;
case SR_CONF_PROBE_FACTOR:
if (analog_channel < 0) {
sr_dbg("Negative analog channel: %d.", analog_channel);
return SR_ERR_NA;
}
*data = g_variant_new_uint64(devc->attenuation[analog_channel]);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_get(int key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
GVariant *range[2];
uint64_t low, high;
int tmp, ret;
(void)cg;
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
ret = SR_OK;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_DATALOG:
if ((ret = cem_dt_885x_recording_get(sdi, &tmp)) == SR_OK)
*data = g_variant_new_boolean(tmp);
break;
case SR_CONF_SPL_WEIGHT_FREQ:
tmp = cem_dt_885x_weight_freq_get(sdi);
if (tmp == SR_MQFLAG_SPL_FREQ_WEIGHT_A)
*data = g_variant_new_string("A");
else if (tmp == SR_MQFLAG_SPL_FREQ_WEIGHT_C)
*data = g_variant_new_string("C");
else
return SR_ERR;
break;
case SR_CONF_SPL_WEIGHT_TIME:
tmp = cem_dt_885x_weight_time_get(sdi);
if (tmp == SR_MQFLAG_SPL_TIME_WEIGHT_F)
*data = g_variant_new_string("F");
else if (tmp == SR_MQFLAG_SPL_TIME_WEIGHT_S)
*data = g_variant_new_string("S");
else
return SR_ERR;
break;
case SR_CONF_HOLD_MAX:
if ((ret = cem_dt_885x_holdmode_get(sdi, &tmp)) == SR_OK)
*data = g_variant_new_boolean(tmp == SR_MQFLAG_MAX);
break;
case SR_CONF_HOLD_MIN:
if ((ret = cem_dt_885x_holdmode_get(sdi, &tmp)) == SR_OK)
*data = g_variant_new_boolean(tmp == SR_MQFLAG_MIN);
break;
case SR_CONF_SPL_MEASUREMENT_RANGE:
if ((ret = cem_dt_885x_meas_range_get(sdi, &low, &high)) == SR_OK) {
range[0] = g_variant_new_uint64(low);
range[1] = g_variant_new_uint64(high);
*data = g_variant_new_tuple(range, 2);
}
break;
case SR_CONF_POWER_OFF:
*data = g_variant_new_boolean(FALSE);
break;
case SR_CONF_DATA_SOURCE:
if (devc->cur_data_source == DATA_SOURCE_LIVE)
*data = g_variant_new_string("Live");
else
*data = g_variant_new_string("Memory");
break;
default:
return SR_ERR_NA;
}
return ret;
}
/**
* gcm_utils_install_package:
**/
gboolean
gcm_utils_install_package (const gchar *package_name, GtkWindow *window)
{
GDBusConnection *connection;
GVariant *args = NULL;
GVariant *response = NULL;
GVariantBuilder *builder = NULL;
GError *error = NULL;
gboolean ret = FALSE;
guint32 xid = 0;
gchar **packages = NULL;
g_return_val_if_fail (package_name != NULL, FALSE);
#ifndef HAVE_PACKAGEKIT
g_warning ("cannot install %s: this package was not compiled with --enable-packagekit", package_name);
goto out;
#endif
/* get xid of this window */
if (window != NULL)
xid = gdk_x11_window_get_xid (gtk_widget_get_window (GTK_WIDGET(window)));
/* we're expecting an array of packages */
packages = g_strsplit (package_name, "|", 1);
/* get a session bus connection */
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (connection == NULL) {
/* TRANSLATORS: no DBus session bus */
g_print ("%s %s\n", _("Failed to connect to session bus:"), error->message);
g_error_free (error);
goto out;
}
/* create arguments */
builder = g_variant_builder_new (G_VARIANT_TYPE ("(uass)"));
g_variant_builder_add_value (builder, g_variant_new_uint32 (xid));
g_variant_builder_add_value (builder, g_variant_new_strv ((const gchar * const *)packages, -1));
g_variant_builder_add_value (builder, g_variant_new_string ("hide-confirm-search,hide-finished"));
args = g_variant_builder_end (builder);
/* execute sync method */
response = g_dbus_connection_call_sync (connection,
PK_DBUS_SERVICE,
PK_DBUS_PATH,
PK_DBUS_INTERFACE_MODIFY,
"InstallPackageNames",
args,
NULL,
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT, NULL, &error);
if (response == NULL) {
/* TRANSLATORS: the DBus method failed */
g_warning ("%s %s\n", _("The request failed:"), error->message);
g_error_free (error);
goto out;
}
/* success */
ret = TRUE;
out:
if (builder != NULL)
g_variant_builder_unref (builder);
if (args != NULL)
g_variant_unref (args);
if (response != NULL)
g_variant_unref (response);
g_strfreev (packages);
return ret;
}
/**
* cd_sensor_dbus_get_property:
**/
static GVariant *
cd_sensor_dbus_get_property (GDBusConnection *connection_, const gchar *sender,
const gchar *object_path, const gchar *interface_name,
const gchar *property_name, GError **error,
gpointer user_data)
{
CdSensor *sensor = CD_SENSOR (user_data);
CdSensorPrivate *priv = sensor->priv;
GVariant *retval = NULL;
g_debug ("CdSensor %s:GetProperty '%s'",
sender, property_name);
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_ID) == 0) {
retval = g_variant_new_string (priv->id);
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_KIND) == 0) {
retval = g_variant_new_string (cd_sensor_kind_to_string (priv->kind));
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_STATE) == 0) {
retval = g_variant_new_string (cd_sensor_state_to_string (priv->state));
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_MODE) == 0) {
retval = g_variant_new_string (cd_sensor_cap_to_string (priv->mode));
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_SERIAL) == 0) {
retval = cd_sensor_get_nullable_for_string (priv->serial);
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_MODEL) == 0) {
retval = cd_sensor_get_nullable_for_string (priv->model);
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_VENDOR) == 0) {
retval = cd_sensor_get_nullable_for_string (priv->vendor);
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_NATIVE) == 0) {
retval = g_variant_new_boolean (priv->native);
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_LOCKED) == 0) {
retval = g_variant_new_boolean (priv->locked);
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_EMBEDDED) == 0) {
retval = g_variant_new_boolean (priv->embedded);
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_CAPABILITIES) == 0) {
retval = cd_sensor_get_variant_for_caps (priv->caps);
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_OPTIONS) == 0) {
retval = cd_sensor_get_options_as_variant (sensor);
goto out;
}
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_METADATA) == 0) {
retval = cd_sensor_get_metadata_as_variant (sensor);
goto out;
}
/* return an error */
g_set_error (error,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"failed to get sensor property %s",
property_name);
out:
return retval;
}
int opt_to_gvar(char *key, char *value, struct sr_config *src)
{
const struct sr_config_info *srci;
double tmp_double, dlow, dhigh;
uint64_t tmp_u64, p, q, low, high;
GVariant *rational[2], *range[2];
gboolean tmp_bool;
int ret;
if (!(srci = sr_config_info_name_get(key))) {
g_critical("Unknown device option '%s'.", (char *) key);
return -1;
}
src->key = srci->key;
if ((value == NULL) &&
(srci->datatype != SR_T_BOOL)) {
g_critical("Option '%s' needs a value.", (char *)key);
return -1;
}
ret = 0;
switch (srci->datatype) {
case SR_T_UINT64:
ret = sr_parse_sizestring(value, &tmp_u64);
if (ret != 0)
break;
src->data = g_variant_new_uint64(tmp_u64);
break;
case SR_T_INT32:
ret = sr_parse_sizestring(value, &tmp_u64);
if (ret != 0)
break;
src->data = g_variant_new_int32(tmp_u64);
break;
case SR_T_STRING:
src->data = g_variant_new_string(value);
break;
case SR_T_BOOL:
if (!value)
tmp_bool = TRUE;
else
tmp_bool = sr_parse_boolstring(value);
src->data = g_variant_new_boolean(tmp_bool);
break;
case SR_T_FLOAT:
tmp_double = strtof(value, NULL);
src->data = g_variant_new_double(tmp_double);
break;
case SR_T_RATIONAL_PERIOD:
if ((ret = sr_parse_period(value, &p, &q)) != SR_OK)
break;
rational[0] = g_variant_new_uint64(p);
rational[1] = g_variant_new_uint64(q);
src->data = g_variant_new_tuple(rational, 2);
break;
case SR_T_RATIONAL_VOLT:
if ((ret = sr_parse_voltage(value, &p, &q)) != SR_OK)
break;
rational[0] = g_variant_new_uint64(p);
rational[1] = g_variant_new_uint64(q);
src->data = g_variant_new_tuple(rational, 2);
break;
case SR_T_UINT64_RANGE:
if (sscanf(value, "%"PRIu64"-%"PRIu64, &low, &high) != 2) {
ret = -1;
break;
} else {
range[0] = g_variant_new_uint64(low);
range[1] = g_variant_new_uint64(high);
src->data = g_variant_new_tuple(range, 2);
}
break;
case SR_T_DOUBLE_RANGE:
if (sscanf(value, "%lf-%lf", &dlow, &dhigh) != 2) {
ret = -1;
break;
} else {
range[0] = g_variant_new_double(dlow);
range[1] = g_variant_new_double(dhigh);
src->data = g_variant_new_tuple(range, 2);
}
break;
default:
ret = -1;
}
return ret;
}
static void
nm_ip_up (void *data, int arg)
{
guint32 pppd_made_up_address = htonl (0x0a404040 + ifunit);
ipcp_options opts = ipcp_gotoptions[0];
ipcp_options peer_opts = ipcp_hisoptions[0];
GVariantBuilder builder;
struct sockaddr_in addr;
g_return_if_fail (G_IS_DBUS_PROXY (proxy));
g_message ("nm-sstp-ppp-plugin: (%s): ip-up event", __func__);
if (!opts.ouraddr) {
g_warning ("nm-sstp-ppp-plugin: (%s): didn't receive an internal IP from pppd!", __func__);
return;
}
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&builder, "{sv}",
NM_VPN_PLUGIN_IP4_CONFIG_TUNDEV,
g_variant_new_string (ifname));
g_variant_builder_add (&builder, "{sv}",
NM_VPN_PLUGIN_IP4_CONFIG_ADDRESS,
g_variant_new_uint32 (opts.ouraddr));
/* Request the address of the server sstpc connected to */
if (0 == nm_sstp_getaddr(&addr))
{
/* This will eliminate the need to have nm-sstp-service
* insert a new entry for "gateway" as we have already set it.
*/
g_variant_builder_add (&builder, "{sv}",
NM_VPN_PLUGIN_IP4_CONFIG_EXT_GATEWAY,
g_variant_new_uint32 (addr.sin_addr.s_addr));
}
/* Prefer the peer options remote address first, _unless_ pppd made the
* address up, at which point prefer the local options remote address,
* and if that's not right, use the made-up address as a last resort.
*/
if (peer_opts.hisaddr && (peer_opts.hisaddr != pppd_made_up_address)) {
g_variant_builder_add (&builder, "{sv}",
NM_VPN_PLUGIN_IP4_CONFIG_PTP,
g_variant_new_uint32 (peer_opts.hisaddr));
} else if (opts.hisaddr) {
g_variant_builder_add (&builder, "{sv}",
NM_VPN_PLUGIN_IP4_CONFIG_PTP,
g_variant_new_uint32 (opts.hisaddr));
} else if (peer_opts.hisaddr == pppd_made_up_address) {
/* As a last resort, use the made-up address */
g_variant_builder_add (&builder, "{sv}",
NM_VPN_PLUGIN_IP4_CONFIG_PTP,
g_variant_new_uint32 (peer_opts.ouraddr));
}
g_variant_builder_add (&builder, "{sv}",
NM_VPN_PLUGIN_IP4_CONFIG_PREFIX,
g_variant_new_uint32 (32));
if (opts.dnsaddr[0] || opts.dnsaddr[1]) {
guint32 dns[2];
int len = 0;
if (opts.dnsaddr[0])
dns[len++] = opts.dnsaddr[0];
if (opts.dnsaddr[1])
dns[len++] = opts.dnsaddr[1];
g_variant_builder_add (&builder, "{sv}",
NM_VPN_PLUGIN_IP4_CONFIG_DNS,
g_variant_new_fixed_array (G_VARIANT_TYPE_UINT32,
dns, len, sizeof (guint32)));
}
/* Default MTU to 1400, which is also what Windows XP/Vista use */
g_variant_builder_add (&builder, "{sv}",
NM_VPN_PLUGIN_IP4_CONFIG_MTU,
g_variant_new_uint32 (1400));
g_message ("nm-sstp-ppp-plugin: (%s): sending Ip4Config to NetworkManager-sstp...", __func__);
g_dbus_proxy_call (proxy,
"SetIp4Config",
g_variant_new ("(a{sv})", &builder),
G_DBUS_CALL_FLAGS_NONE, -1,
NULL,
NULL, NULL);
}
void
fe_tray_set_balloon (const char *title, const char *text)
{
#ifndef WIN32
#if 0
const char *argv[8];
const char *path;
char time[16];
#endif
WinStatus ws;
/* no balloons if the window is focused */
ws = tray_get_window_status ();
if ((prefs.hex_away_omit_alerts && hexchat_get_info(ph, "away")) ||
(prefs.hex_gui_focus_omitalerts && ws == WS_FOCUSED))
return;
/* bit 1 of flags means "no balloons unless hidden/iconified" */
if (ws != WS_HIDDEN && prefs.hex_gui_tray_quiet)
return;
/* FIXME: this should close the current balloon */
if (!text)
return;
#ifdef USE_LIBNOTIFY
static int notify_text_strip_flags = STRIP_ALL;
NotifyNotification *notification;
char *notify_text, *notify_title;
if (!notify_is_initted())
{
notify_init(PACKAGE_NAME);
GList* server_caps = notify_get_server_caps ();
if (g_list_find_custom (server_caps, "body-markup", (GCompareFunc)strcmp))
{
notify_text_strip_flags |= STRIP_ESCMARKUP;
}
g_list_free_full (server_caps, g_free);
}
notify_text = strip_color (text, -1, notify_text_strip_flags);
notify_title = strip_color (title, -1, STRIP_ALL);
notification = XC_NOTIFY_NEW (notify_title, notify_text, HEXCHATSHAREDIR "/icons/hicolor/scalable/apps/hexchat.svg", NULL);
#if NOTIFY_CHECK_VERSION(0,7,0)
notify_notification_set_hint (notification, "desktop-entry", g_variant_new_string ("hexchat"));
#endif
g_free ((char *)notify_title);
g_free ((char *)notify_text);
notify_notification_set_timeout (notification, prefs.hex_input_balloon_time*1000);
notify_notification_show (notification, NULL);
g_object_unref (notification);
#endif
#endif
}
gboolean
ot_admin_builtin_set_origin (int argc, char **argv, GCancellable *cancellable, GError **error)
{
gboolean ret = FALSE;
GOptionContext *context;
const char *remotename = NULL;
const char *url = NULL;
const char *branch = NULL;
gs_unref_object OstreeRepo *repo = NULL;
gs_unref_object OstreeSysroot *sysroot = NULL;
OstreeDeployment *target_deployment = NULL;
context = g_option_context_new ("REMOTENAME URL [BRANCH]");
if (!ostree_admin_option_context_parse (context, options, &argc, &argv,
OSTREE_ADMIN_BUILTIN_FLAG_SUPERUSER,
&sysroot, cancellable, error))
goto out;
if (argc < 3)
{
ot_util_usage_error (context, "REMOTENAME and URL must be specified", error);
goto out;
}
remotename = argv[1];
url = argv[2];
if (argc > 3)
branch = argv[3];
if (!ostree_sysroot_load (sysroot, cancellable, error))
goto out;
if (!ostree_sysroot_get_repo (sysroot, &repo, cancellable, error))
goto out;
if (opt_index == -1)
{
target_deployment = ostree_sysroot_get_booted_deployment (sysroot);
if (target_deployment == NULL)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Not currently booted into an OSTree system");
goto out;
}
}
else
{
target_deployment = ot_admin_get_indexed_deployment (sysroot, opt_index, error);
if (!target_deployment)
goto out;
}
{ char **iter;
gs_unref_variant_builder GVariantBuilder *optbuilder =
g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
for (iter = opt_set; iter && *iter; iter++)
{
const char *keyvalue = *iter;
gs_free char *subkey = NULL;
gs_free char *subvalue = NULL;
if (!ot_parse_keyvalue (keyvalue, &subkey, &subvalue, error))
goto out;
g_variant_builder_add (optbuilder, "{s@v}",
subkey, g_variant_new_variant (g_variant_new_string (subvalue)));
}
if (!ostree_repo_remote_change (repo, NULL,
OSTREE_REPO_REMOTE_CHANGE_ADD_IF_NOT_EXISTS,
remotename, url,
g_variant_builder_end (optbuilder),
cancellable, error))
goto out;
}
{ GKeyFile *old_origin = ostree_deployment_get_origin (target_deployment);
gs_free char *origin_refspec = g_key_file_get_string (old_origin, "origin", "refspec", NULL);
gs_free char *new_refspec = NULL;
gs_free char *origin_remote = NULL;
gs_free char *origin_ref = NULL;
if (!ostree_parse_refspec (origin_refspec, &origin_remote, &origin_ref, error))
goto out;
{ gs_free char *new_refspec = g_strconcat (remotename, ":", branch ? branch : origin_ref, NULL);
gs_unref_keyfile GKeyFile *new_origin = NULL;
gs_unref_object GFile *origin_path = NULL;
new_origin = ostree_sysroot_origin_new_from_refspec (sysroot, new_refspec);
if (!ostree_sysroot_write_origin_file (sysroot, target_deployment, new_origin,
cancellable, error))
goto out;
}
}
ret = TRUE;
out:
if (context)
g_option_context_free (context);
return ret;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
struct sr_usb_dev_inst *usb;
char str[128];
const uint64_t *vdiv;
int ch_idx;
switch (key) {
case SR_CONF_NUM_VDIV:
*data = g_variant_new_int32(ARRAY_SIZE(vdivs));
break;
}
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
if (!cg) {
switch (key) {
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(devc->samplerate);
break;
case SR_CONF_LIMIT_MSEC:
*data = g_variant_new_uint64(devc->limit_msec);
break;
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
case SR_CONF_CONN:
if (!sdi->conn)
return SR_ERR_ARG;
usb = sdi->conn;
if (usb->address == 255)
/* Device still needs to re-enumerate after firmware
* upload, so we don't know its (future) address. */
return SR_ERR;
snprintf(str, 128, "%d.%d", usb->bus, usb->address);
*data = g_variant_new_string(str);
break;
default:
return SR_ERR_NA;
}
} else {
if (sdi->channel_groups->data == cg)
ch_idx = 0;
else if (sdi->channel_groups->next->data == cg)
ch_idx = 1;
else
return SR_ERR_ARG;
switch (key) {
case SR_CONF_VDIV:
vdiv = vdivs[devc->voltage[ch_idx]];
*data = g_variant_new("(tt)", vdiv[0], vdiv[1]);
break;
case SR_CONF_COUPLING:
*data = g_variant_new_string(coupling[devc->coupling[ch_idx]]);
break;
}
}
return SR_OK;
}
void proximity_monitor_set_link_loss_alert_level(ProximityMonitor *self, const gchar *value, GError **error)
{
g_assert(PROXIMITY_MONITOR_IS(self));
g_assert(self->priv->properties != NULL);
properties_set(self->priv->properties, PROXIMITY_MONITOR_DBUS_INTERFACE, "LinkLossAlertLevel", g_variant_new_string(value), error);
}
static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
GVariant *gvar, *grange[2];
GVariantBuilder gvb;
double v;
GVariant *range[2];
(void)cg;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
break;
case SR_CONF_SAMPLERATE:
devc = sdi->priv;
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
if (devc->prof->max_sampling_freq == 100) {
gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
samplerates_100, ARRAY_SIZE(samplerates_100),
sizeof(uint64_t));
} else if (devc->prof->max_sampling_freq == 200) {
gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
samplerates_200, ARRAY_SIZE(samplerates_200),
sizeof(uint64_t));
} else {
sr_err("Internal error: Unknown max. samplerate: %d.",
devc->prof->max_sampling_freq);
return SR_ERR_ARG;
}
g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TRIGGER_TYPE:
*data = g_variant_new_string(TRIGGER_TYPE);
break;
case SR_CONF_VOLTAGE_THRESHOLD:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
for (v = -6.0; v <= 6.0; v += 0.1) {
range[0] = g_variant_new_double(v);
range[1] = g_variant_new_double(v);
gvar = g_variant_new_tuple(range, 2);
g_variant_builder_add_value(&gvb, gvar);
}
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_LIMIT_SAMPLES:
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
grange[0] = g_variant_new_uint64(0);
grange[1] = g_variant_new_uint64(devc->max_sample_depth);
*data = g_variant_new_tuple(grange, 2);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static GSList *scan(struct sr_dev_driver *di, GSList *options)
{
struct sr_config default_serialcomm = {
.key = SR_CONF_SERIALCOMM,
.data = g_variant_new_string("9600/8n1"),
};
struct sr_config default_modbusaddr = {
.key = SR_CONF_MODBUSADDR,
.data = g_variant_new_uint64(1),
};
GSList *opts = options, *devices;
if (!g_slist_find_custom(options, &default_serialcomm, config_compare))
opts = g_slist_prepend(opts, &default_serialcomm);
if (!g_slist_find_custom(options, &default_modbusaddr, config_compare))
opts = g_slist_prepend(opts, &default_modbusaddr);
devices = sr_modbus_scan(di->context, opts, probe_device);
while (opts != options)
opts = g_slist_delete_link(opts, opts);
g_variant_unref(default_serialcomm.data);
g_variant_unref(default_modbusaddr.data);
return devices;
}
static int dev_open(struct sr_dev_inst *sdi)
{
struct sr_modbus_dev_inst *modbus = sdi->conn;
if (sr_modbus_open(modbus) < 0)
return SR_ERR;
sdi->status = SR_ST_ACTIVE;
maynuo_m97_set_bit(modbus, PC1, 1);
return SR_OK;
}
static int dev_close(struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct sr_modbus_dev_inst *modbus;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
modbus = sdi->conn;
if (modbus) {
devc = sdi->priv;
if (devc->expecting_registers) {
/* Wait for the last data that was requested from the device. */
uint16_t registers[devc->expecting_registers];
sr_modbus_read_holding_registers(modbus, -1,
devc->expecting_registers,
registers);
}
maynuo_m97_set_bit(modbus, PC1, 0);
if (sr_modbus_close(modbus) < 0)
return SR_ERR;
sdi->status = SR_ST_INACTIVE;
}
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
struct sr_modbus_dev_inst *modbus;
enum maynuo_m97_mode mode;
int ret, ivalue;
float fvalue;
(void)cg;
modbus = sdi->conn;
devc = sdi->priv;
ret = SR_OK;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
case SR_CONF_LIMIT_MSEC:
ret = sr_sw_limits_config_get(&devc->limits, key, data);
break;
case SR_CONF_ENABLED:
if ((ret = maynuo_m97_get_bit(modbus, ISTATE, &ivalue)) == SR_OK)
*data = g_variant_new_boolean(ivalue);
break;
case SR_CONF_REGULATION:
if ((ret = maynuo_m97_get_bit(modbus, UNREG, &ivalue)) != SR_OK)
break;
if (ivalue)
*data = g_variant_new_string("UR");
else if ((ret = maynuo_m97_get_mode(modbus, &mode)) == SR_OK)
*data = g_variant_new_string(maynuo_m97_mode_to_str(mode));
break;
case SR_CONF_VOLTAGE:
if ((ret = maynuo_m97_get_float(modbus, U, &fvalue)) == SR_OK)
*data = g_variant_new_double(fvalue);
break;
case SR_CONF_VOLTAGE_TARGET:
if ((ret = maynuo_m97_get_float(modbus, UFIX, &fvalue)) == SR_OK)
*data = g_variant_new_double(fvalue);
break;
case SR_CONF_CURRENT:
if ((ret = maynuo_m97_get_float(modbus, I, &fvalue)) == SR_OK)
*data = g_variant_new_double(fvalue);
break;
case SR_CONF_CURRENT_LIMIT:
if ((ret = maynuo_m97_get_float(modbus, IFIX, &fvalue)) == SR_OK)
*data = g_variant_new_double(fvalue);
break;
case SR_CONF_OVER_VOLTAGE_PROTECTION_ENABLED:
*data = g_variant_new_boolean(TRUE);
break;
case SR_CONF_OVER_VOLTAGE_PROTECTION_ACTIVE:
if ((ret = maynuo_m97_get_bit(modbus, UOVER, &ivalue)) == SR_OK)
*data = g_variant_new_boolean(ivalue);
break;
case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
if ((ret = maynuo_m97_get_float(modbus, UMAX, &fvalue)) == SR_OK)
*data = g_variant_new_double(fvalue);
break;
case SR_CONF_OVER_CURRENT_PROTECTION_ENABLED:
*data = g_variant_new_boolean(TRUE);
break;
case SR_CONF_OVER_CURRENT_PROTECTION_ACTIVE:
if ((ret = maynuo_m97_get_bit(modbus, IOVER, &ivalue)) == SR_OK)
*data = g_variant_new_boolean(ivalue);
break;
case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
if ((ret = maynuo_m97_get_float(modbus, IMAX, &fvalue)) == SR_OK)
*data = g_variant_new_double(fvalue);
break;
case SR_CONF_OVER_TEMPERATURE_PROTECTION:
*data = g_variant_new_boolean(TRUE);
break;
case SR_CONF_OVER_TEMPERATURE_PROTECTION_ACTIVE:
if ((ret = maynuo_m97_get_bit(modbus, HEAT, &ivalue)) == SR_OK)
*data = g_variant_new_boolean(ivalue);
break;
default:
return SR_ERR_NA;
}
return ret;
}
static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
struct sr_modbus_dev_inst *modbus;
int ret;
(void)cg;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
modbus = sdi->conn;
devc = sdi->priv;
ret = SR_OK;
switch (key) {
case SR_CONF_LIMIT_SAMPLES:
case SR_CONF_LIMIT_MSEC:
ret = sr_sw_limits_config_set(&devc->limits, key, data);
break;
case SR_CONF_ENABLED:
ret = maynuo_m97_set_input(modbus, g_variant_get_boolean(data));
break;
case SR_CONF_VOLTAGE_TARGET:
ret = maynuo_m97_set_float(modbus, UFIX, g_variant_get_double(data));
break;
case SR_CONF_CURRENT_LIMIT:
ret = maynuo_m97_set_float(modbus, IFIX, g_variant_get_double(data));
break;
case SR_CONF_OVER_VOLTAGE_PROTECTION_THRESHOLD:
ret = maynuo_m97_set_float(modbus, UMAX, g_variant_get_double(data));
break;
case SR_CONF_OVER_CURRENT_PROTECTION_THRESHOLD:
ret = maynuo_m97_set_float(modbus, IMAX, g_variant_get_double(data));
break;
default:
ret = SR_ERR_NA;
}
return ret;
}
static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
GVariantBuilder gvb;
int ret;
/* Always available, even without sdi. */
if (key == SR_CONF_SCAN_OPTIONS) {
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
return SR_OK;
} else if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
return SR_OK;
}
if (!sdi)
return SR_ERR_ARG;
devc = sdi->priv;
ret = SR_OK;
if (!cg) {
/* No channel group: global options. */
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
default:
return SR_ERR_NA;
}
} else {
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(uint32_t));
break;
case SR_CONF_VOLTAGE_TARGET:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
/* Min, max, write resolution. */
g_variant_builder_add_value(&gvb, g_variant_new_double(0.0));
g_variant_builder_add_value(&gvb, g_variant_new_double(devc->model->max_voltage));
g_variant_builder_add_value(&gvb, g_variant_new_double(0.001));
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_CURRENT_LIMIT:
g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
/* Min, max, step. */
g_variant_builder_add_value(&gvb, g_variant_new_double(0.0));
g_variant_builder_add_value(&gvb, g_variant_new_double(devc->model->max_current));
g_variant_builder_add_value(&gvb, g_variant_new_double(0.0001));
*data = g_variant_builder_end(&gvb);
break;
default:
return SR_ERR_NA;
}
}
return ret;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct sr_modbus_dev_inst *modbus;
int ret;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
modbus = sdi->conn;
devc = sdi->priv;
if ((ret = sr_modbus_source_add(sdi->session, modbus, G_IO_IN, 10,
maynuo_m97_receive_data, (void *)sdi)) != SR_OK)
return ret;
sr_sw_limits_acquisition_start(&devc->limits);
std_session_send_df_header(sdi);
return maynuo_m97_capture_start(sdi);
}
static int dev_acquisition_stop(struct sr_dev_inst *sdi)
{
struct sr_modbus_dev_inst *modbus;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
std_session_send_df_end(sdi);
modbus = sdi->conn;
sr_modbus_source_remove(sdi->session, modbus);
return SR_OK;
}
static struct sr_dev_driver maynuo_m97_driver_info = {
.name = "maynuo-m97",
.longname = "maynuo M97/M98 series",
.api_version = 1,
.init = std_init,
.cleanup = std_cleanup,
.scan = scan,
.dev_list = std_dev_list,
.config_get = config_get,
.config_set = config_set,
.config_list = config_list,
.dev_open = dev_open,
.dev_close = dev_close,
.dev_acquisition_start = dev_acquisition_start,
.dev_acquisition_stop = dev_acquisition_stop,
.context = NULL,
};
SR_REGISTER_DEV_DRIVER(maynuo_m97_driver_info);
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 void
write_translations_dictionary (GList * licenses, const gchar * dict_filename)
{
/* maps C string => (dictionary of: locale => translation) */
GVariantBuilder array;
/* maps C string => boolean (if it's in the dictionary already */
GHashTable *translations;
GVariant *var;
GList *l;
FILE *f;
/* sort langs for prettiness / to make variant dumps easier to read */
langs = g_list_sort (langs, (GCompareFunc) strcmp);
g_variant_builder_init (&array, G_VARIANT_TYPE_ARRAY);
translations = g_hash_table_new (g_str_hash, g_str_equal);
for (l = licenses; l != NULL; l = l->next) {
const gchar *en;
License *license;
license = l->data;
if (license->packed_into_source)
continue;
/* add title + translations */
en = g_hash_table_lookup (license->titles, "en");
g_assert (en != NULL);
/* check if we already have added translations for this string */
if (!g_hash_table_lookup (translations, (gpointer) en)) {
GVariant *trans;
trans = create_translation_dict (license->titles, en);
if (trans != NULL) {
g_variant_builder_add_value (&array,
g_variant_new_dict_entry (g_variant_new_string (en), trans));
g_hash_table_insert (translations, (gpointer) en,
GINT_TO_POINTER (TRUE));
}
}
/* add description + translations */
if (license->descriptions == NULL)
continue;
en = g_hash_table_lookup (license->descriptions, "en");
g_assert (en != NULL);
/* check if we already have added translations for this string */
if (!g_hash_table_lookup (translations, (gpointer) en)) {
GVariant *trans;
trans = create_translation_dict (license->descriptions, en);
if (trans != NULL) {
g_variant_builder_add_value (&array,
g_variant_new_dict_entry (g_variant_new_string (en), trans));
g_hash_table_insert (translations, (gpointer) en,
GINT_TO_POINTER (TRUE));
}
}
}
var = g_variant_builder_end (&array);
f = fopen (dict_filename, "wb");
if (fwrite (g_variant_get_data (var), g_variant_get_size (var), 1, f) != 1) {
g_error ("failed to write dict to file: %s", g_strerror (errno));
}
fclose (f);
g_printerr ("Wrote dictionary to %s, size: %u, type: %s\n", dict_filename,
(guint) g_variant_get_size (var), (gchar *) g_variant_get_type (var));
g_variant_unref (var);
g_hash_table_destroy (translations);
}
