history_actions.c

Go to the documentation of this file.

/*
    This file is part of Ansel,
    Copyright (C) 2026 Aurélien PIERRE.
 
    Ansel is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Ansel is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with Ansel.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "common/history_actions.h"
#include "history/notify.h"
 
#include "common/collection.h"
#include "common/xmp_sidecar.h"
#include "history/history.h"
#include "history/history_snapshot.h"
#include "common/image.h"
#include "caches/image_cache.h"
#include "common/styles.h"
#include "common/undo.h"
#include "common/conf.h"
#include "develop/dev_history.h"
#include "develop/develop.h"
#include "develop/imageop.h"
 
#ifdef GDK_WINDOWING_QUARTZ
#include "osx/osx.h"
#endif
 
/* The history clipboard. Was a member of dt_view_manager_t, which the view manager never
 * touched; zero-initialised there by its calloc, and zero-initialised here by being static. */
static dt_history_copy_item_t _copy_paste = { 0 };
 
dt_history_copy_item_t *dt_history_copy_paste_get(void)
{
  return &_copy_paste;
}
 
static void _history_action_finalize_list(const GList *list, const gboolean changed)
{
  if(!changed) return;
 
  dt_history_changed(DT_HISTORY_CHANGE_TAGS);
  dt_history_changed_images(list);
}
 
typedef gboolean (*dt_history_action_fn)(const int32_t imgid, void *user_data);
 
static gboolean _history_action_on_list_with_undo(const GList *list, dt_history_action_fn action, void *user_data,
                                                  const gboolean use_undo)
{
  if(IS_NULL_PTR(list)) return FALSE;
 
  if(use_undo) dt_undo_start_group(dt_undo_get_global(), DT_UNDO_LT_HISTORY);
  gboolean changed = FALSE;
  for(const GList *l = list; l; l = g_list_next(l))
  {
    const int32_t imgid = GPOINTER_TO_INT(l->data);
    changed |= action(imgid, user_data);
  }
  if(use_undo) dt_undo_end_group(dt_undo_get_global());
 
  _history_action_finalize_list(list, changed);
  return changed;
}
 
static gboolean _history_action_on_list(const GList *list, dt_history_action_fn action, void *user_data)
{
  return _history_action_on_list_with_undo(list, action, user_data, TRUE);
}
 
static GList *_get_user_mod_list(dt_develop_t *dev_src, GList *ops, gboolean copy_full)
{
  GList *mod_list = NULL;
 
  if(ops)
  {
    dt_print(DT_DEBUG_PARAMS, "[_history_copy_and_paste_on_image_merge] pasting selected IOP\n");
 
    // copy only selected history entries
    for(const GList *l = g_list_last(ops); l; l = g_list_previous(l))
    {
      const unsigned int num = GPOINTER_TO_UINT(l->data);
      const dt_dev_history_item_t *hist = NULL;
      for(GList *h = g_list_last(dev_src->history); h; h = g_list_previous(h))
      {
        const dt_dev_history_item_t *item = (dt_dev_history_item_t *)h->data;
        if(item && item->num == (int)num)
        {
          hist = item;
          break;
        }
      }
 
      if(hist)
      {
        dt_iop_module_t *mod = hist->module;
        if(mod && !dt_iop_is_hidden(mod))
        {
          dt_print(DT_DEBUG_HISTORY, "selected for copy/pasting : module %20s, multiprio %i", mod->op, mod->multi_priority);
 
          mod_list = g_list_prepend(mod_list, mod);
        }
      }
    }
  }
  else
  {
    dt_print(DT_DEBUG_PARAMS, "[_history_copy_and_paste_on_image_merge] pasting all IOP\n");
 
    // we will copy all modules
    for(GList *modules_src = g_list_first(dev_src->iop); modules_src; modules_src = g_list_next(modules_src))
    {
      dt_iop_module_t *mod_src = (dt_iop_module_t *)(modules_src->data);
 
      // copy from history only if
      if((dt_dev_history_get_first_item_by_module(dev_src->history, mod_src) != NULL) // module is in history of source image
         && !dt_iop_is_hidden(mod_src) // hidden modules are technical and special
         && (copy_full || !dt_history_module_skip_copy(mod_src->flags()))
        )
      {
        // Note: we prepend to GList because it's more efficient
        mod_list = g_list_prepend(mod_list, mod_src);
      }
    }
  }
 
  return g_list_reverse(mod_list);
}
 
