gboolean flatpak_builtin_remote_add (int argc, char **argv, GCancellable *cancellable, GError **error) { g_autoptr(GOptionContext) context = NULL; g_autoptr(GPtrArray) dirs = NULL; FlatpakDir *dir; g_autoptr(GFile) file = NULL; g_auto(GStrv) remotes = NULL; g_autofree char *remote_url = NULL; const char *remote_name; const char *location = NULL; g_autoptr(GKeyFile) config = NULL; g_autoptr(GBytes) gpg_data = NULL; gboolean changed = FALSE; g_autoptr(GError) local_error = NULL; gboolean is_oci; context = g_option_context_new (_("NAME LOCATION - Add a remote repository")); g_option_context_set_translation_domain (context, GETTEXT_PACKAGE); g_option_context_add_main_entries (context, common_options, NULL); if (!flatpak_option_context_parse (context, add_options, &argc, &argv, FLATPAK_BUILTIN_FLAG_ONE_DIR | FLATPAK_BUILTIN_FLAG_OPTIONAL_REPO, &dirs, cancellable, error)) return FALSE; dir = g_ptr_array_index (dirs, 0); if (argc < 2) return usage_error (context, _("NAME must be specified"), error); if (argc < 3) return usage_error (context, _("LOCATION must be specified"), error); if (argc > 3) return usage_error (context, _("Too many arguments"), error); if (opt_collection_id != NULL && !ostree_validate_collection_id (opt_collection_id, &local_error)) return flatpak_fail (error, _("‘%s’ is not a valid collection ID: %s"), opt_collection_id, local_error->message); if (opt_collection_id != NULL && (opt_no_gpg_verify || opt_gpg_import == NULL || opt_gpg_import[0] == NULL)) return flatpak_fail (error, _("GPG verification is required if collections are enabled")); remote_name = argv[1]; location = argv[2]; remotes = flatpak_dir_list_remotes (dir, cancellable, error); if (remotes == NULL) return FALSE; if (g_strv_contains ((const char **) remotes, remote_name)) { if (opt_if_not_exists) return TRUE; /* Do nothing */ return flatpak_fail (error, _("Remote %s already exists"), remote_name); } if (opt_from || flatpak_file_arg_has_suffix (location, ".flatpakrepo")) { load_options (location, &gpg_data); if (opt_url == NULL) return flatpak_fail (error, _("No url specified in flatpakrepo file")); } else { file = g_file_new_for_commandline_arg (location); if (g_file_is_native (file)) remote_url = g_file_get_uri (file); else remote_url = g_strdup (location); opt_url = remote_url; } /* Default to gpg verify, except for OCI registries */ is_oci = opt_url && g_str_has_prefix (opt_url, "oci+"); if (!opt_no_gpg_verify && !is_oci) opt_do_gpg_verify = TRUE; config = get_config_from_opts (dir, remote_name, &changed); if (opt_gpg_import != NULL) { gpg_data = flatpak_load_gpg_keys (opt_gpg_import, cancellable, error); if (gpg_data == NULL) return FALSE; } if (!flatpak_dir_modify_remote (dir, remote_name, config, gpg_data, cancellable, error)) return FALSE; /* Reload previously changed configuration */ if (!flatpak_dir_recreate_repo (dir, cancellable, error)) return FALSE; /* We can't retrieve the extra metadata until the remote has been added locally, since ostree_repo_remote_fetch_summary() works with the repository's name, not its URL. Don't propagate IO failed errors here because we might just be offline - the remote should already be usable. */ if (!flatpak_dir_update_remote_configuration (dir, remote_name, cancellable, &local_error)) { if (local_error->domain == G_RESOLVER_ERROR || g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_FAILED)) { g_printerr (_("Warning: Could not update extra metadata for '%s': %s\n"), remote_name, local_error->message); } else { g_propagate_error (error, g_steal_pointer (&local_error)); return FALSE; } } return TRUE; }
/** * file_open_thumbnail: * @gimp: * @context: * @progress: * @file: an image file * @size: requested size of the thumbnail * @mime_type: return location for image MIME type * @image_width: return location for image width * @image_height: return location for image height * @format: return location for image format (set to NULL if unknown) * @num_layers: return location for number of layers * (set to -1 if the number of layers is not known) * @error: * * Attempts to load a thumbnail by using a registered thumbnail loader. * * Return value: the thumbnail image */ GimpImage * file_open_thumbnail (Gimp *gimp, GimpContext *context, GimpProgress *progress, GFile *file, gint size, const gchar **mime_type, gint *image_width, gint *image_height, const Babl **format, gint *num_layers, GError **error) { GimpPlugInProcedure *file_proc; GimpProcedure *procedure; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); g_return_val_if_fail (G_IS_FILE (file), NULL); g_return_val_if_fail (mime_type != NULL, NULL); g_return_val_if_fail (image_width != NULL, NULL); g_return_val_if_fail (image_height != NULL, NULL); g_return_val_if_fail (format != NULL, NULL); g_return_val_if_fail (num_layers != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); *image_width = 0; *image_height = 0; *format = NULL; *num_layers = -1; file_proc = file_procedure_find (gimp->plug_in_manager->load_procs, file, NULL); if (! file_proc || ! file_proc->thumb_loader) return NULL; procedure = gimp_pdb_lookup_procedure (gimp->pdb, file_proc->thumb_loader); if (procedure && procedure->num_args >= 2 && procedure->num_values >= 1) { GimpPDBStatusType status; GimpValueArray *return_vals; GimpImage *image = NULL; gchar *path = NULL; if (! file_proc->handles_uri) path = g_file_get_path (file); if (! path) path = g_file_get_uri (file); return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, context, progress, error, gimp_object_get_name (procedure), G_TYPE_STRING, path, GIMP_TYPE_INT32, size, G_TYPE_NONE); g_free (path); status = g_value_get_enum (gimp_value_array_index (return_vals, 0)); if (status == GIMP_PDB_SUCCESS && GIMP_VALUE_HOLDS_IMAGE_ID (gimp_value_array_index (return_vals, 1))) { image = gimp_value_get_image (gimp_value_array_index (return_vals, 1), gimp); if (gimp_value_array_length (return_vals) >= 3 && G_VALUE_HOLDS_INT (gimp_value_array_index (return_vals, 2)) && G_VALUE_HOLDS_INT (gimp_value_array_index (return_vals, 3))) { *image_width = MAX (0, g_value_get_int (gimp_value_array_index (return_vals, 2))); *image_height = MAX (0, g_value_get_int (gimp_value_array_index (return_vals, 3))); if (gimp_value_array_length (return_vals) >= 5 && G_VALUE_HOLDS_INT (gimp_value_array_index (return_vals, 4))) { gint value = g_value_get_int (gimp_value_array_index (return_vals, 4)); switch (value) { case GIMP_RGB_IMAGE: *format = gimp_babl_format (GIMP_RGB, GIMP_PRECISION_U8_GAMMA, FALSE); break; case GIMP_RGBA_IMAGE: *format = gimp_babl_format (GIMP_RGB, GIMP_PRECISION_U8_GAMMA, TRUE); break; case GIMP_GRAY_IMAGE: *format = gimp_babl_format (GIMP_GRAY, GIMP_PRECISION_U8_GAMMA, FALSE); break; case GIMP_GRAYA_IMAGE: *format = gimp_babl_format (GIMP_GRAY, GIMP_PRECISION_U8_GAMMA, TRUE); break; case GIMP_INDEXED_IMAGE: case GIMP_INDEXEDA_IMAGE: { const Babl *rgb; const Babl *rgba; babl_new_palette ("-gimp-indexed-format-dummy", &rgb, &rgba); if (value == GIMP_INDEXED_IMAGE) *format = rgb; else *format = rgba; } break; default: break; } } if (gimp_value_array_length (return_vals) >= 6 && G_VALUE_HOLDS_INT (gimp_value_array_index (return_vals, 5))) { *num_layers = MAX (0, g_value_get_int (gimp_value_array_index (return_vals, 5))); } } if (image) { file_open_sanitize_image (image, FALSE); *mime_type = file_proc->mime_type; #ifdef GIMP_UNSTABLE g_printerr ("opened thumbnail at %d x %d\n", gimp_image_get_width (image), gimp_image_get_height (image)); #endif } } gimp_value_array_unref (return_vals); return image; } return NULL; }
static void slot_proxy_handle_drop (GtkWidget *widget, GdkDragContext *context, unsigned int time, NautilusDragSlotProxyInfo *drag_info) { GtkWidget *window; NautilusWindowSlot *target_slot; NautilusView *target_view; char *target_uri; GList *uri_list; if (!drag_info->have_data || !drag_info->have_valid_data) { gtk_drag_finish (context, FALSE, FALSE, time); drag_info_clear (drag_info); return; } window = gtk_widget_get_toplevel (widget); g_assert (NAUTILUS_IS_WINDOW (window)); if (drag_info->target_slot != NULL) { target_slot = drag_info->target_slot; } else { target_slot = nautilus_window_get_active_slot (NAUTILUS_WINDOW (window)); } target_uri = NULL; if (drag_info->target_location != NULL) { target_uri = g_file_get_uri (drag_info->target_location); } else if (target_slot != NULL) { target_uri = nautilus_window_slot_get_current_uri (target_slot); } target_view = NULL; if (target_slot != NULL) { target_view = nautilus_window_slot_get_current_view (target_slot); } if (target_slot != NULL && target_view != NULL) { if (drag_info->info == NAUTILUS_ICON_DND_GNOME_ICON_LIST) { uri_list = nautilus_drag_uri_list_from_selection_list (drag_info->data.selection_list); g_assert (uri_list != NULL); nautilus_view_drop_proxy_received_uris (target_view, uri_list, target_uri, gdk_drag_context_get_selected_action (context)); g_list_free_full (uri_list, g_free); } else if (drag_info->info == NAUTILUS_ICON_DND_URI_LIST) { nautilus_view_drop_proxy_received_uris (target_view, drag_info->data.uri_list, target_uri, gdk_drag_context_get_selected_action (context)); } if (drag_info->info == NAUTILUS_ICON_DND_NETSCAPE_URL) { nautilus_view_handle_netscape_url_drop (target_view, drag_info->data.netscape_url, target_uri, gdk_drag_context_get_selected_action (context), 0, 0); } gtk_drag_finish (context, TRUE, FALSE, time); } else { gtk_drag_finish (context, FALSE, FALSE, time); } if (target_view != NULL) { g_object_unref (target_view); } g_free (target_uri); drag_info_clear (drag_info); }
static void list_volumes (GList *volumes, int indent, gboolean only_with_no_drive) { GList *l, *mounts; int c, i; GMount *mount; GVolume *volume; GDrive *drive; char *name; char *uuid; GFile *activation_root; char **ids; GIcon *icon; char *type_name; for (c = 0, l = volumes; l != NULL; l = l->next, c++) { volume = (GVolume *) l->data; if (only_with_no_drive) { drive = g_volume_get_drive (volume); if (drive != NULL) { g_object_unref (drive); continue; } } name = g_volume_get_name (volume); g_print ("%*sVolume(%d): %s\n", indent, "", c, name); g_free (name); type_name = get_type_name (volume); g_print ("%*sType: %s\n", indent+2, "", type_name); g_free (type_name); if (extra_detail) { ids = g_volume_enumerate_identifiers (volume); if (ids && ids[0] != NULL) { g_print ("%*sids:\n", indent+2, ""); for (i = 0; ids[i] != NULL; i++) { char *id = g_volume_get_identifier (volume, ids[i]); g_print ("%*s %s: '%s'\n", indent+2, "", ids[i], id); g_free (id); } } g_strfreev (ids); uuid = g_volume_get_uuid (volume); if (uuid) g_print ("%*suuid=%s\n", indent + 2, "", uuid); activation_root = g_volume_get_activation_root (volume); if (activation_root) { char *uri; uri = g_file_get_uri (activation_root); g_print ("%*sactivation_root=%s\n", indent + 2, "", uri); g_free (uri); g_object_unref (activation_root); } icon = g_volume_get_icon (volume); if (icon) { if (G_IS_THEMED_ICON (icon)) show_themed_icon_names (G_THEMED_ICON (icon), indent + 2); g_object_unref (icon); } g_print ("%*scan_mount=%d\n", indent + 2, "", g_volume_can_mount (volume)); g_print ("%*scan_eject=%d\n", indent + 2, "", g_volume_can_eject (volume)); g_print ("%*sshould_automount=%d\n", indent + 2, "", g_volume_should_automount (volume)); g_free (uuid); } mount = g_volume_get_mount (volume); if (mount) { mounts = g_list_prepend (NULL, mount); list_mounts (mounts, indent + 2, FALSE); g_list_free (mounts); g_object_unref (mount); } } }
/** * anjuta_session_get_relative_uri_from_file: * @session: an #AnjutaSession object * @file: a GFile * @fragment: an optional fragment * * Return an URI relative to the session directory file with an optional * fragment. * It is useful to keep only relative file paths in a session file to be able * to copy the whole project without breaking references. * * Returns: (transfer full): A string that has to be freed with g_free(). */ gchar * anjuta_session_get_relative_uri_from_file (AnjutaSession *session, GFile *file, const gchar *fragment) { GFile *parent; gchar *uri; gint level; parent = g_file_new_for_path (session->priv->dir_path); for (level = 0; (parent != NULL) && !g_file_equal (file, parent) && !g_file_has_prefix (file, parent); level++) { GFile *next = g_file_get_parent (parent); g_object_unref (parent); parent = next; } if (parent == NULL) { uri = g_file_get_uri (file); } else { gchar *path; if (g_file_equal (file, parent)) { uri = g_strdup("."); } else { path = g_file_get_relative_path (parent, file); uri = g_uri_escape_string (path, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, TRUE); g_free (path); } if (level != 0) { gsize len; gchar *buffer; gchar *ptr; len = strlen (uri); buffer = g_new (gchar, len + level * 3 + 1); for (ptr = buffer; level; level--) { memcpy (ptr, ".." G_DIR_SEPARATOR_S, 3); ptr += 3; } memcpy (ptr, uri, len + 1); g_free (uri); uri = buffer; } } if (fragment != NULL) { gchar *with_fragment; with_fragment = g_strconcat (uri, "#", fragment, NULL); g_free (uri); uri = with_fragment; } return uri; }
static void file_save_as (CeditTab *tab, CeditWindow *window) { GtkWidget *save_dialog; GtkWindowGroup *wg; CeditDocument *doc; GFile *file; gboolean uri_set = FALSE; const CeditEncoding *encoding; CeditDocumentNewlineType newline_type; g_return_if_fail (CEDIT_IS_TAB (tab)); g_return_if_fail (CEDIT_IS_WINDOW (window)); cedit_debug (DEBUG_COMMANDS); save_dialog = cedit_file_chooser_dialog_new (_("Save As\342\200\246"), GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (save_dialog), TRUE); g_signal_connect (save_dialog, "confirm-overwrite", G_CALLBACK (confirm_overwrite_callback), NULL); wg = cedit_window_get_group (window); gtk_window_group_add_window (wg, GTK_WINDOW (save_dialog)); /* Save As dialog is modal to its main window */ gtk_window_set_modal (GTK_WINDOW (save_dialog), TRUE); /* Set the suggested file name */ doc = cedit_tab_get_document (tab); file = cedit_document_get_location (doc); if (file != NULL) { uri_set = gtk_file_chooser_set_file (GTK_FILE_CHOOSER (save_dialog), file, NULL); g_object_unref (file); } if (!uri_set) { GFile *default_path; gchar *docname; default_path = _cedit_window_get_default_location (window); docname = cedit_document_get_short_name_for_display (doc); if (default_path != NULL) { gchar *uri; uri = g_file_get_uri (default_path); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (save_dialog), uri); g_free (uri); g_object_unref (default_path); } gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (save_dialog), docname); g_free (docname); } /* Set suggested encoding */ encoding = cedit_document_get_encoding (doc); g_return_if_fail (encoding != NULL); newline_type = cedit_document_get_newline_type (doc); cedit_file_chooser_dialog_set_encoding (CEDIT_FILE_CHOOSER_DIALOG (save_dialog), encoding); cedit_file_chooser_dialog_set_newline_type (CEDIT_FILE_CHOOSER_DIALOG (save_dialog), newline_type); g_object_set_data (G_OBJECT (save_dialog), CEDIT_TAB_TO_SAVE_AS, tab); g_signal_connect (save_dialog, "response", G_CALLBACK (save_dialog_response_cb), window); gtk_widget_show (save_dialog); }
static gboolean cat (GFile * file) { GInputStream *in; char buffer[1024 * 8 + 1]; char *p; gssize res; gboolean close_res; GError *error; gboolean success; error = NULL; in = (GInputStream *) g_file_read (file, NULL, &error); if (in == NULL) { /* Translators: the first %s is the program name, the second one */ /* is the URI of the file, the third is the error message. */ g_printerr (_("%s: %s: error opening file: %s\n"), g_get_prgname (), g_file_get_uri (file), error->message); g_error_free (error); return FALSE; } success = TRUE; while (1) { res = g_input_stream_read (in, buffer, sizeof (buffer) - 1, NULL, &error); if (res > 0) { ssize_t written; p = buffer; while (res > 0) { written = write (STDOUT_FILENO, p, res); if (written == -1 && errno != EINTR) { /* Translators: the first %s is the program name, the */ /* second one is the URI of the file. */ g_printerr (_("%s: %s, error writing to stdout"), g_get_prgname (), g_file_get_uri (file)); success = FALSE; goto out; } res -= written; p += written; } } else if (res < 0) { /* Translators: the first %s is the program name, the second one */ /* is the URI of the file, the third is the error message. */ g_printerr (_("%s: %s: error reading: %s\n"), g_get_prgname (), g_file_get_uri (file), error->message); g_error_free (error); error = NULL; success = FALSE; break; } else if (res == 0) break; } out: close_res = g_input_stream_close (in, NULL, &error); if (!close_res) { /* Translators: the first %s is the program name, the second one */ /* is the URI of the file, the third is the error message. */ g_printerr (_("%s: %s:error closing: %s\n"), g_get_prgname (), g_file_get_uri (file), error->message); g_error_free (error); success = FALSE; } return success; }
XplayerPlParserResult xplayer_pl_parser_add_directory (XplayerPlParser *parser, GFile *file, GFile *base_file, XplayerPlParseData *parse_data, gpointer data) { XplayerDiscMediaType type; GList *list, *l; char *media_uri, *uri; gboolean unhandled; uri = g_file_get_uri (file); media_uri = NULL; type = xplayer_cd_detect_type_from_dir (uri, &media_uri, NULL); g_free (uri); if (type != MEDIA_TYPE_DATA && type != MEDIA_TYPE_ERROR && media_uri != NULL) { char *base_name = NULL, *fname; fname = g_file_get_path (file); if (fname != NULL) { base_name = g_filename_display_basename (fname); g_free (fname); } xplayer_pl_parser_add_one_uri (parser, media_uri, base_name); g_free (base_name); g_free (media_uri); return XPLAYER_PL_PARSER_RESULT_SUCCESS; } g_free (media_uri); if (xplayer_pl_parser_load_directory (file, &list, &unhandled) == FALSE) { if (unhandled != FALSE) return XPLAYER_PL_PARSER_RESULT_UNHANDLED; return XPLAYER_PL_PARSER_RESULT_ERROR; } list = g_list_sort (list, (GCompareFunc) xplayer_pl_parser_dir_compare); l = list; while (l != NULL) { GFileInfo *info = l->data; GFile *item; XplayerPlParserResult ret; item = g_file_get_child (file, g_file_info_get_name (info)); ret = xplayer_pl_parser_parse_internal (parser, item, NULL, parse_data); if (ret != XPLAYER_PL_PARSER_RESULT_SUCCESS && ret != XPLAYER_PL_PARSER_RESULT_IGNORED && ret != XPLAYER_PL_PARSER_RESULT_ERROR) { char *item_uri; item_uri = g_file_get_uri (item); xplayer_pl_parser_add_one_uri (parser, item_uri, NULL); g_free (item_uri); } g_object_unref (item); g_object_unref (info); l = l->next; } g_list_free (list); return XPLAYER_PL_PARSER_RESULT_SUCCESS; }
static gboolean trash_empty_update_dialog (gpointer user_data) { gsize deleted, total; GFile *file; gboolean actually_deleting; g_assert (trash_empty_update_pending); deleted = trash_empty_deleted_files; total = trash_empty_total_files; file = trash_empty_current_file; actually_deleting = trash_empty_actually_deleting; /* maybe the done() got processed first. */ if (!trash_empty_dialog) goto out; if (!actually_deleting) { /* If we havent finished counting yet, then pulse the progressbar every 100ms. * This stops the user from thinking the dialog has frozen if there are * a lot of files to delete. We don't pulse it every time we are called from the * worker thread, otherwise it moves to fast and looks hideous */ if (timer) { if (g_timer_elapsed (timer, NULL) > 0.1) { gtk_progress_bar_pulse (GTK_PROGRESS_BAR (progressbar)); g_timer_start (timer); } } else { timer = g_timer_new (); g_timer_start (timer); gtk_progress_bar_pulse (GTK_PROGRESS_BAR (progressbar)); } } else { gchar *text; gchar *tmp; gchar *markup; GFile *parent; text = g_strdup_printf (_("Removing item %lu of %lu"), deleted, total); gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progressbar), text); g_free (text); if (deleted > total) gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progressbar), 1.0); else gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progressbar), (gdouble) deleted / (gdouble) total); parent = g_file_get_parent (file); text = g_file_get_uri (parent); g_object_unref (parent); gtk_label_set_text (GTK_LABEL (location_label), text); g_free (text); tmp = g_file_get_basename (file); text = g_markup_printf_escaped (_("Removing: %s"), tmp); markup = g_strdup_printf ("<i>%s</i>", text); gtk_label_set_markup (GTK_LABEL (file_label), text); g_free (markup); g_free (text); g_free (tmp); /* unhide the labels */ gtk_widget_show_all (GTK_WIDGET (trash_empty_dialog)); } out: trash_empty_current_file = NULL; g_object_unref (file); trash_empty_update_pending = FALSE; return FALSE; }
void sj_extractor_extract_track (SjExtractor *extractor, const TrackDetails *track, GFile *file, GError **error) { GParamSpec *spec; GstStateChangeReturn state_ret; SjExtractorPrivate *priv; GstIterator *iter; GValue item = {0, }; GstTagSetter *tagger; gboolean done; char *uri; g_return_if_fail (SJ_IS_EXTRACTOR (extractor)); g_return_if_fail (file != NULL); g_return_if_fail (track != NULL); priv = extractor->priv; /* See if we need to rebuild the pipeline */ if (priv->rebuild_pipeline != FALSE) { build_pipeline (extractor); if (priv->construct_error != NULL) { g_propagate_error (error, priv->construct_error); priv->construct_error = NULL; return; } } /* Need to do this, as playback will have locked the read speed to 2x previously */ spec = g_object_class_find_property (G_OBJECT_GET_CLASS (priv->cdsrc), "read-speed"); if (spec && spec->value_type == G_TYPE_INT) { g_object_set (G_OBJECT (priv->cdsrc), "read-speed", ((GParamSpecInt*)spec)->maximum, NULL); } /* Set the output filename */ gst_element_set_state (priv->filesink, GST_STATE_NULL); uri = g_file_get_uri (file); g_object_set (G_OBJECT (priv->filesink), "location", uri, NULL); g_free (uri); /* Set the metadata */ iter = gst_bin_iterate_all_by_interface (GST_BIN (priv->pipeline), GST_TYPE_TAG_SETTER); done = FALSE; while (!done) { switch (gst_iterator_next (iter, &item)) { case GST_ITERATOR_OK: /* TODO: generate this as a taglist once, and apply it to all elements */ tagger = g_value_get_object (&item); gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_REPLACE_ALL, GST_TAG_TITLE, track->title, GST_TAG_ARTIST, track->artist, GST_TAG_TRACK_NUMBER, track->number, GST_TAG_TRACK_COUNT, track->album->number, GST_TAG_ALBUM, track->album->title, GST_TAG_DURATION, track->duration * GST_SECOND, NULL); if (track->composer != NULL && strcmp (track->composer, "") != 0) { gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_COMPOSER, track->composer, NULL); } if (track->composer_sortname != NULL && strcmp (track->composer_sortname, "") != 0) { gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_COMPOSER_SORTNAME, track->composer_sortname, NULL); } if (track->album->album_id != NULL && strcmp (track->album->album_id, "") != 0) { gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_MUSICBRAINZ_ALBUMID, track->album->album_id, NULL); } if (track->album->artist_id != NULL && strcmp (track->album->artist_id, "") != 0) { gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_MUSICBRAINZ_ALBUMARTISTID, track->album->artist_id, NULL); } if (track->album->artist != NULL && strcmp (track->album->artist, "") != 0) { gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_ALBUM_ARTIST, track->album->artist, NULL); } if (track->album->artist_sortname != NULL && strcmp (track->album->artist_sortname, "") != 0) { gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_ALBUM_ARTIST_SORTNAME, track->album->artist_sortname, NULL); } if (track->artist_id != NULL && strcmp (track->artist_id, "") != 0) { gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_MUSICBRAINZ_ARTISTID, track->artist_id, NULL); } if (track->track_id != NULL && strcmp (track->track_id, "") != 0) { gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_MUSICBRAINZ_TRACKID, track->track_id, NULL); } if (track->artist_sortname != NULL && strcmp (track->artist_sortname, "") != 0) { gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_ARTIST_SORTNAME, track->artist_sortname, NULL); } if (track->album->genre != NULL && strcmp (track->album->genre, "") != 0) { char **values, **l; values = g_strsplit (track->album->genre, ",", 0); for (l = values; *l; l++) { g_strstrip (*l); gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_GENRE, *l, NULL); } g_strfreev (values); } if (track->album->release_date) { GDate *date; guint year = 1; guint month = 1; guint day = 1; if (gst_date_time_has_year (track->album->release_date)) { year = gst_date_time_get_year (track->album->release_date); } if (gst_date_time_has_month (track->album->release_date)) { month = gst_date_time_get_month (track->album->release_date); } if (gst_date_time_has_day (track->album->release_date)) { day = gst_date_time_get_day (track->album->release_date); } date = g_date_new_dmy (day, month, year); /* We set both GST_TAG_DATE_TIME and GST_TAG_DATE as most taggers * use GST_TAG__DATE_TIME, but a few (id3v2mux/apemux) are still using * GST_TAG_DATE */ gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_DATE_TIME, track->album->release_date, GST_TAG_DATE, date, NULL); g_date_free (date); } if (track->album->disc_number > 0) { gst_tag_setter_add_tags (tagger, GST_TAG_MERGE_APPEND, GST_TAG_ALBUM_VOLUME_NUMBER, track->album->disc_number, NULL); } g_value_unset (&item); break; case GST_ITERATOR_RESYNC: /* TODO? */ g_warning ("Got GST_ITERATOR_RESYNC, not sure what to do"); gst_iterator_resync (iter); break; case GST_ITERATOR_ERROR: done = TRUE; break; case GST_ITERATOR_DONE: done = TRUE; break; } } g_value_unset (&item); gst_iterator_free (iter); /* Seek to the right track */ g_object_set (G_OBJECT (priv->cdsrc), "track", track->number, NULL); /* Let's get ready to rumble! */ state_ret = gst_element_set_state (priv->pipeline, GST_STATE_PLAYING); if (state_ret == GST_STATE_CHANGE_ASYNC) { /* Wait for state change to either complete or fail, but not for too long, * just to catch immediate errors. The rest we'll handle asynchronously */ state_ret = gst_element_get_state (priv->pipeline, NULL, NULL, GST_SECOND / 2); } if (state_ret == GST_STATE_CHANGE_FAILURE) { GstMessage *msg; msg = gst_bus_poll (GST_ELEMENT_BUS (priv->pipeline), GST_MESSAGE_ERROR, 0); if (msg) { gst_message_parse_error (msg, error, NULL); gst_message_unref (msg); } else if (error) { /* this should never happen, create generic error just in case */ *error = g_error_new (SJ_ERROR, SJ_ERROR_INTERNAL_ERROR, "Error starting ripping pipeline"); } gst_element_set_state (priv->pipeline, GST_STATE_NULL); priv->rebuild_pipeline = TRUE; return; } priv->tick_id = g_timeout_add (250, (GSourceFunc)tick_timeout_cb, extractor); g_source_set_name_by_id (priv->tick_id, "[sound-juicer] tick_timeout_cb"); }
G_MODULE_EXPORT gboolean tracker_extract_get_metadata (TrackerExtractInfo *info) { TIFF *image; TrackerXmpData *xd = NULL; TrackerIptcData *id = NULL; TrackerExifData *ed = NULL; MergeData md = { 0 }; TiffData td = { 0 }; gchar *filename, *uri; gchar *date; glong exif_offset; GPtrArray *keywords; guint i; GFile *file; TrackerSparqlBuilder *metadata, *preupdate; const gchar *graph; GString *where; int fd; #ifdef HAVE_LIBIPTCDATA gchar *iptc_offset; guint32 iptc_size; #endif #ifdef HAVE_EXEMPI gchar *xmp_offset; guint32 size; #endif /* HAVE_EXEMPI */ file = tracker_extract_info_get_file (info); filename = g_file_get_path (file); preupdate = tracker_extract_info_get_preupdate_builder (info); metadata = tracker_extract_info_get_metadata_builder (info); graph = tracker_extract_info_get_graph (info); fd = tracker_file_open_fd (filename); if (fd == -1) { g_warning ("Could not open tiff file '%s': %s\n", filename, g_strerror (errno)); g_free (filename); return FALSE; } if ((image = TIFFFdOpen (fd, filename, "r")) == NULL){ g_warning ("Could not open image:'%s'\n", filename); g_free (filename); close (fd); return FALSE; } tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nfo:Image"); tracker_sparql_builder_object (metadata, "nmm:Photo"); uri = g_file_get_uri (file); #ifdef HAVE_LIBIPTCDATA if (TIFFGetField (image, TIFFTAG_RICHTIFFIPTC, &iptc_size, &iptc_offset)) { if (TIFFIsByteSwapped(image) != 0) { TIFFSwabArrayOfLong((uint32*) iptc_offset, (unsigned long) iptc_size); } id = tracker_iptc_new (iptc_offset, 4 * iptc_size, uri); } #endif /* HAVE_LIBIPTCDATA */ if (!id) { id = g_new0 (TrackerIptcData, 1); } /* FIXME There are problems between XMP data embedded with different tools due to bugs in the original spec (type) */ #ifdef HAVE_EXEMPI if (TIFFGetField (image, TIFFTAG_XMLPACKET, &size, &xmp_offset)) { xd = tracker_xmp_new (xmp_offset, size, uri); } #endif /* HAVE_EXEMPI */ if (!xd) { xd = g_new0 (TrackerXmpData, 1); } ed = g_new0 (TrackerExifData, 1); /* Get Tiff specifics */ td.width = tag_to_string (image, TIFFTAG_IMAGEWIDTH, TAG_TYPE_UINT32); td.length = tag_to_string (image, TIFFTAG_IMAGELENGTH, TAG_TYPE_UINT32); td.artist = tag_to_string (image, TIFFTAG_ARTIST, TAG_TYPE_STRING); td.copyright = tag_to_string (image, TIFFTAG_COPYRIGHT, TAG_TYPE_STRING); date = tag_to_string (image, TIFFTAG_DATETIME, TAG_TYPE_STRING); td.date = tracker_date_guess (date); g_free (date); td.title = tag_to_string (image, TIFFTAG_DOCUMENTNAME, TAG_TYPE_STRING); td.description = tag_to_string (image, TIFFTAG_IMAGEDESCRIPTION, TAG_TYPE_STRING); td.make = tag_to_string (image, TIFFTAG_MAKE, TAG_TYPE_STRING); td.model = tag_to_string (image, TIFFTAG_MODEL, TAG_TYPE_STRING); td.orientation = get_orientation (image); /* Get Exif specifics */ if (TIFFGetField (image, TIFFTAG_EXIFIFD, &exif_offset)) { if (TIFFReadEXIFDirectory (image, exif_offset)) { ed->exposure_time = tag_to_string (image, EXIFTAG_EXPOSURETIME, TAG_TYPE_DOUBLE); ed->fnumber = tag_to_string (image, EXIFTAG_FNUMBER, TAG_TYPE_DOUBLE); ed->iso_speed_ratings = tag_to_string (image, EXIFTAG_ISOSPEEDRATINGS, TAG_TYPE_C16_UINT16); date = tag_to_string (image, EXIFTAG_DATETIMEORIGINAL, TAG_TYPE_STRING); ed->time_original = tracker_date_guess (date); g_free (date); ed->metering_mode = get_metering_mode (image); ed->flash = get_flash (image); ed->focal_length = tag_to_string (image, EXIFTAG_DATETIMEORIGINAL, TAG_TYPE_DOUBLE); ed->white_balance = get_white_balance (image); /* ed->software = tag_to_string (image, EXIFTAG_SOFTWARE, TAG_TYPE_STRING); */ } } TIFFClose (image); g_free (filename); md.title = tracker_coalesce_strip (5, xd->title, xd->pdf_title, td.title, ed->document_name, xd->title2); md.orientation = tracker_coalesce_strip (4, xd->orientation, td.orientation, ed->orientation, id->image_orientation); md.copyright = tracker_coalesce_strip (4, xd->rights, td.copyright, ed->copyright, id->copyright_notice); md.white_balance = tracker_coalesce_strip (2, xd->white_balance, ed->white_balance); md.fnumber = tracker_coalesce_strip (2, xd->fnumber, ed->fnumber); md.flash = tracker_coalesce_strip (2, xd->flash, ed->flash); md.focal_length = tracker_coalesce_strip (2, xd->focal_length, ed->focal_length); md.artist = tracker_coalesce_strip (4, xd->artist, td.artist, ed->artist, xd->contributor); md.exposure_time = tracker_coalesce_strip (2, xd->exposure_time, ed->exposure_time); md.iso_speed_ratings = tracker_coalesce_strip (2, xd->iso_speed_ratings, ed->iso_speed_ratings); md.date = tracker_coalesce_strip (6, xd->date, xd->time_original, td.date, ed->time, id->date_created, ed->time_original); md.description = tracker_coalesce_strip (3, xd->description, td.description, ed->description); md.metering_mode = tracker_coalesce_strip (2, xd->metering_mode, ed->metering_mode); md.city = tracker_coalesce_strip (2, xd->city, id->city); md.state = tracker_coalesce_strip (2, xd->state, id->state); md.address = tracker_coalesce_strip (2, xd->address, id->sublocation); md.country = tracker_coalesce_strip (2, xd->country, id->country_name); /* FIXME We are not handling the altitude ref here for xmp */ md.gps_altitude = tracker_coalesce_strip (2, xd->gps_altitude, ed->gps_altitude); md.gps_latitude = tracker_coalesce_strip (2, xd->gps_latitude, ed->gps_latitude); md.gps_longitude = tracker_coalesce_strip (2, xd->gps_longitude, ed->gps_longitude); md.gps_direction = tracker_coalesce_strip (2, xd->gps_direction, ed->gps_direction); md.creator = tracker_coalesce_strip (3, xd->creator, id->byline, id->credit); md.x_dimension = tracker_coalesce_strip (2, td.width, ed->x_dimension); md.y_dimension = tracker_coalesce_strip (2, td.length, ed->y_dimension); md.make = tracker_coalesce_strip (3, xd->make, td.make, ed->make); md.model = tracker_coalesce_strip (3, xd->model, td.model, ed->model); keywords = g_ptr_array_new (); if (ed->user_comment) { tracker_sparql_builder_predicate (metadata, "nie:comment"); tracker_sparql_builder_object_unvalidated (metadata, ed->user_comment); } if (md.x_dimension) { tracker_sparql_builder_predicate (metadata, "nfo:width"); tracker_sparql_builder_object_unvalidated (metadata, md.x_dimension); } if (md.y_dimension) { tracker_sparql_builder_predicate (metadata, "nfo:height"); tracker_sparql_builder_object_unvalidated (metadata, md.y_dimension); } if (xd->keywords) { tracker_keywords_parse (keywords, xd->keywords); } if (xd->pdf_keywords) { tracker_keywords_parse (keywords, xd->pdf_keywords); } if (xd->subject) { tracker_keywords_parse (keywords, xd->subject); } if (xd->publisher) { gchar *uri = tracker_sparql_escape_uri_printf ("urn:contact:%s", xd->publisher); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:Contact"); tracker_sparql_builder_predicate (preupdate, "nco:fullname"); tracker_sparql_builder_object_unvalidated (preupdate, xd->publisher); if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_predicate (metadata, "nco:publisher"); tracker_sparql_builder_object_iri (metadata, uri); g_free (uri); } if (xd->type) { tracker_sparql_builder_predicate (metadata, "dc:type"); tracker_sparql_builder_object_unvalidated (metadata, xd->type); } if (xd->format) { tracker_sparql_builder_predicate (metadata, "dc:format"); tracker_sparql_builder_object_unvalidated (metadata, xd->format); } if (xd->identifier) { tracker_sparql_builder_predicate (metadata, "dc:identifier"); tracker_sparql_builder_object_unvalidated (metadata, xd->identifier); } if (xd->source) { tracker_sparql_builder_predicate (metadata, "dc:source"); tracker_sparql_builder_object_unvalidated (metadata, xd->source); } if (xd->language) { tracker_sparql_builder_predicate (metadata, "dc:language"); tracker_sparql_builder_object_unvalidated (metadata, xd->language); } if (xd->relation) { tracker_sparql_builder_predicate (metadata, "dc:relation"); tracker_sparql_builder_object_unvalidated (metadata, xd->relation); } if (xd->coverage) { tracker_sparql_builder_predicate (metadata, "dc:coverage"); tracker_sparql_builder_object_unvalidated (metadata, xd->coverage); } if (xd->rating) { tracker_sparql_builder_predicate (metadata, "nao:numericRating"); tracker_sparql_builder_object_unvalidated (metadata, xd->rating); } if (xd->license) { tracker_sparql_builder_predicate (metadata, "nie:license"); tracker_sparql_builder_object_unvalidated (metadata, xd->license); } if (xd->regions) { tracker_xmp_apply_regions (preupdate, metadata, graph, xd); } if (md.address || md.state || md.country || md.city || md.gps_altitude || md.gps_latitude || md.gps_longitude) { tracker_sparql_builder_predicate (metadata, "slo:location"); tracker_sparql_builder_object_blank_open (metadata); /* GeoPoint */ tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "slo:GeoLocation"); if (md.address || md.state || md.country || md.city) { gchar *addruri; addruri = tracker_sparql_get_uuid_urn (); tracker_sparql_builder_predicate (metadata, "slo:postalAddress"); tracker_sparql_builder_object_iri (metadata, addruri); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, addruri); g_free (addruri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:PostalAddress"); if (md.address) { tracker_sparql_builder_predicate (preupdate, "nco:streetAddress"); tracker_sparql_builder_object_unvalidated (preupdate, md.address); } if (md.state) { tracker_sparql_builder_predicate (preupdate, "nco:region"); tracker_sparql_builder_object_unvalidated (preupdate, md.state); } if (md.city) { tracker_sparql_builder_predicate (preupdate, "nco:locality"); tracker_sparql_builder_object_unvalidated (preupdate, md.city); } if (md.country) { tracker_sparql_builder_predicate (preupdate, "nco:country"); tracker_sparql_builder_object_unvalidated (preupdate, md.country); } if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); } if (md.gps_altitude) { tracker_sparql_builder_predicate (metadata, "slo:altitude"); tracker_sparql_builder_object_unvalidated (metadata, md.gps_altitude); } if (md.gps_latitude) { tracker_sparql_builder_predicate (metadata, "slo:latitude"); tracker_sparql_builder_object_unvalidated (metadata, md.gps_latitude); } if (md.gps_longitude) { tracker_sparql_builder_predicate (metadata, "slo:longitude"); tracker_sparql_builder_object_unvalidated (metadata, md.gps_longitude); } tracker_sparql_builder_object_blank_close (metadata); /* GeoLocation */ } if (md.gps_direction) { tracker_sparql_builder_predicate (metadata, "nfo:heading"); tracker_sparql_builder_object_unvalidated (metadata, md.gps_direction); } if (id->contact) { gchar *uri = tracker_sparql_escape_uri_printf ("urn:contact:%s", id->contact); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:Contact"); tracker_sparql_builder_predicate (preupdate, "nco:fullname"); tracker_sparql_builder_object_unvalidated (preupdate, id->contact); if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_predicate (metadata, "nco:representative"); tracker_sparql_builder_object_iri (metadata, uri); g_free (uri); } if (id->keywords) { tracker_keywords_parse (keywords, id->keywords); } where = g_string_new (""); for (i = 0; i < keywords->len; i++) { gchar *p, *escaped, *var; p = g_ptr_array_index (keywords, i); escaped = tracker_sparql_escape_string (p); var = g_strdup_printf ("tag%d", i + 1); /* ensure tag with specified label exists */ tracker_sparql_builder_append (preupdate, "INSERT { "); if (graph) { tracker_sparql_builder_append (preupdate, "GRAPH <"); tracker_sparql_builder_append (preupdate, graph); tracker_sparql_builder_append (preupdate, "> { "); } tracker_sparql_builder_append (preupdate, "_:tag a nao:Tag ; nao:prefLabel \""); tracker_sparql_builder_append (preupdate, escaped); tracker_sparql_builder_append (preupdate, "\""); if (graph) { tracker_sparql_builder_append (preupdate, " } "); } tracker_sparql_builder_append (preupdate, " }\n"); tracker_sparql_builder_append (preupdate, "WHERE { FILTER (NOT EXISTS { " "?tag a nao:Tag ; nao:prefLabel \""); tracker_sparql_builder_append (preupdate, escaped); tracker_sparql_builder_append (preupdate, "\" }) }\n"); /* associate file with tag */ tracker_sparql_builder_predicate (metadata, "nao:hasTag"); tracker_sparql_builder_object_variable (metadata, var); g_string_append_printf (where, "?%s a nao:Tag ; nao:prefLabel \"%s\" .\n", var, escaped); g_free (var); g_free (escaped); g_free (p); } g_ptr_array_free (keywords, TRUE); tracker_extract_info_set_where_clause (info, where->str); g_string_free (where, TRUE); if (md.make || md.model) { gchar *equip_uri; equip_uri = tracker_sparql_escape_uri_printf ("urn:equipment:%s:%s:", md.make ? md.make : "", md.model ? md.model : ""); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, equip_uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nfo:Equipment"); if (md.make) { tracker_sparql_builder_predicate (preupdate, "nfo:manufacturer"); tracker_sparql_builder_object_unvalidated (preupdate, md.make); } if (md.model) { tracker_sparql_builder_predicate (preupdate, "nfo:model"); tracker_sparql_builder_object_unvalidated (preupdate, md.model); } if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_predicate (metadata, "nfo:equipment"); tracker_sparql_builder_object_iri (metadata, equip_uri); g_free (equip_uri); } tracker_guarantee_title_from_file (metadata, "nie:title", md.title, uri, NULL); if (md.orientation) { tracker_sparql_builder_predicate (metadata, "nfo:orientation"); tracker_sparql_builder_object_unvalidated (metadata, md.orientation); } if (md.copyright) { tracker_sparql_builder_predicate (metadata, "nie:copyright"); tracker_sparql_builder_object_unvalidated (metadata, md.copyright); } if (md.white_balance) { tracker_sparql_builder_predicate (metadata, "nmm:whiteBalance"); tracker_sparql_builder_object_unvalidated (metadata, md.white_balance); } if (md.fnumber) { tracker_sparql_builder_predicate (metadata, "nmm:fnumber"); tracker_sparql_builder_object_unvalidated (metadata, md.fnumber); } if (md.flash) { tracker_sparql_builder_predicate (metadata, "nmm:flash"); tracker_sparql_builder_object_unvalidated (metadata, md.flash); } if (md.focal_length) { tracker_sparql_builder_predicate (metadata, "nmm:focalLength"); tracker_sparql_builder_object_unvalidated (metadata, md.focal_length); } if (md.artist) { gchar *uri = tracker_sparql_escape_uri_printf ("urn:contact:%s", md.artist); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:Contact"); tracker_sparql_builder_predicate (preupdate, "nco:fullname"); tracker_sparql_builder_object_unvalidated (preupdate, md.artist); if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_predicate (metadata, "nco:contributor"); tracker_sparql_builder_object_iri (metadata, uri); g_free (uri); } if (md.exposure_time) { tracker_sparql_builder_predicate (metadata, "nmm:exposureTime"); tracker_sparql_builder_object_unvalidated (metadata, md.exposure_time); } if (md.iso_speed_ratings) { tracker_sparql_builder_predicate (metadata, "nmm:isoSpeed"); tracker_sparql_builder_object_unvalidated (metadata, md.iso_speed_ratings); } tracker_guarantee_date_from_file_mtime (metadata, "nie:contentCreated", md.date, uri); if (md.description) { tracker_sparql_builder_predicate (metadata, "nie:description"); tracker_sparql_builder_object_unvalidated (metadata, md.description); } if (md.metering_mode) { tracker_sparql_builder_predicate (metadata, "nmm:meteringMode"); tracker_sparql_builder_object_unvalidated (metadata, md.metering_mode); } if (md.creator) { gchar *uri = tracker_sparql_escape_uri_printf ("urn:contact:%s", md.creator); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:Contact"); tracker_sparql_builder_predicate (preupdate, "nco:fullname"); tracker_sparql_builder_object_unvalidated (preupdate, md.creator); if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); /* NOTE: We only have affiliation with * nco:PersonContact and we are using * nco:Contact here. */ /* if (id->byline_title) { */ /* tracker_sparql_builder_insert_open (preupdate, NULL); */ /* tracker_sparql_builder_subject (preupdate, "_:affiliation_by_line"); */ /* tracker_sparql_builder_predicate (preupdate, "a"); */ /* tracker_sparql_builder_object (preupdate, "nco:Affiliation"); */ /* tracker_sparql_builder_predicate (preupdate, "nco:title"); */ /* tracker_sparql_builder_object_unvalidated (preupdate, id->byline_title); */ /* tracker_sparql_builder_insert_close (preupdate); */ /* tracker_sparql_builder_predicate (metadata, "a"); */ /* tracker_sparql_builder_object (metadata, "nco:PersonContact"); */ /* tracker_sparql_builder_predicate (metadata, "nco:hasAffiliation"); */ /* tracker_sparql_builder_object (metadata, "_:affiliation_by_line"); */ /* } */ tracker_sparql_builder_predicate (metadata, "nco:creator"); tracker_sparql_builder_object_iri (metadata, uri); g_free (uri); } if (ed->x_resolution) { gdouble value; value = ed->resolution_unit != 3 ? g_strtod (ed->x_resolution, NULL) : g_strtod (ed->x_resolution, NULL) * CM_TO_INCH; tracker_sparql_builder_predicate (metadata, "nfo:horizontalResolution"); tracker_sparql_builder_object_double (metadata, value); } if (ed->y_resolution) { gdouble value; value = ed->resolution_unit != 3 ? g_strtod (ed->y_resolution, NULL) : g_strtod (ed->y_resolution, NULL) * CM_TO_INCH; tracker_sparql_builder_predicate (metadata, "nfo:verticalResolution"); tracker_sparql_builder_object_double (metadata, value); } tiff_data_free (&td); tracker_exif_free (ed); tracker_xmp_free (xd); tracker_iptc_free (id); g_free (uri); close (fd); return TRUE; }
static void _uri_handle_recurse (GFile *dir, GCancellable *cancel, GHashTable *handled, RBUriRecurseFunc func, gpointer user_data) { GFileEnumerator *files; GFileInfo *info; GError *error = NULL; GFileType file_type; const char *file_id; gboolean file_handled; const char *attributes = G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE "," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN "," G_FILE_ATTRIBUTE_ID_FILE "," G_FILE_ATTRIBUTE_ACCESS_CAN_READ; files = g_file_enumerate_children (dir, attributes, G_FILE_QUERY_INFO_NONE, cancel, &error); if (error != NULL) { char *where; /* handle the case where we're given a single file to process */ if (error->code == G_IO_ERROR_NOT_DIRECTORY) { g_clear_error (&error); info = g_file_query_info (dir, attributes, G_FILE_QUERY_INFO_NONE, cancel, &error); if (error == NULL) { if (_should_process (info)) { (func) (dir, FALSE, user_data); } g_object_unref (info); return; } } where = g_file_get_uri (dir); rb_debug ("error enumerating %s: %s", where, error->message); g_free (where); g_error_free (error); return; } while (1) { GFile *child; gboolean is_dir; gboolean ret; ret = TRUE; info = g_file_enumerator_next_file (files, cancel, &error); if (error != NULL) { rb_debug ("error enumerating files: %s", error->message); break; } else if (info == NULL) { break; } if (_should_process (info) == FALSE) { g_object_unref (info); continue; } /* already handled? */ file_id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILE); if (file_id == NULL) { /* have to hope for the best, I guess */ file_handled = FALSE; } else if (g_hash_table_lookup (handled, file_id) != NULL) { file_handled = TRUE; } else { file_handled = FALSE; g_hash_table_insert (handled, g_strdup (file_id), GINT_TO_POINTER (1)); } /* type? */ file_type = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE); switch (file_type) { case G_FILE_TYPE_DIRECTORY: case G_FILE_TYPE_MOUNTABLE: is_dir = TRUE; break; default: is_dir = FALSE; break; } if (file_handled == FALSE) { child = g_file_get_child (dir, g_file_info_get_name (info)); ret = (func) (child, is_dir, user_data); if (is_dir) { _uri_handle_recurse (child, cancel, handled, func, user_data); } g_object_unref (child); } g_object_unref (info); if (ret == FALSE) break; } g_object_unref (files); }
/** * rb_uri_resolve_symlink: * @uri: the URI to process * @error: returns error information * * Attempts to resolve symlinks in @uri and return a canonical URI for the file * it identifies. * * Return value: resolved URI, or NULL on error */ char * rb_uri_resolve_symlink (const char *uri, GError **error) { GFile *file = NULL; GFileInfo *file_info = NULL; int link_count = 0; char *result = NULL; const char *attr = G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET; GError *l_error = NULL; file = g_file_new_for_uri (uri); while (link_count < MAX_LINK_LEVEL) { GFile *parent; GFile *new_file; const char *target; /* look for a symlink target */ file_info = g_file_query_info (file, attr, G_FILE_QUERY_INFO_NONE, NULL, &l_error); if (l_error != NULL) { /* argh */ result = g_file_get_uri (file); rb_debug ("error querying %s: %s", result, l_error->message); g_free (result); result = NULL; break; } else if (g_file_info_has_attribute (file_info, attr) == FALSE) { /* no symlink, so return the path */ result = g_file_get_uri (file); if (link_count > 0) { rb_debug ("resolved symlinks: %s -> %s", uri, result); } break; } /* resolve it and try again */ new_file = NULL; parent = g_file_get_parent (file); if (parent == NULL) { /* dang */ break; } target = g_file_info_get_attribute_byte_string (file_info, attr); new_file = g_file_resolve_relative_path (parent, target); g_object_unref (parent); g_object_unref (file_info); file_info = NULL; g_object_unref (file); file = new_file; if (file == NULL) { /* dang */ break; } link_count++; } if (file != NULL) { g_object_unref (file); } if (file_info != NULL) { g_object_unref (file_info); } if (result == NULL && error == NULL) { rb_debug ("too many symlinks while resolving %s", uri); l_error = g_error_new (G_IO_ERROR, G_IO_ERROR_TOO_MANY_LINKS, _("Too many symlinks")); } if (l_error != NULL) { g_propagate_error (error, l_error); } return result; }
static gboolean load_playlist (RBGenericPlayerPlaylistSource *source) { RBGenericPlayerPlaylistSourcePrivate *priv = GET_PRIVATE (source); TotemPlParser *parser; gboolean result; GFile *file; char *name; char *uri; if (priv->playlist_path == NULL) { /* this happens when we're creating a new playlist */ rb_debug ("playlist has no path; obviously can't load it"); g_object_set (source, "name", "", NULL); return TRUE; } priv->loading = TRUE; file = g_file_new_for_path (priv->playlist_path); /* make a default name for the playlist based on the filename */ name = g_file_get_basename (file); g_object_set (source, "name", name, NULL); g_free (name); parser = totem_pl_parser_new (); if (rb_debug_matches ("totem_pl_parser_parse", "totem-pl-parser.c")) { g_object_set (parser, "debug", TRUE, NULL); } rb_generic_player_source_set_supported_formats (priv->player_source, parser); g_signal_connect (parser, "entry-parsed", G_CALLBACK (handle_playlist_entry_cb), source); g_signal_connect (parser, "playlist-started", G_CALLBACK (handle_playlist_start_cb), source); g_object_set (G_OBJECT (parser), "recurse", FALSE, NULL); uri = g_file_get_uri (file); switch (totem_pl_parser_parse_with_base (parser, uri, priv->device_root, FALSE)) { case TOTEM_PL_PARSER_RESULT_SUCCESS: rb_debug ("playlist parsed successfully"); result = TRUE; break; case TOTEM_PL_PARSER_RESULT_ERROR: rb_debug ("playlist parser returned an error"); result = FALSE; break; case TOTEM_PL_PARSER_RESULT_UNHANDLED: rb_debug ("playlist parser didn't handle the file"); result = FALSE; break; case TOTEM_PL_PARSER_RESULT_IGNORED: rb_debug ("playlist parser ignored the file"); result = FALSE; break; default: g_assert_not_reached (); } g_free (uri); g_object_unref (file); priv->loading = FALSE; return result; }
void _cedit_cmd_file_open (GtkAction *action, CeditWindow *window) { GtkWidget *open_dialog; gpointer data; CeditDocument *doc; GFile *default_path = NULL; cedit_debug (DEBUG_COMMANDS); data = g_object_get_data (G_OBJECT (window), CEDIT_OPEN_DIALOG_KEY); if (data != NULL) { g_return_if_fail (CEDIT_IS_FILE_CHOOSER_DIALOG (data)); gtk_window_present (GTK_WINDOW (data)); return; } /* Translators: "Open Files" is the title of the file chooser window */ open_dialog = cedit_file_chooser_dialog_new (_("Open Files"), GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_OPEN, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); g_object_set_data (G_OBJECT (window), CEDIT_OPEN_DIALOG_KEY, open_dialog); g_object_weak_ref (G_OBJECT (open_dialog), (GWeakNotify) open_dialog_destroyed, window); /* Set the curret folder uri */ doc = cedit_window_get_active_document (window); if (doc != NULL) { GFile *file; file = cedit_document_get_location (doc); if (file != NULL) { default_path = g_file_get_parent (file); g_object_unref (file); } } if (default_path == NULL) default_path = _cedit_window_get_default_location (window); if (default_path != NULL) { gchar *uri; uri = g_file_get_uri (default_path); gtk_file_chooser_set_current_folder_uri (GTK_FILE_CHOOSER (open_dialog), uri); g_free (uri); g_object_unref (default_path); } g_signal_connect (open_dialog, "response", G_CALLBACK (open_dialog_response_cb), window); gtk_widget_show (open_dialog); }
gint main (gint argc, gchar **argv) { PopplerDocument *document; GtkWidget *win; GtkWidget *hbox; GtkWidget *notebook; GtkWidget *treeview; GtkTreeSelection *selection; GFile *file; gchar *uri; GTimer *timer; GError *error = NULL; if (argc != 2) { g_print ("Usage: poppler-glib-demo FILE\n"); return 1; } if (!g_thread_supported ()) g_thread_init (NULL); gtk_init (&argc, &argv); file = g_file_new_for_commandline_arg (argv[1]); uri = g_file_get_uri (file); timer = g_timer_new (); document = poppler_document_new_from_file (uri, NULL, &error); g_timer_stop (timer); if (error) { while (g_error_matches (error, POPPLER_ERROR, POPPLER_ERROR_ENCRYPTED)) { GtkDialog *dialog; const gchar *password; dialog = pgd_demo_get_auth_dialog (file); if (gtk_dialog_run (dialog) != GTK_RESPONSE_OK) { g_print ("Error: no password provided\n"); g_object_unref (file); g_free (uri); return 1; } g_clear_error (&error); password = g_object_get_data (G_OBJECT (dialog), "pgd-password"); g_timer_start (timer); document = poppler_document_new_from_file (uri, password, &error); g_timer_stop (timer); gtk_widget_destroy (GTK_WIDGET (dialog)); } if (error) { g_print ("Error: %s\n", error->message); g_error_free (error); g_object_unref (file); g_free (uri); return 1; } } g_object_unref (file); g_free (uri); g_print ("Document successfully loaded in %.4f seconds\n", g_timer_elapsed (timer, NULL)); g_timer_destroy (timer); /* Main window */ win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (win), 600, 600); gtk_window_set_title (GTK_WINDOW (win), "Poppler GLib Demo"); g_signal_connect (G_OBJECT (win), "delete-event", G_CALLBACK (gtk_main_quit), NULL); hbox = gtk_hbox_new (FALSE, 6); treeview = pgd_demo_list_create (); gtk_box_pack_start (GTK_BOX (hbox), treeview, FALSE, TRUE, 0); gtk_widget_show (treeview); notebook = pdg_demo_notebook_create (document); gtk_box_pack_start (GTK_BOX (hbox), notebook, TRUE, TRUE, 0); gtk_widget_show (notebook); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (pgd_demo_changed), (gpointer) notebook); gtk_container_add (GTK_CONTAINER (win), hbox); gtk_widget_show (hbox); gtk_widget_show (win); gtk_main (); g_object_unref (document); return 0; }
static void save_dialog_response_cb (CeditFileChooserDialog *dialog, gint response_id, CeditWindow *window) { GFile *file; const CeditEncoding *encoding; CeditTab *tab; gpointer data; GSList *tabs_to_save_as; CeditDocumentNewlineType newline_type; cedit_debug (DEBUG_COMMANDS); tab = CEDIT_TAB (g_object_get_data (G_OBJECT (dialog), CEDIT_TAB_TO_SAVE_AS)); if (response_id != GTK_RESPONSE_OK) { gtk_widget_destroy (GTK_WIDGET (dialog)); goto save_next_tab; } file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog)); g_return_if_fail (file != NULL); encoding = cedit_file_chooser_dialog_get_encoding (dialog); newline_type = cedit_file_chooser_dialog_get_newline_type (dialog); gtk_widget_destroy (GTK_WIDGET (dialog)); if (tab != NULL) { CeditDocument *doc; gchar *parse_name; gchar *uri; doc = cedit_tab_get_document (tab); g_return_if_fail (CEDIT_IS_DOCUMENT (doc)); parse_name = g_file_get_parse_name (file); cedit_statusbar_flash_message (CEDIT_STATUSBAR (window->priv->statusbar), window->priv->generic_message_cid, _("Saving file '%s'\342\200\246"), parse_name); g_free (parse_name); /* let's remember the dir we navigated too, * even if the saving fails... */ _cedit_window_set_default_location (window, file); // FIXME: pass the GFile to tab when api is there uri = g_file_get_uri (file); _cedit_tab_save_as (tab, uri, encoding, newline_type); g_free (uri); } g_object_unref (file); save_next_tab: data = g_object_get_data (G_OBJECT (window), CEDIT_LIST_OF_TABS_TO_SAVE_AS); if (data == NULL) return; /* Save As the next tab of the list (we are Saving All files) */ tabs_to_save_as = (GSList *)data; g_return_if_fail (tab == CEDIT_TAB (tabs_to_save_as->data)); /* Remove the first item of the list */ tabs_to_save_as = g_slist_delete_link (tabs_to_save_as, tabs_to_save_as); g_object_set_data (G_OBJECT (window), CEDIT_LIST_OF_TABS_TO_SAVE_AS, tabs_to_save_as); if (tabs_to_save_as != NULL) { tab = CEDIT_TAB (tabs_to_save_as->data); if (GPOINTER_TO_BOOLEAN (g_object_get_data (G_OBJECT (tab), CEDIT_IS_CLOSING_TAB)) == TRUE) { g_object_set_data (G_OBJECT (tab), CEDIT_IS_CLOSING_TAB, NULL); /* Trace tab state changes */ g_signal_connect (tab, "notify::state", G_CALLBACK (tab_state_changed_while_saving), window); } cedit_window_set_active_tab (window, tab); file_save_as (tab, window); } }
char* ext_spe = strchr(basename, '.'); if (ext_spe == NULL) { return basename; } else { char* app_id = g_strndup(basename, ext_spe - basename); g_free(basename); return app_id; } } JS_EXPORT_API char* dentry_get_uri(Entry* e) { TEST_GFILE(e, f) char* uri = g_file_get_uri(f); /* * some characters like ')', '(' may not be escaped * * ':' for scheme, like file:///...., the : cannot be escaped * '/' for path separator, should be escaped * '%' for the characters escaped, should be escaped */ char* escaped_uri = g_uri_escape_string(uri, ":/%", FALSE); g_free(uri); return escaped_uri; TEST_GAPP(e, app) char* encode = g_uri_escape_string(g_desktop_app_info_get_filename(G_DESKTOP_APP_INFO(app)), "/", FALSE); char* uri = g_strdup_printf("file://%s", encode); g_free(encode);
static void nautilus_emblem_sidebar_drag_received_cb (GtkWidget *widget, GdkDragContext *drag_context, gint x, gint y, GtkSelectionData *data, guint info, guint time, NautilusEmblemSidebar *emblem_sidebar) { GSList *emblems; Emblem *emblem; GdkPixbuf *pixbuf; char *uri, *error, *uri_utf8; char **uris; GFile *f; int i; gboolean had_failure; had_failure = FALSE; emblems = NULL; switch (info) { case TARGET_URI_LIST: if (data->format != 8 || data->length == 0) { g_message ("URI list had wrong format (%d) or length (%d)\n", data->format, data->length); return; } uris = g_uri_list_extract_uris (data->data); if (uris == NULL) { break; } for (i = 0; uris[i] != NULL; ++i) { f = g_file_new_for_uri (uris[i]); pixbuf = nautilus_emblem_load_pixbuf_for_emblem (f); if (pixbuf == NULL) { /* this one apparently isn't an image, or * at least not one that we know how to read */ had_failure = TRUE; g_object_unref (f); continue; } emblem = g_new (Emblem, 1); emblem->uri = g_file_get_uri (f); emblem->name = NULL; /* created later on by the user */ emblem->keyword = NULL; emblem->pixbuf = pixbuf; g_object_unref (f); emblems = g_slist_prepend (emblems, emblem); } g_strfreev (uris); if (had_failure && emblems != NULL) { eel_show_error_dialog (_("Some of the files could not be added as emblems."), _("The emblems do not appear to be valid images."), NULL); } else if (had_failure && emblems == NULL) { eel_show_error_dialog (_("None of the files could be added as emblems."), _("The emblems do not appear to be valid images."), NULL); } if (emblems != NULL) { show_add_emblems_dialog (emblem_sidebar, emblems); } break; case TARGET_URI: if (data->format != 8 || data->length == 0) { g_warning ("URI had wrong format (%d) or length (%d)\n", data->format, data->length); return; } uri = g_strndup (data->data, data->length); f = g_file_new_for_uri (uri); pixbuf = nautilus_emblem_load_pixbuf_for_emblem (f); if (pixbuf != NULL) { emblem = g_new (Emblem, 1); emblem->uri = uri; emblem->name = NULL; emblem->keyword = NULL; emblem->pixbuf = pixbuf; emblems = g_slist_prepend (NULL, emblem); show_add_emblems_dialog (emblem_sidebar, emblems); } else { uri_utf8 = g_file_get_parse_name (f); if (uri_utf8) { error = g_strdup_printf (_("The file '%s' does not appear to be a valid image."), uri_utf8); g_free (uri_utf8); } else { error = g_strdup (_("The dragged file does not appear to be a valid image.")); } eel_show_error_dialog (_("The emblem cannot be added."), error, NULL); g_free (error); g_free (uri_utf8); } g_object_unref (f); g_free (uri); break; case TARGET_NETSCAPE_URL: if (data->format != 8 || data->length == 0) { g_message ("URI had wrong format (%d) or length (%d)\n", data->format, data->length); return; } /* apparently, this is a URI/title pair? or just a pair * of identical URIs? Regardless, this seems to work... */ uris = g_uri_list_extract_uris (data->data); if (uris == NULL) { break; } uri = uris[0]; if (uri == NULL) { g_strfreev (uris); break; } f = g_file_new_for_uri (uri); pixbuf = nautilus_emblem_load_pixbuf_for_emblem (f); g_object_unref (f); if (pixbuf != NULL) { emblem = g_new (Emblem, 1); emblem->uri = g_strdup (uri); emblem->name = NULL; emblem->keyword = NULL; emblem->pixbuf = pixbuf; emblems = g_slist_prepend (NULL, emblem); show_add_emblems_dialog (emblem_sidebar, emblems); } else { g_warning ("Tried to load '%s', but failed.\n", uri); error = g_strdup_printf (_("The file '%s' does not appear to be a valid image."), uri); eel_show_error_dialog (_("The emblem cannot be added."), error, NULL); g_free (error); } g_strfreev (uris); break; } }
G_MODULE_EXPORT gboolean tracker_extract_get_metadata (TrackerExtractInfo *info) { TrackerConfig *config; GTime creation_date; GError *error = NULL; TrackerSparqlBuilder *metadata, *preupdate; const gchar *graph; const gchar *urn; TrackerXmpData *xd = NULL; PDFData pd = { 0 }; /* actual data */ PDFData md = { 0 }; /* for merging */ PopplerDocument *document; gchar *xml = NULL; gchar *content, *uri; guint n_bytes; GPtrArray *keywords; guint i; GFile *file; gchar *filename; int fd; gchar *contents = NULL; gsize len; struct stat st; metadata = tracker_extract_info_get_metadata_builder (info); preupdate = tracker_extract_info_get_preupdate_builder (info); graph = tracker_extract_info_get_graph (info); urn = tracker_extract_info_get_urn (info); file = tracker_extract_info_get_file (info); filename = g_file_get_path (file); fd = tracker_file_open_fd (filename); if (fd == -1) { g_warning ("Could not open pdf file '%s': %s\n", filename, g_strerror (errno)); g_free (filename); return FALSE; } if (fstat (fd, &st) == -1) { g_warning ("Could not fstat pdf file '%s': %s\n", filename, g_strerror (errno)); close (fd); g_free (filename); return FALSE; } if (st.st_size == 0) { contents = NULL; len = 0; } else { contents = (gchar *) mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); if (contents == NULL || contents == MAP_FAILED) { g_warning ("Could not mmap pdf file '%s': %s\n", filename, g_strerror (errno)); close (fd); g_free (filename); return FALSE; } len = st.st_size; } g_free (filename); uri = g_file_get_uri (file); document = poppler_document_new_from_data (contents, len, NULL, &error); if (error) { if (error->code == POPPLER_ERROR_ENCRYPTED) { tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nfo:PaginatedTextDocument"); tracker_sparql_builder_predicate (metadata, "nfo:isContentEncrypted"); tracker_sparql_builder_object_boolean (metadata, TRUE); g_error_free (error); g_free (uri); close (fd); return TRUE; } else { g_warning ("Couldn't create PopplerDocument from uri:'%s', %s", uri, error->message ? error->message : "no error given"); g_error_free (error); g_free (uri); close (fd); return FALSE; } } if (!document) { g_warning ("Could not create PopplerDocument from uri:'%s', " "NULL returned without an error", uri); g_free (uri); close (fd); return FALSE; } tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nfo:PaginatedTextDocument"); g_object_get (document, "title", &pd.title, "author", &pd.author, "subject", &pd.subject, "keywords", &pd.keywords, "creation-date", &creation_date, "metadata", &xml, NULL); if (creation_date > 0) { pd.creation_date = tracker_date_to_string ((time_t) creation_date); } keywords = g_ptr_array_new_with_free_func ((GDestroyNotify) g_free); if (xml && *xml && (xd = tracker_xmp_new (xml, strlen (xml), uri)) != NULL) { /* The casts here are well understood and known */ md.title = (gchar *) tracker_coalesce_strip (4, pd.title, xd->title, xd->title2, xd->pdf_title); md.subject = (gchar *) tracker_coalesce_strip (2, pd.subject, xd->subject); md.date = (gchar *) tracker_coalesce_strip (3, pd.creation_date, xd->date, xd->time_original); md.author = (gchar *) tracker_coalesce_strip (2, pd.author, xd->creator); write_pdf_data (md, metadata, keywords); if (xd->keywords) { tracker_keywords_parse (keywords, xd->keywords); } if (xd->pdf_keywords) { tracker_keywords_parse (keywords, xd->pdf_keywords); } if (xd->publisher) { tracker_sparql_builder_predicate (metadata, "nco:publisher"); tracker_sparql_builder_object_blank_open (metadata); tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nco:Contact"); tracker_sparql_builder_predicate (metadata, "nco:fullname"); tracker_sparql_builder_object_unvalidated (metadata, xd->publisher); tracker_sparql_builder_object_blank_close (metadata); } if (xd->type) { tracker_sparql_builder_predicate (metadata, "dc:type"); tracker_sparql_builder_object_unvalidated (metadata, xd->type); } if (xd->format) { tracker_sparql_builder_predicate (metadata, "dc:format"); tracker_sparql_builder_object_unvalidated (metadata, xd->format); } if (xd->identifier) { tracker_sparql_builder_predicate (metadata, "dc:identifier"); tracker_sparql_builder_object_unvalidated (metadata, xd->identifier); } if (xd->source) { tracker_sparql_builder_predicate (metadata, "dc:source"); tracker_sparql_builder_object_unvalidated (metadata, xd->source); } if (xd->language) { tracker_sparql_builder_predicate (metadata, "dc:language"); tracker_sparql_builder_object_unvalidated (metadata, xd->language); } if (xd->relation) { tracker_sparql_builder_predicate (metadata, "dc:relation"); tracker_sparql_builder_object_unvalidated (metadata, xd->relation); } if (xd->coverage) { tracker_sparql_builder_predicate (metadata, "dc:coverage"); tracker_sparql_builder_object_unvalidated (metadata, xd->coverage); } if (xd->license) { tracker_sparql_builder_predicate (metadata, "nie:license"); tracker_sparql_builder_object_unvalidated (metadata, xd->license); } if (xd->make || xd->model) { gchar *equip_uri; equip_uri = tracker_sparql_escape_uri_printf ("urn:equipment:%s:%s:", xd->make ? xd->make : "", xd->model ? xd->model : ""); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, equip_uri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nfo:Equipment"); if (xd->make) { tracker_sparql_builder_predicate (preupdate, "nfo:manufacturer"); tracker_sparql_builder_object_unvalidated (preupdate, xd->make); } if (xd->model) { tracker_sparql_builder_predicate (preupdate, "nfo:model"); tracker_sparql_builder_object_unvalidated (preupdate, xd->model); } if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_predicate (metadata, "nfo:equipment"); tracker_sparql_builder_object_iri (metadata, equip_uri); g_free (equip_uri); } if (xd->orientation) { tracker_sparql_builder_predicate (metadata, "nfo:orientation"); tracker_sparql_builder_object (metadata, xd->orientation); } if (xd->rights) { tracker_sparql_builder_predicate (metadata, "nie:copyright"); tracker_sparql_builder_object_unvalidated (metadata, xd->rights); } if (xd->white_balance) { tracker_sparql_builder_predicate (metadata, "nmm:whiteBalance"); tracker_sparql_builder_object (metadata, xd->white_balance); } if (xd->fnumber) { gdouble value; value = g_strtod (xd->fnumber, NULL); tracker_sparql_builder_predicate (metadata, "nmm:fnumber"); tracker_sparql_builder_object_double (metadata, value); } if (xd->flash) { tracker_sparql_builder_predicate (metadata, "nmm:flash"); tracker_sparql_builder_object (metadata, xd->flash); } if (xd->focal_length) { gdouble value; value = g_strtod (xd->focal_length, NULL); tracker_sparql_builder_predicate (metadata, "nmm:focalLength"); tracker_sparql_builder_object_double (metadata, value); } /* Question: Shouldn't xd->Artist be merged with md.author instead? */ if (xd->artist || xd->contributor) { const gchar *artist; artist = tracker_coalesce_strip (2, xd->artist, xd->contributor); tracker_sparql_builder_predicate (metadata, "nco:contributor"); tracker_sparql_builder_object_blank_open (metadata); tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "nco:Contact"); tracker_sparql_builder_predicate (metadata, "nco:fullname"); tracker_sparql_builder_object_unvalidated (metadata, artist); tracker_sparql_builder_object_blank_close (metadata); } if (xd->exposure_time) { gdouble value; value = g_strtod (xd->exposure_time, NULL); tracker_sparql_builder_predicate (metadata, "nmm:exposureTime"); tracker_sparql_builder_object_double (metadata, value); } if (xd->iso_speed_ratings) { gdouble value; value = g_strtod (xd->iso_speed_ratings, NULL); tracker_sparql_builder_predicate (metadata, "nmm:isoSpeed"); tracker_sparql_builder_object_double (metadata, value); } if (xd->description) { tracker_sparql_builder_predicate (metadata, "nie:description"); tracker_sparql_builder_object_unvalidated (metadata, xd->description); } if (xd->metering_mode) { tracker_sparql_builder_predicate (metadata, "nmm:meteringMode"); tracker_sparql_builder_object (metadata, xd->metering_mode); } if (xd->address || xd->state || xd->country || xd->city || xd->gps_altitude || xd->gps_latitude || xd-> gps_longitude) { tracker_sparql_builder_predicate (metadata, "slo:location"); tracker_sparql_builder_object_blank_open (metadata); /* GeoLocation */ tracker_sparql_builder_predicate (metadata, "a"); tracker_sparql_builder_object (metadata, "slo:GeoLocation"); if (xd->address || xd->state || xd->country || xd->city) { gchar *addruri; addruri = tracker_sparql_get_uuid_urn (); tracker_sparql_builder_predicate (metadata, "slo:postalAddress"); tracker_sparql_builder_object_iri (metadata, addruri); tracker_sparql_builder_insert_open (preupdate, NULL); if (graph) { tracker_sparql_builder_graph_open (preupdate, graph); } tracker_sparql_builder_subject_iri (preupdate, addruri); g_free (addruri); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nco:PostalAddress"); if (xd->address) { tracker_sparql_builder_predicate (preupdate, "nco:streetAddress"); tracker_sparql_builder_object_unvalidated (preupdate, xd->address); } if (xd->state) { tracker_sparql_builder_predicate (preupdate, "nco:region"); tracker_sparql_builder_object_unvalidated (preupdate, xd->state); } if (xd->city) { tracker_sparql_builder_predicate (preupdate, "nco:locality"); tracker_sparql_builder_object_unvalidated (preupdate, xd->city); } if (xd->country) { tracker_sparql_builder_predicate (preupdate, "nco:country"); tracker_sparql_builder_object_unvalidated (preupdate, xd->country); } if (graph) { tracker_sparql_builder_graph_close (preupdate); } tracker_sparql_builder_insert_close (preupdate); } if (xd->gps_altitude) { tracker_sparql_builder_predicate (metadata, "slo:altitude"); tracker_sparql_builder_object_unvalidated (metadata, xd->gps_altitude); } if (xd->gps_latitude) { tracker_sparql_builder_predicate (metadata, "slo:latitude"); tracker_sparql_builder_object_unvalidated (metadata, xd->gps_latitude); } if (xd->gps_longitude) { tracker_sparql_builder_predicate (metadata, "slo:longitude"); tracker_sparql_builder_object_unvalidated (metadata, xd->gps_longitude); } tracker_sparql_builder_object_blank_close (metadata); /* GeoLocation */ } if (xd->regions) { tracker_xmp_apply_regions (preupdate, metadata, graph, xd); } tracker_xmp_free (xd); } else { /* So if we are here we have NO XMP data and we just * write what we know from Poppler. */ write_pdf_data (pd, metadata, keywords); } for (i = 0; i < keywords->len; i++) { gchar *escaped, *subject; const gchar *p; p = g_ptr_array_index (keywords, i); escaped = tracker_sparql_escape_string (p); subject = g_strdup_printf ("_:tag%d", i + 1); /* ensure tag with specified label exists */ tracker_sparql_builder_insert_open (preupdate, graph); tracker_sparql_builder_subject (preupdate, subject); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nao:Tag"); tracker_sparql_builder_predicate (preupdate, "nao:prefLabel"); tracker_sparql_builder_object_unvalidated (preupdate, escaped); tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_append (preupdate, "WHERE { FILTER (NOT EXISTS { " "?tag a nao:Tag ; nao:prefLabel \""); tracker_sparql_builder_append (preupdate, escaped); tracker_sparql_builder_append (preupdate, "\" }) }\n"); /* associate file with tag */ tracker_sparql_builder_insert_open (preupdate, graph); tracker_sparql_builder_subject_iri (preupdate, urn); tracker_sparql_builder_predicate (preupdate, "nao:hasTag"); tracker_sparql_builder_object (preupdate, "?tag"); tracker_sparql_builder_insert_close (preupdate); tracker_sparql_builder_where_open (preupdate); tracker_sparql_builder_subject (preupdate, "?tag"); tracker_sparql_builder_predicate (preupdate, "a"); tracker_sparql_builder_object (preupdate, "nao:Tag"); tracker_sparql_builder_predicate (preupdate, "nao:prefLabel"); tracker_sparql_builder_object_unvalidated (preupdate, escaped); tracker_sparql_builder_where_close (preupdate); g_free (subject); g_free (escaped); } g_ptr_array_free (keywords, TRUE); tracker_sparql_builder_predicate (metadata, "nfo:pageCount"); tracker_sparql_builder_object_int64 (metadata, poppler_document_get_n_pages (document)); config = tracker_main_get_config (); n_bytes = tracker_config_get_max_bytes (config); content = extract_content_text (document, n_bytes); if (content) { tracker_sparql_builder_predicate (metadata, "nie:plainTextContent"); tracker_sparql_builder_object_unvalidated (metadata, content); g_free (content); } read_outline (document, metadata); g_free (xml); g_free (pd.keywords); g_free (pd.title); g_free (pd.subject); g_free (pd.creation_date); g_free (pd.author); g_free (pd.date); g_free (uri); g_object_unref (document); if (contents) { munmap (contents, len); } close (fd); return TRUE; }
static void list_mounts (GList *mounts, int indent, gboolean only_with_no_volume) { GList *l; int c; GMount *mount; GVolume *volume; char *name, *uuid, *uri; GFile *root, *default_location; GIcon *icon; char **x_content_types; char *type_name; for (c = 0, l = mounts; l != NULL; l = l->next, c++) { mount = (GMount *) l->data; if (only_with_no_volume) { volume = g_mount_get_volume (mount); if (volume != NULL) { g_object_unref (volume); continue; } } name = g_mount_get_name (mount); root = g_mount_get_root (mount); uri = g_file_get_uri (root); g_print ("%*sMount(%d): %s -> %s\n", indent, "", c, name, uri); type_name = get_type_name (mount); g_print ("%*sType: %s\n", indent+2, "", type_name); g_free (type_name); if (extra_detail) { uuid = g_mount_get_uuid (mount); if (uuid) g_print ("%*suuid=%s\n", indent + 2, "", uuid); default_location = g_mount_get_default_location (mount); if (default_location) { char *loc_uri = g_file_get_uri (default_location); g_print ("%*sdefault_location=%s\n", indent + 2, "", loc_uri); g_free (loc_uri); g_object_unref (default_location); } icon = g_mount_get_icon (mount); if (icon) { if (G_IS_THEMED_ICON (icon)) show_themed_icon_names (G_THEMED_ICON (icon), indent + 2); g_object_unref (icon); } x_content_types = g_mount_guess_content_type_sync (mount, FALSE, NULL, NULL); if (x_content_types != NULL && g_strv_length (x_content_types) > 0) { int n; g_print ("%*sx_content_types:", indent + 2, ""); for (n = 0; x_content_types[n] != NULL; n++) g_print (" %s", x_content_types[n]); g_print ("\n"); } g_strfreev (x_content_types); g_print ("%*scan_unmount=%d\n", indent + 2, "", g_mount_can_unmount (mount)); g_print ("%*scan_eject=%d\n", indent + 2, "", g_mount_can_eject (mount)); g_print ("%*sis_shadowed=%d\n", indent + 2, "", g_mount_is_shadowed (mount)); g_free (uuid); } g_object_unref (root); g_free (name); g_free (uri); } }
gboolean flatpak_builtin_install (int argc, char **argv, GCancellable *cancellable, GError **error) { g_autoptr(GOptionContext) context = NULL; g_autoptr(GPtrArray) dirs = NULL; g_autoptr(FlatpakDir) dir = NULL; g_autofree char *remote = NULL; g_autofree char *remote_url = NULL; char **prefs = NULL; int i, n_prefs; g_autofree char *target_branch = NULL; g_autofree char *default_branch = NULL; FlatpakKinds kinds; g_autoptr(FlatpakTransaction) transaction = NULL; g_autoptr(FlatpakDir) dir_with_remote = NULL; gboolean auto_remote = FALSE; context = g_option_context_new (_("[LOCATION/REMOTE] [REF…] - Install applications or runtimes")); g_option_context_set_translation_domain (context, GETTEXT_PACKAGE); if (!flatpak_option_context_parse (context, options, &argc, &argv, FLATPAK_BUILTIN_FLAG_ALL_DIRS | FLATPAK_BUILTIN_FLAG_OPTIONAL_REPO, &dirs, cancellable, error)) return FALSE; /* Start with the default or specified dir, this is fine for opt_bundle or opt_from */ dir = g_object_ref (g_ptr_array_index (dirs, 0)); if (!opt_bundle && !opt_from && argc >= 2) { if (flatpak_file_arg_has_suffix (argv[1], ".flatpakref")) opt_from = TRUE; if (flatpak_file_arg_has_suffix (argv[1], ".flatpak")) opt_bundle = TRUE; } if (opt_bundle) return install_bundle (dir, context, argc, argv, cancellable, error); if (opt_from) return install_from (dir, context, argc, argv, cancellable, error); if (argc < 2) return usage_error (context, _("At least one REF must be specified"), error); if (argc == 2) auto_remote = TRUE; kinds = flatpak_kinds_from_bools (opt_app, opt_runtime); if (!opt_noninteractive) g_print (_("Looking for matches…\n")); if (!auto_remote && (g_path_is_absolute (argv[1]) || g_str_has_prefix (argv[1], "./"))) { g_autoptr(GFile) remote_file = g_file_new_for_commandline_arg (argv[1]); remote_url = g_file_get_uri (remote_file); remote = g_strdup (remote_url); } else { g_autoptr(GError) local_error = NULL; /* If the remote was used, and no single dir was specified, find which * one based on the remote. If the remote isn't found assume it's a ref * and we should auto-detect the remote. */ if (!auto_remote && !flatpak_resolve_duplicate_remotes (dirs, argv[1], &dir_with_remote, cancellable, &local_error)) { if (g_error_matches (local_error, FLATPAK_ERROR, FLATPAK_ERROR_REMOTE_NOT_FOUND)) { auto_remote = TRUE; } else { g_propagate_error (error, g_steal_pointer (&local_error)); return FALSE; } } if (!auto_remote) { remote = g_strdup (argv[1]); g_clear_object (&dir); dir = g_object_ref (dir_with_remote); } else { g_autoptr(GPtrArray) remote_dir_pairs = NULL; RemoteDirPair *chosen_pair = NULL; remote_dir_pairs = g_ptr_array_new_with_free_func ((GDestroyNotify) remote_dir_pair_free); /* Search all remotes for a matching ref. This is imperfect * because it only takes the first specified ref into account and * doesn't distinguish between an exact match and a fuzzy match, but * that's okay because the user will be asked to confirm the remote */ for (i = 0; i < dirs->len; i++) { FlatpakDir *this_dir = g_ptr_array_index (dirs, i); g_auto(GStrv) remotes = NULL; guint j = 0; remotes = flatpak_dir_list_remotes (this_dir, cancellable, error); if (remotes == NULL) return FALSE; for (j = 0; remotes[j] != NULL; j++) { const char *this_remote = remotes[j]; g_autofree char *this_default_branch = NULL; g_autofree char *id = NULL; g_autofree char *arch = NULL; g_autofree char *branch = NULL; FlatpakKinds matched_kinds; g_auto(GStrv) refs = NULL; g_autoptr(GError) local_error = NULL; if (flatpak_dir_get_remote_disabled (this_dir, this_remote) || flatpak_dir_get_remote_noenumerate (this_dir, this_remote)) continue; this_default_branch = flatpak_dir_get_remote_default_branch (this_dir, this_remote); flatpak_split_partial_ref_arg_novalidate (argv[1], kinds, opt_arch, target_branch, &matched_kinds, &id, &arch, &branch); if (opt_no_pull) refs = flatpak_dir_find_local_refs (this_dir, this_remote, id, branch, this_default_branch, arch, flatpak_get_default_arch (), matched_kinds, FIND_MATCHING_REFS_FLAGS_FUZZY, cancellable, &local_error); else refs = flatpak_dir_find_remote_refs (this_dir, this_remote, id, branch, this_default_branch, arch, flatpak_get_default_arch (), matched_kinds, FIND_MATCHING_REFS_FLAGS_FUZZY, cancellable, &local_error); if (refs == NULL) { g_warning ("An error was encountered searching remote ‘%s’ for ‘%s’: %s", this_remote, argv[1], local_error->message); continue; } if (g_strv_length (refs) == 0) continue; else { RemoteDirPair *pair = remote_dir_pair_new (this_remote, this_dir); g_ptr_array_add (remote_dir_pairs, pair); } } } if (remote_dir_pairs->len == 0) return flatpak_fail (error, _("No remote refs found similar to ‘%s’"), argv[1]); if (!flatpak_resolve_matching_remotes (opt_yes, remote_dir_pairs, argv[1], &chosen_pair, error)) return FALSE; remote = g_strdup (chosen_pair->remote_name); g_clear_object (&dir); dir = g_object_ref (chosen_pair->dir); } } if (auto_remote) { prefs = &argv[1]; n_prefs = argc - 1; } else { prefs = &argv[2]; n_prefs = argc - 2; } /* Backwards compat for old "REMOTE NAME [BRANCH]" argument version */ if (argc == 4 && flatpak_is_valid_name (argv[2], NULL) && looks_like_branch (argv[3])) { target_branch = g_strdup (argv[3]); n_prefs = 1; } default_branch = flatpak_dir_get_remote_default_branch (dir, remote); if (opt_noninteractive) transaction = flatpak_quiet_transaction_new (dir, error); else transaction = flatpak_cli_transaction_new (dir, opt_yes, TRUE, error); if (transaction == NULL) return FALSE; flatpak_transaction_set_no_pull (transaction, opt_no_pull); flatpak_transaction_set_no_deploy (transaction, opt_no_deploy); flatpak_transaction_set_disable_static_deltas (transaction, opt_no_static_deltas); flatpak_transaction_set_disable_dependencies (transaction, opt_no_deps); flatpak_transaction_set_disable_related (transaction, opt_no_related); flatpak_transaction_set_reinstall (transaction, opt_reinstall); for (i = 0; i < n_prefs; i++) { const char *pref = prefs[i]; FlatpakKinds matched_kinds; g_autofree char *id = NULL; g_autofree char *arch = NULL; g_autofree char *branch = NULL; g_autofree char *ref = NULL; g_auto(GStrv) refs = NULL; guint refs_len; g_autoptr(GError) local_error = NULL; flatpak_split_partial_ref_arg_novalidate (pref, kinds, opt_arch, target_branch, &matched_kinds, &id, &arch, &branch); /* We used _novalidate so that the id can be partial, but we can still validate the branch */ if (branch != NULL && !flatpak_is_valid_branch (branch, &local_error)) return flatpak_fail_error (error, FLATPAK_ERROR_INVALID_REF, _("Invalid branch %s: %s"), branch, local_error->message); if (opt_no_pull) refs = flatpak_dir_find_local_refs (dir, remote, id, branch, default_branch, arch, flatpak_get_default_arch (), matched_kinds, FIND_MATCHING_REFS_FLAGS_FUZZY, cancellable, error); else refs = flatpak_dir_find_remote_refs (dir, remote, id, branch, default_branch, arch, flatpak_get_default_arch (), matched_kinds, FIND_MATCHING_REFS_FLAGS_FUZZY, cancellable, error); if (refs == NULL) return FALSE; refs_len = g_strv_length (refs); if (refs_len == 0) { if (opt_no_pull) g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Nothing matches %s in local repository for remote %s"), id, remote); else g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, _("Nothing matches %s in remote %s"), id, remote); return FALSE; } if (!flatpak_resolve_matching_refs (remote, dir, opt_yes, refs, id, &ref, error)) return FALSE; if (!flatpak_transaction_add_install (transaction, remote, ref, (const char **)opt_subpaths, error)) { if (!g_error_matches (*error, FLATPAK_ERROR, FLATPAK_ERROR_ALREADY_INSTALLED)) return FALSE; g_printerr (_("Skipping: %s\n"), (*error)->message); g_clear_error (error); } } if (!flatpak_transaction_run (transaction, cancellable, error)) { if (g_error_matches (*error, FLATPAK_ERROR, FLATPAK_ERROR_ABORTED)) { g_clear_error (error); return TRUE; } return FALSE; } return TRUE; }
/** * tracker_media_art_get_path: * @artist: the artist * @title: the title * @prefix: For example "album" * @uri: NULL or the uri of the file * @path: the location to store the local path * @local_uri: the location to store the local uri or NULL * * Get the path to media art for a given resource. Newly allocated data in * @path and @local_uri must be freed with g_free. * * Since: 0.10.14 */ void tracker_media_art_get_path (const gchar *artist, const gchar *title, const gchar *prefix, const gchar *uri, gchar **path, gchar **local_uri) { const gchar *space_checksum = "7215ee9c7d9dc229d2921a40e899ec5f"; gchar *art_filename; gchar *dir; gchar *artist_down, *title_down; gchar *artist_stripped, *title_stripped; gchar *artist_norm, *title_norm; gchar *artist_checksum = NULL, *title_checksum = NULL; /* http://live.gnome.org/MediaArtStorageSpec */ if (path) { *path = NULL; } if (local_uri) { *local_uri = NULL; } if (!artist && !title) { return; } if (artist) { artist_stripped = tracker_media_art_strip_invalid_entities (artist); artist_norm = g_utf8_normalize (artist_stripped, -1, G_NORMALIZE_NFKD); artist_down = g_utf8_strdown (artist_norm, -1); artist_checksum = media_art_checksum_for_data (G_CHECKSUM_MD5, (const guchar *) artist_down, strlen (artist_down)); } if (title) { title_stripped = tracker_media_art_strip_invalid_entities (title); title_norm = g_utf8_normalize (title_stripped, -1, G_NORMALIZE_NFKD); title_down = g_utf8_strdown (title_norm, -1); title_checksum = media_art_checksum_for_data (G_CHECKSUM_MD5, (const guchar *) title_down, strlen (title_down)); } dir = g_build_filename (g_get_user_cache_dir (), "media-art", NULL); if (!g_file_test (dir, G_FILE_TEST_EXISTS)) { g_mkdir_with_parents (dir, 0770); } art_filename = g_strdup_printf ("%s-%s-%s.jpeg", prefix ? prefix : "album", artist ? artist_checksum : space_checksum, title ? title_checksum : space_checksum); if (artist) { g_free (artist_checksum); g_free (artist_stripped); g_free (artist_down); g_free (artist_norm); } if (title) { g_free (title_checksum); g_free (title_stripped); g_free (title_down); g_free (title_norm); } if (path) { *path = g_build_filename (dir, art_filename, NULL); } if (local_uri) { gchar *local_dir; GFile *file, *parent; if (strstr (uri, "://")) { file = g_file_new_for_uri (uri); } else { file = g_file_new_for_path (uri); } parent = g_file_get_parent (file); if (parent) { local_dir = g_file_get_uri (parent); /* This is a URI, don't use g_build_filename here */ *local_uri = g_strdup_printf ("%s/.mediaartlocal/%s", local_dir, art_filename); g_free (local_dir); g_object_unref (parent); } g_object_unref (file); } g_free (dir); g_free (art_filename); }
static void load_files (const char **files) { GdkScreen *screen = gdk_screen_get_default (); EvWindowRunMode mode = EV_WINDOW_MODE_NORMAL; gint i; EvLinkDest *global_dest = NULL; if (!files) { if (!ev_application_has_window (EV_APP)) ev_application_open_window (EV_APP, screen, GDK_CURRENT_TIME); return; } if (ev_page_label) global_dest = ev_link_dest_new_page_label (ev_page_label); else if (ev_page_index) global_dest = ev_link_dest_new_page (MAX (0, ev_page_index - 1)); if (fullscreen_mode) mode = EV_WINDOW_MODE_FULLSCREEN; else if (presentation_mode) mode = EV_WINDOW_MODE_PRESENTATION; for (i = 0; files[i]; i++) { const gchar *filename; gchar *uri; gchar *label; GFile *file; EvLinkDest *dest = NULL; const gchar *app_uri; filename = files[i]; label = get_label_from_filename (filename); if (label) { *label = 0; label++; dest = ev_link_dest_new_page_label (label); } else if (global_dest) { dest = g_object_ref (global_dest); } file = g_file_new_for_commandline_arg (filename); uri = g_file_get_uri (file); g_object_unref (file); app_uri = ev_application_get_uri (EV_APP); if (app_uri && strcmp (app_uri, uri) == 0) { g_free (uri); continue; } ev_application_open_uri_at_dest (EV_APP, uri, screen, dest, mode, ev_find_string, GDK_CURRENT_TIME); if (dest) g_object_unref (dest); g_free (uri); } }
static char * get_uri_func (GthFileData *file_data) { return g_file_get_uri (file_data->file); }
gboolean checkcopy_file_list_write_checksum (CheckcopyFileList * list, GFile * dest) { CheckcopyFileListPrivate *priv = GET_PRIVATE (list); GOutputStream * out; GCancellable * cancel; GError *error = NULL; gboolean aborted; cancel = checkcopy_get_cancellable (); if (priv->verify_only) { g_message ("Not writing checksum file because we are only verifying"); return TRUE; } /* If we got cancelled, we still want to try this operation. * So remember the state of the cancellable, and continue */ if ((aborted = g_cancellable_is_cancelled (cancel)) == TRUE) g_cancellable_reset (cancel); out = get_checksum_stream (list, dest); if (out) { /* Write the file */ GList * file_list; GList * curr_file; file_list = checkcopy_file_list_get_sorted_list (list); for (curr_file = file_list; curr_file != NULL; curr_file = g_list_next (curr_file)) { CheckcopyFileInfo * info = (CheckcopyFileInfo *) curr_file->data; gchar * line; gint n; gsize n_written; gboolean r = FALSE; if (!(info->status==CHECKCOPY_STATUS_COPIED || info->status==CHECKCOPY_STATUS_VERIFICATION_FAILED)) { continue; } n = checkcopy_file_info_format_checksum (info, &line); if (!g_cancellable_set_error_if_cancelled (cancel, &error)) r = g_output_stream_write_all (out, line, n, &n_written, cancel, &error); if (!r || n != n_written) { gchar * disp_name; disp_name = g_file_get_uri (priv->checksum_file); if (error) { g_critical ("While writing checksum file %s: %s", disp_name, error->message); g_error_free (error); } else { g_critical ("Only wrote %u of %d bytes of checksum file %s", n_written, n, disp_name); } g_free (disp_name); } if (error) { thread_show_gerror (dest, error); g_error_free (error); error = NULL; g_free (line); break; } g_free (line); } /* for */ if (!g_cancellable_set_error_if_cancelled (cancel, &error)) g_output_stream_close (out, cancel, &error); if (error) { thread_show_gerror (dest, error); g_error_free (error); error = NULL; } g_list_free (file_list); } if (aborted && !g_cancellable_is_cancelled (cancel)) { g_cancellable_cancel (cancel); } return out != NULL; }
GimpImage * file_open_image (Gimp *gimp, GimpContext *context, GimpProgress *progress, GFile *file, GFile *entered_file, gboolean as_new, GimpPlugInProcedure *file_proc, GimpRunMode run_mode, GimpPDBStatusType *status, const gchar **mime_type, GError **error) { GimpValueArray *return_vals; GimpImage *image = NULL; GFile *local_file = NULL; gchar *path = NULL; gchar *entered_uri = NULL; GError *my_error = NULL; g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); g_return_val_if_fail (G_IS_FILE (file), NULL); g_return_val_if_fail (G_IS_FILE (entered_file), NULL); g_return_val_if_fail (status != NULL, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); *status = GIMP_PDB_EXECUTION_ERROR; /* FIXME enable these tests for remote files again, needs testing */ if (g_file_is_native (file) && g_file_query_exists (file, NULL)) { GFileInfo *info; info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_TYPE "," G_FILE_ATTRIBUTE_ACCESS_CAN_READ, G_FILE_QUERY_INFO_NONE, NULL, error); if (! info) return NULL; if (g_file_info_get_file_type (info) != G_FILE_TYPE_REGULAR) { g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("Not a regular file")); g_object_unref (info); return NULL; } if (! g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ)) { g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("Permission denied")); g_object_unref (info); return NULL; } g_object_unref (info); } if (! file_proc) file_proc = file_procedure_find (gimp->plug_in_manager->load_procs, file, error); if (! file_proc) return NULL; if (! g_file_is_native (file) && ! file_remote_mount_file (gimp, file, progress, &my_error)) { if (my_error) g_propagate_error (error, my_error); else *status = GIMP_PDB_CANCEL; return NULL; } if (! file_proc->handles_uri) { path = g_file_get_path (file); if (! path) { local_file = file_remote_download_image (gimp, file, progress, &my_error); if (! local_file) { if (my_error) g_propagate_error (error, my_error); else *status = GIMP_PDB_CANCEL; return NULL; } path = g_file_get_path (local_file); } } if (! path) path = g_file_get_uri (file); entered_uri = g_file_get_uri (entered_file); if (! entered_uri) entered_uri = g_strdup (path); return_vals = gimp_pdb_execute_procedure_by_name (gimp->pdb, context, progress, error, gimp_object_get_name (file_proc), GIMP_TYPE_INT32, run_mode, G_TYPE_STRING, path, G_TYPE_STRING, entered_uri, G_TYPE_NONE); g_free (path); g_free (entered_uri); *status = g_value_get_enum (gimp_value_array_index (return_vals, 0)); if (*status == GIMP_PDB_SUCCESS) image = gimp_value_get_image (gimp_value_array_index (return_vals, 1), gimp); if (local_file) { if (image) gimp_image_set_file (image, file); g_file_delete (local_file, NULL, NULL); g_object_unref (local_file); } if (*status == GIMP_PDB_SUCCESS) { if (image) { file_open_sanitize_image (image, as_new); /* Only set the load procedure if it hasn't already been set. */ if (! gimp_image_get_load_proc (image)) gimp_image_set_load_proc (image, file_proc); file_proc = gimp_image_get_load_proc (image); if (mime_type) *mime_type = file_proc->mime_type; } else { if (error && ! *error) g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("%s plug-in returned SUCCESS but did not " "return an image"), gimp_plug_in_procedure_get_label (file_proc)); *status = GIMP_PDB_EXECUTION_ERROR; } } else if (*status != GIMP_PDB_CANCEL) { if (error && ! *error) g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("%s plug-In could not open image"), gimp_plug_in_procedure_get_label (file_proc)); } gimp_value_array_unref (return_vals); if (image) { file_open_handle_color_profile (image, context, progress, run_mode); if (file_open_file_proc_is_import (file_proc)) { /* Remember the import source */ gimp_image_set_imported_file (image, file); /* We shall treat this file as an Untitled file */ gimp_image_set_file (image, NULL); } } return image; }
/* File loading */ static gint load_file_list (CeditWindow *window, GSList *files, const CeditEncoding *encoding, gint line_pos, gboolean create) { CeditTab *tab; gint loaded_files = 0; /* Number of files to load */ gboolean jump_to = TRUE; /* Whether to jump to the new tab */ GList *win_docs; GSList *files_to_load = NULL; GSList *l; cedit_debug (DEBUG_COMMANDS); win_docs = cedit_window_get_documents (window); /* Remove the uris corresponding to documents already open * in "window" and remove duplicates from "uris" list */ for (l = files; l != NULL; l = l->next) { if (!is_duplicated_file (files_to_load, l->data)) { tab = get_tab_from_file (win_docs, l->data); if (tab != NULL) { if (l == files) { cedit_window_set_active_tab (window, tab); jump_to = FALSE; if (line_pos > 0) { CeditDocument *doc; CeditView *view; doc = cedit_tab_get_document (tab); view = cedit_tab_get_view (tab); /* document counts lines starting from 0 */ cedit_document_goto_line (doc, line_pos - 1); cedit_view_scroll_to_cursor (view); } } ++loaded_files; } else { files_to_load = g_slist_prepend (files_to_load, l->data); } } } g_list_free (win_docs); if (files_to_load == NULL) return loaded_files; files_to_load = g_slist_reverse (files_to_load); l = files_to_load; tab = cedit_window_get_active_tab (window); if (tab != NULL) { CeditDocument *doc; doc = cedit_tab_get_document (tab); if (cedit_document_is_untouched (doc) && (cedit_tab_get_state (tab) == CEDIT_TAB_STATE_NORMAL)) { gchar *uri; // FIXME: pass the GFile to tab when api is there uri = g_file_get_uri (l->data); _cedit_tab_load (tab, uri, encoding, line_pos, create); g_free (uri); l = g_slist_next (l); jump_to = FALSE; ++loaded_files; } } while (l != NULL) { gchar *uri; g_return_val_if_fail (l->data != NULL, 0); // FIXME: pass the GFile to tab when api is there uri = g_file_get_uri (l->data); tab = cedit_window_create_tab_from_uri (window, uri, encoding, line_pos, create, jump_to); g_free (uri); if (tab != NULL) { jump_to = FALSE; ++loaded_files; } l = g_slist_next (l); } if (loaded_files == 1) { CeditDocument *doc; gchar *uri_for_display; g_return_val_if_fail (tab != NULL, loaded_files); doc = cedit_tab_get_document (tab); uri_for_display = cedit_document_get_uri_for_display (doc); cedit_statusbar_flash_message (CEDIT_STATUSBAR (window->priv->statusbar), window->priv->generic_message_cid, _("Loading file '%s'\342\200\246"), uri_for_display); g_free (uri_for_display); } else { cedit_statusbar_flash_message (CEDIT_STATUSBAR (window->priv->statusbar), window->priv->generic_message_cid, ngettext("Loading %d file\342\200\246", "Loading %d files\342\200\246", loaded_files), loaded_files); } /* Free uris_to_load. Note that l points to the first element of uris_to_load */ g_slist_free (files_to_load); return loaded_files; }
static gboolean slot_proxy_drag_motion (GtkWidget *widget, GdkDragContext *context, int x, int y, unsigned int time, gpointer user_data) { NautilusDragSlotProxyInfo *drag_info; NautilusWindowSlot *target_slot; GtkWidget *window; GdkAtom target; int action; char *target_uri; drag_info = user_data; action = 0; if (gtk_drag_get_source_widget (context) == widget) { goto out; } window = gtk_widget_get_toplevel (widget); g_assert (NAUTILUS_IS_WINDOW (window)); if (!drag_info->have_data) { target = gtk_drag_dest_find_target (widget, context, NULL); if (target == GDK_NONE) { goto out; } gtk_drag_get_data (widget, context, target, time); } target_uri = NULL; if (drag_info->target_location != NULL) { target_uri = g_file_get_uri (drag_info->target_location); } else { if (drag_info->target_slot != NULL) { target_slot = drag_info->target_slot; } else { target_slot = nautilus_window_get_active_slot (NAUTILUS_WINDOW (window)); } if (target_slot != NULL) { target_uri = nautilus_window_slot_get_current_uri (target_slot); } } if (drag_info->have_data && drag_info->have_valid_data) { if (drag_info->info == NAUTILUS_ICON_DND_GNOME_ICON_LIST) { nautilus_drag_default_drop_action_for_icons (context, target_uri, drag_info->data.selection_list, &action); } else if (drag_info->info == NAUTILUS_ICON_DND_URI_LIST) { action = nautilus_drag_default_drop_action_for_uri_list (context, target_uri); } else if (drag_info->info == NAUTILUS_ICON_DND_NETSCAPE_URL) { action = nautilus_drag_default_drop_action_for_netscape_url (context); } } g_free (target_uri); out: if (action != 0) { gtk_drag_highlight (widget); } else { gtk_drag_unhighlight (widget); } gdk_drag_status (context, action, time); return TRUE; }
static void queryInfoCallback(GObject* source, GAsyncResult* res, gpointer data) { ResourceHandle* handle = static_cast<ResourceHandle*>(data); ResourceHandleInternal* d = handle->getInternal(); ResourceHandleClient* client = handle->client(); if (d->m_cancelled) { cleanupGioOperation(handle); return; } ResourceResponse response; char* uri = g_file_get_uri(d->m_gfile); response.setUrl(KURL(uri)); g_free(uri); GError *error = NULL; GFileInfo* info = g_file_query_info_finish(d->m_gfile, res, &error); if (error) { // FIXME: to be able to handle ftp URIs properly, we must // check if the error is G_IO_ERROR_NOT_MOUNTED, and if so, // call g_file_mount_enclosing_volume() to mount the ftp // server (and then keep track of the fact that we mounted it, // and set a timeout to unmount it later after it's been idle // for a while). cleanupGioOperation(handle); if (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_FOUND) response.setHTTPStatusCode(SOUP_STATUS_NOT_FOUND); else if (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_PERMISSION_DENIED) response.setHTTPStatusCode(SOUP_STATUS_FORBIDDEN); else response.setHTTPStatusCode(SOUP_STATUS_BAD_REQUEST); // ? g_error_free(error); // FIXME: do we need to fake up a response body containing the // error message? client->didReceiveResponse(handle, response); client->didFinishLoading(handle); return; } if (g_file_info_get_file_type(info) != G_FILE_TYPE_REGULAR) { // FIXME: what if the URI points to a directory? Should we // generate a listing? How? What do other backends do here? cleanupGioOperation(handle); response.setHTTPStatusCode(SOUP_STATUS_FORBIDDEN); // ? client->didReceiveResponse(handle, response); client->didFinishLoading(handle); return; } response.setMimeType(g_file_info_get_content_type(info)); response.setExpectedContentLength(g_file_info_get_size(info)); response.setHTTPStatusCode(SOUP_STATUS_OK); GTimeVal tv; g_file_info_get_modification_time(info, &tv); response.setLastModifiedDate(tv.tv_sec); client->didReceiveResponse(handle, response); g_file_read_async(d->m_gfile, G_PRIORITY_DEFAULT, d->m_cancellable, openCallback, handle); }