static void service_property_changed(DBusGProxy *proxy, const char *property,
GValue *value, gpointer user_data)
{
if (property == NULL || value == NULL)
return;
if (g_str_equal(property, "Type") == TRUE) {
const gchar *type = g_value_get_string(value);
if (g_strcmp0(type, "ethernet") == 0)
global_strength = -1;
else if (g_strcmp0(type, "wifi") == 0)
global_strength = g_value_get_uchar(value);
} else if (g_str_equal(property, "State") == TRUE) {
const gchar *state = g_value_get_string(value);
if (g_strcmp0(state, "ready") == 0 || g_strcmp0(state, "online") == 0)
global_ready = TRUE;
else
global_ready = FALSE;
} else if (g_str_equal(property, "Strength") == TRUE) {
const guchar strength = g_value_get_uchar(value);
global_strength = strength;
}
if (global_ready == TRUE)
status_ready(global_strength);
else
status_offline();
}
G_GNUC_UNUSED static gboolean
_g_value_equal (const GValue *a, const GValue *b)
{
gboolean ret = FALSE;
g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b));
switch (G_VALUE_TYPE (a))
{
case G_TYPE_BOOLEAN:
ret = (g_value_get_boolean (a) == g_value_get_boolean (b));
break;
case G_TYPE_UCHAR:
ret = (g_value_get_uchar (a) == g_value_get_uchar (b));
break;
case G_TYPE_INT:
ret = (g_value_get_int (a) == g_value_get_int (b));
break;
case G_TYPE_UINT:
ret = (g_value_get_uint (a) == g_value_get_uint (b));
break;
case G_TYPE_INT64:
ret = (g_value_get_int64 (a) == g_value_get_int64 (b));
break;
case G_TYPE_UINT64:
ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b));
break;
case G_TYPE_DOUBLE:
{
/* Avoid -Wfloat-equal warnings by doing a direct bit compare */
gdouble da = g_value_get_double (a);
gdouble db = g_value_get_double (b);
ret = memcmp (&da, &db, sizeof (gdouble)) == 0;
}
break;
case G_TYPE_STRING:
ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0);
break;
case G_TYPE_VARIANT:
ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b));
break;
default:
if (G_VALUE_TYPE (a) == G_TYPE_STRV)
ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b));
else
g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a)));
break;
}
return ret;
}
/**
* fs_session_parse_telephony_event_started:
* @session: a #FsSession to match against the message
* @message: a #GstMessage to parse
* @method: (out): Returns the #FsDTMFMethod in the message if not %NULL.
* @event: (out): Returns the #FsDTMFEvent in the message if not %NULL.
* @volume: (out): Returns the volume in the message if not %NULL.
*
* Parses a "farstream-telephony-event-started" message and checks if it matches
* the @session parameters.
*
* Returns: %TRUE if the message matches the session and is valid.
*/
gboolean
fs_session_parse_telephony_event_started (FsSession *session,
GstMessage *message,
FsDTMFMethod *method, FsDTMFEvent *event,
guint8 *volume)
{
const GstStructure *s;
const GValue *value;
g_return_val_if_fail (session != NULL, FALSE);
if (!check_message (message, session, "farstream-telephony-event-started"))
return FALSE;
s = gst_message_get_structure (message);
if (!gst_structure_has_field_typed (s, "method", FS_TYPE_DTMF_METHOD))
return FALSE;
if (method)
gst_structure_get_enum (s, "method", FS_TYPE_DTMF_METHOD, (gint*) method);
if (!gst_structure_has_field_typed (s, "event", FS_TYPE_DTMF_EVENT))
return FALSE;
if (event)
gst_structure_get_enum (s, "event", FS_TYPE_DTMF_EVENT, (gint*) event);
value = gst_structure_get_value (s, "volume");
if (!value || !G_VALUE_HOLDS (value, G_TYPE_UCHAR))
return FALSE;
if (volume)
*volume = g_value_get_uchar (value);
return TRUE;
}
static inline gboolean
gtk_argloc_set_from_value (GtkArg *arg,
GValue *value,
gboolean copy_string)
{
switch (G_TYPE_FUNDAMENTAL (arg->type))
{
case G_TYPE_CHAR: *GTK_RETLOC_CHAR (*arg) = g_value_get_char (value); break;
case G_TYPE_UCHAR: *GTK_RETLOC_UCHAR (*arg) = g_value_get_uchar (value); break;
case G_TYPE_BOOLEAN: *GTK_RETLOC_BOOL (*arg) = g_value_get_boolean (value); break;
case G_TYPE_INT: *GTK_RETLOC_INT (*arg) = g_value_get_int (value); break;
case G_TYPE_UINT: *GTK_RETLOC_UINT (*arg) = g_value_get_uint (value); break;
case G_TYPE_LONG: *GTK_RETLOC_LONG (*arg) = g_value_get_long (value); break;
case G_TYPE_ULONG: *GTK_RETLOC_ULONG (*arg) = g_value_get_ulong (value); break;
case G_TYPE_ENUM: *GTK_RETLOC_ENUM (*arg) = g_value_get_enum (value); break;
case G_TYPE_FLAGS: *GTK_RETLOC_FLAGS (*arg) = g_value_get_flags (value); break;
case G_TYPE_FLOAT: *GTK_RETLOC_FLOAT (*arg) = g_value_get_float (value); break;
case G_TYPE_DOUBLE: *GTK_RETLOC_DOUBLE (*arg) = g_value_get_double (value); break;
case G_TYPE_BOXED: *GTK_RETLOC_BOXED (*arg) = g_value_get_boxed (value); break;
case G_TYPE_POINTER: *GTK_RETLOC_POINTER (*arg) = g_value_get_pointer (value); break;
case G_TYPE_OBJECT: *GTK_RETLOC_POINTER (*arg) = g_value_get_object (value); break;
case G_TYPE_STRING: if (copy_string)
*GTK_RETLOC_STRING (*arg) = g_value_dup_string (value);
else
*GTK_RETLOC_STRING (*arg) = (char *) g_value_get_string (value);
break;
default:
return FALSE;
}
return TRUE;
}
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;
}
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 guint
get_uint (GHashTable *properties, const char *prop_name)
{
const GValue *value;
value = g_hash_table_lookup (properties, prop_name);
if (value)
return g_value_get_uchar (value);
else
return 0;
}
static gboolean
sig_match_conn (TpStreamTubeChannel *self,
SigWaitingConn *sig,
ConnWaitingSig *c)
{
if (self->priv->access_control == TP_SOCKET_ACCESS_CONTROL_PORT)
{
/* Use the port to identify the connection */
guint port;
GSocketAddress *address;
GError *error = NULL;
address = g_socket_connection_get_remote_address (c->conn, &error);
if (address == NULL)
{
DEBUG ("Failed to get connection address: %s", error->message);
g_error_free (error);
return FALSE;
}
dbus_g_type_struct_get (sig->param, 1, &port, G_MAXINT);
if (port == g_inet_socket_address_get_port (
G_INET_SOCKET_ADDRESS (address)))
{
DEBUG ("Identified connection %u using port %u",
port, sig->connection_id);
g_object_unref (address);
return TRUE;
}
g_object_unref (address);
}
else if (self->priv->access_control == TP_SOCKET_ACCESS_CONTROL_CREDENTIALS)
{
guchar byte;
byte = g_value_get_uchar (sig->param);
return byte == c->byte;
}
else
{
DEBUG ("Can't properly identify connection as we are using "
"access control %u. Assume it's the head of the list",
self->priv->access_control);
return TRUE;
}
return FALSE;
}
static void
test_enum_transformation (void)
{
GType type;
GValue orig = { 0, };
GValue xform = { 0, };
GEnumValue values[] = { {0,"0","0"}, {1,"1","1"}};
type = g_enum_register_static ("TestEnum", values);
g_value_init (&orig, type);
g_value_set_enum (&orig, 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_CHAR);
g_value_transform (&orig, &xform);
g_assert (g_value_get_char (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_UCHAR);
g_value_transform (&orig, &xform);
g_assert (g_value_get_uchar (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_INT);
g_value_transform (&orig, &xform);
g_assert (g_value_get_int (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_UINT);
g_value_transform (&orig, &xform);
g_assert (g_value_get_uint (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_LONG);
g_value_transform (&orig, &xform);
g_assert (g_value_get_long (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_ULONG);
g_value_transform (&orig, &xform);
g_assert (g_value_get_ulong (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_INT64);
g_value_transform (&orig, &xform);
g_assert (g_value_get_int64 (&xform) == 1);
memset (&xform, 0, sizeof (GValue));
g_value_init (&xform, G_TYPE_UINT64);
g_value_transform (&orig, &xform);
g_assert (g_value_get_uint64 (&xform) == 1);
}
int g_value_print(GValue *val)
{
const gchar *type;
gchar **gstrv;
gboolean boolean;
GPtrArray *gptr_array;
guchar uch;
GHashTable *table;
type = G_VALUE_TYPE_NAME(val);
if (!g_strcmp0(type, "DBusGObjectPath")) {
g_print(" %s\n", (gchar *)g_value_get_boxed(val));
} else if (!g_strcmp0(type, "GStrv")) {
gstrv = (gchar **)g_value_get_boxed(val);
while (gstrv != NULL && *gstrv != NULL) {
g_print(" %s\n", *gstrv);
gstrv++;
}
} else if(!g_strcmp0(type, "gchararray")) {
g_print(" %s\n", (gchar *)g_value_get_string(val));
} else if(!g_strcmp0(type, "gboolean")) {
boolean = g_value_get_boolean(val);
if (boolean) {
g_print(" true\n");
} else {
g_print(" false\n");
}
} else if (!g_strcmp0(type, "GPtrArray_DBusGObjectPath_")) {
gptr_array = g_value_get_boxed(val);
g_ptr_array_foreach(gptr_array, array_foreach_cb, NULL);
} else if (!g_strcmp0(type, "guchar")) {
uch = g_value_get_uchar(val);
g_print(" %d\n", uch);
} else if (!g_strcmp0(type, "GHashTable_gchararray+GValue_")) {
table = g_value_get_boxed(val);
hashtable_show_value_type(table);
}else {
g_printerr("==============================unknown\n");
}
g_print(" null\n");
return 0;
}
void scp_tree_data_from_value(ScpTreeData *data, GValue *value, gboolean copy)
{
switch (scp_tree_data_get_fundamental_type(G_VALUE_TYPE(value)))
{
case G_TYPE_INT : data->v_int = g_value_get_int(value); break;
case G_TYPE_UINT : data->v_uint = g_value_get_uint(value); break;
case G_TYPE_STRING :
{
data->v_string = copy ? g_value_dup_string(value) :
(char *) g_value_get_string(value);
break;
}
case G_TYPE_BOOLEAN : data->v_int = g_value_get_boolean(value); break;
case G_TYPE_LONG : data->v_long = g_value_get_long(value); break;
case G_TYPE_ULONG : data->v_ulong = g_value_get_ulong(value); break;
case G_TYPE_FLOAT : data->v_float = g_value_get_float(value); break;
case G_TYPE_DOUBLE : data->v_double = g_value_get_double(value); break;
#if GLIB_CHECK_VERSION(2, 32, 0)
case G_TYPE_CHAR : data->v_char = g_value_get_schar(value); break;
#else
case G_TYPE_CHAR : data->v_char = g_value_get_char(value); break;
#endif
case G_TYPE_UCHAR : data->v_uchar = g_value_get_uchar(value); break;
case G_TYPE_INT64 : data->v_int64 = g_value_get_int64(value); break;
case G_TYPE_UINT64 : data->v_uint64 = g_value_get_uint64(value); break;
case G_TYPE_ENUM : data->v_int = g_value_get_enum(value); break;
case G_TYPE_FLAGS : data->v_uint = g_value_get_flags(value); break;
case G_TYPE_POINTER : data->v_pointer = g_value_get_pointer(value); break;
case G_TYPE_OBJECT :
{
data->v_pointer = copy ? g_value_dup_object(value) :
g_value_get_object(value);
break;
}
case G_TYPE_BOXED :
{
data->v_pointer = copy ? g_value_dup_boxed(value) :
g_value_get_boxed(value);
break;
}
#if GLIB_CHECK_VERSION(2, 26, 0)
case G_TYPE_VARIANT :
{
data->v_pointer = copy ? g_value_dup_variant(value) :
g_value_get_variant(value);
break;
}
#endif
default : scp_tree_data_warn_unsupported_type(G_STRFUNC, G_VALUE_TYPE(value));
}
}
static void
aisleriot_card_set_property (GObject *self,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
AisleriotCard *card = AISLERIOT_CARD (self);
switch (property_id) {
case PROP_BOTTOM_CARD:
{
Card card_num;
card_num.value = g_value_get_uchar (value);
aisleriot_card_set_card (card, card_num, card->priv->top_card);
}
break;
case PROP_TOP_CARD:
{
Card card_num;
card_num.value = g_value_get_uchar (value);
aisleriot_card_set_card (card, card->priv->bottom_card, card_num);
}
break;
case PROP_CACHE:
aisleriot_card_set_cache (card, g_value_get_object (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec);
break;
}
}
/*
*
* Fundemental type transformations
*
*/
static GVariant *
serialize_fundamental(GvsSerializer *self, const GValue *value, gpointer unused)
{
GVariant *variant;
switch (G_VALUE_TYPE(value))
{
case G_TYPE_BOOLEAN:
variant = g_variant_new_boolean(g_value_get_boolean(value));
break;
case G_TYPE_CHAR:
variant = g_variant_new_byte(g_value_get_schar(value));
break;
case G_TYPE_DOUBLE:
variant = g_variant_new_double(g_value_get_double(value));
break;
case G_TYPE_FLOAT:
variant = g_variant_new_double(g_value_get_float(value));
break;
case G_TYPE_INT:
variant = g_variant_new_int32(g_value_get_int(value));
break;
case G_TYPE_INT64:
case G_TYPE_LONG:
variant = g_variant_new_int64(g_value_get_int64(value));
break;
case G_TYPE_STRING:
variant = g_variant_new("ms", g_value_get_string(value));
break;
case G_TYPE_UCHAR:
variant = g_variant_new_byte(g_value_get_uchar(value));
break;
case G_TYPE_UINT:
variant = g_variant_new_uint32(g_value_get_uint(value));
break;
case G_TYPE_UINT64:
case G_TYPE_ULONG:
variant = g_variant_new_uint64(g_value_get_uint64(value));
break;
case G_TYPE_VARIANT:
variant = g_value_dup_variant(value);
break;
default:
g_assert_not_reached();
break;
}
return variant;
}
static json_t *json_serialize_pspec (const GValue *value)
{
/* Only types in json-glib but G_TYPE_BOXED */
switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (value))) {
case G_TYPE_STRING:
if (!g_value_get_string (value))
break;
else
return json_string (g_value_get_string (value));
case G_TYPE_BOOLEAN:
if (g_value_get_boolean (value))
return json_true ();
else return json_false ();
case G_TYPE_INT:
return json_integer (g_value_get_int (value));
case G_TYPE_UINT:
return json_integer (g_value_get_uint (value));
case G_TYPE_LONG:
return json_integer (g_value_get_long (value));
case G_TYPE_ULONG:
return json_integer (g_value_get_ulong (value));
case G_TYPE_INT64:
return json_integer (g_value_get_int64 (value));
case G_TYPE_FLOAT:
return json_real (g_value_get_float (value));
case G_TYPE_DOUBLE:
return json_real (g_value_get_double (value));
case G_TYPE_CHAR:
return json_integer (g_value_get_schar (value));
case G_TYPE_UCHAR:
return json_integer (g_value_get_uchar (value));
case G_TYPE_ENUM:
return json_integer (g_value_get_enum (value));
case G_TYPE_FLAGS:
return json_integer (g_value_get_flags (value));
case G_TYPE_NONE:
break;
case G_TYPE_OBJECT:
{
GObject *object = g_value_get_object (value);
if (object)
return json_gobject_serialize (object);
}
break;
defalut:
g_warning("Unsuppoted type `%s'",g_type_name (G_VALUE_TYPE (value)));
}
return json_null();
}
inline static HaskellObj gtk2hs_value_as_haskellobj(Capability *cap, const GValue *value) {
switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) {
case G_TYPE_INTERFACE:
if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT))
return rts_mkPtr(cap, g_value_get_object(value));
else
break;
case G_TYPE_CHAR:
return rts_mkChar(cap, g_value_get_char(value));
case G_TYPE_UCHAR:
return rts_mkChar(cap, g_value_get_uchar(value));
case G_TYPE_BOOLEAN:
return rts_mkBool(cap, g_value_get_boolean(value));
case G_TYPE_INT:
return rts_mkInt(cap, g_value_get_int(value));
case G_TYPE_UINT:
return rts_mkWord(cap, g_value_get_uint(value));
case G_TYPE_LONG:
return rts_mkInt(cap, g_value_get_long(value));
case G_TYPE_ULONG:
return rts_mkWord(cap, g_value_get_ulong(value));
/* case G_TYPE_INT64:
return rts_mkInt64(cap, g_value_get_int64(value));
case G_TYPE_UINT64:
return rts_mkWord64(cap, g_value_get_uint64(value)); */
case G_TYPE_ENUM:
return rts_mkInt(cap, g_value_get_enum(value));
case G_TYPE_FLAGS:
return rts_mkWord(cap, g_value_get_enum(value));
case G_TYPE_FLOAT:
return rts_mkFloat(cap, g_value_get_float(value));
case G_TYPE_DOUBLE:
return rts_mkDouble(cap, g_value_get_double(value));
case G_TYPE_STRING:
return rts_mkPtr(cap, (char *)g_value_get_string(value)); /* CHECKME: is the string freed? */
case G_TYPE_POINTER:
return rts_mkPtr(cap, g_value_get_pointer(value));
case G_TYPE_BOXED:
return rts_mkPtr(cap, g_value_get_boxed(value));
/* case G_TYPE_PARAM:
return g_value_get_param(value); */
case G_TYPE_OBJECT:
return rts_mkPtr(cap, g_value_get_object(value));
}
g_error("gtk2hs_value_as_haskellobj: unable to handle GValue with type %s\n"
"please report this as a bug to [email protected]",
g_type_name(G_VALUE_TYPE(value)));
}
static void
set_property(CAModule *cam,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
if (prop_id == PROP_DEVICE)
{
cam->device = g_object_ref(g_value_get_object(value));
g_signal_connect_swapped(cam->device, "received-tpdu", G_CALLBACK(received_tpdu), cam);
}
else if (prop_id == PROP_SLOT)
{
cam->slot = g_value_get_uchar(value);
}
}
static void
gst_cmml_enc_set_property (GObject * object, guint property_id,
const GValue * value, GParamSpec * pspec)
{
GstCmmlEnc *enc = GST_CMML_ENC (object);
switch (property_id) {
case GST_CMML_ENC_GRANULERATE_N:
/* XXX: may need to flush clips */
enc->granulerate_n = g_value_get_int64 (value);
break;
case GST_CMML_ENC_GRANULERATE_D:
enc->granulerate_d = g_value_get_int64 (value);
break;
case GST_CMML_ENC_GRANULESHIFT:
enc->granuleshift = g_value_get_uchar (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
/* Set notification hints */
void
set_notification_hints(GtkWindow *nw, GHashTable *hints)
{
WindowData *windata = g_object_get_data(G_OBJECT(nw), "windata");
GValue *value;
g_assert(windata != NULL);
value = (GValue *)g_hash_table_lookup(hints, "urgency");
if (value != NULL)
{
windata->urgency = g_value_get_uchar(value);
if (windata->urgency == URGENCY_CRITICAL) {
gtk_window_set_title(GTK_WINDOW(nw), "Critical Notification");
} else {
gtk_window_set_title(GTK_WINDOW(nw), "Notification");
}
}
}
static void
client_socket_connected (TpStreamTubeChannel *self)
{
GSocketConnection *conn;
conn = g_socket_connection_factory_create_connection (
self->priv->client_socket);
g_assert (conn);
DEBUG ("Stream Tube socket connected");
#ifdef HAVE_GIO_UNIX
if (self->priv->access_control == TP_SOCKET_ACCESS_CONTROL_CREDENTIALS)
{
guchar byte;
byte = g_value_get_uchar (self->priv->access_control_param);
tp_unix_connection_send_credentials_with_byte_async (conn, byte, NULL,
send_credentials_cb, self);
}
#endif
if (self->priv->local_conn_id_set)
{
new_local_connection_identified (self, conn, self->priv->local_conn_id);
self->priv->local_conn_id_set = FALSE;
}
else
{
/* Wait for NewLocalConnection signal */
/* This assume that we never connect more than once. Or at least that we
* wait to have identify a connection before making a new connection. */
g_assert (self->priv->local_conn_waiting_id == NULL);
self->priv->local_conn_waiting_id = g_object_ref (conn);
}
g_object_unref (conn);
}
// 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 void
maman_bar_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
MamanBar *self = MAMAN_BAR (object);
switch (property_id) {
case PROP_MAMAN_NAME:
g_free (self->name);
self->name = g_value_dup_string (value);
break;
case PROP_PAPA_NUMBER:
self->papa_number = g_value_get_uchar (value);
break;
default:
/* We don't have any other property... */
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
void
_gtk_tree_data_list_value_to_node (GtkTreeDataList *list,
GValue *value)
{
switch (get_fundamental_type (G_VALUE_TYPE (value)))
{
case G_TYPE_BOOLEAN:
list->data.v_int = g_value_get_boolean (value);
break;
case G_TYPE_CHAR:
list->data.v_char = g_value_get_schar (value);
break;
case G_TYPE_UCHAR:
list->data.v_uchar = g_value_get_uchar (value);
break;
case G_TYPE_INT:
list->data.v_int = g_value_get_int (value);
break;
case G_TYPE_UINT:
list->data.v_uint = g_value_get_uint (value);
break;
case G_TYPE_LONG:
list->data.v_long = g_value_get_long (value);
break;
case G_TYPE_ULONG:
list->data.v_ulong = g_value_get_ulong (value);
break;
case G_TYPE_INT64:
list->data.v_int64 = g_value_get_int64 (value);
break;
case G_TYPE_UINT64:
list->data.v_uint64 = g_value_get_uint64 (value);
break;
case G_TYPE_ENUM:
list->data.v_int = g_value_get_enum (value);
break;
case G_TYPE_FLAGS:
list->data.v_uint = g_value_get_flags (value);
break;
case G_TYPE_POINTER:
list->data.v_pointer = g_value_get_pointer (value);
break;
case G_TYPE_FLOAT:
list->data.v_float = g_value_get_float (value);
break;
case G_TYPE_DOUBLE:
list->data.v_double = g_value_get_double (value);
break;
case G_TYPE_STRING:
g_free (list->data.v_pointer);
list->data.v_pointer = g_value_dup_string (value);
break;
case G_TYPE_OBJECT:
if (list->data.v_pointer)
g_object_unref (list->data.v_pointer);
list->data.v_pointer = g_value_dup_object (value);
break;
case G_TYPE_BOXED:
if (list->data.v_pointer)
g_boxed_free (G_VALUE_TYPE (value), list->data.v_pointer);
list->data.v_pointer = g_value_dup_boxed (value);
break;
case G_TYPE_VARIANT:
if (list->data.v_pointer)
g_variant_unref (list->data.v_pointer);
list->data.v_pointer = g_value_dup_variant (value);
break;
default:
g_warning ("%s: Unsupported type (%s) stored.", G_STRLOC, g_type_name (G_VALUE_TYPE (value)));
break;
}
}
/*
* Signature the prototype of (*GClosureMarshall), meeting the requirements
* to be the second argument to g_closure_set_marshal()
*/
static void
bindings_java_marshaller
(
GClosure* closure,
GValue* return_value,
guint n_param_values,
const GValue* param_values,
gpointer invocation_hint,
gpointer marshal_data
)
{
BindingsJavaClosure* bjc;
JNIEnv* env;
jvalue* jargs;
guint i;
GType type;
// Return values, as necessary
jboolean _b;
gboolean b;
jint _e;
jstring _str;
gchar* str;
GObject* obj;
/*
* Begin marshaller by downcasting the GClosure we got.
*/
bjc = (BindingsJavaClosure*) closure;
/*
* Get the JNIEnv interface pointer
*/
env = bindings_java_getEnv();
if (env == NULL) {
g_critical("Couldn't get JNIEnv interface, aborting marshal");
return;
}
/*
* Build the parameters for the callback. The signature of the
* handlers on the Java side for a signal "name" would be:
*
* receiveName(Signal handler, type arg0, type arg1, ...)
*
* Note that arg0 is universally the source object (in otherwords, a
* method function where the first argument is always a reference to
* self).
*
* In case you didn't know, JNI's jvalue us a rather complex union
* which holds any of the possible things you can send across the
* boundary. So we allocate an array of them, then for each parameter
* passed to the marshaller, whack them in.
*/
jargs = g_newa(jvalue, n_param_values + 1);
jargs[0].l = bjc->handler;
for(i = 0; i < n_param_values; i++) {
type = G_VALUE_TYPE(¶m_values[i]);
switch(G_TYPE_FUNDAMENTAL(type)) {
case G_TYPE_CHAR:
jargs[i+1].c = g_value_get_char(¶m_values[i]);
break;
case G_TYPE_UCHAR:
jargs[i+1].c = g_value_get_uchar(¶m_values[i]);
break;
case G_TYPE_BOOLEAN:
b = g_value_get_boolean(¶m_values[i]);
jargs[i+1].z = (b == TRUE) ? JNI_TRUE : JNI_FALSE;
break;
case G_TYPE_INT:
jargs[i+1].i = g_value_get_int(¶m_values[i]);
break;
case G_TYPE_UINT:
jargs[i+1].i = g_value_get_uint(¶m_values[i]);
break;
case G_TYPE_ENUM:
jargs[i+1].i = g_value_get_enum(¶m_values[i]);
break;
case G_TYPE_FLAGS:
jargs[i+1].i = g_value_get_flags(¶m_values[i]);
break;
case G_TYPE_LONG:
jargs[i+1].j = g_value_get_long(¶m_values[i]);
break;
case G_TYPE_ULONG:
jargs[i+1].j = g_value_get_ulong(¶m_values[i]);
break;
case G_TYPE_FLOAT:
jargs[i+1].f = g_value_get_float(¶m_values[i]);
break;
case G_TYPE_DOUBLE:
jargs[i+1].d = g_value_get_double(¶m_values[i]);
break;
case G_TYPE_STRING:
jargs[i+1].l = bindings_java_newString(env, g_value_get_string(¶m_values[i]));
break;
case G_TYPE_OBJECT:
case G_TYPE_INTERFACE:
/*
* GObjects are just pointers, and so we pass up the
* address across the boundary to be looked up and
* either an existing Proxy returned or a new Proxy
* created.
*/
obj = g_value_get_object(¶m_values[i]);
bindings_java_memory_cleanup(obj, FALSE);
jargs[i+1].j = (jlong) obj;
break;
case G_TYPE_BOXED:
/*
* We make a copy of the GBoxed so that we own it and
* thus it can (will) survive the duration of the
* signal in the event that the developer using this
* code keeps a reference to the returned Boxed.
*/
jargs[i+1].j = (jlong) g_boxed_copy(type, g_value_get_boxed(¶m_values[i]));
break;
case G_TYPE_PARAM:
/*
* We're ignoring GParamSpec at the moment. They
* normally only show up in 'notify' signals, and we
* don't need them.
*/
case G_TYPE_POINTER:
/*
* and, we're ignoring something that gets registered
* as a gpointer, by definition it has no type
* information and there's nothing we can do.
*/
jargs[i+1].j = (jlong) NULL;
break;
default:
/*
* Unrecognized. Probably means we need to add a clause above.
*/
g_printerr("Don't know how to marshal a %s", g_type_name(type));
jargs[i+1].l = 0;
break;
}
}
/*
* And now we invoke the callback on the Java side Signal handler; we have to
* select the correct function based on what return type is necessary.
*/
switch(bjc->returnType) {
case 'V':
/*
* void return signals
*/
(*env)->CallStaticVoidMethodA(env, bjc->receiver, bjc->method, jargs);
break;
case 'Z':
/*
* boolean return signals
*/
_b = (*env)->CallStaticBooleanMethodA(env, bjc->receiver, bjc->method, jargs);
if (_b == JNI_TRUE) {
b = TRUE;
} else if (_b == JNI_FALSE) {
b = FALSE;
} else {
g_critical("How did you manage to return a boolean that's neither TRUE nor FALSE?");
return;
}
g_value_set_boolean(return_value, b);
break;
case 'I':
/*
* integer return signals
*/
_e = (*env)->CallStaticIntMethodA(env, bjc->receiver, bjc->method, jargs);
g_value_set_int(return_value, _e);
break;
case 'E':
/*
* enum return signals
*/
_e = (*env)->CallStaticIntMethodA(env, bjc->receiver, bjc->method, jargs);
g_value_set_enum(return_value, _e);
break;
case 'L':
/*
* String return signals
*
* L is actually Object, of course, but the only type we need to
* worry about is java.lang.String encode it for now, and so make the
* enormous assumption that a string is what we get back.
*/
_str = (*env)->CallStaticObjectMethodA(env, bjc->receiver, bjc->method, jargs);
if (_str == NULL) {
g_warning("Invoking string handler returned null. That's probably bad");
break;
}
str = (gchar*) bindings_java_getString(env, _str);
if (str == NULL) {
/* OutOfMemoryError already thrown */
return;
}
// according to the API docs, this copies the input...
g_value_set_string(return_value, str);
// ... so we can release str
bindings_java_releaseString(str);
break;
default:
/*
* If it's not void, boolean or gchar*, then what kind of signal is it?
*/
g_critical("Invocation for return type %c not implemented", bjc->returnType);
break;
}
/*
* Cleanup
*/
for(i = 0; i < n_param_values; i++) {
type = G_VALUE_TYPE(¶m_values[i]);
switch(G_TYPE_FUNDAMENTAL(type)) {
case G_TYPE_STRING:
(*env)->DeleteLocalRef(env, jargs[i+1].l);
break;
default:
break;
}
}
/*
* Don't need to free jargs - we alloca()'d it
*/
/*
* Now, check if an exception occurred in the callback. There's a
* catch: because we're in native code right now [care of the call to
* gtk_main()] the exception gets swallowed until we return from that
* native call. So we call the function which causes the main loop to
* terminate, with the result that the exception will propegate out
* and, yes, probably halt the program.
*
* This is abrupt, but it is deliberate: we need to force developers
* to deal with criticals emitted by the underlying libraries.
* Otherwise, the next thing that is likely to happen is a
* segmentation fault, and not only does that crash the "program" but
* it takes out the Java Virtual Machine running it. People don't
* like VM crashes.
*
* Uncaught exceptions of any kind leaving a signal handler are to be
* considered programmer error and will be fatal.
*/
if ((*env)->ExceptionOccurred(env)) {
gtk_main_quit();
}
}
VALUE
rbgobj_gvalue_to_rvalue(const GValue* value)
{
GType type, fundamental_type;
VALUE rvalue;
if (!value)
return Qnil;
type = G_VALUE_TYPE(value);
if (rbgobj_convert_gvalue2rvalue(type, value, &rvalue))
return rvalue;
fundamental_type = G_TYPE_FUNDAMENTAL(type);
switch (fundamental_type) {
case G_TYPE_NONE:
return Qnil;
case G_TYPE_CHAR:
return CHR2FIX(g_value_get_char(value));
case G_TYPE_UCHAR:
return INT2FIX(g_value_get_uchar(value));
case G_TYPE_BOOLEAN:
return CBOOL2RVAL(g_value_get_boolean(value));
case G_TYPE_INT:
return INT2NUM(g_value_get_int(value));
case G_TYPE_UINT:
return UINT2NUM(g_value_get_uint(value));
case G_TYPE_LONG:
return LONG2NUM(g_value_get_long(value));
case G_TYPE_ULONG:
return ULONG2NUM(g_value_get_ulong(value));
case G_TYPE_INT64:
return rbglib_int64_to_num(g_value_get_int64(value));
case G_TYPE_UINT64:
return rbglib_uint64_to_num(g_value_get_uint64(value));
case G_TYPE_FLOAT:
return rb_float_new(g_value_get_float(value));
case G_TYPE_DOUBLE:
return rb_float_new(g_value_get_double(value));
case G_TYPE_STRING:
return CSTR2RVAL(g_value_get_string(value));
case G_TYPE_ENUM:
return rbgobj_make_enum(g_value_get_enum(value), type);
case G_TYPE_FLAGS:
return rbgobj_make_flags(g_value_get_flags(value), type);
case G_TYPE_OBJECT:
case G_TYPE_INTERFACE:
{
GObject* gobj = g_value_get_object(value);
return gobj ? GOBJ2RVAL(gobj) : Qnil;
}
case G_TYPE_PARAM:
{
GParamSpec* pspec = g_value_get_param(value);
return pspec ? rbgobj_ruby_object_from_instance(pspec) : Qnil;
}
case G_TYPE_POINTER:
{
gpointer ptr = g_value_get_pointer(value);
if (!ptr)
return Qnil;
else
return rbgobj_ptr_new(type, ptr);
}
case G_TYPE_BOXED:
{
GType gtype;
for (gtype = type;
gtype != G_TYPE_INVALID;
gtype = g_type_parent(gtype))
{
GValueToRValueFunc func =
g_type_get_qdata(gtype, qGValueToRValueFunc);
if (!func)
continue;
return func(value);
}
}
default:
if (!rbgobj_convert_gvalue2rvalue(fundamental_type, value, &rvalue)) {
GValueToRValueFunc func;
func = g_type_get_qdata(type, qGValueToRValueFunc);
if (!func) {
g_warning("rbgobj_gvalue_to_rvalue: unsupported type: %s\n",
g_type_name(type));
} else {
rvalue = func(value);
}
}
return rvalue;
}
}
JsonNode *
json_serialize_pspec (const GValue *real_value,
GParamSpec *pspec)
{
JsonNode *retval = NULL;
JsonNodeType node_type;
switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (real_value)))
{
/* JSON native types */
case G_TYPE_INT64:
retval = json_node_init_int (json_node_alloc (), g_value_get_int64 (real_value));
break;
case G_TYPE_BOOLEAN:
retval = json_node_init_boolean (json_node_alloc (), g_value_get_boolean (real_value));
break;
case G_TYPE_DOUBLE:
retval = json_node_init_double (json_node_alloc (), g_value_get_double (real_value));
break;
case G_TYPE_STRING:
retval = json_node_init_string (json_node_alloc (), g_value_get_string (real_value));
break;
/* auto-promoted types */
case G_TYPE_INT:
retval = json_node_init_int (json_node_alloc (), g_value_get_int (real_value));
break;
case G_TYPE_UINT:
retval = json_node_init_int (json_node_alloc (), g_value_get_uint (real_value));
break;
case G_TYPE_LONG:
retval = json_node_init_int (json_node_alloc (), g_value_get_long (real_value));
break;
case G_TYPE_ULONG:
retval = json_node_init_int (json_node_alloc (), g_value_get_ulong (real_value));
break;
case G_TYPE_UINT64:
retval = json_node_init_int (json_node_alloc (), g_value_get_uint64 (real_value));
break;
case G_TYPE_FLOAT:
retval = json_node_init_double (json_node_alloc (), g_value_get_float (real_value));
break;
case G_TYPE_CHAR:
retval = json_node_alloc ();
json_node_init_int (retval, g_value_get_schar (real_value));
break;
case G_TYPE_UCHAR:
retval = json_node_init_int (json_node_alloc (), g_value_get_uchar (real_value));
break;
case G_TYPE_ENUM:
retval = json_node_init_int (json_node_alloc (), g_value_get_enum (real_value));
break;
case G_TYPE_FLAGS:
retval = json_node_init_int (json_node_alloc (), g_value_get_flags (real_value));
break;
/* complex types */
case G_TYPE_BOXED:
if (G_VALUE_HOLDS (real_value, G_TYPE_STRV))
{
gchar **strv = g_value_get_boxed (real_value);
gint i, strv_len;
JsonArray *array;
strv_len = g_strv_length (strv);
array = json_array_sized_new (strv_len);
for (i = 0; i < strv_len; i++)
{
JsonNode *str = json_node_new (JSON_NODE_VALUE);
json_node_set_string (str, strv[i]);
json_array_add_element (array, str);
}
retval = json_node_init_array (json_node_alloc (), array);
json_array_unref (array);
}
else if (json_boxed_can_serialize (G_VALUE_TYPE (real_value), &node_type))
{
gpointer boxed = g_value_get_boxed (real_value);
retval = json_boxed_serialize (G_VALUE_TYPE (real_value), boxed);
}
else
g_warning ("Boxed type '%s' is not handled by JSON-GLib",
g_type_name (G_VALUE_TYPE (real_value)));
break;
case G_TYPE_OBJECT:
{
GObject *object = g_value_get_object (real_value);
retval = json_node_alloc ();
if (object != NULL)
{
json_node_init (retval, JSON_NODE_OBJECT);
json_node_take_object (retval, json_gobject_dump (object));
}
else
json_node_init_null (retval);
}
break;
case G_TYPE_NONE:
retval = json_node_new (JSON_NODE_NULL);
break;
default:
g_warning ("Unsupported type `%s'", g_type_name (G_VALUE_TYPE (real_value)));
break;
}
return retval;
}
static gint
_gvalues_compare_fixed (const GValue *value1, const GValue *value2)
{
int ret = 0;
switch (G_VALUE_TYPE (value1)) {
case G_TYPE_CHAR: {
gchar val1 = g_value_get_schar (value1);
gchar val2 = g_value_get_schar (value2);
if (val1 != val2)
ret = val1 < val2 ? -1 : val1 > val2;
break;
}
case G_TYPE_UCHAR: {
guchar val1 = g_value_get_uchar (value1);
guchar val2 = g_value_get_uchar (value2);
if (val1 != val2)
ret = val1 < val2 ? -1 : val1 > val2;
break;
}
case G_TYPE_BOOLEAN: {
gboolean val1 = g_value_get_boolean (value1);
gboolean val2 = g_value_get_boolean (value2);
if (val1 != val2)
ret = val1 < val2 ? -1 : val1 > val2;
break;
}
case G_TYPE_LONG: {
glong val1 = g_value_get_long (value1);
glong val2 = g_value_get_long (value2);
if (val1 != val2)
ret = val1 < val2 ? -1 : val1 > val2;
break;
}
case G_TYPE_ULONG: {
gulong val1 = g_value_get_ulong (value1);
gulong val2 = g_value_get_ulong (value2);
if (val1 != val2)
ret = val1 < val2 ? -1 : val1 > val2;
break;
}
case G_TYPE_INT: {
gint val1 = g_value_get_int (value1);
gint val2 = g_value_get_int (value2);
if (val1 != val2)
ret = val1 < val2 ? -1 : val1 > val2;
break;
}
case G_TYPE_UINT: {
guint val1 = g_value_get_uint (value1);
guint val2 = g_value_get_uint (value2);
if (val1 != val2)
ret = val1 < val2 ? -1 : val1 > val2;
break;
}
case G_TYPE_INT64: {
gint64 val1 = g_value_get_int64 (value1);
gint64 val2 = g_value_get_int64 (value2);
if (val1 != val2)
ret = val1 < val2 ? -1 : val1 > val2;
break;
}
case G_TYPE_UINT64: {
guint64 val1 = g_value_get_uint64 (value1);
guint64 val2 = g_value_get_uint64 (value2);
if (val1 != val2)
ret = val1 < val2 ? -1 : val1 > val2;
break;
}
case G_TYPE_FLOAT: {
gfloat val1 = g_value_get_float (value1);
gfloat val2 = g_value_get_float (value2);
/* Can't use == or != here due to inexactness of FP */
if (fabsf (val1 - val2) > FLOAT_FACTOR)
ret = val1 < val2 ? -1 : val1 > val2;
break;
}
case G_TYPE_DOUBLE: {
gdouble val1 = g_value_get_double (value1);
gdouble val2 = g_value_get_double (value2);
if (fabs (val1 - val2) > FLOAT_FACTOR)
ret = val1 < val2 ? -1 : val1 > val2;
break;
}
default:
g_warning ("Unhandled fixed size type '%s'", G_VALUE_TYPE_NAME (value1));
}
return ret;
}
void
gy_value_push(GValue * pval, GITypeInfo * info, gy_Object* o)
{
GITypeTag tag = g_type_info_get_tag(info);
GY_DEBUG("Pushing %s from GValue\n", g_type_tag_to_string(tag));
switch (tag) {
/* basic types */
case GI_TYPE_TAG_VOID:{
GITypeInfo * cellinfo = g_type_info_get_param_type(info, 0);
if (cellinfo) {
GITypeTag ctag = g_type_info_get_tag(cellinfo);
GY_DEBUG("void contains %s\n", g_type_tag_to_string(ctag));
g_base_info_unref(cellinfo);
}
ypush_nil();
break;}
case GI_TYPE_TAG_BOOLEAN:
*ypush_c(NULL) = g_value_get_boolean(pval);
break;
case GI_TYPE_TAG_INT8:
*ypush_gint8(NULL) = g_value_get_schar(pval);
break;
case GI_TYPE_TAG_UINT8:
*ypush_guint8(NULL)= g_value_get_uchar(pval);
break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_INT32:
*ypush_gint32(NULL) = g_value_get_int(pval);
break;
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_UINT32:
*ypush_guint32(NULL) = g_value_get_uint(pval);
break;
case GI_TYPE_TAG_INT64:
ypush_long(g_value_get_int64(pval));
break;
case GI_TYPE_TAG_UINT64:
ypush_long(g_value_get_uint64(pval));
break;
case GI_TYPE_TAG_FLOAT:
*ypush_f(NULL)=g_value_get_float(pval);
break;
case GI_TYPE_TAG_DOUBLE:
ypush_double(g_value_get_double(pval));
break;
case GI_TYPE_TAG_GTYPE:
ypush_long(g_value_get_gtype(pval));
break;
case GI_TYPE_TAG_UTF8:
case GI_TYPE_TAG_FILENAME:
*ypush_q(NULL) = p_strcpy(g_value_get_string(pval));
break;
/* array types */
case GI_TYPE_TAG_ARRAY:
y_error("array");
break;
/* interface types */
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo * itrf = g_type_info_get_interface (info);
switch(g_base_info_get_type (itrf)) {
case GI_INFO_TYPE_ENUM:
ypush_long(g_value_get_enum(pval));
g_base_info_unref(itrf);
break;
case GI_INFO_TYPE_OBJECT:
{
GObject * prop=g_value_get_object(pval);
g_object_ref_sink(prop);
if (!prop) {
g_base_info_unref(itrf);
y_error("get property failed");
}
GY_DEBUG("pushing result... ");
ypush_check(1);
gy_Object * out = ypush_gy_Object();
out->info=itrf;
out->object=prop;
out->repo=o->repo;
}
break;
default:
g_base_info_unref(itrf);
y_error ("fix me: only properties of type object supported yet");
}
break;
}
default:
y_error("Unimplemented");
}
}
gint
_gtk_tree_data_list_compare_func (GtkTreeModel *model,
GtkTreeIter *a,
GtkTreeIter *b,
gpointer user_data)
{
gint column = GPOINTER_TO_INT (user_data);
GType type = gtk_tree_model_get_column_type (model, column);
GValue a_value = G_VALUE_INIT;
GValue b_value = G_VALUE_INIT;
gint retval;
const gchar *stra, *strb;
gtk_tree_model_get_value (model, a, column, &a_value);
gtk_tree_model_get_value (model, b, column, &b_value);
switch (get_fundamental_type (type))
{
case G_TYPE_BOOLEAN:
if (g_value_get_boolean (&a_value) < g_value_get_boolean (&b_value))
retval = -1;
else if (g_value_get_boolean (&a_value) == g_value_get_boolean (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_CHAR:
if (g_value_get_schar (&a_value) < g_value_get_schar (&b_value))
retval = -1;
else if (g_value_get_schar (&a_value) == g_value_get_schar (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_UCHAR:
if (g_value_get_uchar (&a_value) < g_value_get_uchar (&b_value))
retval = -1;
else if (g_value_get_uchar (&a_value) == g_value_get_uchar (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_INT:
if (g_value_get_int (&a_value) < g_value_get_int (&b_value))
retval = -1;
else if (g_value_get_int (&a_value) == g_value_get_int (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_UINT:
if (g_value_get_uint (&a_value) < g_value_get_uint (&b_value))
retval = -1;
else if (g_value_get_uint (&a_value) == g_value_get_uint (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_LONG:
if (g_value_get_long (&a_value) < g_value_get_long (&b_value))
retval = -1;
else if (g_value_get_long (&a_value) == g_value_get_long (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_ULONG:
if (g_value_get_ulong (&a_value) < g_value_get_ulong (&b_value))
retval = -1;
else if (g_value_get_ulong (&a_value) == g_value_get_ulong (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_INT64:
if (g_value_get_int64 (&a_value) < g_value_get_int64 (&b_value))
retval = -1;
else if (g_value_get_int64 (&a_value) == g_value_get_int64 (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_UINT64:
if (g_value_get_uint64 (&a_value) < g_value_get_uint64 (&b_value))
retval = -1;
else if (g_value_get_uint64 (&a_value) == g_value_get_uint64 (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_ENUM:
/* this is somewhat bogus. */
if (g_value_get_enum (&a_value) < g_value_get_enum (&b_value))
retval = -1;
else if (g_value_get_enum (&a_value) == g_value_get_enum (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_FLAGS:
/* this is even more bogus. */
if (g_value_get_flags (&a_value) < g_value_get_flags (&b_value))
retval = -1;
else if (g_value_get_flags (&a_value) == g_value_get_flags (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_FLOAT:
if (g_value_get_float (&a_value) < g_value_get_float (&b_value))
retval = -1;
else if (g_value_get_float (&a_value) == g_value_get_float (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_DOUBLE:
if (g_value_get_double (&a_value) < g_value_get_double (&b_value))
retval = -1;
else if (g_value_get_double (&a_value) == g_value_get_double (&b_value))
retval = 0;
else
retval = 1;
break;
case G_TYPE_STRING:
stra = g_value_get_string (&a_value);
strb = g_value_get_string (&b_value);
if (stra == NULL) stra = "";
if (strb == NULL) strb = "";
retval = g_utf8_collate (stra, strb);
break;
case G_TYPE_VARIANT:
case G_TYPE_POINTER:
case G_TYPE_BOXED:
case G_TYPE_OBJECT:
default:
g_warning ("Attempting to sort on invalid type %s\n", g_type_name (type));
retval = FALSE;
break;
}
g_value_unset (&a_value);
g_value_unset (&b_value);
return retval;
}
static HaskellObj
#ifdef GHC_RTS_USES_CAPABILITY
gtk2hs_value_as_haskellobj(Capability *cap, const GValue *value) {
#else
gtk2hs_value_as_haskellobj(const GValue *value) {
#endif
switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) {
case G_TYPE_INTERFACE:
if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT))
return rts_mkPtr(CAP g_value_get_object(value));
else
break;
case G_TYPE_CHAR:
return rts_mkChar(CAP g_value_get_schar(value));
case G_TYPE_UCHAR:
return rts_mkChar(CAP g_value_get_uchar(value));
case G_TYPE_BOOLEAN:
return rts_mkBool(CAP g_value_get_boolean(value));
case G_TYPE_INT:
return rts_mkInt(CAP g_value_get_int(value));
case G_TYPE_UINT:
return rts_mkWord(CAP g_value_get_uint(value));
case G_TYPE_LONG:
return rts_mkInt(CAP g_value_get_long(value));
case G_TYPE_ULONG:
return rts_mkWord(CAP g_value_get_ulong(value));
/* case G_TYPE_INT64:
return rts_mkInt64(CAP g_value_get_int64(value));
case G_TYPE_UINT64:
return rts_mkWord64(CAP g_value_get_uint64(value)); */
case G_TYPE_ENUM:
return rts_mkInt(CAP g_value_get_enum(value));
case G_TYPE_FLAGS:
return rts_mkWord(CAP g_value_get_enum(value));
case G_TYPE_FLOAT:
return rts_mkFloat(CAP g_value_get_float(value));
case G_TYPE_DOUBLE:
return rts_mkDouble(CAP g_value_get_double(value));
case G_TYPE_STRING:
return rts_mkPtr(CAP (char *)g_value_get_string(value)); /* CHECKME: is the string freed? */
case G_TYPE_POINTER:
return rts_mkPtr(CAP g_value_get_pointer(value));
case G_TYPE_BOXED:
return rts_mkPtr(CAP g_value_get_boxed(value));
case G_TYPE_PARAM:
return rts_mkPtr(CAP g_value_get_param(value));
case G_TYPE_OBJECT:
return rts_mkPtr(CAP g_value_get_object(value));
}
g_error("gtk2hs_value_as_haskellobj: unable to handle GValue with type %s\n"
"please report this as a bug to [email protected]",
g_type_name(G_VALUE_TYPE(value)));
}
void
gtk2hs_value_from_haskellobj(GValue *value, HaskellObj obj) {
switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) {
case G_TYPE_INVALID:
case G_TYPE_NONE:
return;
case G_TYPE_INTERFACE:
/* we only handle interface types that have a GObject prereq */
if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) {
g_value_set_object(value, rts_getPtr(obj));
} else {
break;
}
return;
case G_TYPE_CHAR:
g_value_set_schar(value, rts_getChar(obj));
return;
case G_TYPE_UCHAR:
g_value_set_schar(value, rts_getChar(obj));
return;
case G_TYPE_BOOLEAN:
g_value_set_boolean(value, rts_getBool(obj));
return;
case G_TYPE_INT:
g_value_set_int(value, rts_getInt(obj));
return;
case G_TYPE_UINT:
g_value_set_uint(value, rts_getWord(obj));
return;
case G_TYPE_LONG:
g_value_set_long(value, rts_getInt(obj));
return;
case G_TYPE_ULONG:
g_value_set_ulong(value, rts_getWord(obj));
return;
/* case G_TYPE_INT64:
g_value_set_int64(value, rts_getInt64(obj));
return;
case G_TYPE_UINT64:
g_value_set_uint64(value, rts_getWord64(obj));
return; */
case G_TYPE_ENUM:
g_value_set_enum(value, rts_getInt(obj));
return;
case G_TYPE_FLAGS:
g_value_set_flags(value, rts_getInt(obj));
return;
case G_TYPE_FLOAT:
g_value_set_float(value, rts_getFloat(obj));
return;
case G_TYPE_DOUBLE:
g_value_set_double(value, rts_getDouble(obj));
return;
case G_TYPE_STRING:
g_value_set_string(value, rts_getPtr(obj));
return;
case G_TYPE_POINTER:
g_value_set_pointer(value, rts_getPtr(obj));
return;
/* case G_TYPE_BOXED: {
g_value_set_boxed(value, obj);
break;
}
case G_TYPE_PARAM:
g_value_set_param(value, (obj));
break; */
case G_TYPE_OBJECT:
g_value_set_object(value, rts_getPtr(obj));
return;
}
g_error("gtk2hs_value_from_haskellobj: unable to handle GValue with type %s\n"
"please report this as a bug to [email protected]",
g_type_name(G_VALUE_TYPE(value)));
}
static void
test_collection (void)
{
GValue value = { 0, };
gchar *error;
g_value_init (&value, G_TYPE_CHAR);
error = collect (&value, 'c');
g_assert (error == NULL);
g_assert (g_value_get_char (&value) == 'c');
g_value_unset (&value);
g_value_init (&value, G_TYPE_UCHAR);
error = collect (&value, 129);
g_assert (error == NULL);
g_assert (g_value_get_uchar (&value) == 129);
g_value_unset (&value);
g_value_init (&value, G_TYPE_BOOLEAN);
error = collect (&value, TRUE);
g_assert (error == NULL);
g_assert (g_value_get_boolean (&value) == TRUE);
g_value_unset (&value);
g_value_init (&value, G_TYPE_INT);
error = collect (&value, G_MAXINT);
g_assert (error == NULL);
g_assert (g_value_get_int (&value) == G_MAXINT);
g_value_unset (&value);
g_value_init (&value, G_TYPE_UINT);
error = collect (&value, G_MAXUINT);
g_assert (error == NULL);
g_assert (g_value_get_uint (&value) == G_MAXUINT);
g_value_unset (&value);
g_value_init (&value, G_TYPE_LONG);
error = collect (&value, G_MAXLONG);
g_assert (error == NULL);
g_assert (g_value_get_long (&value) == G_MAXLONG);
g_value_unset (&value);
g_value_init (&value, G_TYPE_ULONG);
error = collect (&value, G_MAXULONG);
g_assert (error == NULL);
g_assert (g_value_get_ulong (&value) == G_MAXULONG);
g_value_unset (&value);
g_value_init (&value, G_TYPE_INT64);
error = collect (&value, G_MAXINT64);
g_assert (error == NULL);
g_assert (g_value_get_int64 (&value) == G_MAXINT64);
g_value_unset (&value);
g_value_init (&value, G_TYPE_UINT64);
error = collect (&value, G_MAXUINT64);
g_assert (error == NULL);
g_assert (g_value_get_uint64 (&value) == G_MAXUINT64);
g_value_unset (&value);
g_value_init (&value, G_TYPE_FLOAT);
error = collect (&value, G_MAXFLOAT);
g_assert (error == NULL);
g_assert (g_value_get_float (&value) == G_MAXFLOAT);
g_value_unset (&value);
g_value_init (&value, G_TYPE_DOUBLE);
error = collect (&value, G_MAXDOUBLE);
g_assert (error == NULL);
g_assert (g_value_get_double (&value) == G_MAXDOUBLE);
g_value_unset (&value);
g_value_init (&value, G_TYPE_STRING);
error = collect (&value, "string ?");
g_assert (error == NULL);
g_assert (strcmp (g_value_get_string (&value), "string ?") == 0);
g_value_unset (&value);
g_value_init (&value, G_TYPE_GTYPE);
error = collect (&value, G_TYPE_BOXED);
g_assert (error == NULL);
g_assert (g_value_get_gtype (&value) == G_TYPE_BOXED);
}
