import.c

Go to the documentation of this file.

/*
    This file is part of the Ansel project.
    Copyright (C) 2023-2024 Alynx Zhou.
    Copyright (C) 2023-2026 Aurélien PIERRE.
    Copyright (C) 2023-2025 Guillaume Stutin.
    Copyright (C) 2023 lologor.
    Copyright (C) 2023 Luca Zulberti.
    
    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/film.h"
#include "caches/pixelpipe_cache_alloc.h"
#include "common/file_location.h"
#include "metadata/exif.h"
#include "gui/import.h"
#include "common/image.h"
#include "caches/image_cache.h"
#include "common/image_extensions.h"
#include "imageio/imageio_core.h"
#include "metadata/metadata.h"
#include "common/datetime.h"
#include "common/conf.h"
#include "control/control.h"
#include "control/signal.h"
#include "control/jobs/control_jobs.h"   // dt_control_image_enumerator_t
#include "control/jobs/import_jobs.h"
 
#include "widgets/gtkentry.h"
 
#include <gio/gio.h>
 
#ifdef GDK_WINDOWING_QUARTZ
#include "osx/osx.h"
#endif
#ifdef _WIN32
//MSVCRT does not have strptime implemented
#endif
#include <librsvg/rsvg.h>
#include "common/utility.h"
#include "common/logging.h"
#include "gui/application.h"
#include "widgets/accelerators.h"
#include "widgets/popup.h"
#include "widgets/widget_settings.h"
#include "widgets/widget_style.h"
// ugh, ugly hack. why do people break stuff all the time?
#ifndef RSVG_CAIRO_H
#include <librsvg/rsvg-cairo.h>
#endif
 
 
typedef struct dt_import_scan_state_t
{
  dt_pthread_mutex_t lock;
  uint32_t generation;
  uint32_t refcount;
  gboolean closing;
} dt_import_scan_state_t;
 
// dt_import_filter_type_t (gui/import.h) mirrors the 3 GtkFileFilter entries built by
// _file_filters(). The recursive folder scan runs on a worker thread and must not touch
// GtkFileFilter (Gtk objects are not thread-safe), so the active filter is resolved to one of
// those plain values on the GUI thread, once, in dt_import_init().
 
typedef struct dt_import_t {
  // User-selected folders and files from the Gtk file chooser,
  // referenced by basename.
  GSList *selection;
 
  // List of GFiles to import, built recursively by traversing the user selection
  GList *files;
 
  // Generation snapshot captured when this job starts.
  uint32_t generation;
 
  // Number of elements in the list
  uint32_t elements;
 
  // Job-local lock. Do not alias dialog state because the dialog can be destroyed
  // while background jobs are still running.
  dt_pthread_mutex_t lock;
 
  dt_import_scan_state_t *scan_state;
 
  // Active GUI file-type filter (All/Raw/Raster), snapshotted on the GUI thread.
  dt_import_filter_type_t filter_type;
 
  // Number of folders that could not be enumerated (permission denied, I/O error, folder gone
  // mid-scan...) during this recursive scan. See _recurse_folder(): GLib reports these through a
  // GError that used to be silently discarded (NULL error arg), so a folder failure looked
  // identical to "this folder is simply empty" -- no way to tell the user why an expected file
  // didn't show up.
  guint scan_errors;
 
} dt_import_t;
 
typedef enum exif_fields_t {
  EXIF_DATETIME_FIELD = 0,
  EXIF_SEPARATOR1_FIELD,
  EXIF_MODEL_FIELD,
  EXIF_MAKER_FIELD,
  EXIF_LENS_FIELD,
  EXIF_FOCAL_LENS_FIELD,
  EXIF_SEPARATOR2_FIELD,
  EXIF_EXPOSURE_FIELD,
  EXIF_SEPARATOR3_FIELD,
  EXIF_INLIB_FIELD,
  EXIF_PATH_FIELD,
  EXIF_LAST_FIELD
} exif_fields_t;
 
 
typedef struct dt_lib_import_t
{
  GtkWidget *file_chooser;
  GtkWidget *preview;
  GtkWidget *exif;
 
  GtkWidget *exif_info[EXIF_LAST_FIELD];
  GtkWidget *datetime;
  GtkWidget *dialog;
  GtkWidget *grid;
  GtkWidget *jobcode;
 
  GtkWidget *help_string;
  GtkWidget *test_path;
  GtkWidget *selected_files;
  guint selection_scan_timeout_id;
 
  // The 3 filters registered in the file chooser by _file_filters(), kept around so
  // dt_import_init() can tell which one is currently active by pointer comparison.
  GtkFileFilter *filter_all;
  GtkFileFilter *filter_raw;
  GtkFileFilter *filter_raster;
 
  // Mirrors the last dt_import_t::filter_type resolved by dt_import_init(), so
  // _filelist_changed_callback() (GUI thread, only gets files/elements/finished from the signal)
  // can word the selected-files label according to the active filter.
  dt_import_filter_type_t last_filter_type;
 
  gboolean closing;
 
  dt_pthread_mutex_t lock;
 
  char *path_file;
 
  dt_import_scan_state_t *scan_state;
 
} dt_lib_import_t;
 
static dt_import_t *dt_import_init(dt_lib_import_t *d, const uint32_t generation);
static void dt_import_cleanup(void *import);
 
static dt_lib_import_t * _init();
static void _cleanup(dt_lib_import_t *d);
 
static void gui_init(dt_lib_import_t *d);
static void gui_cleanup(dt_lib_import_t *d);
 
static void _set_test_path(dt_lib_import_t *d, dt_image_t *img);
 
static void _do_select_all(dt_lib_import_t *d);
static void _do_select_none(dt_lib_import_t *d);
static void _do_select_new(dt_lib_import_t *d);
static gboolean _selection_changed_scan_trigger(gpointer user_data);
 
static void _recurse_folder(GVfs *vfs, GFile *folder, dt_import_t *const import);
 
static gboolean _scan_still_valid(dt_import_t *const import)
{
  gboolean valid = FALSE;
  dt_pthread_mutex_lock(&import->scan_state->lock);
  valid = !import->scan_state->closing && import->scan_state->generation == import->generation;
  dt_pthread_mutex_unlock(&import->scan_state->lock);
  return valid;
}
 
// one-liner to set GtkLabel text from non-constant text and free it straight away
static void _gtk_label_set_and_free(GtkWidget *widget, gchar *label)
{
  gtk_label_set_text(GTK_LABEL(widget), label);
  dt_free(label);
}
 
// dt_image_ext_is_gui_raw()/is_gui_raster() (common/image_extensions.c) are shared with
// _file_filters() below so the GtkFileFilter patterns and this recursive-scan check can never
// drift. Public (gui/import.h): the drag-and-drop folder-import path (gui/dtgtk/thumbtable.c)
// reuses this exact function rather than re-deriving the same "does this file match" logic.
gboolean dt_import_passes_filter(const dt_import_filter_type_t filter_type, const gchar *pathname)
{
  if(!dt_supported_image(pathname)) return FALSE;
  if(filter_type == DT_IMPORT_FILTER_ALL) return TRUE;
 
  const char *extension = g_strrstr(pathname, ".");
  if(IS_NULL_PTR(extension)) return FALSE;
  extension++;
 
  return (filter_type == DT_IMPORT_FILTER_RAW) ? dt_image_ext_is_gui_raw(extension)
                                                : dt_image_ext_is_gui_raster(extension);
}
 
static void _filter_document(GVfs *vfs, GFile *document, dt_import_t *import)
{
  if(!_scan_still_valid(import)) return;
 
  gchar *pathname = g_file_get_path(document);
 
  // Check that document is a real file (not directory) and it passes the type check defined by user in GUI filters.
  // gtk_file_chooser_get_files() applies the filters on the first level of recursivity,
  // so this test is only useful for the next levels if folders are selected at the first level.
  // We must not call GtkFileFilter from worker threads because Gtk objects are not thread-safe,
  // so import->filter_type (a plain enum snapshotted on the GUI thread, see dt_import_init())
  // stands in for the live GtkFileFilter here.
  if(pathname && g_file_test(pathname, G_FILE_TEST_IS_REGULAR) && dt_import_passes_filter(import->filter_type, pathname))
  {
    import->files = g_list_prepend(import->files, pathname);
    // prepend is more efficient than append. Import control reorders alphabetically anyway.
    pathname = NULL;
  }
  else if(pathname && g_file_test(pathname, G_FILE_TEST_IS_DIR))
  {
    _recurse_folder(vfs, document, import);
  }
 
  dt_free(pathname);
}
 
static void _report_scan_error(dt_import_t *const import, GFile *folder, GError *error)
{
  gchar *path = g_file_get_path(folder);
  dt_print(DT_DEBUG_IMPORT, "[import] could not fully scan folder `%s': %s\n",
           path ? path : "?", error->message);
  dt_free(path);
  g_error_free(error);
  import->scan_errors++;
}
 
static void _recurse_folder(GVfs *vfs, GFile *folder, dt_import_t *const import)
{
  // Get subfolders and files from current folder
  if(!_scan_still_valid(import)) return;
 
  GError *error = NULL;
  GFileEnumerator *files
      = g_file_enumerate_children(folder, G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE,
                                  G_FILE_QUERY_INFO_NONE, NULL, &error);
  if(IS_NULL_PTR(files))
  {
    // e.g. permission denied, or the folder vanished mid-scan: previously silent (NULL error arg),
    // indistinguishable from "this folder is simply empty".
    if(error) _report_scan_error(import, folder, error);
    return;
  }
 
  GFile *file = NULL;
  GError *iter_error = NULL;
  while(g_file_enumerator_iterate(files, NULL, &file, NULL, &iter_error))
  {
    // g_file_enumerator_iterate returns FALSE only on errors, not on end of enumeration.
    // We need an ugly break here else infinite loop.
    if(IS_NULL_PTR(file)) break;
 
    // Shutdown ASAP
    if(!_scan_still_valid(import))
    {
      g_object_unref(files);
      return;
    }
 
    _filter_document(vfs, file, import);
    // g_file_enumerator_iterate() returns transfer-none children owned by the enumerator.
    // Unref happens when the enumerator advances or is destroyed.
    file = NULL;
  }
 
  // A FALSE return above without a set error just means "iteration finished normally" -- only
  // report when GLib actually set one.
  if(iter_error) _report_scan_error(import, folder, iter_error);
 
  g_object_unref(files);
}
 
static void _recurse_selection(GSList *selection, dt_import_t *const import)
{
  // Entry point of the file recursion : process user selection.
  // GtkFileChooser gives us a GSList for selection, so we can't directly recurse from here
  // since the import job expects a GList.
 
  if(!_scan_still_valid(import) || IS_NULL_PTR(selection)) return;
 
  GVfs *vfs = g_vfs_get_default();
  for(GSList *uri = selection; uri; uri = g_slist_next(uri))
  {
    GFile *file = g_vfs_get_file_for_uri(vfs, (const char *)uri->data);
    _filter_document(vfs, file, import);
    g_object_unref(file);
  }
 
  import->files = g_list_sort(import->files, (GCompareFunc) g_strcmp0);
}
 
static int32_t dt_get_selected_files(dt_import_t *import)
{
  // Recurse through subfolders if any selected.
  // Can be called directly from GUI thread without using a job,
  // but that might freeze the GUI on large directories.
 
  dt_pthread_mutex_lock(&import->lock);
 
  // Get the new list
  _recurse_selection(import->selection, import);
  import->elements = (import->files) ? g_list_length(import->files) : 0;
  gboolean valid = _scan_still_valid(import);
 
  // If shutdown was triggered, we may already have no Gtk label widget to update through the callback.
  // In that case, it will segfault. So don't raise the signal at all if shutdown was set.
  if(valid)
  {
    dt_pthread_mutex_unlock(&import->lock);
 
    // Raise even when import->files is empty (e.g. the active Raw/Raster filter matched
    // nothing recursively): receivers need to know detection finished with zero results,
    // otherwise the GUI label is stuck on "Detecting..." and clicking Import never fires
    // _process_file_list, leaving the dialog looking frozen. scan_errors rides along so the
    // label can report folders that failed to scan (permission denied, etc.) -- see
    // _set_selected_files_label().
    DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_FILELIST_CHANGED, import->files, import->elements, 1,
                                  import->scan_errors);
    // Signal receivers only observe this list. Ownership stays in dt_import_t and is released in dt_import_cleanup.
  }
  else if(import->files)
  {
    g_list_free_full(g_steal_pointer(&import->files), dt_free_gpointer);
    import->files = NULL;
    // no callback will be triggered. Free here.
 
    dt_pthread_mutex_unlock(&import->lock);
  }
  else
  {
    dt_pthread_mutex_unlock(&import->lock);
  }
 
  return valid; // TRUE if completed without interruption
}
 
static int32_t _get_selected_files_job(dt_job_t *job)
{
  return dt_get_selected_files((dt_import_t *)dt_control_job_get_params(job));
}
 
void dt_control_get_selected_files(dt_lib_import_t *d, gboolean destroy_window)
{
  if(d->closing || IS_NULL_PTR(d->scan_state)) return;
 
  uint32_t generation = 0;
  dt_pthread_mutex_lock(&d->scan_state->lock);
  if(d->scan_state->closing)
  {
    dt_pthread_mutex_unlock(&d->scan_state->lock);
    return;
  }
  d->scan_state->generation++;
  generation = d->scan_state->generation;
  dt_pthread_mutex_unlock(&d->scan_state->lock);
 
  dt_job_t *job = dt_control_job_create(&_get_selected_files_job, "recursively detect files to import");
  if(job)
  {
    dt_import_t *import = dt_import_init(d, generation);
    if(IS_NULL_PTR(import))
    {
      dt_control_job_dispose(job);
      return;
    }
    dt_control_job_set_params(job, import, dt_import_cleanup);
    // Note : we don't free import->files. It's returned with the signal.
    dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_BG, job);
  }
}
 
static GdkPixbuf *_import_get_thumbnail(const gchar *filename, const int width, const int height,
                                        const gboolean valid_exif, dt_image_t *img)
{
  if(!filename || !g_file_test(filename, G_FILE_TEST_IS_REGULAR)) return NULL;
 
  GdkPixbuf *pixbuf = NULL;
  uint8_t *buffer = NULL;
  int32_t th_width;
  int32_t th_height;
  char *mime_type = NULL;
  const char *const extension = g_strrstr(filename, ".");
  const dt_image_flags_t file_type = extension ? dt_image_flags_from_extension(extension + 1) : 0u;
  dt_colorspaces_color_profile_type_t color_space;
  if(!dt_image_is_hdr(img)
     && !dt_imageio_large_thumbnail(filename, &buffer, &th_width, &th_height, &color_space, width, height))
  {
    // Show the framing the camera recorded, not the wider frame it renders its previews from,
    // so the import window matches what the lighttable and darkroom will show after import.
    dt_boundingbox_t usercrop;
    dt_image_get_usercrop(img, usercrop);
    dt_imageio_crop_thumbnail(usercrop, buffer, &th_width, &th_height);
 
    const float ratio = ((float)th_height) / ((float)th_width);
 
    // Convert RGBa to RGB because GdkPixbuf doesn't do RGBa
    uint8_t *rgb = dt_pixelpipe_cache_alloc_align_cache(
        th_width * th_height * 3 * sizeof(uint8_t),
        0);
    if(rgb)
    {
      __OMP_PARALLEL_FOR__()
      for(size_t k = 0; k < th_width * th_height; k++)
      {
        const float alpha = buffer[k * 4 + 3] > 0 ? buffer[k * 4 + 3] / 255.0f : 1.0f;
        rgb[k * 3] = CLAMP((int)roundf((buffer[k * 4] / 255.0f * alpha + (1.0f - alpha)) * 255.0f), 0, 255);
        rgb[k * 3 + 1] = CLAMP((int)roundf((buffer[k * 4 + 1] / 255.0f * alpha + (1.0f - alpha)) * 255.0f), 0, 255);
        rgb[k * 3 + 2] = CLAMP((int)roundf((buffer[k * 4 + 2] / 255.0f * alpha + (1.0f - alpha)) * 255.0f), 0, 255);
      }
 
      // Build the actual pixbuf object
      GdkPixbuf *tmp = gdk_pixbuf_new_from_data(rgb, 0, FALSE, 8, th_width, th_height,
                                                th_width * 3 * sizeof(uint8_t), NULL, NULL);
      if(tmp)
      {
        pixbuf = gdk_pixbuf_scale_simple(tmp, roundf((float)width / ratio), height, GDK_INTERP_HYPER);
        g_object_unref(tmp);
      }
    }
 
    dt_pixelpipe_cache_free_align(buffer);
    dt_pixelpipe_cache_free_align(rgb);
    dt_free(mime_type);
  }
 
  if(IS_NULL_PTR(pixbuf))
  {
    const gboolean use_internal_loader = !(file_type & DT_IMAGE_RAW);
 
    if(use_internal_loader)
    {
      dt_mipmap_buffer_t mipbuf = { 0 };
 
      /* If embedded preview extraction failed, non-RAW files should still get a preview by
       * decoding the real image through Ansel instead of relying on the desktop pixbuf stack.
       * RAWs stay excluded here because the import dialog only wants a lightweight fallback. */
      if(dt_imageio_open_standalone(img, filename, &mipbuf) == DT_IMAGEIO_OK
         && !IS_NULL_PTR(mipbuf.buf) && mipbuf.width > 0 && mipbuf.height > 0)
      {
        const size_t pixels = (size_t)mipbuf.width * mipbuf.height;
        uint8_t *rgb = dt_pixelpipe_cache_alloc_align_cache(pixels * 3 * sizeof(uint8_t), 0);
        if(!IS_NULL_PTR(rgb))
        {
          const float *const in = (const float *const)mipbuf.buf;
          __OMP_PARALLEL_FOR__()
          for(size_t k = 0; k < pixels; k++)
          {
            const float alpha = in[k * 4 + 3] > 0.0f ? CLAMPF(in[k * 4 + 3], 0.0f, 1.0f) : 1.0f;
            rgb[k * 3] = CLAMP((int)roundf((CLAMPF(in[k * 4], 0.0f, 1.0f) * alpha + (1.0f - alpha)) * 255.0f), 0, 255);
            rgb[k * 3 + 1] = CLAMP((int)roundf((CLAMPF(in[k * 4 + 1], 0.0f, 1.0f) * alpha + (1.0f - alpha)) * 255.0f), 0, 255);
            rgb[k * 3 + 2] = CLAMP((int)roundf((CLAMPF(in[k * 4 + 2], 0.0f, 1.0f) * alpha + (1.0f - alpha)) * 255.0f), 0, 255);
          }
 
          GdkPixbuf *tmp = gdk_pixbuf_new_from_data(rgb, 0, FALSE, 8, mipbuf.width, mipbuf.height,
                                                    mipbuf.width * 3 * sizeof(uint8_t), NULL, NULL);
          if(!IS_NULL_PTR(tmp))
          {
            const float ratio = (float)mipbuf.height / (float)mipbuf.width;
            pixbuf = gdk_pixbuf_scale_simple(tmp, roundf((float)width / ratio), height, GDK_INTERP_HYPER);
            g_object_unref(tmp);
          }
 
          dt_pixelpipe_cache_free_align(rgb);
        }
      }
 
      dt_imageio_close_standalone(&mipbuf);
    }
  }
 
  // Fallback to whatever Gtk found in the file
  if(IS_NULL_PTR(pixbuf))
    pixbuf = gdk_pixbuf_new_from_file_at_size(filename, width, height, NULL);
 
  if(IS_NULL_PTR(pixbuf)) return NULL;
 
  // Rotate the image to the correct orientation
  GdkPixbuf *tmp = pixbuf;
  if(img->orientation == ORIENTATION_ROTATE_CCW_90_DEG)
    tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE);
  else if(img->orientation == ORIENTATION_ROTATE_CW_90_DEG)
    tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_CLOCKWISE);
  else if(img->orientation == ORIENTATION_ROTATE_180_DEG)
    tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_UPSIDEDOWN);
 
  if(pixbuf != tmp) g_object_unref(pixbuf);
 
  return tmp;
}
 
