control_jobs.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2010-2012 Henrik Andersson.
    Copyright (C) 2010-2014, 2016 johannes hanika.
    Copyright (C) 2010 kibooz.
    Copyright (C) 2010-2017, 2019-2020 Tobias Ellinghaus.
    Copyright (C) 2011 Antony Dovgal.
    Copyright (C) 2011 José Carlos García Sogo.
    Copyright (C) 2011 Karl Mikaelsson.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2012 Christian Tellefsen.
    Copyright (C) 2012 Frédéric Grollier.
    Copyright (C) 2012 James C. McPherson.
    Copyright (C) 2012 Jens Fendler.
    Copyright (C) 2012 Joao Trindade.
    Copyright (C) 2012 marcel.
    Copyright (C) 2012 Michal Babej.
    Copyright (C) 2012 Pascal de Bruijn.
    Copyright (C) 2012-2015, 2018-2022 Pascal Obry.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2012-2013 Simon Spannagel.
    Copyright (C) 2013, 2015 Jérémy Rosen.
    Copyright (C) 2013 Pierre Le Magourou.
    Copyright (C) 2013-2016 Roman Lebedev.
    Copyright (C) 2013 Thomas Pryds.
    Copyright (C) 2013 Ulrich Pegelow.
    Copyright (C) 2014 Dan Torop.
    Copyright (C) 2015 Bruce Guenter.
    Copyright (C) 2015 Guillaume Benny.
    Copyright (C) 2015 Nikolai Ugelvik.
    Copyright (C) 2016 Matthieu Volat.
    Copyright (C) 2016-2018 parafin.
    Copyright (C) 2017 pgkos.
    Copyright (C) 2018 Peter Budai.
    Copyright (C) 2019 Andreas Schneider.
    Copyright (C) 2019 August Schwerdfeger.
    Copyright (C) 2019 Denis Dyakov.
    Copyright (C) 2019 Edgardo Hoszowski.
    Copyright (C) 2019-2020 Heiko Bauke.
    Copyright (C) 2019-2022 Philippe Weyland.
    Copyright (C) 2019 Sam Smith.
    Copyright (C) 2020-2022 Aldric Renaudin.
    Copyright (C) 2020 Hanno Schwalm.
    Copyright (C) 2020-2021 Hubert Kowalski.
    Copyright (C) 2020 JP Verrue.
    Copyright (C) 2020 Marco.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2020 Robert Bridge.
    Copyright (C) 2020 U-DESKTOP-HQME86J\marco.
    Copyright (C) 2021 Bill Ferguson.
    Copyright (C) 2021-2022 Chris Elston.
    Copyright (C) 2021 Cobert0.
    Copyright (C) 2021 Diederik Ter Rahe.
    Copyright (C) 2021 Felipe Contreras.
    Copyright (C) 2021 Marco Carrarini.
    Copyright (C) 2021 quovadit.
    Copyright (C) 2022-2025 Aurélien PIERRE.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2022 Paolo Benvenuto.
    Copyright (C) 2022 Victor Forsiuk.
    Copyright (C) 2023-2024 Alynx Zhou.
    Copyright (C) 2023 Ricky Moon.
    Copyright (C) 2024-2026 Guillaume Stutin.
    Copyright (C) 2024 Miguel Moquillon.
    
    darktable 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.
    
    darktable 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 darktable.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "control/jobs/control_jobs.h"
#include "common/paths.h"   // DT_PATH_MAX
#include "control/signal.h"
#include "database/film_repository.h"
#include "database/image_repository.h"
#include "common/act_on.h"
#include "common/history_actions.h"
#include "control/control.h"
#include "common/collection.h"
#include "common/xmp_sidecar.h"
#include "metadata/exif.h"
#include "common/film.h"
#include "metadata/gpx.h"
#include "history/history.h"
#include "develop/history_merge.h"
#include "common/image.h"
#include "caches/image_cache.h"
#include "imageio/imageio_core.h"
#include "imageio/imageio_dng.h"
#include "imageio/imageio_module.h"
#include "metadata/tags.h"
#include "common/undo.h"
#include "common/grouping.h"
#include "common/utility.h"
#include "common/datetime.h"
#include "common/conf.h"
#include "develop/imageop_math.h"
 
 
#include "gui/application.h"
 
#include <gio/gio.h>
#include <glib.h>
#include <glib/gstdio.h>
#ifndef _WIN32
#endif
#ifdef __APPLE__
#include "osx/osx.h"
#endif
#ifdef _WIN32
#include "win/dtwin.h"
#endif
 
// Control of the collection updates during an import.  Start with a short interval to feel responsive,
// but use fairly infrequent updates for large imports to minimize overall time.
#define INIT_UPDATE_INTERVAL  2 //seconds
#define MAX_UPDATE_INTERVAL     3.0 //seconds
// How long (in seconds) between updates of the "Importing N/M" progress indicator?  Should be relatively
// short to avoid the impression that the import has gotten stuck.  Setting this too low will impact the
// overall time for a large import.
#define PROGRESS_UPDATE_INTERVAL 1
 
typedef struct dt_control_datetime_t
{
  GTimeSpan offset;
  char datetime[DT_DATETIME_LENGTH];
} dt_control_datetime_t;
 
typedef struct dt_control_gpx_apply_t
{
  gchar *filename;
  gchar *tz;
} dt_control_gpx_apply_t;
 
typedef struct dt_control_export_t
{
  int max_width, max_height, format_index, storage_index;
  double scale_factor; // > 0: reduce by it, otherwise fit in max_width x max_height
  dt_imageio_module_data_t *sdata; // needed since the gui thread resets things like overwrite once the export
  // is dispatched, but we have to keep that information
  gboolean export_masks;
  char style[128];
  dt_colorspaces_color_profile_type_t icc_type;
  gchar *icc_filename;
  dt_iop_color_intent_t icc_intent;
  gchar *metadata_export;
} dt_control_export_t;
 
 
/* enumerator of images from filmroll */
static void dt_control_image_enumerator_job_film_init(dt_control_image_enumerator_t *t, int32_t filmid)
{
  /* get a list of images in filmroll */
  GList *ids = dt_film_repository_get_image_ids(filmid);
  for(GList *l = ids; l; l = g_list_next(l))
    t->index = g_list_append(t->index, l->data);
  g_list_free(ids);
}
 
static int32_t _generic_dt_control_fileop_images_job_run(dt_job_t *job,
                                                         int32_t (*fileop_callback)(const int32_t,
                                                                                    const int32_t),
                                                         const char *desc, const char *desc_pl)
{
  dt_control_image_enumerator_t *params = (dt_control_image_enumerator_t *)dt_control_job_get_params(job);
  GList *t = params->index;
  const guint total = g_list_length(t);
  char message[512] = { 0 };
  double fraction = 0;
  gchar *newdir = (gchar *)params->data;
 
  g_snprintf(message, sizeof(message), ngettext(desc, desc_pl, total), total);
  dt_control_job_set_progress_message(job, message);
 
  // create new film roll for the destination directory
  dt_film_t new_film;
  const int32_t film_id = dt_film_new(&new_film, newdir);
  dt_free(newdir);
 
  if(film_id <= 0)
  {
    dt_control_alert(_("File operation failed"),
                     _("failed to create film roll for destination directory, aborting move.."), NULL);
    return -1;
  }
 
  gboolean completeSuccess = TRUE;
  while(t && dt_control_job_get_state(job) != DT_JOB_STATE_CANCELLED)
  {
    completeSuccess &= (fileop_callback(GPOINTER_TO_INT(t->data), film_id) != -1);
    t = g_list_next(t);
    fraction += 1.0 / total;
    dt_control_job_set_progress(job, fraction);
  }
 
  if(completeSuccess)
  {
    char collect[1024];
    snprintf(collect, sizeof(collect), "1:0:0:%s$", new_film.dirname);
    dt_collection_deserialize(collect);
  }
  dt_film_remove_empty();
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_FILMROLLS_CHANGED);
  dt_collection_update_query(dt_collection_get_global(), DT_COLLECTION_CHANGE_RELOAD, DT_COLLECTION_PROP_UNDEF,
                             g_list_copy(params->index));
  dt_control_queue_redraw_center();
  return 0;
}
 
void *dt_control_image_enumerator_alloc()
{
  dt_control_image_enumerator_t *params = calloc(1, sizeof(dt_control_image_enumerator_t));
  if(IS_NULL_PTR(params)) return NULL;
  return params;
}
 
void dt_control_image_enumerator_cleanup(void *p)
{
  dt_control_image_enumerator_t *params = p;
 
  if(params->index)
  {
    g_list_free(params->index);
    params->index = NULL;
  }
  params->index = NULL;
 
  dt_free(params);
}
 
typedef enum {PROGRESS_NONE, PROGRESS_SIMPLE, PROGRESS_CANCELLABLE} progress_type_t;
 
static dt_job_t *dt_control_generic_images_job_create(dt_job_execute_callback execute, const char *message,
                                                      int flag, gpointer data, progress_type_t progress_type,
                                                      gboolean only_visible)
{
  dt_job_t *job = dt_control_job_create(execute, "%s", message);
  if(IS_NULL_PTR(job)) return NULL;
  dt_control_image_enumerator_t *params = dt_control_image_enumerator_alloc();
  if(IS_NULL_PTR(params))
  {
    dt_control_job_dispose(job);
    return NULL;
  }
  if(progress_type != PROGRESS_NONE)
    dt_control_job_add_progress(job, _(message), progress_type == PROGRESS_CANCELLABLE);
  params->index = dt_act_on_get_images();
 
  dt_control_job_set_params(job, params, dt_control_image_enumerator_cleanup);
 
  params->flag = flag;
  params->data = data;
  return job;
}
 
