export.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2009-2013 johannes hanika.
    Copyright (C) 2010 Alexandre Prokoudine.
    Copyright (C) 2010-2011, 2013 Henrik Andersson.
    Copyright (C) 2010 Milan Knížek.
    Copyright (C) 2010, 2013-2014 Pascal de Bruijn.
    Copyright (C) 2010 Stuart Henderson.
    Copyright (C) 2011, 2013 Antony Dovgal.
    Copyright (C) 2011-2013, 2015 Jérémy Rosen.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2011-2017, 2019-2020 Tobias Ellinghaus.
    Copyright (C) 2012 Christian Tellefsen.
    Copyright (C) 2012 Moritz Lipp.
    Copyright (C) 2012-2015, 2019-2021 Pascal Obry.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2012-2013 Simon Spannagel.
    Copyright (C) 2013 José Carlos García Sogo.
    Copyright (C) 2013-2016 Roman Lebedev.
    Copyright (C) 2013 Thomas Pryds.
    Copyright (C) 2017 luzpaz.
    Copyright (C) 2018 Maurizio Paglia.
    Copyright (C) 2018 rawfiner.
    Copyright (C) 2019-2020, 2022-2023, 2025-2026 Aurélien PIERRE.
    Copyright (C) 2019 Edgardo Hoszowski.
    Copyright (C) 2019 jakubfi.
    Copyright (C) 2019 parafin.
    Copyright (C) 2019-2021 Philippe Weyland.
    Copyright (C) 2020 a.
    Copyright (C) 2020-2022 Aldric Renaudin.
    Copyright (C) 2020-2021 Chris Elston.
    Copyright (C) 2020-2022 Diederik Ter Rahe.
    Copyright (C) 2020 Heiko Bauke.
    Copyright (C) 2020-2021 Hubert Kowalski.
    Copyright (C) 2020 junkyardsparkle.
    Copyright (C) 2020 Marco.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2021 lhietal.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2022 Miloš Komarčević.
    Copyright (C) 2022 Nicolas Auffray.
    Copyright (C) 2022 Victor Forsiuk.
    Copyright (C) 2023 Luca Zulberti.
    Copyright (C) 2024 Guillaume Stutin.
    
    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 "widgets/bauhaus.h"
#include "common/paths.h"   // DT_PATH_MAX
#include "database/preset_repository.h"
#include "common/act_on.h"
#include "control/jobs/control_jobs.h"
#include "common/collection.h"
#include "colorprofiles/colorspaces.h"
#include "system/macros.h"
#include "system/mem_alloc.h"
#include "common/module_versioning.h"
#include "common/file_location.h"
#include "imageio/imageio_module.h"
#include "common/styles.h"
#include "common/conf.h"
#include "control/control.h"
#include "control/signal.h"
 
#include "gui/application.h"
#include "widgets/accelerators.h"
#include "libs/lib.h"
#include "libs/lib_api.h"
#ifdef GDK_WINDOWING_QUARTZ
#include "osx/osx.h"
#endif
#include <gdk/gdkkeysyms.h>
#include "widgets/container.h"
#include "widgets/dialog.h"
#include "widgets/label.h"
 
#include <gtk/gtk.h>
#include <limits.h>
#include <stdlib.h>
 
#include <glib.h>
 
DT_MODULE(7)
 
#define EXPORT_MAX_IMAGE_SIZE UINT16_MAX
#define CONFIG_PREFIX "plugins/lighttable/export/"
 
typedef struct dt_lib_export_t
{
  GtkWidget *dimensions_type, *print_dpi, *print_height, *print_width;
  GtkWidget *unit_label;
  GtkWidget *width, *height;
  GtkWidget *px_size, *print_size, *scale, *size_in_px;
  GtkWidget *storage, *format;
  int format_lut[128];
  uint32_t max_allowed_width , max_allowed_height;
  GtkWidget *profile, *intent, *style;
  GtkButton *export_button;
  GtkWidget *storage_extra_container, *format_extra_container;
  GtkWidget *export_masks;
  char *metadata_export;
} dt_lib_export_t;
 
 
typedef enum dt_dimensions_type_t
{
  DT_DIMENSIONS_PIXELS = 0, // set dimensions exactly in pixels
  DT_DIMENSIONS_CM     = 1, // set dimensions from physical size in centimeters * DPI
  DT_DIMENSIONS_INCH   = 2,  // set dimensions from physical size in inch
  DT_DIMENSIONS_SCALE   = 3,  // set dimensions by scale
  DT_DIMENSIONS_ORIGINAL = 4 // user-friendly alias for scale = 1
} dt_dimensions_type_t;
 
char *dt_lib_export_metadata_configuration_dialog(char *list, const gboolean ondisk);
static void _update_formats_combobox(dt_lib_export_t *d);
static void _update_dimensions(dt_lib_export_t *d);
static void _get_max_output_dimension(dt_lib_export_t *d, uint32_t *width, uint32_t *height);
static void _print_size_display(dt_lib_export_t *d);
 
#define INCH_TO_CM (2.54f)
 
/* Each size mode keeps settings of its own, so switching modes loses none of them: the pixel box
 * in "width"/"height", the print size in "print_width"/"print_height" -- always in cm, shown in
 * the unit selected -- at "print_dpi", the factor in "resizing_factor". "original resolution"
 * has none. The export resolves the selected mode into one size when it is dispatched
 * (_resolve_export_size()), and nothing downstream reads these keys. */
#define CONF_PRINT_WIDTH CONFIG_PREFIX "print_width"
#define CONF_PRINT_HEIGHT CONFIG_PREFIX "print_height"
 
static dt_dimensions_type_t _dimensions_type(void)
{
  return (dt_dimensions_type_t)dt_conf_get_int(CONFIG_PREFIX "dimensions_type");
}
 
static int _print_dpi(void)
{
  const int dpi = dt_conf_get_int(CONFIG_PREFIX "print_dpi");
  return dpi > 0 ? dpi : 300;
}
 
// centimeters per unit the print size is shown in
static float _print_unit_in_cm(const dt_dimensions_type_t d_type)
{
  return d_type == DT_DIMENSIONS_INCH ? INCH_TO_CM : 1.f;
}
 
static uint32_t _cm_to_pixels(const float cm, const int dpi)
{
  return cm > 0.f ? (uint32_t)ceilf(cm * (float)dpi / INCH_TO_CM) : 0;
}
 
static void _print_size_from_pixels(const uint32_t width, const uint32_t height)
{
  const int dpi = _print_dpi();
  dt_conf_set_float(CONF_PRINT_WIDTH, (float)width * INCH_TO_CM / (float)dpi);
  dt_conf_set_float(CONF_PRINT_HEIGHT, (float)height * INCH_TO_CM / (float)dpi);
}
 
static void _ensure_print_size_conf(void)
{
  // settings written before the print size had keys of its own start from the pixel box
  if(!dt_conf_key_exists(CONF_PRINT_WIDTH) || !dt_conf_key_exists(CONF_PRINT_HEIGHT))
    _print_size_from_pixels(dt_conf_get_int(CONFIG_PREFIX "width"), dt_conf_get_int(CONFIG_PREFIX "height"));
}
 
/* The size the selected mode asks for: with *scale_factor > 0 the image is reduced by it,
 * otherwise it fits in *max_width x *max_height, 0 x 0 meaning full size. */
static void _resolve_export_size(int *max_width, int *max_height, double *scale_factor)
{
  *max_width = 0;
  *max_height = 0;
  *scale_factor = 0.0;
 
  switch(_dimensions_type())
  {
    case DT_DIMENSIONS_PIXELS:
      *max_width = MAX(dt_conf_get_int(CONFIG_PREFIX "width"), 0);
      *max_height = MAX(dt_conf_get_int(CONFIG_PREFIX "height"), 0);
      break;
    case DT_DIMENSIONS_CM:
    case DT_DIMENSIONS_INCH:
    {
      const int dpi = _print_dpi();
      *max_width = (int)_cm_to_pixels(dt_conf_get_float(CONF_PRINT_WIDTH), dpi);
      *max_height = (int)_cm_to_pixels(dt_conf_get_float(CONF_PRINT_HEIGHT), dpi);
      break;
    }
    case DT_DIMENSIONS_SCALE:
    {
      double num = 1.0;
      double denum = 1.0;
      dt_imageio_resizing_factor_parse(dt_conf_get_string_const(CONFIG_PREFIX "resizing_factor"), &num, &denum);
      *scale_factor = num / denum;
      break;
    }
    case DT_DIMENSIONS_ORIGINAL:
      break;
  }
}
 
const char *name(struct dt_lib_module_t *self)
{
  return _("export");
}
 
const char **views(dt_lib_module_t *self)
{
  // Not displayed in views, only in popup triggered from main menu
  static const char *v[] = {"special", NULL};
  return v;
}
 
uint32_t container(dt_lib_module_t *self)
{
  return DT_UI_CONTAINER_SIZE;
}
 
static void _update(dt_lib_module_t *self)
{
  dt_lib_cancel_postponed_update(self);
  const dt_lib_export_t *d = (dt_lib_export_t *)self->data;
 
  const gboolean has_act_on = (dt_act_on_get_images_nb(TRUE, FALSE) > 0);
 
  const char *format_name = dt_conf_get_string_const(CONFIG_PREFIX "format_name");
  const char *storage_name = dt_conf_get_string_const(CONFIG_PREFIX "storage_name");
  const int format_index = dt_imageio_get_index_of_format(dt_imageio_get_format_by_name(format_name));
  const int storage_index = dt_imageio_get_index_of_storage(dt_imageio_get_storage_by_name(storage_name));
 
  gtk_widget_set_sensitive(GTK_WIDGET(d->export_button), has_act_on && format_index != -1 && storage_index != -1);
}
 
static void _image_selection_changed_callback(gpointer instance, dt_lib_module_t *self)
{
  _update(self);
}
 
static void _collection_updated_callback(gpointer instance, dt_collection_change_t query_change,
                                         dt_collection_properties_t changed_property, gpointer imgs, int next,
                                         dt_lib_module_t *self)
{
  _update(self);
}
 
// a positive whole number that fits the int it is printed as
static gboolean _is_int(const double value)
{
  return value > 0.0 && value <= (double)INT_MAX && value == (int)value;
}
 