void _dt_check_basedir()
{
  gchar basedir[DT_PATH_MAX] = { 0 };
  g_strlcpy(basedir, dt_conf_get_string_const("session/base_directory_pattern"), sizeof(basedir));
 
  if(*basedir == 0 && dt_get_user_pictures_dir(dt_loc_get_home_dir(NULL), basedir, sizeof(basedir)))
  {
    // Basedir is empty
    dt_conf_set_string("session/base_directory_pattern", basedir);
  }
  else if(strstr(basedir, "$(") != NULL)
  {
    // Basedir contains a pattern to expand - remnant of Darktable's defaults
    dt_variables_params_t *params;
    dt_variables_params_init(&params);
 
    gchar *file_expand = dt_variables_expand(params, basedir, FALSE);
    dt_conf_set_string("session/base_directory_pattern", file_expand);
 
    dt_free(file_expand);
    dt_variables_params_destroy(params);
  }
}
 
static void _do_select_all_clicked(GtkWidget *widget, dt_lib_import_t *d)
{
  _do_select_all(d);
}
 
static void _do_select_none_clicked(GtkWidget *widget, dt_lib_import_t *d)
{
  _do_select_none(d);
}
 
static void _do_select_new_clicked(GtkWidget *widget, dt_lib_import_t *d)
{
  _do_select_new(d);
}
 
 
static void _resize_dialog(GtkWidget *widget)
{
  GtkAllocation allocation;
  gtk_widget_get_allocation(widget, &allocation);
  dt_conf_set_int("ui_last/import_dialog_width", allocation.width);
  dt_conf_set_int("ui_last/import_dialog_height", allocation.height);
}
 
