import_jobs.c

Go to the documentation of this file.

/*
    This file is part of the Ansel project.
    Copyright (C) 2025-2026 Aurélien PIERRE.
    
    Ansel is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    Ansel is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with Ansel.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "system/mem_alloc.h"
#include "common/paths.h"   // DT_PATH_MAX
#include "common/conf.h"
#include "import_jobs.h"
#include "import_sequence.h"
#include "common/collection.h"
#include "common/datetime.h"
#include "metadata/exif.h"
#include "develop/history_merge.h"
#include "metadata/metadata.h"
#include "common/styles.h"
#include "control/control.h"
#include "common/film.h"
#include "common/image.h"
#include "control/jobs/control_jobs.h"
 
#ifndef _WIN32
#endif
#include <string.h>
#include <glib/gstdio.h>
#include "common/utility.h"
#ifdef __APPLE__
#include "osx/osx.h"
#endif
#ifdef _WIN32
#endif
 
 
gboolean _create_dir(const char *path)
{
  if(g_mkdir_with_parents(path, 0755) == -1)
  {
    fprintf(stderr, "failed to create directory %s.\n", path);
    dt_control_log(_("Impossible to create directory %s.\nThe target may be full or read-only.\n"), path);
    return TRUE;
  }
  return FALSE;
}
 
gchar *_path_cleanup(gchar *path_in)
{
  gchar *clean = dt_cleanup_separators(path_in);
  gchar *path_out = dt_util_remove_whitespace(clean);
  dt_free(clean);
  return path_out;
}
 
gchar *dt_build_filename_from_pattern(const char *const filename, const int index, dt_image_t *img, dt_control_import_t *data)
{
  dt_variables_params_t *params;
  dt_variables_params_init(&params);
  // Borrowed references, like every other dt_variables_params_t caller (see iop/watermark.c):
  // dt_variables_params_destroy() does not own/free filename or jobcode.
  params->filename = filename;
  params->sequence = index;
  params->jobcode = data->jobcode;
  params->imgid = UNKNOWN_IMAGE;
  params->img = img;
  dt_variables_set_datetime(params, data->datetime);
 
  if(IS_NULL_PTR(data->base_folder) || IS_NULL_PTR(data->target_file_pattern)
     || IS_NULL_PTR(data->target_subfolder_pattern))
  {
    dt_variables_params_destroy(params);
    return NULL;
  }
 
  gchar *file_expand = dt_variables_expand(params, data->target_file_pattern, FALSE);
  gchar *path_expand = dt_variables_expand(params, data->target_subfolder_pattern, FALSE);
  if(IS_NULL_PTR(file_expand) || IS_NULL_PTR(path_expand))
  {
    dt_free(file_expand);
    dt_free(path_expand);
    dt_variables_params_destroy(params);
    return NULL;
  }
 
  // remove this if we decide to do the correction on user's settings directly
  gchar *file = _path_cleanup(file_expand);
  gchar *path = _path_cleanup(path_expand);
  dt_free(file_expand);
  dt_free(path_expand);
  if(IS_NULL_PTR(file) || IS_NULL_PTR(path))
  {
    dt_free(file);
    dt_free(path);
    dt_variables_params_destroy(params);
    return NULL;
  }
 
  gchar *dir = g_build_path(G_DIR_SEPARATOR_S, data->base_folder, path, (char *) NULL);
  gchar *target_dir = IS_NULL_PTR(dir) ? NULL : dt_util_normalize_path(dir);
  gchar *res = IS_NULL_PTR(target_dir) ? NULL : g_build_path(G_DIR_SEPARATOR_S, target_dir, file, (char *) NULL);
 
  if(!IS_NULL_PTR(res))
  {
    data->target_dir = target_dir;
    target_dir = NULL;
    dt_print(DT_DEBUG_PRINT, "[Import] Importing file to %s\n", res);
  }
 
  dt_free(file);
  dt_free(path);
  dt_free(dir);
  dt_free(target_dir);
  dt_variables_params_destroy(params);
  return res;
}
 
gboolean _file_exist(const char *dest_file_path)
{
  return !IS_NULL_PTR(dest_file_path) && dest_file_path[0] && g_file_test(dest_file_path, G_FILE_TEST_EXISTS);
}
 
gboolean _copy_file(const char *filename, const char *dest_file_path)
{
  GFile *in = g_file_new_for_path(filename);
  GFile *out = g_file_new_for_path(dest_file_path);
 
  gboolean res = g_file_copy(in, out, G_FILE_COPY_NONE, 0, 0, 0, NULL);
  if(!res) dt_print(DT_DEBUG_IMPORT, "[Import] Could not copy the file %s to %s\n", filename, dest_file_path);
 
  g_object_unref(in);
  g_object_unref(out);
 
  return res;
}
 
const int32_t _import_job(dt_control_import_t *data, gchar *img_path_to_db)
{
  gchar *dirname = g_strdup(dt_util_path_get_dirname(img_path_to_db));
 
  dt_film_t film;
  const int32_t filmid = dt_film_new(&film, dirname);
  // Regular imports skip the per-file DT_SIGNAL_IMAGE_IMPORT (large batches
  // would otherwise raise it hundreds of times). Folder survey imports one or
  // a few files at a time, and Studio Capture needs that signal to know which
  // image to display as soon as it lands, so raise it for that case only.
  const int32_t imgid = dt_image_import(filmid, img_path_to_db, data->folder_survey);
  dt_free(dirname);
  return imgid;
}
 
void dt_import_duplicate_get_dest_name(char *xmp_dest_name, const char *dest_file_path, const int counter)
{
  char *norm_dest_file = dt_util_normalize_path(dest_file_path);
  char *ext = norm_dest_file + safe_strlen(norm_dest_file);
  while(*ext != '.' && ext > norm_dest_file) ext--;
  const size_t name_len = safe_strlen(norm_dest_file) - safe_strlen(ext);
 
  if(counter == 0)
    g_snprintf(xmp_dest_name, DT_PATH_MAX, "%s.xmp", norm_dest_file);
  else
    g_snprintf(xmp_dest_name, DT_PATH_MAX, "%.*s_%.2d%s.xmp", (int)name_len, norm_dest_file, counter, ext);
 
  dt_print(DT_DEBUG_IMPORT, "[Import] XMP destination name: %s\n", xmp_dest_name);
 
  dt_free(norm_dest_file);
}
 
int _import_copy_xmp(const char *const filename, const gchar *dest_file_path)
{
  int xmp_cntr = 0;
 
  GList *xmp_files = dt_image_find_xmps(filename); // the first xmp will be the original
  if(g_list_length(xmp_files) > 0)
  {
    for(GList *current_xmp = xmp_files; current_xmp; current_xmp = g_list_next(current_xmp))
    {
      char *xmp_source = g_strdup((char*) current_xmp->data);
      gchar xmp_dest_name[DT_PATH_MAX] = { 0 };
      dt_import_duplicate_get_dest_name(xmp_dest_name, dest_file_path, xmp_cntr);
 
      // folder already created and writable, just copy.
      int success = _copy_file(xmp_source, xmp_dest_name);
      dt_print(DT_DEBUG_IMPORT, "[Import] copying %s to %s %s\n", xmp_source, xmp_dest_name,
               (success) ? "succeeded" : "failed");
      if(success) xmp_cntr++;
      dt_free(xmp_source);
    }
  }
  g_list_free(xmp_files);
  xmp_files = NULL;
  return xmp_cntr;
}
 
int _import_copy_txt(const char *const filename, const char *dest_file_path)
{
  char *txt_source = dt_image_get_text_path_from_path(filename);
  if(IS_NULL_PTR(txt_source)) return 0;
 
  char *txt_dest = dt_image_build_text_path_from_path(dest_file_path);
  int success = 0;
 
  if(!IS_NULL_PTR(txt_dest))
  {
    success = _copy_file(txt_source, txt_dest);
    dt_print(DT_DEBUG_IMPORT, "[Import] copying %s to %s %s\n", txt_source, txt_dest,
             (success) ? "succeeded" : "failed");
  }
 
  dt_free(txt_dest);
  dt_free(txt_source);
  return success ? 1 : 0;
}
 
int _import_copy_file(const char *const filename, const char *const dest_file_path, dt_control_import_t *data,
                      gchar *img_path_to_db, size_t pathname_len, GList **discarded)
{
  dt_print(DT_DEBUG_IMPORT, "[Import] Image %s will be copied into %s\n", filename, dest_file_path);
 
  int copied = -1;
  char *unique_destination = NULL;
  const char *copy_destination = dest_file_path;
 
  gboolean exists = _file_exist(copy_destination);
 
  // Resolve a name collision according to the requested policy. UNIQUE rewrites
  // the destination to a free "<stem>_NN.<ext>" so the copy proceeds normally.
  if(exists && data->on_conflict == DT_IMPORT_ONCONFLICT_UNIQUE)
  {
    const char *dot = strrchr(copy_destination, '.');
    const int stem_len = dot ? (int)(dot - copy_destination) : (int)strlen(copy_destination);
    const char *ext = dot ? dot : "";
    for(int seq = 1; seq < 10000; seq++)
    {
      dt_free(unique_destination);
      unique_destination = g_strdup_printf("%.*s_%02d%s", stem_len, copy_destination, seq, ext);
      if(!_file_exist(unique_destination)) break;
    }
    copy_destination = unique_destination;
    exists = FALSE;
  }
 
  // OVERWRITE deletes the stale destination so g_file_copy() (G_FILE_COPY_NONE)
  // does not fail on an existing target.
  if(exists && data->on_conflict == DT_IMPORT_ONCONFLICT_OVERWRITE)
  {
    g_unlink(copy_destination);
    exists = FALSE;
  }
 
  if(exists)
  {
    *discarded = g_list_prepend(*discarded, g_strdup(filename));
    g_strlcpy(img_path_to_db, copy_destination, pathname_len);
    dt_print(DT_DEBUG_IMPORT, "[Import] File copy skipped, the target file %s already exists on the destination.\n", copy_destination);
    copied = 0;
    goto cleanup;
  }
 
  if(dt_util_dir_exist(data->target_dir))
    dt_print(DT_DEBUG_PRINT, "[Import] target folder %s already exists. Nothing to do.\n", data->target_dir);
  else if(_create_dir(data->target_dir))
  {
    fprintf(stdout, "[Import] Unable to create the target folder %s.\n", data->target_dir);
    goto cleanup;
  }
 
  if(!dt_util_test_writable_dir(data->target_dir))
  {
    fprintf(stdout, "[Import] Not allowed to write in the %s folder.\n", data->target_dir);
    goto cleanup;
  }
 
  if(!_copy_file(filename, copy_destination))
  {
    fprintf(stderr, "[Import] Unable to copy the file %s to %s.\n", filename, copy_destination);
    goto cleanup;
  }
 
  _import_copy_xmp(filename, copy_destination);
  _import_copy_txt(filename, copy_destination);
  g_strlcpy(img_path_to_db, copy_destination, pathname_len);
  copied = 1;
 
cleanup:
  dt_free(unique_destination)
  return copied;
}
 
void _write_xmp_id(const char *filename, int32_t imgid)
{
  GList *res = dt_metadata_get(imgid, "Xmp.darktable.image_id", NULL);
  if(!IS_NULL_PTR(res))
  {
    // Image ID is already set in metadata, don't overwrite it
    g_list_free_full(res, dt_free_gpointer);
    res = NULL;
    return;
  }
  // else : init it
  GError *error = NULL;
  GFile *gfile = g_file_new_for_path(filename);
  GFileInfo *info = g_file_query_info(gfile,
                            G_FILE_ATTRIBUTE_STANDARD_NAME ","
                            G_FILE_ATTRIBUTE_TIME_MODIFIED,
                            G_FILE_QUERY_INFO_NONE, NULL, &error);
  const char *fn = g_file_info_get_name(info);
 
  const time_t datetime = g_file_info_get_attribute_uint64(info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
  char dt_txt[DT_DATETIME_EXIF_LENGTH];
  dt_datetime_unix_to_exif(dt_txt, sizeof(dt_txt), &datetime);
  const char *id = g_strconcat(fn, "-", dt_txt, NULL);
  dt_metadata_set(imgid, "Xmp.darktable.image_id", id, FALSE);
  g_object_unref(info);
  g_object_unref(gfile);
  g_clear_error(&error);
}
 
int32_t _import_image(const GList *img, dt_control_import_t *data, const char *final_destination, GList **discarded, int *xmps)
{
  const char *filename = (const char*) img->data;
 
  gchar img_path_to_db[DT_PATH_MAX] = { 0 };
  int copy_status = 0;
 
  if(data->copy)
  {
    copy_status = _import_copy_file(filename, final_destination, data, img_path_to_db, sizeof(img_path_to_db), discarded);
    if(copy_status < 0) return UNKNOWN_IMAGE;
  }
  else
    // destination = origin, nothing to do
    g_strlcpy(img_path_to_db, filename, sizeof(img_path_to_db));
 
  if(img_path_to_db[0] == 0)
  {
    fprintf(stderr, "[Import] Could not import file from disk: empty file path\n");
    return UNKNOWN_IMAGE;
  }
 
  const int32_t imgid = _import_job(data, img_path_to_db);
  if(imgid <= 0)
  {
    dt_control_log(_("Error importing file in collection: %s"), img_path_to_db);
    fprintf(stderr, "[Import] Error importing file in collection: %s", img_path_to_db);
    return UNKNOWN_IMAGE;
  }
 
  *xmps = dt_image_read_duplicates(imgid, img_path_to_db, FALSE);
  dt_print(DT_DEBUG_IMPORT, "[Import] Found and imported %i XMP for %s.\n", *xmps, img_path_to_db);
  dt_print(DT_DEBUG_IMPORT, "[Import] successfully imported %s in DB at imgid %i\n", img_path_to_db, imgid);
 
  if(!data->delete_source || copy_status != 1) goto apply_styles;
 
  int identical = 0;
  GStatBuf source_stat;
  GStatBuf destination_stat;
  if(g_stat(filename, &source_stat) == 0
     && g_stat(img_path_to_db, &destination_stat) == 0
     && source_stat.st_size == destination_stat.st_size)
  {
    FILE *source = g_fopen(filename, "rb");
    FILE *destination = g_fopen(img_path_to_db, "rb");
    if(!IS_NULL_PTR(source) && !IS_NULL_PTR(destination))
      identical = dt_util_streams_equal(source, destination);
    if(!IS_NULL_PTR(source)) fclose(source);
    if(!IS_NULL_PTR(destination)) fclose(destination);
  }
 
  if(identical != 1)
    dt_control_log(_("The imported file differs from the original, which was not deleted: %s"), filename);
  else if(g_unlink(filename) != 0)
    dt_control_log(_("The imported file was verified but the original could not be deleted: %s"), filename);
 
apply_styles:
  if(IS_NULL_PTR(data->styles)) return imgid;
 
  dt_hm_batch_state_t batch = { 0 };
  for(GList *s = data->styles; s; s = g_list_next(s))
  {
    const char *style_name = (const char *)s->data;
    const int32_t style_id = dt_styles_get_id_by_name(style_name);
    if(style_id <= 0) continue;
    dt_styles_apply_to_image_merge(style_name, style_id, imgid, DT_HISTORY_MERGE_APPEND, &batch);
  }
  dt_hm_batch_state_cleanup(&batch);
  dt_image_history_changed(imgid, TRUE);
 
  return imgid;
}
 
static void _refresh_progress_counter(dt_job_t *job, const int elements, const int index,
                                      const gboolean folder_survey)
{
  gchar message[128] = { 0 };
  double fraction = (double)index / (double)elements;
  if(folder_survey)
    snprintf(message, sizeof(message),
             ngettext("Capture: importing %i/%i image", "Capture: importing %i/%i images", index),
             index, elements);
  else
    snprintf(message, sizeof(message),
             ngettext("Importing %i/%i image", "Importing %i/%i images", index),
             index, elements);
  dt_control_job_set_progress_message(job, message);
  dt_control_job_set_progress(job, fraction);
  g_usleep(100);
}
 
static int32_t _control_import_job_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = (dt_control_image_enumerator_t *)dt_control_job_get_params(job);
  dt_control_import_t *data = params->data;
 
  int index = 0;
  int xmps = 0; // number of xmps imported in db.
  int32_t imgid = UNKNOWN_IMAGE;
  int32_t last_imgid = UNKNOWN_IMAGE;
  gint64 last_collection_refresh = 0;
  dt_import_sequence_t sequences = {
    .captures = g_hash_table_new_full(g_str_hash, g_str_equal, dt_free_gpointer, NULL),
    .destinations = g_hash_table_new_full(g_str_hash, g_str_equal, dt_free_gpointer, NULL),
  };
 
  // What this import may do to the view the user is in, decided once from what the import IS. An
  // automatic (folder survey) one never moves them: Studio Capture displays the capture itself,
  // from DT_SIGNAL_IMAGE_IMPORT, and the survey outlives its atelier. A requested one shows the
  // grid as images arrive, and opens the darkroom instead if it turns out to have imported one.
  dt_collection_import_view_t first_image_policy = DT_COLLECTION_IMPORT_VIEW_GRID;
  dt_collection_import_view_t single_image_policy = DT_COLLECTION_IMPORT_VIEW_IMAGE;
  const char *no_image_message = _("No image imported!");
  if(data->folder_survey)
  {
    first_image_policy = DT_COLLECTION_IMPORT_VIEW_KEEP;
    single_image_policy = DT_COLLECTION_IMPORT_VIEW_KEEP;
    no_image_message = _("Capture: No image imported!");
  }
 
  for(GList *img = g_list_first(data->imgs); img; img = g_list_next(img))
  {
    const char *filename = (const char *)img->data;
    int capture_sequence = 0;
    gboolean import_ready = !data->copy;
    gchar *destination = NULL;
    dt_image_t *expansion_image = NULL;
    imgid = UNKNOWN_IMAGE;
 
    dt_print(DT_DEBUG_IMPORT, "[Import] starting import of image #%i...\n", index);
 
    _refresh_progress_counter(job, data->elements, index, data->folder_survey);
    if(!data->copy) goto import_image;
 
    capture_sequence = dt_import_sequence_assign(&sequences, filename);
    expansion_image = dt_alloc_align(sizeof(dt_image_t));
    if(IS_NULL_PTR(expansion_image)) goto complete_image;
    dt_image_init(expansion_image);
 
    if(!IS_NULL_PTR(strstr(data->target_file_pattern, "$(EXIF"))
       || !IS_NULL_PTR(strstr(data->target_subfolder_pattern, "$(EXIF")))
      dt_exif_read(expansion_image, filename);
 
    const dt_import_destination_t request = { filename, expansion_image, data, capture_sequence };
    destination = dt_import_sequence_destination(&sequences, &request);
    import_ready = !IS_NULL_PTR(destination);
 
import_image:
    if(import_ready) imgid = _import_image(img, data, destination, &data->discarded, &xmps);
complete_image:
    dt_free(destination)
    dt_free_align(expansion_image);
    if(!IS_NULL_PTR(data->file_imported))
      data->file_imported((const char *)img->data, imgid > UNKNOWN_IMAGE, data->callback_data);
 
    if(imgid <= UNKNOWN_IMAGE) continue;
    last_imgid = imgid;
 
    // On the first image, try to switch the current filmroll to the imported image's folder.
    // dt_collection_load_filmroll() silently declines to do anything (no collection refresh)
    // when it cannot switch folders, e.g. the collect module is not on the "Folders" tab. In
    // that case a single imported image would never show up until the user reloads the
    // collection by hand (issue #860). So always run a collection update afterwards: it
    // re-runs the current query and makes newly-imported matching images appear.
    if(index == 0)
      dt_collection_load_filmroll(dt_collection_get_global(), imgid, first_image_policy, TRUE);
 
    // known_image_folder is NULL: in copy mode the image's final DB location can be a
    // completely different, pattern-generated folder from its original source path, which is
    // all this loop has at hand -- dt_collection_notify_imported() must resolve it fresh.
    dt_collection_notify_imported(imgid, NULL, &last_collection_refresh);
 
    index++;
  }
 
  g_hash_table_destroy(sequences.destinations);
  g_hash_table_destroy(sequences.captures);
 
  if(index == 0)
  {
    dt_conf_set_int("ui_last/nb_imported", index);
    dt_control_log("%s", no_image_message);
    fprintf(stderr, "No image imported!\n\n");
    return 1;
  }
 
  // Guarantee the final state is reflected even if the last few images landed inside the throttle window.
  dt_collection_update_query(dt_collection_get_global(), DT_COLLECTION_CHANGE_NEW_QUERY, DT_COLLECTION_PROP_UNDEF, NULL);
  dt_conf_set_int("ui_last/nb_imported", index);
 
  // Don't open the picture in darkroom if more than 1 xmp (= duplicates) has been imported: the
  // single file then stands for several images in the DB and none of them is the obvious one to
  // open. Zero xmp is the ordinary case of a file with no sidecar (and of a library configured
  // not to write any), still exactly one image: open it like any other single import.
  if(index == 1 && xmps <= 1)
  {
    // A requested single image opens in the darkroom, which is announcement enough -- only the
    // survey, which stays where it is, says anything.
    if(data->folder_survey) dt_control_log(_("Capture: imported 1 image."));
    dt_collection_load_filmroll(dt_collection_get_global(), last_imgid, single_image_policy, TRUE);
    return 0;
  }
 
  dt_control_log(data->folder_survey
                 ? ngettext("Capture: imported %d image.", "Capture: imported %d images.", index)
                 : ngettext("Imported %d image", "Imported %d images", index), index);
  fprintf(stdout, "%d files imported in database.\n\n", index);
 
  return 0;
}
 
void dt_control_import_data_free(dt_control_import_t *data)
{
  g_date_time_unref(data->datetime);
  dt_free(data->jobcode);
  dt_free(data->base_folder);
  dt_free(data->target_subfolder_pattern);
  dt_free(data->target_file_pattern);
  dt_free(data->target_dir);
  if(data->styles)
  {
    g_list_free_full(data->styles, dt_free_gpointer);
    data->styles = NULL;
  }
  if(!IS_NULL_PTR(data->callback_data_free))
    data->callback_data_free(data->callback_data);
  data->callback_data = NULL;
 
  // GList of pathes stored as *char. We need to free the list and the *char
  if(data->discarded)
  {
    g_list_free_full(data->discarded, dt_free_gpointer);
    data->discarded = NULL;
  }
  if(data->imgs)
  {
    g_list_free_full(data->imgs, dt_free_gpointer);
    data->imgs = NULL;
  }
}
 
/* Installed by the GUI at startup; absent under ansel-cli, where the discarded list is
 * simply freed with the rest -- a headless import has nobody to show a dialog to. */