static dt_job_t *dt_control_generic_image_job_create(dt_job_execute_callback execute, const char *message,
                                                     int flag, gpointer data, progress_type_t progress_type,
                                                     int32_t imgid)
{
  dt_job_t *job = dt_control_job_create(execute, "%s", message);
  if(IS_NULL_PTR(job)) return NULL;
  dt_control_image_enumerator_t *params = dt_control_image_enumerator_alloc();
  if(IS_NULL_PTR(params))
  {
    dt_control_job_dispose(job);
    return NULL;
  }
  if(progress_type != PROGRESS_NONE)
    dt_control_job_add_progress(job, _(message), progress_type == PROGRESS_CANCELLABLE);
 
  params->index = g_list_append(NULL, GINT_TO_POINTER(imgid));
 
  dt_control_job_set_params(job, params, dt_control_image_enumerator_cleanup);
 
  params->flag = flag;
  params->data = data;
  return job;
}
 
 
static int32_t dt_control_save_xmps_job_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = dt_control_job_get_params(job);
  const gboolean forced = (params->flag == 1);
 
  if(!forced && !dt_image_get_xmp_mode()) return 0;
 
  for(GList *t = params->index; t; t = g_list_next(t))
  {
    const int32_t imgid = GPOINTER_TO_INT(t->data);
    const dt_image_write_sidecar_result_t res =
      forced ? dt_image_write_sidecar_file_forced(imgid)
             : dt_image_write_sidecar_file(imgid);
    const char *alert_msg = NULL;
    switch(res)
    {
      case DT_IMAGE_WRITE_SIDECAR_OK:
        break;
      case DT_IMAGE_WRITE_SIDECAR_DISABLED:
        // xmp writing is off, or the setting changed mid-batch: nothing was attempted, nothing to report
        break;
      case DT_IMAGE_WRITE_SIDECAR_CACHE_BUSY:
        alert_msg = _("cannot write XMP file: the image cache entry is busy, try again.");
        break;
      case DT_IMAGE_WRITE_SIDECAR_NO_SOURCE_PATH:
        alert_msg = _("cannot write XMP file: the original file could not be found.");
        break;
      case DT_IMAGE_WRITE_SIDECAR_IO_ERROR:
        alert_msg = _("cannot write XMP file: the target storage may be unavailable or read-only.");
        break;
    }
    if(!IS_NULL_PTR(alert_msg))
    {
      // The image goes under the message, by the path it has in the library: an id means nothing to
      // the user, and dt_image_full_path() gives no path for an original that is gone.
      char fullpath[DT_PATH_MAX] = { 0 };
      const dt_image_t *img = dt_image_cache_get(imgid, 'r');
      if(!IS_NULL_PTR(img))
      {
        g_strlcpy(fullpath, img->fullpath, sizeof(fullpath));
        dt_image_cache_read_release(img);
      }
      dt_control_alert(_("Sidecar file not written"), alert_msg, fullpath[0] ? fullpath : NULL);
    }
  }
  return 0;
}
 
void dt_control_write_sidecar_files()
{
  GList *imgs = dt_act_on_get_images();
  if(IS_NULL_PTR(imgs)) return;
  dt_control_save_xmps_forced(imgs);
  g_list_free(imgs);
  imgs = NULL;
}
 
typedef struct dt_control_merge_hdr_t
{
  uint32_t first_imgid;
  uint32_t first_filter;
  uint8_t first_xtrans[6][6];
 
  float *pixels, *weight;
 
  int wd;
  int ht;
  dt_image_orientation_t orientation;
 
  float whitelevel;
  float epsw;
  dt_aligned_pixel_t wb_coeffs;
  float adobe_XYZ_to_CAM[4][3];
  char camera_makermodel[128];
 
  // 0 - ok; 1 - errors, abort
  gboolean abort;
} dt_control_merge_hdr_t;
 
typedef struct dt_control_merge_hdr_format_t
{
  dt_imageio_module_data_t parent;
  dt_control_merge_hdr_t *d;
} dt_control_merge_hdr_format_t;
 
static int dt_control_merge_hdr_bpp(dt_imageio_module_data_t *data)
{
  return 32;
}
 
static int dt_control_merge_hdr_levels(dt_imageio_module_data_t *data)
{
  return IMAGEIO_RGB | IMAGEIO_FLOAT;
}
 
static const char *dt_control_merge_hdr_mime(dt_imageio_module_data_t *data)
{
  return "memory";
}
 
static float envelope(const float xx)
{
  const float x = CLAMPS(xx, 0.0f, 1.0f);
  // const float alpha = 2.0f;
  const float beta = 0.5f;
  if(x < beta)
  {
    // return 1.0f-fabsf(x/beta-1.0f)^2
    const float tmp = fabsf(x / beta - 1.0f);
    return 1.0f - tmp * tmp;
  }
  else
  {
    const float tmp1 = (1.0f - x) / (1.0f - beta);
    const float tmp2 = tmp1 * tmp1;
    const float tmp3 = tmp2 * tmp1;
    return 3.0f * tmp2 - 2.0f * tmp3;
  }
}
 
static int dt_control_merge_hdr_process(dt_imageio_module_data_t *datai, const char *filename,
                                        const void *const ivoid,
                                        dt_colorspaces_color_profile_type_t over_type, const char *over_filename,
                                        void *exif, int exif_len, int32_t imgid, int num, int total,
                                        dt_dev_pixelpipe_t *pipe, const gboolean export_masks)
{
  dt_control_merge_hdr_format_t *data = (dt_control_merge_hdr_format_t *)datai;
  dt_control_merge_hdr_t *d = data->d;
 
  // just take a copy. also do it after blocking read, so filters will make sense.
  const dt_image_t *img = dt_image_cache_get(imgid, 'r');
  if(IS_NULL_PTR(img))
  {
    // a merge missing one of its exposures is not the merge that was asked for
    dt_control_alert(_("Image could not be opened"), _("Could not read image information from the database."),
                     NULL);
    d->abort = TRUE;
    return 1;
  }
  const dt_image_t image = *img;
  dt_image_cache_read_release(img);
 
  if(IS_NULL_PTR(d->pixels))
  {
    d->first_imgid = imgid;
    d->first_filter = image.dsc.filters;
    // sensor layout is just passed on to be written to dng.
    // we offset it to the crop of the image here, so we don't
    // need to load in the FCxtrans dependency into the dng writer.
    // for some stupid reason the dng needs this layout wrt cropped
    // offsets, not globally.
    dt_iop_roi_t roi = {0};
    roi.x = image.crop_x;
    roi.y = image.crop_y;
    for(int j=0;j<6;j++)
      for(int i = 0; i < 6; i++) d->first_xtrans[j][i] = FCxtrans(j, i, &roi, image.dsc.xtrans);
    d->pixels = calloc((size_t)datai->width * datai->height, sizeof(float));
    d->weight = calloc((size_t)datai->width * datai->height, sizeof(float));
    d->wd = datai->width;
    d->ht = datai->height;
    d->orientation = image.orientation;
    for(int i = 0; i < 3; i++)
      d->wb_coeffs[i] = image.wb_coeffs[i];
    for(int k=0; k<4; k++)
      for(int i=0; i<3; i++)
        d->adobe_XYZ_to_CAM[k][i] = image.adobe_XYZ_to_CAM[k][i];
  }
 
  if(image.dsc.filters == 0u || image.dsc.channels != 1 || image.dsc.datatype != TYPE_UINT16)
  {
    dt_control_log(_("exposure bracketing only works on raw images."));
    d->abort = TRUE;
    return 1;
  }
  else if(datai->width != d->wd || datai->height != d->ht || d->first_filter != image.dsc.filters
          || d->orientation != image.orientation)
  {
    dt_control_log(_("images have to be of same size and orientation!"));
    d->abort = TRUE;
    return 1;
  }
 
  // if no valid exif data can be found, assume peleng fisheye at f/16, 8mm, with half of the light lost in
  // the system => f/22
  const float eap = image.exif_aperture > 0.0f ? image.exif_aperture : 22.0f;
  const float efl = image.exif_focal_length > 0.0f ? image.exif_focal_length : 8.0f;
  const float rad = .5f * efl / eap;
  const float aperture = M_PI * rad * rad;
  const float iso = image.exif_iso > 0.0f ? image.exif_iso : 100.0f;
  const float exp = image.exif_exposure > 0.0f ? image.exif_exposure : 1.0f;
  const float cal = 100.0f / (aperture * exp * iso);
  // about proportional to how many photons we can expect from this shot:
  const float photoncnt = 100.0f * aperture * exp / iso;
  float saturation = 1.0f;
  d->whitelevel = fmaxf(d->whitelevel, saturation * cal);
  __OMP_PARALLEL_FOR__(collapse(2))
  for(int y = 0; y < d->ht; y++)
    for(int x = 0; x < d->wd; x++)
    {
      // read unclamped raw value with subtracted black and rescaled to 1.0 saturation.
      // this is the output of the rawprepare iop.
      const float in = ((float *)ivoid)[x + d->wd * y];
      // weights based on siggraph 12 poster
      // zijian zhu, zhengguo li, susanto rahardja, pasi fraenti
      // 2d denoising factor for high dynamic range imaging
      float w = photoncnt;
 
      // need some safety margin due to upsampling and 16-bit quantization + dithering?
      float offset = 3000.0f / (float)UINT16_MAX;
 
      // cannot do an envelope based on single pixel values here, need to get
      // maximum value of all color channels. to find that, go through the
      // pattern block (we conservatively do a 3x3 for bayer or xtrans):
      int xx = x & ~1, yy = y & ~1;
      float M = 0.0f, m = FLT_MAX;
      if(xx < d->wd - 2 && yy < d->ht - 2)
      {
        for(int i = 0; i < 3; i++)
          for(int j = 0; j < 3; j++)
          {
            M = MAX(M, ((float *)ivoid)[xx + i + d->wd * (yy + j)]);
            m = MIN(m, ((float *)ivoid)[xx + i + d->wd * (yy + j)]);
          }
        // move envelope a little to allow non-zero weight even for clipped regions.
        // this is because even if the 2x2 block is clipped somewhere, the other channels
        // might still prove useful. we'll check for individual channel saturation below.
        w *= d->epsw + envelope((M + offset) / saturation);
      }
 
      if(M + offset >= saturation)
      {
        if(d->weight[x + d->wd * y] <= 0.0f)
        { // only consider saturated pixels in case we have nothing better:
          if(d->weight[x + d->wd * y] == 0 || m < -d->weight[x + d->wd * y])
          {
            if(m + offset >= saturation)
              d->pixels[x + d->wd * y] = 1.0f; // let's admit we were completely clipped, too
            else
              d->pixels[x + d->wd * y] = in * cal / d->whitelevel;
            d->weight[x + d->wd * y]
                = -m; // could use -cal here, but m is per pixel and safer for varying illumination conditions
          }
        }
        // else silently ignore, others have filled in a better color here already
      }
      else
      {
        if(d->weight[x + d->wd * y] <= 0.0)
        { // cleanup potentially blown highlights from earlier images
          d->pixels[x + d->wd * y] = 0.0f;
          d->weight[x + d->wd * y] = 0.0f;
        }
        d->pixels[x + d->wd * y] += w * in * cal;
        d->weight[x + d->wd * y] += w;
      }
    }
 
  return 0;
}
 