static void _build_filter(GtkFileFilter *filter, const gchar *extension)
{
  gchar *text = g_strdup_printf("*.%s", extension);
  gchar *TEXT = g_utf8_strup(text, -1); // uppercase variant
  gtk_file_filter_add_pattern(filter, text);
  gtk_file_filter_add_pattern(filter, TEXT);
  dt_free(text);
  dt_free(TEXT);
}
 
/* Add file extension patterns for file chooser filters
* Bloody GTK doesn't support regex patterns so we need to unroll
* every combination separately, for lowercase and uppercase.
*/
static void _file_filters(dt_lib_import_t *d)
{
  GtkWidget *file_chooser = d->file_chooser;
  GtkFileFilter *filter;
 
  // Enumerate every extension Ansel knows about (common/image_extensions.c) instead of
  // hand-maintaining a copy here -- keeps this GUI filter and the recursive-scan check in
  // dt_import_passes_filter() from ever drifting apart again.
  const char *const *lists[] = { dt_image_ext_raw_list(), dt_image_ext_ldr_list(), dt_image_ext_hdr_list() };
  const int n_lists = sizeof(lists) / sizeof(lists[0]);
 
  /* ALL IMAGES */
  filter = gtk_file_filter_new();
  gtk_file_filter_set_name(filter, _("All image files"));
  for(int l = 0; l < n_lists; l++)
    for(const char *const *i = lists[l]; *i; i++)
      _build_filter(filter, *i);
 
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser), filter);
 
  // Set ALL IMAGES as default
  gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(file_chooser), filter);
  d->filter_all = filter;
 
  /* RAW ONLY */
  filter = gtk_file_filter_new();
  gtk_file_filter_set_name(filter, _("Raw image files"));
  for(int l = 0; l < n_lists; l++)
    for(const char *const *i = lists[l]; *i; i++)
      if(dt_image_ext_is_gui_raw(*i)) _build_filter(filter, *i);
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser), filter);
  d->filter_raw = filter;
 
  /* RASTER ONLY */
  filter = gtk_file_filter_new();
  gtk_file_filter_set_name(filter, _("Raster image files"));
  for(int l = 0; l < n_lists; l++)
    for(const char *const *i = lists[l]; *i; i++)
      if(dt_image_ext_is_gui_raster(*i)) _build_filter(filter, *i);
 
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(file_chooser), filter);
  d->filter_raster = filter;
}
 
static GtkWidget * _attach_aligned_grid_item(GtkWidget *grid, const int row, const int column,
                                      const char *label, const GtkAlign align, const gboolean fixed_width,
                                      const gboolean full_width)
{
  GtkWidget *w = gtk_label_new(label);
  if(fixed_width)
    gtk_label_set_max_width_chars(GTK_LABEL(w), 25);
 
  gtk_label_set_ellipsize(GTK_LABEL(w), PANGO_ELLIPSIZE_END);
  gtk_grid_attach(GTK_GRID(grid), w, column, row, full_width ? 2 : 1, 1);
  gtk_label_set_xalign(GTK_LABEL(w), align);
  gtk_widget_set_halign(w, align);
  gtk_label_set_line_wrap(GTK_LABEL(w), TRUE);
  return w;
}
 
static GtkWidget * _attach_grid_separator(GtkWidget *grid, const int row, const int length)
{
  GtkWidget *w = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
  gtk_grid_attach(GTK_GRID(grid), w, 0, row, length, 1);
  dt_gui_add_class(w, "grid-separator");
  return w;
}
 
static int _is_in_library_by_path(const gchar *folder, const char *filename)
{
  int32_t filmroll_id = dt_film_get_id(folder);
  int32_t image_id = dt_image_get_id(filmroll_id, filename);
  return image_id;
}
 