// rewrite the resizing factor in its shortest spelling: "2.0/4" becomes "2/4"
static void _scale_optim()
{
  double num = 1.0;
  double denum = 1.0;
  gchar *scale_str = dt_conf_get_string(CONFIG_PREFIX "resizing_factor");
  dt_imageio_resizing_factor_parse(scale_str, &num, &denum);
  const gchar *pdiv = strchr(scale_str, '/');
 
  gchar scale_buf[64] = "";
  gchar num_str[16] = "";
  gchar denum_str[16] = "";
  if(_is_int(num)) snprintf(num_str, sizeof(num_str), "%d", (int)num);
  if(_is_int(denum)) snprintf(denum_str, sizeof(denum_str), "%d", (int)denum);
 
  if(IS_NULL_PTR(pdiv))
  {
    g_strlcat(scale_buf, num_str[0] ? num_str : scale_str, sizeof(scale_buf));
  }
  else if(pdiv == scale_str)
  {
    if(denum_str[0])
      g_strlcat(scale_buf, denum_str, sizeof(scale_buf));
    else
    {
      g_strlcat(scale_buf, "1/", sizeof(scale_buf));
      g_strlcat(scale_buf, pdiv + 1, sizeof(scale_buf));
    }
  }
  else
  {
    if(num_str[0])
      g_strlcat(scale_buf, num_str, sizeof(scale_buf));
    else
    {
      // the numerator alone, not the whole "num/denum" string
      gchar *num_part = g_strndup(scale_str, pdiv - scale_str);
      g_strlcat(scale_buf, num_part, sizeof(scale_buf));
      dt_free(num_part);
    }
    g_strlcat(scale_buf, "/", sizeof(scale_buf));
    g_strlcat(scale_buf, denum_str[0] ? denum_str : pdiv + 1, sizeof(scale_buf));
  }
  dt_conf_set_string(CONFIG_PREFIX "resizing_factor", scale_buf);
 
  dt_free(scale_str);
}
 
static void _export_button_clicked(GtkWidget *widget, dt_lib_export_t *d)
{
  /* write current history changes so nothing gets lost,
     do that only in the darkroom as there is nothing to be saved
     when in the lighttable (and it would write over current history stack) */
  char style[128] = { 0 };
 
  // get the format_name and storage_name settings which are plug-ins name and not necessary what is displayed on the combobox.
  // note that we cannot take directly the combobox entry index as depending on the storage some format are not listed.
  const char *format_name = dt_conf_get_string_const(CONFIG_PREFIX "format_name");
  const char *storage_name = dt_conf_get_string_const(CONFIG_PREFIX "storage_name");
  const int format_index = dt_imageio_get_index_of_format(dt_imageio_get_format_by_name(format_name));
  const int storage_index = dt_imageio_get_index_of_storage(dt_imageio_get_storage_by_name(storage_name));
 
  if(format_index == -1)
  {
    dt_control_log("invalid format for export selected");
    return;
  }
  if(storage_index == -1)
  {
    dt_control_log("invalid storage for export selected");
    return;
  }
 
  char *confirm_message = NULL;
  dt_imageio_module_storage_t *mstorage = dt_imageio_get_storage();
  if(mstorage->ask_user_confirmation)
    confirm_message = mstorage->ask_user_confirmation(mstorage);
  if(confirm_message)
  {
    const GtkWidget *win = dt_gui_main_window();
    GtkWidget *dialog = gtk_message_dialog_new(
        GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
        "%s", confirm_message);
#ifdef GDK_WINDOWING_QUARTZ
    dt_osx_disallow_fullscreen(dialog);
#endif
 
    gtk_window_set_title(GTK_WINDOW(dialog), _("export to disk"));
    const gint res = gtk_dialog_run(GTK_DIALOG(dialog));
    GtkWindow *dialog_parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
    gtk_widget_destroy(dialog);
    dt_gui_refocus_parent(dialog_parent);
    dt_free(confirm_message);
 
    if(res != GTK_RESPONSE_YES)
    {
      return;
    }
  }
 
  // the size the selected mode asks for, resolved now: the job keeps it whatever happens to the settings
  dt_control_export_request_t request = { .format_index = format_index, .storage_index = storage_index };
  _resolve_export_size(&request.max_width, &request.max_height, &request.scale_factor);
 
  request.export_masks = dt_conf_get_bool(CONFIG_PREFIX "export_masks");
  const char *tmp = dt_conf_get_string_const(CONFIG_PREFIX "style");
  if(tmp)
  {
    g_strlcpy(style, tmp, sizeof(style));
  }
  request.style = style;
 
  request.icc_type = sanitize_colorspaces(dt_conf_get_int(CONFIG_PREFIX "icctype"));
  gchar *icc_filename = dt_conf_get_string(CONFIG_PREFIX "iccprofile");
  request.icc_filename = icc_filename;
  request.icc_intent = dt_conf_get_int(CONFIG_PREFIX "iccintent");
  request.metadata_export = d->metadata_export;
 
  GList *list = dt_act_on_get_images();
  dt_control_export(list, &request);
 
  dt_free(icc_filename);
 
  _scale_optim();
  gtk_entry_set_text(GTK_ENTRY(d->scale), dt_conf_get_string_const(CONFIG_PREFIX "resizing_factor"));
}
 
static void _scale_changed(GtkEntry *spin, dt_lib_export_t *d)
{
  const char *validSign = ",.0123456789";
  const gchar *value = gtk_entry_get_text(spin);
 
  char new_value[30] = "";
  // each character read writes at most one: keep room for the terminator
  const int len = MIN((int)strlen(value), (int)sizeof(new_value) - 1);
  int i, j = 0, idec = 0, idiv = 0, pdiv = 0;
 
  for (i = 0; i < len; i++)
  {
    char *val = strchr(validSign, value[i]);
    if(IS_NULL_PTR(val))
    {
      if(idiv==0)
      {
        if(i == 0)
        {
          new_value[j++] = '1';
        }
        else
        {
          if(atof(value) == 0.0)
          {
            new_value[0] = '1';
          }
          idec = 0;
          idiv = 1;
          new_value[j++] = '/';
          pdiv = j;
        }
      }
    }
    else if((val[0] == '.') || (val[0] == ','))
    {
      if(idec == 0)
      {
        if((i == 0) || (i == pdiv))
        {
          new_value[j++] = '0';
        }
        else
        {
          idec = 1;
          new_value[j++] = value[i];
        }
      }
    }
    else if(value[i] == '\0')
    {
      break;
    }
    else
    {
      new_value[j++] = value[i];
    }
  }
  dt_conf_set_string(CONFIG_PREFIX "resizing_factor", new_value);
  gtk_entry_set_text(spin, new_value);
}
 
/* A middle click resets a size entry to the value that means "no limit"; the entry's own "changed"
 * handler stores it. The click is taken, or GTK would paste the primary selection right after the
 * reset. Any other click is the entry's own: it is how it gets the focus and the cursor. */
static gboolean _size_entry_reset_click(GtkEntry *entry, const GdkEventButton *event, gpointer reset_text)
{
  if(event->button != 2) return FALSE;
  gtk_entry_set_text(entry, (const char *)reset_text);
  return TRUE;
}
 
static void _size_in_px_update(dt_lib_export_t *d)
{
  const dt_dimensions_type_t d_type = _dimensions_type();
 
  if((d_type == DT_DIMENSIONS_SCALE) || (d_type == DT_DIMENSIONS_PIXELS) || (d_type == DT_DIMENSIONS_ORIGINAL))
  {
    gtk_widget_hide(d->size_in_px);
  }
  else
  {
    gtk_widget_show(d->size_in_px);
    int max_width = 0;
    int max_height = 0;
    double scale_factor = 0.0;
    _resolve_export_size(&max_width, &max_height, &scale_factor);
    gchar width_txt[16];
    gchar height_txt[16];
    snprintf(width_txt, sizeof(width_txt), "%d", max_width);
    snprintf(height_txt, sizeof(height_txt), "%d", max_height);
    gchar size_in_px_txt[120];
    snprintf(size_in_px_txt, sizeof(size_in_px_txt), _("which is equal to %s \303\227 %s px"), width_txt, height_txt);
    gtk_label_set_text(GTK_LABEL(d->size_in_px), size_in_px_txt);
  }
}
 
void _set_dimensions(dt_lib_export_t *d, uint32_t max_width, uint32_t max_height)
{
  gchar *max_width_char = g_strdup_printf("%d", max_width);
  gchar *max_height_char = g_strdup_printf("%d", max_height);
 
  dt_gui_freeze_begin();
  gtk_entry_set_text(GTK_ENTRY(d->width), max_width_char);
  gtk_entry_set_text(GTK_ENTRY(d->height), max_height_char);
  _size_in_px_update(d);
  dt_gui_freeze_end();
 
  dt_conf_set_int(CONFIG_PREFIX "width", max_width);
  dt_conf_set_int(CONFIG_PREFIX "height", max_height);
 
  dt_free(max_width_char);
  dt_free(max_height_char);
}
 
 
void _size_update_display(dt_lib_export_t *self)
{
  const dt_dimensions_type_t d_type = (dt_dimensions_type_t)dt_bauhaus_combobox_get(self->dimensions_type);
 
  gtk_widget_set_visible(self->px_size, d_type == DT_DIMENSIONS_PIXELS);
  gtk_widget_set_visible(self->print_size, d_type == DT_DIMENSIONS_CM || d_type == DT_DIMENSIONS_INCH);
  gtk_widget_set_visible(self->scale, d_type == DT_DIMENSIONS_SCALE);
 
  gtk_label_set_text(GTK_LABEL(self->unit_label),
                     d_type == DT_DIMENSIONS_CM ? _("cm") : C_("unit", "in"));
  // the print size is stored in cm and shown in the unit just selected
  if(d_type == DT_DIMENSIONS_CM || d_type == DT_DIMENSIONS_INCH) _print_size_display(self);
  _size_in_px_update(self);
}
 