static int32_t dt_control_merge_hdr_job_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = dt_control_job_get_params(job);
  GList *t = params->index;
  const guint total = g_list_length(t);
  char message[512] = { 0 };
  double fraction = 0;
  snprintf(message, sizeof(message), ngettext("merging %d image", "merging %d images", total), total);
 
  dt_control_job_set_progress_message(job, message);
 
  dt_control_merge_hdr_t d = (dt_control_merge_hdr_t){.epsw = 1e-8f, .abort = FALSE };
 
  dt_imageio_module_format_t buf = (dt_imageio_module_format_t){.mime = dt_control_merge_hdr_mime,
                                                                .levels = dt_control_merge_hdr_levels,
                                                                .bpp = dt_control_merge_hdr_bpp,
                                                                .write_image = dt_control_merge_hdr_process };
 
  dt_control_merge_hdr_format_t dat = (dt_control_merge_hdr_format_t){.parent = { 0 }, .d = &d };
 
  int num = 1;
  while(t)
  {
    if(d.abort) goto end;
 
    const int32_t imgid = GPOINTER_TO_INT(t->data);
 
    // the merge reads the images at full size: the export module's size settings are not its own
    dt_imageio_export_with_flags(imgid, "unused", &buf, (dt_imageio_module_data_t *)&dat, TRUE, FALSE, FALSE, 0.0,
                                 FALSE, FALSE, "pre:rawprepare", FALSE, FALSE, DT_COLORSPACE_NONE, NULL, DT_INTENT_LAST, NULL,
                                 NULL, num, total, NULL, NULL);
 
    t = g_list_next(t);
 
    /* update the progress bar */
    fraction += 1.0 / (total + 1);
    dt_control_job_set_progress(job, fraction);
    num++;
  }
 
  if(d.abort) goto end;
 
// normalize by white level to make clipping at 1.0 work as expected
  __OMP_PARALLEL_FOR__()
  for(size_t k = 0; k < (size_t)d.wd * d.ht; k++)
  {
    if(d.weight[k] > 0.0) d.pixels[k] = fmaxf(0.0f, d.pixels[k] / (d.whitelevel * d.weight[k]));
  }
 
  // output hdr as digital negative with exif data.
  uint8_t *exif = NULL;
  char pathname[DT_PATH_MAX] = { 0 };
  gboolean from_cache = TRUE;
  dt_image_full_path(d.first_imgid,  pathname,  sizeof(pathname),  &from_cache, __FUNCTION__);
 
  // last param is dng mode
  const int exif_len = dt_exif_read_blob(&exif, pathname, d.first_imgid, 0, d.wd, d.ht, 1);
  char *c = pathname + safe_strlen(pathname);
  while(*c != '.' && c > pathname) c--;
  g_strlcpy(c, "-hdr.dng", sizeof(pathname) - (c - pathname));
  dt_imageio_write_dng(pathname,
                       d.pixels,
                       d.wd,
                       d.ht,
                       exif,
                       exif_len,
                       d.first_filter,
                       (const uint8_t (*)[6])d.first_xtrans,
                       1.0f,
                       (const float (*))d.wb_coeffs,
                       d.adobe_XYZ_to_CAM);
  dt_free(exif);
 
  dt_control_job_set_progress(job, 1.0);
 
  while(*c != '/' && c > pathname) c--;
  dt_control_log(_("wrote merged HDR `%s'"), c + 1);
 
  // import new image
  gchar *directory = g_path_get_dirname((const gchar *)pathname);
  dt_film_t film;
  const int filmid = dt_film_new(&film, directory);
  const uint32_t imageid = dt_image_import(filmid, pathname, TRUE);
  dt_free(directory);
 
  // refresh the thumbtable view
  dt_collection_update_query(dt_collection_get_global(), DT_COLLECTION_CHANGE_RELOAD, DT_COLLECTION_PROP_UNDEF,
                             g_list_prepend(NULL, GINT_TO_POINTER(imageid)));
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_FILMROLLS_CHANGED);
  dt_control_queue_redraw_center();
 
end:
  dt_free(d.pixels);
  dt_free(d.weight);
 
  return 0;
}
 
static int32_t dt_control_duplicate_images_job_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = dt_control_job_get_params(job);
  GList *t = params->index;
  const guint total = g_list_length(t);
  double fraction = 0.0f;
  char message[512] = { 0 };
 
  dt_undo_start_group(dt_undo_get_global(), DT_UNDO_DUPLICATE);
 
  snprintf(message, sizeof(message), ngettext("duplicating %d image", "duplicating %d images", total), total);
  dt_control_job_set_progress_message(job, message);
  while(t)
  {
    const int32_t imgid = GPOINTER_TO_INT(t->data);
    // Defer exposing the duplicate to the collection/lighttable grid until its history is
    // settled below -- otherwise the grid can generate and cache a thumbnail from the
    // still-historyless row before the copy/delete below ever runs.
    const int newimgid = dt_image_duplicate_no_reload(imgid);
    if(newimgid != UNKNOWN_IMAGE)
    {
      if(GPOINTER_TO_INT(params->data))
        dt_history_delete_on_image(newimgid);
      else
        dt_history_copy_and_paste_on_image(imgid, newimgid, NULL, TRUE, DT_HISTORY_MERGE_REPLACE, FALSE, NULL);
 
      dt_collection_update_query(dt_collection_get_global(), DT_COLLECTION_CHANGE_RELOAD, DT_COLLECTION_PROP_UNDEF, NULL);
    }
    t = g_list_next(t);
    fraction += 1.0 / total;
    dt_control_job_set_progress(job, fraction);
  }
 
  dt_undo_end_group(dt_undo_get_global());
 
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_FILMROLLS_CHANGED);
  dt_control_queue_redraw_center();
  return 0;
}
 
static int32_t dt_control_flip_images_job_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = dt_control_job_get_params(job);
  const dt_image_transform_t transform = (dt_image_transform_t)params->flag;
  GList *t = params->index;
  const guint total = g_list_length(t);
  double fraction = 0.0f;
  char message[512] = { 0 };
 
  dt_undo_start_group(dt_undo_get_global(), DT_UNDO_LT_HISTORY);
 
  snprintf(message, sizeof(message), ngettext("flipping %d image", "flipping %d images", total), total);
  dt_control_job_set_progress_message(job, message);
  while(t)
  {
    const int32_t imgid = GPOINTER_TO_INT(t->data);
    dt_image_flip(imgid, transform);
    t = g_list_next(t);
    fraction += 1.0 / total;
    dt_control_job_set_progress(job, fraction);
  }
 
  dt_undo_end_group(dt_undo_get_global());
  dt_control_queue_redraw_center();
  return 0;
}
static int32_t dt_control_monochrome_images_job_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = dt_control_job_get_params(job);
  const int32_t mode = params->flag;
  GList *t = params->index;
  const guint total = g_list_length(t);
  char message[512] = { 0 };
  double fraction = 0.0f;
 
  dt_undo_start_group(dt_undo_get_global(), DT_UNDO_FLAGS);
 
  if(mode == 0)
    snprintf(message, sizeof(message), ngettext("set %d color image", "setting %d color images", total), total);
  else
    snprintf(message, sizeof(message), ngettext("set %d monochrome image", "setting %d monochrome images", total), total);
 
  dt_control_job_set_progress_message(job, message);
  while(t)
  {
    const int32_t imgid = GPOINTER_TO_INT(t->data);
 
    if(imgid >= 0)
    {
      dt_image_set_monochrome_flag(imgid, mode == 2);
    }
    else
      fprintf(stderr,"[dt_control_monochrome_images_job_run] got illegal imgid %i\n", imgid);
 
    t = g_list_next(t);
    fraction += 1.0 / total;
    dt_control_job_set_progress(job, fraction);
  }
 
  dt_undo_end_group(dt_undo_get_global());
 
  dt_collection_update_query(dt_collection_get_global(), DT_COLLECTION_CHANGE_RELOAD, DT_COLLECTION_PROP_UNDEF,
                             g_list_copy(params->index));
  dt_control_queue_redraw_center();
  return 0;
}
 
// Regenerate .xmp files for any surviving duplicate at each of `pathnames` (owned, g_strdup'd
// full paths from _get_full_pathname(); this call takes ownership and frees them), batched into
// a single dt_control_save_xmps() job. dt_image_synch_all_xmp() spawns one DT_JOB_QUEUE_USER_FG
// job per path -- fine for the handful of images a normal removal/delete touches, but for a large
// recursive folder removal it flooded that same queue (the one this job itself runs on) with one
// tiny job per path, each spawning its own GUI progress bar: stalled the app for minutes, looking
// like an infinite loop.
static void _resync_xmp_duplicates(GList *pathnames)
{
  GList *resync_imgids = NULL;
  if(dt_image_get_xmp_mode())
  {
    for(GList *l = pathnames; l; l = g_list_next(l))
    {
      const int32_t dup_imgid = dt_image_get_id_full_path((const char *)l->data);
      if(dup_imgid != UNKNOWN_IMAGE) resync_imgids = g_list_prepend(resync_imgids, GINT_TO_POINTER(dup_imgid));
    }
  }
  g_list_free_full(pathnames, dt_free_gpointer);
  if(!IS_NULL_PTR(resync_imgids)) dt_control_save_xmps(resync_imgids, FALSE);
  g_list_free(resync_imgids);
}
 
