/** * g_strdup_value_contents: * @value: #GValue which contents are to be described. * * Return a newly allocated string, which describes the contents of a * #GValue. The main purpose of this function is to describe #GValue * contents for debugging output, the way in which the contents are * described may change between different GLib versions. * * Returns: Newly allocated string. */ gchar* g_strdup_value_contents (const GValue *value) { const gchar *src; gchar *contents; g_return_val_if_fail (G_IS_VALUE (value), NULL); if (G_VALUE_HOLDS_STRING (value)) { src = g_value_get_string (value); if (!src) contents = g_strdup ("NULL"); else { gchar *s = g_strescape (src, NULL); contents = g_strdup_printf ("\"%s\"", s); g_free (s); } } else if (g_value_type_transformable (G_VALUE_TYPE (value), G_TYPE_STRING)) { GValue tmp_value = { 0, }; gchar *s; g_value_init (&tmp_value, G_TYPE_STRING); g_value_transform (value, &tmp_value); s = g_strescape (g_value_get_string (&tmp_value), NULL); g_value_unset (&tmp_value); if (G_VALUE_HOLDS_ENUM (value) || G_VALUE_HOLDS_FLAGS (value)) contents = g_strdup_printf ("((%s) %s)", g_type_name (G_VALUE_TYPE (value)), s); else contents = g_strdup (s ? s : "NULL"); g_free (s); } else if (g_value_fits_pointer (value)) { gpointer p = g_value_peek_pointer (value); if (!p) contents = g_strdup ("NULL"); else if (G_VALUE_HOLDS_OBJECT (value)) contents = g_strdup_printf ("((%s*) %p)", G_OBJECT_TYPE_NAME (p), p); else if (G_VALUE_HOLDS_PARAM (value)) contents = g_strdup_printf ("((%s*) %p)", G_PARAM_SPEC_TYPE_NAME (p), p); else if (G_VALUE_HOLDS (value, G_TYPE_STRV)) { GStrv strv = g_value_get_boxed (value); GString *tmp = g_string_new ("["); while (*strv != NULL) { gchar *escaped = g_strescape (*strv, NULL); g_string_append_printf (tmp, "\"%s\"", escaped); g_free (escaped); if (*++strv != NULL) g_string_append (tmp, ", "); } g_string_append (tmp, "]"); contents = g_string_free (tmp, FALSE); } else if (G_VALUE_HOLDS_BOXED (value)) contents = g_strdup_printf ("((%s*) %p)", g_type_name (G_VALUE_TYPE (value)), p); else if (G_VALUE_HOLDS_POINTER (value)) contents = g_strdup_printf ("((gpointer) %p)", p); else contents = g_strdup ("???"); } else contents = g_strdup ("???"); return contents; }
static GimpValueArray * image_convert_indexed_invoker (GimpProcedure *procedure, Gimp *gimp, GimpContext *context, GimpProgress *progress, const GimpValueArray *args, GError **error) { gboolean success = TRUE; GimpImage *image; gint32 dither_type; gint32 palette_type; gint32 num_cols; gboolean alpha_dither; gboolean remove_unused; const gchar *palette; image = gimp_value_get_image (gimp_value_array_index (args, 0), gimp); dither_type = g_value_get_enum (gimp_value_array_index (args, 1)); palette_type = g_value_get_enum (gimp_value_array_index (args, 2)); num_cols = g_value_get_int (gimp_value_array_index (args, 3)); alpha_dither = g_value_get_boolean (gimp_value_array_index (args, 4)); remove_unused = g_value_get_boolean (gimp_value_array_index (args, 5)); palette = g_value_get_string (gimp_value_array_index (args, 6)); if (success) { GimpPalette *pal = NULL; if (gimp_pdb_image_is_not_base_type (image, GIMP_INDEXED, error) && gimp_pdb_image_is_precision (image, GIMP_PRECISION_U8_GAMMA, error) && gimp_item_stack_is_flat (GIMP_ITEM_STACK (gimp_image_get_layers (image)))) { switch (palette_type) { case GIMP_MAKE_PALETTE: if (num_cols < 1 || num_cols > MAXNUMCOLORS) success = FALSE; break; case GIMP_CUSTOM_PALETTE: pal = gimp_pdb_get_palette (gimp, palette, FALSE, error); if (! pal) { success = FALSE; } else if (pal->n_colors > MAXNUMCOLORS) { g_set_error_literal (error, GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT, _("Cannot convert to a palette " "with more than 256 colors.")); success = FALSE; } break; default: break; } } else { success = FALSE; } if (success) success = gimp_image_convert_type (image, GIMP_INDEXED, num_cols, dither_type, alpha_dither, FALSE, remove_unused, palette_type, pal, NULL, error); } return gimp_procedure_get_return_values (procedure, success, error ? *error : NULL); }
orcaData orcaGtk::ex_get_data(orcaVM* vm, int n)/*{{{*/ { if (n < 1) vm->need_param(); orcaData key = vm->get_param(0); if (type == GUI_LIST || type == GUI_TREE) { if (is<TYPE_INT>(key)) { int nth = key.Integer(); GtkTreeIter iter; gtk_tree_model_get_iter_first(store, &iter); for (int i=0; i<nth; i++) { if (!gtk_tree_model_iter_next(store, &iter)) throw orcaException(vm, "orca.index", "out of index"); } orcaList* lp = new orcaList(); int width = gtk_tree_model_get_n_columns(store); for (int i=0; i<width; i++) { GValue value = { 0, }; gtk_tree_model_get_value(store, &iter, i, &value); GType t = value.g_type; if (t == G_TYPE_STRING) { char* cp = (char*)g_value_get_string(&value); if (cp == NULL) cp = (char*)""; lp->push_back(cp); } else if (t == G_TYPE_BOOLEAN) { bool r = g_value_get_boolean(&value); lp->push_back(r); } else { lp->push_back(NIL); } g_value_unset(&value); } return lp; } string str = key.String(); if (str == "begin") { orcaGtkIter* bp = new orcaGtkIter(); bp->m_gp = this; gtk_tree_model_get_iter_first(store, &bp->m_iter); if (type == GUI_LIST) bp->m_type = GUI_LIST; else bp->m_type = GUI_TREE; return bp; } else if (type == GUI_TREE && str == "branch") { orcaTuple* path = castobj<orcaTuple>(vm->get_param(1)); if (path == NULL) { return NIL; } orcaGtkIter* bp = new orcaGtkIter(); bp->m_gp = this; bp->m_type = GUI_TREE; GtkTreeIter iter; GtkTreeIter parent; for (int i=0; i<path->size(); i++) { if (i==0) { gtk_tree_model_get_iter_first(store, &iter); for (int j=0; j<path->at(0).Integer(); j++) { if (!gtk_tree_model_iter_next(store, &iter)) throw orcaException(vm, "orca.index", "out of index"); } parent = iter; bp->m_iter = iter; continue; } if (!gtk_tree_model_iter_nth_child(store, &iter, &parent, path->at(i).Integer())) throw orcaException(vm, "orca.index", "out of index"); parent = iter; bp->m_iter = iter; } return bp; } } else if (type == GUI_ENTRY) { if (key.String() == "text") { char* p = gtk_editable_get_chars(GTK_EDITABLE(handle), 0, -1); return p; } } else if (type == GUI_TEXT) { if (key.String() == "text") { GtkTextIter start_iter, end_iter; GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(handle)); gtk_text_buffer_get_start_iter(buffer, &start_iter); gtk_text_buffer_get_end_iter(buffer, &end_iter); char* p = gtk_text_buffer_get_text(buffer, &start_iter, &end_iter, FALSE); return p; } } return NIL; }
GList * lgm_device_enum_devices (const gchar * source_name, LgmDeviceType type) { GstElement *source; GstPropertyProbe *probe; GValueArray *va; const gchar *prop_name; GList *list = NULL; guint i = 0; source = gst_element_factory_make (source_name, "source"); if (!source || !GST_IS_PROPERTY_PROBE (source)) goto finish; gst_element_set_state (source, GST_STATE_READY); gst_element_get_state (source, NULL, NULL, 5 * GST_SECOND); probe = GST_PROPERTY_PROBE (source); prop_name = lgm_device_get_property_name_for_source (source_name); va = gst_property_probe_probe_and_get_values_name (probe, prop_name); gst_element_set_state (source, GST_STATE_NULL); gst_element_get_state (source, NULL, NULL, 5 * GST_SECOND); gst_object_unref (source); if (!va) goto finish; for (i = 0; i < va->n_values; ++i) { GValue *v = g_value_array_get_nth (va, i); GValue valstr = { 0, }; LgmDevice *device; gchar *name; g_value_init (&valstr, G_TYPE_STRING); if (!g_value_transform (v, &valstr)) continue; /* Skip blackmagic on avfvideosrc as we only properly support them * through decklinkvideosrc. */ if (!g_strcmp0 (source_name, "avfvideosrc")) if (!g_strcmp0 (g_value_get_string (&valstr), "Blackmagic")) continue; /* Use the pattern "Blackmagic%d" for device name when decklinkvideosrc */ if (!g_strcmp0 (source_name, "decklinkvideosrc")) name = g_strdup_printf ("Blackmagic%s", g_value_get_string (&valstr)); else name = g_value_dup_string (&valstr); device = lgm_device_new (source_name, name, type); g_value_unset (&valstr); g_free (name); lgm_device_fill_formats (device, prop_name); list = g_list_append (list, device); } g_value_array_free (va); finish: { return list; } }
static void nautilus_column_set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec) { NautilusColumn *column; column = NAUTILUS_COLUMN (object); switch (param_id) { case PROP_NAME: { g_free (column->details->name); column->details->name = g_strdup (g_value_get_string (value)); g_object_notify (object, "name"); } break; case PROP_ATTRIBUTE: { column->details->attribute = g_quark_from_string (g_value_get_string (value)); g_object_notify (object, "attribute"); g_object_notify (object, "attribute_q"); } break; case PROP_LABEL: { g_free (column->details->label); column->details->label = g_strdup (g_value_get_string (value)); g_object_notify (object, "label"); } break; case PROP_DESCRIPTION: { g_free (column->details->description); column->details->description = g_strdup (g_value_get_string (value)); g_object_notify (object, "description"); } break; case PROP_XALIGN: { column->details->xalign = g_value_get_float (value); g_object_notify (object, "xalign"); } break; case PROP_DEFAULT_SORT_ORDER: { column->details->default_sort_order = g_value_get_enum (value); g_object_notify (object, "default-sort-order"); } break; default: { G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec); } break; } }
static void delete_selection (DialogTab *tab) { EphyPermissionsDialog *dialog = tab->dialog; EphyPermissionsDialogPrivate *priv = dialog->priv; EphyPermissionManager *manager = priv->manager; GtkTreeModel *model = tab->model; GtkTreeSelection *selection = tab->selection; GList *llist, *rlist = NULL, *l, *r; GtkTreePath *path; GtkTreeIter iter, iter2; GtkTreeRowReference *row_ref = NULL; llist = gtk_tree_selection_get_selected_rows (selection, &model); if (llist == NULL) { /* nothing to delete, return early */ return; } for (l = llist;l != NULL; l = l->next) { rlist = g_list_prepend (rlist, gtk_tree_row_reference_new (model, (GtkTreePath *)l->data)); } /* Intelligent selection logic, no actual selection yet */ path = gtk_tree_row_reference_get_path ((GtkTreeRowReference *) g_list_first (rlist)->data); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_path_free (path); iter2 = iter; if (gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter)) { path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); row_ref = gtk_tree_row_reference_new (model, path); } else { path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter2); if (gtk_tree_path_prev (path)) { row_ref = gtk_tree_row_reference_new (model, path); } } gtk_tree_path_free (path); /* Removal */ for (r = rlist; r != NULL; r = r->next) { GValue val = { 0, }; path = gtk_tree_row_reference_get_path ((GtkTreeRowReference *)r->data); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get_value (model, &iter, COL_HOST, &val); ephy_permission_manager_remove_permission (manager, g_value_get_string (&val), tab->type); g_value_unset (&val); gtk_tree_row_reference_free ((GtkTreeRowReference *)r->data); gtk_tree_path_free (path); } g_list_foreach (llist, (GFunc)gtk_tree_path_free, NULL); g_list_free (llist); g_list_free (rlist); /* Selection */ if (row_ref != NULL) { path = gtk_tree_row_reference_get_path (row_ref); if (path != NULL) { gtk_tree_view_set_cursor (GTK_TREE_VIEW (tab->treeview), path, NULL, FALSE); gtk_tree_path_free (path); } gtk_tree_row_reference_free (row_ref); } }
static void write_setting_value (NMSetting *setting, const char *key, const GValue *value, GParamFlags flag, gpointer user_data) { WriteInfo *info = user_data; const char *setting_name; GType type = G_VALUE_TYPE (value); KeyWriter *writer = &key_writers[0]; GParamSpec *pspec; /* Setting name gets picked up from the keyfile's section name instead */ if (!strcmp (key, NM_SETTING_NAME)) return; /* Don't write the NMSettingConnection object's 'read-only' property */ if ( NM_IS_SETTING_CONNECTION (setting) && !strcmp (key, NM_SETTING_CONNECTION_READ_ONLY)) return; setting_name = nm_setting_get_name (setting); /* If the value is the default value, remove the item from the keyfile */ pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (setting), key); if (pspec) { if (g_param_value_defaults (pspec, (GValue *) value)) { g_key_file_remove_key (info->keyfile, setting_name, key, NULL); return; } } /* Don't write secrets that are owned by user secret agents or aren't * supposed to be saved. VPN secrets are handled specially though since * the secret flags there are in a third-level hash in the 'secrets' * property. */ if (pspec->flags & NM_SETTING_PARAM_SECRET && !NM_IS_SETTING_VPN (setting)) { NMSettingSecretFlags secret_flags = NM_SETTING_SECRET_FLAG_NONE; nm_setting_get_secret_flags (setting, key, &secret_flags, NULL); if (secret_flags != NM_SETTING_SECRET_FLAG_NONE) return; } /* Look through the list of handlers for non-standard format key values */ while (writer->setting_name) { if (!strcmp (writer->setting_name, setting_name) && !strcmp (writer->key, key)) { (*writer->writer) (info->keyfile, info->keyfile_dir, info->uuid, setting, key, value); return; } writer++; } if (type == G_TYPE_STRING) { const char *str; str = g_value_get_string (value); if (str) g_key_file_set_string (info->keyfile, setting_name, key, str); } else if (type == G_TYPE_UINT) g_key_file_set_integer (info->keyfile, setting_name, key, (int) g_value_get_uint (value)); else if (type == G_TYPE_INT) g_key_file_set_integer (info->keyfile, setting_name, key, g_value_get_int (value)); else if (type == G_TYPE_UINT64) { char *numstr; numstr = g_strdup_printf ("%" G_GUINT64_FORMAT, g_value_get_uint64 (value)); g_key_file_set_value (info->keyfile, setting_name, key, numstr); g_free (numstr); } else if (type == G_TYPE_BOOLEAN) { g_key_file_set_boolean (info->keyfile, setting_name, key, g_value_get_boolean (value)); } else if (type == G_TYPE_CHAR) { g_key_file_set_integer (info->keyfile, setting_name, key, (int) g_value_get_char (value)); } else if (type == DBUS_TYPE_G_UCHAR_ARRAY) { GByteArray *array; array = (GByteArray *) g_value_get_boxed (value); if (array && array->len > 0) { int *tmp_array; int i; tmp_array = g_new (gint, array->len); for (i = 0; i < array->len; i++) tmp_array[i] = (int) array->data[i]; g_key_file_set_integer_list (info->keyfile, setting_name, key, tmp_array, array->len); g_free (tmp_array); } } else if (type == DBUS_TYPE_G_LIST_OF_STRING) { GSList *list; GSList *iter; list = (GSList *) g_value_get_boxed (value); if (list) { char **array; int i = 0; array = g_new (char *, g_slist_length (list)); for (iter = list; iter; iter = iter->next) array[i++] = iter->data; g_key_file_set_string_list (info->keyfile, setting_name, key, (const gchar **const) array, i); g_free (array); } } else if (type == DBUS_TYPE_G_MAP_OF_STRING) {
static GObject * g_local_directory_monitor_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_properties) { GObject *obj; GLocalDirectoryMonitorClass *klass; GObjectClass *parent_class; GLocalDirectoryMonitor *local_monitor; GFileMonitorFlags flags = 0; const gchar *dirname = NULL; gint i; klass = G_LOCAL_DIRECTORY_MONITOR_CLASS (g_type_class_peek (G_TYPE_LOCAL_DIRECTORY_MONITOR)); parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass)); obj = parent_class->constructor (type, n_construct_properties, construct_properties); local_monitor = G_LOCAL_DIRECTORY_MONITOR (obj); for (i = 0; i < n_construct_properties; i++) { if (strcmp ("dirname", g_param_spec_get_name (construct_properties[i].pspec)) == 0) { g_warn_if_fail (G_VALUE_HOLDS_STRING (construct_properties[i].value)); dirname = g_value_get_string (construct_properties[i].value); } if (strcmp ("flags", g_param_spec_get_name (construct_properties[i].pspec)) == 0) { g_warn_if_fail (G_VALUE_HOLDS_FLAGS (construct_properties[i].value)); flags = g_value_get_flags (construct_properties[i].value); } } local_monitor->dirname = g_strdup (dirname); local_monitor->flags = flags; if (!klass->mount_notify && (flags & G_FILE_MONITOR_WATCH_MOUNTS)) { #ifdef G_OS_WIN32 /*claim everything was mounted */ local_monitor->was_mounted = TRUE; #else GUnixMountEntry *mount; /* Emulate unmount detection */ mount = g_unix_mount_at (local_monitor->dirname, NULL); local_monitor->was_mounted = mount != NULL; if (mount) g_unix_mount_free (mount); local_monitor->mount_monitor = g_unix_mount_monitor_new (); g_signal_connect_object (local_monitor->mount_monitor, "mounts-changed", G_CALLBACK (mounts_changed), local_monitor, 0); #endif } return obj; }
static void check_pad_template (GstPadTemplate * tmpl) { const GValue *list_val, *fmt_val; GstStructure *s; gboolean *formats_supported; GstCaps *caps; guint i, num_formats; num_formats = get_num_formats (); formats_supported = g_new0 (gboolean, num_formats); caps = gst_pad_template_get_caps (tmpl); /* If this fails, we need to update this unit test */ fail_unless_equals_int (gst_caps_get_size (caps), 2); /* Remove the ANY caps features structure */ caps = gst_caps_truncate (caps); s = gst_caps_get_structure (caps, 0); fail_unless (gst_structure_has_name (s, "video/x-raw")); list_val = gst_structure_get_value (s, "format"); fail_unless (list_val != NULL); /* If this fails, we need to update this unit test */ fail_unless (GST_VALUE_HOLDS_LIST (list_val)); for (i = 0; i < gst_value_list_get_size (list_val); ++i) { GstVideoFormat fmt; const gchar *fmt_str; fmt_val = gst_value_list_get_value (list_val, i); fail_unless (G_VALUE_HOLDS_STRING (fmt_val)); fmt_str = g_value_get_string (fmt_val); GST_LOG ("format string: '%s'", fmt_str); fmt = gst_video_format_from_string (fmt_str); if (fmt == GST_VIDEO_FORMAT_UNKNOWN) g_error ("Unknown raw format '%s' in pad template caps", fmt_str); formats_supported[(guint) fmt] = TRUE; } gst_caps_unref (caps); for (i = 2; i < num_formats; ++i) { if (!formats_supported[i]) { const gchar *fmt_str = gst_video_format_to_string ((GstVideoFormat) i); switch (i) { case GST_VIDEO_FORMAT_v210: case GST_VIDEO_FORMAT_v216: case GST_VIDEO_FORMAT_NV12: case GST_VIDEO_FORMAT_NV16: case GST_VIDEO_FORMAT_NV21: case GST_VIDEO_FORMAT_NV24: case GST_VIDEO_FORMAT_UYVP: case GST_VIDEO_FORMAT_A420: case GST_VIDEO_FORMAT_YUV9: case GST_VIDEO_FORMAT_YVU9: case GST_VIDEO_FORMAT_IYU1: case GST_VIDEO_FORMAT_r210:{ static gboolean shown_fixme[100] = { FALSE, }; if (!shown_fixme[i]) { GST_FIXME ("FIXME: add %s support to videoscale", fmt_str); shown_fixme[i] = TRUE; } break; } case GST_VIDEO_FORMAT_BGR16: case GST_VIDEO_FORMAT_BGR15: case GST_VIDEO_FORMAT_RGB8P: case GST_VIDEO_FORMAT_I420_10BE: case GST_VIDEO_FORMAT_I420_10LE: case GST_VIDEO_FORMAT_I422_10BE: case GST_VIDEO_FORMAT_I422_10LE: case GST_VIDEO_FORMAT_Y444_10BE: case GST_VIDEO_FORMAT_Y444_10LE: case GST_VIDEO_FORMAT_GBR: case GST_VIDEO_FORMAT_GBR_10BE: case GST_VIDEO_FORMAT_GBR_10LE: GST_LOG ("Ignoring lack of support for format %s", fmt_str); break; default: g_error ("videoscale doesn't support format '%s'", fmt_str); break; } } } g_free (formats_supported); }
static void inf_tcp_connection_set_property(GObject* object, guint prop_id, const GValue* value, GParamSpec* pspec) { InfTcpConnection* connection; InfTcpConnectionPrivate* priv; #ifndef G_OS_WIN32 const gchar* device_string; unsigned int new_index; #endif GError* error; connection = INF_TCP_CONNECTION(object); priv = INF_TCP_CONNECTION_PRIVATE(connection); switch(prop_id) { case PROP_IO: g_assert(priv->status == INF_TCP_CONNECTION_CLOSED); if(priv->io != NULL) g_object_unref(G_OBJECT(priv->io)); priv->io = INF_IO(g_value_dup_object(value)); break; case PROP_RESOLVER: g_assert(priv->status == INF_TCP_CONNECTION_CLOSED); inf_tcp_connection_set_resolver( connection, INF_NAME_RESOLVER(g_value_get_object(value)) ); break; case PROP_KEEPALIVE: error = NULL; inf_tcp_connection_set_keepalive( connection, (InfKeepalive*)g_value_get_boxed(value), &error ); if(error != NULL) { g_warning("Failed to set keepalive settings: %s\n", error->message); g_error_free(error); } break; case PROP_REMOTE_ADDRESS: g_assert(priv->status == INF_TCP_CONNECTION_CLOSED); if(priv->remote_address != NULL) inf_ip_address_free(priv->remote_address); priv->remote_address = (InfIpAddress*)g_value_dup_boxed(value); break; case PROP_REMOTE_PORT: g_assert(priv->status == INF_TCP_CONNECTION_CLOSED); priv->remote_port = g_value_get_uint(value); break; case PROP_DEVICE_INDEX: g_assert(priv->status == INF_TCP_CONNECTION_CLOSED); /* TODO: Verify that such a device exists */ priv->device_index = g_value_get_uint(value); g_object_notify(G_OBJECT(object), "device-name"); break; case PROP_DEVICE_NAME: #ifdef G_OS_WIN32 /* TODO: We can probably implement this using GetInterfaceInfo() */ g_warning("The device-name property is not implemented on Win32"); #else g_assert(priv->status == INF_TCP_CONNECTION_CLOSED); device_string = g_value_get_string(value); if(device_string == NULL) priv->device_index = 0; new_index = if_nametoindex(device_string); if(new_index == 0) { g_warning(_("Interface `%s' does not exist"), device_string); } else { priv->device_index = new_index; g_object_notify(G_OBJECT(object), "device-index"); } #endif break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }
void test_didl_item_cb(GUPnPDIDLLiteParser* parser, GUPnPDIDLLiteObject* didlobject, gpointer user_data) { GList *resources; GUPnPDIDLLiteResource* res_node; gchar* value; gint type; gint num; GHashTable *mdata = mafw_metadata_new(); GValue *val; gboolean is_audio, is_supported = FALSE; MafwUPnPSource* source; fail_if(didlobject == NULL, "GUPnP is %s", "broken"); source = MAFW_UPNP_SOURCE(mafw_upnp_source_new("name", "uuid")); g_assert(source != NULL); value= util_create_objectid(source, didlobject); fail_unless(strcmp(value, "uuid::18132") == 0, "Wrong object ID"); g_free(value); g_object_unref(source); /* Protocol info stuff */ resources = didl_get_supported_resources(didlobject); fail_if(resources == NULL || resources->data == NULL, "Unable to get a resource node"); fail_if(g_list_length(resources) != 1, "Resource list not correct"); res_node = resources->data; /* Properties */ is_audio = didl_check_filetype(didlobject, &is_supported); fail_if(is_audio == FALSE, "Item should be audio"); fail_if(is_supported == FALSE, "Item should be supported"); didl_get_mimetype(mdata, FALSE, TRUE, resources); val = mafw_metadata_first(mdata, MAFW_METADATA_KEY_MIME); fail_if(val == NULL); fail_if(strcmp(g_value_get_string(val), "audio/mpeg") != 0, "Wrong MIME: %s", value); didl_get_http_res_uri(mdata, resources, TRUE); val = mafw_metadata_first(mdata, MAFW_METADATA_KEY_URI); fail_if(strcmp(g_value_get_string(val), "http://172.23.117.242:9000/disk/music/O18132.mp3") != 0, "Wrong URI: %s", g_value_get_string(val)); /* Fallbacks */ type = 0; value = didl_fallback(didlobject, res_node, 7, &type); fail_if(strcmp(value, "http://foo.bar.com:31337/lyrics.txt") != 0, "Wrong lyrics URI: %s", value); fail_if(type != G_TYPE_STRING, "Wrong type"); g_free(value); type = 0; value = didl_fallback(didlobject, res_node, 9, &type); fail_if(strcmp(value, "http://foo.bar.com:31337/albumArt.png") != 0, "Wrong small album art URI: %s", value); fail_if(type != G_TYPE_STRING, "Wrong type"); g_free(value); type = 0; value = didl_fallback(didlobject, res_node, 10, &type); fail_if(strcmp(value, "http://foo.bar.com:31337/albumArt.png") != 0, "Wrong medium album art URI: %s", value); fail_if(type != G_TYPE_STRING, "Wrong type"); g_free(value); type = 0; value = didl_fallback(didlobject, res_node, 11, &type); fail_if(strcmp(value, "http://foo.bar.com:31337/albumArt.png") != 0, "Wrong large album art URI: %s", value); fail_if(type != G_TYPE_STRING, "Wrong type"); g_free(value); type = 0; value = didl_fallback(didlobject, res_node, 12, &type); fail_if(strcmp(value, "http://foo.bar.com:31337/disco.html") != 0, "Wrong artist info URI: %s", value); fail_if(type != G_TYPE_STRING, "Wrong type"); g_free(value); type = 0; value = didl_fallback(didlobject, res_node, 13, &type); fail_if(strcmp(value, "31337") != 0, "Wrong audio bitrate: %s", value); fail_if(type != G_TYPE_INT, "Wrong type"); g_free(value); type = 0; value = didl_fallback(didlobject, res_node, 14, &type); fail_if(strcmp(value, "31337") != 0, "Wrong video bitrate: %s", value); fail_if(type != G_TYPE_INT, "Wrong type"); g_free(value); type = 0; value = didl_fallback(didlobject, res_node, 17, &type); fail_if(strcmp(value, "32") != 0, "Wrong BPP: %s", value); fail_if(type != G_TYPE_INT, "Wrong type"); g_free(value); }
gboolean __query_select_add_joins (MidgardQuerySelect *self, GdaSqlOperation *operation, GError **error) { __add_implicit_workspace_join (self, operation); if (!MIDGARD_QUERY_EXECUTOR (self)->priv->joins) return TRUE; GSList *l = NULL; MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR (self); GdaSqlStatement *sql_stm = executor->priv->stmt; GdaSqlStatementSelect *select = (GdaSqlStatementSelect *) sql_stm->contents; GdaSqlSelectFrom *from = select->from; GdaSqlSelectJoin *join; for (l = MIDGARD_QUERY_EXECUTOR (self)->priv->joins; l != NULL; l = l->next) { qsj *_sj = (qsj*) l->data; join = gda_sql_select_join_new (GDA_SQL_ANY_PART (from)); join->type = _sj->join_type; MidgardQueryStorage *left_storage = _sj->left_property->priv->storage; MidgardQueryStorage *right_storage = _sj->right_property->priv->storage; GError *err = NULL; GValue lval = {0, }; midgard_query_holder_get_value (MIDGARD_QUERY_HOLDER (_sj->left_property), &lval); gchar *left_table_field = midgard_core_query_compute_constraint_property (executor, left_storage, g_value_get_string (&lval), &err); if (err) { g_propagate_error (error, err); g_free (left_table_field); } GValue rval = {0, }; midgard_query_holder_get_value (MIDGARD_QUERY_HOLDER (_sj->right_property), &rval); gchar *right_table_field = midgard_core_query_compute_constraint_property (executor, right_storage, g_value_get_string (&rval), &err); if (err) { g_propagate_error (error, err); g_free (right_table_field); } GdaSqlExpr *expr = gda_sql_expr_new (GDA_SQL_ANY_PART (join)); expr->value = gda_value_new (G_TYPE_STRING); g_value_take_string (expr->value, g_strdup_printf ("%s = %s", left_table_field, right_table_field)); join->expr = expr; join->position = ++executor->priv->joinid; /* Add right storage to targets */ MQE_SET_TABLE_ALIAS (executor, right_storage); gda_sql_select_from_take_new_join (from , join); GdaSqlSelectTarget *s_target = gda_sql_select_target_new (GDA_SQL_ANY_PART (from)); s_target->table_name = g_strdup (right_storage->priv->table); s_target->as = g_strdup (right_storage->priv->table_alias); gda_sql_select_from_take_new_target (from, s_target); // Set target expression GdaSqlExpr *texpr = gda_sql_expr_new (GDA_SQL_ANY_PART (s_target)); GValue *tval = g_new0 (GValue, 1); g_value_init (tval, G_TYPE_STRING); g_value_set_string (tval, right_storage->priv->table); texpr->value = tval; s_target->expr = texpr; } return TRUE; }
static void gst_netfilter_set_property(GObject *object, guint prop_id, GValue const *value, GParamSpec *pspec) { GstNetfilter *netfilter; GST_OBJECT_LOCK(object); netfilter = GST_NETFILTER(object); switch (prop_id) { case PROP_FILTER_ADDRESS: { /* The address can be specified in many ways, as hostname, as IPv4 address, as IPv6 address.. getaddrinfo is used to get an IP address out of what has been specified */ int error; struct addrinfo *result; char const *address_str; address_str = g_value_get_string(value); error = getaddrinfo(address_str, NULL, NULL, &result); if (error != 0) { GST_ERROR_OBJECT(netfilter, "Could not set filter address property: %s", gai_strerror(error)); } else { switch (result->ai_family) { case AF_INET: { struct sockaddr_in const *sockaddr_ipv4 = (struct sockaddr_in const *)(result->ai_addr); struct in_addr const *addr = &(sockaddr_ipv4->sin_addr); gst_netaddress_set_ip4_address(&(netfilter->filter_address), addr->s_addr, DUMMY_PORT); break; } case AF_INET6: { struct sockaddr_in6 const *sockaddr_ipv6 = (struct sockaddr_in6 const *)(result->ai_addr); struct in6_addr const *addr = &(sockaddr_ipv6->sin6_addr); gst_netaddress_set_ip6_address(&(netfilter->filter_address), (guint8 *)(addr->s6_addr), DUMMY_PORT); break; } default: GST_ERROR_OBJECT(netfilter, "Could not set filter address property: unknown address family %d", result->ai_family); } } freeaddrinfo(result); break; } case PROP_ENABLED: { netfilter->filtering_enabled = g_value_get_boolean(value); GST_DEBUG_OBJECT(netfilter, "Filtering is %s", netfilter->filtering_enabled ? "enabled" : "disabled"); break; } default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } GST_OBJECT_UNLOCK(object); }
/** * midgard_object_set_parameter: * @self: #MidgardObject instance * @domain: parameter's domain string * @name: parameter's name string * @value: a GValue value which should be set for domain&name pair * * Creates object's parameter object if it doesn't exists, updates otherwise. * * Returns: %TRUE on success, %FALSE otherwise */ gboolean midgard_object_set_parameter (MidgardObject *self, const gchar *domain, const gchar *name, GValue *value) { g_return_val_if_fail (self != NULL, FALSE); if(!__is_guid_valid(self)) return FALSE; MidgardObject *param; const gchar *value_string = g_value_get_string(value); gboolean delete_parameter = FALSE; gboolean do_return_true = FALSE; if(g_str_equal(value_string, "")) delete_parameter = TRUE; const GValue *get_value = midgard_object_get_parameter(self, domain, name); MidgardCollector *domain_collector = __get_parameters_collector(self, domain); if(!domain_collector) { domain_collector = __create_domain_collector(MGD_OBJECT_CNC (self), domain); __register_domain_collector(self, domain, domain_collector); } /* This is the case when set_parameter is invoked * before any get_parameter */ if(get_value == NULL && delete_parameter) { MIDGARD_ERRNO_SET(MGD_OBJECT_CNC (self), MGD_ERR_NOT_EXISTS); return FALSE; } /* Parameter doesn't exist. We have to create it */ if(get_value == NULL && !delete_parameter){ param = midgard_object_new(MGD_OBJECT_CNC (self), "midgard_parameter", NULL); g_object_set(param, "domain", domain, "name", name, "parentguid", MGD_OBJECT_GUID (self), NULL); g_object_set_property(G_OBJECT(param), "value", value); if(midgard_object_create(param)) { if(domain_collector) { if(!midgard_collector_set(domain_collector, name, "value", value)){ g_warning("Failed to update parameter's cache"); } } g_object_unref(param); return TRUE; } else { /* Error should be already set by create */ g_object_unref(param); return FALSE; } /* Parameter exists. if value is '' we delete it. * In any other case we update it */ } else { MidgardQueryBuilder *builder = midgard_query_builder_new(MGD_OBJECT_CNC (self), "midgard_parameter"); GValue gval = {0,}; g_value_init(&gval, G_TYPE_STRING); g_value_set_string(&gval, MGD_OBJECT_GUID (self)); midgard_query_builder_add_constraint(builder, "parentguid", "=", &gval); g_value_unset(&gval); g_value_init(&gval, G_TYPE_STRING); g_value_set_string(&gval, domain); midgard_query_builder_add_constraint(builder, "domain", "=", &gval); g_value_unset(&gval); g_value_init(&gval, G_TYPE_STRING); g_value_set_string(&gval, name); midgard_query_builder_add_constraint(builder, "name", "=", &gval); g_value_unset(&gval); guint n_objects; GObject **ret_object = midgard_query_builder_execute(builder, &n_objects); g_object_unref(builder); if(!ret_object){ return FALSE; } if(delete_parameter){ if(midgard_object_delete( MIDGARD_OBJECT(ret_object[0]), FALSE)) { midgard_collector_remove_key( domain_collector, name); do_return_true = TRUE; } } else { g_object_set(ret_object[0], "value", value_string, NULL); if(midgard_object_update( MIDGARD_OBJECT(ret_object[0]))) { if(domain_collector) { midgard_collector_set(domain_collector, name, "value", value); } do_return_true = TRUE; } } g_object_unref(ret_object[0]); g_free(ret_object); if(do_return_true) return TRUE; } return FALSE; }
static void modem_get_all_cb (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data) { PluginInfo *info = user_data; const char *path; GHashTable *properties = NULL; GError *error = NULL; GValue *value; BMDeviceType devtype = BM_DEVICE_TYPE_UNKNOWN; path = dbus_g_proxy_get_path (proxy); g_message ("%s: (%s) processing GetAll reply", __func__, path); if (!dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_MAP_OF_VARIANT, &properties, G_TYPE_INVALID)) { g_warning ("%s: (%s) Error getting modem properties: (%d) %s", __func__, path, error ? error->code : -1, (error && error->message) ? error->message : "(unknown)"); g_error_free (error); goto out; } /* check whether this is the device we care about */ value = g_hash_table_lookup (properties, "Device"); if (value && G_VALUE_HOLDS_STRING (value) && g_value_get_string (value)) { char *iface_basename = g_path_get_basename (info->rfcomm_iface); const char *modem_iface = g_value_get_string (value); if (!strcmp (iface_basename, modem_iface)) { /* yay, found it! */ value = g_hash_table_lookup (properties, "Type"); if (value && G_VALUE_HOLDS_UINT (value)) { switch (g_value_get_uint (value)) { case 1: devtype = BM_DEVICE_TYPE_GSM; break; case 2: devtype = BM_DEVICE_TYPE_CDMA; break; default: g_message ("%s: (%s) unknown modem type", __func__, path); break; } } } else { g_message ("%s: (%s) (%s) not the modem we're looking for (%s)", __func__, path, modem_iface, iface_basename); } g_free (iface_basename); } else g_message ("%s: (%s) modem had no 'Device' property", __func__, path); g_hash_table_unref (properties); if (devtype != BM_DEVICE_TYPE_UNKNOWN) { GtkWidget *parent; if (info->wizard) { g_message ("%s: (%s) oops! not starting Wizard as one is already in progress", __func__, path); goto out; } g_message ("%s: (%s) starting the mobile wizard", __func__, path); g_source_remove (info->dun_timeout_id); info->dun_timeout_id = 0; parent = gtk_widget_get_toplevel (info->hbox); #if GTK_CHECK_VERSION(2,18,0) if (gtk_widget_is_toplevel (parent)) { #else if (GTK_WIDGET_TOPLEVEL (parent)) { #endif info->window_group = gtk_window_group_new (); gtk_window_group_add_window (info->window_group, GTK_WINDOW (parent)); } else { parent = NULL; info->window_group = NULL; } /* Start the mobile wizard */ info->wizard = mobile_wizard_new (parent ? GTK_WINDOW (parent) : NULL, info->window_group, devtype, FALSE, wizard_done_cb, info); mobile_wizard_present (info->wizard); } out: g_message ("%s: finished", __func__); } static void modem_added (DBusGProxy *proxy, const char *path, gpointer user_data) { PluginInfo *info = user_data; DBusGProxy *props_proxy; g_return_if_fail (path != NULL); g_message ("%s: (%s) modem found", __func__, path); /* Create a proxy for the modem and get its properties */ props_proxy = dbus_g_proxy_new_for_name (info->bus, MM_SERVICE, path, "org.freedesktop.DBus.Properties"); g_assert (proxy); info->modem_proxies = g_slist_append (info->modem_proxies, props_proxy); g_message ("%s: (%s) calling GetAll...", __func__, path); dbus_g_proxy_begin_call (props_proxy, "GetAll", modem_get_all_cb, info, NULL, G_TYPE_STRING, MM_MODEM_INTERFACE, G_TYPE_INVALID); }
void ags_add_effect_set_property(GObject *gobject, guint prop_id, const GValue *value, GParamSpec *param_spec) { AgsAddEffect *add_effect; add_effect = AGS_ADD_EFFECT(gobject); switch(prop_id){ case PROP_CHANNEL: { AgsChannel *channel; channel = (AgsChannel *) g_value_get_object(value); if(add_effect->channel == channel){ return; } if(add_effect->channel != NULL){ g_object_unref(add_effect->channel); } if(channel != NULL){ g_object_ref(channel); } add_effect->channel = channel; } break; case PROP_FILENAME: { gchar *filename; filename = g_value_get_string(value); if(add_effect->filename == filename){ return; } if(add_effect->filename != NULL){ g_free(add_effect->filename); } add_effect->filename = g_strdup(filename); } break; case PROP_EFFECT: { gchar *effect; effect = g_value_get_string(value); if(add_effect->effect == effect){ return; } if(add_effect->effect != NULL){ g_free(add_effect->effect); } add_effect->effect = g_strdup(effect); } break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, param_spec); break; } }
static void mame_rom_entry_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { MameRomEntry *rom = MAME_ROM_ENTRY (object); switch (prop_id) { case PROP_ROM_ROMNAME: rom->priv->romname = g_strdup (g_value_get_string (value)); break; case PROP_ROM_GAMENAME: rom->priv->gamename = g_strdup (g_value_get_string (value)); break; case PROP_ROM_GAMENAMEEXT: rom->priv->gamenameext = g_strdup (g_value_get_string (value)); break; case PROP_ROM_MANUFACTURER: rom->priv->manu = g_strdup (g_value_get_string (value)); break; case PROP_ROM_YEAR: rom->priv->year = g_strdup (g_value_get_string (value)); break; case PROP_ROM_CLONEOF: rom->priv->cloneof = g_strdup (g_value_get_string (value)); break; case PROP_ROM_ROMOF: rom->priv->romof = g_strdup (g_value_get_string (value)); break; case PROP_ROM_SAMPLEOF: rom->priv->sampleof = g_strdup (g_value_get_string (value)); break; case PROP_ROM_DRIVER: rom->priv->driver = g_strdup (g_value_get_string (value)); break; case PROP_ROM_DRIVER_STATUS: rom->priv->driver_status = g_value_get_int (value); break; case PROP_ROM_DRIVER_STATUS_EMULATION: rom->priv->driver_status_emulation = g_value_get_int (value); break; case PROP_ROM_DRIVER_STATUS_COLOUR: rom->priv->driver_status_color = g_value_get_int (value); break; case PROP_ROM_DRIVER_STATUS_SOUND: rom->priv->driver_status_sound = g_value_get_int (value); break; case PROP_ROM_DRIVER_STATUS_GRAPHICS: rom->priv->driver_status_graphics = g_value_get_int (value); break; case PROP_ROM_NUMPLAYERS: rom->priv->num_players = g_value_get_int (value); break; case PROP_ROM_NUMBUTTONS: rom->priv->num_buttons = g_value_get_int (value); break; case PROP_ROM_CONTROLTYPE: rom->priv->control = g_value_get_int (value); break; case PROP_ROM_CHANNELS: rom->priv->num_channels = g_value_get_int (value); break; case PROP_ROM_TIMESPLAYED: rom->priv->timesplayed = g_value_get_int (value); break; case PROP_ROM_HAS_ROMS: rom->priv->has_roms = g_value_get_int (value); break; case PROP_ROM_HAS_SAMPLES: rom->priv->has_samples = g_value_get_int (value); break; case PROP_ROM_IS_VECTOR: rom->priv->is_vector = g_value_get_boolean (value); break; case PROP_ROM_IS_HORIZONTAL: rom->priv->is_horizontal = g_value_get_boolean (value); break; case PROP_ROM_SCREEN_X: rom->priv->screen_x = g_value_get_int (value); break; case PROP_ROM_SCREEN_Y: rom->priv->screen_y = g_value_get_int (value); break; case PROP_ROM_NUM_COLOURS: rom->priv->num_colours = g_value_get_int (value); break; case PROP_ROM_SCREEN_FREQ: rom->priv->screen_freq = g_value_get_float (value); break; case PROP_ROM_IS_FAVOURITE: rom->priv->is_favourite = g_value_get_boolean (value); break; case PROP_ROM_NUM_ROMS: rom->priv->num_roms = g_value_get_int (value); break; case PROP_ROM_NUM_SAMPLES: rom->priv->num_samples = g_value_get_int (value); break; case PROP_ROM_THE_TRAILER: rom->priv->the_trailer = g_value_get_boolean (value); break; case PROP_ROM_CATEGORY: rom->priv->category = g_strdup (g_value_get_string (value)); break; case PROP_ROM_VER_ADDED: rom->priv->mame_ver_added = g_strdup (g_value_get_string (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void gst_dvbsrc_set_property (GObject * _object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstDvbSrc *object; g_return_if_fail (GST_IS_DVBSRC (_object)); object = GST_DVBSRC (_object); switch (prop_id) { case ARG_DVBSRC_ADAPTER: object->adapter_number = g_value_get_int (value); break; case ARG_DVBSRC_FRONTEND: object->frontend_number = g_value_get_int (value); break; case ARG_DVBSRC_DISEQC_SRC: if (object->diseqc_src != g_value_get_int (value)) { object->diseqc_src = g_value_get_int (value); object->send_diseqc = TRUE; } GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_DISEQC_ID"); break; case ARG_DVBSRC_FREQUENCY: object->freq = g_value_get_uint (value); GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_FREQUENCY"); break; case ARG_DVBSRC_POLARITY: { const char *s = NULL; s = g_value_get_string (value); if (s != NULL) object->pol = (s[0] == 'h' || s[0] == 'H') ? DVB_POL_H : DVB_POL_V; } GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_POLARITY"); break; case ARG_DVBSRC_PIDS: { gchar *pid_string; GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_PIDS"); pid_string = g_value_dup_string (value); if (!strcmp (pid_string, "8192")) { /* get the whole ts */ int pid_count = 1; object->pids[0] = 8192; while (pid_count < MAX_FILTERS) { object->pids[pid_count++] = G_MAXUINT16; } } else { int pid = 0; int pid_count; gchar **pids; char **tmp; tmp = pids = g_strsplit (pid_string, ":", MAX_FILTERS); if (pid_string) g_free (pid_string); /* always add the PAT and CAT pids */ object->pids[0] = 0; object->pids[1] = 1; pid_count = 2; while (*pids != NULL && pid_count < MAX_FILTERS) { pid = strtol (*pids, NULL, 0); if (pid > 1 && pid <= 8192) { GST_INFO_OBJECT (object, "Parsed Pid: %d\n", pid); object->pids[pid_count] = pid; pid_count++; } pids++; } while (pid_count < MAX_FILTERS) { object->pids[pid_count++] = G_MAXUINT16; } g_strfreev (tmp); } /* if we are in playing or paused, then set filters now */ GST_INFO_OBJECT (object, "checking if playing for setting pes filters"); if (GST_ELEMENT (object)->current_state == GST_STATE_PLAYING || GST_ELEMENT (object)->current_state == GST_STATE_PAUSED) { GST_INFO_OBJECT (object, "Setting pes filters now"); gst_dvbsrc_set_pes_filters (object); } } break; case ARG_DVBSRC_SYM_RATE: object->sym_rate = g_value_get_uint (value); GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_SYM_RATE to value %d", g_value_get_int (value)); break; case ARG_DVBSRC_BANDWIDTH: object->bandwidth = g_value_get_enum (value); break; case ARG_DVBSRC_CODE_RATE_HP: object->code_rate_hp = g_value_get_enum (value); break; case ARG_DVBSRC_CODE_RATE_LP: object->code_rate_lp = g_value_get_enum (value); break; case ARG_DVBSRC_GUARD: object->guard_interval = g_value_get_enum (value); break; case ARG_DVBSRC_MODULATION: object->modulation = g_value_get_enum (value); break; case ARG_DVBSRC_TRANSMISSION_MODE: object->transmission_mode = g_value_get_enum (value); break; case ARG_DVBSRC_HIERARCHY_INF: object->hierarchy_information = g_value_get_enum (value); break; case ARG_DVBSRC_INVERSION: object->inversion = g_value_get_enum (value); break; case ARG_DVBSRC_TUNE:{ GST_INFO_OBJECT (object, "Set Property: ARG_DVBSRC_TUNE"); /* if we are in paused/playing state tune now, otherwise in ready to paused state change */ if (GST_STATE (object) > GST_STATE_READY) { g_mutex_lock (object->tune_mutex); gst_dvbsrc_tune (object); g_mutex_unlock (object->tune_mutex); } break; } case ARG_DVBSRC_STATS_REPORTING_INTERVAL: object->stats_interval = g_value_get_uint (value); object->stats_counter = 0; break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); } }
/* returns static descriptions and dynamic ones (such as video/x-raw-yuv), * or NULL if caps aren't known at all */ static gchar * format_info_get_desc (const FormatInfo * info, const GstCaps * caps) { const GstStructure *s; g_assert (info != NULL); if (info->desc != NULL) return g_strdup (_(info->desc)); s = gst_caps_get_structure (caps, 0); if (strcmp (info->type, "video/x-raw-yuv") == 0) { const gchar *ret = NULL; guint32 fourcc = 0; gst_structure_get_fourcc (s, "format", &fourcc); switch (fourcc) { case GST_MAKE_FOURCC ('I', '4', '2', '0'): ret = _("Uncompressed planar YUV 4:2:0"); break; case GST_MAKE_FOURCC ('Y', 'V', '1', '2'): ret = _("Uncompressed planar YVU 4:2:0"); break; case GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'): ret = _("Uncompressed packed YUV 4:2:2"); break; case GST_MAKE_FOURCC ('Y', 'U', 'V', '9'): ret = _("Uncompressed packed YUV 4:1:0"); break; case GST_MAKE_FOURCC ('Y', 'V', 'U', '9'): ret = _("Uncompressed packed YVU 4:1:0"); break; case GST_MAKE_FOURCC ('Y', 'V', 'Y', 'U'): case GST_MAKE_FOURCC ('U', 'Y', 'V', 'Y'): ret = _("Uncompressed packed YUV 4:2:2"); break; case GST_MAKE_FOURCC ('Y', '4', '1', 'P'): ret = _("Uncompressed packed YUV 4:1:1"); break; case GST_MAKE_FOURCC ('I', 'Y', 'U', '2'): ret = _("Uncompressed packed YUV 4:4:4"); break; case GST_MAKE_FOURCC ('Y', '4', '2', 'B'): ret = _("Uncompressed planar YUV 4:2:2"); break; case GST_MAKE_FOURCC ('Y', '4', '1', 'B'): ret = _("Uncompressed planar YUV 4:1:1"); break; case GST_MAKE_FOURCC ('Y', '8', '0', '0'): ret = _("Uncompressed black and white Y-plane"); break; default: ret = _("Uncompressed YUV"); break; } return g_strdup (ret); } else if (strcmp (info->type, "video/x-raw-rgb") == 0) { const gchar *rgb_str; gint depth = 0; gst_structure_get_int (s, "depth", &depth); rgb_str = gst_structure_has_field (s, "alpha_mask") ? "RGBA" : "RGB"; if (gst_structure_has_field (s, "paletted_data")) { return g_strdup_printf (_("Uncompressed palettized %d-bit %s"), depth, rgb_str); } else { return g_strdup_printf ("Uncompressed %d-bit %s", depth, rgb_str); } } else if (strcmp (info->type, "video/x-h263") == 0) { const gchar *variant, *ret; variant = gst_structure_get_string (s, "variant"); if (variant == NULL) ret = "H.263"; else if (strcmp (variant, "itu") == 0) ret = "ITU H.26n"; /* why not ITU H.263? (tpm) */ else if (strcmp (variant, "lead") == 0) ret = "Lead H.263"; else if (strcmp (variant, "microsoft") == 0) ret = "Microsoft H.263"; else if (strcmp (variant, "vdolive") == 0) ret = "VDOLive"; else if (strcmp (variant, "vivo") == 0) ret = "Vivo H.263"; else if (strcmp (variant, "xirlink") == 0) ret = "Xirlink H.263"; else { GST_WARNING ("Unknown H263 variant '%s'", variant); ret = "H.263"; } return g_strdup (ret); } else if (strcmp (info->type, "video/x-h264") == 0) { const gchar *variant, *ret; variant = gst_structure_get_string (s, "variant"); if (variant == NULL) ret = "H.264"; else if (strcmp (variant, "itu") == 0) ret = "ITU H.264"; else if (strcmp (variant, "videosoft") == 0) ret = "Videosoft H.264"; else if (strcmp (variant, "lead") == 0) ret = "Lead H.264"; else { GST_WARNING ("Unknown H264 variant '%s'", variant); ret = "H.264"; } return g_strdup (ret); } else if (strcmp (info->type, "video/x-divx") == 0) { gint ver = 0; if (!gst_structure_get_int (s, "divxversion", &ver) || ver <= 2) { GST_WARNING ("Unexpected DivX version in %" GST_PTR_FORMAT, caps); return g_strdup ("DivX MPEG-4"); } return g_strdup_printf (_("DivX MPEG-4 Version %d"), ver); } else if (strcmp (info->type, "video/x-msmpeg") == 0) { gint ver = 0; if (!gst_structure_get_int (s, "msmpegversion", &ver) || ver < 40 || ver > 49) { GST_WARNING ("Unexpected msmpegversion in %" GST_PTR_FORMAT, caps); return g_strdup ("Microsoft MPEG-4 4.x"); } return g_strdup_printf ("Microsoft MPEG-4 4.%d", ver % 10); } else if (strcmp (info->type, "video/x-truemotion") == 0) { gint ver = 0; gst_structure_get_int (s, "trueversion", &ver); switch (ver) { case 1: return g_strdup_printf ("Duck TrueMotion 1"); case 2: return g_strdup_printf ("TrueMotion 2.0"); default: GST_WARNING ("Unexpected trueversion in %" GST_PTR_FORMAT, caps); break; } return g_strdup_printf ("TrueMotion"); } else if (strcmp (info->type, "video/x-xan") == 0) { gint ver = 0; if (!gst_structure_get_int (s, "wcversion", &ver) || ver < 1) { GST_WARNING ("Unexpected wcversion in %" GST_PTR_FORMAT, caps); return g_strdup ("Xan Wing Commander"); } return g_strdup_printf ("Xan Wing Commander %u", ver); } else if (strcmp (info->type, "video/x-indeo") == 0) { gint ver = 0; if (!gst_structure_get_int (s, "indeoversion", &ver) || ver < 2) { GST_WARNING ("Unexpected indeoversion in %" GST_PTR_FORMAT, caps); return g_strdup ("Intel Indeo"); } return g_strdup_printf ("Intel Indeo %u", ver); } else if (strcmp (info->type, "audio/x-wma") == 0) { gint ver = 0; gst_structure_get_int (s, "wmaversion", &ver); switch (ver) { case 1: case 2: case 3: return g_strdup_printf ("Windows Media Audio %d", ver + 6); default: break; } GST_WARNING ("Unexpected wmaversion in %" GST_PTR_FORMAT, caps); return g_strdup ("Windows Media Audio"); } else if (strcmp (info->type, "video/x-wmv") == 0) { gint ver = 0; gst_structure_get_int (s, "wmvversion", &ver); switch (ver) { case 1: case 2: case 3: return g_strdup_printf ("Windows Media Video %d", ver + 6); default: break; } GST_WARNING ("Unexpected wmvversion in %" GST_PTR_FORMAT, caps); return g_strdup ("Windows Media Video"); } else if (strcmp (info->type, "audio/x-mace") == 0) { gint ver = 0; gst_structure_get_int (s, "maceversion", &ver); if (ver == 3 || ver == 6) { return g_strdup_printf ("MACE-%d", ver); } else { GST_WARNING ("Unexpected maceversion in %" GST_PTR_FORMAT, caps); return g_strdup ("MACE"); } } else if (strcmp (info->type, "video/x-svq") == 0) { gint ver = 0; gst_structure_get_int (s, "svqversion", &ver); if (ver == 1 || ver == 3) { return g_strdup_printf ("Sorensen Video %d", ver); } else { GST_WARNING ("Unexpected svqversion in %" GST_PTR_FORMAT, caps); return g_strdup ("Sorensen Video"); } } else if (strcmp (info->type, "video/x-asus") == 0) { gint ver = 0; gst_structure_get_int (s, "asusversion", &ver); if (ver == 1 || ver == 2) { return g_strdup_printf ("Asus Video %d", ver); } else { GST_WARNING ("Unexpected asusversion in %" GST_PTR_FORMAT, caps); return g_strdup ("Asus Video"); } } else if (strcmp (info->type, "video/x-ati-vcr") == 0) { gint ver = 0; gst_structure_get_int (s, "vcrversion", &ver); if (ver == 1 || ver == 2) { return g_strdup_printf ("ATI VCR %d", ver); } else { GST_WARNING ("Unexpected acrversion in %" GST_PTR_FORMAT, caps); return g_strdup ("ATI VCR"); } } else if (strcmp (info->type, "audio/x-adpcm") == 0) { const GValue *layout_val; layout_val = gst_structure_get_value (s, "layout"); if (layout_val != NULL && G_VALUE_HOLDS_STRING (layout_val)) { const gchar *layout; if ((layout = g_value_get_string (layout_val))) { gchar *layout_upper, *ret; if (strcmp (layout, "swf") == 0) return g_strdup ("Shockwave ADPCM"); if (strcmp (layout, "microsoft") == 0) return g_strdup ("Microsoft ADPCM"); if (strcmp (layout, "quicktime") == 0) return g_strdup ("Quicktime ADPCM"); if (strcmp (layout, "westwood") == 0) return g_strdup ("Westwood ADPCM"); if (strcmp (layout, "yamaha") == 0) return g_strdup ("Yamaha ADPCM"); /* FIXME: other layouts: sbpro2, sbpro3, sbpro4, ct, g726, ea, * adx, xa, 4xm, smjpeg, dk4, dk3, dvi */ layout_upper = g_ascii_strup (layout, -1); ret = g_strdup_printf ("%s ADPCM", layout_upper); g_free (layout_upper); return ret; } } return g_strdup ("ADPCM"); } else if (strcmp (info->type, "audio/mpeg") == 0) { gint ver = 0, layer = 0; gst_structure_get_int (s, "mpegversion", &ver); switch (ver) { case 1: gst_structure_get_int (s, "layer", &layer); switch (layer) { case 1: case 2: case 3: return g_strdup_printf ("MPEG-1 Layer %d (MP%d)", layer, layer); default: break; } GST_WARNING ("Unexpected MPEG-1 layer in %" GST_PTR_FORMAT, caps); return g_strdup ("MPEG-1 Audio"); case 4: return g_strdup ("MPEG-4 AAC"); default: break; } GST_WARNING ("Unexpected audio mpegversion in %" GST_PTR_FORMAT, caps); return g_strdup ("MPEG Audio"); } else if (strcmp (info->type, "audio/x-pn-realaudio") == 0) { gint ver = 0; gst_structure_get_int (s, "raversion", &ver); switch (ver) { case 1: return g_strdup ("RealAudio 14k4bps"); case 2: return g_strdup ("RealAudio 28k8bps"); case 8: return g_strdup ("RealAudio G2 (Cook)"); default: break; } GST_WARNING ("Unexpected raversion in %" GST_PTR_FORMAT, caps); return g_strdup ("RealAudio"); } else if (strcmp (info->type, "video/x-pn-realvideo") == 0) { gint ver = 0; gst_structure_get_int (s, "rmversion", &ver); switch (ver) { case 1: return g_strdup ("RealVideo 1.0"); case 2: return g_strdup ("RealVideo 2.0"); case 3: return g_strdup ("RealVideo 3.0"); case 4: return g_strdup ("RealVideo 4.0"); default: break; } GST_WARNING ("Unexpected rmversion in %" GST_PTR_FORMAT, caps); return g_strdup ("RealVideo"); } else if (strcmp (info->type, "video/mpeg") == 0) { gboolean sysstream; gint ver = 0; if (!gst_structure_get_boolean (s, "systemstream", &sysstream) || !gst_structure_get_int (s, "mpegversion", &ver) || ver < 1 || ver > 4) { GST_WARNING ("Missing fields in mpeg video caps %" GST_PTR_FORMAT, caps); } else { if (sysstream) { return g_strdup_printf ("MPEG-%d System Stream", ver); } else { return g_strdup_printf ("MPEG-%d Video", ver); } } return g_strdup ("MPEG Video"); } else if (strcmp (info->type, "audio/x-raw-int") == 0) { gint bitdepth = 0; /* 8-bit pcm might not have depth field (?) */ if (!gst_structure_get_int (s, "depth", &bitdepth)) gst_structure_get_int (s, "width", &bitdepth); if (bitdepth != 0) return g_strdup_printf (_("Raw %d-bit PCM audio"), bitdepth); else return g_strdup (_("Raw PCM audio")); } else if (strcmp (info->type, "audio/x-raw-float") == 0) { gint bitdepth = 0; gst_structure_get_int (s, "width", &bitdepth); if (bitdepth != 0) return g_strdup_printf (_("Raw %d-bit floating-point audio"), bitdepth); else return g_strdup (_("Raw floating-point audio")); } return NULL; }
void _camera_import_dialog_run(_camera_import_dialog_t *data) { gtk_widget_show_all(data->dialog); // Populate store // Setup a listener for previews of all files on camera // then initiate fetch of all previews from camera if(data->params->camera!=NULL) { /* setup a camctl listener */ dt_camctl_listener_t listener= {0}; listener.data=data; listener.control_status=_control_status; listener.camera_storage_image_filename=_camera_storage_image_filename; dt_job_t job; dt_camera_get_previews_job_init(&job,data->params->camera, &listener, CAMCTL_IMAGE_PREVIEW_DATA); dt_control_job_set_state_callback(&job,_preview_job_state_changed,data); dt_control_add_job(darktable.control, &job); } else return; // Lets run dialog gtk_label_set_text(GTK_LABEL(data->import.info),_("select the images from the list below that you want to import into a new filmroll")); gboolean all_good=FALSE; g_signal_connect(G_OBJECT(data->dialog),"delete-event",G_CALLBACK(_dialog_close),data); while(!all_good) { gint result = gtk_dialog_run (GTK_DIALOG (data->dialog)); if( result == GTK_RESPONSE_ACCEPT) { GtkTreeIter iter; all_good=TRUE; GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview)))); // Now build up result from store into GList **result if(data->params->result) g_list_free(data->params->result); data->params->result=NULL; GtkTreeModel *model=GTK_TREE_MODEL(data->store); GList *sp= gtk_tree_selection_get_selected_rows(selection,&model); if( sp ) { do { GValue value = { 0, }; gtk_tree_model_get_iter(GTK_TREE_MODEL (data->store),&iter,(GtkTreePath*)sp->data); gtk_tree_model_get_value(GTK_TREE_MODEL (data->store),&iter,1,&value); if (G_VALUE_HOLDS_STRING (&value)) data->params->result = g_list_append(data->params->result,g_strdup(g_value_get_string(&value)) ); } while( (sp=g_list_next(sp)) ); } /* get jobcode from import dialog */ data->params->jobcode = data->import.jobname->value; /* get time override if used */ data->params->time_override = 0; if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override))) data->params->time_override = parse_date_time(gtk_entry_get_text(GTK_ENTRY(data->settings.general.date_entry))); if( data->params->jobcode == NULL || data->params->jobcode[0] == '\0' ) { g_free(data->params->jobcode); // might just be a string of length 0 data->params->jobcode = dt_conf_get_string("plugins/capture/camera/import/jobcode"); } else if( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override)) && data->params->time_override == 0) { GtkWidget *dialog=gtk_message_dialog_new(NULL,GTK_DIALOG_DESTROY_WITH_PARENT,GTK_MESSAGE_ERROR,GTK_BUTTONS_OK,_("please use YYYY-MM-DD format for date override")); g_signal_connect_swapped (dialog, "response",G_CALLBACK (gtk_widget_destroy),dialog); gtk_dialog_run (GTK_DIALOG (dialog)); all_good=FALSE; } } else { data->params->result=NULL; all_good=TRUE; } } // Destroy and quit gtk_widget_destroy (data->dialog); }
static void load_owner( const GncSqlBackend* be, GncSqlRow* row, QofSetterFunc setter, gpointer pObject, const GncSqlColumnTableEntry* table_row ) { const GValue* val; gchar* buf; GncOwnerType type; GncGUID guid; QofBook* book; GncOwner owner; GncGUID* pGuid = NULL; g_return_if_fail( be != NULL ); g_return_if_fail( row != NULL ); g_return_if_fail( pObject != NULL ); g_return_if_fail( table_row != NULL ); book = be->primary_book; buf = g_strdup_printf( "%s_type", table_row->col_name ); val = gnc_sql_row_get_value_at_col_name( row, buf ); type = (GncOwnerType)gnc_sql_get_integer_value( val ); g_free( buf ); buf = g_strdup_printf( "%s_guid", table_row->col_name ); val = gnc_sql_row_get_value_at_col_name( row, buf ); g_free( buf ); if ( val != NULL && G_VALUE_HOLDS_STRING( val ) && g_value_get_string( val ) != NULL ) { string_to_guid( g_value_get_string( val ), &guid ); pGuid = &guid; } switch ( type ) { case GNC_OWNER_CUSTOMER: { GncCustomer *cust = NULL; if ( pGuid != NULL ) { cust = gncCustomerLookup( book, pGuid ); if ( cust == NULL ) { cust = gncCustomerCreate( book ); gncCustomerSetGUID( cust, &guid ); } } gncOwnerInitCustomer( &owner, cust ); break; } case GNC_OWNER_JOB: { GncJob *job = NULL; if ( pGuid != NULL ) { job = gncJobLookup( book, pGuid ); if ( job == NULL ) { job = gncJobCreate( book ); gncJobSetGUID( job, &guid ); } } gncOwnerInitJob( &owner, job ); break; } case GNC_OWNER_VENDOR: { GncVendor *vendor = NULL; if ( pGuid != NULL ) { vendor = gncVendorLookup( book, pGuid ); if ( vendor == NULL ) { vendor = gncVendorCreate( book ); gncVendorSetGUID( vendor, &guid ); } } gncOwnerInitVendor( &owner, vendor ); break; } case GNC_OWNER_EMPLOYEE: { GncEmployee *employee = NULL; if ( pGuid != NULL ) { employee = gncEmployeeLookup( book, pGuid ); if ( employee == NULL ) { employee = gncEmployeeCreate( book ); gncEmployeeSetGUID( employee, &guid ); } } gncOwnerInitEmployee( &owner, employee ); break; } default: PWARN("Invalid owner type: %d\n", type ); } if ( table_row->gobj_param_name != NULL ) { g_object_set( pObject, table_row->gobj_param_name, &owner, NULL ); } else { (*setter)( pObject, &owner ); } }
void _midgard_query_constraint_add_conditions_to_statement (MidgardQueryExecutor *executor, MidgardQueryConstraintSimple *constraint_simple, GdaSqlStatement *stmt, GdaSqlExpr *where_expr_node) { MidgardQueryConstraint *self = MIDGARD_QUERY_CONSTRAINT (constraint_simple); //GdaConnection *cnc = executor->priv->mgd->priv->connection; MidgardDBObjectClass *dbklass = NULL; if (self->priv->storage && (self->priv->storage != MIDGARD_QUERY_EXECUTOR (executor)->priv->storage)) { dbklass = self->priv->storage->priv->klass; MQE_SET_TABLE_ALIAS (executor, self->priv->storage); } if (!dbklass) dbklass = executor->priv->storage->priv->klass; g_return_if_fail (dbklass != NULL); /* Get table */ //const gchar *table = midgard_core_class_get_table (dbklass); /* Get field name */ GValue field_value = {0, }; midgard_query_holder_get_value (MIDGARD_QUERY_HOLDER (MIDGARD_QUERY_CONSTRAINT (constraint_simple)->priv->property_value), &field_value); GdaSqlStatementSelect *select = stmt->contents; GdaSqlExpr *top_where, *where, *expr; GdaSqlOperation *top_operation, *cond; GValue *value; if (where_expr_node) { top_where = where_expr_node; top_operation = top_where->cond; } else { top_where = select->where_cond; top_operation = top_where->cond; } where = gda_sql_expr_new (GDA_SQL_ANY_PART (top_operation)); top_operation->operands = g_slist_append (top_operation->operands, where); cond = gda_sql_operation_new (GDA_SQL_ANY_PART (where)); where->cond = cond; cond->operator_type = self->priv->op_type; /* Create table_alias.field name */ gchar *table_alias_field; expr = gda_sql_expr_new (GDA_SQL_ANY_PART (cond)); table_alias_field = midgard_core_query_compute_constraint_property (executor, MIDGARD_QUERY_CONSTRAINT (constraint_simple)->priv->storage, g_value_get_string (&field_value)); if (!table_alias_field) g_warning ("Null table.field alias for given '%s'", g_value_get_string (&field_value)); /* TODO, handle error case when table_alias_field is NULL */ g_value_take_string ((value = gda_value_new (G_TYPE_STRING)), table_alias_field); expr->value = value; cond->operands = g_slist_append (cond->operands, expr); expr = gda_sql_expr_new (GDA_SQL_ANY_PART (cond)); /* Create value */ GValue val = {0, }; midgard_query_holder_get_value (MIDGARD_QUERY_CONSTRAINT (constraint_simple)->priv->holder, &val); /*GType v_type = G_VALUE_TYPE (&val); //FIXME, create parameter name::type */ //GValue *dval = gda_value_new (G_TYPE_STRING); //g_value_transform (&val, dval); //expr->param_spec = gda_sql_param_spec_new (dval); //expr->param_spec->g_type = v_type; expr->value = gda_value_new (G_TYPE_STRING); __set_expression_value (expr->value, &val); g_value_unset (&val); cond->operands = g_slist_append (cond->operands, expr); /* increase executor's constraints number */ executor->priv->n_constraints++; }
static void gst_audio_mixer_filter_probe_feature (GstAudioMixerFilterFunc filter_func, GstElementFactory * factory, GList ** p_collection, gboolean first, gpointer user_data) { GstElement *element; GST_DEBUG ("probing %s ...", gst_element_factory_get_longname (factory)); /* create element */ element = gst_element_factory_create (factory, NULL); if (element == NULL) { GST_DEBUG ("could not create element from factory"); return; } GST_DEBUG ("created element %s (%p)", GST_ELEMENT_NAME (element), element); if (GST_IS_PROPERTY_PROBE (element)) { GstPropertyProbe *probe; const GParamSpec *devspec; probe = GST_PROPERTY_PROBE (element); GST_DEBUG ("probing available devices ..."); if ((devspec = gst_property_probe_get_property (probe, "device"))) { GValueArray *array; if ((array = gst_property_probe_probe_and_get_values (probe, devspec))) { guint n; GST_DEBUG ("there are %d available devices", array->n_values); /* set all devices and test for mixer */ for (n = 0; n < array->n_values; n++) { GValue *device; /* set this device */ device = g_value_array_get_nth (array, n); g_object_set_property (G_OBJECT (element), "device", device); GST_DEBUG ("trying device %s ..", g_value_get_string (device)); if (gst_audio_mixer_filter_check_element (element)) { gst_audio_mixer_filter_do_filter (filter_func, factory, &element, p_collection, user_data); if (first && *p_collection != NULL) { GST_DEBUG ("Stopping after first found mixer, as requested"); break; } } } g_value_array_free (array); } } } else { GST_DEBUG ("element does not support the property probe interface"); if (gst_audio_mixer_filter_check_element (element)) { gst_audio_mixer_filter_do_filter (filter_func, factory, &element, p_collection, user_data); } } if (element) { gst_element_set_state (element, GST_STATE_NULL); gst_object_unref (element); } }
static void gst_udpsrc_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstUDPSrc *udpsrc = GST_UDPSRC (object); switch (prop_id) { case PROP_BUFFER_SIZE: udpsrc->buffer_size = g_value_get_int (value); break; case PROP_PORT: udpsrc->port = g_value_get_int (value); g_free (udpsrc->uri); udpsrc->uri = g_strdup_printf ("udp://%s:%u", udpsrc->host, udpsrc->port); break; case PROP_MULTICAST_GROUP: { const gchar *group; g_free (udpsrc->host); if ((group = g_value_get_string (value))) udpsrc->host = g_strdup (group); else udpsrc->host = g_strdup (UDP_DEFAULT_MULTICAST_GROUP); g_free (udpsrc->uri); udpsrc->uri = g_strdup_printf ("udp://%s:%u", udpsrc->host, udpsrc->port); break; } case PROP_MULTICAST_IFACE: g_free (udpsrc->multi_iface); if (g_value_get_string (value) == NULL) udpsrc->multi_iface = g_strdup (UDP_DEFAULT_MULTICAST_IFACE); else udpsrc->multi_iface = g_value_dup_string (value); break; case PROP_URI: gst_udpsrc_set_uri (udpsrc, g_value_get_string (value)); break; case PROP_CAPS: { const GstCaps *new_caps_val = gst_value_get_caps (value); GstCaps *new_caps; GstCaps *old_caps; if (new_caps_val == NULL) { new_caps = gst_caps_new_any (); } else { new_caps = gst_caps_copy (new_caps_val); } old_caps = udpsrc->caps; udpsrc->caps = new_caps; if (old_caps) gst_caps_unref (old_caps); gst_pad_set_caps (GST_BASE_SRC (udpsrc)->srcpad, new_caps); break; } case PROP_SOCKET: if (udpsrc->socket != NULL && udpsrc->socket != udpsrc->used_socket && udpsrc->close_socket) { GError *err = NULL; if (!g_socket_close (udpsrc->socket, &err)) { GST_ERROR ("failed to close socket %p: %s", udpsrc->socket, err->message); g_clear_error (&err); } } if (udpsrc->socket) g_object_unref (udpsrc->socket); udpsrc->socket = g_value_dup_object (value); GST_DEBUG ("setting socket to %p", udpsrc->socket); break; case PROP_TIMEOUT: udpsrc->timeout = g_value_get_uint64 (value); break; case PROP_SKIP_FIRST_BYTES: udpsrc->skip_first_bytes = g_value_get_int (value); break; case PROP_CLOSE_SOCKET: udpsrc->close_socket = g_value_get_boolean (value); break; case PROP_AUTO_MULTICAST: udpsrc->auto_multicast = g_value_get_boolean (value); break; case PROP_REUSE: udpsrc->reuse = g_value_get_boolean (value); break; default: break; } }
static void gst_imx_v4l2src_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GstImxV4l2VideoSrc *v4l2src = GST_IMX_V4L2SRC(object); switch (prop_id) { case IMX_V4L2SRC_CAPTURE_MODE: v4l2src->capture_mode = g_value_get_int(value); break; case IMX_V4L2SRC_FRAMERATE_NUM: v4l2src->fps_n = g_value_get_int(value); break; case IMX_V4L2SRC_INPUT: v4l2src->input = g_value_get_int(value); break; case IMX_V4L2SRC_DEVICE: if (v4l2src->devicename) g_free(v4l2src->devicename); v4l2src->devicename = g_strdup(g_value_get_string(value)); break; case IMX_V4L2SRC_QUEUE_SIZE: v4l2src->queue_size = g_value_get_int(value); break; case IMX_V4L2SRC_CROP_META_X: v4l2src->metaCropX = g_value_get_int(value); break; case IMX_V4L2SRC_CROP_META_Y: v4l2src->metaCropY = g_value_get_int(value); break; case IMX_V4L2SRC_CROP_META_WIDTH: v4l2src->metaCropWidth = g_value_get_int(value); break; case IMX_V4L2SRC_CROP_META_HEIGHT: v4l2src->metaCropHeight = g_value_get_int(value); break; case PROP_FOCUS_MODE: gst_imx_v4l2src_set_focus_mode(GST_PHOTOGRAPHY(v4l2src), g_value_get_enum(value)); break; case PROP_WB_MODE: case PROP_COLOR_TONE: case PROP_SCENE_MODE: case PROP_FLASH_MODE: case PROP_FLICKER_MODE: case PROP_CAPABILITIES: case PROP_EV_COMP: case PROP_ISO_SPEED: case PROP_APERTURE: case PROP_EXPOSURE_TIME: case PROP_IMAGE_CAPTURE_SUPPORTED_CAPS: case PROP_IMAGE_PREVIEW_SUPPORTED_CAPS: case PROP_ZOOM: case PROP_COLOR_TEMPERATURE: case PROP_WHITE_POINT: case PROP_ANALOG_GAIN: case PROP_LENS_FOCUS: case PROP_MIN_EXPOSURE_TIME: case PROP_MAX_EXPOSURE_TIME: case PROP_NOISE_REDUCTION: GST_WARNING_OBJECT(v4l2src, "setting GstPhotography properties is not supported"); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } }
static gboolean __bt_request_callback(DBusGMethodInvocation *context, DBusGProxy *transfer, gpointer user_data) { GValue *value; const char *transfer_name; const char *file_name; int size; int result = BLUETOOTH_ERROR_NONE; GHashTable *hash = NULL; GError *error; if (sending_info == NULL || sending_info->is_canceled == TRUE) { result = BLUETOOTH_ERROR_CANCEL_BY_USER; goto canceled; } dbus_g_method_return(context, ""); __bt_free_transfer_info(sending_info->transfer_info); sending_info->transfer_info = g_malloc0(sizeof(bt_transfer_info_t)); sending_info->transfer_info->proxy = g_object_ref(transfer); dbus_g_proxy_call(transfer, "GetProperties", NULL, G_TYPE_INVALID, dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &hash, G_TYPE_INVALID); if (hash == NULL) goto fail; value = g_hash_table_lookup(hash, "Name"); transfer_name = value ? g_value_get_string(value) : NULL; value = g_hash_table_lookup(hash, "Filename"); file_name = value ? g_value_get_string(value) : NULL; value = g_hash_table_lookup(hash, "Size"); size = value ? g_value_get_uint64(value) : 0; sending_info->transfer_info->transfer_name = g_strdup(transfer_name); sending_info->transfer_info->file_name = g_strdup(file_name); sending_info->transfer_info->size = size; sending_info->result = BLUETOOTH_ERROR_NONE; g_hash_table_destroy(hash); _bt_send_event(BT_OPP_CLIENT_EVENT, BLUETOOTH_EVENT_OPC_TRANSFER_STARTED, DBUS_TYPE_INT32, &result, DBUS_TYPE_STRING, &sending_info->transfer_info->file_name, DBUS_TYPE_UINT64, &sending_info->transfer_info->size, DBUS_TYPE_INT32, &sending_info->request_id, DBUS_TYPE_INVALID); return TRUE; canceled: error = g_error_new(__bt_opc_error_quark(), BT_OBEX_AGENT_ERROR_CANCEL, "CancelledByUser"); dbus_g_method_return_error(context, error); g_error_free(error); return FALSE; fail: result = BLUETOOTH_ERROR_INTERNAL; /* Send the event in only error none case */ _bt_send_event(BT_OPP_CLIENT_EVENT, BLUETOOTH_EVENT_OPC_DISCONNECTED, DBUS_TYPE_INT32, &result, DBUS_TYPE_STRING, &sending_info->address, DBUS_TYPE_INT32, &sending_info->request_id, DBUS_TYPE_INVALID); __bt_free_sending_info(sending_info); sending_info = NULL; __bt_opp_client_agent_deinit(); return TRUE; }
static GtkWidget* create_tool_item( GtkAction* action ) { GtkWidget* item = 0; if ( IS_EGE_ADJUSTMENT_ACTION(action) ) { EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action ); GtkWidget* spinbutton = 0; GtkWidget* hb = gtk_hbox_new( FALSE, 5 ); GValue value; memset( &value, 0, sizeof(value) ); g_value_init( &value, G_TYPE_STRING ); g_object_get_property( G_OBJECT(action), "short_label", &value ); const gchar* sss = g_value_get_string( &value ); if ( act->private_data->appearanceMode == APPEARANCE_FULL ) { spinbutton = gtk_hscale_new( act->private_data->adj); gtk_widget_set_size_request(spinbutton, 100, -1); gtk_scale_set_digits (GTK_SCALE(spinbutton), 0); gtk_signal_connect(GTK_OBJECT(spinbutton), "format-value", GTK_SIGNAL_FUNC(slider_format_falue), (void *) sss); #if GTK_CHECK_VERSION(2,12,0) } else if ( act->private_data->appearanceMode == APPEARANCE_MINIMAL ) { spinbutton = gtk_scale_button_new( GTK_ICON_SIZE_MENU, 0, 100, 2, 0 ); gtk_scale_button_set_adjustment( GTK_SCALE_BUTTON(spinbutton), act->private_data->adj ); gtk_scale_button_set_icons( GTK_SCALE_BUTTON(spinbutton), floogles ); #endif /* GTK_CHECK_VERSION(2,12,0) */ } else { spinbutton = gtk_spin_button_new( act->private_data->adj, act->private_data->climbRate, act->private_data->digits ); } item = GTK_WIDGET( gtk_tool_item_new() ); { GValue tooltip; memset( &tooltip, 0, sizeof(tooltip) ); g_value_init( &tooltip, G_TYPE_STRING ); g_object_get_property( G_OBJECT(action), "tooltip", &tooltip ); const gchar* tipstr = g_value_get_string( &tooltip ); if ( tipstr && *tipstr ) { if ( !act->private_data->toolTips ) { act->private_data->toolTips = gtk_tooltips_new(); } gtk_tooltips_set_tip( act->private_data->toolTips, spinbutton, tipstr, 0 ); } } if ( act->private_data->appearanceMode != APPEARANCE_FULL ) { GtkWidget* lbl = gtk_label_new( sss ? sss : "wwww" ); GtkWidget* filler1 = gtk_label_new(" "); gtk_misc_set_alignment( GTK_MISC(lbl), 1.0, 0.5 ); gtk_box_pack_start( GTK_BOX(hb), filler1, FALSE, FALSE, 0 ); gtk_box_pack_start( GTK_BOX(hb), lbl, FALSE, FALSE, 0 ); } if ( act->private_data->appearanceMode == APPEARANCE_FULL ) { gtk_box_pack_start( GTK_BOX(hb), spinbutton, TRUE, TRUE, 0 ); } else { gtk_box_pack_start( GTK_BOX(hb), spinbutton, FALSE, FALSE, 0 ); } gtk_container_add( GTK_CONTAINER(item), hb ); if ( act->private_data->selfId ) { g_object_set_data( G_OBJECT(spinbutton), act->private_data->selfId, spinbutton ); } g_signal_connect( G_OBJECT(spinbutton), "focus-in-event", G_CALLBACK(focus_in_cb), action ); g_signal_connect( G_OBJECT(spinbutton), "focus-out-event", G_CALLBACK(focus_out_cb), action ); g_signal_connect( G_OBJECT(spinbutton), "key-press-event", G_CALLBACK(keypress_cb), action ); g_signal_connect( G_OBJECT(spinbutton), "value-changed", G_CALLBACK(value_changed_cb), action ); g_signal_connect_swapped( G_OBJECT(spinbutton), "event", G_CALLBACK(event_cb), action ); if ( act->private_data->appearanceMode == APPEARANCE_FULL ) { /* */ #if GTK_CHECK_VERSION(2,12,0) } else if ( act->private_data->appearanceMode == APPEARANCE_MINIMAL ) { /* */ #endif /* GTK_CHECK_VERSION(2,12,0) */ } else { gtk_entry_set_width_chars( GTK_ENTRY(spinbutton), act->private_data->digits + 3 ); } gtk_widget_show_all( item ); /* Shrink or whatnot after shown */ if ( act->private_data->toolPost ) { act->private_data->toolPost( item ); } } else { item = gParentClass->create_tool_item( action ); } return item; }
void getSongInfos(void) { GHashTable *data_list = NULL; GValue *value; const gchar *data; if(dbus_g_proxy_call (dbus_proxy_shell, "getSongProperties", NULL, G_TYPE_STRING, musicData.playing_uri, G_TYPE_INVALID, dbus_g_type_get_map("GHashTable",G_TYPE_STRING, G_TYPE_VALUE), &data_list, G_TYPE_INVALID)) { g_free (musicData.playing_artist); value = (GValue *) g_hash_table_lookup(data_list, "artist"); if (value != NULL && G_VALUE_HOLDS_STRING(value)) musicData.playing_artist = g_strdup (g_value_get_string(value)); else musicData.playing_artist = NULL; cid_message (" playing_artist <- %s\n", musicData.playing_artist); g_free (musicData.playing_album); value = (GValue *) g_hash_table_lookup(data_list, "album"); if (value != NULL && G_VALUE_HOLDS_STRING(value)) musicData.playing_album = g_strdup (g_value_get_string(value)); else musicData.playing_album = NULL; cid_message (" playing_album <- %s\n", musicData.playing_album); g_free (musicData.playing_title); value = (GValue *) g_hash_table_lookup(data_list, "title"); if (value != NULL && G_VALUE_HOLDS_STRING(value)) musicData.playing_title = g_strdup (g_value_get_string(value)); else musicData.playing_title = NULL; cid_message (" playing_title <- %s\n", musicData.playing_title); value = (GValue *) g_hash_table_lookup(data_list, "track-number"); if (value != NULL && G_VALUE_HOLDS_UINT(value)) musicData.playing_track = g_value_get_uint(value); else musicData.playing_track = 0; cid_message (" playing_track <- %d\n", musicData.playing_track); value = (GValue *) g_hash_table_lookup(data_list, "duration"); if (value != NULL && G_VALUE_HOLDS_UINT(value)) musicData.playing_duration = g_value_get_uint(value); else musicData.playing_duration = 0; cid_message (" playing_duration <- %ds\n", musicData.playing_duration); value = (GValue *) g_hash_table_lookup(data_list, "rb:coverArt-uri"); g_free (musicData.playing_cover); if (value != NULL && G_VALUE_HOLDS_STRING(value)) { GError *erreur = NULL; const gchar *cString = g_value_get_string(value); if (cString != NULL && strncmp (cString, "file://", 7) == 0) { musicData.playing_cover = g_filename_from_uri (cString, NULL, &erreur); if (erreur != NULL) { cid_warning ("Attention : %s\n", erreur->message); g_error_free (erreur); } } else { musicData.playing_cover = g_strdup (cString); } } else { CidDataTable *p_tabFiles = cid_create_datatable(G_TYPE_STRING,"cover","album","albumart", ".folder",".cover","folder","Cover","Folder", G_TYPE_INVALID); gchar *cSongPath = g_filename_from_uri (musicData.playing_uri, NULL, NULL); // on teste d'abord dans le repertoire de la chanson. if (cSongPath != NULL) { gchar *cSongDir = g_path_get_dirname (cSongPath); g_free (cSongPath); musicData.playing_cover = g_strdup_printf ("%s/%s - %s.jpg", cSongDir, musicData.playing_artist, musicData.playing_album); cid_debug (" test de %s\n", musicData.playing_cover); BEGIN_FOREACH_DT(p_tabFiles) if (g_file_test (musicData.playing_cover, G_FILE_TEST_EXISTS)) break; g_free (musicData.playing_cover); musicData.playing_cover = g_strdup_printf ("%s/%s.jpg", cSongDir, p_temp->content->string); cid_debug (" test de %s\n", musicData.playing_cover); END_FOREACH_DT if (! g_file_test (musicData.playing_cover, G_FILE_TEST_EXISTS)) { cid_debug (" test de %s (.gnome2)\n", musicData.playing_cover); g_free (musicData.playing_cover); musicData.playing_cover = g_strdup_printf("%s/.gnome2/rhythmbox/covers/%s - %s.jpg", g_getenv("HOME"),musicData.playing_artist, musicData.playing_album); } if (! g_file_test (musicData.playing_cover, G_FILE_TEST_EXISTS)) { cid_debug (" test de %s (.cache)\n", musicData.playing_cover); g_free (musicData.playing_cover); musicData.playing_cover = g_strdup_printf("%s/.cache/rhythmbox/covers/%s - %s.jpg", g_getenv("HOME"),musicData.playing_artist, musicData.playing_album); } g_free (cSongDir); if (! g_file_test (musicData.playing_cover, G_FILE_TEST_EXISTS)) { cid->runtime->iCheckIter = 0; if (musicData.iSidCheckCover == 0 && cid->config->iPlayer != PLAYER_NONE) { cid_debug ("l'image n'existe pas encore => on boucle.\n"); musicData.iSidCheckCover = g_timeout_add (1 SECONDES, (GSourceFunc) _check_cover_is_present, (gpointer) NULL); } } } }
/* * Parse a filename pattern and replace markers with values from a TrackDetails * structure. * * Valid markers so far are: * %at -- album title * %aa -- album artist * %aA -- album artist (lowercase) * %as -- album artist sortname * %aS -- album artist sortname (lowercase) * %ay -- album year * %ag -- album genre * %aG -- album genre (lowercase) * %an -- album disc number * %aN -- album disc number, zero padded * %tn -- track number (i.e 8) * %tN -- track number, zero padded (i.e 08) * %tt -- track title * %ta -- track artist * %tA -- track artist (lowercase) * %ts -- track artist sortname * %tS -- track artist sortname (lowercase) * %td -- track duration * %te -- track elapsed time * %tb -- track bitrate * %st -- stream title */ static char * parse_pattern (const char *pattern, GHashTable *properties, guint elapsed) { /* p is the pattern iterator, i is a general purpose iterator */ const char *p; char *temp; GString *s; if (pattern == NULL || pattern[0] == 0) return g_strdup (" "); s = g_string_new (NULL); p = pattern; while (*p) { char *string = NULL; const GValue *value = NULL; /* If not a % marker, copy and continue */ if (*p != '%') { g_string_append_c (s, *p++); /* Explicit increment as we continue past the increment */ continue; } /* Is a % marker, go to next and see what to do */ switch (*++p) { case '%': /* * Literal % */ g_string_append_c (s, '%'); break; case 'a': /* * Album tag */ switch (*++p) { case 't': value = g_hash_table_lookup (properties, "album"); if (value) string = g_value_dup_string (value); break; case 'T': value = g_hash_table_lookup (properties, "album-folded"); if (value) string = g_value_dup_string (value); break; case 'a': value = g_hash_table_lookup (properties, "artist"); if (value) string = g_value_dup_string (value); break; case 'A': value = g_hash_table_lookup (properties, "artist-folded"); if (value) string = g_value_dup_string (value); break; case 's': value = g_hash_table_lookup (properties, "mb-artistsortname"); if (value) string = g_value_dup_string (value); break; case 'S': value = g_hash_table_lookup (properties, "mb-artistsortname"); if (value) string = g_utf8_strdown (g_value_get_string (value), -1); break; case 'y': /* Release year */ value = g_hash_table_lookup (properties, "year"); if (value) string = g_strdup_printf ("%u", g_value_get_uint (value)); break; /* Disc number */ case 'n': value = g_hash_table_lookup (properties, "disc-number"); if (value) string = g_strdup_printf ("%u", g_value_get_uint (value)); break; case 'N': value = g_hash_table_lookup (properties, "disc-number"); if (value) string = g_strdup_printf ("%02u", g_value_get_uint (value)); break; /* genre */ case 'g': value = g_hash_table_lookup (properties, "genre"); if (value) string = g_value_dup_string (value); break; case 'G': value = g_hash_table_lookup (properties, "genre-folded"); if (value) string = g_value_dup_string (value); break; default: string = g_strdup_printf ("%%a%c", *p); } break; case 't': /* * Track tag */ switch (*++p) { case 't': value = g_hash_table_lookup (properties, "title"); if (value) string = g_value_dup_string (value); break; case 'T': value = g_hash_table_lookup (properties, "title-folded"); if (value) string = g_value_dup_string (value); break; case 'a': value = g_hash_table_lookup (properties, "artist"); if (value) string = g_value_dup_string (value); break; case 'A': value = g_hash_table_lookup (properties, "artist-folded"); if (value) string = g_value_dup_string (value); break; case 's': value = g_hash_table_lookup (properties, "mb-artistsortname"); if (value) string = g_value_dup_string (value); break; case 'S': value = g_hash_table_lookup (properties, "mb-artistsortname"); if (value) string = g_utf8_strdown (g_value_get_string (value), -1); break; case 'n': /* Track number */ value = g_hash_table_lookup (properties, "track-number"); if (value) string = g_strdup_printf ("%u", g_value_get_uint (value)); break; case 'N': /* Track number, zero-padded */ value = g_hash_table_lookup (properties, "track-number"); if (value) string = g_strdup_printf ("%02u", g_value_get_uint (value)); break; case 'd': /* Track duration */ value = g_hash_table_lookup (properties, "duration"); if (value) string = rb_make_duration_string (g_value_get_uint (value)); break; case 'e': /* Track elapsed time */ string = rb_make_duration_string (elapsed); break; case 'b': /* Track bitrate */ value = g_hash_table_lookup (properties, "bitrate"); if (value) string = g_strdup_printf ("%u", g_value_get_uint (value)); break; default: string = g_strdup_printf ("%%t%c", *p); } break; case 's': /* * Stream tag */ switch (*++p) { case 't': value = g_hash_table_lookup (properties, "rb:stream-song-title"); if (value) string = g_value_dup_string (value); break; default: string = g_strdup_printf ("%%s%c", *p); } break; default: string = g_strdup_printf ("%%%c", *p); } if (string) g_string_append (s, string); g_free (string); ++p; } temp = s->str; g_string_free (s, FALSE); return temp; }
static void print_element_properties_info (GstElement * element) { GParamSpec **property_specs; guint num_properties, i; gboolean readable; gboolean first_flag; property_specs = g_object_class_list_properties (G_OBJECT_GET_CLASS (element), &num_properties); n_print ("\n"); n_print ("Element Properties:\n"); for (i = 0; i < num_properties; i++) { GValue value = { 0, }; GParamSpec *param = property_specs[i]; readable = FALSE; g_value_init (&value, param->value_type); n_print (" %-20s: %s\n", g_param_spec_get_name (param), g_param_spec_get_blurb (param)); first_flag = TRUE; n_print ("%-23.23s flags: ", ""); if (param->flags & G_PARAM_READABLE) { g_object_get_property (G_OBJECT (element), param->name, &value); readable = TRUE; g_print ("%s%s", (first_flag) ? "" : ", ", _("readable")); first_flag = FALSE; } else { /* if we can't read the property value, assume it's set to the default * (which might not be entirely true for sub-classes, but that's an * unlikely corner-case anyway) */ g_param_value_set_default (param, &value); } if (param->flags & G_PARAM_WRITABLE) { g_print ("%s%s", (first_flag) ? "" : ", ", _("writable")); first_flag = FALSE; } if (param->flags & G_PARAM_DEPRECATED) { g_print ("%s%s", (first_flag) ? "" : ", ", _("deprecated")); first_flag = FALSE; } if (param->flags & GST_PARAM_CONTROLLABLE) { g_print (", %s", _("controllable")); first_flag = FALSE; } if (param->flags & GST_PARAM_MUTABLE_PLAYING) { g_print (", %s", _("changeable in NULL, READY, PAUSED or PLAYING state")); } else if (param->flags & GST_PARAM_MUTABLE_PAUSED) { g_print (", %s", _("changeable only in NULL, READY or PAUSED state")); } else if (param->flags & GST_PARAM_MUTABLE_READY) { g_print (", %s", _("changeable only in NULL or READY state")); } if (param->flags & ~KNOWN_PARAM_FLAGS) { g_print ("%s0x%0x", (first_flag) ? "" : ", ", param->flags & ~KNOWN_PARAM_FLAGS); } n_print ("\n"); switch (G_VALUE_TYPE (&value)) { case G_TYPE_STRING: { const char *string_val = g_value_get_string (&value); n_print ("%-23.23s String. ", ""); if (string_val == NULL) g_print ("Default: null"); else g_print ("Default: \"%s\"", string_val); break; } case G_TYPE_BOOLEAN: { gboolean bool_val = g_value_get_boolean (&value); n_print ("%-23.23s Boolean. ", ""); g_print ("Default: %s", bool_val ? "true" : "false"); break; } case G_TYPE_ULONG: { GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param); n_print ("%-23.23s Unsigned Long. ", ""); g_print ("Range: %lu - %lu Default: %lu ", pulong->minimum, pulong->maximum, g_value_get_ulong (&value)); GST_ERROR ("%s: property '%s' of type ulong: consider changing to " "uint/uint64", GST_OBJECT_NAME (element), g_param_spec_get_name (param)); break; } case G_TYPE_LONG: { GParamSpecLong *plong = G_PARAM_SPEC_LONG (param); n_print ("%-23.23s Long. ", ""); g_print ("Range: %ld - %ld Default: %ld ", plong->minimum, plong->maximum, g_value_get_long (&value)); GST_ERROR ("%s: property '%s' of type long: consider changing to " "int/int64", GST_OBJECT_NAME (element), g_param_spec_get_name (param)); break; } case G_TYPE_UINT: { GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param); n_print ("%-23.23s Unsigned Integer. ", ""); g_print ("Range: %u - %u Default: %u ", puint->minimum, puint->maximum, g_value_get_uint (&value)); break; } case G_TYPE_INT: { GParamSpecInt *pint = G_PARAM_SPEC_INT (param); n_print ("%-23.23s Integer. ", ""); g_print ("Range: %d - %d Default: %d ", pint->minimum, pint->maximum, g_value_get_int (&value)); break; } case G_TYPE_UINT64: { GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param); n_print ("%-23.23s Unsigned Integer64. ", ""); g_print ("Range: %" G_GUINT64_FORMAT " - %" G_GUINT64_FORMAT " Default: %" G_GUINT64_FORMAT " ", puint64->minimum, puint64->maximum, g_value_get_uint64 (&value)); break; } case G_TYPE_INT64: { GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param); n_print ("%-23.23s Integer64. ", ""); g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT " Default: %" G_GINT64_FORMAT " ", pint64->minimum, pint64->maximum, g_value_get_int64 (&value)); break; } case G_TYPE_FLOAT: { GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param); n_print ("%-23.23s Float. ", ""); g_print ("Range: %15.7g - %15.7g Default: %15.7g ", pfloat->minimum, pfloat->maximum, g_value_get_float (&value)); break; } case G_TYPE_DOUBLE: { GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param); n_print ("%-23.23s Double. ", ""); g_print ("Range: %15.7g - %15.7g Default: %15.7g ", pdouble->minimum, pdouble->maximum, g_value_get_double (&value)); break; } case G_TYPE_CHAR: case G_TYPE_UCHAR: GST_ERROR ("%s: property '%s' of type char: consider changing to " "int/string", GST_OBJECT_NAME (element), g_param_spec_get_name (param)); /* fall through */ default: if (param->value_type == GST_TYPE_CAPS) { const GstCaps *caps = gst_value_get_caps (&value); if (!caps) n_print ("%-23.23s Caps (NULL)", ""); else { print_caps (caps, " "); } } else if (G_IS_PARAM_SPEC_ENUM (param)) { GEnumValue *values; guint j = 0; gint enum_value; const gchar *value_nick = ""; values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values; enum_value = g_value_get_enum (&value); while (values[j].value_name) { if (values[j].value == enum_value) value_nick = values[j].value_nick; j++; } n_print ("%-23.23s Enum \"%s\" Default: %d, \"%s\"", "", g_type_name (G_VALUE_TYPE (&value)), enum_value, value_nick); j = 0; while (values[j].value_name) { g_print ("\n"); if (_name) g_print ("%s", _name); g_print ("%-23.23s (%d): %-16s - %s", "", values[j].value, values[j].value_nick, values[j].value_name); j++; } /* g_type_class_unref (ec); */ } else if (G_IS_PARAM_SPEC_FLAGS (param)) { GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (param); GFlagsValue *vals; gchar *cur; vals = pflags->flags_class->values; cur = flags_to_string (vals, g_value_get_flags (&value)); n_print ("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\"", "", g_type_name (G_VALUE_TYPE (&value)), g_value_get_flags (&value), cur); while (vals[0].value_name) { g_print ("\n"); if (_name) g_print ("%s", _name); g_print ("%-23.23s (0x%08x): %-16s - %s", "", vals[0].value, vals[0].value_nick, vals[0].value_name); ++vals; } g_free (cur); } else if (G_IS_PARAM_SPEC_OBJECT (param)) { n_print ("%-23.23s Object of type \"%s\"", "", g_type_name (param->value_type)); } else if (G_IS_PARAM_SPEC_BOXED (param)) { n_print ("%-23.23s Boxed pointer of type \"%s\"", "", g_type_name (param->value_type)); if (param->value_type == GST_TYPE_STRUCTURE) { const GstStructure *s = gst_value_get_structure (&value); if (s) gst_structure_foreach (s, print_field, (gpointer) " "); } } else if (G_IS_PARAM_SPEC_POINTER (param)) { if (param->value_type != G_TYPE_POINTER) { n_print ("%-23.23s Pointer of type \"%s\".", "", g_type_name (param->value_type)); } else { n_print ("%-23.23s Pointer.", ""); } } else if (param->value_type == G_TYPE_VALUE_ARRAY) { GParamSpecValueArray *pvarray = G_PARAM_SPEC_VALUE_ARRAY (param); if (pvarray->element_spec) { n_print ("%-23.23s Array of GValues of type \"%s\"", "", g_type_name (pvarray->element_spec->value_type)); } else { n_print ("%-23.23s Array of GValues", ""); } } else if (GST_IS_PARAM_SPEC_FRACTION (param)) { GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION (param); n_print ("%-23.23s Fraction. ", ""); g_print ("Range: %d/%d - %d/%d Default: %d/%d ", pfraction->min_num, pfraction->min_den, pfraction->max_num, pfraction->max_den, gst_value_get_fraction_numerator (&value), gst_value_get_fraction_denominator (&value)); } else { n_print ("%-23.23s Unknown type %ld \"%s\"", "", (glong) param->value_type, g_type_name (param->value_type)); } break; } if (!readable) g_print (" Write only\n"); else g_print ("\n"); g_value_reset (&value); } if (num_properties == 0) n_print (" none\n"); g_free (property_specs); }