void gui_reset(dt_lib_module_t *self)
{
  // make sure we don't do anything useless:
  if(!dt_control_running()) return;
  dt_lib_export_t *d = (dt_lib_export_t *)self->data;
  gtk_entry_set_text(GTK_ENTRY(d->width), dt_confgen_get(CONFIG_PREFIX "width", DT_DEFAULT));
  gtk_entry_set_text(GTK_ENTRY(d->height), dt_confgen_get(CONFIG_PREFIX "height", DT_DEFAULT));
  _print_size_from_pixels(dt_confgen_get_int(CONFIG_PREFIX "width", DT_DEFAULT),
                          dt_confgen_get_int(CONFIG_PREFIX "height", DT_DEFAULT));
  dt_bauhaus_combobox_set(d->dimensions_type, dt_confgen_get_int(CONFIG_PREFIX "dimensions_type", DT_DEFAULT));
  _size_update_display(d);
 
  // Set storage
  const int storage_index = dt_imageio_get_index_of_storage(dt_imageio_get_storage_by_name(dt_confgen_get(CONFIG_PREFIX "storage_name", DT_DEFAULT)));
  dt_bauhaus_combobox_set(d->storage, storage_index);
 
  dt_bauhaus_combobox_set(d->export_masks, dt_confgen_get_bool(CONFIG_PREFIX "export_masks", DT_DEFAULT) ? 1 : 0);
 
  dt_bauhaus_combobox_set(d->intent, dt_confgen_get_int(CONFIG_PREFIX "iccintent", DT_DEFAULT) + 1);
 
  // iccprofile
  const int icctype = dt_confgen_get_int(CONFIG_PREFIX "icctype", DT_DEFAULT);
  gchar *iccfilename = dt_conf_get_string(CONFIG_PREFIX "iccprofile");
  dt_bauhaus_combobox_set(d->profile, 0);
  if(icctype != DT_COLORSPACE_NONE)
  {
    // +1: the combo carries "same as original" ahead of the profiles.
    const int pos = dt_colorspaces_profile_index(DT_PROFILE_ROLE_OUTPUT, icctype, iccfilename);
    if(pos > -1) dt_bauhaus_combobox_set(d->profile, pos + 1);
  }
 
  dt_free(iccfilename);
 
  // style
  // set it to none if the var is not set or the style doesn't exist anymore
  gboolean rc = FALSE;
  const char *style = dt_confgen_get(CONFIG_PREFIX "style", DT_DEFAULT);
  if(!IS_NULL_PTR(style) && strlen(style) > 0)
  {
    rc = dt_bauhaus_combobox_set_from_text(d->style, style);
    if(rc == FALSE) dt_bauhaus_combobox_set(d->style, 0);
  }
  else
    dt_bauhaus_combobox_set(d->style, 0);
 
  // export metadata presets
  dt_free(d->metadata_export);
  d->metadata_export = dt_lib_export_metadata_get_conf();
 
  dt_imageio_module_format_t *mformat = dt_imageio_get_format();
  if(mformat) mformat->gui_reset(mformat);
  dt_imageio_module_storage_t *mstorage = dt_imageio_get_storage();
  if(mstorage) mstorage->gui_reset(mstorage);
 
  _update(self);
}
 
static void set_format_by_name(dt_lib_export_t *d, const char *name)
{
  // Find the selected format plugin among all existing plugins
  dt_imageio_module_format_t *module = NULL;
  for(GList *it = dt_imageio_get_global()->plugins_format; it; it = g_list_next(it))
  {
    if(g_strcmp0(((dt_imageio_module_format_t *)it->data)->name(), name) == 0
       || g_strcmp0(((dt_imageio_module_format_t *)it->data)->plugin_name, name) == 0)
    {
      module = (dt_imageio_module_format_t *)it->data;
      break;
    }
  }
 
  if(!module)
  {
    gtk_widget_hide(d->format_extra_container);
    return;
  }
  else if(module->widget)
  {
    gtk_widget_show_all(d->format_extra_container);
    gtk_stack_set_visible_child(GTK_STACK(d->format_extra_container), module->widget);
  }
  else
  {
    gtk_widget_hide(d->format_extra_container);
  }
 
  // Store the new format
  dt_conf_set_string(CONFIG_PREFIX "format_name", module->plugin_name);
 
  if(dt_bauhaus_combobox_set_from_text(d->format, module->name()) == FALSE)
    dt_bauhaus_combobox_set(d->format, 0);
 
  // Let's also update combination of storage/format dimension restrictions
  _update_dimensions(d);
 
  // only some modules support export of masks
  // set it to 0 when insensitive and restore when making it sensitive again. this doesn't survive dt restarts.
  const gboolean support_layers = (module->flags(NULL) & FORMAT_FLAGS_SUPPORT_LAYERS) == FORMAT_FLAGS_SUPPORT_LAYERS;
  const gboolean is_enabled = gtk_widget_get_sensitive(d->export_masks);
  if(support_layers && !is_enabled)
  {
    // combobox was disabled and shall be enabled. we want to restore the old setting.
    const gboolean export_masks = dt_conf_get_bool(CONFIG_PREFIX "export_masks");
    gtk_widget_set_sensitive(GTK_WIDGET(d->export_masks), TRUE);
    dt_bauhaus_combobox_set(d->export_masks, export_masks ? 1 : 0);
  }
  else if(!support_layers && is_enabled)
  {
    // combobox was enabled but shall be disabled. we want to save the current setting.
    const int export_masks = dt_bauhaus_combobox_get(d->export_masks);
    dt_bauhaus_combobox_set(d->export_masks, 0);
    dt_conf_set_bool(CONFIG_PREFIX "export_masks", export_masks == 1);
    gtk_widget_set_sensitive(GTK_WIDGET(d->export_masks), FALSE);
  }
}
 
static void _format_changed(GtkWidget *widget, dt_lib_export_t *d)
{
  const gchar *name = dt_bauhaus_combobox_get_text(d->format);
  g_signal_handlers_block_by_func(widget, _format_changed, d);
  set_format_by_name(d, name);
  g_signal_handlers_unblock_by_func(widget, _format_changed, d);
}
 
static void _get_max_output_dimension(dt_lib_export_t *d, uint32_t *width, uint32_t *height)
{
  const char *storage_name = dt_conf_get_string_const(CONFIG_PREFIX "storage_name");
  dt_imageio_module_storage_t *storage = dt_imageio_get_storage_by_name(storage_name);
 
  const char *format_name = dt_conf_get_string_const(CONFIG_PREFIX "format_name");
  dt_imageio_module_format_t *format = dt_imageio_get_format_by_name(format_name);
 
  if(storage && format)
  {
    uint32_t fw, fh, sw, sh;
    fw = fh = sw = sh = 0; // We are all equals!!!
    storage->dimension(storage, NULL, &sw, &sh);
    format->dimension(format, NULL, &fw, &fh);
 
    if(sw == 0 || fw == 0)
      *width = sw > fw ? sw : fw;
    else
      *width = sw < fw ? sw : fw;
 
    if(sh == 0 || fh == 0)
      *height = sh > fh ? sh : fh;
    else
      *height = sh < fh ? sh : fh;
  }
}
 
static void _validate_dimensions(dt_lib_export_t *d)
{
  //reset dimensions to previously stored value if they exceed the maximum
  uint32_t width = atoi(gtk_entry_get_text(GTK_ENTRY(d->width)));
  uint32_t height = atoi(gtk_entry_get_text(GTK_ENTRY(d->height)));
  if(width > d->max_allowed_width || height > d->max_allowed_height)
  {
    width  = width  > d->max_allowed_width  ? dt_conf_get_int(CONFIG_PREFIX "width")  : width;
    height = height > d->max_allowed_height ? dt_conf_get_int(CONFIG_PREFIX "height") : height;
    _set_dimensions(d, width, height);
  }
}
 
static void _update_dimensions(dt_lib_export_t *d)
{
  uint32_t max_w = 0, max_h = 0;
  _get_max_output_dimension(d, &max_w, &max_h);
  d->max_allowed_width = max_w > 0 ? max_w : EXPORT_MAX_IMAGE_SIZE;
  d->max_allowed_height = max_h > 0 ? max_h : EXPORT_MAX_IMAGE_SIZE;
  _validate_dimensions(d);
}
 
static void set_storage_by_name(dt_lib_export_t *d, const char *name)
{
  int k = -1;
  dt_imageio_module_storage_t *module = NULL;
 
  for(const GList *it = dt_imageio_get_global()->plugins_storage; it; it = g_list_next(it))
  {
    dt_imageio_module_storage_t *storage = (dt_imageio_module_storage_t *)it->data;
    k++;
    if(strcmp(storage->name(storage), name) == 0 || strcmp(storage->plugin_name, name) == 0)
    {
      module = storage;
      break;
    }
  }
 
  if(!module)
  {
    gtk_widget_hide(d->storage_extra_container);
    return;
  }
  else if(module->widget)
  {
    gtk_widget_show_all(d->storage_extra_container);
    gtk_stack_set_visible_child(GTK_STACK(d->storage_extra_container),module->widget);
  }
  else
  {
    gtk_widget_hide(d->storage_extra_container);
  }
  dt_bauhaus_combobox_set(d->storage, k);
  dt_conf_set_string(CONFIG_PREFIX "storage_name", module->plugin_name);
 
 
  // Check if plugin recommends a max dimension and set
  // if not implemented the stored conf values are used..
  uint32_t w = 0, h = 0;
  module->recommended_dimension(module, NULL, &w, &h);
 
  const uint32_t cw = dt_conf_get_int(CONFIG_PREFIX "width");
  const uint32_t ch = dt_conf_get_int(CONFIG_PREFIX "height");
 
  // If user's selected value is below the max, select it
  if(w > cw || w == 0) w = cw;
  if(h > ch || h == 0) h = ch;
 
  // Set the recommended dimension
  _set_dimensions(d, w, h);
 
  // Let's update formats combobox with supported formats of selected storage module...
  _update_formats_combobox(d);
 
  // Lets try to set selected format if fail select first in list..
  const char *format_name = dt_conf_get_string_const(CONFIG_PREFIX "format_name");
  const dt_imageio_module_format_t *format = dt_imageio_get_format_by_name(format_name);
 
  if(IS_NULL_PTR(format)
     || dt_bauhaus_combobox_set_from_text(d->format, format->name()) == FALSE)
    dt_bauhaus_combobox_set(d->format, 0);
}
 
static void _storage_changed(GtkWidget *widget, dt_lib_export_t *d)
{
  const gchar *name = dt_bauhaus_combobox_get_text(d->storage);
  g_signal_handlers_block_by_func(widget, _storage_changed, d);
  if(name) set_storage_by_name(d, name);
  g_signal_handlers_unblock_by_func(widget, _storage_changed, d);
}
 
static void _profile_changed(GtkWidget *widget, dt_lib_export_t *d)
{
  int pos = dt_bauhaus_combobox_get(widget);
  if(pos > 0)
  {
    pos--;   // the combo carries "same as original" at 0
    dt_colorprofile_desc_t desc;
    if(dt_colorspaces_profile_at(DT_PROFILE_ROLE_OUTPUT, pos, &desc))
    {
      dt_conf_set_int(CONFIG_PREFIX "icctype", desc.type);
      dt_conf_set_string(CONFIG_PREFIX "iccprofile",
                         (desc.type == DT_COLORSPACE_FILE) ? desc.filename : "");
      return;
    }
  }
  dt_conf_set_int(CONFIG_PREFIX "icctype", DT_COLORSPACE_NONE);
  dt_conf_set_string(CONFIG_PREFIX "iccprofile", "");
}
 