static int32_t dt_control_remove_images_job_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = dt_control_job_get_params(job);
  GList *t = params->index;
  const guint total = g_list_length(t);
  char message[512] = { 0 };
  snprintf(message, sizeof(message), ngettext("removing %d image", "removing %d images", total), total);
  dt_control_job_set_progress_message(job, message);
 
  // check that we can safely remove the image
  gboolean remove_ok = TRUE;
  GList *local_copies = dt_image_repository_get_ids_with_flag_among(t, DT_IMAGE_LOCAL_COPY);
  for(GList *l = local_copies; l; l = g_list_next(l))
  {
    if(!dt_image_safe_remove(GPOINTER_TO_INT(l->data)))
    {
      remove_ok = FALSE;
      break;
    }
  }
  g_list_free(local_copies);
 
  if(!remove_ok)
  {
    dt_control_alert(_("File operation failed"),
                     _("cannot remove local copy when the original file is not accessible."), NULL);
    return 0;
  }
 
  // update remove status
  dt_image_repository_set_flag_among(t, DT_IMAGE_REMOVE);
 
  dt_collection_update(dt_collection_get_global());
 
  // We need a list of files to regenerate .xmp files if there are duplicates
  GList *list = dt_image_repository_get_full_paths(t);
 
  /* One undo record per image, grouped so Ctrl+Z takes the whole batch back at once. The
   * files stay on disk, but the database rows do not, and neither the edit nor the tags nor
   * the group membership they carry can be reconstructed from the file -- so they are staged
   * before deletion rather than re-imported after. */
  dt_undo_start_group(dt_undo_get_global(), DT_UNDO_REMOVE);
 
  double fraction = 0.0f;
  while(t)
  {
    int32_t imgid = GPOINTER_TO_INT(t->data);
    dt_image_remove_undoable(imgid);
    t = g_list_next(t);
    fraction += 1.0 / total;
    dt_control_job_set_progress(job, fraction);
  }
 
  dt_undo_end_group(dt_undo_get_global());
 
  _resync_xmp_duplicates(list);
  dt_film_remove_empty();
  dt_collection_update_query(dt_collection_get_global(), DT_COLLECTION_CHANGE_RELOAD, DT_COLLECTION_PROP_UNDEF,
                             g_list_copy(params->index));
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_FILMROLLS_CHANGED);
  dt_control_queue_redraw_center();
 
  return 0;
}
 
typedef struct _dt_delete_modal_dialog_t
{
  int send_to_trash;
  const char *filename;
  const char *error_message;
 
  gint dialog_result;
 
  dt_pthread_mutex_t mutex;
  pthread_cond_t cond;
} _dt_delete_modal_dialog_t;
 
enum _dt_delete_status
{
  _DT_DELETE_STATUS_UNKNOWN = 0,
  _DT_DELETE_STATUS_OK_TO_REMOVE = 1,
  _DT_DELETE_STATUS_SKIP_FILE = 2,
  _DT_DELETE_STATUS_STOP_PROCESSING = 3
};
 
enum _dt_delete_dialog_choice
{
  _DT_DELETE_DIALOG_CHOICE_DELETE = 1,
  _DT_DELETE_DIALOG_CHOICE_DELETE_ALL = 2,
  _DT_DELETE_DIALOG_CHOICE_REMOVE = 3,
  _DT_DELETE_DIALOG_CHOICE_CONTINUE = 4,
  _DT_DELETE_DIALOG_CHOICE_STOP = 5
};
 
static gboolean _dt_delete_dialog_main_thread(gpointer user_data)
{
  _dt_delete_modal_dialog_t* modal_dialog = (_dt_delete_modal_dialog_t*)user_data;
  dt_pthread_mutex_lock(&modal_dialog->mutex);
 
  GtkWidget *dialog = gtk_message_dialog_new(
      GTK_WINDOW(dt_gui_main_window()),
      GTK_DIALOG_DESTROY_WITH_PARENT,
      GTK_MESSAGE_QUESTION,
      GTK_BUTTONS_NONE,
      modal_dialog->send_to_trash
        ? _("could not send %s to trash.%s%s")
        : _("could not physically delete %s.%s%s"),
      modal_dialog->filename,
      !IS_NULL_PTR(modal_dialog->error_message) ? "\n" : "",
      !IS_NULL_PTR(modal_dialog->error_message) ? modal_dialog->error_message : "");
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(dialog);
#endif
 
  if(modal_dialog->send_to_trash)
  {
    gtk_dialog_add_button(GTK_DIALOG(dialog), _("physically delete"), _DT_DELETE_DIALOG_CHOICE_DELETE);
    gtk_dialog_add_button(GTK_DIALOG(dialog), _("physically delete all files"), _DT_DELETE_DIALOG_CHOICE_DELETE_ALL);
  }
  gtk_dialog_add_button(GTK_DIALOG(dialog), _("only remove from the image library"), _DT_DELETE_DIALOG_CHOICE_REMOVE);
  gtk_dialog_add_button(GTK_DIALOG(dialog), _("skip to next file"), _DT_DELETE_DIALOG_CHOICE_CONTINUE);
  gtk_dialog_add_button(GTK_DIALOG(dialog), _("stop process"), _DT_DELETE_DIALOG_CHOICE_STOP);
 
  gtk_window_set_title(
      GTK_WINDOW(dialog),
      modal_dialog->send_to_trash
        ? _("trashing error")
        : _("deletion error"));
  modal_dialog->dialog_result = gtk_dialog_run(GTK_DIALOG(dialog));
  gtk_widget_destroy(dialog);
 
  pthread_cond_signal(&modal_dialog->cond);
 
  dt_pthread_mutex_unlock(&modal_dialog->mutex);
 
  // Don't call again on next idle time
  return FALSE;
}
 
static gint _dt_delete_file_display_modal_dialog(int send_to_trash, const char *filename, const char *error_message)
{
  _dt_delete_modal_dialog_t modal_dialog;
  modal_dialog.send_to_trash = send_to_trash;
  modal_dialog.filename = filename;
  modal_dialog.error_message = error_message;
 
  modal_dialog.dialog_result = GTK_RESPONSE_NONE;
 
  dt_pthread_mutex_init(&modal_dialog.mutex, NULL);
  pthread_cond_init(&modal_dialog.cond, NULL);
 
  dt_pthread_mutex_lock(&modal_dialog.mutex);
 
  gdk_threads_add_idle(_dt_delete_dialog_main_thread, &modal_dialog);
  while (modal_dialog.dialog_result == GTK_RESPONSE_NONE)
    dt_pthread_cond_wait(&modal_dialog.cond, &modal_dialog.mutex);
 
  dt_pthread_mutex_unlock(&modal_dialog.mutex);
  dt_pthread_mutex_destroy(&modal_dialog.mutex);
  pthread_cond_destroy(&modal_dialog.cond);
 
  return modal_dialog.dialog_result;
}
 
static enum _dt_delete_status delete_file_from_disk(const char *filename, gboolean *delete_on_trash_error)
{
  enum _dt_delete_status delete_status = _DT_DELETE_STATUS_UNKNOWN;
 
  GFile *gfile = g_file_new_for_path(filename);
  int send_to_trash = dt_conf_get_bool("send_to_trash");
 
