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