static void _dimensions_type_changed(GtkWidget *widget, dt_lib_export_t *d)
{
  if(dt_gui_widgets_suppressed()) return;
 
  const dt_dimensions_type_t d_type = (dt_dimensions_type_t)dt_bauhaus_combobox_get(widget);
 
  // only the mode changes: each one keeps its own size settings
  dt_conf_set_int(CONFIG_PREFIX "dimensions_type", d_type);
 
  if(d_type == DT_DIMENSIONS_CM || d_type == DT_DIMENSIONS_INCH)
  {
    // set dpi to user-set dpi
    dt_conf_set_int("metadata/resolution", _print_dpi());
  }
  else
  {
    // reset export dpi to default value for scale/pixel specific export
    dt_conf_set_int("metadata/resolution", dt_confgen_get_int("metadata/resolution", DT_DEFAULT));
  }
 
  _size_update_display(d);
}
 
// show the stored print size in the unit selected, and the dpi
static void _print_size_display(dt_lib_export_t *d)
{
  const float unit = _print_unit_in_cm(_dimensions_type());
  gchar *pwidth = g_strdup_printf("%.2f", dt_conf_get_float(CONF_PRINT_WIDTH) / unit);
  gchar *pheight = g_strdup_printf("%.2f", dt_conf_get_float(CONF_PRINT_HEIGHT) / unit);
  gchar *pdpi = g_strdup_printf("%d", _print_dpi());
 
  dt_gui_freeze_begin();
  gtk_entry_set_text(GTK_ENTRY(d->print_width), pwidth);
  gtk_entry_set_text(GTK_ENTRY(d->print_height), pheight);
  gtk_entry_set_text(GTK_ENTRY(d->print_dpi), pdpi);
  dt_gui_freeze_end();
 
  dt_free(pwidth);
  dt_free(pheight);
  dt_free(pdpi);
}
 
static void _width_changed(GtkEditable *entry, gpointer user_data)
{
  if(dt_gui_widgets_suppressed()) return;
 
  const dt_lib_export_t *d = (dt_lib_export_t *)user_data;
  const uint32_t width = atoi(gtk_entry_get_text(GTK_ENTRY(d->width)));
  dt_conf_set_int(CONFIG_PREFIX "width", width);
}
 
// the print size is stored in cm, whatever unit it is typed in
static void _print_size_changed(GtkEntry *entry, const char *key, dt_lib_export_t *d)
{
  const float value = atof(gtk_entry_get_text(entry));
  dt_conf_set_float(key, MAX(value, 0.f) * _print_unit_in_cm(_dimensions_type()));
  _size_in_px_update(d);
}
 
static void _print_width_changed(GtkEditable *entry, gpointer user_data)
{
  if(dt_gui_widgets_suppressed()) return;
  _print_size_changed(GTK_ENTRY(entry), CONF_PRINT_WIDTH, (dt_lib_export_t *)user_data);
}
 
static void _height_changed(GtkEditable *entry, gpointer user_data)
{
  if(dt_gui_widgets_suppressed()) return;
 
  const dt_lib_export_t *d = (dt_lib_export_t *)user_data;
  const uint32_t height = atoi(gtk_entry_get_text(GTK_ENTRY(d->height)));
  dt_conf_set_int(CONFIG_PREFIX "height", height);
}
 
static void _print_height_changed(GtkEditable *entry, gpointer user_data)
{
  if(dt_gui_widgets_suppressed()) return;
  _print_size_changed(GTK_ENTRY(entry), CONF_PRINT_HEIGHT, (dt_lib_export_t *)user_data);
}
 
static void _print_dpi_changed(GtkWidget *widget, gpointer user_data)
{
  if(dt_gui_widgets_suppressed()) return;
 
  dt_lib_export_t *d = (dt_lib_export_t *)user_data;
  const int dpi = atoi(gtk_entry_get_text(GTK_ENTRY(d->print_dpi)));
 
  dt_conf_set_int(CONFIG_PREFIX "print_dpi", dpi);
  dt_conf_set_int("metadata/resolution", dpi);
 
  // the print size stays what it is: its pixel equivalent is what moves
  _size_in_px_update(d);
}
 
static void _callback_bool(GtkWidget *widget, gpointer user_data)
{
  const char *key = (const char *)user_data;
  dt_conf_set_bool(key, dt_bauhaus_combobox_get(widget) == 1);
}
 
static void _intent_changed(GtkWidget *widget, dt_lib_export_t *d)
{
  const int pos = dt_bauhaus_combobox_get(widget);
  dt_conf_set_int(CONFIG_PREFIX "iccintent", pos - 1);
}
 
static void _style_changed(GtkWidget *widget, dt_lib_export_t *d)
{
  if(dt_bauhaus_combobox_get(d->style) == 0)
  {
    dt_conf_set_string(CONFIG_PREFIX "style", "");
  }
  else
  {
    const gchar *style = dt_bauhaus_combobox_get_text(d->style);
    dt_conf_set_string(CONFIG_PREFIX "style", style);
  }
}
 
int position()
{
  return 99;
}
 
static void _update_formats_combobox(dt_lib_export_t *d)
{
  // Clear format combo box
  dt_bauhaus_combobox_clear(d->format);
 
  // Get current selected storage
  const char *storage_name = dt_conf_get_string_const(CONFIG_PREFIX "storage_name");
  dt_imageio_module_storage_t *storage = dt_imageio_get_storage_by_name(storage_name);
 
  // Add supported formats to combobox
  gboolean empty = TRUE;
  for(const GList *it = dt_imageio_get_global()->plugins_format; it; it = g_list_next(it))
  {
    dt_imageio_module_format_t *format = (dt_imageio_module_format_t *)it->data;
    if(storage->supported(storage, format))
    {
      dt_bauhaus_combobox_add(d->format, format->name());
      empty = FALSE;
    }
  }
 
  gtk_widget_set_sensitive(GTK_WIDGET(d->format), !empty);
}
 
static void _on_storage_list_changed(gpointer instance, dt_lib_module_t *self)
{
  dt_lib_export_t *d = self->data;
  dt_imageio_module_storage_t *storage = dt_imageio_get_storage();
  dt_bauhaus_combobox_clear(d->storage);
 
  dt_gui_container_remove_children(GTK_CONTAINER(d->storage_extra_container));
 
  for(const GList *it = dt_imageio_get_global()->plugins_storage; it; it = g_list_next(it))
  {
    const dt_imageio_module_storage_t *module = (dt_imageio_module_storage_t *)it->data;
    dt_bauhaus_combobox_add(d->storage, module->name(module));
    if(module->widget)
    {
      gtk_container_add(GTK_CONTAINER(d->storage_extra_container), module->widget);
    }
  }
  dt_bauhaus_combobox_set(d->storage, dt_imageio_get_index_of_storage(storage));
}
 
static void _lib_export_styles_changed_callback(gpointer instance, gpointer user_data)
{
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  dt_lib_export_t *d = self->data;
 
  dt_bauhaus_combobox_clear(d->style);
  dt_bauhaus_combobox_add(d->style, _("none"));
 
  GList *styles = dt_styles_get_list("");
  for(const GList *st_iter = styles; st_iter; st_iter = g_list_next(st_iter))
  {
    const dt_style_t *style = (dt_style_t *)st_iter->data;
    dt_bauhaus_combobox_add(d->style, style->name);
  }
  dt_bauhaus_combobox_set(d->style, 0);
 
  g_list_free_full(styles, dt_style_free);
  styles = NULL;
}
 
void _menuitem_preferences(GtkMenuItem *menuitem, dt_lib_module_t *self)
{
  dt_lib_export_t *d = (dt_lib_export_t *)self->data;
  const gchar *name = dt_bauhaus_combobox_get_text(d->storage);
  const gboolean ondisk = name && !g_strcmp0(name, _("file on disk")); // FIXME: NO!!!!!one!
  d->metadata_export = dt_lib_export_metadata_configuration_dialog(d->metadata_export, ondisk);
}
 
void set_preferences(void *menu, dt_lib_module_t *self)
{
  GtkWidget *mi = gtk_menu_item_new_with_label(_("preferences..."));
  g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(_menuitem_preferences), self);
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
}
 