static int _is_in_library_by_metadata(GFile *file)
{
  GError *error = NULL;
  GFileInfo *info = g_file_query_info(file,
                            G_FILE_ATTRIBUTE_STANDARD_NAME ","
                            G_FILE_ATTRIBUTE_TIME_MODIFIED,
                            G_FILE_QUERY_INFO_NONE, NULL, &error);
  if(IS_NULL_PTR(info))
  {
    if(error) g_error_free(error);
    return 0;
  }
 
  const guint64 datetime = g_file_info_get_attribute_uint64(info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
  char dtid[DT_DATETIME_EXIF_LENGTH];
  dt_datetime_unix_to_exif(dtid, sizeof(dtid), (const time_t *)&datetime);
  const int res = dt_metadata_already_imported(g_file_info_get_name(info), dtid);
  g_object_unref(info);
  return res;
}
 
static void _exif_text_set_and_free(dt_lib_import_t *d, exif_fields_t field, gchar *label)
{
  _gtk_label_set_and_free(d->exif_info[field], label);
}
 
static void update_preview_cb(GtkFileChooser *file_chooser, gpointer userdata)
{
  dt_lib_import_t *d = (dt_lib_import_t *)userdata;
  if(d->closing) return;
  gchar *uri = gtk_file_chooser_get_preview_uri(file_chooser);
  if(IS_NULL_PTR(uri))
  {
    gtk_file_chooser_set_preview_widget_active(file_chooser, FALSE);
    return; // nothing to do, nothing to free.
  }
 
  GVfs *vfs = g_vfs_get_default();
  GFile *in = g_vfs_get_file_for_uri(vfs, (const char *)uri);
  char *filename = g_file_get_path(in);
 
  gboolean have_file = (!IS_NULL_PTR(filename)) && g_file_test(filename, G_FILE_TEST_IS_REGULAR);
  gtk_file_chooser_set_preview_widget_active(file_chooser, have_file);
 
  dt_image_t *img = NULL;
  int valid_exif = 0;
  if(have_file)
  {
    const char *const extension = g_strrstr(filename, ".");
    const dt_image_flags_t file_type = extension ? dt_image_flags_from_extension(extension + 1) : 0u;
 
    dt_free(d->path_file);
    d->path_file = g_strdup(filename);
 
    img = dt_alloc_align(sizeof(dt_image_t)); // dt_image_t is 64-aligned, see #1212
    dt_image_init(img);
    if(!(file_type & DT_IMAGE_HDR))
      valid_exif = dt_exif_read(img, filename);
    else
      valid_exif = 1;
    _set_test_path(d, img);
  }
  else
  {
    g_object_unref(in);
    dt_free(filename);
    dt_free(uri);
    return;
  }
 
  /* Get the thumbnail */
  // 160x120 px seems a reasonably generic size for small thumbs from RAW files
  if(!dt_conf_get_bool("import/disable_thumbnail"))
  {
    GdkPixbuf *pixbuf = _import_get_thumbnail(filename, (int) DT_PIXEL_APPLY_DPI(180), (int) DT_PIXEL_APPLY_DPI(180), valid_exif, img);
    gtk_image_set_from_pixbuf(GTK_IMAGE(d->preview), pixbuf);
    if(pixbuf) g_object_unref(pixbuf);
  }
 
  gtk_widget_show_all(d->preview);
 
 
  // Reset everything
  gtk_label_set_text(GTK_LABEL(d->exif_info[EXIF_DATETIME_FIELD]), "");
  gtk_label_set_text(GTK_LABEL(d->exif_info[EXIF_MODEL_FIELD]), "");
  gtk_label_set_text(GTK_LABEL(d->exif_info[EXIF_MAKER_FIELD]), "");
  gtk_label_set_text(GTK_LABEL(d->exif_info[EXIF_LENS_FIELD]), "");
  gtk_label_set_text(GTK_LABEL(d->exif_info[EXIF_FOCAL_LENS_FIELD]), "");
  gtk_label_set_text(GTK_LABEL(d->exif_info[EXIF_EXPOSURE_FIELD]), "");
  gtk_label_set_text(GTK_LABEL(d->exif_info[EXIF_INLIB_FIELD]), _("No"));
  gtk_label_set_text(GTK_LABEL(d->exif_info[EXIF_PATH_FIELD]), "");
 
  /* Do we already have this picture in library ? */
  gchar *folder = dt_util_path_get_dirname(filename);
  gchar *basename = g_file_get_basename(in);
  const int is_path_in_lib = _is_in_library_by_path(folder, basename);
  const int is_metadata_in_lib = _is_in_library_by_metadata(in);
  g_object_unref(in);
  const gboolean is_in_lib = (is_path_in_lib > -1) || (is_metadata_in_lib > -1);
  dt_free(folder);
  dt_free(basename);
 
  /* If alread imported, find out where */
  int32_t imgid = UNKNOWN_IMAGE;
  if(is_path_in_lib > -1)
    imgid = is_path_in_lib;
  else if(is_metadata_in_lib > -1)
    imgid = is_metadata_in_lib;
 
  char path[512] = { 0 };
  if(imgid > UNKNOWN_IMAGE)
  {
    dt_image_t *lib_img = dt_image_cache_get(imgid, 'r');
    if(lib_img)
    {
      dt_image_film_roll_directory(lib_img, path, sizeof(path));
      dt_image_cache_read_release(lib_img);
    }
  }
 
  /* Get EXIF info */
  if(!valid_exif)
  {
    char datetime[200];
    const gboolean valid = dt_datetime_img_to_local(datetime, sizeof(datetime), img, FALSE);
    gchar *exposure = dt_util_format_exposure(img->exif_exposure);
    gchar *exposure_field = g_strdup_printf("%.0f ISO - f/%.1f - %s", img->exif_iso, img->exif_aperture, exposure);
    dt_free(exposure);
    _exif_text_set_and_free(d, EXIF_DATETIME_FIELD, g_strdup_printf(" %s", valid ? datetime : "-"));
    _exif_text_set_and_free(d, EXIF_MODEL_FIELD, g_strdup_printf(" %s", (img->exif_model[0] != '\0') ? img->exif_model : "-"));
    _exif_text_set_and_free(d, EXIF_MAKER_FIELD, g_strdup_printf(" %s", (img->exif_maker[0] != '\0') ? img->exif_maker : "-"));
    _exif_text_set_and_free(d, EXIF_LENS_FIELD,  g_strdup_printf(" %s", (img->exif_lens[0]  != '\0') ? img->exif_lens  : "-"));
    _exif_text_set_and_free(d, EXIF_FOCAL_LENS_FIELD, g_strdup_printf(" %0.f mm", img->exif_focal_length));
    _exif_text_set_and_free(d, EXIF_EXPOSURE_FIELD, exposure_field);
    _exif_text_set_and_free(d, EXIF_INLIB_FIELD, (is_in_lib) ? g_strdup_printf(_(" Yes (ID %i), in"), imgid) : g_strdup_printf(_(" No")));
 
    if(is_in_lib && path[0] != '\0') _exif_text_set_and_free(d, EXIF_PATH_FIELD, g_strdup_printf(_("%s"), path));
  }
 
  dt_free(filename);
  dt_free(uri);
  dt_free_align(img);
}
 
static void _update_directory(GtkWidget *file_chooser, dt_lib_import_t *d)
{
  gchar *path = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(file_chooser));
  dt_conf_set_string("ui_last/import_last_directory", path);
  dt_free(path);
}
 
static void _set_help_string(dt_lib_import_t *d, gboolean copy)
{
  if(copy)
    gtk_label_set_markup(
        GTK_LABEL(d->help_string),
        _("<i>The files will be copied to the selected destination. You can rename them in batch below:</i>"));
  else
    gtk_label_set_markup(
        GTK_LABEL(d->help_string),
        _("<i>The files will stay at their original location</i>"));
}
 
static void _set_test_path(dt_lib_import_t *d, dt_image_t *img)
{
  if(IS_NULL_PTR(d->path_file))
    return;
 
  const gboolean duplicate = dt_conf_get_bool("ui_last/import_copy");
  if(!duplicate)
  {
    gtk_label_set_text(GTK_LABEL(d->test_path), _("No copy."));
    return;
  }
 
  char datetime_override[DT_DATETIME_LENGTH] = { 0 };
  const char *date = gtk_entry_get_text(GTK_ENTRY(d->datetime));
 
  // Both guards below run BEFORE the file list is built: the list is only ever released
  // through dt_control_import_data_free() at the end, so anything returning between the two
  // would have to free it by hand.
  if(date[0] && !dt_datetime_entry_to_exif(datetime_override, sizeof(datetime_override), date))
  {
    dt_control_log(_("invalid date/time format for import"));
    gtk_label_set_text(GTK_LABEL(d->test_path), _("Please check the date."));
    return;
  }
 
  if(!dt_supported_image(d->path_file))
  {
    gtk_label_set_text(GTK_LABEL(d->test_path), _("Choose a file to see the result..."));
    return;
  }
 
  GList *file = g_list_prepend(NULL, g_strdup(d->path_file));
  gchar *basedir = dt_conf_get_string("session/base_directory_pattern");
  dt_control_import_t data = {.imgs = file,
                              .datetime = dt_string_to_datetime(date),
                              .copy = 1,
                              .jobcode = dt_conf_get_string("ui_last/import_jobcode"),
                              .base_folder = basedir,
                              .target_subfolder_pattern = dt_conf_get_string("session/sub_directory_pattern"),
                              .target_file_pattern = dt_conf_get_string("session/filename_pattern"),
                              .target_dir = NULL,
                              .elements = 1,
                              .discarded = NULL,
                              };
 
  gboolean free_after = FALSE;
  if(IS_NULL_PTR(img))
  {
    img = dt_alloc_align(sizeof(dt_image_t)); // dt_image_t is 64-aligned, see #1212
    dt_image_init(img);
 
    // Generate file I/O only if the pattern is using EXIF variables.
    // Otherwise, discard it since it's really expensive if the file is on external/remote storage.
    // This is mandatory BEFORE expanding variables in pattern
    if(strstr(data.target_file_pattern, "$(EXIF") != NULL
      || strstr(data.target_subfolder_pattern, "$(EXIF") != NULL )
      dt_exif_read(img, (const char*)file->data);
 
    free_after = TRUE;
  }
 
  gchar *_path = dt_build_filename_from_pattern((const char *const)file->data, 1, img, &data);
  gchar * cut = g_strdup(g_strrstr(basedir, G_DIR_SEPARATOR_S));
  gchar *fake_path = g_strdup(g_strrstr(_path, cut));
 
  if(free_after)
  {
    dt_free_align(img);
  }
 
  if(fake_path && fake_path[0] != 0)
    _gtk_label_set_and_free(d->test_path, g_strdup_printf(_("...%s"), fake_path));
  else
    gtk_label_set_text(GTK_LABEL(d->test_path), _("Can't build a valid path."));
 
  dt_free(cut);
  dt_free(_path);
  dt_free(fake_path);
  dt_control_import_data_free(&data);
}
 
// Words the selected-files label according to the active GUI filter (raw/raster get called out
// explicitly; "All" is left exactly as before, per the user's request not to touch that case).
// When scan_errors > 0, appends a warning so a permission-denied (or otherwise failed) subfolder
// is visible right in the label instead of only in a transient dt_control_log() toast.
static void _set_selected_files_label(dt_lib_import_t *d, const guint elements, const guint scan_errors)
{
  gchar *text;
 
  if(elements == 0)
  {
    switch(d->last_filter_type)
    {
      case DT_IMPORT_FILTER_RAW:
        text = g_strdup(_("No raw file selected"));
        break;
      case DT_IMPORT_FILTER_RASTER:
        text = g_strdup(_("No raster file selected"));
        break;
      default:
        text = g_strdup(_("No file selected"));
        break;
    }
  }
  else
  {
    switch(d->last_filter_type)
    {
      case DT_IMPORT_FILTER_RAW:
        text = g_strdup_printf(_("%i raw files selected"), elements);
        break;
      case DT_IMPORT_FILTER_RASTER:
        text = g_strdup_printf(_("%i raster files selected"), elements);
        break;
      default:
        text = g_strdup_printf(_("%i files selected"), elements);
        break;
    }
  }
 
  if(scan_errors > 0)
  {
    gchar *warning = g_strdup_printf(ngettext(" -- %u folder could not be scanned (permission denied?)",
                                              " -- %u folders could not be scanned (permission denied?)",
                                              scan_errors), scan_errors);
    gchar *combined = g_strconcat(text, warning, NULL);
    dt_free(text);
    dt_free(warning);
    text = combined;
  }
 
  _gtk_label_set_and_free(d->selected_files, text);
}
 