static int _history_copy_and_paste_on_image_merge(int32_t imgid, int32_t dest_imgid, GList *ops,
                                                  const gboolean copy_full, const dt_history_merge_strategy_t mode,
                                                  const gboolean copy_iop_order, dt_hm_batch_state_t *batch)
{
  // Init source history + pipeline
  dt_develop_t _dev_src = { 0 };
  dt_develop_t *dev_src = &_dev_src;
  dt_dev_init(dev_src, FALSE);
  dt_dev_reload_history_items(dev_src, imgid);
 
  int ret_val = 0;
 
  if(mode == DT_HISTORY_MERGE_REPLACE)
  {
    // Dumb mode : keep dev_src intact but swap destination imgid and image info into it.
    //
    // NOTE: when pasting from LDR/JPEG onto RAW images, the source iop-order list might not be compatible
    // with the destination pipeline. We need to re-init the iop-order list for the destination image and
    // reload module defaults for the destination image, but we must not apply auto-presets.
    ret_val = dt_dev_replace_history_on_image(dev_src, dest_imgid, TRUE, "_history_copy_and_paste_on_image_merge");
  }
  else
  {
    // Merge
    GList *mod_list = _get_user_mod_list(dev_src, ops, copy_full);
    ret_val = dt_dev_merge_history_into_image(dev_src, dest_imgid, mod_list,
                                              copy_iop_order, mode,
                                              dt_conf_get_bool("history/paste_instances"), NULL, batch);
    g_list_free(mod_list);
    mod_list = NULL;
  }
  dt_dev_cleanup(dev_src);
 
  return ret_val;
}
 
gboolean dt_history_copy_and_paste_on_image(const int32_t imgid, const int32_t dest_imgid, GList *ops,
                                            const gboolean copy_full, const dt_history_merge_strategy_t mode,
                                            const gboolean copy_iop_order, dt_hm_batch_state_t *batch)
{
  if(imgid == dest_imgid) return 1;
 
  if(imgid == UNKNOWN_IMAGE)
  {
    dt_history_message(_("you need to copy history from an image before you paste it onto another"));
    return 1;
  }
 
  dt_undo_lt_history_t *hist = dt_history_snapshot_item_init();
  hist->imgid = dest_imgid;
  dt_history_snapshot_undo_create(hist->imgid, &hist->before, &hist->before_history_end);
 
  int ret_val = _history_copy_and_paste_on_image_merge(imgid, dest_imgid, ops, copy_full, mode, copy_iop_order,
                                                       batch);
 
  dt_history_snapshot_undo_create(hist->imgid, &hist->after, &hist->after_history_end);
  dt_undo_record(dt_undo_get_global(), NULL, DT_UNDO_LT_HISTORY, (dt_undo_data_t)hist,
                 dt_history_snapshot_undo_pop, dt_history_snapshot_undo_lt_history_data_free);
 
  return ret_val;
}
 
gboolean dt_history_copy(int32_t imgid)
{
  // note that this routine does not copy anything, it just setup the copy_paste proxy
  // with the needed information that will be used while pasting.
 
  if(imgid <= 0) return FALSE;
 
  dt_history_copy_paste_get()->copied_imageid = imgid;
 
  return TRUE;
}
 
typedef struct _paste_action_ctx_t
{
  dt_hm_batch_state_t batch;
} _paste_action_ctx_t;
 
