static void
gst_divxenc_get_property (GObject * object,
guint prop_id, GValue * value, GParamSpec * pspec)
{
GstDivxEnc *divxenc = GST_DIVXENC (object);
GST_OBJECT_LOCK (divxenc);
switch (prop_id) {
case ARG_BITRATE:
g_value_set_ulong (value, divxenc->bitrate);
break;
case ARG_BUFSIZE:
g_value_set_ulong (value, divxenc->buffer_size);
break;
case ARG_MAXKEYINTERVAL:
g_value_set_int (value, divxenc->max_key_interval);
break;
case ARG_QUALITY:
g_value_set_int (value, divxenc->quality);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
GST_OBJECT_UNLOCK (divxenc);
}
/* The set function is simply the inverse of the get fuction. */
static void
gst_ffmpegenc_get_property (GObject * object,
guint prop_id, GValue * value, GParamSpec * pspec)
{
GstFFMpegEnc *ffmpegenc;
/* It's not null if we got it, but it might not be ours */
ffmpegenc = (GstFFMpegEnc *) (object);
switch (prop_id) {
case ARG_BIT_RATE:
g_value_set_ulong (value, ffmpegenc->bitrate);
break;
case ARG_GOP_SIZE:
g_value_set_int (value, ffmpegenc->gop_size);
break;
case ARG_ME_METHOD:
g_value_set_enum (value, ffmpegenc->me_method);
break;
case ARG_BUFSIZE:
g_value_set_ulong (value, ffmpegenc->buffer_size);
break;
case ARG_RTP_PAYLOAD_SIZE:
g_value_set_ulong (value, ffmpegenc->rtp_payload_size);
break;
default:
if (!gst_ffmpeg_cfg_get_property (object, value, pspec))
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* rb_source_update_play_statistics:
* @source: a #RBSource
* @db: the #RhythmDB instance
* @entry: the #RhythmDBEntry to update
*
* Updates play count and play time statistics for a database entry.
* Sources containing entries that do not normally reach EOS should
* call this for an entry when it is no longer being played.
*/
void
rb_source_update_play_statistics (RBSource *source,
RhythmDB *db,
RhythmDBEntry *entry)
{
time_t now;
gulong current_count;
GValue value = { 0, };
g_value_init (&value, G_TYPE_ULONG);
current_count = rhythmdb_entry_get_ulong (entry, RHYTHMDB_PROP_PLAY_COUNT);
g_value_set_ulong (&value, current_count + 1);
/* Increment current play count */
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_PLAY_COUNT, &value);
g_value_unset (&value);
/* Reset the last played time */
time (&now);
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, now);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_LAST_PLAYED, &value);
g_value_unset (&value);
rhythmdb_commit (db);
}
static void
purple_circular_buffer_get_property(GObject *obj, guint param_id,
GValue *value, GParamSpec *pspec)
{
PurpleCircularBuffer *buffer = PURPLE_CIRCULAR_BUFFER(obj);
switch(param_id) {
case PROP_GROW_SIZE:
g_value_set_ulong(value,
purple_circular_buffer_get_grow_size(buffer));
break;
case PROP_BUFFER_USED:
g_value_set_ulong(value,
purple_circular_buffer_get_used(buffer));
break;
case PROP_INPUT:
g_value_set_pointer(value,
(void*) purple_circular_buffer_get_input(buffer));
break;
case PROP_OUTPUT:
g_value_set_pointer(value,
(void*) purple_circular_buffer_get_output(buffer));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
break;
}
}
static void
bt_song_info_get_property (GObject * const object, const guint property_id,
GValue * const value, GParamSpec * const pspec)
{
const BtSongInfo *const self = BT_SONG_INFO (object);
return_if_disposed ();
switch (property_id) {
case SONG_INFO_SONG:
g_value_set_object (value, self->priv->song);
break;
case SONG_INFO_TAGLIST:
g_value_set_pointer (value, gst_tag_list_copy (self->priv->taglist));
break;
case SONG_INFO_FILE_NAME:
g_value_set_string (value, self->priv->file_name);
break;
case SONG_INFO_INFO:
g_value_set_string (value, self->priv->info);
break;
case SONG_INFO_NAME:
g_value_set_string (value, self->priv->name);
break;
case SONG_INFO_GENRE:
g_value_set_string (value, self->priv->genre);
break;
case SONG_INFO_AUTHOR:
g_value_set_string (value, self->priv->author);
break;
case SONG_INFO_BPM:
g_value_set_ulong (value, self->priv->beats_per_minute);
break;
case SONG_INFO_TPB:
g_value_set_ulong (value, self->priv->ticks_per_beat);
break;
case SONG_INFO_BARS:
g_value_set_ulong (value, self->priv->bars);
break;
case SONG_INFO_CREATE_DTS:
g_value_set_string (value, self->priv->create_dts);
break;
case SONG_INFO_CHANGE_DTS:
g_value_set_string (value, self->priv->change_dts);
break;
case SONG_INFO_TICK_DURATION:
g_value_set_uint64 (value, self->priv->tick_duration);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
gbp_player_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GbpPlayer *player = GBP_PLAYER (object);
switch (prop_id)
{
case PROP_URI:
g_value_set_string (value, player->priv->uri);
break;
case PROP_XID:
g_value_set_ulong (value, player->priv->xid);
break;
case PROP_WIDTH:
g_value_set_uint (value, player->priv->width);
break;
case PROP_HEIGHT:
g_value_set_uint (value, player->priv->height);
break;
case PROP_VOLUME:
g_value_set_double (value, player->priv->volume);
break;
case PROP_HAVE_AUDIO:
g_value_set_boolean (value, player->priv->have_audio);
break;
case PROP_VIDEO_SINK:
g_value_set_string (value, player->priv->video_sink);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
gst_date_gulong_transform (const GValue *src, GValue *dest)
{
const GDate *date = gst_value_get_date (src);
g_value_set_ulong (dest, (date) ? g_date_get_julian (date) : 0);
}
void scp_tree_data_to_value(const ScpTreeData *data, GType type, GValue *value)
{
g_value_init(value, type);
switch (scp_tree_data_get_fundamental_type(type))
{
case G_TYPE_INT : g_value_set_int(value, data->v_int); break;
case G_TYPE_UINT : g_value_set_uint(value, data->v_uint); break;
case G_TYPE_STRING : g_value_set_string(value, data->v_string); break;
case G_TYPE_BOOLEAN : g_value_set_boolean(value, data->v_int); break;
case G_TYPE_LONG : g_value_set_long(value, data->v_long); break;
case G_TYPE_ULONG : g_value_set_ulong(value, data->v_ulong); break;
case G_TYPE_FLOAT : g_value_set_float(value, data->v_float); break;
case G_TYPE_DOUBLE : g_value_set_double(value, data->v_double); break;
#if GLIB_CHECK_VERSION(2, 32, 0)
case G_TYPE_CHAR : g_value_set_schar(value, data->v_char); break;
#else
case G_TYPE_CHAR : g_value_set_char(value, data->v_char); break;
#endif
case G_TYPE_UCHAR : g_value_set_uchar(value, data->v_uchar); break;
case G_TYPE_INT64 : g_value_set_int64(value, data->v_int64); break;
case G_TYPE_UINT64 : g_value_set_uint64 (value, data->v_uint64); break;
case G_TYPE_ENUM : g_value_set_enum(value, data->v_int); break;
case G_TYPE_FLAGS : g_value_set_flags(value, data->v_uint); break;
case G_TYPE_POINTER : g_value_set_pointer(value, data->v_pointer); break;
case G_TYPE_OBJECT : g_value_set_object(value, (GObject *) data->v_pointer); break;
case G_TYPE_BOXED : g_value_set_boxed(value, data->v_pointer); break;
#if GLIB_CHECK_VERSION(2, 26, 0)
case G_TYPE_VARIANT : g_value_set_variant(value, data->v_pointer); break;
#endif
default : scp_tree_data_warn_unsupported_type(G_STRFUNC, type);
}
}
static void
gst_shmdata_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstShmdataSink *self = GST_SHMDATA_SINK (object);
GST_OBJECT_LOCK (object);
switch (prop_id) {
case PROP_SOCKET_PATH:
g_value_set_string (value, self->socket_path);
break;
case PROP_CAPS:
g_value_set_string (value, self->caps);
break;
case PROP_BYTES_SINCE_LAST_REQUEST:
g_value_set_uint64 (value, self->bytes_since_last_request);
self->bytes_since_last_request = 0;
break;
/* case PROP_PERMS: */
/* g_value_set_uint (value, self->perms); */
/* break; */
case PROP_INITIAL_SHM_SIZE:
g_value_set_ulong (value, self->size);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
GST_OBJECT_UNLOCK (object);
}
static void
meta_plugin_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MetaPluginPrivate *priv = META_PLUGIN (object)->priv;
switch (prop_id)
{
case PROP_SCREEN:
g_value_set_object (value, priv->screen);
break;
case PROP_DISABLED:
g_value_set_boolean (value, priv->disabled);
break;
case PROP_DEBUG_MODE:
g_value_set_boolean (value, priv->debug);
break;
case PROP_FEATURES:
g_value_set_ulong (value, priv->features);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gkm_object_get_property (GObject *obj, guint prop_id, GValue *value,
GParamSpec *pspec)
{
GkmObject *self = GKM_OBJECT (obj);
switch (prop_id) {
case PROP_HANDLE:
g_value_set_ulong (value, gkm_object_get_handle (self));
break;
case PROP_MODULE:
g_return_if_fail (GKM_IS_MODULE (self->pv->module));
g_value_set_object (value, gkm_object_get_module (self));
break;
case PROP_MANAGER:
g_value_set_object (value, gkm_object_get_manager (self));
break;
case PROP_STORE:
g_value_set_object (value, self->pv->store);
break;
case PROP_UNIQUE:
g_value_set_string (value, gkm_object_get_unique (self));
break;
case PROP_TRANSIENT:
g_value_set_boolean (value, gkm_object_is_transient (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
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;
}
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
clutter_alpha_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterAlphaPrivate *priv = CLUTTER_ALPHA (object)->priv;
switch (prop_id)
{
case PROP_TIMELINE:
g_value_set_object (value, priv->timeline);
break;
case PROP_ALPHA:
g_value_set_double (value, priv->alpha);
break;
case PROP_MODE:
g_value_set_ulong (value, priv->mode);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_file_src_get_property (GObject * object, guint prop_id, GValue * value,
GParamSpec * pspec)
{
GstFileSrc *src;
g_return_if_fail (GST_IS_FILE_SRC (object));
src = GST_FILE_SRC (object);
switch (prop_id) {
case ARG_LOCATION:
g_value_set_string (value, src->filename);
break;
case ARG_FD:
g_value_set_int (value, src->fd);
break;
case ARG_MMAPSIZE:
g_value_set_ulong (value, src->mapsize);
break;
case ARG_TOUCH:
g_value_set_boolean (value, src->touch);
break;
case ARG_SEQUENTIAL:
g_value_set_boolean (value, src->sequential);
break;
case ARG_USEMMAP:
g_value_set_boolean (value, src->use_mmap);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
msd_smartcard_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
MsdSmartcard *card = MSD_SMARTCARD (object);
switch (prop_id) {
case PROP_NAME:
g_value_take_string (value,
msd_smartcard_get_name (card));
break;
case PROP_SLOT_ID:
g_value_set_ulong (value,
(gulong) msd_smartcard_get_slot_id (card));
break;
case PROP_SLOT_SERIES:
g_value_set_int (value,
msd_smartcard_get_slot_series (card));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
void
ags_recall_ladspa_get_property(GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *param_spec)
{
AgsRecallLadspa *recall_ladspa;
recall_ladspa = AGS_RECALL_LADSPA(gobject);
switch(prop_id){
case PROP_FILENAME:
{
g_value_set_string(value, recall_ladspa->filename);
}
break;
case PROP_EFFECT:
{
g_value_set_string(value, recall_ladspa->effect);
}
break;
case PROP_INDEX:
{
g_value_set_ulong(value, recall_ladspa->effect_index);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec);
break;
}
}
static void
gst_goo_videoenc_get_property (GObject* object, guint prop_id,
GValue* value, GParamSpec* pspec)
{
GstGooVideoEnc* self = GST_GOO_VIDEOENC (object);
GooComponent* component = GST_GOO_VIDEO_FILTER (self)->component;
switch (prop_id)
{
case PROP_CONTROLRATE:
{
gint controlrate;
g_object_get (G_OBJECT (component), "control-rate", &controlrate, NULL);
g_value_set_enum (value, controlrate);
break;
}
case PROP_BITRATE:
{
GooPort* port = GST_GOO_VIDEO_FILTER (self)->outport;
g_value_set_ulong (value, GOO_PORT_GET_DEFINITION (port)->format.video.nBitrate);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
return;
}
/**
* ufo_gpu_node_get_info:
* @node: A #UfoGpuNodeInfo
* @info: Information to be queried
*
* Return information about the associated OpenCL device.
*
* Returns: (transfer full): Information about @info.
*/
GValue *
ufo_gpu_node_get_info (UfoGpuNode *node,
UfoGpuNodeInfo info)
{
UfoGpuNodePrivate *priv;
GValue *value;
cl_ulong ulong_value;
priv = UFO_GPU_NODE_GET_PRIVATE (node);
value = g_new0 (GValue, 1);
memset (value, 0, sizeof (GValue));
g_value_init (value, G_TYPE_ULONG);
switch (info) {
case UFO_GPU_NODE_INFO_GLOBAL_MEM_SIZE:
UFO_RESOURCES_CHECK_CLERR (clGetDeviceInfo (priv->device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof (cl_ulong), &ulong_value, NULL));
break;
case UFO_GPU_NODE_INFO_LOCAL_MEM_SIZE:
UFO_RESOURCES_CHECK_CLERR (clGetDeviceInfo (priv->device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof (cl_ulong), &ulong_value, NULL));
break;
}
g_value_set_ulong (value, ulong_value);
return value;
}
void
ags_lv2_urid_manager_test_unmap()
{
AgsLv2UridManager *urid_manager;
uint32_t id;
GValue value = {0,};
urid_manager = ags_lv2_urid_manager_get_instance();
id = ags_lv2_urid_manager_map(NULL,
AGS_LV2_URID_MANAGER_TEST_UNMAP_URI);
g_value_init(&value,
G_TYPE_ULONG);
g_value_set_ulong(&value,
id);
ags_lv2_urid_manager_unmap(NULL,
id);
CU_ASSERT(g_hash_table_lookup(urid_manager->urid,
AGS_LV2_URID_MANAGER_TEST_UNMAP_URI) == NULL);
g_object_unref(urid_manager);
}
static inline gboolean
gtk_arg_static_to_value (GtkArg *arg,
GValue *value)
{
switch (G_TYPE_FUNDAMENTAL (arg->type))
{
case G_TYPE_CHAR: g_value_set_char (value, GTK_VALUE_CHAR (*arg)); break;
case G_TYPE_UCHAR: g_value_set_uchar (value, GTK_VALUE_UCHAR (*arg)); break;
case G_TYPE_BOOLEAN: g_value_set_boolean (value, GTK_VALUE_BOOL (*arg)); break;
case G_TYPE_INT: g_value_set_int (value, GTK_VALUE_INT (*arg)); break;
case G_TYPE_UINT: g_value_set_uint (value, GTK_VALUE_UINT (*arg)); break;
case G_TYPE_LONG: g_value_set_long (value, GTK_VALUE_LONG (*arg)); break;
case G_TYPE_ULONG: g_value_set_ulong (value, GTK_VALUE_ULONG (*arg)); break;
case G_TYPE_ENUM: g_value_set_enum (value, GTK_VALUE_ENUM (*arg)); break;
case G_TYPE_FLAGS: g_value_set_flags (value, GTK_VALUE_FLAGS (*arg)); break;
case G_TYPE_FLOAT: g_value_set_float (value, GTK_VALUE_FLOAT (*arg)); break;
case G_TYPE_DOUBLE: g_value_set_double (value, GTK_VALUE_DOUBLE (*arg)); break;
case G_TYPE_STRING: g_value_set_static_string (value, GTK_VALUE_STRING (*arg)); break;
case G_TYPE_BOXED: g_value_set_static_boxed (value, GTK_VALUE_BOXED (*arg)); break;
case G_TYPE_POINTER: g_value_set_pointer (value, GTK_VALUE_POINTER (*arg)); break;
case G_TYPE_OBJECT: g_value_set_object (value, GTK_VALUE_POINTER (*arg)); break;
default:
return FALSE;
}
return TRUE;
}
static gboolean
g_child_watch_closure_callback (GPid pid,
gint status,
gpointer data)
{
GClosure *closure = data;
GValue params[2] = { G_VALUE_INIT, G_VALUE_INIT };
GValue result_value = G_VALUE_INIT;
gboolean result;
g_value_init (&result_value, G_TYPE_BOOLEAN);
#ifdef G_OS_UNIX
g_value_init (¶ms[0], G_TYPE_ULONG);
g_value_set_ulong (¶ms[0], pid);
#endif
#ifdef G_OS_WIN32
g_value_init (¶ms[0], G_TYPE_POINTER);
g_value_set_pointer (¶ms[0], pid);
#endif
g_value_init (¶ms[1], G_TYPE_INT);
g_value_set_int (¶ms[1], status);
g_closure_invoke (closure, &result_value, 2, params, NULL);
result = g_value_get_boolean (&result_value);
g_value_unset (&result_value);
g_value_unset (¶ms[0]);
g_value_unset (¶ms[1]);
return result;
}
static gboolean
clutter_alpha_parse_custom_node (ClutterScriptable *scriptable,
ClutterScript *script,
GValue *value,
const gchar *name,
JsonNode *node)
{
if (strncmp (name, "function", 8) == 0)
{
const gchar *func_name = json_node_get_string (node);
g_value_init (value, G_TYPE_POINTER);
g_value_set_pointer (value, resolve_alpha_func (func_name));
return TRUE;
}
/* we need to do this because we use gulong in place
* of ClutterAnimationMode for ClutterAlpha:mode
*/
if (strncmp (name, "mode", 4) == 0)
{
gulong mode;
mode = _clutter_script_resolve_animation_mode (node);
g_value_init (value, G_TYPE_ULONG);
g_value_set_ulong (value, mode);
return TRUE;
}
return FALSE;
}
static void
integerCriteriaGetWidgetData (GtkWidget *widget, GValue *val)
{
gint num = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (widget));
g_assert (num >= 0);
g_value_init (val, G_TYPE_ULONG);
g_value_set_ulong (val, (gulong)num);
}
void
set_entry_ulong (RhythmDB *db, RhythmDBEntry *entry, RhythmDBPropType prop, gulong value)
{
GValue v = {0,};
g_value_init (&v, G_TYPE_ULONG);
g_value_set_ulong (&v, value);
rhythmdb_entry_set (db, entry, prop, &v);
g_value_unset (&v);
}
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))));
}
}
static void
bt_sequence_grid_model_get_property (GObject * const object,
const guint property_id, GValue * const value, GParamSpec * const pspec)
{
BtSequenceGridModel *self = BT_SEQUENCE_GRID_MODEL (object);
switch (property_id) {
case SEQUENCE_GRID_MODEL_POS_FORMAT:
g_value_set_enum (value, self->priv->pos_format);
break;
case SEQUENCE_GRID_MODEL_BARS:
g_value_set_ulong (value, self->priv->bars);
break;
case SEQUENCE_GRID_MODEL_LENGTH:
g_value_set_ulong (value, self->priv->visible_length);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static gboolean
update_disc_number_cb (GtkWidget *widget, GdkEventFocus *event, RBAudioCdSource *source)
{
GValue v = {0, };
g_value_init (&v, G_TYPE_ULONG);
g_value_set_ulong (&v, strtoul (gtk_entry_get_text (GTK_ENTRY (widget)), NULL, 10));
update_tracks (source, RHYTHMDB_PROP_DISC_NUMBER, &v);
g_value_unset (&v);
return FALSE;
}
static void
update_entry_last_seen (RhythmDB *db, RhythmDBEntry *entry)
{
GTimeVal time;
GValue val = {0, };
g_get_current_time (&time);
g_value_init (&val, G_TYPE_ULONG);
g_value_set_ulong (&val, time.tv_sec);
rhythmdb_entry_set_internal (db, entry, FALSE, RHYTHMDB_PROP_LAST_SEEN, &val);
g_value_unset (&val);
}
/**
* pka_subscription_deliver_sample:
* @subscription: A #PkaSubscription.
*
* Delivers @sample from @source to the @subscription. @manifest should
* be the current manifest for the source that has already been sent
* to pka_subscription_deliver_manifest().
*
* Returns: None.
* Side effects: None.
*/
void
pka_subscription_deliver_sample (PkaSubscription *subscription, /* IN */
PkaSource *source, /* IN */
PkaManifest *manifest, /* IN */
PkaSample *sample) /* IN */
{
GValue params[3] = { { 0 } };
guint8 *buffer = NULL;
gsize buffer_len = 0;
PkaSample *samples[1] = { sample };
g_return_if_fail(subscription != NULL);
g_return_if_fail(sample != NULL);
g_return_if_fail(PKA_IS_SOURCE(source));
/*
* TODO: In the recent rewrite of this, we didn't implement buffering.
* We need to add back support for buffering based on timeouts or
* size of raw-data.
*/
ENTRY;
g_static_rw_lock_reader_lock(&subscription->rw_lock);
if (G_LIKELY(subscription->sample_closure)) {
if (!pka_encoder_encode_samples(NULL, manifest, samples, 1,
&buffer, &buffer_len)) {
WARNING(Subscription, "Subscription %d failed to encode sample.",
subscription->id);
GOTO(failed);
}
DUMP_BYTES(Sample, buffer, buffer_len);
/*
* XXX: It should be obvious that this marshalling isn't very fast.
* But I've certainly done worse.
*/
g_value_init(¶ms[0], PKA_TYPE_SUBSCRIPTION);
g_value_init(¶ms[1], G_TYPE_POINTER);
g_value_init(¶ms[2], G_TYPE_ULONG);
g_value_set_boxed(¶ms[0], subscription);
g_value_set_pointer(¶ms[1], buffer);
g_value_set_ulong(¶ms[2], buffer_len);
g_closure_invoke(subscription->sample_closure, NULL,
3, ¶ms[0], NULL);
g_value_unset(¶ms[0]);
g_value_unset(¶ms[1]);
g_value_unset(¶ms[2]);
g_free(buffer);
}
failed:
g_static_rw_lock_reader_unlock(&subscription->rw_lock);
EXIT;
}