static void _filelist_changed_callback(gpointer instance, GList *files, guint elements, guint finished, guint scan_errors, gpointer user_data)
{
  dt_lib_import_t *d = (dt_lib_import_t *)user_data;
  if(IS_NULL_PTR(d) || d->closing || IS_NULL_PTR(d->selected_files)) return;
 
  if(finished)
  {
    // Lock the thread to ensure we have the correct final number
    dt_pthread_mutex_lock(&d->lock);
    _set_selected_files_label(d, elements, scan_errors);
    dt_pthread_mutex_unlock(&d->lock);
  }
  else
  {
    // We don't care for correctness, we just want to show user that we are still at it
    const char *fmt;
    switch(d->last_filter_type)
    {
      case DT_IMPORT_FILTER_RAW:
        fmt = _("Detection in progress... (%i raw files found so far)");
        break;
      case DT_IMPORT_FILTER_RASTER:
        fmt = _("Detection in progress... (%i raster files found so far)");
        break;
      default:
        fmt = _("Detection in progress... (%i files found so far)");
        break;
    }
    _gtk_label_set_and_free(d->selected_files, g_strdup_printf(fmt, elements));
  }
}
 
static void _selection_changed(GtkWidget *filechooser, dt_lib_import_t *d)
{
  if(d->closing) return;
  gtk_label_set_text(GTK_LABEL(d->selected_files), _("Detecting candidate files for import..."));
 
  // Coalesce bursts of Gtk "selection-changed" signals while navigating file lists.
  // A short delay avoids queueing redundant recursive scans for transient selections.
  if(d->selection_scan_timeout_id > 0) g_source_remove(d->selection_scan_timeout_id);
  d->selection_scan_timeout_id = g_timeout_add(120, _selection_changed_scan_trigger, d);
}
 
static gboolean _selection_changed_scan_trigger(gpointer user_data)
{
  dt_lib_import_t *d = (dt_lib_import_t *)user_data;
  d->selection_scan_timeout_id = 0;
  if(d->closing) return G_SOURCE_REMOVE;
  dt_control_get_selected_files(d, FALSE);
  return G_SOURCE_REMOVE;
}
 
static void _copy_toggled_callback(GtkWidget *combobox, dt_lib_import_t *d)
{
  gboolean state = gtk_combo_box_get_active(GTK_COMBO_BOX(combobox));
  dt_conf_set_bool("ui_last/import_copy", state);
  gtk_widget_set_visible(GTK_WIDGET(d->grid), state);
  gtk_widget_set_visible(GTK_WIDGET(d->test_path), state);
  _set_help_string(d, state);
  _set_test_path(d, NULL);
}
 
static void _jobcode_changed(GtkFileChooserButton* widget, dt_lib_import_t *d)
{
  dt_conf_set_string("ui_last/import_jobcode", gtk_entry_get_text(GTK_ENTRY(widget)));
  _set_test_path(d, NULL);
}
 
static void _base_dir_changed(GtkFileChooserButton* self, dt_lib_import_t *d)
{
  dt_conf_set_string("session/base_directory_pattern", gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(self)));
  _set_test_path(d, NULL);
}
 
static void _project_dir_changed(GtkWidget *widget, dt_lib_import_t *d)
{
  dt_conf_set_string("session/sub_directory_pattern", gtk_entry_get_text(GTK_ENTRY(widget)));
  _set_test_path(d, NULL);
}
 
static void _filename_changed(GtkWidget *widget, dt_lib_import_t *d)
{
  dt_conf_set_string("session/filename_pattern", gtk_entry_get_text(GTK_ENTRY(widget)));
  _set_test_path(d, NULL);
}
 
static void _update_date(GtkCalendar *calendar, GtkWidget *entry)
{
  guint year, month, day;
  gtk_calendar_get_date(calendar, &year, &month, &day);
  GTimeZone *tz = g_time_zone_new_local();
 
  // Again, GDateTime counts months from 1 but GtkCalendar from 0. Stupid.
  GDateTime *datetime = g_date_time_new(tz, year, month + 1, day, 0, 0, 0.);
  g_time_zone_unref(tz);
  gchar *date = g_date_time_format(datetime, "%F");
  gtk_entry_set_text(GTK_ENTRY(entry), date);
  dt_free(date);
  g_date_time_unref(datetime);
}
 
/* Validate user input, aka check if date format respects ISO 8601*/
static void _datetime_changed_callback(GtkEntry *entry, dt_lib_import_t *d)
{
  const char *date = gtk_entry_get_text(entry);
  if(date[0])
  {
    char filtered[DT_DATETIME_LENGTH] = { 0 };
    gboolean valid = dt_datetime_entry_to_exif(filtered, sizeof(filtered), date);
    if(!valid)
    {
      gtk_entry_set_icon_from_icon_name(entry, GTK_ENTRY_ICON_SECONDARY, "dialog-error");
      gtk_entry_set_icon_tooltip_text(entry, GTK_ENTRY_ICON_SECONDARY,
                                      _("Date should follow the ISO 8601 format, like :\n"
                                        "YYYY-MM-DD\n"
                                        "YYYY-MM-DD HH:mm\n"
                                        "YYYY-MM-DD HH:mm:ss\n"
                                        "YYYY-MM-DDTHH:mm:ss"));
      return;
    }
    else
    {
      gtk_entry_set_icon_from_icon_name(entry, GTK_ENTRY_ICON_SECONDARY, "");
      gtk_entry_set_icon_tooltip_text(entry, GTK_ENTRY_ICON_SECONDARY, "");
    }
  }
  gtk_entry_set_icon_from_icon_name(entry, GTK_ENTRY_ICON_PRIMARY, NULL);
  _set_test_path(d, NULL);
}
 
static void _file_activated(GtkFileChooser *chooser, GtkDialog *dialog)
{
  // If we double-click on image and we are not asking to duplicate files, let the filechooser
  // behave as a replacement of lighttable and directly open the image in darkroom.
  if(g_file_test(gtk_file_chooser_get_filename(chooser), G_FILE_TEST_IS_REGULAR)
     && !dt_conf_get_bool("ui_last/import_copy"))
  {
    gtk_dialog_response(dialog, GTK_RESPONSE_ACCEPT);
  }
}
 
 
static void _process_file_list(gpointer instance, GList *files, int elements, gboolean finished, guint scan_errors, gpointer user_data)
{
  if(!finished) return; // Should be fired only when we are done detecting stuff
 
  dt_lib_import_t *d = (dt_lib_import_t *)user_data;
  if(IS_NULL_PTR(d) || d->closing) return;
 
  if(elements > 0)
  {
    // Deep-copy the source list so import job owns an independent set of file path strings.
    dt_control_import_t data = {.imgs = g_list_copy_deep(files, (GCopyFunc)g_strdup, NULL),
                                .datetime = dt_string_to_datetime(gtk_entry_get_text(GTK_ENTRY(d->datetime))),
                                .copy = dt_conf_get_bool("ui_last/import_copy"),
                                .jobcode = dt_conf_get_string("ui_last/import_jobcode"),
                                .base_folder = dt_conf_get_string("session/base_directory_pattern"),
                                .target_subfolder_pattern = dt_conf_get_string("session/sub_directory_pattern"),
                                .target_file_pattern = dt_conf_get_string("session/filename_pattern"),
                                .target_dir = NULL,
                                .elements = elements,
                                .discarded = NULL
                                };
 
    // Prepare to catch the end of import signal
    if(dt_control_import(data))
      dt_control_log(_("Could not start the import job."));
  }
  else
    dt_control_log(_("No files to import. Check your selection."));
 
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_process_file_list), (gpointer)d);
  gui_cleanup(d);
  _cleanup(d);
 
  // Re-allocate focus to center widget
  dt_gui_refocus_center();
}
 
