static int
file_open_file(prop_t *page, const char *url, struct fa_stat *fs)
{
char redir[URL_MAX];
char errbuf[200];
int c;
prop_t *meta;
meta = prop_create_root("metadata");
c = fa_probe(meta, url, redir, sizeof(redir), errbuf, sizeof(errbuf), fs, 1);
switch(c) {
case CONTENT_ARCHIVE:
case CONTENT_ALBUM:
prop_destroy(meta);
return file_open_dir(page, redir);
case CONTENT_AUDIO:
if(!file_open_audio(page, url)) {
prop_destroy(meta);
return 0;
}
playqueue_play(url, meta, 0);
return playqueue_open(page);
case CONTENT_VIDEO:
case CONTENT_DVD:
prop_destroy(meta);
return backend_open_video(page, url);
case CONTENT_IMAGE:
return file_open_image(page, meta);
case CONTENT_PLUGIN:
plugin_open_file(page, url);
return 0;
default:
prop_destroy(meta);
return nav_open_error(page, errbuf);
}
}
static void
file_open_file(prop_t *page, const char *url, fa_stat_t *fs)
{
char errbuf[200];
metadata_t *md;
void *db = metadb_get();
md = metadb_metadata_get(db, url, fs->fs_mtime);
metadb_close(db);
if(md == NULL)
md = fa_probe_metadata(url, errbuf, sizeof(errbuf), NULL);
if(md == NULL) {
nav_open_errorf(page, _("Unable to open file: %s"), errbuf);
return;
}
if(md->md_redirect != NULL)
url = md->md_redirect;
prop_t *meta = prop_create_root("metadata");
metadata_to_proptree(md, meta, 0);
switch(md->md_contenttype) {
case CONTENT_ARCHIVE:
case CONTENT_ALBUM:
file_open_browse(page, url, fs->fs_mtime);
break;
case CONTENT_AUDIO:
if(!file_open_audio(page, url)) {
break;
}
playqueue_play(url, meta, 0);
playqueue_open(page);
meta = NULL;
break;
case CONTENT_VIDEO:
case CONTENT_DVD:
backend_open_video(page, url, 0);
break;
case CONTENT_IMAGE:
file_open_image(page, meta);
meta = NULL;
break;
case CONTENT_PLUGIN:
plugin_open_file(page, url);
break;
default:
nav_open_errorf(page, _("Can't handle content type %d"),
md->md_contenttype);
break;
}
prop_destroy(meta);
metadata_destroy(md);
}
GList *
file_open_layers (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GimpImage *dest_image,
gboolean merge_visible,
GFile *file,
GimpRunMode run_mode,
GimpPlugInProcedure *file_proc,
GimpPDBStatusType *status,
GError **error)
{
GimpImage *new_image;
GList *layers = NULL;
const gchar *mime_type = 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 (GIMP_IS_IMAGE (dest_image), NULL);
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (status != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
new_image = file_open_image (gimp, context, progress,
file, file, FALSE,
file_proc,
run_mode,
status, &mime_type, error);
if (new_image)
{
gint n_visible = 0;
gimp_image_undo_disable (new_image);
layers = file_open_get_layers (new_image, merge_visible, &n_visible);
if (merge_visible && n_visible > 1)
{
GimpLayer *layer;
g_list_free (layers);
layer = gimp_image_merge_visible_layers (new_image, context,
GIMP_CLIP_TO_IMAGE,
FALSE, FALSE);
layers = g_list_prepend (NULL, layer);
}
if (layers)
{
gchar *basename;
basename = g_path_get_basename (gimp_file_get_utf8_name (file));
file_open_convert_items (dest_image, basename, layers);
g_free (basename);
gimp_document_list_add_file (GIMP_DOCUMENT_LIST (gimp->documents),
file, mime_type);
}
else
{
g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
_("Image doesn't contain any layers"));
*status = GIMP_PDB_EXECUTION_ERROR;
}
g_object_unref (new_image);
}
return g_list_reverse (layers);
}
GimpImage *
file_open_with_proc_and_display (Gimp *gimp,
GimpContext *context,
GimpProgress *progress,
GFile *file,
GFile *entered_file,
gboolean as_new,
GimpPlugInProcedure *file_proc,
GObject *screen,
gint monitor,
GimpPDBStatusType *status,
GError **error)
{
GimpImage *image;
const gchar *mime_type = 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 (screen == NULL || G_IS_OBJECT (screen), NULL);
g_return_val_if_fail (status != NULL, NULL);
image = file_open_image (gimp, context, progress,
file,
entered_file,
as_new,
file_proc,
GIMP_RUN_INTERACTIVE,
status,
&mime_type,
error);
if (image)
{
/* If the file was imported we want to set the layer name to the
* file name. For now, assume that multi-layered imported images
* have named the layers already, so only rename the layer of
* single-layered imported files. Note that this will also
* rename already named layers from e.g. single-layered PSD
* files. To solve this properly, we would need new file plug-in
* API.
*/
if (! file_proc)
file_proc = gimp_image_get_load_proc (image);
if (file_open_file_proc_is_import (file_proc) &&
gimp_image_get_n_layers (image) == 1)
{
GimpObject *layer = gimp_image_get_layer_iter (image)->data;
gchar *basename;
basename = g_path_get_basename (gimp_file_get_utf8_name (file));
gimp_item_rename (GIMP_ITEM (layer), basename, NULL);
gimp_image_undo_free (image);
gimp_image_clean_all (image);
g_free (basename);
}
if (gimp_create_display (image->gimp, image, GIMP_UNIT_PIXEL, 1.0,
screen, monitor))
{
/* the display owns the image now */
g_object_unref (image);
}
if (! as_new)
{
GimpDocumentList *documents = GIMP_DOCUMENT_LIST (gimp->documents);
GimpImagefile *imagefile;
GFile *any_file;
imagefile = gimp_document_list_add_file (documents, file, mime_type);
/* can only create a thumbnail if the passed file and the
* resulting image's file match. Use any_file() here so we
* create thumbnails for both XCF and imported images.
*/
any_file = gimp_image_get_any_file (image);
if (any_file && g_file_equal (file, any_file))
{
/* no need to save a thumbnail if there's a good one already */
if (! gimp_imagefile_check_thumbnail (imagefile))
{
gimp_imagefile_save_thumbnail (imagefile, mime_type, image,
NULL);
}
}
}
/* announce that we opened this image */
gimp_image_opened (image->gimp, file);
}
return image;
}
