Esempio n. 1
0
static void
length_get_value (gpointer test, GValue * value)
{
  LengthTest *t = test;

  g_value_set_int64 (value, t ? t->value : -1);
}
Esempio n. 2
0
gboolean
stetic_param_spec_get_maximum (GParamSpec *pspec, GValue *value)
{
	g_value_init (value, pspec->value_type);

	if (G_IS_PARAM_SPEC_CHAR (pspec))
		g_value_set_char (value, G_PARAM_SPEC_CHAR (pspec)->maximum);
	else if (G_IS_PARAM_SPEC_UCHAR (pspec))
		g_value_set_uchar (value, G_PARAM_SPEC_UCHAR (pspec)->maximum);
	else if (G_IS_PARAM_SPEC_INT (pspec))
		g_value_set_int (value, G_PARAM_SPEC_INT (pspec)->maximum);
	else if (G_IS_PARAM_SPEC_UINT (pspec))
		g_value_set_uint (value, G_PARAM_SPEC_UINT (pspec)->maximum);
	else if (G_IS_PARAM_SPEC_LONG (pspec))
		g_value_set_long (value, G_PARAM_SPEC_LONG (pspec)->maximum);
	else if (G_IS_PARAM_SPEC_ULONG (pspec))
		g_value_set_ulong (value, G_PARAM_SPEC_ULONG (pspec)->maximum);
	else if (G_IS_PARAM_SPEC_INT64 (pspec))
		g_value_set_int64 (value, G_PARAM_SPEC_INT64 (pspec)->maximum);
	else if (G_IS_PARAM_SPEC_UINT64 (pspec))
		g_value_set_uint64 (value, G_PARAM_SPEC_UINT64 (pspec)->maximum);
	else if (G_IS_PARAM_SPEC_FLOAT (pspec))
		g_value_set_float (value, G_PARAM_SPEC_FLOAT (pspec)->maximum);
	else if (G_IS_PARAM_SPEC_DOUBLE (pspec))
		g_value_set_double (value, G_PARAM_SPEC_DOUBLE (pspec)->maximum);
	else
		return FALSE;
	return TRUE;
}
static void
tpl_call_event_get_property (GObject *object,
    guint param_id,
    GValue *value,
    GParamSpec *pspec)
{
  TplCallEventPriv *priv = TPL_CALL_EVENT (object)->priv;

  switch (param_id)
    {
      case PROP_DURATION:
        g_value_set_int64 (value, priv->duration);
        break;
      case PROP_END_ACTOR:
        g_value_set_object (value, priv->end_actor);
        break;
      case PROP_END_REASON:
        g_value_set_int (value, priv->end_reason);
        break;
      case PROP_DETAILED_END_REASON:
        g_value_set_string (value, priv->detailed_end_reason);
        break;
      default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
        break;
    }
}
Esempio n. 4
0
static void
timedur_get_value (gpointer test, GValue * value)
{
  TimeDurTest *t = test;

  g_value_set_int64 (value, t ? (t->diff / MAX (1, t->count)) : -1);
}
Esempio n. 5
0
static void
rg_table_get_property (GObject    *object,
                       guint       prop_id,
                       GValue     *value,
                       GParamSpec *pspec)
{
  RgTable *self = (RgTable *)object;
  RgTablePrivate *priv = rg_table_get_instance_private (self);

  switch (prop_id)
    {
    case PROP_TIMESPAN:
      g_value_set_int64 (value, priv->timespan);
      break;

    case PROP_MAX_SAMPLES:
      g_value_set_uint (value, priv->max_samples);
      break;

    case PROP_VALUE_MAX:
      g_value_set_double (value, priv->value_max);
      break;

    case PROP_VALUE_MIN:
      g_value_set_double (value, priv->value_min);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}
Esempio n. 6
0
GValue*
ghb_int_value_new(gint ival)
{
    GValue *gval = ghb_value_new(G_TYPE_INT64);
    g_value_set_int64(gval, ival);
    return gval;
}
Esempio n. 7
0
gboolean
stetic_param_spec_get_default (GParamSpec *pspec, GValue *value)
{
	g_value_init (value, pspec->value_type);

	if (G_IS_PARAM_SPEC_CHAR (pspec))
		g_value_set_char (value, G_PARAM_SPEC_CHAR (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_UCHAR (pspec))
		g_value_set_uchar (value, G_PARAM_SPEC_UCHAR (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_INT (pspec))
		g_value_set_int (value, G_PARAM_SPEC_INT (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_UINT (pspec))
		g_value_set_uint (value, G_PARAM_SPEC_UINT (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_LONG (pspec))
		g_value_set_long (value, G_PARAM_SPEC_LONG (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_ULONG (pspec))
		g_value_set_ulong (value, G_PARAM_SPEC_ULONG (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_INT64 (pspec))
		g_value_set_int64 (value, G_PARAM_SPEC_INT64 (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_UINT64 (pspec))
		g_value_set_uint64 (value, G_PARAM_SPEC_UINT64 (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_FLOAT (pspec))
		g_value_set_float (value, G_PARAM_SPEC_FLOAT (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_DOUBLE (pspec))
		g_value_set_double (value, G_PARAM_SPEC_DOUBLE (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_BOOLEAN (pspec))
		g_value_set_boolean (value, G_PARAM_SPEC_BOOLEAN (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_UNICHAR (pspec))
		g_value_set_uint (value, G_PARAM_SPEC_UNICHAR (pspec)->default_value);
	else if (G_IS_PARAM_SPEC_STRING (pspec))
		g_value_set_static_string (value, G_PARAM_SPEC_STRING (pspec)->default_value);
	else
		return FALSE;
	return TRUE;
}
Esempio n. 8
0
static void
_rygel_example_player_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec) {
  RygelMediaPlayer *base = RYGEL_MEDIA_PLAYER (object);

  switch (property_id) {
    case RYGEL_EXAMPLE_PLAYER_PLAYBACK_STATE:
      g_value_take_string (value, rygel_media_player_get_playback_state (base));
      break;
    case RYGEL_EXAMPLE_PLAYER_URI:
      g_value_take_string (value, rygel_media_player_get_uri (base));
      break;
    case RYGEL_EXAMPLE_PLAYER_MIME_TYPE:
      g_value_take_string (value, rygel_media_player_get_mime_type (base));
      break;
    case RYGEL_EXAMPLE_PLAYER_METADATA:
      g_value_take_string (value, rygel_media_player_get_metadata (base));
      break;
    case RYGEL_EXAMPLE_PLAYER_CONTENT_FEATURES:
      g_value_take_string (value, rygel_media_player_get_content_features (base));
      break;
    case RYGEL_EXAMPLE_PLAYER_VOLUME:
      g_value_set_double (value, rygel_media_player_get_volume (base));
      break;
    case RYGEL_EXAMPLE_PLAYER_DURATION:
      g_value_set_int64 (value, rygel_media_player_get_duration (base));
      break;
    case RYGEL_EXAMPLE_PLAYER_POSITION:
      g_value_set_int64 (value, rygel_media_player_get_position (base));
      break;
    case RYGEL_EXAMPLE_PLAYER_CAN_SEEK:
      g_value_set_boolean (value, rygel_media_player_get_can_seek (base));
      break;
    case RYGEL_EXAMPLE_PLAYER_PLAYBACK_SPEED:
      g_value_take_string (value, rygel_media_player_get_playback_speed (base));
      break;
    case RYGEL_EXAMPLE_PLAYER_ALLOWED_PLAYBACK_SPEEDS:
      {
        int length;

        g_value_take_boxed (value, rygel_media_player_get_allowed_playback_speeds (base, &length));
      }
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
  }
}
Esempio n. 9
0
gboolean GN_value_set(int ARI, ei_x_buff *XBUF, char *B, int *I){

  GValue* object;
  int type, len;

  gboolean v_boolean;
  gchar v_atom[MAXATOMLEN+1];
  gchar* v_gchar;
  gint64 v_gint64;
  gdouble v_double;

  /* no return value */

  if ( ! gn_check_arity(XBUF, 2, ARI) ) return FALSE;
  if ( ! gn_get_arg_struct(XBUF, B, I, "GValue", (void**)&object) ) return FALSE;

  if ( G_IS_VALUE(object) ) g_value_unset(object);

  ei_get_type(B,I,&type,&len);  /* can't fail */
  switch (type) {
  case ERL_ATOM_EXT:
    if ( ! ei_decode_boolean(B, I, (int*)&v_boolean) ){
      g_value_init(object,G_TYPE_BOOLEAN);
      g_value_set_boolean(object, v_boolean);
    } else if ( gn_get_arg_gchar_fix(XBUF, B, I, v_atom) ){
      g_value_init(object,G_TYPE_STRING);
      g_value_set_string(object,v_atom);
    } else {
      return FALSE;
    }
    break;
  case ERL_SMALL_INTEGER_EXT:
  case ERL_INTEGER_EXT:
  case ERL_SMALL_BIG_EXT:
  case ERL_LARGE_BIG_EXT:
    if ( ! gn_get_arg_gint64(XBUF, B, I, &v_gint64) ) return FALSE;
    g_value_init(object,G_TYPE_INT64);
    g_value_set_int64(object, v_gint64);
    break;
  case ERL_FLOAT_EXT:
    if ( ! gn_get_arg_gdouble(XBUF, B, I, &v_double) ) return FALSE;
      g_value_init(object,G_TYPE_DOUBLE);
    g_value_set_double(object, v_double);
    break;
  case ERL_NIL_EXT:
  case ERL_STRING_EXT:
    if ( ! gn_get_arg_gchar(XBUF, B, I, &v_gchar) ) return FALSE;
    g_value_init(object,G_TYPE_STRING);
    g_value_set_string(object,v_gchar);
    free(v_gchar);
    break;
  default:
    gn_enc_1_error(XBUF, "bad_erl_type");
    return FALSE;
    break;
  }
  gn_put_void(XBUF);
  return TRUE;
}
Esempio n. 10
0
static void
gimp_thumbnail_get_property (GObject    *object,
                             guint       property_id,
                             GValue     *value,
                             GParamSpec *pspec)
{
  GimpThumbnail *thumbnail = GIMP_THUMBNAIL (object);

  switch (property_id)
    {
    case PROP_IMAGE_STATE:
      g_value_set_enum (value, thumbnail->image_state);
      break;
    case PROP_IMAGE_URI:
      g_value_set_string (value, thumbnail->image_uri);
      break;
    case PROP_IMAGE_MTIME:
      g_value_set_int64 (value, thumbnail->image_mtime);
      break;
    case PROP_IMAGE_FILESIZE:
      g_value_set_int64 (value, thumbnail->image_filesize);
      break;
    case PROP_IMAGE_MIMETYPE:
      g_value_set_string (value, thumbnail->image_mimetype);
      break;
    case PROP_IMAGE_WIDTH:
      g_value_set_int (value, thumbnail->image_width);
      break;
    case PROP_IMAGE_HEIGHT:
      g_value_set_int (value, thumbnail->image_height);
      break;
    case PROP_IMAGE_TYPE:
      g_value_set_string (value, thumbnail->image_type);
      break;
    case PROP_IMAGE_NUM_LAYERS:
      g_value_set_int (value, thumbnail->image_num_layers);
      break;
    case PROP_THUMB_STATE:
      g_value_set_enum (value, thumbnail->thumb_state);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
      break;
    }
}
Esempio n. 11
0
/**
 * tp_g_value_slice_new_int64:
 * @n: a 64-bit integer
 *
 * Slice-allocate and initialize a #GValue. This function is convenient to
 * use when constructing hash tables from string to #GValue, for example.
 *
 * Returns: a #GValue of type %G_TYPE_INT64 with value @n, to be freed with
 * tp_g_value_slice_free() or g_slice_free()
 *
 * Since: 0.7.27
 */
GValue *
tp_g_value_slice_new_int64 (gint64 n)
{
  GValue *v = tp_g_value_slice_new (G_TYPE_INT64);

  g_value_set_int64 (v, n);
  return v;
}
Esempio n. 12
0
static void
gnl_object_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GnlObject *gnlobject = (GnlObject *) object;

  switch (prop_id) {
    case PROP_START:
      g_value_set_uint64 (value, gnlobject->start);
      break;
    case PROP_DURATION:
      g_value_set_int64 (value, gnlobject->duration);
      break;
    case PROP_STOP:
      g_value_set_uint64 (value, gnlobject->stop);
      break;
    case PROP_MEDIA_START:
      g_value_set_uint64 (value, gnlobject->media_start);
      break;
    case PROP_MEDIA_DURATION:
      g_value_set_int64 (value, gnlobject->media_duration);
      break;
    case PROP_MEDIA_STOP:
      g_value_set_uint64 (value, gnlobject->media_stop);
      break;
    case PROP_RATE:
      g_value_set_double (value, gnlobject->rate);
      break;
    case PROP_PRIORITY:
      g_value_set_uint (value, gnlobject->priority);
      break;
    case PROP_ACTIVE:
      g_value_set_boolean (value, gnlobject->active);
      break;
    case PROP_CAPS:
      gst_value_set_caps (value, gnlobject->caps);
      break;
    case PROP_EXPANDABLE:
      g_value_set_boolean (value, GNL_OBJECT_IS_EXPANDABLE (object));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}
Esempio n. 13
0
/*
 * cd_profile_get_property:
 */
static void
cd_profile_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
	CdProfile *profile = CD_PROFILE (object);
	CdProfilePrivate *priv = GET_PRIVATE (profile);

	switch (prop_id) {
	case PROP_OBJECT_PATH:
		g_value_set_string (value, priv->object_path);
		break;
	case PROP_CONNECTED:
		g_value_set_boolean (value, priv->proxy != NULL);
		break;
	case PROP_ID:
		g_value_set_string (value, priv->id);
		break;
	case PROP_FILENAME:
		g_value_set_string (value, priv->filename);
		break;
	case PROP_QUALIFIER:
		g_value_set_string (value, priv->qualifier);
		break;
	case PROP_FORMAT:
		g_value_set_string (value, priv->format);
		break;
	case PROP_TITLE:
		g_value_set_string (value, priv->title);
		break;
	case PROP_KIND:
		g_value_set_uint (value, priv->kind);
		break;
	case PROP_COLORSPACE:
		g_value_set_uint (value, priv->colorspace);
		break;
	case PROP_CREATED:
		g_value_set_int64 (value, priv->created);
		break;
	case PROP_HAS_VCGT:
		g_value_set_boolean (value, priv->has_vcgt);
		break;
	case PROP_IS_SYSTEM_WIDE:
		g_value_set_boolean (value, priv->is_system_wide);
		break;
	case PROP_SCOPE:
		g_value_set_uint (value, priv->scope);
		break;
	case PROP_OWNER:
		g_value_set_uint (value, priv->owner);
		break;
	case PROP_WARNINGS:
		g_value_set_boxed (value, priv->warnings);
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
    }
}
Esempio n. 14
0
gboolean
fb_data_load(FbData *fata)
{
	const gchar *str;
	FbDataPrivate *priv;
	FbId id;
	gboolean ret = TRUE;
	guint i;
	guint64 uint;
	GValue val = G_VALUE_INIT;
	PurpleAccount *acct;

	g_return_val_if_fail(FB_IS_DATA(fata), FALSE);
	priv = fata->priv;
	acct = purple_connection_get_account(priv->gc);

	for (i = 0; i < G_N_ELEMENTS(fb_props_strs); i++) {
		str = purple_account_get_string(acct, fb_props_strs[i], NULL);

		if (str == NULL) {
			ret = FALSE;
		}

		g_value_init(&val, G_TYPE_STRING);
		g_value_set_string(&val, str);
		g_object_set_property(G_OBJECT(priv->api), fb_props_strs[i],
		                      &val);
		g_value_unset(&val);
	}

	str = purple_account_get_string(acct, "mid", NULL);

	if (str != NULL) {
		uint = g_ascii_strtoull(str, NULL, 10);
		g_value_init(&val, G_TYPE_UINT64);
		g_value_set_uint64(&val, uint);
		g_object_set_property(G_OBJECT(priv->api), "mid", &val);
		g_value_unset(&val);
	} else {
		ret = FALSE;
	}

	str = purple_account_get_string(acct, "uid", NULL);

	if (str != NULL) {
		id = FB_ID_FROM_STR(str);
		g_value_init(&val, FB_TYPE_ID);
		g_value_set_int64(&val, id);
		g_object_set_property(G_OBJECT(priv->api), "uid", &val);
		g_value_unset(&val);
	} else {
		ret = FALSE;
	}

	fb_api_rehash(priv->api);
	return ret;
}
Esempio n. 15
0
GValue*
ghb_int_value(gint ival)
{
	static GValue gval = {0,};
	if (!G_IS_VALUE(&gval))
		g_value_init(&gval, G_TYPE_INT64);
	g_value_set_int64(&gval, (gint64)ival);
	return &gval;
}
static void
_get_property (GObject      *object,
               unsigned int  property_id,
               GValue       *value,
               GParamSpec   *pspec)
{
  MpdStorageDevicePrivate *priv = GET_PRIVATE (object);

  switch (property_id) {
  case PROP_AVAILABLE_SIZE:
    g_value_set_int64 (value,
                       mpd_storage_device_get_available_size (
                        MPD_STORAGE_DEVICE (object)));
    break;
  case PROP_PATH:
    g_value_set_string (value, priv->path);
    break;
  case PROP_SIZE:
    g_value_set_int64 (value,
                       mpd_storage_device_get_size (
                        MPD_STORAGE_DEVICE (object)));
    break;
#if 0
  case PROP_LABEL:
    g_value_set_string (value,
                        mpd_storage_device_get_label (
                          MPD_STORAGE_DEVICE (object)));
    break;
  case PROP_MODEL:
    g_value_set_string (value,
                        mpd_storage_device_get_model (
                          MPD_STORAGE_DEVICE (object)));
    break;
  case PROP_VENDOR:
    g_value_set_string (value,
                        mpd_storage_device_get_vendor (
                          MPD_STORAGE_DEVICE (object)));
    break;
#endif
  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
  }
}
Esempio n. 17
0
static void
xform_string_int64(const GValue *sval, GValue *ival)
{
	gchar *end;
	const gchar *str = g_value_get_string(sval);
	gint64 val = g_strtod(str, &end);
	if (*end)
		val = (guint64)(~0L)>>1;
	g_value_set_int64(ival, val);
}
Esempio n. 18
0
/**
 * grl_related_keys_set_int64:
 * @relkeys: set of related keys to change
 * @key: (type GrlKeyID): key to change or add
 * @intvalue: the new value
 *
 * Sets the value associated with @key into @relkeys. @key must have been
 * registered as a int64-type key. Old value is replaced by the new one.
 *
 * Since: 0.2.12
 **/
void
grl_related_keys_set_int64 (GrlRelatedKeys *relkeys,
                            GrlKeyID key,
                            gint64 intvalue)
{
  GValue value = { 0 };
  g_return_if_fail (GRL_IS_RELATED_KEYS (relkeys));
  g_value_init (&value, G_TYPE_INT64);
  g_value_set_int64 (&value, intvalue);
  grl_related_keys_set (relkeys, key, &value);
}
Esempio n. 19
0
static void
gst_cmml_enc_get_property (GObject * object, guint property_id,
    GValue * value, GParamSpec * pspec)
{
  GstCmmlEnc *enc = GST_CMML_ENC (object);

  switch (property_id) {
    case GST_CMML_ENC_GRANULERATE_N:
      g_value_set_int64 (value, enc->granulerate_n);
      break;
    case GST_CMML_ENC_GRANULERATE_D:
      g_value_set_int64 (value, enc->granulerate_d);
      break;
    case GST_CMML_ENC_GRANULESHIFT:
      g_value_set_uchar (value, enc->granuleshift);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
  }
}
static void
gst_audio_ringbuffer_get_property (GObject * object,
    guint prop_id, GValue * value, GParamSpec * pspec)
{
  GstAudioRingbuffer *ringbuffer;

  ringbuffer = GST_AUDIO_RINGBUFFER (object);

  switch (prop_id) {
    case PROP_BUFFER_TIME:
      g_value_set_int64 (value, ringbuffer->buffer_time);
      break;
    case PROP_SEGMENT_TIME:
      g_value_set_int64 (value, ringbuffer->segment_time);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}
Esempio n. 21
0
static void
gst_srt_enc_get_property (GObject * object,
    guint prop_id, GValue * value, GParamSpec * pspec)
{
  GstSrtEnc *srtenc;

  srtenc = GST_SRT_ENC (object);

  switch (prop_id) {
    case ARG_TIMESTAMP:
      g_value_set_int64 (value, srtenc->timestamp);
      break;
    case ARG_DURATION:
      g_value_set_int64 (value, srtenc->duration);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}
Esempio n. 22
0
static void
g_value_from_ffi_value (GValue           *gvalue,
                        const GIArgument *value)
{
  switch (g_type_fundamental (G_VALUE_TYPE (gvalue))) {
  case G_TYPE_INT:
      g_value_set_int (gvalue, (gint)value->v_long);
      break;
  case G_TYPE_FLOAT:
      g_value_set_float (gvalue, (gfloat)value->v_float);
      break;
  case G_TYPE_DOUBLE:
      g_value_set_double (gvalue, (gdouble)value->v_double);
      break;
  case G_TYPE_BOOLEAN:
      g_value_set_boolean (gvalue, (gboolean)value->v_long);
      break;
  case G_TYPE_STRING:
      g_value_set_string (gvalue, (gchar*)value->v_pointer);
      break;
  case G_TYPE_CHAR:
      g_value_set_char (gvalue, (gchar)value->v_long);
      break;
  case G_TYPE_UCHAR:
      g_value_set_uchar (gvalue, (guchar)value->v_ulong);
      break;
  case G_TYPE_UINT:
      g_value_set_uint (gvalue, (guint)value->v_ulong);
      break;
  case G_TYPE_POINTER:
      g_value_set_pointer (gvalue, (gpointer)value->v_pointer);
      break;
  case G_TYPE_LONG:
      g_value_set_long (gvalue, (glong)value->v_long);
      break;
  case G_TYPE_ULONG:
      g_value_set_ulong (gvalue, (gulong)value->v_ulong);
      break;
  case G_TYPE_INT64:
      g_value_set_int64 (gvalue, (gint64)value->v_int64);
      break;
  case G_TYPE_UINT64:
      g_value_set_uint64 (gvalue, (guint64)value->v_uint64);
      break;
  case G_TYPE_BOXED:
      g_value_set_boxed (gvalue, (gpointer)value->v_pointer);
      break;
  default:
    g_warning ("Unsupported fundamental type: %s",
	       g_type_name (g_type_fundamental (G_VALUE_TYPE (gvalue))));
  }

}
Esempio n. 23
0
static void rygel_http_seek_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
	RygelHTTPSeek * self;
	self = RYGEL_HTTP_SEEK (object);
	switch (property_id) {
		case RYGEL_HTTP_SEEK_MSG:
		g_value_set_object (value, rygel_http_seek_get_msg (self));
		break;
		case RYGEL_HTTP_SEEK_START:
		g_value_set_int64 (value, rygel_http_seek_get_start (self));
		break;
		case RYGEL_HTTP_SEEK_STOP:
		g_value_set_int64 (value, rygel_http_seek_get_stop (self));
		break;
		case RYGEL_HTTP_SEEK_LENGTH:
		g_value_set_int64 (value, rygel_http_seek_get_length (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}
Esempio n. 24
0
/*!
 * \brief Convert a QVariant to GValue
 * \param other QVariant to convert
 * \return a GValue holding the QVariant's content or an invalid GValue if it
 *         could not be converted.
 */
GValue *qVariantToGValue(const QVariant &other)
{
    GValue *gvalue = g_new0(GValue, 1);
    switch (other.type()) {
    case QVariant::Bool:
        g_value_init(gvalue, G_TYPE_BOOLEAN);
        g_value_set_boolean(gvalue, other.toBool() ? TRUE : FALSE);
        break;
    case QVariant::UInt:
        g_value_init(gvalue, G_TYPE_UINT);
        g_value_set_uint(gvalue, other.toUInt());
        break;
    case QVariant::Int:
        g_value_init(gvalue, G_TYPE_INT);
        g_value_set_int(gvalue, other.toInt());
        break;
    case QVariant::LongLong:
        g_value_init(gvalue, G_TYPE_INT64);
        g_value_set_int64(gvalue, other.toLongLong());
        break;
    case QVariant::ULongLong:
        g_value_init(gvalue, G_TYPE_UINT64);
        g_value_set_int64(gvalue, other.toULongLong());
        break;
    case QVariant::Double:
        g_value_init(gvalue, G_TYPE_DOUBLE);
        g_value_set_double(gvalue, other.toDouble());
        break;
    case QVariant::String:
        g_value_init(gvalue, G_TYPE_STRING);
        g_value_set_string(gvalue, other.toString().toUtf8().constData());
        break;
    default:
        // do nothing - probably assert or whatever
        break;
    }

    return gvalue;
}
Esempio n. 25
0
void
ags_port_real_safe_read(AgsPort *port, GValue *value)
{
  guint overall_size;
  gpointer data;

  overall_size = port->port_value_length * port->port_value_size;

  pthread_mutex_lock(&(port->mutex));

  if(!port->port_value_is_pointer){
    if(port->port_value_type == G_TYPE_BOOLEAN){
      g_value_set_boolean(value, port->port_value.ags_port_boolean);
    }else if(port->port_value_type == G_TYPE_INT64){
      g_value_set_int64(value, port->port_value.ags_port_int);
    }else if(port->port_value_type == G_TYPE_UINT64){
      g_value_set_uint64(value, port->port_value.ags_port_uint);
    }else if(port->port_value_type == G_TYPE_FLOAT){
      g_value_set_float(value, (gdouble) port->port_value.ags_port_float);
    }else if(port->port_value_type == G_TYPE_DOUBLE){
      g_value_set_double(value, port->port_value.ags_port_double);
    }
  }else{
    data = (gpointer) malloc(overall_size);

    if(port->port_value_type == G_TYPE_BOOLEAN){
      memcpy(data, port->port_value.ags_port_boolean_ptr, overall_size);
    }else if(port->port_value_type == G_TYPE_INT64){
      memcpy(data, port->port_value.ags_port_int_ptr, overall_size);
    }else if(port->port_value_type == G_TYPE_UINT64){
      memcpy(data, port->port_value.ags_port_uint_ptr, overall_size);
    }else if(port->port_value_type == G_TYPE_FLOAT){
      guint i;

      for(i = 0; i < port->port_value_length; i++){
	port->port_value.ags_port_float_ptr[i] = ((gdouble *) data)[i];
      }
    }else if(port->port_value_type == G_TYPE_DOUBLE){
      memcpy(data, port->port_value.ags_port_double_ptr, overall_size);
    }else if(port->port_value_type == G_TYPE_POINTER){
      data = port->port_value.ags_port_pointer;
    }else if(port->port_value_type == G_TYPE_OBJECT){
      data = port->port_value.ags_port_object;
    }

    g_value_set_pointer(value, data);
  }

  pthread_mutex_unlock(&(port->mutex));
}
Esempio n. 26
0
gboolean
gom_resource_do_save (GomResource  *resource,
                      GomAdapter   *adapter,
                      GError      **error)
{
   gboolean ret = FALSE;
   gboolean is_insert;
   gint64 row_id = -1;
   GType resource_type;
   GList *cmds, *l;

   g_return_val_if_fail(GOM_IS_RESOURCE(resource), FALSE);
   g_return_val_if_fail(GOM_IS_ADAPTER(adapter), FALSE);

   resource_type = G_TYPE_FROM_INSTANCE(resource);
   g_assert(g_type_is_a(resource_type, GOM_TYPE_RESOURCE));

   is_insert = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(resource), "is-insert"));
   cmds = g_object_get_data(G_OBJECT(resource), "save-commands");

   for (l = cmds; l != NULL; l = l->next) {
      GomCommand *command = l->data;

      if (!gom_command_execute(command, NULL, error))
         goto out;

      if (is_insert && row_id == -1 && gom_resource_has_dynamic_pkey(resource_type)) {
         sqlite3 *handle = gom_adapter_get_handle(adapter);
         GValue *value;

         row_id = sqlite3_last_insert_rowid(handle);
         value = g_new0 (GValue, 1);
         g_value_init(value, G_TYPE_INT64);
         g_value_set_int64(value, row_id);
         g_object_set_data_full(G_OBJECT(resource), "row-id", value, value_free);

         g_object_set_data (G_OBJECT(resource), "is-from-table", GINT_TO_POINTER(TRUE));

         is_insert = FALSE;
      }
   }

   ret = TRUE;

out:
   g_object_set_data (G_OBJECT (resource), "save-commands", NULL);
   g_object_set_data (G_OBJECT (resource), "is-insert", NULL);

   return ret;
}
Esempio n. 27
0
static void
bookmark_resolve (GrlSourceResolveSpec *rs)
{
  GomRepository *repository;
  GValue value = { 0, };
  GomFilter *filter;
  GomResource *resource;
  GError *error = NULL;
  gint64 id;
  GrlTypeFilter type_filter;

  GRL_DEBUG (__FUNCTION__);

  repository = GRL_BOOKMARKS_SOURCE (rs->source)->priv->repository;

  id = g_ascii_strtoll (grl_media_get_id (rs->media), NULL, 0);
  if (!id) {
    /* Root category: special case */
    grl_media_set_title (rs->media, GRL_ROOT_TITLE);
    rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, NULL);
    return;
  }

  g_value_init (&value, G_TYPE_INT64);
  g_value_set_int64 (&value, id);
  filter = gom_filter_new_eq (BOOKMARKS_TYPE_RESOURCE, "id", &value);
  g_value_unset (&value);
  resource = gom_repository_find_one_sync (repository,
                                           BOOKMARKS_TYPE_RESOURCE,
                                           filter,
                                           &error);
  g_object_unref (filter);

  if (!resource) {
    GRL_WARNING ("Failed to get bookmark: %s", error->message);
    g_error_free (error);

    error = g_error_new_literal (GRL_CORE_ERROR,
                                 GRL_CORE_ERROR_RESOLVE_FAILED,
                                 _("Failed to get bookmark metadata"));
    rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, error);
    g_error_free (error);
    return;
  }

  type_filter = grl_operation_options_get_type_filter (rs->options);
  build_media_from_resource (rs->media, resource, type_filter);
  g_object_unref (resource);
  rs->callback (rs->source, rs->operation_id, rs->media, rs->user_data, NULL);
}
Esempio n. 28
0
static void
get_property (GObject *object,
              guint prop_id,
              GValue *value,
              GParamSpec *pspec)
{
	NMDeviceTun *device = NM_DEVICE_TUN (object);

	switch (prop_id) {
	case PROP_HW_ADDRESS:
		g_value_set_string (value, nm_device_tun_get_hw_address (device));
		break;
	case PROP_MODE:
		g_value_set_string (value, nm_device_tun_get_mode (device));
		break;
	case PROP_OWNER:
		g_value_set_int64 (value, nm_device_tun_get_owner (device));
		break;
	case PROP_GROUP:
		g_value_set_int64 (value, nm_device_tun_get_group (device));
		break;
	case PROP_NO_PI:
		g_value_set_boolean (value, nm_device_tun_get_no_pi (device));
		break;
	case PROP_VNET_HDR:
		g_value_set_boolean (value, nm_device_tun_get_vnet_hdr (device));
		break;
	case PROP_MULTI_QUEUE:
		g_value_set_boolean (value, nm_device_tun_get_multi_queue (device));
		break;

	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
	}
}
static void
gst_trigger_control_source_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GstTriggerControlSource *self = GST_TRIGGER_CONTROL_SOURCE (object);

  switch (prop_id) {
    case PROP_TOLERANCE:
      g_value_set_int64 (value, self->priv->tolerance);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}
Esempio n. 30
0
static void
gst_aggregator_get_property (GObject * object, guint prop_id,
    GValue * value, GParamSpec * pspec)
{
  GstAggregator *agg = GST_AGGREGATOR (object);

  switch (prop_id) {
    case PROP_TIMEOUT:
      g_value_set_int64 (value, gst_aggregator_get_timeout (agg));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}