  while (delete_status == _DT_DELETE_STATUS_UNKNOWN)
  {
    gboolean delete_success = FALSE;
    GError *gerror = NULL;
    if(send_to_trash)
    {
#ifdef __APPLE__
      delete_success = dt_osx_file_trash(filename, &gerror);
#elif defined(_WIN32)
      delete_success = dt_win_file_trash(gfile, NULL /*cancellable*/, &gerror);
#else
      delete_success = g_file_trash(gfile, NULL /*cancellable*/, &gerror);
#endif
    }
    else
    {
      delete_success = g_file_delete(gfile, NULL /*cancellable*/, &gerror);
    }
 
    // Delete is a success or the file does not exists: OK to remove from darktable
    if(delete_success
        || g_error_matches(gerror, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
    {
      delete_status = _DT_DELETE_STATUS_OK_TO_REMOVE;
    }
    else if(send_to_trash && *delete_on_trash_error)
    {
      // Loop again, this time delete instead of trashing
      delete_status = _DT_DELETE_STATUS_UNKNOWN;
      send_to_trash = FALSE;
    }
    else
    {
      const char *filename_display = NULL;
      GFileInfo *gfileinfo = g_file_query_info(
          gfile,
          G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
          G_FILE_QUERY_INFO_NONE,
          NULL /*cancellable*/,
          NULL /*error*/);
      if(!IS_NULL_PTR(gfileinfo))
        filename_display = g_file_info_get_attribute_string(
            gfileinfo,
            G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME);
 
      gint res = _dt_delete_file_display_modal_dialog(
          send_to_trash,
          IS_NULL_PTR(filename_display) ? filename : filename_display,
          IS_NULL_PTR(gerror) ? NULL : gerror->message);
      g_object_unref(gfileinfo);
      if(send_to_trash && res == _DT_DELETE_DIALOG_CHOICE_DELETE)
      {
        // Loop again, this time delete instead of trashing
        delete_status = _DT_DELETE_STATUS_UNKNOWN;
        send_to_trash = FALSE;
      }
      else if(send_to_trash && res == _DT_DELETE_DIALOG_CHOICE_DELETE_ALL)
      {
        // Loop again, this time delete instead of trashing
        delete_status = _DT_DELETE_STATUS_UNKNOWN;
        send_to_trash = FALSE;
        *delete_on_trash_error = TRUE;
      }
      else if(res == _DT_DELETE_DIALOG_CHOICE_REMOVE)
      {
        delete_status = _DT_DELETE_STATUS_OK_TO_REMOVE;
      }
      else if(res == _DT_DELETE_DIALOG_CHOICE_CONTINUE)
      {
        delete_status = _DT_DELETE_STATUS_SKIP_FILE;
      }
      else
      {
        delete_status = _DT_DELETE_STATUS_STOP_PROCESSING;
      }
    }
    if(!IS_NULL_PTR(gerror))
      g_error_free(gerror);
  }
 
  if(!IS_NULL_PTR(gfile))
    g_object_unref(gfile);
 
  return delete_status;
}
 
 
static int32_t dt_control_delete_images_job_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = dt_control_job_get_params(job);
  GList *t = params->index;
 
  const guint total = g_list_length(t);
  double fraction = 0.0f;
  char message[512] = { 0 };
  gboolean delete_on_trash_error = FALSE;
  if(dt_conf_get_bool("send_to_trash"))
    snprintf(message, sizeof(message), ngettext("trashing %d image", "trashing %d images", total), total);
  else
    snprintf(message, sizeof(message), ngettext("deleting %d image", "deleting %d images", total), total);
  dt_control_job_set_progress_message(job, message);
 
 
  dt_collection_update(dt_collection_get_global());
 
  // We need a list of files to regenerate .xmp files if there are duplicates
  GList *list = dt_image_repository_get_full_paths(t);
  while(t)
  {
    enum _dt_delete_status delete_status = _DT_DELETE_STATUS_UNKNOWN;
    const int32_t imgid = GPOINTER_TO_INT(t->data);
    char filename[DT_PATH_MAX] = { 0 };
    gboolean from_cache = FALSE;
    dt_image_full_path(imgid,  filename,  sizeof(filename),  &from_cache, __FUNCTION__);
 
#ifdef _WIN32
    char *dirname = g_path_get_dirname(filename);
#endif
 
    // same row set the duplicate list returns: every image sharing this one's roll and filename
    GList *dups = dt_image_repository_get_duplicate_ids(imgid);
    const int duplicates = g_list_length(dups);
    g_list_free(dups);
 
    // remove from disk:
    if(duplicates == 1)
    {
      // first check for local copies, never delete a file whose original file is not accessible
      if(dt_image_local_copy_reset(imgid))
        goto delete_next_file;
 
      GList *one = g_list_prepend(NULL, GINT_TO_POINTER(imgid));
      dt_image_repository_set_flag_among(one, DT_IMAGE_REMOVE);
      g_list_free(one);
      dt_image_remove(imgid);
 
      // there are no further duplicates so we can remove the source data file
      delete_status = delete_file_from_disk(filename, &delete_on_trash_error);
      if(delete_status != _DT_DELETE_STATUS_OK_TO_REMOVE)
        goto delete_next_file;
 
      // all sidecar files - including left-overs - can be deleted;
      // left-overs can result when previously duplicates have been REMOVED;
      // no need to keep them as the source data file is gone.
 
      GList *files = dt_image_find_xmps(filename);
 
      for(GList *file_iter = files; file_iter; file_iter = g_list_next(file_iter))
      {
        delete_status = delete_file_from_disk(file_iter->data, &delete_on_trash_error);
        if(delete_status != _DT_DELETE_STATUS_OK_TO_REMOVE)
          break;
      }
 
      g_list_free_full(files, dt_free_gpointer);
      files = NULL;
    }
    else
    {
      // don't remove the actual source data if there are further duplicates using it;
      // just delete the xmp file of the duplicate selected.
 
      dt_image_path_append_version(imgid, filename, sizeof(filename));
      g_strlcat(filename, ".xmp", sizeof(filename));
 
      // remove image from db first ...
      GList *one = g_list_prepend(NULL, GINT_TO_POINTER(imgid));
      dt_image_repository_set_flag_among(one, DT_IMAGE_REMOVE);
      g_list_free(one);
      dt_image_remove(imgid);
 
      // ... and delete afterwards because removing will re-write the XMP
      delete_status = delete_file_from_disk(filename, &delete_on_trash_error);
    }
 
delete_next_file:
#ifdef _WIN32
    dt_free(dirname);
#endif
    t = g_list_next(t);
    fraction += 1.0 / total;
    dt_control_job_set_progress(job, fraction);
    if(delete_status == _DT_DELETE_STATUS_STOP_PROCESSING)
      break;
  }
 
 
  _resync_xmp_duplicates(list);
  list = NULL;
  dt_film_remove_empty();
  dt_collection_update_query(dt_collection_get_global(), DT_COLLECTION_CHANGE_RELOAD, DT_COLLECTION_PROP_UNDEF,
                             g_list_copy(params->index));
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_FILMROLLS_CHANGED);
  dt_control_queue_redraw_center();
  return 0;
}
 
static int32_t dt_control_gpx_apply_job_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = dt_control_job_get_params(job);
  GList *t = params->index;
  struct dt_gpx_t *gpx = NULL;
  uint32_t cntr = 0;
  const dt_control_gpx_apply_t *d = params->data;
  const gchar *filename = d->filename;
  const gchar *tz = d->tz;
  /* do we have any selected images */
  if(IS_NULL_PTR(t)) goto bail_out;
 
  /* try parse the gpx data */
  gpx = dt_gpx_new(filename);
  if(IS_NULL_PTR(gpx))
  {
    dt_control_log(_("failed to parse GPX file"));
    goto bail_out;
  }
 
  GTimeZone *tz_camera = (IS_NULL_PTR(tz)) ? g_time_zone_new_utc() : g_time_zone_new(tz);
  if(IS_NULL_PTR(tz_camera)) goto bail_out;
 
  GList *imgs = NULL;
  GArray *gloc = g_array_new(FALSE, FALSE, sizeof(dt_image_geoloc_t));
  /* go thru each selected image and lookup location in gpx */
  do
  {
    dt_image_geoloc_t geoloc;
    int32_t imgid = GPOINTER_TO_INT(t->data);
 
    /* get image */
    const dt_image_t *cimg = dt_image_cache_get(imgid, 'r');
    if(IS_NULL_PTR(cimg)) continue;
 
    GDateTime *exif_time = dt_datetime_img_to_gdatetime(cimg, tz_camera);
 
    /* release the lock */
    dt_image_cache_read_release(cimg);
    if(IS_NULL_PTR(exif_time)) continue;
    GDateTime *utc_time = g_date_time_to_timezone(exif_time, dt_datetime_utc_tz());
    g_date_time_unref(exif_time);
    if(IS_NULL_PTR(utc_time)) continue;
 
    /* only update image location if time is within gpx tack range */
    if(dt_gpx_get_location(gpx, utc_time, &geoloc))
    {
      // takes the option to include the grouped images
      GList *grps = dt_grouping_get_group_images(imgid);
      for(GList *grp = grps; grp; grp = g_list_next(grp))
      {
        imgs = g_list_prepend(imgs, grp->data);
        g_array_append_val(gloc, geoloc);
        cntr++;
      }
      g_list_free(grps);
      grps = NULL;
    }
    g_date_time_unref(utc_time);
  } while((t = g_list_next(t)) != NULL);
  imgs = g_list_reverse(imgs);
 
  dt_image_set_images_locations(imgs, gloc, TRUE);
 
  dt_control_log(ngettext("applied matched GPX location onto %d image",
                          "applied matched GPX location onto %d images", cntr), cntr);
 
  g_time_zone_unref(tz_camera);
  dt_gpx_destroy(gpx);
  g_array_unref(gloc);
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_GEOTAG_CHANGED, imgs, 0);
  return 0;
 
bail_out:
  if(!IS_NULL_PTR(gpx)) dt_gpx_destroy(gpx);
 
  return 1;
}
 
static int32_t dt_control_move_images_job_run(dt_job_t *job)
{
  return _generic_dt_control_fileop_images_job_run(job, &dt_image_move, _("moving %d image"),
                                                   _("moving %d images"));
}
 
static int32_t dt_control_copy_images_job_run(dt_job_t *job)
{
  return _generic_dt_control_fileop_images_job_run(job, &dt_image_copy, _("copying %d image"),
                                                   _("copying %d images"));
}
 
static int32_t dt_control_local_copy_images_job_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = (dt_control_image_enumerator_t *)dt_control_job_get_params(job);
  GList *t = params->index;
  guint tagid = 0;
  const guint total = g_list_length(t);
  double fraction = 0;
  const gboolean is_copy = params->flag == 1;
  char message[512] = { 0 };
 
  if(is_copy)
    snprintf(message, sizeof(message),
             ngettext("creating local copy of %d image", "creating local copies of %d images", total), total);
  else
    snprintf(message, sizeof(message),
             ngettext("removing local copy of %d image", "removing local copies of %d images", total), total);
 
  dt_control_log("%s", message);
  dt_control_job_set_progress_message(job, message);
 
  dt_tag_new("darktable|local-copy", &tagid);
 
  gboolean tag_change = FALSE;
  while(t && dt_control_job_get_state(job) != DT_JOB_STATE_CANCELLED)
  {
    const int32_t imgid = GPOINTER_TO_INT(t->data);
    if(is_copy)
    {
      if(dt_image_local_copy_set(imgid) == 0)
      {
        if(dt_tag_attach(tagid, imgid, FALSE, FALSE)) tag_change = TRUE;
      }
    }
    else
    {
      if(dt_image_local_copy_reset(imgid) == 0)
      {
        if(dt_tag_detach(tagid, imgid, FALSE, FALSE)) tag_change = TRUE;
      }
    }
    t = g_list_next(t);
 
    fraction += 1.0 / total;
    dt_control_job_set_progress(job, fraction);
  }
 
  dt_collection_update_query(dt_collection_get_global(), DT_COLLECTION_CHANGE_RELOAD, DT_COLLECTION_PROP_LOCAL_COPY,
                             g_list_copy(params->index));
  if(tag_change) DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_TAG_CHANGED);
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_FILMROLLS_CHANGED);
  dt_control_queue_redraw_center();
  return 0;
}
 