void gui_init(dt_lib_module_t *self)
{
  dt_lib_export_t *d = (dt_lib_export_t *)malloc(sizeof(dt_lib_export_t));
  self->timeout_handle = 0;
  self->data = (void *)d;
  self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
 
  GtkWidget *label = dt_ui_section_label_new(_("Storage options"));
  gtk_box_pack_start(GTK_BOX(self->widget), label, FALSE, TRUE, 0);
 
  d->storage = dt_bauhaus_combobox_new(dt_bauhaus_get_global(), DT_GUI_MODULE(NULL));
  dt_bauhaus_widget_set_label(d->storage, N_("Target storage"));
  gtk_box_pack_start(GTK_BOX(self->widget), d->storage, FALSE, TRUE, 0);
 
  // add all storage widgets to the stack widget
  d->storage_extra_container = gtk_stack_new();
  gtk_stack_set_homogeneous(GTK_STACK(d->storage_extra_container),FALSE);
  gtk_box_pack_start(GTK_BOX(self->widget), d->storage_extra_container, FALSE, TRUE, 0);
  for(const GList *it = dt_imageio_get_global()->plugins_storage; it; it = g_list_next(it))
  {
    const dt_imageio_module_storage_t *module = (dt_imageio_module_storage_t *)it->data;
    dt_bauhaus_combobox_add(d->storage, module->name(module));
    if(module->widget)
    {
      gtk_container_add(GTK_CONTAINER(d->storage_extra_container), module->widget);
    }
  }
 
  // postponed so we can do the two steps in one loop
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_IMAGEIO_STORAGE_CHANGE,
                            G_CALLBACK(_on_storage_list_changed), self);
  g_signal_connect(G_OBJECT(d->storage), "value-changed", G_CALLBACK(_storage_changed), (gpointer)d);
 
  label = dt_ui_section_label_new(_("format options"));
  gtk_box_pack_start(GTK_BOX(self->widget), label, FALSE, TRUE, 0);
 
  d->format = dt_bauhaus_combobox_new(dt_bauhaus_get_global(), DT_GUI_MODULE(NULL));
  dt_bauhaus_widget_set_label(d->format, N_("file format"));
  gtk_box_pack_start(GTK_BOX(self->widget), d->format, FALSE, TRUE, 0);
  g_signal_connect(G_OBJECT(d->format), "value-changed", G_CALLBACK(_format_changed), (gpointer)d);
 
  // add all format widgets to the stack widget
  d->format_extra_container = gtk_stack_new();
  gtk_stack_set_homogeneous(GTK_STACK(d->format_extra_container),FALSE);
  gtk_box_pack_start(GTK_BOX(self->widget), d->format_extra_container, FALSE, TRUE, 0);
  for(const GList *it = dt_imageio_get_global()->plugins_format; it; it = g_list_next(it))
  {
    const dt_imageio_module_format_t *module = (dt_imageio_module_format_t *)it->data;
    dt_bauhaus_combobox_add(d->format, module->name());
    if(module->widget)
    {
      gtk_container_add(GTK_CONTAINER(d->format_extra_container), module->widget);
    }
  }
 
  label = dt_ui_section_label_new(_("global options"));
  gtk_box_pack_start(GTK_BOX(self->widget), label, FALSE, TRUE, 0);
 
  DT_BAUHAUS_COMBOBOX_NEW_FULL(dt_bauhaus_get_global(), d->dimensions_type, NULL, N_("set size (bounding box)"),
                               _("Choose a method for setting the output size.\n"
                                 "The width and height specified define the bounding box\n"
                                 "in which the image will be proportionnaly fitted.\n"),
                               dt_conf_get_int(CONFIG_PREFIX "dimensions_type"),
                               (GtkCallback)_dimensions_type_changed, d,
                               N_("in pixels (for file)"),
                               N_("in cm (for print)"),
                               N_("in inch (for print)"),
                               N_("by scale (for file)"),
                               N_("original resolution"));
 
  d->print_width = gtk_entry_new();
  dt_accels_disconnect_on_text_input(d->print_width);
  gtk_widget_set_tooltip_text(d->print_width, _("maximum output width limit.\n"
                                                "click middle mouse button to reset to 0."));
  gtk_entry_set_width_chars(GTK_ENTRY(d->print_width), 5);
  d->print_height = gtk_entry_new();
  dt_accels_disconnect_on_text_input(d->print_height);
  gtk_widget_set_tooltip_text(d->print_height, _("maximum output height limit.\n"
                                                 "click middle mouse button to reset to 0."));
  gtk_entry_set_width_chars(GTK_ENTRY(d->print_height), 5);
  d->print_dpi = gtk_entry_new();
  dt_accels_disconnect_on_text_input(d->print_dpi);
  gtk_widget_set_tooltip_text(d->print_dpi, _("resolution in dot per inch"));
  gtk_entry_set_width_chars(GTK_ENTRY(d->print_dpi), 4);
  const char *dpi = dt_conf_get_string_const(CONFIG_PREFIX "print_dpi");
  gtk_entry_set_text(GTK_ENTRY(d->print_dpi), dpi);
 
 
  d->width = gtk_entry_new();
  dt_accels_disconnect_on_text_input(d->width);
  gtk_widget_set_tooltip_text(d->width, _("maximum output width limit.\n"
                                          "click middle mouse button to reset to 0."));
  gtk_entry_set_width_chars(GTK_ENTRY(d->width), 5);
  d->height = gtk_entry_new();
  dt_accels_disconnect_on_text_input(d->height);
  gtk_widget_set_tooltip_text(d->height, _("maximum output height limit.\n"
                                           "click middle mouse button to reset to 0."));
  gtk_entry_set_width_chars(GTK_ENTRY(d->height), 5);
 
  gtk_widget_add_events(d->width, GDK_BUTTON_PRESS_MASK);
  gtk_widget_add_events(d->height, GDK_BUTTON_PRESS_MASK);
 
 
  d->print_size = gtk_flow_box_new();
  gtk_flow_box_set_max_children_per_line(GTK_FLOW_BOX(d->print_size), 5);
  gtk_flow_box_set_column_spacing (GTK_FLOW_BOX(d->print_size), 3);
  gtk_container_add(GTK_CONTAINER(d->print_size), d->print_width);
  gtk_container_add(GTK_CONTAINER(d->print_size), gtk_label_new(_("x")));
  gtk_container_add(GTK_CONTAINER(d->print_size), d->print_height);
  d->unit_label = gtk_label_new(_("cm"));
  gtk_container_add(GTK_CONTAINER(d->print_size), d->unit_label);
  GtkBox *dpi_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING));
  gtk_box_pack_start(dpi_box, gtk_label_new(_("@")), FALSE, FALSE, 0);
  gtk_box_pack_start(dpi_box, d->print_dpi, TRUE, TRUE, 0);
  gtk_box_pack_start(dpi_box, gtk_label_new(_("dpi")), FALSE, FALSE, 0);
  gtk_container_add(GTK_CONTAINER(d->print_size), GTK_WIDGET(dpi_box));
  dt_gui_flow_box_as_layout(GTK_FLOW_BOX(d->print_size));
 
  d->px_size = gtk_flow_box_new();
  gtk_flow_box_set_max_children_per_line(GTK_FLOW_BOX(d->px_size), 3);
  gtk_flow_box_set_column_spacing (GTK_FLOW_BOX(d->px_size), 3);
  gtk_container_add(GTK_CONTAINER(d->px_size), d->width);
  gtk_container_add(GTK_CONTAINER(d->px_size), gtk_label_new(_("x")));
  GtkBox *px_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING));
  gtk_box_pack_start(px_box, d->height, TRUE, TRUE, 0);
  gtk_box_pack_start(px_box, gtk_label_new(_("px")), FALSE, FALSE, 0);
  gtk_container_add(GTK_CONTAINER(d->px_size), GTK_WIDGET(px_box));
  dt_gui_flow_box_as_layout(GTK_FLOW_BOX(d->px_size));
 
  d->scale = gtk_entry_new();
  dt_accels_disconnect_on_text_input(d->scale);
  gtk_entry_set_width_chars(GTK_ENTRY(d->scale), 5);
  gtk_entry_set_text (GTK_ENTRY(d->scale), dt_conf_get_string_const(CONFIG_PREFIX "resizing_factor"));
  gtk_widget_set_tooltip_text(d->scale, _("it can be an integer, decimal number or simple fraction.\n"
                                          "zero or empty values are equal to 1.\n"
                                          "click middle mouse button to reset to 1."));
  gtk_widget_set_halign(GTK_WIDGET(d->scale), GTK_ALIGN_END);
  gtk_widget_add_events(d->scale, GDK_BUTTON_PRESS_MASK);
 
  d->size_in_px = gtk_label_new("");
  gtk_label_set_ellipsize(GTK_LABEL(d->size_in_px), PANGO_ELLIPSIZE_START);
  gtk_widget_set_sensitive(GTK_WIDGET(d->size_in_px), FALSE);
 
  gtk_widget_set_halign(GTK_WIDGET(d->scale), GTK_ALIGN_FILL);
  gtk_widget_set_halign(GTK_WIDGET(d->size_in_px), GTK_ALIGN_END);
 
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->dimensions_type), FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->px_size), FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->print_size), FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->scale), FALSE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->size_in_px), FALSE, FALSE, 0);
 
  d->export_masks = dt_bauhaus_combobox_new(dt_bauhaus_get_global(), DT_GUI_MODULE(NULL));
  dt_bauhaus_widget_set_label(d->export_masks, N_("store masks"));
  dt_bauhaus_combobox_add(d->export_masks, _("no"));
  dt_bauhaus_combobox_add(d->export_masks, _("yes"));
  gtk_widget_set_tooltip_text(d->export_masks, _("store masks as layers in exported images. only works for some formats."));
  gtk_box_pack_start(GTK_BOX(self->widget), d->export_masks, FALSE, TRUE, 0);
 
  //  Add profile combo
 
  char datadir[DT_PATH_MAX] = { 0 };
  char confdir[DT_PATH_MAX] = { 0 };
  dt_loc_get_user_config_dir(confdir, sizeof(confdir));
  dt_loc_get_datadir(datadir, sizeof(datadir));
 
  d->profile = dt_bauhaus_combobox_new(dt_bauhaus_get_global(), DT_GUI_MODULE(NULL));
  dt_bauhaus_widget_set_label(d->profile, N_("Color space"));
  gtk_box_pack_start(GTK_BOX(self->widget), d->profile, FALSE, TRUE, 0);
  dt_bauhaus_combobox_add(d->profile, _("same as original"));
  dt_colorprofile_desc_t *out_profiles = NULL;
  const size_t n_out_profiles = dt_colorspaces_enumerate_profiles(DT_PROFILE_ROLE_OUTPUT, &out_profiles);
  for(size_t k = 0; k < n_out_profiles; k++)
    dt_bauhaus_combobox_add(d->profile, out_profiles[k].name);
  dt_free_align(out_profiles);
 
  dt_bauhaus_combobox_set(d->profile, 1);
 
  char *system_profile_dir = g_build_filename(datadir, "color", "out", NULL);
  char *user_profile_dir = g_build_filename(confdir, "color", "out", NULL);
  char *tooltip = g_strdup_printf(_(
    "RGB color space used to encode the output files.\n"
    "\"same as original\" exports to the same space as the original\n"
    "picture, which is linear sensor RGB for raw pictures.\n"
    "sRGB is recommended in most cases.\n"
    "You can use custom color spaces defined\n"
    "by ICC profiles stored in:\n- %s\n- %s"), user_profile_dir, system_profile_dir);
  gtk_widget_set_tooltip_text(d->profile, tooltip);
  dt_free(system_profile_dir);
  dt_free(user_profile_dir);
  dt_free(tooltip);
 
  //  Add intent combo
 
  d->intent = dt_bauhaus_combobox_new(dt_bauhaus_get_global(), DT_GUI_MODULE(NULL));
  dt_bauhaus_widget_set_label(d->intent, N_("intent"));
  dt_bauhaus_combobox_add(d->intent, _("same as original"));
  dt_bauhaus_combobox_add(d->intent, _("perceptual"));
  dt_bauhaus_combobox_add(d->intent, _("relative colorimetric"));
  dt_bauhaus_combobox_add(d->intent, C_("rendering intent", "saturation"));
  dt_bauhaus_combobox_add(d->intent, _("absolute colorimetric"));
  gtk_box_pack_start(GTK_BOX(self->widget), d->intent, FALSE, TRUE, 0);
 
  tooltip = g_strdup_printf(_("• perceptual: "
                              "smoothly moves out-of-gamut colors into gamut,"
                              "preserving gradations, but distorts in-gamut colors in the process."
                              " note that perceptual is often a proprietary LUT that depends"
                              " on the destination space."
                              "\n\n"
 
                              "• relative colorimetric: "
                              "keeps luminance while reducing as little as possible saturation"
                              " until colors fit in gamut."
                              "\n\n"
 
                              "• saturation: "
                              "designed to present eye-catching business graphics"
                              " by preserving the saturation. (not suited for photography)."
                              "\n\n"
 
                              "• absolute colorimetric: "
                              "adapt white point of the image to the white point of the"
                              " destination medium and do nothing else. mainly used when"
                              " proofing colors. (not suited for photography)."
                              ""
                              ));
  gtk_widget_set_tooltip_text(d->intent, tooltip);
  dt_free(tooltip);
 
  //  Add style combo
 
  d->style = dt_bauhaus_combobox_new(dt_bauhaus_get_global(), DT_GUI_MODULE(NULL));
  dt_bauhaus_widget_set_label(d->style, N_("style"));
  _lib_export_styles_changed_callback(NULL, self);
  gtk_box_pack_start(GTK_BOX(self->widget), d->style, FALSE, TRUE, 0);
  gtk_widget_set_tooltip_text(d->style, _("temporary style to use while exporting"));
 
  //  Set callback signals
  g_signal_connect(G_OBJECT(d->export_masks), "value-changed", G_CALLBACK(_callback_bool),
                   (gpointer)CONFIG_PREFIX "export_masks");
  g_signal_connect(G_OBJECT(d->intent), "value-changed", G_CALLBACK(_intent_changed), (gpointer)d);
  g_signal_connect(G_OBJECT(d->profile), "value-changed", G_CALLBACK(_profile_changed), (gpointer)d);
  g_signal_connect(G_OBJECT(d->style), "value-changed", G_CALLBACK(_style_changed), (gpointer)d);
 
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_STYLE_CHANGED,
                            G_CALLBACK(_lib_export_styles_changed_callback), self);
 
  GtkBox *hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING));
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), FALSE, TRUE, 0);
 
  // Export button
  d->export_button = GTK_BUTTON(dt_action_button_new(self, N_("export"), _export_button_clicked, d,
                                                     _("export with current settings"), GDK_KEY_e, DT_PRIMARY_MASK));
  gtk_box_pack_start(hbox, GTK_WIDGET(d->export_button), TRUE, TRUE, 0);
 
  g_signal_connect(G_OBJECT(d->width), "changed", G_CALLBACK(_width_changed), (gpointer)d);
  g_signal_connect(G_OBJECT(d->height), "changed", G_CALLBACK(_height_changed), (gpointer)d);
  g_signal_connect(G_OBJECT(d->print_width), "changed", G_CALLBACK(_print_width_changed), (gpointer)d);
  g_signal_connect(G_OBJECT(d->print_height), "changed", G_CALLBACK(_print_height_changed), (gpointer)d);
  g_signal_connect(G_OBJECT(d->print_dpi), "changed", G_CALLBACK(_print_dpi_changed), (gpointer)d);
 
  g_signal_connect(G_OBJECT(d->width), "button-press-event", G_CALLBACK(_size_entry_reset_click), (gpointer)"0");
  g_signal_connect(G_OBJECT(d->height), "button-press-event", G_CALLBACK(_size_entry_reset_click), (gpointer)"0");
  g_signal_connect(G_OBJECT(d->print_width), "button-press-event", G_CALLBACK(_size_entry_reset_click), (gpointer)"0");
  g_signal_connect(G_OBJECT(d->print_height), "button-press-event", G_CALLBACK(_size_entry_reset_click), (gpointer)"0");
 
  g_signal_connect(G_OBJECT(d->scale), "button-press-event", G_CALLBACK(_size_entry_reset_click), (gpointer)"1");
  g_signal_connect(G_OBJECT(d->scale), "changed", G_CALLBACK(_scale_changed), (gpointer)d);
 
  // this takes care of keeping hidden widgets hidden
  gtk_widget_show_all(self->widget);
  gtk_widget_set_no_show_all(self->widget, TRUE);
 
  const char* setting = dt_conf_get_string_const(CONFIG_PREFIX "width");
  gtk_entry_set_text(GTK_ENTRY(d->width), setting);
  setting = dt_conf_get_string_const(CONFIG_PREFIX "height");
  gtk_entry_set_text(GTK_ENTRY(d->height), setting);
 
  _ensure_print_size_conf();
  _size_update_display(d);
 
  // Set storage
  setting = dt_conf_get_string_const(CONFIG_PREFIX "storage_name");
  const int storage_index = dt_imageio_get_index_of_storage(dt_imageio_get_storage_by_name(setting));
  dt_bauhaus_combobox_set(d->storage, storage_index);
 
  // Set format
  setting = dt_conf_get_string_const(CONFIG_PREFIX "format_name");
  const int format_index = dt_imageio_get_index_of_format(dt_imageio_get_format_by_name(setting));
  dt_bauhaus_combobox_set(d->format, format_index);
 
  dt_bauhaus_combobox_set(d->export_masks, dt_conf_get_bool(CONFIG_PREFIX "export_masks") ? 1 : 0);
 
  dt_bauhaus_combobox_set(d->intent, dt_conf_get_int(CONFIG_PREFIX "iccintent") + 1);
 
  // iccprofile
  const int icctype = dt_conf_get_int(CONFIG_PREFIX "icctype");
  gchar *iccfilename = dt_conf_get_string(CONFIG_PREFIX "iccprofile");
  dt_bauhaus_combobox_set(d->profile, 0);
 
  if(icctype != DT_COLORSPACE_NONE)
  {
    // +1: the combo carries "same as original" ahead of the profiles.
    const int pos = dt_colorspaces_profile_index(DT_PROFILE_ROLE_OUTPUT, icctype, iccfilename);
    if(pos > -1) dt_bauhaus_combobox_set(d->profile, pos + 1);
  }
 
  dt_free(iccfilename);
 
  // style
  // set it to none if the var is not set or the style doesn't exist anymore
  gboolean rc = FALSE;
  setting = dt_conf_get_string_const(CONFIG_PREFIX "style");
  if(!IS_NULL_PTR(setting) && strlen(setting) > 0)
  {
    rc = dt_bauhaus_combobox_set_from_text(d->style, setting);
    if(rc == FALSE)
      dt_bauhaus_combobox_set(d->style, 0);
  }
  else
    dt_bauhaus_combobox_set(d->style, 0);
 
  // export metadata presets
  d->metadata_export = dt_lib_export_metadata_get_conf();
 
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_SELECTION_CHANGED,
                            G_CALLBACK(_image_selection_changed_callback), self);
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_COLLECTION_CHANGED,
                            G_CALLBACK(_collection_updated_callback), self);
}
 