static dt_control_import_discarded_handler_t _discarded_files_handler = NULL;
 
void dt_control_import_set_discarded_files_handler(dt_control_import_discarded_handler_t handler)
{
  _discarded_files_handler = handler;
}
 
/* The discarded-files recap dialog lives in gui/import.c now: it was the only GUI
 * code in this job file, and the only reason a control-layer TU included
 * widgets/ and gui/ headers. The job reaches it through the handler below. */
 
static void _control_import_job_cleanup(void *p)
{
  dt_control_image_enumerator_t *params = (dt_control_image_enumerator_t *)p;
  dt_control_import_t *data = params->data;
 
  // Display a recap of files that weren't copied
  if(g_list_length(data->discarded) > 0 && _discarded_files_handler)
  {
    // Called on THIS worker thread: getting onto the GUI main loop is the handler's
    // business (g_main_context_invoke is GTK machinery, not a job's). The handler owns
    // freeing data and params, whenever it is done with them.
    _discarded_files_handler((struct dt_control_image_enumerator_t *)params);
  }
  else
  {
    dt_control_import_data_free(data);
    dt_free(data);
    dt_control_image_enumerator_cleanup(params);
  }
}
 
static void *_control_import_alloc()
{
  dt_control_image_enumerator_t *params = dt_control_image_enumerator_alloc();
  if(IS_NULL_PTR(params)) return NULL;
 
  params->data = g_malloc0(sizeof(dt_control_import_t));
  if(IS_NULL_PTR(params->data))
  {
    dt_control_image_enumerator_cleanup(params);
    return NULL;
  }
  return params;
}
 
static dt_job_t *_control_import_job_create(dt_control_import_t data)
{
  dt_job_t *job = dt_control_job_create(&_control_import_job_run, "import");
  if(IS_NULL_PTR(job)) return NULL;
  dt_control_image_enumerator_t *params = _control_import_alloc();
  if(IS_NULL_PTR(params))
  {
    dt_control_job_dispose(job);
    return NULL;
  }
  memcpy(params->data, &data, sizeof(dt_control_import_t));
  params->index = NULL;
  dt_control_job_add_progress(job, _("import"), FALSE);
  dt_control_job_set_params(job, params, _control_import_job_cleanup);
  return job;
}
 
int dt_control_import(dt_control_import_t data)
{
  dt_job_t *job = _control_import_job_create(data);
  if(IS_NULL_PTR(job))
  {
    // Report every source as failed so asynchronous clients can release their queued state.
    for(GList *img = g_list_first(data.imgs); img; img = g_list_next(img))
      if(!IS_NULL_PTR(data.file_imported))
        data.file_imported((const char *)img->data, FALSE, data.callback_data);
 
    dt_control_import_data_free(&data);
    return 1;
  }
 
  return dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG, job);
}