static int32_t dt_control_refresh_exif_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = (dt_control_image_enumerator_t *)dt_control_job_get_params(job);
  GList *t = params->index;
  const guint total = g_list_length(t);
  double fraction = 0.0f;
  char message[512] = { 0 };
  snprintf(message, sizeof(message), ngettext("refreshing info for %d image", "refreshing info for %d images", total), total);
  dt_control_job_set_progress_message(job, message);
  while(t)
  {
    const int32_t imgid = GPOINTER_TO_INT(t->data);
    if(imgid >= 0)
    {
      gboolean from_cache = TRUE;
      char sourcefile[DT_PATH_MAX];
      dt_image_full_path(imgid,  sourcefile,  sizeof(sourcefile),  &from_cache, __FUNCTION__);
 
      dt_image_t *img = dt_image_cache_get(imgid, 'w');
      if(!IS_NULL_PTR(img))
      {
        // Re-sync the file-derived classification flags (LDR/HDR/RAW/sRAW, mosaic, monochrome,
        // 4bayer, additional-DNG-tags, buffer-resolved) with the actual file, repairing entries
        // that were persisted with stale/corrupted flags in the DB. We must *clear* these bits
        // before dt_exif_read(), because it only re-seeds the LDR/HDR/RAW class when none is set
        // yet (see exif.cc): leaving a stale DT_IMAGE_HDR in place would suppress the re-read.
        // Everything else in img->flags is DB-only / user state that the file knows nothing about
        // (star rating & reject, local copy, audio/txt sidecar, preset bookkeeping, monochrome
        // workflow), so it is preserved verbatim.
        const uint32_t file_class_flags
            = DT_IMAGE_LDR | DT_IMAGE_RAW | DT_IMAGE_HDR | DT_IMAGE_S_RAW | DT_IMAGE_4BAYER
            | DT_IMAGE_MONOCHROME | DT_IMAGE_MONOCHROME_BAYER | DT_IMAGE_MOSAIC
            | DT_IMAGE_BUFFER_RESOLVED | DT_IMAGE_HAS_ADDITIONAL_DNG_TAGS;
        img->flags &= ~file_class_flags;
        dt_exif_read(img, sourcefile);
        dt_image_cache_write_release(img, DT_IMAGE_CACHE_SAFE);
      }
      else
        fprintf(stderr,"[dt_control_refresh_exif_run] couldn't dt_image_cache_get for imgid %i\n", imgid);
 
      DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_DEVELOP_IMAGE_CHANGED);
    }
    else
      fprintf(stderr,"[dt_control_refresh_exif_run] illegal imgid %i\n", imgid);
 
    t = g_list_next(t);
    fraction += 1.0 / total;
    dt_control_job_set_progress(job, fraction);
  }
  dt_collection_update_query(dt_collection_get_global(), DT_COLLECTION_CHANGE_RELOAD, DT_COLLECTION_PROP_UNDEF,
                             g_list_copy(params->index));
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_TAG_CHANGED);
  dt_control_queue_redraw_center();
  return 0;
}
 
 
/* Whether the image is still in the library and its file still on disk; tells the user when it is not. */
static gboolean _export_source_available(const int32_t imgid)
{
  const dt_image_t *image = dt_image_cache_get(imgid, 'r');
  if(IS_NULL_PTR(image)) return FALSE;
 
  char imgfilename[DT_PATH_MAX] = { 0 };
  gboolean from_cache = TRUE;
  dt_image_full_path(image->id, imgfilename, sizeof(imgfilename), &from_cache, __FUNCTION__);
  const gboolean available = g_file_test(imgfilename, G_FILE_TEST_IS_REGULAR);
  if(!available)
  {
    dt_control_log(_("image `%s' is currently unavailable"), image->filename);
    fprintf(stderr, "image `%s' is currently unavailable\n", imgfilename);
  }
  dt_image_cache_read_release(image);
  return available;
}
 
static int32_t dt_control_export_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_export_t *settings = (dt_control_export_t *)params->data;
  GList *t = params->index;
  dt_imageio_module_format_t *mformat = dt_imageio_get_format_by_index(settings->format_index);
  g_assert(mformat);
  dt_imageio_module_storage_t *mstorage = dt_imageio_get_storage_by_index(settings->storage_index);
  g_assert(mstorage);
  dt_imageio_module_data_t *sdata = settings->sdata;
 
  gboolean tag_change = FALSE;
 
  // get a thread-safe fdata struct (one jpeg struct per thread etc):
  dt_imageio_module_data_t *fdata = mformat->get_params(mformat);
 
  if(mstorage->initialize_store)
  {
    if(mstorage->initialize_store(mstorage, sdata, &mformat, &fdata, &t, TRUE))
    {
      // bail out, something went wrong
      goto end;
    }
    mformat->set_params(mformat, fdata, mformat->params_size(mformat));
    mstorage->set_params(mstorage, sdata, mstorage->params_size(mstorage));
  }
 
  // Get max dimensions...
  uint32_t w, h, fw, fh, sw, sh;
  fw = fh = sw = sh = 0;
  mstorage->dimension(mstorage, sdata, &sw, &sh);
  mformat->dimension(mformat, fdata, &fw, &fh);
 
  if(sw == 0 || fw == 0)
    w = sw > fw ? sw : fw;
  else
    w = sw < fw ? sw : fw;
 
  if(sh == 0 || fh == 0)
    h = sh > fh ? sh : fh;
  else
    h = sh < fh ? sh : fh;
 
  const guint total = g_list_length(t);
  if(total > 0)
    dt_control_log(ngettext("exporting %d image..", "exporting %d images..", total), total);
  else
    dt_control_log(_("no image to export"));
 
  double fraction = 0;
 
  // set up the fdata struct
  fdata->max_width = (settings->max_width != 0 && w != 0) ? MIN(w, settings->max_width) : MAX(w, settings->max_width);
  fdata->max_height = (settings->max_height != 0 && h != 0) ? MIN(h, settings->max_height) : MAX(h, settings->max_height);
  g_strlcpy(fdata->style, settings->style, sizeof(fdata->style));
  // Invariant: the tagid for 'darktable|changed' will not change while this function runs. Is this a
  // sensible assumption?
  guint tagid = 0, etagid = 0;
  dt_tag_new("darktable|exported", &etagid);
 
  dt_export_metadata_t metadata;
  metadata.flags = 0;
  metadata.list = dt_util_str_to_glist("\1", settings->metadata_export);
  if(metadata.list)
  {
    metadata.flags = strtol(metadata.list->data, NULL, 16);
    metadata.list = g_list_remove(metadata.list, metadata.list->data);
  }
 
  while(t && dt_control_job_get_state(job) != DT_JOB_STATE_CANCELLED)
  {
    const int32_t imgid = GPOINTER_TO_INT(t->data);
    t = g_list_next(t);
    const guint num = total - g_list_length(t);
 
    // progress message
    char message[512] = { 0 };
    snprintf(message, sizeof(message), _("exporting %d / %d to %s"), num, total, mstorage->name(mstorage));
    // update the message. initialize_store() might have changed the number of images
    dt_control_job_set_progress_message(job, message);
 
    // remove 'changed' tag from image
    if(dt_tag_detach(tagid, imgid, FALSE, FALSE)) tag_change = TRUE;
    // make sure the 'exported' tag is set on the image
    if(dt_tag_attach(etagid, imgid, FALSE, FALSE)) tag_change = TRUE;
 
    /* register export timestamp in cache */
    dt_image_cache_set_export_timestamp(imgid);
 
    if(_export_source_available(imgid)
       && mstorage->store(mstorage, sdata, imgid, mformat, fdata, settings->scale_factor, num, total, TRUE,
                          settings->export_masks, settings->icc_type, settings->icc_filename,
                          settings->icc_intent, &metadata) != 0)
      dt_control_job_cancel(job);
 
    fraction += 1.0 / total;
    if(fraction > 1.0) fraction = 1.0;
    dt_control_job_set_progress(job, fraction);
  }
  g_list_free_full(metadata.list, dt_free_gpointer);
  metadata.list = NULL;
 
  if(mstorage->finalize_store) mstorage->finalize_store(mstorage, sdata);
 
end:
  // all threads free their fdata
  mformat->free_params(mformat, fdata);
 
  // notify the user via the window manager
  dt_ui_notify_user();
 
  if(tag_change) DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_TAG_CHANGED);
  return 0;
}
 
static dt_control_image_enumerator_t *dt_control_gpx_apply_alloc()
{
  dt_control_image_enumerator_t *params = dt_control_image_enumerator_alloc();
  if(IS_NULL_PTR(params)) return NULL;
 
  params->data = calloc(1, sizeof(dt_control_gpx_apply_t));
  if(IS_NULL_PTR(params->data))
  {
    dt_control_image_enumerator_cleanup(params);
    return NULL;
  }
 
  return params;
}
 
static void dt_control_gpx_apply_job_cleanup(void *p)
{
  dt_control_image_enumerator_t *params = p;
 
  dt_control_gpx_apply_t *data = params->data;
  params->data = NULL;
  dt_free(data->filename);
  dt_free(data->tz);
 
  dt_free(data);
 
  dt_control_image_enumerator_cleanup(params);
}
 
static dt_job_t *_control_gpx_apply_job_create(const gchar *filename, int32_t filmid,
                                               const gchar *tz, GList *imgs)
{
  dt_job_t *job = dt_control_job_create(&dt_control_gpx_apply_job_run, "gpx apply");
  if(IS_NULL_PTR(job)) return NULL;
  dt_control_image_enumerator_t *params = dt_control_gpx_apply_alloc();
  if(IS_NULL_PTR(params))
  {
    dt_control_job_dispose(job);
    return NULL;
  }
  dt_control_job_set_params(job, params, dt_control_gpx_apply_job_cleanup);
 
  if(filmid != -1)
    dt_control_image_enumerator_job_film_init(params, filmid);
  else if(!imgs)
    params->index = dt_act_on_get_images();
  else
    params->index = imgs;
  dt_control_gpx_apply_t *data = params->data;
  data->filename = g_strdup(filename);
  data->tz = g_strdup(tz);
 
  return job;
}
 
void dt_control_save_xmp(const int32_t imgid)
{
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG,
                     dt_control_generic_image_job_create(&dt_control_save_xmps_job_run,
                                                         N_("save history to XMP"),
                                                         0, NULL, PROGRESS_NONE, imgid));
}
 
void dt_control_save_xmps(const GList *imgids, const gboolean check_history)
{
  (void)check_history;
  if(IS_NULL_PTR(imgids)) return;
 
  dt_job_t *job = dt_control_job_create(&dt_control_save_xmps_job_run, "save xmp");
  if(IS_NULL_PTR(job)) return;
 
  dt_control_image_enumerator_t *params = dt_control_image_enumerator_alloc();
  if(IS_NULL_PTR(params))
  {
    dt_control_job_dispose(job);
    return;
  }
 
  params->index = g_list_copy((GList *)imgids);
  params->flag = 0;
 
  dt_control_job_set_params(job, params, dt_control_image_enumerator_cleanup);
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG, job);
}
 