static gboolean _history_paste_apply(const int32_t imgid, void *user_data)
{
  _paste_action_ctx_t *ctx = (_paste_action_ctx_t *)user_data;
  const dt_history_copy_item_t *copy_paste = dt_history_copy_paste_get();
  if(copy_paste->copied_imageid <= 0) return FALSE;
  if(imgid <= 0) return FALSE;
 
  const gboolean pasted = dt_history_copy_and_paste_on_image(copy_paste->copied_imageid,
                                                             imgid,
                                                             copy_paste->selops,
                                                             FALSE,
                                                             dt_conf_get_int("history/paste/mode"),
                                                             dt_conf_get_bool("history/paste/copy_iop_order"),
                                                             ctx ? &ctx->batch : NULL) == 0;
  return pasted;
}
 
gboolean dt_history_paste_on_image(const int32_t imgid)
{
  return _history_paste_apply(imgid, NULL);  // NULL batch → always show report popup
}
 
gboolean dt_history_paste_on_list(const GList *list)
{
  if(dt_history_copy_paste_get()->copied_imageid <= 0) return FALSE;
  _paste_action_ctx_t ctx = { 0 };
  const gboolean changed = _history_action_on_list(list, _history_paste_apply, &ctx);
  dt_hm_batch_state_cleanup(&ctx.batch);
  return changed;
}
 
static gboolean _history_paste_parts_apply(const int32_t imgid, void *user_data)
{
  _paste_action_ctx_t *ctx = (_paste_action_ctx_t *)user_data;
  const dt_history_copy_item_t *copy_paste = dt_history_copy_paste_get();
  if(copy_paste->copied_imageid <= 0) return FALSE;
  if(IS_NULL_PTR(copy_paste->selops)) return FALSE;
  if(imgid <= 0) return FALSE;
 
  const gboolean pasted = dt_history_copy_and_paste_on_image(copy_paste->copied_imageid,
                                                             imgid,
                                                             copy_paste->selops,
                                                             FALSE,
                                                             dt_conf_get_int("history/paste/mode"),
                                                             dt_conf_get_bool("history/paste/copy_iop_order"),
                                                             ctx ? &ctx->batch : NULL) == 0;
  return pasted;
}
 
gboolean dt_history_paste_parts_on_image(const int32_t imgid)
{
  return _history_paste_parts_apply(imgid, NULL);  // NULL batch → always show report popup
}
 
gboolean dt_history_paste_parts_on_list(const GList *list)
{
  const dt_history_copy_item_t *copy_paste = dt_history_copy_paste_get();
  if(copy_paste->copied_imageid <= 0) return FALSE;
  if(IS_NULL_PTR(copy_paste->selops))
    return FALSE;
  _paste_action_ctx_t ctx = { 0 };
  const gboolean changed = _history_action_on_list(list, _history_paste_parts_apply, &ctx);
  dt_hm_batch_state_cleanup(&ctx.batch);
  return changed;
}
 
static gboolean _history_compress_apply(const int32_t imgid, void *user_data)
{
  (void)user_data;
  dt_print(DT_DEBUG_HISTORY, "[dt_history_compress_on_image] compressing history for image %i\n", imgid);
  if(imgid <= 0) return FALSE;
 
  dt_develop_t dev;
  dt_dev_init(&dev, FALSE);
  dt_dev_reload_history_items(&dev, imgid);
  dt_dev_history_compress_or_truncate(&dev);
  dt_dev_write_history_ext(&dev, imgid);
  dt_dev_cleanup(&dev);
  return TRUE;
}
 
void dt_history_compress_on_image(const int32_t imgid)
{
  _history_compress_apply(imgid, NULL);
}
 
int dt_history_compress_on_list(const GList *imgs)
{
  _history_action_on_list(imgs, _history_compress_apply, NULL);
  return 0;
}
 
typedef struct dt_history_load_params_t
{
  gchar *filename;
  int history_only;
} dt_history_load_params_t;
 
