/* this function is called every second and dumps the RTP manager stats */
static gboolean print_stats (GstElement * rtpbin)
{
GObject *session;
GValueArray *arr;
GValue *val;
guint i;
g_print ("***********************************\n");
/* get session 0 */
g_signal_emit_by_name (rtpbin, "get-internal-session", 0, &session);
/* print all the sources in the session, this includes the internal source */
g_object_get (session, "sources", &arr, NULL);
for (i = 0; i < arr->n_values; i++) {
GObject *source;
val = g_value_array_get_nth (arr, i);
source = g_value_get_object (val);
print_source_stats (source);
}
g_value_array_free (arr);
g_object_unref (session);
return TRUE;
}
static void
terminal_profile_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
TerminalProfile *profile = TERMINAL_PROFILE (object);
TerminalProfilePrivate *priv = profile->priv;
if (prop_id == 0 || prop_id >= LAST_PROP)
{
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
return;
}
/* Note: When adding things here, do the same in get_prop_value_from_prop_name! */
switch (prop_id)
{
case PROP_BACKGROUND_IMAGE:
ensure_pixbuf_property (profile, PROP_BACKGROUND_IMAGE_FILE, PROP_BACKGROUND_IMAGE, &priv->background_load_failed);
break;
default:
break;
}
g_value_copy (g_value_array_get_nth (priv->properties, prop_id), value);
}
/* Print the contents of a GValueArray. */
static void
print_array(GValueArray *array)
{
int i;
GValue *value;
if (array != NULL) {
printf(" (");
for (i = 0; i < array->n_values; i++) {
value = g_value_array_get_nth(array, i);
if (i > 0) {
printf(", ");
}
if (G_VALUE_HOLDS_LONG(value)) {
printf("%ld", g_value_get_long(value));
} else
if (G_VALUE_HOLDS_STRING(value)) {
printf("\"%s\"", g_value_get_string(value));
} else
if (G_VALUE_HOLDS_POINTER(value)) {
printf("\"%ls\"",
(wchar_t*) g_value_get_pointer(value));
}
if (G_VALUE_HOLDS_BOXED(value)) {
print_array(g_value_get_boxed(value));
}
}
printf(")");
/* _vte_matcher_free_params_array(array); */
}
}
static void
message_list_view_delete_clicked(struct MessageListViewData *data,
Evas_Object * obj, void *event_info)
{
g_debug("message_list_view_delete_clicked()");
evas_object_hide(data->hv);
data->selected_row = etk_tree_selected_row_get(data->tree);
if (data->selected_row != NULL) {
GValueArray *message =
etk_tree_row_data_get(data->selected_row);
GHashTable *options = g_hash_table_new(g_str_hash, g_str_equal);
g_hash_table_insert(options, "id",
GINT_TO_POINTER(g_value_get_int
(g_value_array_get_nth
(message, 0))));
g_hash_table_insert(options, "delete_callback",
message_list_view_message_deleted);
g_hash_table_insert(options, "delete_callback_data", data);
struct Window *win = window_new(D_("Delete Message"));
window_init(win);
window_view_show(win, options, message_delete_view_show,
message_delete_view_hide);
}
}
static void
_proxy_items_changed_cb (DBusGProxy *proxy,
GPtrArray *items,
gpointer userdata)
{
MojitoClientView *view = MOJITO_CLIENT_VIEW (userdata);
MojitoClientViewPrivate *priv = GET_PRIVATE (view);
gint i = 0;
GList *items_list = NULL;
for (i = 0; i < items->len; i++)
{
GValueArray *varray = (GValueArray *)g_ptr_array_index (items, i);
MojitoItem *item;
const gchar *uid;
uid = g_value_get_string (g_value_array_get_nth (varray, 1));
item = g_hash_table_lookup (priv->uuid_to_items,
uid);
_mojito_item_update_from_value_array (item, varray);
items_list = g_list_append (items_list, mojito_item_ref (item));
}
/* If handler wants a ref then it should ref it up */
g_signal_emit (view, signals[ITEMS_CHANGED_SIGNAL], 0, items_list);
g_list_foreach (items_list, (GFunc)mojito_item_unref, NULL);
g_list_free (items_list);
}
static void
serving_system_reply (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
{
CdmaDeviceInfo *info = user_data;
GError *error = NULL;
GValueArray *array = NULL;
guint32 new_sid = 0;
GValue *value;
if (dbus_g_proxy_end_call (proxy, call, &error,
SERVING_SYSTEM_TYPE, &array,
G_TYPE_INVALID)) {
if (array->n_values == 3) {
value = g_value_array_get_nth (array, 2);
if (G_VALUE_HOLDS_UINT (value))
new_sid = g_value_get_uint (value);
}
g_value_array_free (array);
}
if (new_sid != info->sid) {
info->sid = new_sid;
g_free (info->provider_name);
info->provider_name = mobile_helper_parse_3gpp2_operator_name (&(info->mobile_providers_database), info->sid);
}
g_clear_error (&error);
}
static void
gst_interleave_set_channel_positions (GstInterleave * self, GstStructure * s)
{
GValue pos_array = { 0, };
gint i;
g_value_init (&pos_array, GST_TYPE_ARRAY);
if (self->channel_positions
&& self->channels == self->channel_positions->n_values
&& gst_interleave_check_channel_positions (self->channel_positions)) {
GST_DEBUG_OBJECT (self, "Using provided channel positions");
for (i = 0; i < self->channels; i++)
gst_value_array_append_value (&pos_array,
g_value_array_get_nth (self->channel_positions, i));
} else {
GValue pos_none = { 0, };
GST_WARNING_OBJECT (self, "Using NONE channel positions");
g_value_init (&pos_none, GST_TYPE_AUDIO_CHANNEL_POSITION);
g_value_set_enum (&pos_none, GST_AUDIO_CHANNEL_POSITION_NONE);
for (i = 0; i < self->channels; i++)
gst_value_array_append_value (&pos_array, &pos_none);
g_value_unset (&pos_none);
}
gst_structure_set_value (s, "channel-positions", &pos_array);
g_value_unset (&pos_array);
}
GArray *
gimp_dash_pattern_from_value_array (GValueArray *value_array)
{
if (value_array == NULL || value_array->n_values == 0)
{
return NULL;
}
else
{
GArray *pattern;
gint i;
pattern = g_array_sized_new (FALSE, FALSE,
sizeof (gdouble), value_array->n_values);
for (i = 0; i < value_array->n_values; i++)
{
GValue *item = g_value_array_get_nth (value_array, i);
gdouble val;
g_return_val_if_fail (G_VALUE_HOLDS_DOUBLE (item), NULL);
val = g_value_get_double (item);
g_array_append_val (pattern, val);
}
return pattern;
}
}
static gchar *
gst_video_parse_int_valarray_to_string (GValueArray * valarray)
{
/* holds a 64-bit number as string, which can have max. 20 digits
* (with extra char for nullbyte) */
gchar stride_str[21];
gchar *str = NULL;
guint i;
for (i = 0; i < valarray->n_values; i++) {
GValue *gvalue = g_value_array_get_nth (valarray, i);
guint val = g_value_get_uint (gvalue);
g_snprintf (stride_str, sizeof (stride_str), "%u", val);
if (str == NULL) {
str = g_strdup (stride_str);
} else {
gchar *new_str = g_strdup_printf ("%s,%s", str, stride_str);
g_free (str);
str = new_str;
}
}
return str;
}
static char *
ip6_array_to_addr_prefix (GValueArray *values)
{
GValue *prefix_val;
char *ret = NULL;
GString *ip6_str;
char buf[INET6_ADDRSTRLEN + 1];
gboolean is_unspec = FALSE;
/* address */
if (ip6_array_to_addr (values, 0, buf, sizeof (buf), NULL)) {
/* Enough space for the address, '/', and the prefix */
ip6_str = g_string_sized_new ((INET6_ADDRSTRLEN * 2) + 5);
/* prefix */
g_string_append (ip6_str, buf);
prefix_val = g_value_array_get_nth (values, 1);
g_string_append_printf (ip6_str, "/%u", g_value_get_uint (prefix_val));
if (ip6_array_to_addr (values, 2, buf, sizeof (buf), &is_unspec)) {
if (!is_unspec)
g_string_append_printf (ip6_str, ",%s", buf);
}
ret = ip6_str->str;
g_string_free (ip6_str, FALSE);
}
return ret;
}
static void
_proxy_items_removed_cb (DBusGProxy *proxy,
GPtrArray *items,
gpointer userdata)
{
SwClientItemView *view = SW_CLIENT_ITEM_VIEW (userdata);
SwClientItemViewPrivate *priv = GET_PRIVATE (view);
gint i = 0;
GList *items_list = NULL;
for (i = 0; i < items->len; i++)
{
GValueArray *varray = (GValueArray *)g_ptr_array_index (items, i);
const gchar *uid;
SwItem *item;
uid = g_value_get_string (g_value_array_get_nth (varray, 1));
item = g_hash_table_lookup (priv->uuid_to_items,
uid);
if (item)
{
/* Must ref up because g_hash_table_remove drops ref */
items_list = g_list_append (items_list, sw_item_ref (item));
g_hash_table_remove (priv->uuid_to_items, uid);
}
}
/* If handler wants a ref then it should ref it up */
g_signal_emit (view, signals[ITEMS_REMOVED_SIGNAL], 0, items_list);
g_list_foreach (items_list, (GFunc)sw_item_unref, NULL);
g_list_free (items_list);
}
static gboolean
gst_interleave_channel_positions_to_mask (GValueArray * positions,
gint default_ordering_map[64], guint64 * mask)
{
gint i;
guint channels;
GstAudioChannelPosition *pos;
gboolean ret;
channels = positions->n_values;
pos = g_new (GstAudioChannelPosition, channels);
for (i = 0; i < channels; i++) {
GValue *val;
val = g_value_array_get_nth (positions, i);
pos[i] = g_value_get_enum (val);
}
/* sort the default ordering map according to the position order */
for (i = 0; i < channels; i++) {
default_ordering_map[i] = i;
}
g_qsort_with_data (default_ordering_map, channels,
sizeof (*default_ordering_map), compare_positions, pos);
ret = gst_audio_channel_positions_to_mask (pos, channels, FALSE, mask);
g_free (pos);
return ret;
}
gboolean
_capabilities_has_stream_tube (TpCapabilities *caps)
{
GPtrArray *classes;
guint i;
if (caps == NULL)
return FALSE;
classes = tp_capabilities_get_channel_classes (caps);
for (i = 0; i < classes->len; i++)
{
GValueArray *arr = g_ptr_array_index (classes, i);
GHashTable *fixed;
const gchar *chan_type;
const gchar *service;
TpHandleType handle_type;
fixed = g_value_get_boxed (g_value_array_get_nth (arr, 0));
chan_type = tp_asv_get_string (fixed, TP_PROP_CHANNEL_CHANNEL_TYPE);
service = tp_asv_get_string (fixed,
TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SERVICE);
handle_type = tp_asv_get_uint32 (fixed,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, NULL);
if (!tp_strdiff (chan_type, TP_IFACE_CHANNEL_TYPE_STREAM_TUBE) &&
handle_type == TP_HANDLE_TYPE_CONTACT &&
(!tp_capabilities_is_specific_to_contact (caps) ||
!tp_strdiff (service, TUBE_SERVICE)))
return TRUE;
}
return FALSE;
}
static gboolean
gst_interleave_check_channel_positions (GValueArray * positions)
{
gint i;
guint channels;
GstAudioChannelPosition *pos;
gboolean ret;
channels = positions->n_values;
pos = g_new (GstAudioChannelPosition, positions->n_values);
for (i = 0; i < channels; i++) {
GValue *v = g_value_array_get_nth (positions, i);
pos[i] = g_value_get_enum (v);
}
ret = gst_audio_check_channel_positions (pos, channels);
g_free (pos);
return ret;
}
void
gst_cmml_parser_meta_to_string (GstCmmlParser * parser,
xmlNodePtr parent, GValueArray * array)
{
gint i;
xmlNodePtr node;
GValue *name, *content;
for (i = 0; i < array->n_values - 1; i += 2) {
name = g_value_array_get_nth (array, i);
content = g_value_array_get_nth (array, i + 1);
node = gst_cmml_parser_new_node (parser, "meta",
"name", g_value_get_string (name),
"content", g_value_get_string (content), NULL);
xmlAddChild (parent, node);
}
}
END_TEST
static void gotmeta(MafwRenderer *renderer,
const gchar *name, GValueArray *varr,
gboolean *isok)
{
static guint callcount = 0;
switch (callcount++) {
case 0:
*isok = !strcmp(name, "bitrate")
&& varr->n_values == 1
&& g_value_get_int(g_value_array_get_nth(varr, 0)) == 123;
break;
case 1:
*isok = !strcmp(name, "date")
&& varr->n_values == 3
&& g_value_get_int(g_value_array_get_nth(varr, 0)) == 2008
&& g_value_get_int(g_value_array_get_nth(varr, 1)) == 05
&& g_value_get_int(g_value_array_get_nth(varr, 2)) == 19;
break;
case 2:
*isok = !strcmp(name, "tags")
&& varr->n_values == 3
&& !strcmp("epic", g_value_get_string(g_value_array_get_nth(varr, 0)))
&& !strcmp("fail", g_value_get_string(g_value_array_get_nth(varr, 1)))
&& !strcmp("aye", g_value_get_string(g_value_array_get_nth(varr, 2)));
break;
default:
fail("invoked too many times");
break;
}
}
static gint
compare_messages(gconstpointer _a, gconstpointer _b)
{
GValueArray **a = (GValueArray **) _a;
GValueArray **b = (GValueArray **) _b;
GHashTable *h1 = g_value_get_boxed(g_value_array_get_nth(*a, 4));
GHashTable *h2 = g_value_get_boxed(g_value_array_get_nth(*b, 4));
long la = g_value_get_long(g_hash_table_lookup(h1, "timestamp_int"));
long lb = g_value_get_long(g_hash_table_lookup(h2, "timestamp_int"));
if (la > lb)
return -1;
else if (la < lb)
return 1;
else
return 0;
}
static int
values_equal (GParamSpec *pspec,
const GValue *va,
const GValue *vb)
{
/* g_param_values_cmp isn't good enough for some types, since e.g.
* it compares colours and font descriptions by pointer value, not
* with the correct compare functions. Providing extra
* PangoParamSpecFontDescription and GdkParamSpecColor wouldn't
* have fixed this either, since it's unclear how to _order_ them.
* Luckily we only need to check them for equality here.
*/
if (g_param_values_cmp (pspec, va, vb) == 0)
return TRUE;
if (G_PARAM_SPEC_VALUE_TYPE (pspec) == GDK_TYPE_COLOR)
return gdk_color_equal (g_value_get_boxed (va), g_value_get_boxed (vb));
if (G_PARAM_SPEC_VALUE_TYPE (pspec) == PANGO_TYPE_FONT_DESCRIPTION)
return pango_font_description_equal (g_value_get_boxed (va), g_value_get_boxed (vb));
if (G_IS_PARAM_SPEC_VALUE_ARRAY (pspec) &&
G_PARAM_SPEC_VALUE_TYPE (G_PARAM_SPEC_VALUE_ARRAY (pspec)->element_spec) == GDK_TYPE_COLOR)
{
GValueArray *ara, *arb;
guint i;
ara = g_value_get_boxed (va);
arb = g_value_get_boxed (vb);
if (!ara || !arb || ara->n_values != arb->n_values)
return FALSE;
for (i = 0; i < ara->n_values; ++i)
if (!gdk_color_equal (g_value_get_boxed (g_value_array_get_nth (ara, i)),
g_value_get_boxed (g_value_array_get_nth (arb, i))))
return FALSE;
return TRUE;
}
return FALSE;
}
static void
tp_chat_properties_changed_cb (TpProxy *proxy,
const GPtrArray *properties,
gpointer user_data,
GObject *chat)
{
EmpathyTpChatPriv *priv = GET_PRIV (chat);
guint i, j;
if (priv->channel == NULL)
return;
if (!priv->had_properties_list || !properties) {
return;
}
for (i = 0; i < properties->len; i++) {
GValueArray *prop_struct;
TpChatProperty *property;
guint id;
GValue *src_value;
prop_struct = g_ptr_array_index (properties, i);
id = g_value_get_uint (g_value_array_get_nth (prop_struct, 0));
src_value = g_value_get_boxed (g_value_array_get_nth (prop_struct, 1));
for (j = 0; j < priv->properties->len; j++) {
property = g_ptr_array_index (priv->properties, j);
if (property->id == id) {
if (property->value) {
g_value_copy (src_value, property->value);
} else {
property->value = tp_g_value_slice_dup (src_value);
}
DEBUG ("property %s changed", property->name);
g_signal_emit (chat, signals[PROPERTY_CHANGED], 0,
property->name, property->value);
break;
}
}
}
}
static void g_value_email_free(gpointer data) {
GValueArray* email = (GValueArray *) data;
GValue* email_member;
guint i;
for (i = 0; i < email->n_values; i++) {
email_member = g_value_array_get_nth(email, i);
g_value_unset(email_member);
}
}
/**
* geoclue_accuracy_get_details:
* @accuracy: A #GeoclueAccuracy
* @level: Pointer to returned #GeoclueAccuracyLevel or %NULL
* @horizontal_accuracy: Pointer to returned horizontal accuracy in meters or %NULL
* @vertical_accuracy: Pointer to returned vertical accuracy in meters or %NULL
*
* @horizontal_accuracy and @vertical_accuracy will only be defined
* if @level is %GEOCLUE_ACCURACY_LEVEL_DETAILED.
*/
void
geoclue_accuracy_get_details (GeoclueAccuracy *accuracy,
GeoclueAccuracyLevel *level,
double *horizontal_accuracy,
double *vertical_accuracy)
{
GValueArray *vals;
vals = accuracy;
if (level != NULL) {
*level = g_value_get_int (g_value_array_get_nth (vals, 0));
}
if (horizontal_accuracy != NULL) {
*horizontal_accuracy = g_value_get_double (g_value_array_get_nth (vals, 1));
}
if (vertical_accuracy != NULL) {
*vertical_accuracy = g_value_get_double (g_value_array_get_nth (vals, 2));
}
}
static void
ip6_route_writer (GKeyFile *file,
const char *keyfile_dir,
const char *uuid,
NMSetting *setting,
const char *key,
const GValue *value)
{
GPtrArray *array;
const char *setting_name = nm_setting_get_name (setting);
char *list[3];
int i, j;
g_return_if_fail (G_VALUE_HOLDS (value, DBUS_TYPE_G_ARRAY_OF_IP6_ROUTE));
array = (GPtrArray *) g_value_get_boxed (value);
if (!array || !array->len)
return;
for (i = 0, j = 1; i < array->len; i++) {
GValueArray *values = g_ptr_array_index (array, i);
char *key_name;
guint32 int_val;
char buf[INET6_ADDRSTRLEN + 1];
gboolean is_unspec = FALSE;
memset (list, 0, sizeof (list));
/* Address and prefix */
list[0] = ip6_array_to_addr_prefix (values);
if (!list[0])
continue;
/* Next Hop */
if (!ip6_array_to_addr (values, 2, buf, sizeof (buf), &is_unspec))
continue;
if (is_unspec)
continue;
list[1] = g_strdup (buf);
/* Metric */
value = g_value_array_get_nth (values, 3);
int_val = g_value_get_uint (value);
list[2] = g_strdup_printf ("%d", int_val);
/* Write it out */
key_name = g_strdup_printf ("%s%d", key, j++);
g_key_file_set_string_list (file, setting_name, key_name, (const char **) list, 3);
g_free (key_name);
g_free (list[0]);
g_free (list[1]);
g_free (list[2]);
}
}
/**
* gst_factory_list_filter:
* @array: a #GValueArray to filter
* @caps: a #GstCaps
*
* Filter out all the elementfactories in @array that can handle @caps as
* input.
*
* Returns: a #GValueArray of #GstElementFactory elements. Use
* g_value_array_free() after usage.
*/
GValueArray *
gst_factory_list_filter (GValueArray * array, const GstCaps * caps)
{
GValueArray *result;
gint i;
result = g_value_array_new (0);
GST_DEBUG ("finding factories");
/* loop over all the factories */
for (i = 0; i < array->n_values; i++) {
GValue *value;
GstElementFactory *factory;
const GList *templates;
GList *walk;
value = g_value_array_get_nth (array, i);
factory = g_value_get_object (value);
/* get the templates from the element factory */
templates = gst_element_factory_get_static_pad_templates (factory);
for (walk = (GList *) templates; walk; walk = g_list_next (walk)) {
GstStaticPadTemplate *templ = walk->data;
/* we only care about the sink templates */
if (templ->direction == GST_PAD_SINK) {
GstCaps *intersect;
GstCaps *tmpl_caps;
/* try to intersect the caps with the caps of the template */
tmpl_caps = gst_static_caps_get (&templ->static_caps);
/* FIXME, intersect is not the right method, we ideally want to check
* for a subset here */
intersect = gst_caps_intersect (caps, tmpl_caps);
gst_caps_unref (tmpl_caps);
/* check if the intersection is empty */
if (!gst_caps_is_empty (intersect)) {
/* non empty intersection, we can use this element */
GValue resval = { 0, };
g_value_init (&resval, G_TYPE_OBJECT);
g_value_set_object (&resval, factory);
g_value_array_append (result, &resval);
g_value_unset (&resval);
gst_caps_unref (intersect);
break;
}
gst_caps_unref (intersect);
}
}
}
return result;
}
//! memasukkan item ke widget , biasanya dipakai di proses editing
static void modifSetItemToWidget(modifStruct_* modif,GValueArray* hasil){
//! hari
GValue *ii = g_value_array_get_nth (hasil ,1 );
globalSetCurrentIndexCombo(modif->hari , g_value_get_string(ii));
//!jam dan menit
ii = g_value_array_get_nth (hasil ,2 );
gchar **kalender = g_strsplit_set(g_value_get_string(ii),":",-1); //is equivalent to ``%H:%M:%S'
gtk_spin_button_set_value( modif->jam,globalConStrToInt(kalender[0]) );
gtk_spin_button_set_value( modif->mnt,globalConStrToInt(kalender[1]) );
g_strfreev (kalender);
//! bagian
ii = g_value_array_get_nth (hasil ,3 );
globalSetCurrentIndexCombo(modif->bagian , g_value_get_string(ii) );
//! total bunyi
ii = g_value_array_get_nth (hasil ,4 );
gtk_spin_button_set_value( modif->total , globalConStrToInt(g_value_get_string(ii)) );
//! nama file
ii = g_value_array_get_nth (hasil ,5 );
gtk_button_set_label(modif->filePilih , g_value_get_string(ii) );
}
/*
char* databaseGetDataFromDb(char* sql , GValueArray *where){
char *tail, *hasil;
int rc = sqlite3_prepare(sqlite->db, sql, strlen(sql), &sqlite->stmt, &tail);
if(rc==SQLITE_OK){
int ema;
for(ema=0;ema<1;ema++){
GValue* value = g_value_array_get_nth (where,ema);
if(G_VALUE_TYPE(value) == G_TYPE_INT){
sqlite3_bind_int(sqlite->stmt , ema+1 , g_value_get_int(value) );
}
else if( G_VALUE_TYPE(value) == G_TYPE_STRING ){
char * tmp = g_value_get_string(value);
sqlite3_bind_text(sqlite->stmt , ema+1 , tmp , strlen(tmp), SQLITE_TRANSIENT );
}
}
// gint ncols = sqlite3_column_count(sqlite->stmt);
sqlite3_step(sqlite->stmt);
hasil = g_strdup_printf ("%s", sqlite3_column_text(sqlite->stmt, 0) ) ;
}
else{
fprintf(stderr, "sqlite3_prepare() : Error: %s\n", tail);
}
sqlite3_finalize(sqlite->stmt);
return hasil;
}
*/
GValueArray *databaseGetDatasFromDb(char* sql , GValueArray *where , gboolean *status ){
status = FALSE;
GValueArray* hasil = g_value_array_new (-1);
char *tail;
int rc = sqlite3_prepare(sqlite->db, sql, strlen(sql), &sqlite->stmt, &tail);
if(rc==SQLITE_OK){
status = TRUE;
int ema;
if(where != NULL){
for(ema=0;ema<where->n_values;ema++){
GValue* value = g_value_array_get_nth (where,ema);
if(G_VALUE_TYPE(value) == G_TYPE_INT){
sqlite3_bind_int(sqlite->stmt , ema+1 , g_value_get_int(value) );
}
else if( G_VALUE_TYPE(value) == G_TYPE_STRING ){
char * tmp = g_value_get_string(value);
sqlite3_bind_text(sqlite->stmt , ema+1 , tmp , strlen(tmp), SQLITE_TRANSIENT );
}
}
}
int ncols = sqlite3_column_count(sqlite->stmt);
rc = sqlite3_step(sqlite->stmt);
//! Print column information
int i;
while(rc == SQLITE_ROW) {
for(i=0; i < ncols; i++) {
GValue a = {0};
g_assert (!G_VALUE_HOLDS_STRING (&a));
int type = sqlite3_column_type(sqlite->stmt, i);
if(type==SQLITE_INTEGER){
g_value_init (&a, G_TYPE_INT);
int tmp = sqlite3_column_int(sqlite->stmt, i);
g_value_set_int (&a, 1);
}
else if(type==SQLITE_FLOAT){
g_value_init (&a, G_TYPE_FLOAT);
}
else if(type==SQLITE_TEXT){
char *tmp = g_strdup_printf ("%s", sqlite3_column_text(sqlite->stmt, i) );
g_value_init (&a, G_TYPE_STRING);
g_value_set_string (&a, tmp);
g_free(tmp);
}
hasil = g_value_array_append(hasil,&a);
}
rc = sqlite3_step(sqlite->stmt);
}
}
else{
fprintf(stderr, "sqlite3_prepare() : Error: %s\n", tail);
}
sqlite3_finalize(sqlite->stmt);
return hasil;
}
static void
__get_expression_value (GdaConnection *cnc, GValue *src, GString *str)
{
gchar *escaped_string = NULL;
switch (G_TYPE_FUNDAMENTAL (G_VALUE_TYPE (src))) {
case G_TYPE_STRING:
escaped_string = gda_connection_value_to_sql_string(cnc, src);
g_string_append_printf (str, "%s", escaped_string);
g_free(escaped_string);
break;
case G_TYPE_UINT:
g_string_append_printf (str, "%d", g_value_get_uint (src));
break;
case G_TYPE_INT:
g_string_append_printf (str, "%d", g_value_get_int (src));
break;
case G_TYPE_FLOAT:
g_string_append_printf (str, "%.04f", g_value_get_float (src));
break;
case G_TYPE_BOOLEAN:
g_string_append_printf (str, "%d", g_value_get_boolean (src));
break;
case G_TYPE_BOXED:
if (G_VALUE_TYPE (src) == G_TYPE_VALUE_ARRAY) {
GValueArray *array = (GValueArray *) g_value_get_boxed (src);
if (!array) {
/* FIXME, add this to validate */
g_warning ("Empty array given");
return;
}
guint i;
for (i = 0; i < array->n_values; i++) {
if (i > 0)
g_string_append (str, ", ");
__get_expression_value (cnc, g_value_array_get_nth (array, i), str);
}
} else {
/*FIXME, add this to validate */
g_warning ("BOXED type '%s' not implemented \n", G_VALUE_TYPE_NAME (src));
}
break;
default:
break;
}
return;
}
static void
gst_audio_iir_filter_update_coefficients (GstAudioIIRFilter * self,
GValueArray * va, GValueArray * vb)
{
gdouble *a = NULL, *b = NULL;
guint i;
if (va) {
if (self->a)
g_value_array_free (self->a);
self->a = va;
}
if (vb) {
if (self->b)
g_value_array_free (self->b);
self->b = vb;
}
if (self->a && self->a->n_values > 0) {
a = g_new (gdouble, self->a->n_values);
for (i = 0; i < self->a->n_values; i++) {
GValue *v = g_value_array_get_nth (self->a, i);
a[i] = g_value_get_double (v);
}
}
if (self->b && self->b->n_values > 0) {
b = g_new (gdouble, self->b->n_values);
for (i = 0; i < self->b->n_values; i++) {
GValue *v = g_value_array_get_nth (self->b, i);
b[i] = g_value_get_double (v);
}
}
gst_audio_fx_base_iir_filter_set_coefficients (GST_AUDIO_FX_BASE_IIR_FILTER
(self), a, (self->a) ? self->a->n_values : 0, b,
(self->b) ? self->b->n_values : 0);
}
static void
clutter_list_model_iter_set_value (ClutterModelIter *iter,
guint column,
const GValue *value)
{
ClutterListModelIter *iter_default;
GValueArray *value_array;
GValue *iter_value;
GValue real_value = { 0, };
gboolean converted = FALSE;
iter_default = CLUTTER_LIST_MODEL_ITER (iter);
g_assert (iter_default->seq_iter != NULL);
value_array = g_sequence_get (iter_default->seq_iter);
iter_value = g_value_array_get_nth (value_array, column);
g_assert (iter_value != NULL);
if (!g_type_is_a (G_VALUE_TYPE (value), G_VALUE_TYPE (iter_value)))
{
if (!g_value_type_compatible (G_VALUE_TYPE (value),
G_VALUE_TYPE (iter_value)) &&
!g_value_type_compatible (G_VALUE_TYPE (iter_value),
G_VALUE_TYPE (value)))
{
g_warning ("%s: Unable to convert from %s to %s\n",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (G_VALUE_TYPE (iter_value)));
return;
}
if (!g_value_transform (value, &real_value))
{
g_warning ("%s: Unable to make conversion from %s to %s\n",
G_STRLOC,
g_type_name (G_VALUE_TYPE (value)),
g_type_name (G_VALUE_TYPE (iter_value)));
g_value_unset (&real_value);
}
converted = TRUE;
}
if (converted)
{
g_value_copy (&real_value, iter_value);
g_value_unset (&real_value);
}
else
g_value_copy (value, iter_value);
}
/* Check if the given pattern matches part of the given trie, returning an
* empty string on a partial initial match, a %NULL if there's no match in the
* works, and the result string if we have an exact match. */
TRIE_MAYBE_STATIC const char *
_vte_trie_match(struct _vte_trie *trie, const gunichar *pattern, gsize length,
const char **res, const gunichar **consumed,
GQuark *quark, GValueArray **array)
{
const char *ret = NULL;
GQuark tmpquark;
GValueArray *valuearray;
GValue *value;
const gunichar *dummyconsumed;
gboolean greedy = FALSE;
guint i;
if (array != NULL && *array != NULL) {
valuearray = *array;
} else {
valuearray = g_value_array_new(0);
}
if (quark == NULL) {
quark = &tmpquark;
}
*quark = 0;
if (consumed == NULL) {
consumed = &dummyconsumed;
}
*consumed = pattern;
ret = _vte_trie_matchx(trie, pattern, length, greedy,
res, consumed, quark, valuearray);
if (((ret == NULL) || (ret[0] == '\0')) || (valuearray->n_values == 0)){
if (valuearray != NULL) {
for (i = 0; i < valuearray->n_values; i++) {
value = g_value_array_get_nth(valuearray, i);
if (G_VALUE_HOLDS_POINTER(value)) {
g_free(g_value_get_pointer(value));
g_value_set_pointer(value, NULL);
}
}
if (array == NULL || valuearray != *array) {
_vte_matcher_free_params_array(NULL, valuearray);
}
}
} else {
if (array == NULL) {
_vte_matcher_free_params_array(NULL, valuearray);
}
}
return ret;
}
static void
tp_contact_factory_got_capabilities (TpConnection *connection,
const GPtrArray *capabilities,
const GError *error,
gpointer user_data,
GObject *weak_object)
{
EmpathyTpContactFactory *tp_factory;
guint i;
tp_factory = EMPATHY_TP_CONTACT_FACTORY (weak_object);
if (error) {
DEBUG ("Error: %s", error->message);
/* FIXME Should set the capabilities of the contacts for which this request
* originated to NONE */
return;
}
for (i = 0; i < capabilities->len; i++) {
GValueArray *values;
guint handle;
const gchar *channel_type;
guint generic;
guint specific;
values = g_ptr_array_index (capabilities, i);
handle = g_value_get_uint (g_value_array_get_nth (values, 0));
channel_type = g_value_get_string (g_value_array_get_nth (values, 1));
generic = g_value_get_uint (g_value_array_get_nth (values, 2));
specific = g_value_get_uint (g_value_array_get_nth (values, 3));
tp_contact_factory_update_capabilities (tp_factory,
handle,
channel_type,
generic,
specific);
}
}