void dt_control_save_xmps_forced(const GList *imgids)
{
  if(IS_NULL_PTR(imgids)) return;
 
  dt_job_t *job = dt_control_job_create(&dt_control_save_xmps_job_run, "save xmp");
  if(IS_NULL_PTR(job)) return;
 
  dt_control_image_enumerator_t *params = dt_control_image_enumerator_alloc();
  if(IS_NULL_PTR(params))
  {
    dt_control_job_dispose(job);
    return;
  }
 
  params->index = g_list_copy((GList *)imgids);
  params->flag = 1;
 
  dt_control_job_set_params(job, params, dt_control_image_enumerator_cleanup);
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG, job);
}
 
void dt_control_merge_hdr()
{
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG,
                     dt_control_generic_images_job_create(&dt_control_merge_hdr_job_run, N_("merge hdr image"), 0,
                                                          NULL, PROGRESS_CANCELLABLE, TRUE));
}
 
void dt_control_gpx_apply(const gchar *filename, int32_t filmid, const gchar *tz, GList *imgs)
{
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG,
                     _control_gpx_apply_job_create(filename, filmid, tz, imgs));
}
 
void dt_control_duplicate_images(gboolean virgin)
{
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG,
                     dt_control_generic_images_job_create(&dt_control_duplicate_images_job_run,
                                                          N_("duplicate images"), 0, GINT_TO_POINTER(virgin), PROGRESS_SIMPLE, TRUE));
}
 
void dt_control_flip_images(const dt_image_transform_t transform)
{
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG,
                     dt_control_generic_images_job_create(&dt_control_flip_images_job_run, N_("flip images"),
                                                          (int32_t)transform, NULL, PROGRESS_SIMPLE, TRUE));
}
 
void dt_control_monochrome_images(const int32_t mode)
{
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG,
                     dt_control_generic_images_job_create(&dt_control_monochrome_images_job_run, N_("set monochrome images"), mode,
                                                          NULL, PROGRESS_SIMPLE, TRUE));
}
 
gboolean dt_control_remove_images()
{
  const dt_view_t *const cv = dt_view_manager_get_current_view(dt_view_manager_get_global());
  if(cv->view(cv) != DT_VIEW_LIGHTTABLE)
  {
    dt_control_log(_("removing images from library is only possible in Lighttable view"));
    return FALSE;
  }
 
  // get all selected images now, to avoid the set changing during ui interaction
  dt_job_t *job = dt_control_generic_images_job_create(&dt_control_remove_images_job_run, N_("remove images"), 0,
                                                       NULL, PROGRESS_SIMPLE, FALSE);
  if(dt_conf_get_bool("ask_before_remove"))
  {
    GtkWidget *dialog;
    GtkWidget *win = dt_gui_main_window();
 
    const dt_control_image_enumerator_t *e = (dt_control_image_enumerator_t *)dt_control_job_get_params(job);
    const int number = g_list_length(e->index);
    if(number == 0)
    {
      dt_control_job_dispose(job);
      return TRUE;
    }
 
    dialog = gtk_message_dialog_new(
        GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
        ngettext("Do you really want to remove %d image from Ansel library ?\nThe files will not be deleted on disk.",
                 "Do you really want to remove %d images from Ansel library ?\nThe files will not be deletetd on disk.", number),
        number);
#ifdef GDK_WINDOWING_QUARTZ
    dt_osx_disallow_fullscreen(dialog);
#endif
 
    gtk_window_set_title(GTK_WINDOW(dialog), ngettext(_("Remove image from library ?"), _("Remove images from library ?"), number));
    gint res = gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
    if(res != GTK_RESPONSE_YES)
    {
      dt_control_job_dispose(job);
      return FALSE;
    }
  }
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG, job);
  return TRUE;
}
 
void dt_control_delete_images()
{
  const dt_view_t *const cv = dt_view_manager_get_current_view(dt_view_manager_get_global());
  if(cv->view(cv) != DT_VIEW_LIGHTTABLE)
  {
    dt_control_log(_("Deleting images from library is only possible in Lighttable view"));
    return;
  }
 
  // first get all selected images, to avoid the set changing during ui interaction
  dt_job_t *job = dt_control_generic_images_job_create(&dt_control_delete_images_job_run, N_("delete images"), 0,
                                                       NULL, PROGRESS_SIMPLE, FALSE);
  if(dt_conf_get_bool("ask_before_delete"))
  {
    GtkWidget *dialog;
    GtkWidget *win = dt_gui_main_window();
 
    const dt_control_image_enumerator_t *e = (dt_control_image_enumerator_t *)dt_control_job_get_params(job);
    const int number = g_list_length(e->index);
 
    // Do not show the dialog if no image is selected:
    if(number == 0)
    {
      dt_control_job_dispose(job);
      return;
    }
 
    dialog = gtk_message_dialog_new(
        GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
        ngettext("Do you really want to physically delete %d image ?\nThe system trash bin will be used if possible.",
                 "Do you really want to physically delete %d images ?\nThe system trash bin will be used if possible.", number),
        number);
#ifdef GDK_WINDOWING_QUARTZ
    dt_osx_disallow_fullscreen(dialog);
#endif
 
    gtk_window_set_title(GTK_WINDOW(dialog), ngettext(_("Remove image from disk ?"), _("Remove images from disk ?"), number));
    gint res = gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
    if(res != GTK_RESPONSE_YES)
    {
      dt_control_job_dispose(job);
      return;
    }
  }
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG, job);
}
 
void dt_control_delete_image(int32_t imgid)
{
  const dt_view_t *const cv = dt_view_manager_get_current_view(dt_view_manager_get_global());
  if(cv->view(cv) != DT_VIEW_LIGHTTABLE)
  {
    dt_control_log(_("Deleting images from library is only possible in Lighttable view"));
    return;
  }
  // first get all selected images, to avoid the set changing during ui interaction
  dt_job_t *job = dt_control_generic_image_job_create(&dt_control_delete_images_job_run, N_("delete images"), 0,
                                                      NULL, PROGRESS_SIMPLE, imgid);
  int send_to_trash = dt_conf_get_bool("send_to_trash");
  if(dt_conf_get_bool("ask_before_delete"))
  {
    GtkWidget *dialog;
    GtkWidget *win = dt_gui_main_window();
 
    // Do not show the dialog if no valid image
    if(imgid < 1)
    {
      dt_control_job_dispose(job);
      return;
    }
 
    dialog = gtk_message_dialog_new(
        GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
        send_to_trash ? _("do you really want to physically delete selected image (using trash if possible)?")
                      : _("do you really want to physically delete selected image from disk?"));
#ifdef GDK_WINDOWING_QUARTZ
    dt_osx_disallow_fullscreen(dialog);
#endif
 
    gtk_window_set_title(GTK_WINDOW(dialog), _("delete image?"));
    gint res = gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
    if(res != GTK_RESPONSE_YES)
    {
      dt_control_job_dispose(job);
      return;
    }
  }
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG, job);
}
 
void dt_control_move_images()
{
  // Open file chooser dialog
  gchar *dir = NULL;
  GtkWidget *win = dt_gui_main_window();
 
  dt_job_t *job = dt_control_generic_images_job_create(&dt_control_move_images_job_run, N_("move images"), 0, dir,
                                                       PROGRESS_CANCELLABLE, FALSE);
  const dt_control_image_enumerator_t *e = (dt_control_image_enumerator_t *)dt_control_job_get_params(job);
  const int number = g_list_length(e->index);
  if(number == 0)
  {
    dt_control_job_dispose(job);
    return;
  }
 
  GtkFileChooserNative *filechooser = gtk_file_chooser_native_new(
        _("select directory"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
        _("_select as destination"), _("_cancel"));
 
  dt_conf_get_folder_to_file_chooser("ui_last/move_path", GTK_FILE_CHOOSER(filechooser));
  if(gtk_native_dialog_run(GTK_NATIVE_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
  {
    dir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
    dt_conf_set_folder_from_file_chooser("ui_last/move_path", GTK_FILE_CHOOSER(filechooser));
  }
  g_object_unref(filechooser);
 
  if(IS_NULL_PTR(dir) || !g_file_test(dir, G_FILE_TEST_IS_DIR)) goto abort;
 
  // ugly, but we need to set this after constructing the job:
  ((dt_control_image_enumerator_t *)dt_control_job_get_params(job))->data = dir;
  // the job's cleanup function is responsible for freeing dir, so we don't do that here
 
  if(dt_conf_get_bool("ask_before_move"))
  {
    GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT,
                                               GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
                                               ngettext("do you really want to physically move %d image to %s?\n"
                                                        "(all duplicates will be moved along)",
                                                        "do you really want to physically move %d images to %s?\n"
                                                        "(all duplicates will be moved along)",
                                                        number),
                                               number, dir);
#ifdef GDK_WINDOWING_QUARTZ
    dt_osx_disallow_fullscreen(dialog);
#endif
    gtk_window_set_title(GTK_WINDOW(dialog), ngettext("move image?", "move images?", number));
 
    gint res = gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
 
    if(res != GTK_RESPONSE_YES) goto abort;
  }
 
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG, job);
  return;
 
abort:
  dt_free(dir);
  dt_control_job_dispose(job);
}
 
void dt_control_copy_images()
{
  // Open file chooser dialog
  gchar *dir = NULL;
  GtkWidget *win = dt_gui_main_window();
  dt_job_t *job = dt_control_generic_images_job_create(&dt_control_copy_images_job_run, N_("copy images"), 0, dir,
                                                       PROGRESS_CANCELLABLE, FALSE);
  const dt_control_image_enumerator_t *e = (dt_control_image_enumerator_t *)dt_control_job_get_params(job);
  const int number = g_list_length(e->index);
  if(number == 0)
  {
    dt_control_job_dispose(job);
    return;
  }
 
  GtkFileChooserNative *filechooser = gtk_file_chooser_native_new(
        _("select directory"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
        _("_select as destination"), _("_cancel"));
 
  dt_conf_get_folder_to_file_chooser("ui_last/copy_path", GTK_FILE_CHOOSER(filechooser));
  if(gtk_native_dialog_run(GTK_NATIVE_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
  {
    dir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
    dt_conf_set_folder_from_file_chooser("ui_last/copy_path", GTK_FILE_CHOOSER(filechooser));
  }
  g_object_unref(filechooser);
 
  if(IS_NULL_PTR(dir) || !g_file_test(dir, G_FILE_TEST_IS_DIR)) goto abort;
 
  // ugly, but we need to set this after constructing the job:
  ((dt_control_image_enumerator_t *)dt_control_job_get_params(job))->data = dir;
  // the job's cleanup function is responsible for freeing dir, so we don't do that here
 
  if(dt_conf_get_bool("ask_before_copy"))
  {
    GtkWidget *dialog = gtk_message_dialog_new(
        GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
        ngettext("do you really want to physically copy %d image to %s?",
                 "do you really want to physically copy %d images to %s?", number),
        number, dir);
#ifdef GDK_WINDOWING_QUARTZ
    dt_osx_disallow_fullscreen(dialog);
#endif
    gtk_window_set_title(GTK_WINDOW(dialog), ngettext("copy image?", "copy images?", number));
 
    gint res = gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
 
    if(res != GTK_RESPONSE_YES) goto abort;
  }
 
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG, job);
  return;
 
abort:
  dt_free(dir);
  dt_control_job_dispose(job);
}
 
void dt_control_set_local_copy_images()
{
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG,
                     dt_control_generic_images_job_create(&dt_control_local_copy_images_job_run,
                                                          N_("local copy images"), 1, NULL, PROGRESS_CANCELLABLE,
                                                          FALSE));
}
 
void dt_control_reset_local_copy_images()
{
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG,
                     dt_control_generic_images_job_create(&dt_control_local_copy_images_job_run,
                                                          N_("local copy images"), 0, NULL, PROGRESS_CANCELLABLE,
                                                          FALSE));
}
 
void dt_control_refresh_exif()
{
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG,
                     dt_control_generic_images_job_create(&dt_control_refresh_exif_run, N_("refresh exif"), 0,
                                                          NULL, PROGRESS_CANCELLABLE, FALSE));
}
 