void gui_cleanup(dt_lib_module_t *self)
{
  if(IS_NULL_PTR(self->data)) return;
  dt_lib_cancel_postponed_update(self);
  dt_lib_export_t *d = (dt_lib_export_t *)self->data;
 
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_on_storage_list_changed), self);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_lib_export_styles_changed_callback), self);
 
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_image_selection_changed_callback), self);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_collection_updated_callback), self);
 
  for(const GList *it = dt_imageio_get_global()->plugins_storage; it; it = g_list_next(it))
  {
    dt_imageio_module_storage_t *module = (dt_imageio_module_storage_t *)it->data;
    if(module->widget && GTK_IS_CONTAINER(d->storage_extra_container)) gtk_container_remove(GTK_CONTAINER(d->storage_extra_container), module->widget);
  }
 
  for(const GList *it = dt_imageio_get_global()->plugins_format; it; it = g_list_next(it))
  {
    dt_imageio_module_format_t *module = (dt_imageio_module_format_t *)it->data;
    if(module->widget && GTK_IS_CONTAINER(d->format_extra_container)) gtk_container_remove(GTK_CONTAINER(d->format_extra_container), module->widget);
  }
 
 
  dt_free(d->metadata_export);
 
  dt_free(self->data);
}
 
void init_presets(dt_lib_module_t *self)
{
  // TODO: store presets in db:
  // dt_lib_presets_add(const char *name, const char *plugin_name, const void *params, const int32_t
  // params_size)
 
 
  // I know that it is super ugly to have this inside a module, but then is export not your average module
  // since it handles the params blobs of imageio libs.
  // - get all existing presets for export from db,
  // - extract the versions of the embedded format/storage blob
  // - check if it's up to date
  // - if older than the module -> call its legacy_params and update the preset
  // - drop presets that cannot be updated
 
  const int version = self->version();
 
  // The whole result set is materialised before the first write. This loop DELETEs and UPDATEs
  // data.presets, and it used to do so while its own cursor was still scanning that table.
  GList *presets = dt_preset_repository_list_all_versions("export");
  for(GList *l = presets; l; l = g_list_next(l))
  {
    const dt_module_preset_t *p = (const dt_module_preset_t *)l->data;
    const int rowid = p->rowid;
    const int op_version = p->op_version;
    const void *op_params = p->op_params;
    const size_t op_params_size = p->op_params_size;
    const char *name = p->name;
 
    if(op_version != version)
    {
      // shouldn't happen, we run legacy_params on the lib level before calling this
      fprintf(stderr, "[export_init_presets] found export preset '%s' with version %d, version %d was "
                      "expected. dropping preset.\n",
              name, op_version, version);
      dt_preset_repository_delete_by_rowid(rowid);
    }
    else
    {
      // extract the interesting parts from the blob
      const char *buf = (const char *)op_params;
 
      // skip 6*int32_t: max_width, max_height, upscale, high_quality and iccintent, icctype
      buf += 6 * sizeof(int32_t);
      // skip metadata presets string
      buf += strlen(buf) + 1;
      // next skip iccfilename
      buf += strlen(buf) + 1;
 
      // parse both names to '\0'
      const char *fname = buf;
      buf += strlen(fname) + 1;
      const char *sname = buf;
      buf += strlen(sname) + 1;
 
      // get module by name and skip if not there.
      dt_imageio_module_format_t *fmod = dt_imageio_get_format_by_name(fname);
      dt_imageio_module_storage_t *smod = dt_imageio_get_storage_by_name(sname);
      if(!fmod || !smod) continue;
 
      // next we have fversion, sversion, fsize, ssize, fdata, sdata which is the stuff that might change
      size_t copy_over_part = (void *)buf - (void *)op_params;
 
      const int fversion = *(const int *)buf;
      buf += sizeof(int32_t);
      const int sversion = *(const int *)buf;
      buf += sizeof(int32_t);
      const int fsize = *(const int *)buf;
      buf += sizeof(int32_t);
      const int ssize = *(const int *)buf;
      buf += sizeof(int32_t);
 
      const void *fdata = buf;
      buf += fsize;
      const void *sdata = buf;
 
      void *new_fdata = NULL, *new_sdata = NULL;
      size_t new_fsize = fsize, new_ssize = ssize;
      const int32_t new_fversion = fmod->version(), new_sversion = smod->version();
 
      if(fversion < new_fversion)
      {
        if(!(fmod->legacy_params
             && (new_fdata = fmod->legacy_params(fmod, fdata, fsize, fversion, new_fversion, &new_fsize))
                != NULL))
          goto delete_preset;
      }
 
      if(sversion < new_sversion)
      {
        if(!(smod->legacy_params
             && (new_sdata = smod->legacy_params(smod, sdata, ssize, sversion, new_sversion, &new_ssize))
                != NULL))
          goto delete_preset;
      }
 
      if(new_fdata || new_sdata)
      {
        // we got an updated blob -> reassemble the parts and update the preset
        const size_t new_params_size = op_params_size - (fsize + ssize) + (new_fsize + new_ssize);
        void *new_params = malloc(new_params_size);
        memcpy(new_params, op_params, copy_over_part);
        // next we have fversion, sversion, fsize, ssize, fdata, sdata which is the stuff that might change
        size_t pos = copy_over_part;
        memcpy((uint8_t *)new_params + pos, &new_fversion, sizeof(int32_t));
        pos += sizeof(int32_t);
        memcpy((uint8_t *)new_params + pos, &new_sversion, sizeof(int32_t));
        pos += sizeof(int32_t);
        memcpy((uint8_t *)new_params + pos, &new_fsize, sizeof(int32_t));
        pos += sizeof(int32_t);
        memcpy((uint8_t *)new_params + pos, &new_ssize, sizeof(int32_t));
        pos += sizeof(int32_t);
        if(new_fdata)
          memcpy((uint8_t *)new_params + pos, new_fdata, new_fsize);
        else
          memcpy((uint8_t *)new_params + pos, fdata, fsize);
        pos += new_fsize;
        if(new_sdata)
          memcpy((uint8_t *)new_params + pos, new_sdata, new_ssize);
        else
          memcpy((uint8_t *)new_params + pos, sdata, ssize);
 
        // write the updated preset back to db
        fprintf(stderr,
                "[export_init_presets] updating export preset '%s' from versions %d/%d to versions %d/%d\n",
                name, fversion, sversion, new_fversion, new_sversion);
        // op_version is written back as the row's own value, so this stays the op_params-only
        // update the original was, whatever branch reaches it.
        dt_preset_repository_update_params_by_rowid(rowid, op_version, new_params, new_params_size);
 
        dt_free(new_fdata);
        dt_free(new_sdata);
        dt_free(new_params);
      }
 
      continue;
 
    delete_preset:
      dt_free(new_fdata);
      dt_free(new_sdata);
      fprintf(stderr, "[export_init_presets] export preset '%s' can't be updated from versions %d/%d to "
                      "versions %d/%d. dropping preset\n",
              name, fversion, sversion, new_fversion, new_sversion);
      dt_preset_repository_delete_by_rowid(rowid);
    }
  }
  g_list_free_full(presets, dt_module_preset_free);
}
 
