unsigned char bluez_characteristic_extract_value(GVariant* variant)
{
GVariant* var_array = g_variant_get_child_value(variant, 0);
for(unsigned int i = 0; i < g_variant_n_children(var_array); i++)
{
GVariant* var_child = g_variant_get_child_value(var_array, i);
if(g_variant_n_children(var_child) == 2)
{
GVariant* var_id = g_variant_get_child_value(var_child, 0);
if(g_variant_type_equal(g_variant_get_type(var_id), G_VARIANT_TYPE_STRING) &&
g_strcmp0(g_variant_get_string(var_id, NULL), "Value") == 0)
{
GVariant* inner_var = g_variant_get_child_value(var_child, 1);
if( g_variant_type_equal(g_variant_get_type(inner_var), G_VARIANT_TYPE_VARIANT) )
{
GVariant* var_value = g_variant_get_variant(inner_var);
if( g_variant_type_equal(g_variant_get_type(var_value), G_VARIANT_TYPE_BYTESTRING) )
{
GVariant* var_byte = g_variant_get_child_value(var_value, 0);
return g_variant_get_byte(var_byte);
}
}
}
}
g_variant_unref(var_child);
}
return 0;
}
static void
bluez_handle_disconnect(GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
// check if parameter is valid and is the parameter we were looking for
if( !(g_variant_type_equal(g_variant_get_type(parameters), "(sv)") &&
g_variant_n_children(parameters) == 2) )
return;
GVariant* name = g_variant_get_child_value(parameters, 0);
GVariant* value = g_variant_get_variant(g_variant_get_child_value(parameters, 1));
if( !(g_strcmp0(g_variant_get_string(name, NULL), "Connected") == 0 &&
g_variant_type_equal(g_variant_get_type(value), G_VARIANT_TYPE_BOOLEAN) ) )
return;
gboolean connected = g_variant_get_boolean(value);
g_printf("Connected: %d\n", connected);
if(!connected)
{
gchar* device_path = (gchar*)user_data;
gchar* service_path = g_strconcat(device_path, "/service0007", NULL);
bluez_unregister_watcher(connection, service_path);
bluez_register_watcher(connection, service_path);
}
}
boost::shared_ptr<AuthProvider> createSignonAuthProvider(const InitStateString &username,
const InitStateString &password)
{
// Expected content of parameter GVariant.
boost::shared_ptr<GVariantType> hashtype(g_variant_type_new("a{sv}"), g_variant_type_free);
// 'username' is the part after signon: which we can parse directly.
GErrorCXX gerror;
GVariantCXX parametersVar(g_variant_parse(hashtype.get(), username.c_str(), NULL, NULL, gerror),
TRANSFER_REF);
if (!parametersVar) {
gerror.throwError(SE_HERE, "parsing 'signon:' username");
}
GHashTableCXX parameters(Variant2HashTable(parametersVar));
// Extract the values that we expect in the parameters hash.
guint32 signonID;
const char *method;
const char *mechanism;
GVariant *value;
value = (GVariant *)g_hash_table_lookup(parameters, "identity");
if (!value ||
!g_variant_type_equal(G_VARIANT_TYPE_UINT32, g_variant_get_type(value))) {
SE_THROW("need 'identity: <numeric ID>' in 'signon:' parameters");
}
signonID = g_variant_get_uint32(value);
value = (GVariant *)g_hash_table_lookup(parameters, "method");
if (!value ||
!g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) {
SE_THROW("need 'method: <string>' in 'signon:' parameters");
}
method = g_variant_get_string(value, NULL);
value = (GVariant *)g_hash_table_lookup(parameters, "mechanism");
if (!value ||
!g_variant_type_equal(G_VARIANT_TYPE_STRING, g_variant_get_type(value))) {
SE_THROW("need 'mechanism: <string>' in 'signon:' parameters");
}
mechanism = g_variant_get_string(value, NULL);
value = (GVariant *)g_hash_table_lookup(parameters, "session");
if (!value ||
!g_variant_type_equal(hashtype.get(), g_variant_get_type(value))) {
SE_THROW("need 'session: <hash>' in 'signon:' parameters");
}
GHashTableCXX sessionData(Variant2HashTable(value));
SE_LOG_DEBUG(NULL, "using identity %u, method %s, mechanism %s",
signonID, method, mechanism);
SignonIdentityCXX identity(signon_identity_new_from_db(signonID), TRANSFER_REF);
SE_LOG_DEBUG(NULL, "using signond identity %d", signonID);
SignonAuthSessionCXX authSession(signon_identity_create_session(identity, method, gerror), TRANSFER_REF);
boost::shared_ptr<AuthProvider> provider(new SignonAuthProvider(authSession, sessionData, mechanism));
return provider;
}
static void
settings_changed (GSettings *settings,
gchar *key,
gpointer data)
{
GVariant *value;
const GVariantType *type;
MetaEnumPreference *cursor;
gboolean found_enum;
/* String array, handled separately */
if (strcmp (key, KEY_WORKSPACE_NAMES) == 0)
{
if (update_workspace_names ());
queue_changed (META_PREF_WORKSPACE_NAMES);
return;
}
value = g_settings_get_value (settings, key);
type = g_variant_get_type (value);
if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
handle_preference_update_bool (settings, key);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
handle_preference_update_int (settings, key);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
cursor = preferences_enum;
found_enum = FALSE;
while (cursor->base.key != NULL)
{
if (strcmp (key, cursor->base.key) == 0)
found_enum = TRUE;
cursor++;
}
if (found_enum)
handle_preference_update_enum (settings, key);
else
handle_preference_update_string (settings, key);
}
else
/* Someone added a preference of an unhandled type */
g_assert_not_reached ();
g_variant_unref (value);
}
static gboolean
g_settings_get_mapping_unsigned_int (GValue *value,
GVariant *variant)
{
const GVariantType *type;
guint64 u;
type = g_variant_get_type (variant);
if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
u = g_variant_get_uint16 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
u = g_variant_get_uint32 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
u = g_variant_get_uint64 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
u = g_variant_get_handle (variant);
else
return FALSE;
if (G_VALUE_HOLDS_INT (value))
{
g_value_set_int (value, u);
return (u <= G_MAXINT32);
}
else if (G_VALUE_HOLDS_UINT (value))
{
g_value_set_uint (value, u);
return (u <= G_MAXUINT32);
}
else if (G_VALUE_HOLDS_INT64 (value))
{
g_value_set_int64 (value, u);
return (u <= G_MAXINT64);
}
else if (G_VALUE_HOLDS_UINT64 (value))
{
g_value_set_uint64 (value, u);
return (u <= G_MAXUINT64);
}
else if (G_VALUE_HOLDS_DOUBLE (value))
{
g_value_set_double (value, u);
return TRUE;
}
return FALSE;
}
SR_PRIV int scpi_cmd_resp(const struct sr_dev_inst *sdi, const struct scpi_command *cmdtable,
GVariant **gvar, const GVariantType *gvtype, int command, ...)
{
struct sr_scpi_dev_inst *scpi;
va_list args;
double d;
int ret;
char *s;
const char *cmd;
if (!(cmd = scpi_cmd_get(cmdtable, command))) {
/* Device does not implement this command, that's OK. */
return SR_OK;
}
scpi = sdi->conn;
va_start(args, command);
ret = sr_scpi_send_variadic(scpi, cmd, args);
va_end(args);
if (ret != SR_OK)
return ret;
/* Straight SCPI getters to GVariant types. */
if (g_variant_type_equal(gvtype, G_VARIANT_TYPE_BOOLEAN)) {
if ((ret = sr_scpi_get_string(scpi, NULL, &s)) != SR_OK)
return ret;
if (!g_ascii_strcasecmp(s, "ON") || !g_ascii_strcasecmp(s, "1")
|| !g_ascii_strcasecmp(s, "YES"))
*gvar = g_variant_new_boolean(TRUE);
else if (!g_ascii_strcasecmp(s, "OFF") || !g_ascii_strcasecmp(s, "0")
|| !g_ascii_strcasecmp(s, "NO"))
*gvar = g_variant_new_boolean(FALSE);
else
ret = SR_ERR;
g_free(s);
} if (g_variant_type_equal(gvtype, G_VARIANT_TYPE_DOUBLE)) {
if ((ret = sr_scpi_get_double(scpi, NULL, &d)) == SR_OK)
*gvar = g_variant_new_double(d);
} if (g_variant_type_equal(gvtype, G_VARIANT_TYPE_STRING)) {
if ((ret = sr_scpi_get_string(scpi, NULL, &s)) == SR_OK)
*gvar = g_variant_new_string(s);
} else {
sr_err("Unable to convert to desired GVariant type.");
ret = SR_ERR_NA;
}
return ret;
}
static void
tm_populate(GtkWidget * toolbar, BalsaToolbarModel * model)
{
gboolean style_is_both;
gboolean make_two_line;
GArray *current;
guint j;
GActionMap *action_map =
g_object_get_data(G_OBJECT(toolbar), BALSA_TOOLBAR_ACTION_MAP);
style_is_both = (model->style == GTK_TOOLBAR_BOTH
|| (model->style == (GtkToolbarStyle) - 1
&& tm_default_style() == GTK_TOOLBAR_BOTH));
make_two_line = style_is_both && tm_has_second_line(model);
current = balsa_toolbar_model_get_current(model);
for (j = 0; j < current->len; j++) {
BalsaToolbarEntry *entry;
GtkToolItem *item;
entry = &g_array_index(current, BalsaToolbarEntry, j);
if (!*entry->action) {
item = gtk_separator_tool_item_new();
} else {
GtkWidget *icon;
GAction *action;
const GVariantType *type;
gchar *prefixed_action;
icon = gtk_image_new_from_icon_name
(balsa_icon_id(entry->icon), GTK_ICON_SIZE_SMALL_TOOLBAR);
action = g_action_map_lookup_action(action_map, entry->action);
if (action &&
(type = g_action_get_state_type(action)) &&
g_variant_type_equal(type, G_VARIANT_TYPE_BOOLEAN)) {
item = gtk_toggle_tool_button_new();
g_object_set(G_OBJECT(item), "icon-widget", icon,
"label", entry->action, NULL);
} else {
item = gtk_tool_button_new(icon, entry->action);
}
tm_set_tool_item_label(GTK_TOOL_ITEM(item), entry->icon,
make_two_line);
prefixed_action =
g_strconcat(action ? "win." : "app.", entry->action, NULL);
gtk_actionable_set_action_name(GTK_ACTIONABLE(item),
prefixed_action);
g_free(prefixed_action);
}
gtk_toolbar_insert((GtkToolbar *) toolbar, item, -1);
}
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar),
model->style != (GtkToolbarStyle) (-1) ?
model->style : tm_default_style());
gtk_widget_show_all(toolbar);
}
SR_PRIV int sr_variant_type_check(uint32_t key, GVariant *value)
{
const struct sr_key_info *info;
const GVariantType *type, *expected;
char *expected_string, *type_string;
info = sr_key_info_get(SR_KEY_CONFIG, key);
if (!info)
return SR_OK;
expected = sr_variant_type_get(info->datatype);
type = g_variant_get_type(value);
if (!g_variant_type_equal(type, expected)
&& !g_variant_type_is_subtype_of(type, expected)) {
expected_string = g_variant_type_dup_string(expected);
type_string = g_variant_type_dup_string(type);
sr_err("Wrong variant type for key '%s': expected '%s', got '%s'",
info->name, expected_string, type_string);
g_free(expected_string);
g_free(type_string);
return SR_ERR_ARG;
}
return SR_OK;
}
static void
services_changed(GVariant *params)
{
connman_service_t *prev = NULL, *cs;
GVariant *del = g_variant_get_child_value(params, 1);
for(int i = 0, n = g_variant_n_children(del); i < n; i++) {
GVariant *v = g_variant_get_child_value(del, i);
if(g_variant_type_equal(g_variant_get_type(v),
G_VARIANT_TYPE_OBJECT_PATH)) {
const char *name = g_variant_get_string(v, NULL);
TRACE(TRACE_DEBUG, "CONNMAN", "Deleted network %s", name);
if((cs = connman_service_find(name)) != NULL)
connman_service_destroy(cs);
}
}
GVariant *add = g_variant_get_child_value(params, 0);
for(int i = 0, n = g_variant_n_children(add); i < n; i++) {
GVariant *v = g_variant_get_child_value(add, i);
const char *id =
g_variant_get_string(g_variant_get_child_value(v, 0), NULL);
cs = update_service(g_variant_get_child_value(v, 1), id, prev);
if(cs != NULL)
prev = cs;
}
}
static gboolean
g_settings_get_mapping_int (GValue *value,
GVariant *variant)
{
const GVariantType *type;
gint64 l;
type = g_variant_get_type (variant);
if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
l = g_variant_get_int16 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
l = g_variant_get_int32 (variant);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
l = g_variant_get_int64 (variant);
else
return FALSE;
if (G_VALUE_HOLDS_INT (value))
{
g_value_set_int (value, l);
return (G_MININT32 <= l && l <= G_MAXINT32);
}
else if (G_VALUE_HOLDS_UINT (value))
{
g_value_set_uint (value, l);
return (0 <= l && l <= G_MAXUINT32);
}
else if (G_VALUE_HOLDS_INT64 (value))
{
g_value_set_int64 (value, l);
return (G_MININT64 <= l && l <= G_MAXINT64);
}
else if (G_VALUE_HOLDS_UINT64 (value))
{
g_value_set_uint64 (value, l);
return (0 <= l && l <= G_MAXUINT64);
}
else if (G_VALUE_HOLDS_DOUBLE (value))
{
g_value_set_double (value, l);
return TRUE;
}
return FALSE;
}
static void
build_json_dictionary (JsonBuilder *builder,
const GVariantType *entry_type,
GVariant *dict)
{
const GVariantType *key_type;
GVariantIter iter;
GVariant *child;
GVariant *key;
GVariant *value;
gboolean is_string;
gchar *key_string;
json_builder_begin_object (builder);
key_type = g_variant_type_key (entry_type);
is_string = (g_variant_type_equal (key_type, G_VARIANT_TYPE_STRING) ||
g_variant_type_equal (key_type, G_VARIANT_TYPE_OBJECT_PATH) ||
g_variant_type_equal (key_type, G_VARIANT_TYPE_SIGNATURE));
g_variant_iter_init (&iter, dict);
while ((child = g_variant_iter_next_value (&iter)) != NULL)
{
key = g_variant_get_child_value (child, 0);
value = g_variant_get_child_value (child, 1);
if (is_string)
{
json_builder_set_member_name (builder, g_variant_get_string (key, NULL));
}
else
{
key_string = g_variant_print (key, FALSE);
json_builder_set_member_name (builder, key_string);
g_free (key_string);
}
build_json (builder, value);
g_variant_unref (key);
g_variant_unref (value);
}
json_builder_end_object (builder);
}
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 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)
{
if(g_strcmp0(method_name, "ValueChanged") == 0)
{
for(unsigned int j = 0; j < g_variant_n_children(parameters); j++)
{
GVariant* var_child = g_variant_get_child_value(parameters, j);
if( g_variant_type_equal(g_variant_get_type(var_child), G_VARIANT_TYPE_OBJECT_PATH) )
g_printf("%s\n", g_variant_get_string(var_child, NULL));
else if( g_variant_type_equal(g_variant_get_type(var_child), "ay") )
{
BLEThread* thread = (BLEThread*)user_data;
GVariant* var_state = g_variant_get_child_value(var_child, 0);
thread->setState(g_variant_get_byte(var_state));
for(unsigned int i = 0; i < g_variant_n_children(var_child); i++)
{
GVariant* var_inner_child = g_variant_get_child_value(var_child, i);
if( g_variant_type_equal(g_variant_get_type(var_inner_child), G_VARIANT_TYPE_BYTE) )
g_printf("%02x ", g_variant_get_byte(var_inner_child));
}
g_printf("\n");
}
g_variant_unref(var_child);
}
}
else
{
g_printf("Received method with name %s\n", method_name);
}
}
static gboolean
type_allows_choices (const GVariantType *type)
{
if (g_variant_type_is_array (type) ||
g_variant_type_is_maybe (type))
return type_allows_choices (g_variant_type_element (type));
return g_variant_type_equal (type, G_VARIANT_TYPE_STRING);
}
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 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;
}
std::string StringFromVariant(GVariant* variant)
{
std::stringstream ss;
const GVariantType* info_hint_type = g_variant_get_type(variant);
if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_BOOLEAN))
{
ss << g_variant_get_int16(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT16))
{
ss << g_variant_get_int16(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT16))
{
ss << g_variant_get_uint16(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT32))
{
ss << g_variant_get_int32(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT32))
{
ss << g_variant_get_uint32(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_INT64))
{
ss << g_variant_get_int64(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_UINT64))
{
ss << g_variant_get_uint64(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_DOUBLE))
{
ss << g_variant_get_double(variant);
}
else if (g_variant_type_equal(info_hint_type, G_VARIANT_TYPE_STRING))
{
std::string str = g_variant_get_string(variant, NULL);
ss << str;
}
else
{
ss << "unknown value";
}
return ss.str();
}
static gboolean
type_uint32 (GSettings *settings,
const gchar *key)
{
const GVariantType *type;
GVariant *value;
value = g_settings_get_value (settings, key);
type = g_variant_get_type (value);
g_variant_unref (value);
return g_variant_type_equal (type, G_VARIANT_TYPE_UINT32);
}
/*
* settings_enum_set_mapping:
* @property_value: value of the object property the setting is bound to.
* @expected_type: GVariant type the setting expects.
* @enum_values: an array of strings with %NULL as a sentinel at the end.
*
* Custom mapping function for setting combo boxes from enum GSettings keys.
*
* Returns: the #GVariant for the setting, or %NULL on failure.
*/
GVariant *
settings_enum_set_mapping(const GValue *property_value, const GVariantType *expected_type, char **enum_values)
{
int count = 0, index;
g_assert(g_variant_type_equal(expected_type, G_VARIANT_TYPE_STRING));
/* Count the number of values */
while(enum_values[count])
count++;
index = g_value_get_int(property_value);
if(index >= count)
return NULL;
return g_variant_new_string(enum_values[index]);
}
static GVariant*
pd_rgba_to_string_mapping (const GValue *value,
const GVariantType *expected_type,
gpointer user_data)
{
GVariant *variant = NULL;
GdkRGBA *color;
gchar *hex_val;
g_return_val_if_fail (G_VALUE_TYPE (value) == GDK_TYPE_RGBA, 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 = gdk_rgba_to_string(color);
variant = g_variant_new_string (hex_val);
g_free (hex_val);
return variant;
}
static gboolean
iter_get_variant (GVariant *variant,
DataType data_type,
gulong attr_type,
GckBuilder *builder)
{
IterGetFunc func = NULL;
gboolean ret;
const GVariantType *sig;
g_assert (variant != NULL);
g_assert (builder != NULL);
switch (data_type) {
case DATA_TYPE_STRING:
func = iter_get_string;
sig = G_VARIANT_TYPE_STRING;
break;
case DATA_TYPE_BOOL:
func = iter_get_bool;
sig = G_VARIANT_TYPE_BOOLEAN;
break;
case DATA_TYPE_TIME:
func = iter_get_time;
sig = G_VARIANT_TYPE_UINT64;
break;
case DATA_TYPE_FIELDS:
func = iter_get_fields;
sig = G_VARIANT_TYPE ("a{ss}");
break;
default:
g_assert (FALSE);
break;
}
ret = g_variant_type_equal (g_variant_get_type (variant), sig);
if (ret == FALSE)
return FALSE;
return (func) (variant, attr_type, builder);
}
/**
* workman_attribute_set_value:
* @attr: a #WorkmanAttribute
* @value: (transfer floating): the attribute %G_VARIANT_TYPE_MAYBE value to set
* @error: (allow-none): return location for a #GError, or %NULL
*
* Returns: %TRUE if the operation succeeded
*/
gboolean
workman_attribute_set_value(WorkmanAttribute *attr,
GVariant *value,
GError **error)
{
g_return_val_if_fail(value != NULL, FALSE);
if (attr->priv->value) {
const GVariantType *old_type = g_variant_get_type(attr->priv->value);
const GVariantType *new_type = g_variant_get_type(value);
g_return_val_if_fail(g_variant_type_equal(old_type, new_type),
FALSE);
g_variant_unref(attr->priv->value);
}
attr->priv->value = value;
g_variant_ref_sink(attr->priv->value);
return TRUE;
}
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;
}
/**
* Set one or more options in a decoder instance.
*
* Handled options are removed from the hash.
*
* @param di Decoder instance.
* @param options A GHashTable of options to set.
*
* @return SRD_OK upon success, a (negative) error code otherwise.
*
* @since 0.1.0
*/
SRD_API int srd_inst_option_set(struct srd_decoder_inst *di,
GHashTable *options)
{
struct srd_decoder_option *sdo;
PyObject *py_di_options, *py_optval;
GVariant *value;
GSList *l;
double val_double;
gint64 val_int;
int ret;
const char *val_str;
if (!di) {
srd_err("Invalid decoder instance.");
return SRD_ERR_ARG;
}
if (!options) {
srd_err("Invalid options GHashTable.");
return SRD_ERR_ARG;
}
if (!PyObject_HasAttrString(di->decoder->py_dec, "options")) {
/* Decoder has no options. */
if (g_hash_table_size(options) == 0) {
/* No options provided. */
return SRD_OK;
} else {
srd_err("Protocol decoder has no options.");
return SRD_ERR_ARG;
}
return SRD_OK;
}
ret = SRD_ERR_PYTHON;
py_optval = NULL;
/*
* The 'options' tuple is a class variable, but we need to
* change it. Changing it directly will affect the entire class,
* so we need to create a new object for it, and populate that
* instead.
*/
if (!(py_di_options = PyObject_GetAttrString(di->py_inst, "options")))
goto err_out;
Py_DECREF(py_di_options);
py_di_options = PyDict_New();
PyObject_SetAttrString(di->py_inst, "options", py_di_options);
for (l = di->decoder->options; l; l = l->next) {
sdo = l->data;
if ((value = g_hash_table_lookup(options, sdo->id))) {
/* A value was supplied for this option. */
if (!g_variant_type_equal(g_variant_get_type(value),
g_variant_get_type(sdo->def))) {
srd_err("Option '%s' should have the same type "
"as the default value.", sdo->id);
goto err_out;
}
} else {
/* Use default for this option. */
value = sdo->def;
}
if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING)) {
val_str = g_variant_get_string(value, NULL);
if (!(py_optval = PyUnicode_FromString(val_str))) {
/* Some UTF-8 encoding error. */
PyErr_Clear();
srd_err("Option '%s' requires a UTF-8 string value.", sdo->id);
goto err_out;
}
} else if (g_variant_is_of_type(value, G_VARIANT_TYPE_INT64)) {
val_int = g_variant_get_int64(value);
if (!(py_optval = PyLong_FromLong(val_int))) {
/* ValueError Exception */
PyErr_Clear();
srd_err("Option '%s' has invalid integer value.", sdo->id);
goto err_out;
}
} else if (g_variant_is_of_type(value, G_VARIANT_TYPE_DOUBLE)) {
val_double = g_variant_get_double(value);
if (!(py_optval = PyFloat_FromDouble(val_double))) {
/* ValueError Exception */
PyErr_Clear();
srd_err("Option '%s' has invalid float value.",
sdo->id);
goto err_out;
}
}
if (PyDict_SetItemString(py_di_options, sdo->id, py_optval) == -1)
goto err_out;
/* Not harmful even if we used the default. */
g_hash_table_remove(options, sdo->id);
}
if (g_hash_table_size(options) != 0)
srd_warn("Unknown options specified for '%s'", di->inst_id);
ret = SRD_OK;
err_out:
Py_XDECREF(py_optval);
if (PyErr_Occurred()) {
srd_exception_catch("Stray exception in srd_inst_option_set()");
ret = SRD_ERR_PYTHON;
}
return ret;
}
void
ccsGSettingsIntegratedSettingWriteValue (CCSIntegratedSetting *setting, CCSSettingValue *v, CCSSettingType type)
{
CCSGSettingsIntegratedSettingPrivate *priv = (CCSGSettingsIntegratedSettingPrivate *) ccsObjectGetPrivate (setting);
const char *gnomeKeyName = ccsGNOMEIntegratedSettingInfoGetGNOMEName ((CCSGNOMEIntegratedSettingInfo *) setting);
char *gsettingsTranslatedName = ccsGSettingsIntegratedSettingsTranslateOldGNOMEKeyForGSettings (gnomeKeyName);
GVariant *variant = ccsGSettingsWrapperGetValue (priv->wrapper, gsettingsTranslatedName);
const GVariantType *variantType = g_variant_get_type (variant);
GVariant *newVariant = NULL;
if (!variant)
{
ccsError ("NULL encountered while reading GSettings value");
free (gsettingsTranslatedName);
return;
}
switch (type)
{
case TypeInt:
{
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE_INT32))
ccsError ("Expected integer value");
else
{
int currentValue = readIntFromVariant (variant);
if ((currentValue != v->value.asInt))
writeIntToVariant (v->value.asInt, &newVariant);
}
}
break;
case TypeBool:
{
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE_BOOLEAN))
ccsError ("Expected boolean value");
else
{
gboolean currentValue = readBoolFromVariant (variant);
if ((currentValue != v->value.asBool))
writeBoolToVariant (v->value.asBool, &newVariant);
}
}
break;
case TypeString:
{
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE_STRING))
ccsError ("Expected string value");
else
{
const char *defaultValue = "";
const char *newValue = v->value.asString ? v->value.asString : defaultValue;
gsize len = 0;
const gchar *currentValue = g_variant_get_string (variant, &len);
if (currentValue)
{
if (strcmp (currentValue, newValue) != 0)
writeStringToVariant (newValue, &newVariant);
}
}
}
break;
case TypeKey:
{
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE ("as")))
ccsError ("Expected array-of-string value");
else
{
const char *defaultValue = "";
GVariantBuilder strvBuilder;
g_variant_builder_init (&strvBuilder, G_VARIANT_TYPE ("as"));
g_variant_builder_add (&strvBuilder, "s", v->value.asString ? v->value.asString : defaultValue);
newVariant = g_variant_builder_end (&strvBuilder);
}
}
break;
default:
g_assert_not_reached ();
break;
}
/* g_settings_set_value consumes the reference */
if (newVariant)
ccsGSettingsWrapperSetValue (priv->wrapper, gsettingsTranslatedName, newVariant);
else
ccsGSettingsWrapperResetKey (priv->wrapper, gsettingsTranslatedName);
g_variant_unref (variant);
free (gsettingsTranslatedName);
}
static NimfSettingsPage *
nimf_settings_page_new (NimfSettings *nsettings,
const gchar *schema_id)
{
NimfSettingsPage *page;
GSettingsSchema *schema;
GList *key_list = NULL;
gchar **keys;
GList *l;
gint i;
page = g_slice_new0 (NimfSettingsPage);
page->gsettings = g_settings_new (schema_id);
page->label = nimf_settings_page_build_label (page, schema_id);
page->box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 15);
page->page_keys = g_ptr_array_new_with_free_func ((GDestroyNotify) nimf_settings_page_key_free);
#if GTK_CHECK_VERSION (3, 12, 0)
gtk_widget_set_margin_start (page->box, 15);
gtk_widget_set_margin_end (page->box, 15);
#else
gtk_widget_set_margin_left (page->box, 15);
gtk_widget_set_margin_right (page->box, 15);
#endif
gtk_widget_set_margin_top (page->box, 15);
gtk_widget_set_margin_bottom (page->box, 15);
schema = g_settings_schema_source_lookup (nsettings->schema_source,
schema_id, TRUE);
#if GLIB_CHECK_VERSION (2, 46, 0)
keys = g_settings_schema_list_keys (schema);
#else
keys = g_settings_list_keys (page->gsettings);
#endif
for (i = 0; keys[i] != NULL; i++)
key_list = g_list_prepend (key_list, keys[i]);
key_list = g_list_sort (key_list, (GCompareFunc) on_comparison);
for (i = 0, l = key_list; l != NULL; l = l->next, i++)
{
GVariant *variant;
GSettingsSchemaKey *schema_key = NULL;
NimfSettingsPageKey *page_key;
const GVariantType *type;
const gchar *key;
const gchar *summary;
const gchar *desc;
key = l->data;
if (g_str_has_prefix (key, "hidden-"))
continue;
variant = g_settings_get_value (page->gsettings, key);
type = g_variant_get_type (variant);
schema_key = g_settings_schema_get_key (schema, key);
summary = g_settings_schema_key_get_summary (schema_key);
desc = g_settings_schema_key_get_description (schema_key);
page_key = nimf_settings_page_key_new (page->gsettings, key, summary, desc);
g_ptr_array_add (page->page_keys, page_key);
if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
{
GtkWidget *item;
item = nimf_settings_page_key_build_boolean (page_key);
gtk_box_pack_start (GTK_BOX (page->box), item, FALSE, FALSE, 0);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
GtkWidget *item;
item = nimf_settings_page_key_build_string (page_key, schema_id, key_list);
gtk_box_pack_start (GTK_BOX (page->box), item, FALSE, FALSE, 0);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING_ARRAY))
{
GtkWidget *item;
item = nimf_settings_page_key_build_string_array (page_key);
gtk_box_pack_start (GTK_BOX (page->box), item, FALSE, FALSE, 0);
}
else
g_error (G_STRLOC ": %s: not supported variant type: \"%s\"",
G_STRFUNC, (gchar *) type);
g_settings_schema_key_unref (schema_key);
g_variant_unref (variant);
}
g_strfreev (keys);
g_list_free (key_list);
g_settings_schema_unref (schema);
return page;
}
CCSSettingValue *
ccsGSettingsIntegratedSettingReadValue (CCSIntegratedSetting *setting, CCSSettingType type)
{
CCSGSettingsIntegratedSettingPrivate *priv = (CCSGSettingsIntegratedSettingPrivate *) ccsObjectGetPrivate (setting);
CCSSettingValue *v = calloc (1, sizeof (CCSSettingValue));
const char *gnomeKeyName = ccsGNOMEIntegratedSettingInfoGetGNOMEName ((CCSGNOMEIntegratedSettingInfo *) setting);
char *gsettingsTranslatedName = ccsGSettingsIntegratedSettingsTranslateOldGNOMEKeyForGSettings (gnomeKeyName);
v->isListChild = FALSE;
v->parent = NULL;
v->refCount = 1;
GVariant *variant = ccsGSettingsWrapperGetValue (priv->wrapper, gsettingsTranslatedName);
if (!variant)
{
free (gsettingsTranslatedName);
free (v);
return NULL;
}
const GVariantType *variantType = G_VARIANT_TYPE (g_variant_get_type_string (variant));
switch (type)
{
case TypeInt:
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE_INT32))
{
ccsError ("Expected integer value");
free (v);
v = NULL;
break;
}
v->value.asInt = readIntFromVariant (variant);
break;
case TypeBool:
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE_BOOLEAN))
{
ccsError ("Expected boolean value");
free (v);
v = NULL;
break;
}
v->value.asBool = readBoolFromVariant (variant);
break;
case TypeString:
{
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE_STRING))
{
ccsError ("Expected string value");
free (v);
v = NULL;
break;
}
const char *str = readStringFromVariant (variant);
v->value.asString = strdup (str ? str : "");
break;
}
case TypeKey:
{
if (!g_variant_type_equal (variantType, G_VARIANT_TYPE ("as")))
{
ccsError ("Expected array-of-string value");
free (v);
v = NULL;
break;
}
gsize len;
const gchar **strv = g_variant_get_strv (variant, &len);
if (strv)
v->value.asString = strdup (strv[0] ? strv[0] : "");
else
v->value.asString = strdup ("");
g_free (strv);
break;
}
default:
g_assert_not_reached ();
}
g_variant_unref (variant);
free (gsettingsTranslatedName);
return v;
}
/**
* Convert a GVariant to a Scheme object. Returns NULL if there's a
* problem.
*/
static Scheme_Object *
g_variant_to_scheme_object (GVariant *gv)
{
const GVariantType *type; // The type of the GVariant
int i; // A counter variable
int len; // Length of arrays and tuples
Scheme_Object *lst = NULL; // A list that we build as a result
Scheme_Object *sval = NULL; // One value
Scheme_Object *result = NULL; // One result to return.
// Special case: We'll treat NULL as void.
if (gv == NULL)
{
return scheme_void;
} // if (gv == NULL)
// Get the type
type = g_variant_get_type (gv);
// ** Handle most of the basic types **
// Integer
if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
{
// We don't refer to any Scheme objects across allocating calls,
// so no need for GC code.
int i;
i = g_variant_get_int32 (gv);
result = scheme_make_integer (i);
return result;
} // if it's an integer
// String
if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
// We don't refer to any Scheme objects across allocating calls,
// so no need for GC code.
const gchar *str;
str = g_variant_get_string (gv, NULL);
result = scheme_make_locale_string (str);
return result;
} // if it's a string
// ** Handle the compound types **
// Tuple or Array
if ( (g_variant_type_is_tuple (type))
|| (g_variant_type_is_array (type)) )
{
// Find out how many values to put into the list.
len = g_variant_n_children (gv);
// Here, we are referring to stuff across allocating calls, so we
// need to be careful.
MZ_GC_DECL_REG (2);
MZ_GC_VAR_IN_REG (0, lst);
MZ_GC_VAR_IN_REG (1, sval);
MZ_GC_REG ();
// Start with the empty list.
lst = scheme_null;
// Step through the items, right to left, adding them to the list.
for (i = len-1; i >= 0; i--)
{
sval = g_variant_to_scheme_object (g_variant_get_child_value (gv, i));
lst = scheme_make_pair (sval, lst);
} // for
// Okay, we've made it through the list, now we can clean up.
MZ_GC_UNREG ();
// And we're done.
return lst;
} // if it's a tuple or an array
// Unknown. Give up.
return NULL;
} // g_variant_to_scheme_object
static GtkWidget *
create_menuitem_from_model (GMenuModel *model,
gint item,
GActionGroup *group)
{
GtkWidget *w;
gchar *label;
gchar *action;
gchar *target;
gchar *s;
ActionData *a;
const GVariantType *type;
GVariant *v;
label = NULL;
g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_LABEL, "s", &label);
action = NULL;
g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_ACTION, "s", &action);
if (action != NULL)
type = g_action_group_get_action_state_type (group, action);
else
type = NULL;
if (type == NULL)
w = gtk_menu_item_new_with_mnemonic (label);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
w = gtk_check_menu_item_new_with_label (label);
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
w = gtk_check_menu_item_new_with_label (label);
gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (w), TRUE);
}
else
g_assert_not_reached ();
if (action != NULL)
{
a = g_new0 (ActionData, 1);
a->group = g_object_ref (group);
a->name = g_strdup (action);
g_object_set_data_full (G_OBJECT (w), "action", a, action_data_free);
if (!g_action_group_get_action_enabled (group, action))
gtk_widget_set_sensitive (w, FALSE);
s = g_strconcat ("action-enabled-changed::", action, NULL);
a->enabled_changed_id = g_signal_connect (group, s,
G_CALLBACK (enabled_changed), w);
g_free (s);
a->activate_handler = g_signal_connect (w, "activate", G_CALLBACK (item_activated), NULL);
if (type == NULL)
{
/* all set */
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_BOOLEAN))
{
s = g_strconcat ("action-state-changed::", action, NULL);
a->state_changed_id = g_signal_connect (group, s,
G_CALLBACK (toggle_state_changed), w);
g_free (s);
v = g_action_group_get_action_state (group, action);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w),
g_variant_get_boolean (v));
g_variant_unref (v);
}
else if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
s = g_strconcat ("action-state-changed::", action, NULL);
a->state_changed_id = g_signal_connect (group, s,
G_CALLBACK (radio_state_changed), w);
g_free (s);
g_menu_model_get_item_attribute (model, item, G_MENU_ATTRIBUTE_TARGET, "s", &target);
a->target = g_strdup (target);
v = g_action_group_get_action_state (group, action);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w),
g_strcmp0 (g_variant_get_string (v, NULL), target) == 0);
g_variant_unref (v);
g_free (target);
}
else
g_assert_not_reached ();
}
g_free (label);
g_free (action);
return w;
}
/**
* Convert a GVariant to a Scheme object. Returns NULL if there's a
* problem.
*/
static Scheme_Object *
g_variant_to_scheme_object (GVariant *gv)
{
const GVariantType *type; // The type of the GVariant
const gchar *typestring; // A string that describes the type
int i; // A counter variable
int len; // Length of arrays and tuples
Scheme_Object *lst = NULL; // A list that we build as a result
Scheme_Object *sval = NULL; // One value
Scheme_Object *result = NULL; // One result to return.
// Special case: We'll treat NULL as void.
if (gv == NULL)
{
return scheme_void;
} // if (gv == NULL)
// Get the type
type = g_variant_get_type (gv);
typestring = g_variant_get_type_string (gv);
// ** Handle most of the basic types **
// Integer
if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
{
// We don't refer to any Scheme objects across allocating calls,
// so no need for GC code.
int i;
i = g_variant_get_int32 (gv);
result = scheme_make_integer (i);
return result;
} // if it's an integer
// Double
if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
{
double d;
d = g_variant_get_double (gv);
result = scheme_make_double (d);
return result;
} // if it's a double
// String
if (g_variant_type_equal (type, G_VARIANT_TYPE_STRING))
{
// We don't refer to any Scheme objects across allocating calls,
// so no need for GC code.
const gchar *str;
str = g_variant_get_string (gv, NULL);
result = scheme_make_locale_string (str);
return result;
} // if it's a string
// ** Handle some special cases **
// We treat arrays of bytes as bytestrings
if (g_strcmp0 (typestring, "ay") == 0)
{
gsize size;
guchar *data;
data = (guchar *) g_variant_get_fixed_array (gv, &size, sizeof (guchar));
return scheme_make_sized_byte_string ((char *) data, size, 1);
} // if it's an array of bytes
// ** Handle the compound types **
// Tuple or Array
if ( (g_variant_type_is_tuple (type))
|| (g_variant_type_is_array (type)) )
{
// Find out how many values to put into the list.
len = g_variant_n_children (gv);
// Here, we are referring to stuff across allocating calls, so we
// need to be careful.
MZ_GC_DECL_REG (2);
MZ_GC_VAR_IN_REG (0, lst);
MZ_GC_VAR_IN_REG (1, sval);
MZ_GC_REG ();
// Start with the empty list.
lst = scheme_null;
// Step through the items, right to left, adding them to the list.
for (i = len-1; i >= 0; i--)
{
sval = g_variant_to_scheme_object (g_variant_get_child_value (gv, i));
lst = scheme_make_pair (sval, lst);
} // for
// Okay, we've made it through the list, now we can clean up.
MZ_GC_UNREG ();
if ((g_variant_type_is_array (type)))
{
//If type is array, convert to vector
scheme_list_to_vector ((char*)lst);
}//If array
// And we're done.
return lst;
} // if it's a tuple or an array
// Unknown. Give up.
scheme_signal_error ("Unknown type %s", typestring);
return scheme_void;
} // g_variant_to_scheme_object
