gboolean dbus_glib_object1_struct_example_method_impl (DBusGlibObject1 *self,
GValueArray* st,
gint* ret,
GError **error)
{
GValue *val;
val = g_value_array_get_nth(st, 0);
if (G_VALUE_HOLDS(val, G_TYPE_INT))
if (g_value_type_compatible (G_VALUE_TYPE (val), G_TYPE_INT))
if(g_value_get_int(val) != 1234)
*ret = -1;
val = g_value_array_get_nth(st, 1);
if (G_VALUE_HOLDS(val, G_TYPE_STRING))
if (g_value_type_compatible (G_VALUE_TYPE (val), G_TYPE_STRING))
if(strcmp("StructPassing", g_value_get_string(val)))
*ret = -1;
if(*ret != -1)
*ret = 5050;
return TRUE;
}
static GList *parse_one_formats_list (GHashTable *sysinfo_dict,
const char *key)
{
GValue *to_parse;
GList *formats = NULL;
GValueArray *array;
gint i;
to_parse = g_hash_table_lookup (sysinfo_dict, key);
if (to_parse == NULL) {
return NULL;
}
if (!G_VALUE_HOLDS (to_parse, G_TYPE_VALUE_ARRAY)) {
return NULL;
}
array = (GValueArray*)g_value_get_boxed (to_parse);
for (i = 0; i < array->n_values; i++) {
Itdb_ArtworkFormat *format;
/* SysInfoExtended on the iPhone has <string> fields in the artwork
* format array in addition to the hash we parse
*/
if (!G_VALUE_HOLDS (g_value_array_get_nth (array, i), G_TYPE_HASH_TABLE)) {
continue;
}
format = g_value_to_image_format (g_value_array_get_nth (array, i));
if (format != NULL) {
formats = g_list_prepend (formats, format);
}
}
g_hash_table_remove (sysinfo_dict, key);
return formats;
}
/**
* fs_stream_parse_new_active_candidate_pair:
* @stream: a #FsStream to match against the message
* @message: a #GstMessage to parse
* @local_candidate: (out) (transfer none): Returns the local #FsCandidate in
* the message if not %NULL.
* @remote_candidate: (out) (transfer none): Returns the remote #FsCandidate in
* the message if not %NULL.
*
* Parses a "farstream-new-active-candidate-pair" message and checks
* if it matches the @stream parameters.
*
* Returns: %TRUE if the message matches the stream and is valid.
*/
gboolean
fs_stream_parse_new_active_candidate_pair (FsStream *stream,
GstMessage *message,
FsCandidate **local_candidate,
FsCandidate **remote_candidate)
{
const GstStructure *s;
const GValue *value;
g_return_val_if_fail (stream != NULL, FALSE);
if (!check_message (message, stream, "farstream-new-active-candidate-pair"))
return FALSE;
s = gst_message_get_structure (message);
value = gst_structure_get_value (s, "local-candidate");
if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CANDIDATE))
return FALSE;
if (local_candidate)
*local_candidate = g_value_get_boxed (value);
value = gst_structure_get_value (s, "remote-candidate");
if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CANDIDATE))
return FALSE;
if (remote_candidate)
*remote_candidate = g_value_get_boxed (value);
return TRUE;
}
/**
* fs_stream_parse_component_state_changed:
* @stream: a #FsStream to match against the message
* @message: a #GstMessage to parse
* @component: (out): Returns the component from the #GstMessage if not %NULL
* @state: (out): Returns the #FsStreamState from the #GstMessage if not %NULL
*
* Parses a "farstream-component-state-changed" message and checks if it matches
* the @stream parameters.
*
* Returns: %TRUE if the message matches the stream and is valid.
*/
gboolean
fs_stream_parse_component_state_changed (FsStream *stream,
GstMessage *message,
guint *component,
FsStreamState *state)
{
const GstStructure *s;
const GValue *value;
g_return_val_if_fail (stream != NULL, FALSE);
if (!check_message (message, stream, "farstream-component-state-changed"))
return FALSE;
s = gst_message_get_structure (message);
value = gst_structure_get_value (s, "component");
if (!value || !G_VALUE_HOLDS (value, G_TYPE_UINT))
return FALSE;
if (component)
*component = g_value_get_uint (value);
value = gst_structure_get_value (s, "state");
if (!value || !G_VALUE_HOLDS (value, G_TYPE_ENUM))
return FALSE;
if (state)
*state = g_value_get_enum (value);
return TRUE;
}
static void midgard_timestamp_transform_from_gda_timestamp(const GValue *src, GValue *dst)
{
g_return_if_fail(G_VALUE_HOLDS(src, GDA_TYPE_TIMESTAMP) &&
G_VALUE_HOLDS(dst, MGD_TYPE_TIMESTAMP));
MidgardTimestamp *mt = midgard_timestamp_new();
GdaTimestamp *gt = (GdaTimestamp *) g_value_get_boxed(src);
mt->year = gt->year;
/* Avoid 0000 year */
if (mt->year == 0)
mt->year = 1;
mt->month = gt->month;
/* Avoid 00 month */
if (mt->month == 0)
mt->month = 1;
mt->day = gt->day;
/* Avoid 00 day */
if (mt->day == 0)
mt->day = 1;
mt->hour = gt->hour;
mt->minute = gt->minute;
mt->second = gt->second;
mt->offset = gt->timezone;
if (gt->timezone == GDA_TIMEZONE_INVALID)
mt->offset = 0;
g_value_take_boxed(dst, mt);
}
/**
* fs_session_parse_send_codec_changed:
* @session: a #FsSession to match against the message
* @message: a #GstMessage to parse
* @codec: (out) (transfer none): Returns the #FsCodec in the message if not
* %NULL.
* @secondary_codecs: (out) (transfer none) (element-type FsCodec):
* Returns a #GList of #FsCodec of the message if not %NULL
*
* Parses a "farstream-send-codec-changed" message and checks if it matches
* the @session parameters.
*
* Returns: %TRUE if the message matches the session and is valid.
*/
gboolean
fs_session_parse_send_codec_changed ( FsSession *session,
GstMessage *message,
FsCodec **codec,
GList **secondary_codecs)
{
const GstStructure *s;
const GValue *value;
g_return_val_if_fail (session != NULL, FALSE);
if (!check_message (message, session, "farstream-send-codec-changed"))
return FALSE;
s = gst_message_get_structure (message);
value = gst_structure_get_value (s, "codec");
if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CODEC))
return FALSE;
if (codec)
*codec = g_value_get_boxed (value);
value = gst_structure_get_value (s, "secondary-codecs");
if (!value || !G_VALUE_HOLDS (value, FS_TYPE_CODEC_LIST))
return FALSE;
if (secondary_codecs)
*secondary_codecs = g_value_get_boxed (value);
return TRUE;
}
gchar *
gda_postgres_render_CREATE_DB (GdaServerProvider *provider, GdaConnection *cnc,
GdaServerOperation *op, G_GNUC_UNUSED GError **error)
{
GString *string;
const GValue *value;
gchar *sql = NULL;
gchar *tmp;
string = g_string_new ("CREATE DATABASE ");
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider, "/DB_DEF_P/DB_NAME", error);
if (!tmp) {
g_string_free (string, TRUE);
return NULL;
}
g_string_append (string, tmp);
g_free (tmp);
value = gda_server_operation_get_value_at (op, "/DB_DEF_P/OWNER");
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value)) {
g_string_append (string, " OWNER ");
g_string_append (string, g_value_get_string (value));
}
value = gda_server_operation_get_value_at (op, "/DB_DEF_P/TEMPLATE");
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value)) {
g_string_append (string, " TEMPLATE ");
g_string_append (string, g_value_get_string (value));
}
value = gda_server_operation_get_value_at (op, "/DB_DEF_P/DB_CSET");
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value)) {
GdaDataHandler *dh;
gchar *str;
dh = gda_server_provider_get_data_handler_g_type (provider, cnc, G_TYPE_STRING);
str = gda_data_handler_get_sql_from_value (dh, value);
if (str) {
g_string_append (string, " ENCODING ");
g_string_append (string, str);
g_free (str);
}
}
value = gda_server_operation_get_value_at (op, "/DB_DEF_P/TABLESPACE");
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value)) {
g_string_append (string, " TABLESPACE ");
g_string_append (string, g_value_get_string (value));
}
sql = string->str;
g_string_free (string, FALSE);
return sql;
}
static gboolean
opus_dec_sink_setcaps (GstPad * pad, GstCaps * caps)
{
GstOpusDec *dec = GST_OPUS_DEC (gst_pad_get_parent (pad));
gboolean ret = TRUE;
GstStructure *s;
const GValue *streamheader;
s = gst_caps_get_structure (caps, 0);
if ((streamheader = gst_structure_get_value (s, "streamheader")) &&
G_VALUE_HOLDS (streamheader, GST_TYPE_ARRAY) &&
gst_value_array_get_size (streamheader) >= 2) {
const GValue *header;
GstBuffer *buf;
GstFlowReturn res = GST_FLOW_OK;
header = gst_value_array_get_value (streamheader, 0);
if (header && G_VALUE_HOLDS (header, GST_TYPE_BUFFER)) {
buf = gst_value_get_buffer (header);
res = opus_dec_chain_parse_header (dec, buf);
if (res != GST_FLOW_OK)
goto done;
gst_buffer_replace (&dec->streamheader, buf);
}
#if 0
vorbiscomment = gst_value_array_get_value (streamheader, 1);
if (vorbiscomment && G_VALUE_HOLDS (vorbiscomment, GST_TYPE_BUFFER)) {
buf = gst_value_get_buffer (vorbiscomment);
res = opus_dec_chain_parse_comments (dec, buf);
if (res != GST_FLOW_OK)
goto done;
gst_buffer_replace (&dec->vorbiscomment, buf);
}
#endif
g_list_foreach (dec->extra_headers, (GFunc) gst_mini_object_unref, NULL);
g_list_free (dec->extra_headers);
dec->extra_headers = NULL;
if (gst_value_array_get_size (streamheader) > 2) {
gint i, n;
n = gst_value_array_get_size (streamheader);
for (i = 2; i < n; i++) {
header = gst_value_array_get_value (streamheader, i);
buf = gst_value_get_buffer (header);
dec->extra_headers =
g_list_prepend (dec->extra_headers, gst_buffer_ref (buf));
}
}
}
done:
gst_object_unref (dec);
return ret;
}
static int
_sort_by_index (ClutterModel *model,
const GValue *a,
const GValue *b,
gpointer user_data)
{
g_assert (G_VALUE_HOLDS (a, G_TYPE_UINT));
g_assert (G_VALUE_HOLDS (b, G_TYPE_UINT));
return g_value_get_uint (a) - g_value_get_uint (b);
}
gchar *
gda_postgres_render_DROP_INDEX (GdaServerProvider *provider, GdaConnection *cnc,
GdaServerOperation *op, G_GNUC_UNUSED GError **error)
{
GString *string;
const GValue *value;
gchar *sql = NULL;
gchar *tmp;
string = g_string_new ("DROP INDEX ");
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider, "/INDEX_DESC_P/INDEX_NAME", error);
if (!tmp) {
g_string_free (string, TRUE);
return NULL;
}
g_string_append (string, tmp);
g_free (tmp);
value = gda_server_operation_get_value_at (op, "/INDEX_DESC_P/REFERENCED_ACTION");
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) {
g_string_append_c (string, ' ');
g_string_append (string, g_value_get_string (value));
}
sql = string->str;
g_string_free (string, FALSE);
return sql;
}
static gboolean
check_message (GstMessage *message,
FsSession *session,
const gchar *message_name)
{
const GstStructure *s;
const GValue *value;
FsSession *message_session;
if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT)
return FALSE;
s = gst_message_get_structure (message);
if (!gst_structure_has_name (s, message_name))
return FALSE;
value = gst_structure_get_value (s, "session");
if (!value || !G_VALUE_HOLDS (value, FS_TYPE_SESSION))
return FALSE;
message_session = g_value_get_object (value);
if (session != message_session)
return FALSE;
return TRUE;
}
static Itdb_ArtworkFormat *g_value_to_image_format (GValue *value)
{
GHashTable *dict;
Itdb_ArtworkFormat *img_spec;
g_return_val_if_fail (G_VALUE_HOLDS (value, G_TYPE_HASH_TABLE), NULL);
dict = g_value_get_boxed (value);
g_return_val_if_fail (dict != NULL, NULL);
img_spec = g_new0 (Itdb_ArtworkFormat, 1);
if (img_spec == NULL) {
return NULL;
}
if (!set_pixel_format (img_spec, dict)) {
g_free (img_spec);
return NULL;
}
set_back_color (img_spec, dict);
dict_to_struct (dict, sysinfo_image_format_fields_mapping, img_spec);
if (get_boolean (dict, "AlignRowBytes")
&& (img_spec->row_bytes_alignment == 0)) {
/* at least the nano3g has the AlignRowBytes key with no
* RowBytesAlignment key.
*/
img_spec->row_bytes_alignment = 4;
}
return img_spec;
}
gchar *
_gda_sqlite_render_DROP_VIEW (G_GNUC_UNUSED GdaServerProvider *provider, GdaConnection *cnc,
GdaServerOperation *op, G_GNUC_UNUSED GError **error)
{
GString *string;
const GValue *value;
gchar *sql = NULL;
gchar *tmp;
string = g_string_new ("DROP VIEW");
value = gda_server_operation_get_value_at (op, "/VIEW_DESC_P/VIEW_IFEXISTS");
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, " IF EXISTS");
tmp = gda_connection_operation_get_sql_identifier_at (cnc, op, "/VIEW_DESC_P/VIEW_NAME", error);
if (!tmp) {
g_string_free (string, TRUE);
return NULL;
}
g_string_append_c (string, ' ');
g_string_append (string, tmp);
g_free (tmp);
sql = string->str;
g_string_free (string, FALSE);
return sql;
}
static gboolean
gdl_dock_reorder (GdlDockObject *object,
GdlDockObject *requestor,
GdlDockPlacement new_position,
GValue *other_data)
{
GdlDock *dock = GDL_DOCK (object);
gboolean handled = FALSE;
if (dock->_priv->floating &&
new_position == GDL_DOCK_FLOATING &&
dock->root == requestor) {
if (other_data && G_VALUE_HOLDS (other_data, GDK_TYPE_RECTANGLE)) {
GdkRectangle *rect;
rect = g_value_get_boxed (other_data);
gtk_window_move (GTK_WINDOW (dock->_priv->window),
rect->x,
rect->y);
handled = TRUE;
}
}
return handled;
}
gboolean
_nm_ip6_address_array_demarshal (GValue *value, GSList **dest)
{
GPtrArray *array;
if (!G_VALUE_HOLDS (value, DBUS_TYPE_G_ARRAY_OF_ARRAY_OF_UCHAR))
return FALSE;
if (*dest) {
g_slist_foreach (*dest, (GFunc) g_free, NULL);
g_slist_free (*dest);
*dest = NULL;
}
array = (GPtrArray *) g_value_get_boxed (value);
if (array && array->len) {
int i;
for (i = 0; i < array->len; i++) {
GByteArray *bytearray = (GByteArray *) g_ptr_array_index (array, i);
struct in6_addr *addr;
addr = g_malloc0 (sizeof (struct in6_addr));
memcpy (addr->s6_addr, bytearray->data, bytearray->len);
*dest = g_slist_append (*dest, addr);
}
}
return TRUE;
}
/**
* fs_session_parse_telephony_event_started:
* @session: a #FsSession to match against the message
* @message: a #GstMessage to parse
* @method: (out): Returns the #FsDTMFMethod in the message if not %NULL.
* @event: (out): Returns the #FsDTMFEvent in the message if not %NULL.
* @volume: (out): Returns the volume in the message if not %NULL.
*
* Parses a "farstream-telephony-event-started" message and checks if it matches
* the @session parameters.
*
* Returns: %TRUE if the message matches the session and is valid.
*/
gboolean
fs_session_parse_telephony_event_started (FsSession *session,
GstMessage *message,
FsDTMFMethod *method, FsDTMFEvent *event,
guint8 *volume)
{
const GstStructure *s;
const GValue *value;
g_return_val_if_fail (session != NULL, FALSE);
if (!check_message (message, session, "farstream-telephony-event-started"))
return FALSE;
s = gst_message_get_structure (message);
if (!gst_structure_has_field_typed (s, "method", FS_TYPE_DTMF_METHOD))
return FALSE;
if (method)
gst_structure_get_enum (s, "method", FS_TYPE_DTMF_METHOD, (gint*) method);
if (!gst_structure_has_field_typed (s, "event", FS_TYPE_DTMF_EVENT))
return FALSE;
if (event)
gst_structure_get_enum (s, "event", FS_TYPE_DTMF_EVENT, (gint*) event);
value = gst_structure_get_value (s, "volume");
if (!value || !G_VALUE_HOLDS (value, G_TYPE_UCHAR))
return FALSE;
if (volume)
*volume = g_value_get_uchar (value);
return TRUE;
}
gchar *midgard_timestamp_dup_string(const GValue *value)
{
g_assert(G_VALUE_HOLDS(value, MIDGARD_TYPE_TIMESTAMP));
MidgardTimestamp *mt = (MidgardTimestamp *) g_value_get_boxed(value);
return (gchar *)caltime_fmt(mt);
}
static void
art_cb (RBExtDBKey *key, const char *filename, GValue *data, MxFrame *frame)
{
ClutterActor *image;
GdkPixbuf *pixbuf;
if (data == NULL || G_VALUE_HOLDS (data, GDK_TYPE_PIXBUF) == FALSE) {
return;
}
clutter_threads_enter ();
image = gtk_clutter_texture_new ();
pixbuf = GDK_PIXBUF (g_value_get_object (data));
gtk_clutter_texture_set_from_pixbuf (GTK_CLUTTER_TEXTURE (image), pixbuf, NULL);
if (clutter_actor_get_height (image) > MAX_IMAGE_HEIGHT) {
clutter_actor_set_height (image, MAX_IMAGE_HEIGHT);
clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (image), TRUE);
}
if (clutter_actor_get_width (image) > MAX_IMAGE_HEIGHT) {
clutter_actor_set_width (image, MAX_IMAGE_HEIGHT);
}
mx_bin_set_child (MX_BIN (frame), image);
clutter_actor_show_all (CLUTTER_ACTOR (frame));
clutter_threads_leave ();
}
static GSList *
add_domains (GSList *items,
GHashTable *hash,
const char *prefix,
const char four_or_six)
{
GValue *val;
char **domains = NULL;
GString *tmp;
guint i;
/* Search domains */
val = g_hash_table_lookup (hash, "domains");
if (!val)
return items;
g_return_val_if_fail (G_VALUE_HOLDS (val, G_TYPE_STRV), items);
domains = (char **) g_value_get_boxed (val);
if (!domains || !domains[0])
return items;
tmp = g_string_new (NULL);
g_string_append_printf (tmp, "%sIP%c_DOMAINS=", prefix, four_or_six);
for (i = 0; domains[i]; i++) {
if (i > 0)
g_string_append_c (tmp, ' ');
g_string_append (tmp, domains[i]);
}
items = g_slist_prepend (items, tmp->str);
g_string_free (tmp, FALSE);
return items;
}
void
tmpl_iterator_init (TmplIterator *iter,
const GValue *value)
{
memset (iter, 0, sizeof *iter);
if (value == NULL)
return;
if (G_VALUE_HOLDS_STRING (value))
{
iter->instance = (gchar *)g_value_get_string (value);
iter->move_next = string_move_next;
iter->get_value = string_get_value;
iter->destroy = NULL;
}
else if (G_VALUE_HOLDS (value, G_TYPE_LIST_MODEL))
{
iter->instance = g_value_get_object (value);
iter->move_next = list_model_move_next;
iter->get_value = list_model_get_value;
iter->destroy = NULL;
}
/* TODO: More iter types */
}
static void
ip4_dns_writer (GKeyFile *file,
NMSetting *setting,
const char *key,
const GValue *value)
{
GArray *array;
char **list;
int i, num = 0;
g_return_if_fail (G_VALUE_HOLDS (value, DBUS_TYPE_G_UINT_ARRAY));
array = (GArray *) g_value_get_boxed (value);
if (!array || !array->len)
return;
list = g_new0 (char *, array->len + 1);
for (i = 0; i < array->len; i++) {
char buf[INET_ADDRSTRLEN + 1];
struct in_addr addr;
addr.s_addr = g_array_index (array, guint32, i);
if (!inet_ntop (AF_INET, &addr, buf, sizeof (buf))) {
nm_warning ("%s: error converting IP4 address 0x%X",
__func__, ntohl (addr.s_addr));
} else
list[num++] = g_strdup (buf);
}
g_key_file_set_string_list (file, nm_setting_get_name (setting), key, (const char **) list, num);
g_strfreev (list);
}
static void
mac_address_writer (GKeyFile *file,
NMSetting *setting,
const char *key,
const GValue *value)
{
GByteArray *array;
const char *setting_name = nm_setting_get_name (setting);
char *mac;
struct ether_addr tmp;
g_return_if_fail (G_VALUE_HOLDS (value, DBUS_TYPE_G_UCHAR_ARRAY));
array = (GByteArray *) g_value_get_boxed (value);
if (!array)
return;
if (array->len != ETH_ALEN) {
nm_warning ("%s: invalid %s / %s MAC address length %d",
__func__, setting_name, key, array->len);
return;
}
memcpy (tmp.ether_addr_octet, array->data, ETH_ALEN);
mac = ether_ntoa (&tmp);
g_key_file_set_string (file, setting_name, key, mac);
}
static gboolean
check_message (GstMessage *message,
FsStream *stream,
const gchar *message_name)
{
const GstStructure *s;
const GValue *value;
FsStream *message_stream;
if (GST_MESSAGE_TYPE (message) != GST_MESSAGE_ELEMENT)
return FALSE;
s = gst_message_get_structure (message);
if (!gst_structure_has_name (s, message_name))
return FALSE;
value = gst_structure_get_value (s, "stream");
if (!value || !G_VALUE_HOLDS (value, FS_TYPE_STREAM))
return FALSE;
message_stream = g_value_get_object (value);
if (stream != message_stream)
return FALSE;
return TRUE;
}
static gint
_gvalues_compare_struct (const GValue *value1, const GValue *value2)
{
/* value1 and value2 must contain the same type since
* _gvalues_compare() enforced that already.
*/
if (G_VALUE_HOLDS (value1, DBUS_TYPE_G_IP6_ADDRESS)) {
return nm_gvalue_ip6_address_compare (value1, value2);
} else if (G_VALUE_HOLDS (value1, DBUS_TYPE_G_IP6_ROUTE)) {
return nm_gvalue_ip6_route_compare (value1, value2);
} else {
g_warning ("Don't know how to compare structures");
return (value1 == value2);
}
}
static void
set_property (GObject * object,
guint prop_id,
GValue const* value,
GParamSpec * pspec)
{
switch (prop_id)
{
case PROP_WORKSPACE:
/* FIXME: update to renames */
g_return_if_fail (!PRIV (object)->workspace);
g_return_if_fail (g_value_get_object (value));
g_return_if_fail (G_VALUE_HOLDS (value, WNCK_TYPE_WORKSPACE));
PRIV (object)->workspace = g_value_get_object (value);
gtk_label_set_text (GTK_LABEL (PRIV (object)->label),
wnck_workspace_get_name (PRIV (object)->workspace));
g_signal_connect (wnck_workspace_get_screen (PRIV (object)->workspace), "active-window-changed",
G_CALLBACK (active_window_changed), object);
g_signal_connect (wnck_workspace_get_screen (PRIV (object)->workspace), "window-closed",
G_CALLBACK (window_closed), object);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
update_one_secret (NMSetting *setting, const char *key, GValue *value, GError **error)
{
gboolean success = FALSE;
g_return_val_if_fail (key != NULL, FALSE);
g_return_val_if_fail (value != NULL, FALSE);
if (G_VALUE_HOLDS_STRING (value)) {
/* Passing the string properties individually isn't correct, and won't
* produce the correct result, but for some reason that's how it used
* to be done. So even though it's not correct, keep the code around
* for compatibility's sake.
*/
success = update_secret_string (setting, key, g_value_get_string (value), error);
} else if (G_VALUE_HOLDS (value, DBUS_TYPE_G_MAP_OF_STRING)) {
if (strcmp (key, NM_SETTING_VPN_SECRETS) != 0) {
g_set_error (error, NM_SETTING_ERROR, NM_SETTING_ERROR_PROPERTY_NOT_SECRET,
"Property %s not a secret property", key);
} else
success = update_secret_hash (setting, g_value_get_boxed (value), error);
} else
g_set_error_literal (error, NM_SETTING_ERROR, NM_SETTING_ERROR_PROPERTY_TYPE_MISMATCH, key);
if (success)
g_object_notify (G_OBJECT (setting), NM_SETTING_VPN_SECRETS);
return success;
}
static void
artwork_notify_cb (RhythmDB *db,
RhythmDBEntry *entry,
const char *property_name,
const GValue *metadata,
RBMtpSource *source)
{
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
GdkPixbuf *pixbuf;
const char *album_name;
album_name = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ALBUM);
/* check if we're looking for art for this entry, and if we actually got some */
if (g_hash_table_remove (priv->artwork_request_map, album_name) == FALSE)
return;
if (G_VALUE_HOLDS (metadata, GDK_TYPE_PIXBUF) == FALSE)
return;
pixbuf = GDK_PIXBUF (g_value_get_object (metadata));
rb_mtp_thread_set_album_image (priv->device_thread, album_name, pixbuf);
queue_free_space_update (source);
}
static gboolean
clutter_behaviour_path_parse_custom_node (ClutterScriptable *scriptable,
ClutterScript *script,
GValue *value,
const gchar *name,
JsonNode *node)
{
if (strcmp ("path", name) == 0)
{
ClutterPath *path;
GValue node_value = { 0 };
path = g_object_ref_sink (clutter_path_new ());
json_node_get_value (node, &node_value);
if (!G_VALUE_HOLDS (&node_value, G_TYPE_STRING)
|| !clutter_path_set_description (path,
g_value_get_string (&node_value)))
g_warning ("Invalid path description");
g_value_unset (&node_value);
g_value_init (value, G_TYPE_OBJECT);
g_value_take_object (value, path);
return TRUE;
}
/* chain up */
else if (parent_scriptable_iface->parse_custom_node)
return parent_scriptable_iface->parse_custom_node (scriptable, script,
value, name, node);
else
return FALSE;
}
static PyObject *
_wrap_value_array_get_nth_type(PyObject *self, PyObject *args)
{
guint n;
GType type;
GValue *nth;
GValueArray *arr;
PyObject *obj;
if (!PyArg_ParseTuple(args, "OI", &obj, &n))
return NULL;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (pyg_boxed_check(obj, G_TYPE_VALUE) &&
G_VALUE_HOLDS(pyg_boxed_get(obj, GValue), G_TYPE_VALUE_ARRAY)) {
arr = g_value_get_boxed(pyg_boxed_get(obj, GValue));
} else if (pyg_boxed_check(obj, G_TYPE_VALUE_ARRAY)) {
arr = pyg_boxed_get(obj, GValueArray);
} else {
PyErr_SetString(PyExc_TypeError, "First argument is not GValueArray");
return NULL;
}
if (n >= arr->n_values) {
PyErr_SetString(PyExc_TypeError, "Index is out of bounds");
return NULL;
}
nth = g_value_array_get_nth(arr, n);
type = G_VALUE_TYPE(nth);
G_GNUC_END_IGNORE_DEPRECATIONS
return pyg_type_wrapper_new(type);
}
gchar *
_gda_sqlite_render_CREATE_VIEW (G_GNUC_UNUSED GdaServerProvider *provider, GdaConnection *cnc,
GdaServerOperation *op, G_GNUC_UNUSED GError **error)
{
GString *string;
const GValue *value;
gboolean allok = TRUE;
gchar *sql = NULL;
gchar *tmp;
string = g_string_new ("CREATE ");
value = gda_server_operation_get_value_at (op, "/VIEW_DEF_P/VIEW_TEMP");
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, "TEMP ");
g_string_append (string, "VIEW ");
value = gda_server_operation_get_value_at (op, "/VIEW_DEF_P/VIEW_IFNOTEXISTS");
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, "IF NOT EXISTS ");
tmp = gda_connection_operation_get_sql_identifier_at (cnc, op, "/VIEW_DEF_P/VIEW_NAME", error);
if (!tmp) {
g_string_free (string, TRUE);
return NULL;
}
g_string_append (string, tmp);
g_free (tmp);
if (allok) {
value = gda_server_operation_get_value_at (op, "/VIEW_DEF_P/VIEW_DEF");
g_assert (value && G_VALUE_HOLDS (value, G_TYPE_STRING));
g_string_append (string, " AS ");
g_string_append (string, g_value_get_string (value));
}
if (allok) {
sql = string->str;
g_string_free (string, FALSE);
}
else {
sql = NULL;
g_string_free (string, TRUE);
}
return sql;
}