static gboolean _history_load_and_apply_apply(const int32_t imgid, void *user_data)
{
  dt_history_load_params_t *params = (dt_history_load_params_t *)user_data;
  dt_image_t *img = dt_image_cache_get(imgid, 'w');
  if(IS_NULL_PTR(img)) return FALSE;
 
  dt_undo_lt_history_t *hist = dt_history_snapshot_item_init();
  hist->imgid = imgid;
  dt_history_snapshot_undo_create(hist->imgid, &hist->before, &hist->before_history_end);
 
  if(dt_exif_xmp_read(img, params->filename, params->history_only))
  {
    dt_image_cache_write_release(img,
                                 // ugly but if not history_only => called from crawler - do not write the xmp
                                 params->history_only ? DT_IMAGE_CACHE_SAFE : DT_IMAGE_CACHE_RELAXED);
    return FALSE;
  }
 
  dt_history_snapshot_undo_create(hist->imgid, &hist->after, &hist->after_history_end);
  dt_undo_record(dt_undo_get_global(), NULL, DT_UNDO_LT_HISTORY, (dt_undo_data_t)hist,
                 dt_history_snapshot_undo_pop, dt_history_snapshot_undo_lt_history_data_free);
 
  dt_image_cache_write_release(img,
                               // ugly but if not history_only => called from crawler - do not write the xmp
                               params->history_only ? DT_IMAGE_CACHE_SAFE : DT_IMAGE_CACHE_RELAXED);
 
  // Loading an XMP rewrites the image history straight into the DB and image cache, bypassing
  // the darkroom/paste path that goes through dt_dev_history_notify_change(). Nothing invalidates
  // the rendered thumbnail, so it keeps showing the pre-XMP development (issue #861).
  // The cached metadata (history_items, ratings...) is refreshed by the DT_SIGNAL_IMAGE_INFO_CHANGED
  // raised in _history_action_finalize_list(), but the pixels are not: reload metadata, invalidate
  // the mipmap and refresh the thumbnail (lighttable context, so refresh the filmstrip too).
  dt_image_history_changed(imgid, TRUE);
 
  return TRUE;
}
 
int dt_history_load_and_apply(const int32_t imgid, gchar *filename, int history_only)
{
  dt_history_load_params_t params = { .filename = filename, .history_only = history_only };
  return _history_load_and_apply_apply(imgid, &params) ? 0 : 1;
}
 
int dt_history_load_and_apply_on_image(int32_t imgid, gchar *filename, int history_only)
{
  return dt_history_load_and_apply(imgid, filename, history_only);
}
 
int dt_history_load_and_apply_on_list(gchar *filename, const GList *list)
{
  dt_history_load_params_t params = { .filename = filename, .history_only = 1 };
  const gboolean changed = _history_action_on_list(list, _history_load_and_apply_apply, &params);
  return changed ? 0 : 1;
}
 
typedef struct dt_history_delete_params_t
{
  gboolean undo;
} dt_history_delete_params_t;
 
static gboolean _history_delete_apply(const int32_t imgid, void *user_data)
{
  if(imgid <= 0) return FALSE;
 
  const dt_history_delete_params_t *params = (dt_history_delete_params_t *)user_data;
  const gboolean undo = params ? params->undo : TRUE;
 
  dt_undo_lt_history_t *hist = NULL;
  if(undo)
  {
    hist = dt_history_snapshot_item_init();
    hist->imgid = imgid;
    dt_history_snapshot_undo_create(hist->imgid, &hist->before, &hist->before_history_end);
  }
 
  dt_history_delete_on_image_ext(imgid, FALSE);
 
  if(undo)
  {
    dt_history_snapshot_undo_create(hist->imgid, &hist->after, &hist->after_history_end);
    dt_undo_record(dt_undo_get_global(), NULL, DT_UNDO_LT_HISTORY, (dt_undo_data_t)hist, dt_history_snapshot_undo_pop,
                   dt_history_snapshot_undo_lt_history_data_free);
  }
 
  return TRUE;
}
 
