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); }