static void fprint_device_get_property(GObject *object, guint property_id,
GValue *value, GParamSpec *pspec)
{
FprintDevice *self = (FprintDevice *) object;
FprintDevicePrivate *priv = DEVICE_GET_PRIVATE(self);
switch (property_id) {
case FPRINT_DEVICE_IN_USE:
g_value_set_boolean(value, g_hash_table_size (priv->clients) != 0);
break;
case FPRINT_DEVICE_NAME:
g_value_set_static_string (value, fp_driver_get_full_name (fp_dscv_dev_get_driver (priv->ddev)));
break;
case FPRINT_DEVICE_NUM_ENROLL:
if (priv->dev)
g_value_set_int (value, fp_dev_get_nr_enroll_stages (priv->dev));
else
g_value_set_int (value, -1);
break;
case FPRINT_DEVICE_SCAN_TYPE: {
const char *type;
if (fp_driver_get_scan_type (fp_dscv_dev_get_driver (priv->ddev)) == FP_SCAN_TYPE_PRESS)
type = "press";
else
type = "swipe";
g_value_set_static_string (value, type);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
break;
}
}
static void
debug_tree_cell_data_func (GtkTreeViewColumn *tree_column,
GtkCellRenderer *cell, GtkTreeModel *tree_model,
GtkTreeIter *iter, gpointer data)
{
gchar *value;
static const gchar *colors[] = {"black", "red"};
GValue gvalue = {0, };
DmaVariableData *node = NULL;
gtk_tree_model_get (tree_model, iter, VALUE_COLUMN, &value, -1);
g_value_init (&gvalue, G_TYPE_STRING);
g_value_set_static_string (&gvalue, value);
g_object_set_property (G_OBJECT (cell), "text", &gvalue);
gtk_tree_model_get (tree_model, iter, DTREE_ENTRY_COLUMN, &node, -1);
if (node)
{
g_value_reset (&gvalue);
g_value_set_static_string (&gvalue,
colors[(node && node->modified ? 1 : 0)]);
g_object_set_property (G_OBJECT (cell), "foreground", &gvalue);
}
g_free (value);
}
static RhythmDBEntry *
create_entry (RhythmDB *db,
const char *location, const char *name, const char *album,
const char *artist, const char *genre)
{
RhythmDBEntry *entry;
GValue val = {0, };
entry = rhythmdb_entry_new (db, RHYTHMDB_ENTRY_TYPE_IGNORE, location);
g_assert (entry);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, genre);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_GENRE, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, artist);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ARTIST, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, album);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ALBUM, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, name);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TITLE, &val);
g_value_unset (&val);
return entry;
}
static void
custom_list_get_value (GtkTreeModel * tree_model,
GtkTreeIter * iter, gint column, GValue * value)
{
chanlistrow *record;
CustomList *custom_list = CUSTOM_LIST (tree_model);
if (custom_list->num_rows == 0)
return;
g_value_init (value, custom_list->column_types[column]);
record = (chanlistrow *) iter->user_data;
switch (column)
{
case CUSTOM_LIST_COL_NAME:
g_value_set_static_string (value, GET_CHAN (record));
break;
case CUSTOM_LIST_COL_USERS:
g_value_set_uint (value, record->users);
break;
case CUSTOM_LIST_COL_TOPIC:
g_value_set_static_string (value, record->topic);
break;
}
}
void
empathy_account_request_presence (EmpathyAccount *account,
TpConnectionPresenceType type,
const gchar *status,
const gchar *message)
{
EmpathyAccountPriv *priv = GET_PRIV (account);
GValue value = {0, };
GValueArray *arr;
g_value_init (&value, TP_STRUCT_TYPE_SIMPLE_PRESENCE);
g_value_take_boxed (&value, dbus_g_type_specialized_construct
(TP_STRUCT_TYPE_SIMPLE_PRESENCE));
arr = (GValueArray *) g_value_get_boxed (&value);
g_value_set_uint (arr->values, type);
g_value_set_static_string (arr->values + 1, status);
g_value_set_static_string (arr->values + 2, message);
tp_cli_dbus_properties_call_set (TP_PROXY (priv->account),
-1,
TP_IFACE_ACCOUNT,
"RequestedPresence",
&value,
empathy_account_requested_presence_cb,
NULL,
NULL,
G_OBJECT (account));
g_value_unset (&value);
}
static void
get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
TpTestsTextChannelGroup *self = TP_TESTS_TEXT_CHANNEL_GROUP (object);
switch (property_id)
{
case PROP_OBJECT_PATH:
g_value_set_string (value, self->priv->object_path);
break;
case PROP_CHANNEL_TYPE:
g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_TEXT);
break;
case PROP_HANDLE_TYPE:
g_value_set_uint (value, TP_HANDLE_TYPE_NONE);
break;
case PROP_HANDLE:
g_value_set_uint (value, 0);
break;
case PROP_TARGET_ID:
g_value_set_static_string (value, "");
break;
case PROP_REQUESTED:
g_value_set_boolean (value, TRUE);
break;
case PROP_INITIATOR_HANDLE:
g_value_set_uint (value, self->conn->self_handle);
break;
case PROP_INITIATOR_ID:
{
TpHandleRepoIface *contact_repo = tp_base_connection_get_handles (
self->conn, TP_HANDLE_TYPE_CONTACT);
g_value_set_string (value,
tp_handle_inspect (contact_repo, self->conn->self_handle));
}
break;
case PROP_INTERFACES:
g_value_set_boxed (value, text_channel_group_interfaces);
break;
case PROP_CONNECTION:
g_value_set_object (value, self->conn);
break;
case PROP_DETAILED:
g_value_set_boolean (value, self->priv->detailed);
break;
case PROP_PROPERTIES:
g_value_set_boolean (value, self->priv->properties);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static gboolean dmm_button_icon_transform(GBinding *binding,
const GValue *source_value, GValue *target_value, gpointer user_data)
{
if (g_value_get_boolean(source_value))
g_value_set_static_string(target_value, "gtk-stop");
else
g_value_set_static_string(target_value, "gtk-media-play");
return TRUE;
}
static void
gnc_tree_model_owner_set_color(GncTreeModelOwner *model,
gboolean negative,
GValue *value)
{
GncTreeModelOwnerPrivate *priv;
priv = GNC_TREE_MODEL_OWNER_GET_PRIVATE(model);
if (negative)
g_value_set_static_string (value, priv->negative_color);
else
g_value_set_static_string (value, NULL);
}
static GTokenType
gimp_config_deserialize_any (GValue *value,
GParamSpec *prop_spec,
GScanner *scanner)
{
GValue src = { 0, };
if (!g_value_type_transformable (G_TYPE_STRING, prop_spec->value_type))
{
g_warning ("%s: %s can not be transformed from a string",
G_STRFUNC, g_type_name (prop_spec->value_type));
return G_TOKEN_NONE;
}
if (g_scanner_peek_next_token (scanner) != G_TOKEN_IDENTIFIER)
return G_TOKEN_IDENTIFIER;
g_scanner_get_next_token (scanner);
g_value_init (&src, G_TYPE_STRING);
g_value_set_static_string (&src, scanner->value.v_identifier);
g_value_transform (&src, value);
g_value_unset (&src);
return G_TOKEN_RIGHT_PAREN;
}
static void zbar_gtk_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ZBarGtk *self = ZBAR_GTK(object);
if(!self->_private)
return;
ZBarGtkPrivate *zbar = ZBAR_GTK_PRIVATE(self->_private);
switch(prop_id) {
case PROP_VIDEO_DEVICE:
if(zbar->video_device)
g_value_set_string(value, zbar->video_device);
else
g_value_set_static_string(value, "");
break;
case PROP_VIDEO_ENABLED:
g_value_set_boolean(value, zbar->video_enabled);
break;
case PROP_VIDEO_OPENED:
g_value_set_boolean(value, zbar->video_opened);
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
}
}
/**
* mcd_channel_new_from_path:
* @connection: the #TpConnection on which the channel exists.
* @object_path: the D-Bus object path of an existing channel.
* @type: the channel type.
* @handle: the channel handle.
* @handle_type: the #TpHandleType.
*
* Creates a #McdChannel with an associated #TpChannel proxy for the channel
* located at @object_path.
*
* Returns: a new #McdChannel if the #TpChannel was created successfully, %NULL
* otherwise.
*/
McdChannel *
mcd_channel_new_from_path (TpConnection *connection, const gchar *object_path,
const gchar *type, guint handle,
TpHandleType handle_type)
{
GHashTable *props;
GValue v_type = G_VALUE_INIT;
GValue v_handle = G_VALUE_INIT;
GValue v_handle_type = G_VALUE_INIT;
McdChannel *channel;
props = g_hash_table_new (g_str_hash, g_str_equal);
g_value_init (&v_type, G_TYPE_STRING);
g_value_set_static_string (&v_type, type);
g_hash_table_insert (props, TP_IFACE_CHANNEL ".ChannelType", &v_type);
g_value_init (&v_handle, G_TYPE_UINT);
g_value_set_uint (&v_handle, handle);
g_hash_table_insert (props, TP_IFACE_CHANNEL ".TargetHandle", &v_handle);
g_value_init (&v_handle_type, G_TYPE_UINT);
g_value_set_uint (&v_handle_type, handle_type);
g_hash_table_insert (props, TP_IFACE_CHANNEL ".TargetHandleType",
&v_handle_type);
channel = mcd_channel_new_from_properties (connection, object_path, props);
g_hash_table_unref (props);
return channel;
}
static gboolean
clutter_binding_entry_invoke (ClutterBindingEntry *entry,
GObject *gobject)
{
GValue params[4] = { { 0, }, { 0, }, { 0, }, { 0, } };
GValue result = { 0, };
gboolean retval = TRUE;
g_value_init (¶ms[0], G_TYPE_OBJECT);
g_value_set_object (¶ms[0], gobject);
g_value_init (¶ms[1], G_TYPE_STRING);
g_value_set_static_string (¶ms[1], entry->name);
g_value_init (¶ms[2], G_TYPE_UINT);
g_value_set_uint (¶ms[2], entry->key_val);
g_value_init (¶ms[3], CLUTTER_TYPE_MODIFIER_TYPE);
g_value_set_flags (¶ms[3], entry->modifiers);
g_value_init (&result, G_TYPE_BOOLEAN);
g_closure_invoke (entry->closure, &result, 4, params, NULL);
retval = g_value_get_boolean (&result);
g_value_unset (&result);
g_value_unset (¶ms[0]);
g_value_unset (¶ms[1]);
g_value_unset (¶ms[2]);
g_value_unset (¶ms[3]);
return retval;
}
/* returns 0 on success, prints a status msg if msg is true */
int owl_variable_set_fromstring(owl_variable *v, const char *value, int msg) {
char *tostring;
GValue values[] = {G_VALUE_INIT, G_VALUE_INIT};
GValue return_box = G_VALUE_INIT;
int set_successfully;
g_value_init(&values[0], G_TYPE_POINTER);
g_value_set_pointer(&values[0], NULL);
g_value_init(&values[1], G_TYPE_STRING);
g_value_set_static_string(&values[1], value);
g_value_init(&return_box, G_TYPE_INT);
g_closure_invoke(v->set_fromstring_fn, &return_box, 2, values, NULL);
set_successfully = g_value_get_int(&return_box);
if (0 != set_successfully) {
if (msg) owl_function_error("Unable to set %s (must be %s)", owl_variable_get_name(v),
owl_variable_get_validsettings(v));
} else if (msg) {
tostring = owl_variable_get_tostring(v);
if (tostring) {
owl_function_makemsg("%s = '%s'", owl_variable_get_name(v), tostring);
} else {
owl_function_makemsg("%s = <null>", owl_variable_get_name(v));
}
g_free(tostring);
}
g_value_unset(&return_box);
g_value_unset(&values[1]);
g_value_unset(&values[0]);
return set_successfully;
}
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
vino_get_password (GValue *value,
GVariant *variant,
gpointer user_data)
{
const gchar *setting;
setting = g_variant_get_string (variant, NULL);
if (strcmp (setting, "keyring") == 0)
{
/* "keyring" is the default value, even though vino doesn't support it at
* the moment */
g_value_set_static_string (value, "");
return TRUE;
}
else
{
gchar *decoded;
gsize length;
gboolean ok;
decoded = (gchar *) g_base64_decode (setting, &length);
if ((ok = g_utf8_validate (decoded, length, NULL)))
g_value_take_string (value, g_strndup (decoded, length));
return ok;
}
}
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 GHashTable *
ring_anon_channel_fixed_properties(void)
{
static GHashTable *hash;
if (hash)
return hash;
hash = g_hash_table_new(g_str_hash, g_str_equal);
char const *key;
GValue *value;
key = TP_IFACE_CHANNEL ".TargetHandleType";
value = tp_g_value_slice_new(G_TYPE_UINT);
g_value_set_uint(value, TP_HANDLE_TYPE_NONE);
g_hash_table_insert(hash, (gpointer)key, value);
key = TP_IFACE_CHANNEL ".ChannelType";
value = tp_g_value_slice_new(G_TYPE_STRING);
g_value_set_static_string(value, TP_IFACE_CHANNEL_TYPE_STREAMED_MEDIA);
g_hash_table_insert(hash, (gpointer)key, value);
return hash;
}
static void
rakia_media_manager_type_foreach_channel_class (GType type,
TpChannelManagerTypeChannelClassFunc func,
gpointer user_data)
{
GHashTable *table = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, (GDestroyNotify) tp_g_value_slice_free);
GValue *value, *handle_type_value;
value = tp_g_value_slice_new (G_TYPE_STRING);
g_value_set_static_string (value, TP_IFACE_CHANNEL_TYPE_CALL);
g_hash_table_insert (table, TP_PROP_CHANNEL_CHANNEL_TYPE, value);
handle_type_value = tp_g_value_slice_new (G_TYPE_UINT);
/* no uint value yet - we'll change it for each channel class */
g_hash_table_insert (table, TP_PROP_CHANNEL_TARGET_HANDLE_TYPE,
handle_type_value);
g_value_set_uint (handle_type_value, TP_HANDLE_TYPE_CONTACT);
g_hash_table_insert (table, TP_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO,
tp_g_value_slice_new_boolean (TRUE));
func (type, table, named_channel_allowed_properties, user_data);
g_hash_table_remove (table, TP_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO);
g_hash_table_insert (table, TP_PROP_CHANNEL_TYPE_CALL_INITIAL_VIDEO,
tp_g_value_slice_new_boolean (TRUE));
func (type, table, named_channel_allowed_properties, user_data);
g_hash_table_unref (table);
}
static void
gst_egl_sink_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstEGLSink *egl_sink;
g_return_if_fail (GST_IS_EGL_SINK (object));
egl_sink = GST_EGL_SINK (object);
switch (prop_id) {
case ARG_DISPLAY:
g_value_set_string (value, egl_sink->display_name);
break;
case PROP_FORCE_ASPECT_RATIO:
g_value_set_boolean (value, egl_sink->keep_aspect_ratio);
break;
case PROP_PIXEL_ASPECT_RATIO:
if (egl_sink->par)
g_value_transform (egl_sink->par, value);
else
g_value_set_static_string(value, "1/1");
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
connection_manager_got_info (TpConnectionManager *cm,
guint source,
gpointer unused)
{
g_message ("Emitted got-info (source=%d)", source);
if (source > 0)
{
GHashTable *params;
GValue value = { 0 };
if (timer != 0)
{
g_source_remove (timer);
timer = 0;
}
params = g_hash_table_new (g_str_hash, g_str_equal);
g_value_init (&value, G_TYPE_STRING);
g_value_set_static_string (&value, "myself@server");
g_hash_table_insert (params, "account", &value);
/* This example is rather lower-level than most: it's
* "going behind the account manager's back". This is not recommended
* in real applications. */
tp_cli_connection_manager_call_request_connection (cm,
-1, "example", params, cm_requested_connection, NULL, NULL, NULL);
g_hash_table_unref (params);
}
}
static void
gwy_vector_layer_get_property(GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GwyVectorLayer *vector_layer = GWY_VECTOR_LAYER(object);
switch (prop_id) {
case PROP_SELECTION_KEY:
g_value_set_static_string(value,
g_quark_to_string(vector_layer->selection_key));
break;
case PROP_EDITABLE:
g_value_set_boolean(value, vector_layer->editable);
break;
case PROP_FOCUS:
g_value_set_int(value, vector_layer->focus);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
static void
get_property (GObject *object, guint property_id,
GValue *value, GParamSpec *pspec)
{
NMConnectivity *self = NM_CONNECTIVITY (object);
NMConnectivityPrivate *priv = NM_CONNECTIVITY_GET_PRIVATE (self);
switch (property_id) {
case PROP_URI:
g_value_set_string (value, priv->uri);
break;
case PROP_INTERVAL:
g_value_set_uint (value, priv->interval);
break;
case PROP_RESPONSE:
if (priv->response)
g_value_set_string (value, priv->response);
else
g_value_set_static_string (value, NM_CONFIG_DEFAULT_CONNECTIVITY_RESPONSE);
break;
case PROP_STATE:
g_value_set_uint (value, priv->state);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
grl_dpap_record_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GrlDPAPRecord *record = SIMPLE_DPAP_RECORD (object);
switch (prop_id) {
case PROP_LOCATION:
g_value_set_static_string (value, record->priv->location);
break;
case PROP_LARGE_FILESIZE:
g_value_set_int (value, record->priv->largefilesize);
break;
case PROP_CREATION_DATE:
g_value_set_int (value, record->priv->creationdate);
break;
case PROP_RATING:
g_value_set_int (value, record->priv->rating);
break;
case PROP_FILENAME:
g_value_set_static_string (value, record->priv->filename);
break;
case PROP_ASPECT_RATIO:
g_value_set_static_string (value, record->priv->aspectratio);
break;
case PROP_PIXEL_HEIGHT:
g_value_set_int (value, record->priv->height);
break;
case PROP_PIXEL_WIDTH:
g_value_set_int (value, record->priv->width);
break;
case PROP_FORMAT:
g_value_set_static_string (value, record->priv->format);
break;
case PROP_COMMENTS:
g_value_set_static_string (value, record->priv->comments);
break;
case PROP_THUMBNAIL:
g_value_set_pointer (value, record->priv->thumbnail);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* tp_g_value_slice_new_static_string:
* @string: a static string which must remain valid forever, to be pointed to
* by the value
*
* 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_STRING whose value is @string,
* to be freed with tp_g_value_slice_free() or g_slice_free()
*
* Since: 0.7.27
*/
GValue *
tp_g_value_slice_new_static_string (const gchar *string)
{
GValue *v = tp_g_value_slice_new (G_TYPE_STRING);
g_value_set_static_string (v, string);
return v;
}
END_TEST
START_TEST (test_rhythmdb_mirroring)
{
GValue val = {0,};
RhythmDBEntry *entry;
const char *str;
entry = rhythmdb_entry_new (db, RHYTHMDB_ENTRY_TYPE_IGNORE, "file:///foo.mp3");
fail_unless (entry != NULL, "failed to create entry");
/* check the last-played date is mirrored */
g_value_init (&val, G_TYPE_ULONG);
g_value_set_ulong (&val, 1354285);
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_LAST_PLAYED, &val);
g_value_unset (&val);
rhythmdb_commit (db);
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LAST_PLAYED_STR);
fail_unless (str && (strlen (str) > 0), "date not converted to string");
/* check folded and sort-key varients */
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "FOO");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TITLE, &val);
g_value_unset (&val);
rhythmdb_commit (db);
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE_SORT_KEY);
fail_unless (str && (strlen (str) > 0), "sort-key not generated");
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE_FOLDED);
fail_unless (str && (strcmp (str, "foo") == 0), "folded variant not generated");
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "BAR");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TITLE, &val);
g_value_unset (&val);
rhythmdb_commit (db);
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE_SORT_KEY);
fail_unless (str && (strlen (str) > 0), "sort-key not generated");
str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE_FOLDED);
fail_unless (str && (strcmp (str, "bar") == 0), "folded variant not generated");
}
void
gst_soup_http_client_sink_get_property (GObject * object, guint property_id,
GValue * value, GParamSpec * pspec)
{
GstSoupHttpClientSink *souphttpsink = GST_SOUP_HTTP_CLIENT_SINK (object);
switch (property_id) {
case PROP_SESSION:
g_value_set_object (value, souphttpsink->prop_session);
break;
case PROP_LOCATION:
g_value_set_string (value, souphttpsink->location);
break;
case PROP_AUTOMATIC_REDIRECT:
g_value_set_boolean (value, souphttpsink->automatic_redirect);
break;
case PROP_USER_AGENT:
g_value_set_string (value, souphttpsink->user_agent);
break;
case PROP_USER_ID:
g_value_set_string (value, souphttpsink->user_id);
break;
case PROP_USER_PW:
g_value_set_string (value, souphttpsink->user_pw);
break;
case PROP_PROXY_ID:
g_value_set_string (value, souphttpsink->proxy_id);
break;
case PROP_PROXY_PW:
g_value_set_string (value, souphttpsink->proxy_pw);
break;
case PROP_PROXY:
if (souphttpsink->proxy == NULL)
g_value_set_static_string (value, "");
else {
char *proxy = soup_uri_to_string (souphttpsink->proxy, FALSE);
g_value_set_string (value, proxy);
g_free (proxy);
}
break;
case PROP_COOKIES:
g_value_set_boxed (value, g_strdupv (souphttpsink->cookies));
break;
case PROP_SOUP_LOG_LEVEL:
g_value_set_enum (value, souphttpsink->log_level);
break;
case PROP_RETRY_DELAY:
g_value_set_int (value, souphttpsink->retry_delay);
break;
case PROP_RETRIES:
g_value_set_int (value, souphttpsink->retries);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static GimpValueArray *
file_save_invoker (GimpProcedure *procedure,
Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
const GimpValueArray *args,
GError **error)
{
GimpValueArray *new_args;
GimpValueArray *return_vals;
GimpPlugInProcedure *file_proc;
GimpProcedure *proc;
gchar *uri;
gint i;
uri = file_utils_filename_to_uri (gimp,
g_value_get_string (gimp_value_array_index (args, 3)),
error);
if (! uri)
return gimp_procedure_get_return_values (procedure, FALSE,
error ? *error : NULL);
file_proc =
file_procedure_find (gimp->plug_in_manager->save_procs, uri, NULL);
if (! file_proc)
file_proc = file_procedure_find (gimp->plug_in_manager->export_procs, uri, error);
g_free (uri);
if (! file_proc)
return gimp_procedure_get_return_values (procedure, FALSE,
error ? *error : NULL);
proc = GIMP_PROCEDURE (file_proc);
new_args = gimp_procedure_get_arguments (proc);
for (i = 0; i < 5; i++)
g_value_transform (gimp_value_array_index (args, i),
gimp_value_array_index (new_args, i));
for (i = 5; i < proc->num_args; i++)
if (G_IS_PARAM_SPEC_STRING (proc->args[i]))
g_value_set_static_string (gimp_value_array_index (new_args, i), "");
return_vals =
gimp_pdb_execute_procedure_by_name_args (gimp->pdb,
context, progress, error,
gimp_object_get_name (proc),
new_args);
gimp_value_array_unref (new_args);
return return_vals;
}
/**
* gst_gl_value_set_texture_target:
* @value: an initialized #GValue of type G_TYPE_STRING
* @target: a #GstGLTextureTarget's
*
* Returns: whether the @target could be set on @value
*/
gboolean
gst_gl_value_set_texture_target (GValue * value, GstGLTextureTarget target)
{
g_return_val_if_fail (value != NULL, FALSE);
g_return_val_if_fail (target != GST_GL_TEXTURE_TARGET_NONE, FALSE);
if (target == GST_GL_TEXTURE_TARGET_2D) {
g_value_set_static_string (value, GST_GL_TEXTURE_TARGET_2D_STR);
} else if (target == GST_GL_TEXTURE_TARGET_RECTANGLE) {
g_value_set_static_string (value, GST_GL_TEXTURE_TARGET_RECTANGLE_STR);
} else if (target == GST_GL_TEXTURE_TARGET_EXTERNAL_OES) {
g_value_set_static_string (value, GST_GL_TEXTURE_TARGET_EXTERNAL_OES_STR);
} else {
return FALSE;
}
return TRUE;
}
END_TEST
START_TEST (test_rhythmdb_modify_after_delete)
{
RhythmDBEntry *entry;
GValue val = {0,};
entry = rhythmdb_entry_new (db, RHYTHMDB_ENTRY_TYPE_IGNORE, "file:///whee.ogg");
fail_unless (entry != NULL, "failed to create entry");
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Anything");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_GENRE, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Nothing");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ARTIST, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Something");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ALBUM, &val);
g_value_unset (&val);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Thing");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_TITLE, &val);
g_value_unset (&val);
rhythmdb_commit (db);
rhythmdb_entry_ref (entry);
rhythmdb_entry_delete (db, entry);
rhythmdb_commit (db);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, "Something Else");
rhythmdb_entry_set (db, entry, RHYTHMDB_PROP_ALBUM, &val);
g_value_unset (&val);
rhythmdb_commit (db);
rhythmdb_entry_unref (entry);
}
static void
_audit_field_init_string (AuditField *field, const char *name, const char *str,
gboolean need_encoding, AuditBackend backends)
{
field->name = name;
field->need_encoding = need_encoding;
field->backends = backends;
g_value_init (&field->value, G_TYPE_STRING);
g_value_set_static_string (&field->value, str);
}