void _file_chooser_response(GtkDialog *dialog, gint response_id, dt_lib_import_t *d)
{
  // Stop capturing the filelist changes for the in-popup label file counter.
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_filelist_changed_callback), (gpointer)d);
 
  switch(response_id)
  {
    case GTK_RESPONSE_ACCEPT:
    {
      if(d->selection_scan_timeout_id > 0)
      {
        g_source_remove(d->selection_scan_timeout_id);
        d->selection_scan_timeout_id = 0;
      }
 
      // The next file list change will now only fire the importer job
      DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_FILELIST_CHANGED, G_CALLBACK(_process_file_list), (gpointer)d);
 
      // It would be swell if we could just re-use the file list computed on "select" callback.
      // However, it depends on the file filter used, and we can't refresh the list when
      // filter is changed (no callback to connect to).
      // To be safe, we need to start again here, from scratch.
      dt_control_get_selected_files(d, TRUE);
 
      // TODO: print "pending" message on modal window
      break;
    }
    case GTK_RESPONSE_CANCEL:
    default:
      gui_cleanup(d);
      _cleanup(d);
      break;
  }
}
 
 
static void gui_init(dt_lib_import_t *d)
{
  _dt_check_basedir();
 
  d->dialog = gtk_dialog_new_with_buttons
    ( _("Ansel - Open pictures"), NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
      _("Cancel"), GTK_RESPONSE_CANCEL,
      _("Import"), GTK_RESPONSE_ACCEPT,
      NULL);
  dt_gui_add_class(d->dialog, "dt_import_dialog");
 
#ifdef GDK_WINDOWING_QUARTZ
// TODO: On MacOS (at least on version 13) the dialog windows doesn't behave as expected. The dialog
// needs to have a parent window. "set_parent_window" wasn't working, so set_transient_for is
// the way to go. Still the window manager isn't dealing with the dialog properly, when the dialog
// is shifted outside its parent. The dialog isn't visible any longer but still listed as a window
// of the app.
  dt_osx_disallow_fullscreen(d->dialog);
  gtk_window_set_position(GTK_WINDOW(d->dialog), GTK_WIN_POS_CENTER_ON_PARENT);
#endif
 
  gtk_window_set_default_size(GTK_WINDOW(d->dialog),
                              dt_conf_get_int("ui_last/import_dialog_width"),
                              dt_conf_get_int("ui_last/import_dialog_height"));
  gtk_window_set_modal(GTK_WINDOW(d->dialog), FALSE);
  gtk_window_set_transient_for(GTK_WINDOW(d->dialog), GTK_WINDOW(dt_gui_main_window()));
  g_signal_connect(d->dialog, "response", G_CALLBACK(_file_chooser_response), d);
 
  GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(d->dialog));
  g_signal_connect(d->dialog, "check-resize", G_CALLBACK(_resize_dialog), NULL);
 
  /* Grid of options for copy/duplicate */
  d->grid = gtk_grid_new();
  GtkGrid *grid = GTK_GRID(d->grid);
  gtk_grid_set_column_spacing(grid, DT_GUI_BOX_SPACING / 2.);
  gtk_grid_set_row_spacing(grid, DT_GUI_BOX_SPACING / 2.);
  gtk_grid_set_column_homogeneous(grid, FALSE);
  gtk_grid_set_row_homogeneous(grid, FALSE);
 
  /* BOTTOM PANEL */
  GtkWidget *rbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(content), rbox, TRUE, TRUE, 0);
 
  // File browser
  d->file_chooser = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_OPEN);
  gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(d->file_chooser), TRUE);
  gtk_file_chooser_set_use_preview_label(GTK_FILE_CHOOSER(d->file_chooser), FALSE);
  gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(d->file_chooser),
                                      dt_conf_get_string_const("ui_last/import_last_directory"));
  gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(d->file_chooser), FALSE);
  gtk_box_pack_start(GTK_BOX(rbox), d->file_chooser, TRUE, TRUE, 0);
  g_signal_connect(G_OBJECT(d->file_chooser), "current-folder-changed", G_CALLBACK(_update_directory), NULL);
  g_signal_connect(G_OBJECT(d->file_chooser), "file-activated", G_CALLBACK(_file_activated), GTK_DIALOG(d->dialog));
  g_signal_connect(G_OBJECT(d->file_chooser), "selection-changed", G_CALLBACK(_selection_changed), d);
  g_signal_connect(G_OBJECT(d->file_chooser), "update-preview", G_CALLBACK(update_preview_cb), d);
 
  // file extension filters
  _file_filters(d);
 
  // File browser toolbox (extra widgets)
  GtkWidget *toolbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_widget_set_halign(toolbox, GTK_ALIGN_END);
 
  GtkWidget *select_all = gtk_button_new_with_label(_("Select all"));
  gtk_box_pack_start(GTK_BOX(toolbox), select_all, FALSE, FALSE, 0);
  g_signal_connect(select_all, "clicked", G_CALLBACK(_do_select_all_clicked), d);
 
  GtkWidget *select_none = gtk_button_new_with_label(_("Select none"));
  gtk_box_pack_start(GTK_BOX(toolbox), select_none, FALSE, FALSE, 0);
  g_signal_connect(select_none, "clicked", G_CALLBACK(_do_select_none_clicked), d);
 
  GtkWidget *select_new = gtk_button_new_with_label(_("Select new"));
  gtk_box_pack_start(GTK_BOX(toolbox), select_new, FALSE, FALSE, 0);
  g_signal_connect(select_new, "clicked", G_CALLBACK(_do_select_new_clicked), d);
  gtk_widget_set_tooltip_text(select_new,
                              _("Selecting new files targets pictures that have never been added to the library. "
                                "The lookup is done by searching for the original filename and date/time. "
                                "It can detect files existing at another path, under a different name. "
                                "False-positive can arise if two pictures have been taken at the same time with the same name."));
 
  d->selected_files = gtk_label_new("");
  gtk_box_pack_start(GTK_BOX(toolbox), d->selected_files, FALSE, FALSE, 0);
 
  gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(d->file_chooser), toolbox);
 
  /* RIGHT PANEL */
  // File browser preview box
  // 1. Thumbnail
  GtkWidget *preview_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
  d->preview = gtk_image_new();
  gtk_widget_set_size_request(d->preview, DT_PIXEL_APPLY_DPI(240), DT_PIXEL_APPLY_DPI(240));
  gtk_box_pack_start(GTK_BOX(preview_box), d->preview, TRUE, FALSE, 0);
 
  // 2. Exif metadata
  d->exif = gtk_grid_new();
  gtk_grid_set_column_spacing(GTK_GRID(d->exif), DT_GUI_BOX_SPACING);
  _attach_aligned_grid_item(d->exif, 0, 0, _("Shot:"), GTK_ALIGN_END, FALSE, FALSE);
  _attach_grid_separator(   d->exif, 1, 2);
  _attach_aligned_grid_item(d->exif, 2, 0, _("Camera:"), GTK_ALIGN_END, FALSE, FALSE);
  _attach_aligned_grid_item(d->exif, 3, 0, _("Brand:"), GTK_ALIGN_END, FALSE, FALSE);
  _attach_aligned_grid_item(d->exif, 4, 0, _("Lens:"), GTK_ALIGN_END, FALSE, FALSE);
  _attach_aligned_grid_item(d->exif, 5, 0, _("Focal:"), GTK_ALIGN_END, FALSE, FALSE);
  _attach_grid_separator(   d->exif, 6, 2);
  // exposure trifecta
  _attach_grid_separator(   d->exif, 8, 2);
 
  GtkWidget *imported_label = gtk_label_new(_("Imported:"));
  GtkBox *help_box_inlib = attach_help_popover(
      imported_label,
      _("Images already in the library will not be imported again, selected or not. "
        "Remove them from the library first, or use the menu "
        "`Run \342\206\222 Resynchronize library and XMP` to update the local database from distant XMP.\n\n"
        "Ansel indexes images by their filename and parent folder (full path), "
        "not by their content. Therefore, renaming or moving images on the filesystem, "
        "or changing the mounting point of their external drive will make them "
        "look like new (unknown) images.\n\n"
        "If an XMP file is present alongside images, it will be imported as well, "
        "including the metadata and settings stored in it. If it is not what you want, "
        "you can reset metadata in the lighttable."));
  gtk_widget_set_halign(imported_label, GTK_ALIGN_END);
  gtk_grid_attach(GTK_GRID(d->exif), GTK_WIDGET(help_box_inlib), 0, EXIF_INLIB_FIELD, 1, 1);
  //_attach_aligned_grid_item(d->exif, 9, 0, _("Imported :"), GTK_ALIGN_END, FALSE, FALSE);
 
  d->exif_info[EXIF_DATETIME_FIELD] = _attach_aligned_grid_item(d->exif, 0, 1, "", GTK_ALIGN_START, TRUE, FALSE);
  d->exif_info[EXIF_MODEL_FIELD] = _attach_aligned_grid_item(d->exif, 2, 1, "", GTK_ALIGN_START, TRUE, FALSE);
  d->exif_info[EXIF_MAKER_FIELD] = _attach_aligned_grid_item(d->exif, 3, 1, "", GTK_ALIGN_START, TRUE, FALSE);
  d->exif_info[EXIF_LENS_FIELD] = _attach_aligned_grid_item(d->exif, 4, 1, "", GTK_ALIGN_START, TRUE, FALSE);
  d->exif_info[EXIF_FOCAL_LENS_FIELD] = _attach_aligned_grid_item(d->exif, 5, 1, "", GTK_ALIGN_START, TRUE, FALSE);
  d->exif_info[EXIF_EXPOSURE_FIELD] = _attach_aligned_grid_item(d->exif, 7, 0, "", GTK_ALIGN_CENTER, TRUE, TRUE);
  d->exif_info[EXIF_INLIB_FIELD] = _attach_aligned_grid_item(d->exif, 9, 1, "", GTK_ALIGN_START, FALSE, TRUE);
  d->exif_info[EXIF_PATH_FIELD] = _attach_aligned_grid_item(d->exif, 10, 0, "", GTK_ALIGN_START, FALSE, TRUE);
  gtk_label_set_ellipsize(GTK_LABEL(d->exif_info[EXIF_PATH_FIELD]), PANGO_ELLIPSIZE_MIDDLE);
 
  gtk_box_pack_start(GTK_BOX(preview_box), d->exif, TRUE, TRUE, 0);
  gtk_widget_show_all(d->exif);
 
  gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(d->file_chooser), preview_box);
  /* BOTTOM PANEL */
 
  GtkWidget *files = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  GtkWidget *file_handling = gtk_label_new("");
  gtk_label_set_markup(GTK_LABEL(file_handling), _("<b>File handling</b>"));
  gtk_box_pack_start(GTK_BOX(files), GTK_WIDGET(file_handling), FALSE, FALSE, 0);
 
  GtkWidget *copy = gtk_combo_box_text_new();
  gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(copy), NULL, _("Add to library"));
  gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(copy), NULL, _("Copy to disk"));
  gtk_combo_box_set_active(GTK_COMBO_BOX(copy), dt_conf_get_bool("ui_last/import_copy"));
  gtk_box_pack_start(GTK_BOX(files), GTK_WIDGET(copy), FALSE, FALSE, 0);
  g_signal_connect(G_OBJECT(copy), "changed", G_CALLBACK(_copy_toggled_callback), (gpointer)d);
 
  d->help_string = gtk_label_new("");
  _set_help_string(d, dt_conf_get_bool("ui_last/import_copy"));
  gtk_box_pack_start(GTK_BOX(files), GTK_WIDGET(d->help_string), FALSE, FALSE, 0);
 
  gtk_box_pack_start(GTK_BOX(rbox), GTK_WIDGET(files), FALSE, FALSE, 0);
 
  // Project date
  GtkWidget *calendar_label = gtk_label_new(_("Project date"));
  gtk_widget_set_halign(calendar_label, GTK_ALIGN_START);
  d->datetime = gtk_entry_new();
  dt_accels_disconnect_on_text_input(d->datetime);
  gtk_entry_set_width_chars(GTK_ENTRY(d->datetime), 20);
  g_signal_connect(G_OBJECT(d->datetime), "changed", G_CALLBACK(_datetime_changed_callback), d);
 
  // Date is inited as today by default
  GDateTime *now = g_date_time_new_now_local();
  gchar *now_string = g_date_time_format(now, "%F");
  gtk_entry_set_text(GTK_ENTRY(d->datetime), now_string);
  dt_free(now_string);
 
  // Date chooser
  GtkWidget *calendar = gtk_calendar_new();
  // GtkCalendar uses monthes in [0:11]. Glib GDateTime returns monthes in [1:12]. Stupid.
  gtk_calendar_select_month(GTK_CALENDAR(calendar), g_date_time_get_month(now) - 1, g_date_time_get_year(now));
  const guint day = g_date_time_get_day_of_month(now);
  gtk_calendar_select_day(GTK_CALENDAR(calendar), day);
  gtk_calendar_mark_day(GTK_CALENDAR(calendar), day);
  GtkBox *box_calendar = attach_popover(d->datetime, "appointment-new-symbolic", calendar);
  g_signal_connect(G_OBJECT(calendar), "day-selected", G_CALLBACK(_update_date), d->datetime);
 
  // free date
  g_date_time_unref(now);
 
  // Base directory of projects
  GtkWidget *jobcode = gtk_entry_new();
  dt_accels_disconnect_on_text_input(jobcode);
  gtk_entry_set_text(GTK_ENTRY(jobcode), dt_conf_get_string_const("ui_last/import_jobcode"));
  gtk_widget_set_hexpand(jobcode, TRUE);
  g_signal_connect(G_OBJECT(jobcode), "changed", G_CALLBACK(_jobcode_changed), d);
 
  GtkWidget *jobcode_label = gtk_label_new(_("Jobcode"));
  gtk_widget_set_halign(jobcode_label, GTK_ALIGN_START);
 
  GtkWidget *base_label = gtk_label_new(_("Base directory of all projects"));
  gtk_widget_set_halign(base_label, GTK_ALIGN_START);
 
  GtkWidget *dir_label = gtk_label_new(_("Project directory naming pattern"));
  gtk_widget_set_halign(dir_label, GTK_ALIGN_START);
 
  GtkWidget *file_label = gtk_label_new(_("File naming pattern"));
  gtk_widget_set_halign(file_label, GTK_ALIGN_START);
 
  GtkWidget *base_dir
      = gtk_file_chooser_button_new(_("Select a base directory"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
  gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(base_dir),
                                      dt_conf_get_string_const("session/base_directory_pattern"));
  g_signal_connect(G_OBJECT(base_dir), "file-set", G_CALLBACK(_base_dir_changed), d);
  gtk_widget_set_hexpand(base_dir, TRUE);
 
  GtkWidget *sep1 = gtk_label_new(G_DIR_SEPARATOR_S);
  GtkWidget *sep2 = gtk_label_new(G_DIR_SEPARATOR_S);
 
  GtkWidget *project_dir = gtk_entry_new();
  dt_accels_disconnect_on_text_input(project_dir);
  gtk_entry_set_text(GTK_ENTRY(project_dir), dt_conf_get_string_const("session/sub_directory_pattern"));
  gtk_widget_set_hexpand(project_dir, TRUE);
  dt_gtkentry_setup_completion(GTK_ENTRY(project_dir), dt_gtkentry_get_default_path_compl_list(), "$(");
  gtk_widget_set_tooltip_text(project_dir, _("Start typing `$(` to see available variables through auto-completion"));
  g_signal_connect(G_OBJECT(project_dir), "changed", G_CALLBACK(_project_dir_changed), d);
 
  GtkWidget *file = gtk_entry_new();
  dt_accels_disconnect_on_text_input(file);
  gtk_entry_set_text(GTK_ENTRY(file), dt_conf_get_string_const("session/filename_pattern"));
  gtk_widget_set_hexpand(file, TRUE);
  dt_gtkentry_setup_completion(GTK_ENTRY(file), dt_gtkentry_get_default_path_compl_list(), "$(");
  g_signal_connect(G_OBJECT(file), "changed", G_CALLBACK(_filename_changed), d);
 
  GtkWidget *pattern_label = gtk_label_new(_("Pattern result"));
  gtk_widget_set_halign(pattern_label, GTK_ALIGN_START);
 
  d->test_path = gtk_label_new(_("Choose a file to see the result..."));
  gtk_widget_set_halign(d->test_path, GTK_ALIGN_START);
  gtk_label_set_line_wrap(GTK_LABEL(d->test_path), TRUE);
  gtk_label_set_max_width_chars(GTK_LABEL(d->test_path), 60);
  _set_test_path(d, NULL);
 
  /* Create the grid of import params when using duplication */
  int row = 0;
  _attach_grid_separator(GTK_WIDGET(grid), row, 5);
  row++;
 
  // Row 0: labels for text entries
  gtk_grid_attach(grid, calendar_label, 0, row, 1, 1);
  gtk_grid_attach(grid, jobcode_label, 2, row, 1, 1);
  gtk_grid_attach(grid, pattern_label, 4, row, 1, 1);
  row++;
 
  // Row 1: text entries
  gtk_grid_attach(grid, GTK_WIDGET(box_calendar), 0, row, 1, 1);
  gtk_grid_attach(grid, jobcode, 2, row, 1, 1);
  gtk_grid_attach(grid, d->test_path, 4, row, 1, 1);
  row++;
 
  // Row 2: separator
  _attach_grid_separator(GTK_WIDGET(grid), row, 5);
  row++;
 
  // Row 3: labels for text entries
  gtk_grid_attach(grid, base_label, 0, row, 1, 1);
  gtk_grid_attach(grid, dir_label, 2, row, 1, 1);
  gtk_grid_attach(grid, file_label, 4, row, 1, 1);
  row++;
 
  // Row 4: text entries
  gtk_grid_attach(grid, base_dir, 0, row, 1, 1);
  gtk_grid_attach(grid, sep1, 1, row, 1, 1);
  gtk_grid_attach(grid, project_dir, 2, row, 1, 1);
  gtk_grid_attach(grid, sep2, 3, row, 1, 1);
  gtk_grid_attach(grid, file, 4, row, 1, 1);
  row++;
 
  gtk_box_pack_start(GTK_BOX(rbox), GTK_WIDGET(grid), FALSE, FALSE, 0);
 
  gtk_widget_show_all(d->dialog);
 
  // Duplication parameters visible only if the option is set
  gtk_widget_set_visible(GTK_WIDGET(grid), dt_conf_get_bool("ui_last/import_copy"));
 
  // Update the number of selected files string because Gtk forces a default selection at opening time
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_FILELIST_CHANGED,
                                  G_CALLBACK(_filelist_changed_callback), d);
}
 