void *legacy_params(dt_lib_module_t *self, const void *const old_params, const size_t old_params_size,
                    const int old_version, int *new_version, size_t *new_size)
{
  if(old_version == 1)
  {
    // add version of format & storage to params
    const size_t new_params_size = old_params_size + 2 * sizeof(int32_t);
    void *new_params = malloc(new_params_size);
 
    const char *buf = (const char *)old_params;
 
    // skip 3*int32_t: max_width, max_height and iccintent
    buf += 3 * sizeof(int32_t);
    // next skip iccprofile
    buf += strlen(buf) + 1;
 
    // parse both names to '\0'
    const char *fname = buf;
    buf += strlen(fname) + 1;
    const char *sname = buf;
    buf += strlen(sname) + 1;
 
    // get module by name and fail if not there.
    dt_imageio_module_format_t *fmod = dt_imageio_get_format_by_name(fname);
    dt_imageio_module_storage_t *smod = dt_imageio_get_storage_by_name(sname);
    if(!fmod || !smod)
    {
      dt_free(new_params);
      return NULL;
    }
 
    // now we are just behind the module/storage names and before their param sizes. this is the place where
    // we want their versions
    // copy everything until here to the new params
    size_t first_half = (void *)buf - (void *)old_params;
    memcpy(new_params, old_params, first_half);
    // add the versions. at the time this code was added all modules were at version 1, except of picasa which was at 2.
    // every newer version of the imageio modules should result in a preset that is not going through this code.
    int32_t fversion = 1;
    int32_t sversion = (strcmp(sname, "picasa") == 0 ? 2 : 1);
    memcpy((uint8_t *)new_params + first_half, &fversion, sizeof(int32_t));
    memcpy((uint8_t *)new_params + first_half + sizeof(int32_t), &sversion, sizeof(int32_t));
    // copy the rest of the old params over
    memcpy((uint8_t *)new_params + first_half + sizeof(int32_t) * 2, buf, old_params_size - first_half);
 
    *new_size = new_params_size;
    *new_version = 2;
    return new_params;
  }
  else if(old_version == 2)
  {
    // add upscale to params
    const size_t new_params_size = old_params_size + sizeof(int32_t);
    void *new_params = calloc(1, new_params_size);
 
    memcpy(new_params, old_params, sizeof(int32_t) * 2);
    memcpy((uint8_t *)new_params + sizeof(int32_t) * 3, (uint8_t *)old_params + sizeof(int32_t) * 2, old_params_size - sizeof(int32_t) * 2);
 
    *new_size = new_params_size;
    *new_version = 3;
    return new_params;
  }
  else if(old_version == 3)
  {
    // replace iccprofile by type + filename
    // format of v3:
    //  - 4 x int32_t (max_width, max_height, upscale, iccintent)
    //  - char* (iccprofile)
    //  - rest
    // format of v4:
    //  - 5 x int32_t (max_width, max_height, upscale, iccintent, icctype)
    //  - char* (iccfilename)
    //  - old rest
 
    const char *buf = (const char *)old_params;
 
    // first get the old iccprofile to find out how big our new blob has to be
    const char *iccprofile = buf + 4 * sizeof(int32_t);
 
    size_t new_params_size = old_params_size - strlen(iccprofile) + sizeof(int32_t);
    int icctype;
    const char *iccfilename = "";
 
    if(!strcmp(iccprofile, "image"))
      icctype = DT_COLORSPACE_NONE;
    else if(!strcmp(iccprofile, "sRGB"))
      icctype = DT_COLORSPACE_SRGB;
    else if(!strcmp(iccprofile, "linear_rec709_rgb") || !strcmp(iccprofile, "linear_rgb"))
      icctype = DT_COLORSPACE_LIN_REC709;
    else if(!strcmp(iccprofile, "linear_rec2020_rgb"))
      icctype = DT_COLORSPACE_LIN_REC2020;
    else if(!strcmp(iccprofile, "adobergb"))
      icctype = DT_COLORSPACE_ADOBERGB;
    else
    {
      icctype = DT_COLORSPACE_FILE;
      iccfilename = iccprofile;
      new_params_size += strlen(iccfilename);
    }
 
    void *new_params = calloc(1, new_params_size);
    size_t pos = 0;
    memcpy(new_params, old_params, sizeof(int32_t) * 4);
    pos += 4 * sizeof(int32_t);
    memcpy((uint8_t *)new_params + pos, &icctype, sizeof(int32_t));
    pos += sizeof(int32_t);
    memcpy((uint8_t *)new_params + pos, iccfilename, strlen(iccfilename) + 1);
    pos += strlen(iccfilename) + 1;
    size_t old_pos = 4 * sizeof(int32_t) + strlen(iccprofile) + 1;
    memcpy((uint8_t *)new_params + pos, (uint8_t *)old_params + old_pos, old_params_size - old_pos);
 
    *new_size = new_params_size;
    *new_version = 4;
    return new_params;
  }
  else if(old_version == 4)
  {
    // add high_quality to params
 
    // format of v4:
    //  - 5 x int32_t (max_width, max_height, upscale, iccintent, icctype)
    //  - char* (iccfilename)
    //  - old rest
    // format of v5:
    //  - 6 x int32_t (max_width, max_height, upscale, high_quality, iccintent, icctype)
    //  - char* (iccfilename)
    //  - old rest
 
    const size_t new_params_size = old_params_size + sizeof(int32_t);
    void *new_params = calloc(1, new_params_size);
 
    size_t pos = 0;
    memcpy(new_params, old_params, sizeof(int32_t) * 3);
    pos += 4 * sizeof(int32_t);
    memcpy((uint8_t *)new_params + pos, (uint8_t *)old_params + pos - sizeof(int32_t), old_params_size - sizeof(int32_t) * 3);
 
    *new_size = new_params_size;
    *new_version = 5;
    return new_params;
  }
  else if(old_version == 5)
  {
    // add metadata preset string
 
    // format of v5:
    //  - 6 x int32_t (max_width, max_height, upscale, high_quality, iccintent, icctype)
    //  - char* (iccfilename)
    //  - old rest
    // format of v6:
    //  - 6 x int32_t (max_width, max_height, upscale, high_quality, iccintent, icctype)
    //  - char* (metadata_export)
    //  - char* (iccfilename)
    //  - old rest
 
    const gboolean omit = dt_conf_get_bool("omit_tag_hierarchy");
    gchar *flags = g_strdup_printf("%x", dt_lib_export_metadata_default_flags() | (omit ? DT_META_OMIT_HIERARCHY : 0));
    const int flags_size = strlen(flags) + 1;
    const size_t new_params_size = old_params_size + flags_size;
    void *new_params = calloc(1, new_params_size);
    size_t pos = 0;
    memcpy(new_params, old_params, sizeof(int32_t) * 6);
    pos += 6 * sizeof(int32_t);
    memcpy((uint8_t *)new_params + pos, flags, flags_size);
    pos += flags_size;
    memcpy((uint8_t *)new_params + pos, (uint8_t *)old_params + pos - flags_size, old_params_size - sizeof(int32_t) * 6);
 
    dt_free(flags);
    *new_size = new_params_size;
    *new_version = 6;
    return new_params;
  }
  else if(old_version == 6)
  {
    // add export_masks
 
    // format of v6:
    //  - 6 x int32_t (max_width, max_height, upscale, high_quality, iccintent, icctype)
    //  - old rest
    // format of v7:
    //  - 7 x int32_t (max_width, max_height, upscale, high_quality, export_masks, iccintent, icctype)
    //  - old rest
 
    const size_t new_params_size = old_params_size + sizeof(int32_t);
    void *new_params = calloc(1, new_params_size);
 
    size_t pos = 0;
    memcpy(new_params, old_params, sizeof(int32_t) * 4);
    pos += 5 * sizeof(int32_t);
    memcpy((uint8_t *)new_params + pos, (uint8_t *)old_params + pos - sizeof(int32_t), old_params_size - sizeof(int32_t) * 4);
 
    *new_size = new_params_size;
    *new_version = 7;
    return new_params;
  }
 
  return NULL;
}
 