static dt_control_image_enumerator_t *dt_control_export_alloc()
{
  dt_control_image_enumerator_t *params = dt_control_image_enumerator_alloc();
  if(IS_NULL_PTR(params)) return NULL;
 
  params->data = calloc(1, sizeof(dt_control_export_t));
  if(IS_NULL_PTR(params->data))
  {
    dt_control_image_enumerator_cleanup(params);
    return NULL;
  }
 
  return params;
}
 
static void dt_control_export_cleanup(void *p)
{
  dt_control_image_enumerator_t *params = p;
 
  dt_control_export_t *settings = (dt_control_export_t *)params->data;
  dt_imageio_module_storage_t *mstorage = dt_imageio_get_storage_by_index(settings->storage_index);
  dt_imageio_module_data_t *sdata = settings->sdata;
 
  mstorage->free_params(mstorage, sdata);
 
  dt_free(settings->icc_filename);
  dt_free(settings->metadata_export);
  dt_free(params->data);
 
  dt_control_image_enumerator_cleanup(params);
}
 
void dt_control_export(GList *imgid_list, const dt_control_export_request_t *request)
{
  dt_job_t *job = dt_control_job_create(&dt_control_export_job_run, "export");
  if(IS_NULL_PTR(job)) return;
  dt_control_image_enumerator_t *params = dt_control_export_alloc();
  if(IS_NULL_PTR(params))
  {
    dt_control_job_dispose(job);
    return;
  }
  dt_control_job_set_params(job, params, dt_control_export_cleanup);
 
  params->index = imgid_list;
 
  dt_control_export_t *data = params->data;
  data->max_width = request->max_width;
  data->max_height = request->max_height;
  data->scale_factor = request->scale_factor;
  data->format_index = request->format_index;
  data->storage_index = request->storage_index;
  dt_imageio_module_storage_t *mstorage = dt_imageio_get_storage_by_index(request->storage_index);
  g_assert(mstorage);
  // get shared storage param struct (global sequence counter, one picasa connection etc)
  dt_imageio_module_data_t *sdata = mstorage->get_params(mstorage);
  if(IS_NULL_PTR(sdata))
  {
    dt_control_alert(_("Export failed"), _("failed to get parameters from storage module, aborting export.."),
                     mstorage->name(mstorage));
    dt_control_job_dispose(job);
    return;
  }
  data->sdata = sdata;
  data->export_masks = request->export_masks;
  g_strlcpy(data->style, request->style, sizeof(data->style));
  data->icc_type = request->icc_type;
  data->icc_filename = g_strdup(request->icc_filename);
  data->icc_intent = request->icc_intent;
  data->metadata_export = g_strdup(request->metadata_export);
 
  dt_control_job_add_progress(job, _("export images"), TRUE);
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_EXPORT, job);
 
  // tell the storage that we got its params for an export so it can reset itself to a safe state
  mstorage->export_dispatched(mstorage);
}
 
static void _add_datetime_offset(const char *odt, const long int offset, char *ndt)
{
  // get the datetime_taken and calculate the new time
  GDateTime *datetime_original = dt_datetime_exif_to_gdatetime(odt, dt_datetime_utc_tz());
  if(IS_NULL_PTR(datetime_original))
    return;
 
  // let's add our offset
  GDateTime *datetime_new = g_date_time_add(datetime_original, offset);
  g_date_time_unref(datetime_original);
 
  if(IS_NULL_PTR(datetime_new))
    return;
  gchar *datetime = g_date_time_format(datetime_new, "%Y:%m:%d %H:%M:%S,%f");
  datetime[DT_DATETIME_LENGTH - 1] = '\0';  // limit to milliseconds
  g_date_time_unref(datetime_new);
 
  if(datetime)
    g_strlcpy(ndt, datetime, DT_DATETIME_LENGTH);
  dt_free(datetime);
}
 
static int32_t dt_control_datetime_job_run(dt_job_t *job)
{
  dt_control_image_enumerator_t *params = (dt_control_image_enumerator_t *)dt_control_job_get_params(job);
  uint32_t cntr = 0;
  GList *t = params->index;
  const GTimeSpan offset = ((dt_control_datetime_t *)params->data)->offset;
  const char *datetime = ((dt_control_datetime_t *)params->data)->datetime;
  char message[512] = { 0 };
 
  /* do we have any selected images and is offset != 0 */
  if(IS_NULL_PTR(t) || (offset == 0 && !datetime[0]))
  {
    return 1;
  }
 
  const guint total = g_list_length(t);
 
  const char *mes11 = offset ? N_("adding time offset to %d image") : N_("setting date/time of %d image");
  const char *mes12 = offset ? N_("adding time offset to %d images") : N_("setting date/time of %d images");
  snprintf(message, sizeof(message), ngettext(mes11, mes12, total), total);
  dt_control_job_set_progress_message(job, message);
 
  GList *imgs = NULL;
  if(offset)
  {
    GArray *dtime = g_array_new(FALSE, TRUE, DT_DATETIME_LENGTH);
 
    for(GList *img = t; img; img = g_list_next(img))
    {
      char odt[DT_DATETIME_LENGTH] = {0};
      dt_image_get_datetime(GPOINTER_TO_INT(img->data), odt);
      if(!odt[0]) continue;
 
      char ndt[DT_DATETIME_LENGTH] = {0};
      _add_datetime_offset(odt, offset, ndt);
      if(!ndt[0]) continue;
 
      // takes the option to include the grouped images
      GList *grps = dt_grouping_get_group_images(GPOINTER_TO_INT(img->data));
      for(GList *grp = grps; grp; grp = g_list_next(grp))
      {
        imgs = g_list_prepend(imgs, grp->data);
        g_array_append_val(dtime, ndt);
        cntr++;
      }
      g_list_free(grps);
      grps = NULL;
    }
    imgs = g_list_reverse(imgs);
    dt_image_set_datetimes(imgs, dtime, TRUE);
  }
  else
  {
    imgs = g_list_copy(t);
    // takes the option to include the grouped images
    dt_grouping_add_grouped_images(&imgs);
    cntr = g_list_length(imgs);
    dt_image_set_datetime(imgs, datetime, TRUE);
  }
 
  const char *mes21 = offset ? N_("added time offset to %d image") : N_("set date/time of %d image");
  const char *mes22 = offset ? N_("added time offset to %d images") : N_("set date/time of %d images");
  dt_control_log(ngettext(mes21, mes22, cntr), cntr);
  return 0;
}
 
static void *dt_control_datetime_alloc()
{
  dt_control_image_enumerator_t *params = dt_control_image_enumerator_alloc();
  if(IS_NULL_PTR(params)) return NULL;
 
  params->data = calloc(1, sizeof(dt_control_datetime_t));
  if(IS_NULL_PTR(params->data))
  {
    dt_control_image_enumerator_cleanup(params);
    return NULL;
  }
 
  return params;
}
 
static void dt_control_datetime_job_cleanup(void *p)
{
  dt_control_image_enumerator_t *params = (dt_control_image_enumerator_t *)p;
 
  dt_free(params->data);
 
  dt_control_image_enumerator_cleanup(params);
}
 
static dt_job_t *dt_control_datetime_job_create(const GTimeSpan offset, const char *datetime, GList *imgs)
{
  dt_job_t *job = dt_control_job_create(&dt_control_datetime_job_run, "time offset");
  if(IS_NULL_PTR(job)) return NULL;
  dt_control_image_enumerator_t *params = dt_control_datetime_alloc();
  if(IS_NULL_PTR(params))
  {
    dt_control_job_dispose(job);
    return NULL;
  }
  dt_control_job_add_progress(job, _("time offset"), FALSE);
  dt_control_job_set_params(job, params, dt_control_datetime_job_cleanup);
 
  if(imgs)
    params->index = imgs;
  else
    params->index = dt_act_on_get_images();
 
  dt_control_datetime_t *data = params->data;
  data->offset = offset;
  if(!IS_NULL_PTR(datetime))
    memcpy(data->datetime, datetime, sizeof(data->datetime));
  else
    data->datetime[0] = '\0';
  params->data = data;
  return job;
}
 
void dt_control_datetime(const GTimeSpan offset, const char *datetime, GList *imgs)
{
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_FG,
                     dt_control_datetime_job_create(offset, datetime, imgs));
}
 
// clang-format off
// modelines: These editor modelines have been set for all relevant files by tools/update_modelines.py
// vim: shiftwidth=2 expandtab tabstop=2 cindent
// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
// clang-format on