static void _do_select_none(dt_lib_import_t *d)
{
  gtk_file_chooser_unselect_all(GTK_FILE_CHOOSER(d->file_chooser));
}
 
static void _do_select_all(dt_lib_import_t *d)
{
  gtk_file_chooser_select_all(GTK_FILE_CHOOSER(d->file_chooser));
}
 
static void _do_select_new(dt_lib_import_t *d)
{
  // Twisted Gtk doesn't let us select multiple files.
  // We need to select all then unselect what we don't want.
  _do_select_all(d);
 
  GtkFileChooser *chooser = GTK_FILE_CHOOSER(d->file_chooser);
  gchar *folder = gtk_file_chooser_get_current_folder(chooser);
  if(IS_NULL_PTR(folder)) return;
 
  GFile *folder_file = g_file_new_for_path(folder);
  GFileEnumerator *files = NULL;
  if(IS_NULL_PTR(folder_file))
    goto end;
 
  files = g_file_enumerate_children(
      folder_file, G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE,
      G_FILE_QUERY_INFO_NONE, NULL, NULL);
  g_object_unref(folder_file);
  if(IS_NULL_PTR(files))
    goto end;
 
  // Get the file filter in use
  GtkFileFilter *filter = gtk_file_chooser_get_filter(chooser);
  if(IS_NULL_PTR(filter))
  {
    goto end;
  }
  const GtkFileFilterFlags filter_needed = gtk_file_filter_get_needed(filter);
 
  GFile *file = NULL;
  while(g_file_enumerator_iterate(files, NULL, &file, NULL, NULL))
  {
    // g_file_enumerator_iterate returns FALSE only on errors, not on end of enumeration.
    // We need an ugly break here else infinite loop.
    if(IS_NULL_PTR(file)) break;
 
    gchar *parse_name = g_file_get_parse_name(file);
    gchar *uri = g_file_get_uri(file);
    gchar *basename = g_file_get_basename(file);
    gchar *filepath = g_file_get_path(file);
    GtkFileFilterInfo filter_info = { filter_needed,
                                      parse_name,
                                      uri,
                                      parse_name, NULL };
 
    const gboolean is_regular = !IS_NULL_PTR(filepath) && g_file_test(filepath, G_FILE_TEST_IS_REGULAR);
    const int is_path_in_lib = !IS_NULL_PTR(basename) ? _is_in_library_by_path(folder, basename) : -1;
    const int is_metadata_in_lib = _is_in_library_by_metadata(file);
    const gboolean is_in_lib = (is_path_in_lib > -1) || (is_metadata_in_lib > -1);
 
    // We need to act only on files passing the file filter, aka being currently displayed on screen.
    // Unselecting files not displayed in the current list freezes the UI and introduces oddities.
    if(gtk_file_filter_filter(filter, &filter_info)
       && !(is_regular && !is_in_lib))
    {
      gtk_file_chooser_unselect_file(chooser, file);
    }
 
    dt_free(parse_name);
    dt_free(uri);
    dt_free(basename);
    dt_free(filepath);
    // g_file_enumerator_iterate() returns transfer-none children owned by the enumerator.
    // Unref happens when the enumerator advances or is destroyed.
    file = NULL;
  }
 
  end:
  if(!IS_NULL_PTR(files)) g_object_unref(files);
  dt_free(folder);
}
 