void *get_params(dt_lib_module_t *self, int *size)
{
  dt_lib_export_t *d = (dt_lib_export_t *)self->data;
  // concat storage and format, size is max + header
  dt_imageio_module_format_t *mformat = dt_imageio_get_format();
  dt_imageio_module_storage_t *mstorage = dt_imageio_get_storage();
  if(IS_NULL_PTR(mformat) || IS_NULL_PTR(mstorage)) return NULL;
 
  // size will be only as large as needed to remove random pointers from params (stored at the end).
  size_t fsize = mformat->params_size(mformat);
  dt_imageio_module_data_t *fdata = mformat->get_params(mformat);
  size_t ssize = mstorage->params_size(mstorage);
  void *sdata = mstorage->get_params(mstorage);
  const int32_t fversion = mformat->version();
  const int32_t sversion = mstorage->version();
  // we allow null pointers (plugin not ready for export in current state), and just don't copy back the
  // settings later:
  if(IS_NULL_PTR(sdata)) ssize = 0;
  if(IS_NULL_PTR(fdata)) fsize = 0;
  if(fdata)
  {
    // clean up format global params (need to set all bytes to reliably detect which preset is active).
    // we happen to want to set it all to 0
    memset(fdata, 0, sizeof(dt_imageio_module_data_t));
  }
 
  // FIXME: also the web preset has to be applied twice to be known as preset! (other dimension magic going on
  // here?)
  // TODO: get this stuff from gui and not from conf, so it will be sanity-checked (you can never delete an
  // insane preset)?
  // also store icc profile/intent here.
  const int32_t iccintent = dt_conf_get_int(CONFIG_PREFIX "iccintent");
  const int32_t icctype = dt_conf_get_int(CONFIG_PREFIX "icctype");
  // the blob holds a pixel box: the size the selected mode resolves to, or, for a factor it cannot
  // hold, the pixel mode's own box
  int32_t max_width = 0;
  int32_t max_height = 0;
  double scale_factor = 0.0;
  _resolve_export_size(&max_width, &max_height, &scale_factor);
  if(scale_factor > 0.0)
  {
    max_width = dt_conf_get_int(CONFIG_PREFIX "width");
    max_height = dt_conf_get_int(CONFIG_PREFIX "height");
  }
  const int32_t upscale = FALSE;
  const int32_t high_quality = TRUE;
  const int32_t export_masks = dt_conf_get_bool(CONFIG_PREFIX "export_masks") ? 1 : 0;
  gchar *iccfilename = dt_conf_get_string(CONFIG_PREFIX "iccprofile");
  gchar *style = dt_conf_get_string(CONFIG_PREFIX "style");
  const char *metadata_export = IS_NULL_PTR(d->metadata_export) ? "" : d->metadata_export;
 
  if(fdata)
  {
    g_strlcpy(fdata->style, style, sizeof(fdata->style));
  }
 
  if(icctype != DT_COLORSPACE_FILE)
  {
    dt_free(iccfilename);
  }
 
  if(!iccfilename) iccfilename = g_strdup("");
 
  const char *fname = mformat->plugin_name;
  const char *sname = mstorage->plugin_name;
  const int32_t fname_len = strlen(fname);
  const int32_t sname_len = strlen(sname);
 
  *size = fname_len + sname_len + 2 + 4 * sizeof(int32_t) + fsize + ssize + 7 * sizeof(int32_t)
          + strlen(iccfilename) + 1 + strlen(metadata_export) + 1;
 
  char *params = (char *)calloc(1, *size);
  int pos = 0;
  memcpy(params + pos, &max_width, sizeof(int32_t));
  pos += sizeof(int32_t);
  memcpy(params + pos, &max_height, sizeof(int32_t));
  pos += sizeof(int32_t);
  memcpy(params + pos, &upscale, sizeof(int32_t));
  pos += sizeof(int32_t);
  memcpy(params + pos, &high_quality, sizeof(int32_t));
  pos += sizeof(int32_t);
  memcpy(params + pos, &export_masks, sizeof(int32_t));
  pos += sizeof(int32_t);
  memcpy(params + pos, &iccintent, sizeof(int32_t));
  pos += sizeof(int32_t);
  memcpy(params + pos, &icctype, sizeof(int32_t));
  pos += sizeof(int32_t);
  memcpy(params + pos, metadata_export, strlen(metadata_export) + 1);
  pos += strlen(metadata_export) + 1;
  memcpy(params + pos, iccfilename, strlen(iccfilename) + 1);
  pos += strlen(iccfilename) + 1;
  memcpy(params + pos, fname, fname_len + 1);
  pos += fname_len + 1;
  memcpy(params + pos, sname, sname_len + 1);
  pos += sname_len + 1;
  memcpy(params + pos, &fversion, sizeof(int32_t));
  pos += sizeof(int32_t);
  memcpy(params + pos, &sversion, sizeof(int32_t));
  pos += sizeof(int32_t);
  memcpy(params + pos, &fsize, sizeof(int32_t));
  pos += sizeof(int32_t);
  memcpy(params + pos, &ssize, sizeof(int32_t));
  pos += sizeof(int32_t);
  if(!IS_NULL_PTR(fdata)) // otherwise fsize == 0, but clang doesn't like it ...
  {
    memcpy(params + pos, fdata, fsize);
    pos += fsize;
  }
  if(!IS_NULL_PTR(sdata)) // see above
  {
    memcpy(params + pos, sdata, ssize);
    pos += ssize;
  }
  g_assert(pos == *size);
 
  dt_free(iccfilename);
  dt_free(style);
 
  if(fdata) mformat->free_params(mformat, fdata);
  if(sdata) mstorage->free_params(mstorage, sdata);
  return params;
}
 
// the NUL-terminated string at *buf, or NULL if the blob ends before its terminator
static const char *_blob_string(const char **buf, const char *const end)
{
  const char *str = *buf;
  const char *nul = memchr(str, '\0', end - str);
  if(IS_NULL_PTR(nul)) return NULL;
  *buf = nul + 1;
  return str;
}
 
int set_params(dt_lib_module_t *self, const void *params, int size)
{
  dt_lib_export_t *d = (dt_lib_export_t *)self->data;
  if(IS_NULL_PTR(params) || size < 0) return 1;
 
  // parse and validate the whole blob before applying anything of it
  const char *buf = (const char *)params;
  const char *const end = buf + size;
 
  // max_width, max_height, upscale (unused now), high_quality (unused now), export_masks, iccintent, icctype
  int32_t header[7];
  if((size_t)(end - buf) < sizeof(header)) return 1;
  memcpy(header, buf, sizeof(header));
  buf += sizeof(header);
  const int max_width = header[0];
  const int max_height = header[1];
  const int export_masks = header[4];
  const int iccintent = header[5];
  const int icctype = header[6];
 
  const char *metadata_export = _blob_string(&buf, end);
  const char *iccfilename = metadata_export ? _blob_string(&buf, end) : NULL;
  const char *fname = iccfilename ? _blob_string(&buf, end) : NULL;
  const char *sname = fname ? _blob_string(&buf, end) : NULL;
  if(IS_NULL_PTR(sname)) return 1;
 
  // fversion, sversion, fsize, ssize
  int32_t modules[4];
  if((size_t)(end - buf) < sizeof(modules)) return 1;
  memcpy(modules, buf, sizeof(modules));
  buf += sizeof(modules);
  const int32_t fversion = modules[0];
  const int32_t sversion = modules[1];
  const int32_t fsize = modules[2];
  const int32_t ssize = modules[3];
  if(fsize < 0 || ssize < 0 || (size_t)(end - buf) != (size_t)fsize + (size_t)ssize) return 1;
 
  // get module by name and fail if not there.
  dt_imageio_module_format_t *fmod = dt_imageio_get_format_by_name(fname);
  dt_imageio_module_storage_t *smod = dt_imageio_get_storage_by_name(sname);
  if(!fmod || !smod) return 1;
  if(fversion != fmod->version() || sversion != smod->version()) return 1;
 
  const dt_imageio_module_data_t *fdata = (const dt_imageio_module_data_t *)buf;
  const void *sdata = buf + fsize;
 
  dt_free(d->metadata_export);
  d->metadata_export = g_strdup(metadata_export);
  dt_lib_export_metadata_set_conf(d->metadata_export);
 
  // reverse these by setting the gui, not the conf vars!
  dt_bauhaus_combobox_set(d->intent, iccintent + 1);
 
  dt_bauhaus_combobox_set(d->profile, 0);
  if(icctype != DT_COLORSPACE_NONE)
  {
    // +1: the combo carries "same as original" ahead of the profiles.
    const int pos = dt_colorspaces_profile_index(DT_PROFILE_ROLE_OUTPUT, icctype, iccfilename);
    if(pos > -1) dt_bauhaus_combobox_set(d->profile, pos + 1);
  }
 
  // the style travels in the format's params: a preset saved while the format had none carries
  // no style, and the current one is left alone.
  if((size_t)fsize >= sizeof(dt_imageio_module_data_t))
  {
    char style[sizeof(fdata->style)];
    memcpy(style, fdata->style, sizeof(style));
    style[sizeof(style) - 1] = '\0';
    if(style[0] == '\0')
      dt_bauhaus_combobox_set(d->style, 0);
    else
      dt_bauhaus_combobox_set_from_text(d->style, style);
  }
 
  // switch modules
  set_storage_by_name(d, sname);
  set_format_by_name(d, fname);
 
  // set dimensions after switching, to have new range ready. The preset holds a pixel box: the
  // print mode gets its equivalent at the current dpi.
  _set_dimensions(d, max_width, max_height);
  _print_size_from_pixels(max_width, max_height);
  _print_size_display(d);
  _size_in_px_update(d);
  dt_bauhaus_combobox_set(d->export_masks, export_masks ? 1 : 0);
 
  // propagate to modules
  int res = 0;
  if(ssize) res += smod->set_params(smod, sdata, ssize);
  if(fsize) res += fmod->set_params(fmod, fdata, fsize);
  return res;
}
 
// 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