void TagExtractor::printOneTag( const GstTagList * list, const gchar * tag, gpointer user_data ) {
int i, num;
num = gst_tag_list_get_tag_size( list, tag );
for (i = 0; i < num; ++i) {
const GValue *val;
/* Note: when looking for specific tags, use the gst_tag_list_get_xyz() API,
* we only use the GValue approach here because it is more generic */
val = gst_tag_list_get_value_index( list, tag, i );
if( G_VALUE_HOLDS_STRING (val)) {
g_print( "\t%20s : %s\n", tag, g_value_get_string( val ) );
} else if( G_VALUE_HOLDS_UINT (val)) {
g_print( "\t%20s : %u\n", tag, g_value_get_uint( val ) );
} else if( G_VALUE_HOLDS_DOUBLE (val)) {
g_print( "\t%20s : %g\n", tag, g_value_get_double( val ) );
} else if( G_VALUE_HOLDS_BOOLEAN (val)) {
g_print( "\t%20s : %s\n", tag, (g_value_get_boolean( val )) ? "true" : "false" );
} else if( GST_VALUE_HOLDS_BUFFER (val)) {
GstBuffer *buf = gst_value_get_buffer (val);
guint buffer_size = gst_buffer_get_size( buf );
g_print( "\t%20s : buffer of size %u\n", tag, buffer_size );
} else if( GST_VALUE_HOLDS_DATE_TIME (val)) {
GstDateTime *dt = (GstDateTime*) g_value_get_boxed( val );
gchar *dt_str = gst_date_time_to_iso8601_string( dt );
g_print( "\t%20s : %s\n", tag, dt_str );
g_free( dt_str );
} else {
g_print( "\t%20s : tag of type '%s'\n", tag, G_VALUE_TYPE_NAME (val));
}
}
}
static void
print_one_tag (const GstTagList * list, const gchar * tag, gpointer user_data)
{
gint i, num;
num = gst_tag_list_get_tag_size (list, tag);
for (i = 0; i < num; ++i) {
const GValue *val;
val = gst_tag_list_get_value_index (list, tag, i);
if (G_VALUE_HOLDS_STRING (val)) {
g_print (" %s : %s \n", tag, g_value_get_string (val));
} else if (G_VALUE_HOLDS_UINT (val)) {
g_print (" %s : %u \n", tag, g_value_get_uint (val));
} else if (G_VALUE_HOLDS_DOUBLE (val)) {
g_print (" %s : %g \n", tag, g_value_get_double (val));
} else if (G_VALUE_HOLDS_BOOLEAN (val)) {
g_print (" %s : %s \n", tag,
g_value_get_boolean (val) ? "true" : "false");
} else if (GST_VALUE_HOLDS_DATE_TIME (val)) {
GstDateTime *dt = g_value_get_boxed (val);
gchar *dt_str = gst_date_time_to_iso8601_string (dt);
g_print (" %s : %s \n", tag, dt_str);
g_free (dt_str);
} else {
g_print (" %s : tag of type '%s' \n", tag, G_VALUE_TYPE_NAME (val));
}
}
}
void cd_NetworkMonitor_get_wired_connection_infos (void)
{
cd_debug ("%s ()", __func__);
GHashTable *hProperties;
GValue *v;
//\_____________ On recupere les proprietes du device "wired"
hProperties = cairo_dock_dbus_get_all_properties (myData.dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device.Wired");
g_return_if_fail (hProperties != NULL);
v = (GValue *)g_hash_table_lookup (hProperties, "Speed");
if (v != NULL && G_VALUE_HOLDS_UINT (v))
{
myData.iSpeed = g_value_get_uint (v);
cd_debug(" Vitesse de connexion : %d",myData.iSpeed);
}
v = (GValue *)g_hash_table_lookup (hProperties, "HwAddress");
if (v != NULL && G_VALUE_HOLDS_STRING (v))
{
myData.cAccessPointHwAdress = g_strdup(g_value_get_string (v));
cd_debug(" Adresse physique : %s",myData.cAccessPointHwAdress);
}
myData.iQuality = WIRED_NO_CONNECTION;
v = (GValue *)g_hash_table_lookup (hProperties, "Carrier");
if (v != NULL && G_VALUE_HOLDS_BOOLEAN (v))
{
if (g_value_get_boolean (v))
myData.iQuality = WIRED_CONNECTION;
cd_debug(" cable branche : %d", g_value_get_boolean (v));
}
g_hash_table_unref (hProperties);
}
/*
* Returns object's disk usage size
*/
guint midgard_quota_get_object_size(MidgardObject *object)
{
g_assert(object != NULL);
MidgardConnection *mgd = MGD_OBJECT_CNC (object);
if (!MGD_CNC_QUOTA (mgd) || !MGD_DBOBJECT_HAS_METADATA(object))
return 0;
const gchar *tablename =
midgard_core_class_get_table(MIDGARD_DBOBJECT_GET_CLASS(object));
gchar *where =
midgard_core_query_where_guid(tablename, MGD_OBJECT_GUID (object));
GValue *value = midgard_core_query_get_field_value(
MGD_OBJECT_CNC (object),
"metadata_size",
tablename,
where);
g_free(where);
guint size = 0;
if(G_VALUE_HOLDS_UINT(value))
size = g_value_get_uint(value);
if(G_VALUE_HOLDS_INT(value))
size = (guint) g_value_get_int(value);
g_value_unset(value);
g_free(value);
return size;
}
int
ce_get_property_default (NMSetting *setting, const char *property_name)
{
GParamSpec *spec;
GValue value = { 0, };
g_return_val_if_fail (NM_IS_SETTING (setting), -1);
spec = g_object_class_find_property (G_OBJECT_GET_CLASS (setting), property_name);
g_return_val_if_fail (spec != NULL, -1);
g_value_init (&value, spec->value_type);
g_param_value_set_default (spec, &value);
if (G_VALUE_HOLDS_CHAR (&value))
return (int) g_value_get_schar (&value);
else if (G_VALUE_HOLDS_INT (&value))
return g_value_get_int (&value);
else if (G_VALUE_HOLDS_INT64 (&value))
return (int) g_value_get_int64 (&value);
else if (G_VALUE_HOLDS_LONG (&value))
return (int) g_value_get_long (&value);
else if (G_VALUE_HOLDS_UINT (&value))
return (int) g_value_get_uint (&value);
else if (G_VALUE_HOLDS_UINT64 (&value))
return (int) g_value_get_uint64 (&value);
else if (G_VALUE_HOLDS_ULONG (&value))
return (int) g_value_get_ulong (&value);
else if (G_VALUE_HOLDS_UCHAR (&value))
return (int) g_value_get_uchar (&value);
g_return_val_if_fail (FALSE, 0);
return 0;
}
static gpointer
value_as_pointer (GValue *value)
{
if (g_value_fits_pointer (value))
return g_value_peek_pointer (value);
if (G_VALUE_HOLDS_BOOLEAN (value))
return (void*) g_value_get_boolean (value);
if (G_VALUE_HOLDS_CHAR (value))
return (void*) (gssize) g_value_get_char (value);
if (G_VALUE_HOLDS_UCHAR (value))
return (void*) (gsize) g_value_get_uchar (value);
if (G_VALUE_HOLDS_INT (value))
return (void*) g_value_get_int (value);
if (G_VALUE_HOLDS_UINT (value))
return (void*) g_value_get_uint (value);
if (G_VALUE_HOLDS_LONG (value))
return (void*) g_value_get_long (value);
if (G_VALUE_HOLDS_ULONG (value))
return (void*) g_value_get_ulong (value);
if (G_VALUE_HOLDS_FLOAT (value))
return (void*) (gssize) g_value_get_float (value);
if (G_VALUE_HOLDS_DOUBLE (value))
return (void*) (gssize) g_value_get_double (value);
if (G_VALUE_HOLDS_ENUM (value))
return (void*) (gssize) g_value_get_enum (value);
if (G_VALUE_HOLDS_FLAGS (value))
return (void*) (gsize) g_value_get_flags (value);
return (void*) 0x1373babe;
}
/**
* midgard_workspace_context_has_workspace:
* @self: #MidgardWorkspaceContext instance
* @workspace: #MidgardWorkspace to check
*
* Check, whether given @workspace is in given context
*
* Returns: %TRUE on success, %FALSE otherwise
* Since: 10.05.5
*/
gboolean
midgard_workspace_context_has_workspace (MidgardWorkspaceContext *self, MidgardWorkspace *workspace)
{
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (workspace != NULL, FALSE);
gboolean rv = FALSE;
GSList *ids = MIDGARD_WORKSPACE_STORAGE_GET_INTERFACE (self)->priv->list_ids (NULL, MIDGARD_WORKSPACE_STORAGE (self));
if (!ids)
return rv;
GSList *l;
guint ws_id = 0;
for (l = ids; l != NULL; l = l->next) {
GValue *val = (GValue *) l->data;
if (G_VALUE_HOLDS_UINT (val))
ws_id = g_value_get_uint (val);
else
ws_id = g_value_get_int (val);
if (ws_id == workspace->priv->id) {
rv = TRUE;
break;
}
}
g_slist_free (ids);
return rv;
}
static void
serving_system_reply (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
{
CdmaDeviceInfo *info = user_data;
GError *error = NULL;
GValueArray *array = NULL;
guint32 new_sid = 0;
GValue *value;
if (dbus_g_proxy_end_call (proxy, call, &error,
SERVING_SYSTEM_TYPE, &array,
G_TYPE_INVALID)) {
if (array->n_values == 3) {
value = g_value_array_get_nth (array, 2);
if (G_VALUE_HOLDS_UINT (value))
new_sid = g_value_get_uint (value);
}
g_value_array_free (array);
}
if (new_sid != info->sid) {
info->sid = new_sid;
g_free (info->provider_name);
info->provider_name = mobile_helper_parse_3gpp2_operator_name (&(info->mobile_providers_database), info->sid);
}
g_clear_error (&error);
}
/**
* g_value_get_uint:
* @value: a valid #GValue of type %G_TYPE_UINT
*
* Get the contents of a %G_TYPE_UINT #GValue.
*
* Returns: unsigned integer contents of @value
*/
guint
g_value_get_uint (const GValue *value)
{
g_return_val_if_fail (G_VALUE_HOLDS_UINT (value), 0);
return value->data[0].v_uint;
}
/**
* g_value_set_uint:
* @value: a valid #GValue of type %G_TYPE_UINT
* @v_uint: unsigned integer value to be set
*
* Set the contents of a %G_TYPE_UINT #GValue to @v_uint.
*/
void
g_value_set_uint (GValue *value,
guint v_uint)
{
g_return_if_fail (G_VALUE_HOLDS_UINT (value));
value->data[0].v_uint = v_uint;
}
static GVariant *
g_settings_set_mapping_unsigned_int (const GValue *value,
const GVariantType *expected_type)
{
GVariant *variant = NULL;
guint64 u;
if (G_VALUE_HOLDS_UINT (value))
u = g_value_get_uint (value);
else if (G_VALUE_HOLDS_UINT64 (value))
u = g_value_get_uint64 (value);
else
return NULL;
if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
{
if (u <= G_MAXINT16)
variant = g_variant_new_int16 ((gint16) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
{
if (u <= G_MAXUINT16)
variant = g_variant_new_uint16 ((guint16) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
{
if (u <= G_MAXINT32)
variant = g_variant_new_int32 ((gint) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
{
if (u <= G_MAXUINT32)
variant = g_variant_new_uint32 ((guint) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
{
if (u <= G_MAXINT64)
variant = g_variant_new_int64 ((gint64) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
{
if (u <= G_MAXUINT64)
variant = g_variant_new_uint64 ((guint64) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
{
if (u <= G_MAXUINT32)
variant = g_variant_new_handle ((guint) u);
}
else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
variant = g_variant_new_double ((gdouble) u);
return variant;
}
static void
set_sysfs_uint (const char *iface,
GObject *obj,
const char *obj_prop,
const char *dir,
const char *sysfs_prop,
gboolean default_if_zero,
gboolean user_hz_compensate)
{
char *path, *s;
GParamSpec *pspec;
GValue val = { 0 };
guint32 uval = 0;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (obj), obj_prop);
g_return_if_fail (pspec != NULL);
/* Get the property's value */
g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_object_get_property (obj, obj_prop, &val);
if (G_VALUE_HOLDS_BOOLEAN (&val))
uval = g_value_get_boolean (&val) ? 1 : 0;
else if (G_VALUE_HOLDS_UINT (&val)) {
uval = g_value_get_uint (&val);
/* zero means "unspecified" for some NM properties but isn't in the
* allowed kernel range, so reset the property to the default value.
*/
if (default_if_zero && uval == 0) {
g_value_unset (&val);
g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_param_value_set_default (pspec, &val);
uval = g_value_get_uint (&val);
}
} else
g_assert_not_reached ();
g_value_unset (&val);
/* Linux kernel bridge interfaces use 'centiseconds' for time-based values.
* In reality it's not centiseconds, but depends on HZ and USER_HZ, which
* is almost always works out to be a multiplier of 100, so we can assume
* centiseconds. See clock_t_to_jiffies().
*/
if (user_hz_compensate)
uval *= 100;
path = g_strdup_printf ("/sys/class/net/%s/%s/%s", iface, dir, sysfs_prop);
s = g_strdup_printf ("%u", uval);
/* FIXME: how should failure be handled? */
nm_utils_do_sysctl (path, s);
g_free (path);
g_free (s);
}
static void
manager_prepared_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
TpWeakRef *wr = user_data;
EmpathyAppPluginWidget *self = tp_weak_ref_dup_object (wr);
TpAccountManager *manager = (TpAccountManager *) source;
GList *accounts;
GError *error = NULL;
if (self == NULL)
{
tp_weak_ref_destroy (wr);
return;
}
if (!tp_proxy_prepare_finish (manager, result, &error))
{
g_debug ("Error preparing Account Manager: %s", error->message);
g_clear_error (&error);
goto out;
}
accounts = tp_account_manager_dup_valid_accounts (manager);
while (accounts != NULL)
{
TpAccount *account = accounts->data;
const GValue *value;
value = tp_account_get_storage_identifier (account);
if (G_VALUE_HOLDS_UINT (value) &&
g_value_get_uint (value) == self->priv->account->id)
{
GtkWidget *alig;
alig = gtk_alignment_new (0.5, 0, 0, 0);
self->priv->user_info = tpaw_user_info_new (account);
gtk_container_add (GTK_CONTAINER (alig), self->priv->user_info);
gtk_widget_show (self->priv->user_info);
gtk_box_pack_start (GTK_BOX (self), alig, TRUE, TRUE, 0);
gtk_widget_show (alig);
break;
}
accounts = g_list_delete_link (accounts, accounts);
}
g_list_free_full (accounts, g_object_unref);
out:
tp_weak_ref_destroy (wr);
g_object_unref (self);
}
guint
ol_get_uint_from_hash_table (GHashTable *hash_table, const gchar *key)
{
if (!hash_table)
return 0;
GValue *value;
value = (GValue *) g_hash_table_lookup(hash_table, key);
if (value != NULL && G_VALUE_HOLDS_UINT(value))
return g_value_get_uint (value);
else
return 0;
}
/*
* Set a new maximum total size for the map tile cache.
*/
void
ph_config_set_max_tile_cache_size(const GValue *value)
{
g_return_if_fail(ph_config != NULL);
g_return_if_fail(value == NULL || G_VALUE_HOLDS_UINT(value));
if (value != NULL)
g_key_file_set_uint64(ph_config->key_file, "tile-cache", "max-size",
g_value_get_uint(value));
else
g_key_file_remove_key(ph_config->key_file, "tile-cache", "max-size",
NULL);
}
/*
* If the given row in the model is the name we're looking for, run it.
* Otherwise keep looking.
*/
gboolean
run_desktop_entry(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter,
gpointer data)
{
char *name_v;
struct state *st;
GValue value = G_VALUE_INIT;
st = (struct state *)data;
gtk_tree_model_get_value(model, iter, NAME_COLUMN, &value);
if (!G_VALUE_HOLDS_STRING(&value)) {
warnx("gtk_tree_model_get_value: name is not a string");
return FALSE;
}
name_v = g_value_dup_string(&value);
g_value_unset(&value);
if (strlen(name_v) != strlen(st->name) ||
strncmp(name_v, st->name, strlen(st->name)) != 0)
return FALSE;
gtk_tree_model_get_value(model, iter, EXEC_COLUMN, &value);
if (!G_VALUE_HOLDS_STRING(&value)) {
warnx("gtk_tree_model_get_value: exec is not a string");
return TRUE;
}
st->cmd = g_value_dup_string(&value);
g_value_unset(&value);
gtk_tree_model_get_value(model, iter, FCODE_COLUMN, &value);
if (!G_VALUE_HOLDS_UINT(&value)) {
warnx("gtk_tree_model_get_value: flags are not an integer");
return TRUE;
}
st->flags = g_value_get_uint(&value);
g_value_unset(&value);
gtk_tree_model_get_value(model, iter, TERM_COLUMN, &value);
if (!G_VALUE_HOLDS_BOOLEAN(&value)) {
warnx("gtk_tree_model_get_value: term is not a Boolean");
return TRUE;
}
st->use_term = g_value_get_boolean(&value);
g_value_unset(&value);
if (run_cmd(st))
return TRUE;
return TRUE;
}
/*
* Get the maximum total size, in megabytes, of the tile cache directory. This
* is an unsigned integer value.
*/
void
ph_config_get_max_tile_cache_size(GValue *value)
{
guint max_size;
g_return_if_fail(ph_config != NULL);
g_return_if_fail(G_VALUE_HOLDS_UINT(value));
max_size = g_key_file_get_uint64(ph_config->key_file,
"tile-cache", "max-size",
NULL);
g_value_set_uint(value, (max_size != 0) ? max_size : 100);
}
void cd_NetworkMonitor_get_wireless_connection_infos (void)
{
cd_debug ("%s ()", __func__);
GHashTable *hProperties;
GValue *v;
g_free (myData.cAccessPointHwAdress);
myData.cAccessPointHwAdress = NULL;
myData.iSpeed = 0;
//\_____________ On recupere les proprietes du device "wireless".
hProperties = cairo_dock_dbus_get_all_properties (myData.dbus_proxy_Device_prop, "org.freedesktop.NetworkManager.Device.Wireless");
g_return_if_fail (hProperties != NULL);
v = (GValue *)g_hash_table_lookup (hProperties, "Bitrate");
if (v && G_VALUE_HOLDS_UINT (v))
{
myData.iSpeed = g_value_get_uint (v);
cd_debug (" Bitrate : %d\n",myData.iSpeed);
}
v = (GValue *)g_hash_table_lookup (hProperties, "HwAddress");
if (v && G_VALUE_HOLDS_STRING (v))
{
myData.cAccessPointHwAdress = g_strdup(g_value_get_string (v));
cd_debug (" Adresse physique : %s\n",myData.cAccessPointHwAdress);
}
v = (GValue *)g_hash_table_lookup (hProperties, "ActiveAccessPoint");
if (v && G_VALUE_HOLDS (v, DBUS_TYPE_G_OBJECT_PATH))
{
gchar *cAccessPoint = g_value_get_boxed (v);
cd_debug (" Access point : %s", cAccessPoint);
if (cAccessPoint && strncmp (cAccessPoint, "/org/freedesktop/NetworkManager/AccessPoint/", 44) == 0)
{
g_free (myData.cAccessPoint);
myData.cAccessPoint = g_strdup (cAccessPoint);
}
}
g_hash_table_unref (hProperties);
//\_____________ On recupere le point d'acces courant sur le bus.
myData.iQuality = WIFI_QUALITY_NO_SIGNAL;
if (myData.cAccessPoint != NULL)
{
cd_NetworkMonitor_get_new_access_point ();
}
}
const gchar *
_midgard_workspace_context_get_path (MidgardWorkspaceStorage *wss)
{
g_return_val_if_fail (wss != NULL, NULL);
MidgardWorkspaceContext *self = MIDGARD_WORKSPACE_CONTEXT (wss);
if (!self->priv->manager)
return NULL;
MidgardConnection *mgd = self->priv->manager->priv->mgd;
if (!mgd)
return NULL;
guint ws_id = self->priv->id;
if (ws_id == 0)
return NULL;
const GValue *up_val = midgard_core_workspace_get_value_by_id (mgd, MGD_WORKSPACE_FIELD_IDX_UP, ws_id, NULL);
if (!up_val)
return NULL;
guint up_id = 0;
if (G_VALUE_HOLDS_UINT (up_val))
up_id = g_value_get_uint (up_val);
else
up_id = (guint) g_value_get_int (up_val);
GSList *list = midgard_core_workspace_get_parent_names (mgd, up_id);
GSList *l;
GString *str = g_string_new ("");
for (l = list; l != NULL; l = l->next) {
gchar *name = (gchar *) l->data;
g_string_append_printf (str, "/%s", name);
}
if (list)
g_slist_free (list);
const GValue *name_value = midgard_core_workspace_get_value_by_id (mgd, MGD_WORKSPACE_FIELD_IDX_NAME, ws_id, NULL);
g_string_append_printf (str, "/%s", g_value_get_string (name_value));
g_free (self->priv->path);
self->priv->path = g_string_free (str, FALSE);
return (const gchar *) self->priv->path;
}
static void
commit_option (NMDevice *device, NMSetting *setting, const Option *option, gboolean slave)
{
int ifindex = nm_device_get_ifindex (device);
GParamSpec *pspec;
GValue val = G_VALUE_INIT;
guint32 uval = 0;
gs_free char *value = NULL;
g_assert (setting);
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (setting), option->name);
g_assert (pspec);
/* Get the property's value */
g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_object_get_property ((GObject *) setting, option->name, &val);
if (G_VALUE_HOLDS_BOOLEAN (&val))
uval = g_value_get_boolean (&val) ? 1 : 0;
else if (G_VALUE_HOLDS_UINT (&val)) {
uval = g_value_get_uint (&val);
/* zero means "unspecified" for some NM properties but isn't in the
* allowed kernel range, so reset the property to the default value.
*/
if (option->default_if_zero && uval == 0) {
g_value_unset (&val);
g_value_init (&val, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_param_value_set_default (pspec, &val);
uval = g_value_get_uint (&val);
}
/* Linux kernel bridge interfaces use 'centiseconds' for time-based values.
* In reality it's not centiseconds, but depends on HZ and USER_HZ, which
* is almost always works out to be a multiplier of 100, so we can assume
* centiseconds. See clock_t_to_jiffies().
*/
if (option->user_hz_compensate)
uval *= 100;
} else
g_assert_not_reached ();
g_value_unset (&val);
value = g_strdup_printf ("%u", uval);
if (slave)
nm_platform_slave_set_option (ifindex, option->sysname, value);
else
nm_platform_master_set_option (ifindex, option->sysname, value);
}
/*
* Pull out the executable from the selected entry, and run it.
*/
void
app_selected(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn
*column, gpointer user_data)
{
GtkTreeModel *model;
GtkTreeIter iter;
GValue value = G_VALUE_INIT;
struct state *st;
st = (struct state *)user_data;
if ((model = gtk_tree_view_get_model(tree_view)) == NULL) {
warnx("gtk_tree_view_get_model is NULL");
return;
}
if (!gtk_tree_model_get_iter(model, &iter, path)) {
warnx("gtk_tree_model_get_iter: path does not exist");
return;
}
gtk_tree_model_get_value(model, &iter, EXEC_COLUMN, &value);
if (!G_VALUE_HOLDS_STRING(&value)) {
warnx("gtk_tree_model_get_value: exec is not a string");
return;
}
st->cmd = g_value_dup_string(&value);
g_value_unset(&value);
gtk_tree_model_get_value(model, &iter, FCODE_COLUMN, &value);
if (!G_VALUE_HOLDS_UINT(&value)) {
warnx("gtk_tree_model_get_value: flags are not an integer");
return;
}
st->flags = g_value_get_uint(&value);
g_value_unset(&value);
gtk_tree_model_get_value(model, &iter, TERM_COLUMN, &value);
if (!G_VALUE_HOLDS_BOOLEAN(&value)) {
warnx("gtk_tree_model_get_value: term is not a Boolean");
return;
}
st->use_term = g_value_get_boolean(&value);
g_value_unset(&value);
if (run_cmd(st))
gtk_main_quit();
}
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;
}
static char *
build_message (GPtrArray *fields, AuditBackend backend)
{
GString *string;
AuditField *field;
gboolean first = TRUE;
guint i;
string = g_string_new (NULL);
for (i = 0; i < fields->len; i++) {
field = fields->pdata[i];
if (!NM_FLAGS_HAS (field->backends, backend))
continue;
if (first)
first = FALSE;
else
g_string_append_c (string, ' ');
if (G_VALUE_HOLDS_STRING (&field->value)) {
const char *str = g_value_get_string (&field->value);
#if HAVE_LIBAUDIT
if (backend == BACKEND_AUDITD) {
if (field->need_encoding) {
char *value;
value = audit_encode_nv_string (field->name, str, 0);
g_string_append (string, value);
g_free (value);
} else
g_string_append_printf (string, "%s=%s", field->name, str);
continue;
}
#endif /* HAVE_LIBAUDIT */
g_string_append_printf (string, "%s=\"%s\"", field->name, str);
} else if (G_VALUE_HOLDS_UINT (&field->value)) {
g_string_append_printf (string, "%s=%u", field->name,
g_value_get_uint (&field->value));
} else
g_assert_not_reached ();
}
return g_string_free (string, FALSE);
}
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 gboolean
lldp_neighbor_equal (LLDPNeighbor *a, LLDPNeighbor *b)
{
GHashTableIter iter;
gpointer k, v;
g_return_val_if_fail (a && a->tlvs, FALSE);
g_return_val_if_fail (b && b->tlvs, FALSE);
if ( a->chassis_id_type != b->chassis_id_type
|| a->port_id_type != b->port_id_type
|| a->dest != b->dest
|| g_strcmp0 (a->chassis_id, b->chassis_id)
|| g_strcmp0 (a->port_id, b->port_id))
return FALSE;
if (g_hash_table_size (a->tlvs) != g_hash_table_size (b->tlvs))
return FALSE;
g_hash_table_iter_init (&iter, a->tlvs);
while (g_hash_table_iter_next (&iter, &k, &v)) {
GValue *value_a, *value_b;
value_a = v;
value_b = g_hash_table_lookup (b->tlvs, k);
if (!value_b)
return FALSE;
g_return_val_if_fail (G_VALUE_TYPE (value_a) == G_VALUE_TYPE (value_b), FALSE);
if (G_VALUE_HOLDS_STRING (value_a)) {
if (g_strcmp0 (g_value_get_string (value_a), g_value_get_string (value_b)))
return FALSE;
} else if (G_VALUE_HOLDS_UINT (value_a)) {
if (g_value_get_uint (value_a) != g_value_get_uint (value_b))
return FALSE;
} else
g_return_val_if_reached (FALSE);
}
return TRUE;
}
static void
print_one_tag (const GstTagList * list, const gchar * tag, gpointer user_data)
{
int i, num;
num = gst_tag_list_get_tag_size (list, tag);
for (i = 0; i < num; ++i) {
const GValue *val;
/* Note: when looking for specific tags, use the g_tag_list_get_xyz() API,
* we only use the GValue approach here because it is more generic */
val = gst_tag_list_get_value_index (list, tag, i);
if (G_VALUE_HOLDS_STRING (val)) {
const char* unformatted = g_value_get_string (val);
gchar* formatted = strescape(unformatted,"\"","\"");
g_print ("(%s . \"%s\")\n", tag, formatted);
g_free(formatted);
} else if (G_VALUE_HOLDS_UINT (val)) {
unsigned int uint = g_value_get_uint (val);
if(uint > 0xf)
g_print ("(%s . #x%x)\n", tag, uint);
} else if (G_VALUE_HOLDS_DOUBLE (val)) {
g_print ("(%s . %g)\n", tag, g_value_get_double (val));
} else if (G_VALUE_HOLDS_BOOLEAN (val)) {
g_print ("(%s . %s)\n", tag,
(g_value_get_boolean (val)) ? "#t" : "#f");
} else if (GST_VALUE_HOLDS_BUFFER (val)) {
g_print ("(%s . (buffer %u))", tag,
gst_buffer_get_size(gst_value_get_buffer (val)));
} else if (GST_VALUE_HOLDS_DATE_TIME (val)) {
GDate* date = (GDate*)g_value_get_boxed(val);
g_print ("(%s . (date 0 0 0 %u %u %u))\n", tag,
g_date_get_day(date),
g_date_get_month(date),
g_date_get_year (date));
} else {
g_print ("(%20s . (type %s))", tag, G_VALUE_TYPE_NAME (val));
}
}
}
/* This function really ought not to be part of Amanda. In my (Ian's) opinion,
serialization and deserialization should be a part of the GValue
interface. But it's not, and here we are. */
gboolean g_value_set_from_string(GValue * val, char * string) {
g_return_val_if_fail(val != NULL, FALSE);
g_return_val_if_fail(G_IS_VALUE(val), FALSE);
if (G_VALUE_HOLDS_BOOLEAN(val)) {
return g_value_set_boolean_from_string(val, string);
} else if (G_VALUE_HOLDS_INT(val)) {
return g_value_set_int_from_string(val, string);
} else if (G_VALUE_HOLDS_UINT(val)) {
return g_value_set_uint_from_string(val, string);
} else if (G_VALUE_HOLDS_UINT64(val)) {
return g_value_set_uint64_from_string(val, string);
} else if (G_VALUE_HOLDS_STRING(val)) {
g_value_set_string(val, string);
return TRUE;
} else if (G_VALUE_HOLDS_FLAGS(val)) {
return g_value_set_flags_from_string(val, string);
}
return TRUE;
}
// les proprietes d'un AccessPoint sont :
// Flags - u - (read) (NM_802_11_AP_FLAGS)
// Flags describing the capabilities of the access point.
// WpaFlags - u - (read) (NM_802_11_AP_SEC)
// Flags describing the access point's capabilities according to WPA (Wifi Protected Access).
// RsnFlags - u - (read) (NM_802_11_AP_SEC)
// Flags describing the access point's capabilities according to the RSN (Robust Secure Network) protocol.
// Ssid - ay - (read)
// The Service Set Identifier identifying the access point.
// Frequency - u - (read)
// The radio channel frequency in use by the access point, in MHz.
// HwAddress - s - (read)
// The hardware address (BSSID) of the access point.
// Mode - u - (read) (NM_802_11_MODE)
// Describes the operating mode of the access point.
// MaxBitrate - u - (read)
// The maximum bitrate this access point is capable of, in kilobits/second (Kb/s).
// Strength - y - (read)
// The current signal quality of the access point, in percent.
void cd_NetworkMonitor_fetch_access_point_properties (GHashTable *hProperties)
{
GValue *v;
v = (GValue *)g_hash_table_lookup (hProperties, "Strength");
if (v != NULL && G_VALUE_HOLDS_UCHAR (v))
{
myData.iPercent = MIN (100, (gint) g_value_get_uchar (v)); // pas clair si c'est deja des % ou s'il faut convertir par 100/255, des fois on se chope des 255 ...
cd_debug ("Network-Monitor : Force du signal : %d %%", myData.iPercent);
cd_NetworkMonitor_quality ();
cd_NetworkMonitor_draw_icon ();
}
v = (GValue *)g_hash_table_lookup (hProperties, "HwAddress");
if (v != NULL && G_VALUE_HOLDS_STRING (v))
{
myData.cAccessPointHwAdress = g_strdup(g_value_get_string (v));
cd_debug ("Network-Monitor : Adresse physique de l'AP active : %s", myData.cAccessPointHwAdress);
}
v = (GValue *)g_hash_table_lookup (hProperties, "Ssid");
if (v != NULL && G_VALUE_HOLDS_BOXED (v))
{
GByteArray *a = g_value_get_boxed (v);
myData.cESSID = g_new0 (gchar, a->len+1);
for (uint i = 0; i < a->len; i ++)
{
myData.cESSID[i] = a->data[i];
}
cd_debug ("Network-Monitor : SSID : %s", myData.cESSID);
}
v = (GValue *)g_hash_table_lookup (hProperties, "MaxBitrate"); // in kilobits/second (Kb/s).
if (v != NULL && G_VALUE_HOLDS_UINT (v))
{
myData.iSpeed = (gint) g_value_get_uint (v) / 8; // Ko/s
cd_debug("Network-Monitor : Max Bitrate au demarrage : %d",myData.iSpeed);
}
}
static gboolean
string_to_num (GBinding *binding,
const GValue *source_value,
GValue *target_value,
gpointer userdata)
{
if (G_VALUE_HOLDS_INT (target_value))
g_value_set_int (target_value,
atoi (g_value_get_string (source_value)));
else if (G_VALUE_HOLDS_UINT (target_value))
g_value_set_uint (target_value,
atoi (g_value_get_string (source_value)));
else if (G_VALUE_HOLDS_DOUBLE (target_value))
g_value_set_double (target_value,
strtod (g_value_get_string (source_value), NULL));
else if (G_VALUE_HOLDS_FLOAT (target_value))
g_value_set_float (target_value,
strtof (g_value_get_string (source_value), NULL));
else
return FALSE;
return TRUE;
}
static gboolean
num_to_string (GBinding *binding,
const GValue *source_value,
GValue *target_value,
gpointer userdata)
{
gchar *string;
if (G_VALUE_HOLDS_INT (source_value))
string = g_strdup_printf ("%d", g_value_get_int (source_value));
else if (G_VALUE_HOLDS_UINT (source_value))
string = g_strdup_printf ("%d", g_value_get_uint (source_value));
else if (G_VALUE_HOLDS_DOUBLE (source_value))
string = g_strdup_printf ("%.2f", g_value_get_double (source_value));
else if (G_VALUE_HOLDS_FLOAT (source_value))
string = g_strdup_printf ("%.2f", g_value_get_float (source_value));
else
return FALSE;
g_value_take_string (target_value, string);
return TRUE;
}