static void gui_cleanup(dt_lib_import_t *d)
{
  d->closing = TRUE;
 
  if(d->selection_scan_timeout_id > 0)
  {
    g_source_remove(d->selection_scan_timeout_id);
    d->selection_scan_timeout_id = 0;
  }
 
  // Disconnect callbacks that may enqueue async work while widgets are being destroyed.
  if(!IS_NULL_PTR(d->file_chooser))
  {
    g_signal_handlers_disconnect_by_func(G_OBJECT(d->file_chooser), G_CALLBACK(_selection_changed), d);
    g_signal_handlers_disconnect_by_func(G_OBJECT(d->file_chooser), G_CALLBACK(update_preview_cb), d);
    g_signal_handlers_disconnect_by_func(G_OBJECT(d->file_chooser), G_CALLBACK(_file_activated), GTK_DIALOG(d->dialog));
    g_signal_handlers_disconnect_by_func(G_OBJECT(d->file_chooser), G_CALLBACK(_update_directory), NULL);
  }
 
  // Ensure the background recursive folder detection is finished before destroying widgets.
  // Reason is, if a job is still running, it might send its signal upon completion,
  // and then the widgets supposed to be updated in callback will be undefined (but not NULL... WTF Gtk ?)
  dt_pthread_mutex_lock(&d->lock);
  gtk_widget_destroy(d->dialog);
  d->dialog = NULL;
  d->file_chooser = NULL;
  d->preview = NULL;
  d->exif = NULL;
  d->grid = NULL;
  d->jobcode = NULL;
  d->help_string = NULL;
  d->test_path = NULL;
  d->selected_files = NULL;
  d->filter_all = NULL;
  d->filter_raw = NULL;
  d->filter_raster = NULL;
  for(int k = 0; k < EXIF_LAST_FIELD; k++) d->exif_info[k] = NULL;
  dt_pthread_mutex_unlock(&d->lock);
}
 
static dt_lib_import_t * _init()
{
  dt_lib_import_t *d = malloc(sizeof(dt_lib_import_t));
  d->closing = FALSE;
  d->selection_scan_timeout_id = 0;
  dt_pthread_mutex_init(&d->lock, NULL);
  d->path_file = NULL;
  d->scan_state = calloc(1, sizeof(dt_import_scan_state_t));
  dt_pthread_mutex_init(&d->scan_state->lock, NULL);
  d->scan_state->generation = 0;
  d->scan_state->refcount = 1;
  d->scan_state->closing = FALSE;
 
  return d;
}
 
static void _cleanup(dt_lib_import_t *d)
{
  // Teardown can be entered from multiple control paths. Ensure no pending global signal
  // callback can still target this module state after memory is released.
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_filelist_changed_callback), (gpointer)d);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_process_file_list), (gpointer)d);
 
  if(!IS_NULL_PTR(d->scan_state))
  {
    gboolean release = FALSE;
    dt_pthread_mutex_lock(&d->scan_state->lock);
    d->scan_state->closing = TRUE;
    d->scan_state->generation++;
    if(d->scan_state->refcount > 0) d->scan_state->refcount--;
    release = (d->scan_state->refcount == 0);
    dt_pthread_mutex_unlock(&d->scan_state->lock);
    if(release)
    {
      dt_pthread_mutex_destroy(&d->scan_state->lock);
      dt_free(d->scan_state);
    }
    d->scan_state = NULL;
  }
 
  dt_pthread_mutex_destroy(&d->lock);
  dt_free(d->path_file);
  dt_free(d);
}
 
void dt_images_import()
{
  dt_lib_import_t *d = _init();
  gui_init(d);
}
 
static dt_import_t * dt_import_init(dt_lib_import_t *d, const uint32_t generation)
{
  dt_import_t *import = g_malloc(sizeof(dt_import_t));
  import->generation = generation;
  import->files = NULL;
  import->elements = 0;
  import->scan_errors = 0;
  dt_pthread_mutex_init(&import->lock, NULL);
  import->scan_state = d->scan_state;
  dt_pthread_mutex_lock(&import->scan_state->lock);
  import->scan_state->refcount++;
  dt_pthread_mutex_unlock(&import->scan_state->lock);
 
  dt_pthread_mutex_lock(&import->lock);
 
  // selection is owned here and will need to be freed.
  import->selection = gtk_file_chooser_get_uris(GTK_FILE_CHOOSER(d->file_chooser));
 
  // Snapshot the active file-type filter here, on the GUI thread, into a plain enum: the
  // recursive scan job runs off-thread and must never touch the live GtkFileFilter objects.
  GtkFileFilter *active_filter = gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(d->file_chooser));
  if(!IS_NULL_PTR(active_filter) && active_filter == d->filter_raw)
    import->filter_type = DT_IMPORT_FILTER_RAW;
  else if(!IS_NULL_PTR(active_filter) && active_filter == d->filter_raster)
    import->filter_type = DT_IMPORT_FILTER_RASTER;
  else
    import->filter_type = DT_IMPORT_FILTER_ALL;
 
  // Mirror it onto d too: _filelist_changed_callback() only gets files/elements/finished from
  // the signal, not the dt_import_t this scan belongs to.
  d->last_filter_type = import->filter_type;
 
  dt_pthread_mutex_unlock(&import->lock);
 
  return import;
}
 
static void dt_import_cleanup(void *data)
{
  // dt_import_t owns the recursive selection list for the whole detection job lifetime.
  // Signal receivers may inspect it, but must not release it.
  dt_import_t *import = (dt_import_t *)data;
  g_list_free_full(import->files, dt_free_gpointer);
  import->files = NULL;
  g_slist_free_full(import->selection, dt_free_gpointer);
  import->selection = NULL;
  if(!IS_NULL_PTR(import->scan_state))
  {
    gboolean release = FALSE;
    dt_pthread_mutex_lock(&import->scan_state->lock);
    if(import->scan_state->refcount > 0) import->scan_state->refcount--;
    release = (import->scan_state->refcount == 0);
    dt_pthread_mutex_unlock(&import->scan_state->lock);
    if(release)
    {
      dt_pthread_mutex_destroy(&import->scan_state->lock);
      dt_free(import->scan_state);
    }
    import->scan_state = NULL;
  }
  dt_pthread_mutex_destroy(&import->lock);
  dt_free(import);
}
 
/* Shows what an import left behind. Lived in control/jobs/import_jobs.c -- the only GUI
 * code in that job file; the job invokes it through the registered handler and this
 * function owns freeing the enumerator params and import data, as the contract says. */
static int _import_discarded_files_popup(dt_control_image_enumerator_t *params)
{
  dt_control_import_t *data = params->data;
 
  // Create the window
  GtkWidget *dialog = gtk_dialog_new_with_buttons("Message",
    GTK_WINDOW(dt_gui_main_window()),
    GTK_DIALOG_DESTROY_WITH_PARENT,
    _("_OK"),
    GTK_RESPONSE_NONE,
    NULL);
  gtk_window_set_title(GTK_WINDOW(dialog), _("Some files have not been copied"));
  gtk_window_set_default_size(GTK_WINDOW(dialog), DT_PIXEL_APPLY_DPI(800), DT_PIXEL_APPLY_DPI(800));
 
  // Create the label
  GtkWidget *label = gtk_label_new(_("The following source files have not been copied "
    "because similarly-named files already exist on the destination. "
    "This may be because the files have already been imported "
    "or the naming pattern leads to non-unique file names."));
  gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
 
  // Create the scrolled window internal container
  GtkWidget *scrolled_window = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC,
  GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_propagate_natural_height(GTK_SCROLLED_WINDOW(scrolled_window), TRUE);
 
  // Create the treeview model from the list of discarded file pathes
  GtkListStore *store = gtk_list_store_new(1, G_TYPE_STRING);
  GtkTreeIter iter;
  for(GList *file = g_list_first(data->discarded); file; file = g_list_next(file))
  {
    if(file->data)
    {
      gtk_list_store_append(store, &iter);
      gtk_list_store_set(store, &iter, 0, (char *)file->data, -1);
    }
  }
 
  // Create the treeview view. Sooooo verbose... it's only a flat list.
  GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
  GtkTreeViewColumn *col = gtk_tree_view_column_new();
  gtk_tree_view_column_set_title(col, _("Origin path"));
  GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
  gtk_tree_view_column_pack_start(col, renderer, TRUE);
  gtk_tree_view_column_set_attributes(col, renderer, "text", 0, NULL);
  gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
  g_object_unref(store);
 
  // Pack widgets to an unified box
  GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(box), scrolled_window, TRUE, TRUE, 0);
  dt_gui_add_class(scrolled_window, "dt_recessed_scroll");
  gtk_container_add(GTK_CONTAINER(scrolled_window), view);
 
  // Pack the box to the dialog internal container
  GtkWidget *content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
  gtk_container_add(GTK_CONTAINER(content_area), box);
  gtk_widget_show_all(dialog);
 
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(dialog);
#endif
 
  gtk_dialog_run(GTK_DIALOG(dialog));
  gtk_widget_destroy(dialog);
 
  dt_control_import_data_free(data);
  dt_free(data);
  dt_control_image_enumerator_cleanup(params);
 
  return 0;
}
 
/* Runs on the import worker thread: hop to the GUI main loop, where the dialog lives.
 * The popup owns freeing params, per the handler contract. */
static void _import_discarded_files_schedule(dt_control_image_enumerator_t *params)
{
  g_main_context_invoke(NULL, (GSourceFunc)_import_discarded_files_popup, params);
}
 
void dt_gui_import_init_handlers(void)
{
  dt_control_import_set_discarded_files_handler(_import_discarded_files_schedule);
}
 
// 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