gboolean dt_history_delete_on_list(const GList *list, gboolean undo)
{
  dt_history_delete_params_t params = { .undo = undo };
  return _history_action_on_list_with_undo(list, _history_delete_apply, &params, undo);
}
 
typedef struct dt_history_style_params_t
{
  const char *name;
  int style_id;
  gboolean duplicate;
  dt_history_merge_strategy_t mode;
  dt_hm_batch_state_t batch;
} dt_history_style_params_t;
 
static gboolean _history_style_apply(const int32_t imgid, void *user_data)
{
  dt_history_style_params_t *params = (dt_history_style_params_t *)user_data;
  if(IS_NULL_PTR(params) || params->style_id == 0 || IS_NULL_PTR(params->name) || !*params->name) return FALSE;
 
  int32_t newimgid = imgid;
  if(params->duplicate)
  {
    // Defer exposing the duplicate to the collection/lighttable grid until its history is
    // copied below -- otherwise the grid can generate and cache a thumbnail from the
    // still-historyless row before the copy ever runs.
    newimgid = dt_image_duplicate_no_reload(imgid);
    if(newimgid == UNKNOWN_IMAGE) return FALSE;
 
    // Structural copy of original history into the duplicate; no merge report needed here.
    const gboolean pasted = dt_history_copy_and_paste_on_image(imgid, newimgid, NULL, TRUE, params->mode,
                                                               dt_conf_get_bool("history/style/copy_iop_order"),
                                                               NULL) == 0;
 
    dt_collection_update_query(dt_collection_get_global(), DT_COLLECTION_CHANGE_RELOAD, DT_COLLECTION_PROP_UNDEF, NULL);
 
    return pasted;
  }
 
  dt_undo_lt_history_t *hist = dt_history_snapshot_item_init();
  hist->imgid = newimgid;
  dt_history_snapshot_undo_create(hist->imgid, &hist->before, &hist->before_history_end);
 
  const int ret_val = dt_styles_apply_to_image_merge(params->name, params->style_id, newimgid, params->mode,
                                                     &params->batch);
 
  dt_history_snapshot_undo_create(hist->imgid, &hist->after, &hist->after_history_end);
  dt_undo_record(dt_undo_get_global(), NULL, DT_UNDO_LT_HISTORY, (dt_undo_data_t)hist,
                 dt_history_snapshot_undo_pop, dt_history_snapshot_undo_lt_history_data_free);
 
  const gboolean changed = (ret_val == 0);
  return changed;
}
 
gboolean dt_history_style_on_image(const int32_t imgid, const char *name, const gboolean duplicate)
{
  if(IS_NULL_PTR(name) || !*name) return FALSE;
 
  dt_history_style_params_t params = {
    .name = name,
    .style_id = dt_styles_get_id_by_name(name),
    .duplicate = duplicate,
    .mode = dt_conf_get_int("history/style/mode"),
    .batch = { .decision = DT_HM_BATCH_UNDECIDED },
  };
  if(params.style_id == 0) return FALSE;
 
  const gboolean changed = _history_style_apply(imgid, &params);
  dt_hm_batch_state_cleanup(&params.batch);
  return changed;
}
 
gboolean dt_history_style_on_list(const GList *list, const char *name, const gboolean duplicate)
{
  if(IS_NULL_PTR(name) || !*name) return FALSE;
 
  dt_history_style_params_t params = {
    .name = name,
    .style_id = dt_styles_get_id_by_name(name),
    .duplicate = duplicate,
    .mode = dt_conf_get_int("history/style/mode"),
    .batch = { .decision = DT_HM_BATCH_UNDECIDED },
  };
  if(params.style_id == 0) return FALSE;
 
  const gboolean changed = _history_action_on_list(list, _history_style_apply, &params);
  dt_hm_batch_state_cleanup(&params.batch);
  return changed;
}