/*
    This file is part of darktable,
    Copyright (C) 2009-2026 darktable developers.

    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 "common/gdk_event_utils.h"

#include "libs/lib.h"
#include "common/debug.h"
#include "common/module.h"
#include "common/presets.h"
#include "common/color_picker.h"
#include "control/conf.h"
#include "control/control.h"
#include "dtgtk/button.h"
#include "dtgtk/expander.h"
#include "gui/accelerators.h"
#include "gui/drag_and_drop.h"
#include "gui/gtk.h"
#include "gui/presets.h"
#include "gui/splash.h"

#include <gtk/gtk.h>
#include <string.h>
#include <stdbool.h>
#include <stdlib.h>

typedef struct dt_lib_presets_edit_dialog_t
{
  GtkEntry *name, *description;
  char plugin_name[128];
  int32_t version;
  void *params;
  int32_t params_size;
  gchar *original_name;
  dt_lib_module_t *module;
  gint old_id;
} dt_lib_presets_edit_dialog_t;

static gchar *_get_lib_view_path(const dt_lib_module_t *module,
                                 const dt_view_t *cv,
                                 char *suffix);

gboolean dt_lib_is_visible_in_view(dt_lib_module_t *module,
                                   const dt_view_t *view)
{
  if(!module->views)
  {
    dt_print(DT_DEBUG_ALWAYS,
             "module %s doesn't have views flags",
             module->name(module));
    return FALSE;
  }

  gboolean ret = module->views(module) & view->view(view);
  gchar *key = _get_lib_view_path(module, view, "_visible");
  if(key && dt_conf_key_exists(key))
    ret = dt_conf_get_bool(key);
  g_free(key);

  return ret;
}

/** calls module->cleanup and closes the dl connection. */
static void _lib_unload_module(dt_lib_module_t *module);

gchar *dt_lib_get_active_preset_name(dt_lib_module_info_t *minfo)
{
  GList *presets = dt_presets_list_params(minfo->plugin_name, minfo->version, FALSE);
  gchar *name = NULL;
  // collect all presets for op from db
  for(const GList *l = presets; l; l = g_list_next(l))
  {
    const dt_presets_params_t *p = l->data;
    if(p->op_params_size == minfo->params_size
       && !memcmp(minfo->params, p->op_params, p->op_params_size))
    {
      name = g_strdup(p->name);
      break;
    }
  }
  g_list_free_full(presets, dt_presets_params_free);
  return name;
}

// get dt_lib_module_info_t for a module. Must be freed by _free_module_info()
static dt_lib_module_info_t *_get_module_info_for_module(dt_lib_module_t *module)
{
  dt_lib_module_info_t *mi = calloc(1, sizeof(dt_lib_module_info_t));

  mi->plugin_name = g_strdup(module->plugin_name);
  mi->version = module->version();
  mi->module = module;
  mi->params = module->get_params ? module->get_params(module, &mi->params_size) : NULL;
  if(!mi->params)
  {
    // this is a valid case, for example in location.c when nothing got selected
    // fprintf(stderr, "something went wrong: &params=%p, size=%i\n",
    //         mi->params, mi->params_size);
    mi->params_size = 0;
  }
  return mi;
}

static void _set_module_preset_label(dt_lib_module_t *module,
                                     const gchar *preset_name)
{
  if(!module->expander || !module->has_preset_label(module))
    return;

  const gchar *current_preset_label_text = gtk_label_get_text(GTK_LABEL(module->preset_label));
  gchar *preset_label_text =
    (*preset_name == '\0' || (!dt_conf_get_bool("darkroom/ui/auto_module_name_update")))?
    g_strdup("") : g_strdup_printf("• %s", preset_name);

  if(g_strcmp0(current_preset_label_text, preset_label_text))
    // update the preset label only if changed to avoid infinite loop
    gtk_label_set_text(GTK_LABEL(module->preset_label), preset_label_text);

  g_free(preset_label_text);
}

static void _free_module_info(gpointer user_data)
{
  dt_lib_module_info_t *minfo = (dt_lib_module_info_t *)user_data;
  g_free(minfo->plugin_name);
  free(minfo->params);
  free(minfo);
}

static void _edit_preset(const char *name_in,
                         dt_lib_module_info_t *minfo)
{
  dt_lib_module_info_t *minfo2 = _get_module_info_for_module(minfo->module);

  // get the original name of the preset
  gchar *name = NULL;
  if(name_in == NULL)
  {
    name = dt_lib_get_active_preset_name(minfo2);
    if(name == NULL) return;
  }
  else
    name = g_strdup(name_in);

  // find the rowid of the preset
  int rowid = -1;
  dt_presets_details_t details = { 0 };
  if(dt_presets_get_details(name, minfo2->plugin_name, minfo2->version, &details))
    rowid = details.rowid;
  dt_presets_details_clear(&details);

  // if we don't have a valid rowid, just exit, there's a problem !
  if(rowid < 0) return;

  GtkWidget *window = dt_ui_main_window(darktable.gui->ui);
  dt_gui_presets_show_edit_dialog
    (name, rowid, NULL, NULL, TRUE, TRUE, FALSE, GTK_WINDOW(window));

  _free_module_info(minfo2);
}

static void _menuitem_update_preset(GSimpleAction *action,
                                    GVariant *parameter,
                                    gpointer user_data)
{
  dt_lib_module_info_t *minfo = (dt_lib_module_info_t *)user_data;
  dt_lib_module_info_t *minfo2 = _get_module_info_for_module(minfo->module);

  const gchar *name = g_variant_get_string(parameter,  NULL);

  if(!dt_conf_get_bool("plugins/lighttable/preset/ask_before_delete_preset")
     || dt_gui_show_yes_no_dialog(_("update preset?"), "",
                                  _("do you really want to update the preset `%s'?"),
                                  name))
  {
    // commit all the module fields
    dt_presets_set_op_params(minfo2->plugin_name, name, minfo2->version,
                             minfo2->params, minfo2->params_size);
    DT_CONTROL_SIGNAL_RAISE(DT_SIGNAL_PRESETS_CHANGED,
                            g_strdup(minfo->plugin_name));
  }

  _free_module_info(minfo2);
}

static void _menuitem_new_preset(GSimpleAction *action,
                                 GVariant *parameter,
                                 gpointer user_data)
{
  dt_lib_module_info_t *minfo = (dt_lib_module_info_t *)user_data;
  dt_lib_module_info_t *minfo2 = _get_module_info_for_module(minfo->module);

  dt_lib_presets_remove(_("new preset"), minfo2->plugin_name, minfo2->version);

  // add new preset
  dt_presets_insert_lib_preset(_("new preset"), minfo2->plugin_name, minfo2->version,
                               minfo2->params, minfo2->params_size);
  // create a shortcut for the new entry

  dt_action_define_preset(&minfo2->module->actions, _("new preset"));

  // then show edit dialog
  _edit_preset(_("new preset"), minfo2);

  _free_module_info(minfo2);
}

static void _menuitem_edit_preset(GSimpleAction *action,
                                  GVariant *parameter,
                                  gpointer user_data)
{
  dt_lib_module_info_t *minfo = (dt_lib_module_info_t *)user_data;
  dt_lib_module_info_t *minfo2 = _get_module_info_for_module(minfo->module);

  _edit_preset(NULL, minfo2);
  _free_module_info(minfo2);
}

static void _menuitem_manage_presets(GSimpleAction *action,
                                    GVariant *parameter,
                                    gpointer user_data)
{
  dt_lib_module_info_t *minfo = (dt_lib_module_info_t *)user_data;

  if(minfo->module->manage_presets)
    minfo->module->manage_presets(minfo->module);
}

static void _menuitem_delete_preset(GSimpleAction *action,
                                    GVariant *parameter,
                                    gpointer user_data)
{
  dt_lib_module_info_t *minfo = (dt_lib_module_info_t *)user_data;
  dt_lib_module_info_t *minfo2 = _get_module_info_for_module(minfo->module);

  gchar *name = dt_lib_get_active_preset_name(minfo2);
  if(name == NULL) return;

  if(!dt_conf_get_bool("plugins/lighttable/preset/ask_before_delete_preset")
     || dt_gui_show_yes_no_dialog(_("delete preset?"), "",
                                  _("do you really want to delete the preset `%s'?"),
                                  name))
  {
    dt_action_rename_preset(&minfo2->module->actions, name, NULL);
    dt_lib_presets_remove(name, minfo2->plugin_name, minfo2->version);
    _set_module_preset_label(minfo2->module, "");

    DT_CONTROL_SIGNAL_RAISE(DT_SIGNAL_PRESETS_CHANGED,
                            g_strdup(minfo2->plugin_name));
  }
  g_free(name);
  _free_module_info(minfo2);
}

gchar *dt_lib_presets_duplicate(const gchar *preset,
                                const gchar *module_name,
                                const int module_version)
{
  return dt_presets_duplicate(preset, module_name, module_version);
}

void dt_lib_presets_remove(const gchar *preset,
                           const gchar *module_name,
                           const int module_version)
{
  dt_presets_remove(preset, module_name, module_version);
}

gboolean dt_lib_presets_apply(const gchar *preset,
                              const gchar *module_name,
                              const int module_version)
{
  gboolean ret = TRUE;
  dt_presets_params_t p = { 0 };

  int res = 0;
  if(dt_presets_get_params(module_name, module_version, preset, &p))
  {
    const void *blob = p.op_params;
    const int length = p.op_params_size;
    const int writeprotect = p.writeprotect;
    if(blob)
    {
      for(const GList *it = darktable.lib->plugins; it; it = g_list_next(it))
      {
        dt_lib_module_t *module = it->data;
        if(!strncmp(module->plugin_name, module_name, 128))
        {
          gchar *tx = g_strdup_printf("plugins/darkroom/%s/last_preset", module_name);
          dt_conf_set_string(tx, preset);
          g_free(tx);
          res = module->set_params(module, blob, length);
          if(!res)
            _set_module_preset_label(module, preset);
          break;
        }
      }
    }

    if(!writeprotect) dt_gui_store_last_preset(preset);
  }
  else
    ret = FALSE;
  dt_presets_params_clear(&p);
  if(res)
  {
    dt_control_log(_("deleting preset for obsolete module"));
    dt_lib_presets_remove(preset, module_name, module_version);
  }
  return ret;
}

void dt_lib_presets_update(const gchar *preset,
                           const gchar *module_name,
                           const int module_version,
                           const gchar *newname,
                           const gchar *desc,
                           const void *params,
                           const int32_t params_size)
{
  dt_presets_update_named(preset, module_name, module_version, newname, desc,
                          params, params_size);
}

static void _menuitem_activate_preset(GSimpleAction *action,
                                      GVariant *parameter,
                                      gpointer user_data)
{
  dt_lib_module_info_t *minfo = (dt_lib_module_info_t *)user_data;
  
  g_simple_action_set_state(action, parameter);

  const gchar *preset_name = g_variant_get_string(parameter,  NULL);
  dt_lib_presets_apply(preset_name,
                       minfo->module->plugin_name, minfo->module->version());

  // close the menu
  gtk_popover_popdown(GTK_POPOVER(darktable.gui->active_popover_menu));
}

/* secondary click copies the preset as lua and keeps the menu open: the
 * gesture is in CAPTURE phase and claims the sequence, so the menu shell
 * never sees the press or release and never activates the item.  primary
 * clicks flow normally and apply via the "activate" signal. */
// static void _menuitem_button_preset_released(GtkGestureSingle *gesture,
//                                              gint n_press,
//                                              gdouble x,
//                                              gdouble y,
//                                              dt_lib_module_info_t *minfo)
// {
//   GtkMenuItem *menuitem = GTK_MENU_ITEM(dt_gui_get_widget(gesture));
//   dt_shortcut_copy_lua((dt_action_t*)minfo->module,
//                        g_object_get_data(G_OBJECT(menuitem), "dt-preset-name"));
// }

/* ---------- lib preset menu (dt_gui_presets_popup_menu_show() ops) ---------- */

static GList *_lib_presets_rows(gpointer data)
{
  const dt_lib_module_info_t *minfo = data;
  const gboolean default_first = dt_conf_get_bool("modules/default_presets_first");
  return dt_presets_menu_rows_lib(minfo->plugin_name, minfo->version, default_first);
}

static gboolean _lib_presets_is_active(const dt_presets_params_t *row, gpointer data,
                                      gboolean *writeprotect)
{
  const dt_lib_module_info_t *minfo = data;
  const void *op_params = row->op_params;
  const int32_t op_params_size = row->op_params_size;

  if(op_params_size == minfo->params_size
     && !memcmp(minfo->params, op_params, op_params_size))
  {
    *writeprotect = row->writeprotect;
    return TRUE;
  }
  return FALSE;
}

static void _lib_presets_prefs(GMenu *menu, gpointer data)
{
  const dt_lib_module_info_t *minfo = data;

  GActionGroup *action_group = gtk_widget_get_action_group(minfo->module->presets_button, "presets");
  minfo->module->set_preferences(menu, action_group, minfo->module);
}

static int _lib_position(const dt_lib_module_t *module)
{
  int pos = module->position ? module->position(module) + 1 : 0;

  gchar *key = _get_lib_view_path(module, NULL, "_position");
  if(key && dt_conf_key_exists(key))
    pos = dt_conf_get_int(key);
  g_free(key);

  return pos;
}

gint dt_lib_sort_plugins(gconstpointer a, gconstpointer b)
{
  return ABS(_lib_position(a)) - ABS(_lib_position(b));
}

uint32_t dt_lib_get_container(dt_lib_module_t *module)
{
  uint32_t container = module->container(module);

  if(_lib_position(module) < 0)
    container = container == DT_UI_CONTAINER_PANEL_LEFT_CENTER
              ? DT_UI_CONTAINER_PANEL_RIGHT_CENTER
              : DT_UI_CONTAINER_PANEL_LEFT_CENTER;

  if(container == DT_UI_CONTAINER_PANEL_RIGHT_CENTER
     && dt_view_get_current() == DT_VIEW_DARKROOM)
    container = DT_UI_CONTAINER_PANEL_LEFT_CENTER;

  return container;
}

/* default has_preset_label  implementation */
static gboolean default_has_preset_label(dt_lib_module_t *self)
{
  return FALSE;
}

/* default expandable implementation */
static gboolean default_expandable(dt_lib_module_t *self)
{
  return TRUE;
}

/* default autoapply implementation */
static gboolean default_preset_autoapply(dt_lib_module_t *self)
{
  return FALSE;
}

/* default gui_update implementation */
static void default_gui_update(dt_lib_module_t *self)
{
}

static int dt_lib_load_module(void *m,
                              const char *libname,
                              const char *module_name)
{
  dt_lib_module_t *module = (dt_lib_module_t *)m;
  g_strlcpy(module->plugin_name, module_name, sizeof(module->plugin_name));

#define INCLUDE_API_FROM_MODULE_LOAD "lib_load_module"
#include "libs/lib_api.h"

  if(((!module->get_params || !module->set_params)
      && (module->legacy_params || module->set_params || module->get_params))
     || (!module->init_presets && module->manage_presets))
  {
    dt_print(DT_DEBUG_ALWAYS, "[dt_lib_load_module] illegal method combination in '%s'",
             module->plugin_name);
  }

  if(!module->get_params || !module->set_params)
  {
    // need all at the same time, or none, note that in this case
    // all the presets for the corresponding module will be deleted.
    // see: dt_lib_init_presets.
    module->legacy_params = NULL;
    module->set_params = NULL;
    module->get_params = NULL;
    module->manage_presets = NULL;
  }

  module->widget = NULL;
  module->expander = NULL;
  module->arrow = NULL;
  module->preset_label = NULL;
  module->reset_button = NULL;
  module->presets_button = NULL;

  module->actions = (dt_action_t){ DT_ACTION_TYPE_LIB,
                                   module->plugin_name,
                                   module->name(module) };

  dt_action_insert_sorted(&darktable.control->actions_libs, &module->actions);
#ifdef USE_LUA
  dt_lua_lib_register(darktable.lua_state.state, module);
#endif

  if(module->init)
    module->init(module);

  return 0;
}

static void *_update_params(dt_lib_module_t *module,
                            const void *const old_params,
                            size_t old_params_size,
                            int old_version,
                            const int target_version,
                            size_t *new_size)
{
  // make a copy of the old params so we can free it in the loop
  void *params = malloc(old_params_size);
  if(params == NULL) return NULL;
  memcpy(params, old_params, old_params_size);
  while(old_version < target_version)
  {
    size_t size;
    int version;
    void *new_params = module->legacy_params(module, params, old_params_size,
                                             old_version, &version, &size);
    free(params);
    if(new_params == NULL) return NULL;
    params = new_params;
    old_version = version;
    old_params_size = size;
  }
  *new_size = old_params_size;
  return params;
}

void dt_lib_init_presets(dt_lib_module_t *module)
{
  // since lighttable presets can't end up in styles or any other
  // place outside of the presets table it is sufficient to update
  // that very table here and assume that everything is up to date
  // elsewhere.  the intended logic is as follows:
  // - no set_params -> delete all presets
  // - op_version >= module_version -> done
  // - op_version < module_version ->
  //   - module has legacy_params -> try to update
  //   - module doesn't have legacy_params -> delete it

  if(module->set_params == NULL)
  {
    dt_presets_delete_module(module->plugin_name);
  }
  else
  {
    // read before updating them: the loop rewrites the rows it reads
    GList *presets = dt_presets_list_stored(module->plugin_name);
    for(const GList *l = presets; l; l = g_list_next(l))
    {
      const dt_presets_params_t *preset = l->data;
      int rowid = preset->rowid;
      int op_version = preset->op_version;
      void *op_params = preset->op_params;
      size_t op_params_size = preset->op_params_size;
      const char *name = preset->name;

      int version = module->version();

      if(op_version < version)
      {
        size_t new_params_size = 0;
        void *new_params = NULL;

        if(module->legacy_params
          && (new_params = _update_params(module, op_params, op_params_size,
                                          op_version, version, &new_params_size)))
        {
          // write the updated preset back to db
          dt_print(DT_DEBUG_ALWAYS,
                   "[lighttable_init_presets] updating '%s' preset '%s'"
                   " from version %d to version %d",
                   module->plugin_name, name, op_version, version);
          dt_presets_upgrade_at_rowid(rowid, version, new_params, new_params_size);
        }
        else
        {
          // delete the preset
          dt_print(DT_DEBUG_ALWAYS,
                   "[lighttable_init_presets] Can't upgrade '%s' preset '%s'"
                   " from version %d to %d, "
                   "no legacy_params() implemented or unable to update",
                   module->plugin_name, name, op_version, version);
          dt_presets_delete_at_rowid(rowid);
        }
        free(new_params);
      }
    }
    g_list_free_full(presets, dt_presets_params_free);
  }

  if(module->init_presets)
    module->init_presets(module);

  DT_CONTROL_SIGNAL_RAISE(DT_SIGNAL_PRESETS_CHANGED,
                          g_strdup(module->plugin_name));

  GList *names = dt_presets_version_names(module->plugin_name, module->version(), TRUE);
  for(const GList *l = names; l; l = g_list_next(l))
    dt_action_define_preset(&module->actions, l->data);
  g_list_free_full(names, g_free);
}

static gboolean _lib_draw_callback(GtkWidget *widget,
                                   gpointer cr,
                                   dt_lib_module_t *self)
{
  dt_lib_gui_update(self);

  return FALSE;
}

void dt_lib_gui_queue_update(dt_lib_module_t *module)
{
  module->gui_uptodate = FALSE;
  gtk_widget_queue_draw(module->widget);
}

void dt_lib_gui_update(dt_lib_module_t *module)
{
  if(module && !module->gui_uptodate)
  {
    module->gui_update(module);
    module->gui_uptodate = TRUE;
  }

  if(module && module->has_preset_label(module))
  {
    dt_lib_module_info_t *mi = _get_module_info_for_module(module);
    gchar *active_preset_name = dt_lib_get_active_preset_name(mi);
    _free_module_info(mi);
    _set_module_preset_label(module, active_preset_name? active_preset_name : "");
    g_free(active_preset_name);
  }
}

static void dt_lib_init_module(void *m)
{
  dt_lib_module_t *module = (dt_lib_module_t *)m;
  dt_lib_init_presets(module);

  // Calling the keyboard shortcut initialization callback if present
  // do not init accelerators if there is no gui
  if(darktable.gui)
  {
    dt_print(DT_DEBUG_PIPE | DT_DEBUG_VERBOSE, "loading utility module : %s",
             module->plugin_name);
    char *msg = g_strdup_printf(_("%s: %s"),
                                _("loading utility modules"),
                                module->name(module));
    dt_splash_screen_set_progress(msg);
    g_free(msg);

    module->gui_init(module);

    if(module->widget)
    {
      g_object_ref_sink(module->widget);
      g_signal_connect(G_OBJECT(module->widget), "draw",
                       G_CALLBACK(_lib_draw_callback), module);
    }
  }
}

static void _lib_unload_module(dt_lib_module_t *module)
{
  if(module->module)
    g_module_close(module->module);
}

static void _lib_gui_reset_callback(GtkGestureSingle *gesture,
                                      gint n_press,
                                      gdouble x,
                                      gdouble y,
                                      dt_lib_module_t *module)
{
  /* the reset action, shared by the module header reset button (wired through
   * its "clicked" signal in _lib_init_header) and the action/shortcut
   * fallback (_action_process, which passes a NULL gesture) */
  module->gui_reset(module);
  if(module->has_preset_label(module))
    gtk_label_set_text(GTK_LABEL(module->preset_label), "");
  if(gesture)
    dt_gui_claim(gesture);
}

static void _lib_gui_reset_button_clicked_callback(GtkWidget *widget,
                                                   gpointer user_data)
{
  /* the reset runs on the button's own "clicked" signal, not on a custom
   * gesture's press/release: gui_reset() may open a modal dialog, and a
   * dialog opened from inside a press handler would interrupt the press
   * dispatch -- the button's gesture only processes the press after the
   * dialog closes and its release was consumed by the dialog's grab, leaving
   * the button stuck in its pressed state.  "clicked" fires once the press
   * and release have both completed, so the dialog cannot split them.
   * (A custom gesture's "released" is equally unusable: the dialog's grab
   * cancels the gesture and dt_gui_connect_click() forwards that
   * cancellation to the released handler, firing the reset twice.) */
  dt_lib_module_t *module = user_data;
  _lib_gui_reset_callback(NULL, 1, 0.0, 0.0, module);
}

static void _presets_popup_callback(GtkWidget *button,
                                    dt_lib_module_t *module)
{
  dt_lib_module_info_t *minfo = _get_module_info_for_module(module);

  const dt_gui_presets_menu_ops_t ops = {
    .data = minfo,
    .hide_defaults_pref = "plugins/lighttable/hide_default_presets",
    .rows = _lib_presets_rows,
    .is_active = _lib_presets_is_active,
    .params_size = minfo->params_size,
    .activate_cb = _menuitem_activate_preset,
    .manage_cb = minfo->module->manage_presets ? _menuitem_manage_presets : NULL,
    .edit_cb = _menuitem_edit_preset,
    .del_cb = _menuitem_delete_preset,
    .store_cb = _menuitem_new_preset,
    .update_cb = _menuitem_update_preset,
    .prefs = minfo->module->set_preferences ? _lib_presets_prefs : NULL,
  };

  darktable.gui->active_popover_menu = dt_gui_presets_popup_menu_show(button, &ops);

  if(button)
    dtgtk_button_set_active(DTGTK_BUTTON(button), FALSE);
}

void dt_lib_gui_set_expanded(dt_lib_module_t *module, const gboolean expanded)
{
  if(!module->expander || !module->arrow) return;

  dtgtk_expander_set_expanded(DTGTK_EXPANDER(module->expander), expanded);

  /* update expander arrow state */
  gint flags = (expanded ? CPF_DIRECTION_DOWN : CPF_DIRECTION_RIGHT);
  dtgtk_button_set_paint(DTGTK_BUTTON(module->arrow), dtgtk_cairo_paint_solid_arrow,
                         flags, NULL);

  darktable.lib->gui_module = expanded ? module : NULL;

  /* if expanded, make sure the module is visible */
  if(module->expanded_state)
    module->expanded_state(module, expanded);

  /* store expanded state of module */
  char var[1024];
  const dt_view_t *current_view = dt_view_manager_get_current_view(darktable.view_manager);
  snprintf(var, sizeof(var), "plugins/%s/%s/expanded",
           current_view->module_name, module->plugin_name);
  dt_conf_set_bool(var, expanded);
}

gboolean dt_lib_gui_get_expanded(dt_lib_module_t *module)
{
  if(!module->expandable(module)) return true;
  if(!module->expander) return true;
  if(!module->widget)
  {
    char var[1024];
    const dt_view_t *current_view =
      dt_view_manager_get_current_view(darktable.view_manager);
    snprintf(var, sizeof(var), "plugins/%s/%s/expanded",
             current_view->module_name, module->plugin_name);
    return dt_conf_get_bool(var);
  }
  return dtgtk_expander_get_expanded(DTGTK_EXPANDER(module->expander));
}

static void _lib_plugin_arrow_button_press_cb(GtkGestureSingle *gesture,
                                                gint n_press,
                                                gdouble x,
                                                gdouble y,
                                                dt_lib_module_t *module)
{
  // every press toggles, n_press > 1 included: the gesture reports a quick
  // second click on the same spot as press 2 of a sequence, and skipping it
  // swallowed a real click. GTK3's button-press-event sent each click as a
  // plain press, plus a separate GDK_2BUTTON_PRESS, the only one skipped
  const guint button = gtk_gesture_single_get_current_button(gesture);
  const GdkModifierType state =
    dt_gui_get_current_event_state(GTK_EVENT_CONTROLLER(gesture));

  if(button == GDK_BUTTON_PRIMARY)
  {
    /* bail out if module is static or disabled */
    if(!module->expandable(module) || (module->arrow && !gtk_widget_is_sensitive(module->arrow))) return;

    if(dt_modifier_is(state, GDK_SHIFT_MASK | GDK_CONTROL_MASK))
      ; // do nothing (for easier dragging)
    /* handle shiftclick on expander, hide all except this */
    else if(!dt_conf_get_bool("lighttable/ui/single_module") !=
            !dt_modifier_is(state, GDK_SHIFT_MASK))
    {
      const dt_view_t *v = dt_view_manager_get_current_view(darktable.view_manager);
      const uint32_t side = dt_lib_get_container(module);
      gboolean all_other_closed = TRUE;
      for(const GList *it = darktable.lib->plugins; it; it = g_list_next(it))
      {
        dt_lib_module_t *m = it->data;

        if(m != module
           && dt_lib_get_container(m) == side
           && m->expandable(m) && dt_lib_is_visible_in_view(m, v))
        {
          all_other_closed = all_other_closed
            && !dtgtk_expander_get_expanded(DTGTK_EXPANDER(m->expander));
          dt_lib_gui_set_expanded(m, FALSE);
        }
      }
      if(all_other_closed)
        dt_lib_gui_set_expanded
          (module,
           !dtgtk_expander_get_expanded(DTGTK_EXPANDER(module->expander)));
      else
        dt_lib_gui_set_expanded(module, TRUE);
    }
    else
    {
      /* else just toggle */
      dt_lib_gui_set_expanded
        (module,
         !dtgtk_expander_get_expanded(DTGTK_EXPANDER(module->expander)));
    }

    //ensure that any gtkentry fields lose focus
    gtk_widget_grab_focus(dt_ui_center(darktable.gui->ui));

    return;
  }
  else if(button == GDK_BUTTON_SECONDARY)
  {
    if(gtk_widget_get_sensitive(module->presets_button))
      _presets_popup_callback(module->presets_button, module);

    return;
  }
}

static void _lib_plugin_header_button_release_cb(GtkGestureSingle *gesture,
                                                    gint n_press,
                                                    gdouble x,
                                                    gdouble y,
                                                    dt_lib_module_t *module)
{
  // ignore clicks on buttons inside the header (presets, reset, enable)
#if GTK_CHECK_VERSION(4, 0, 0)
  /* GTK4 has no gtk_get_event_widget(): find the widget under the release
   * point inside the header instead, and ignore the release if it lands on
   * (or inside) a button -- the gesture receives releases over the whole
   * header, including its child buttons.  The surface-compare alternative
   * is wrong: gdk_event_get_surface() always returns this widget's own
   * surface. */
  GtkWidget *const header = dt_gui_get_widget(gesture);
  GtkWidget *target = gtk_widget_pick(header, x, y, GTK_PICK_DEFAULT);
  for(; target && target != header; target = gtk_widget_get_parent(target))
    if(GTK_IS_BUTTON(target)) return;
#else
  const GdkEvent *event = gtk_gesture_get_last_event(GTK_GESTURE(gesture), NULL);
  if(event && GTK_IS_BUTTON(gtk_get_event_widget((GdkEvent *)event)))
    return;
#endif
  _lib_plugin_arrow_button_press_cb(gesture, n_press, x, y, module);
}

static void show_module_callback(dt_lib_module_t *module)
{
  /* bail out if module is static or disabled */
  if(!module->expandable(module) || (module->arrow && !gtk_widget_is_sensitive(module->arrow))) return;

  if(dt_conf_get_bool("lighttable/ui/single_module"))
  {
    const dt_view_t *v = dt_view_manager_get_current_view(darktable.view_manager);
    const uint32_t side = dt_lib_get_container(module);
    gboolean all_other_closed = TRUE;
    for(const GList *it = darktable.lib->plugins; it; it = g_list_next(it))
    {
      dt_lib_module_t *m = it->data;

      if(m != module
         && dt_lib_get_container(m) == side
         && m->expandable(m)
         && dt_lib_is_visible_in_view(m, v))
      {
        all_other_closed = all_other_closed
          && !dtgtk_expander_get_expanded(DTGTK_EXPANDER(m->expander));
        dt_lib_gui_set_expanded(m, FALSE);
      }
    }
    if(all_other_closed)
      dt_lib_gui_set_expanded
        (module, !dtgtk_expander_get_expanded(DTGTK_EXPANDER(module->expander)));
    else
      dt_lib_gui_set_expanded(module, TRUE);
  }
  else
  {
    /* else just toggle */
    dt_lib_gui_set_expanded
      (module, !dtgtk_expander_get_expanded(DTGTK_EXPANDER(module->expander)));
  }
}

static void _header_enter_notify_callback(GtkEventControllerMotion *controller,
                                            gdouble x,
                                            gdouble y,
                                            gpointer user_data)
{
  darktable.control->element = GPOINTER_TO_INT(user_data);
}

static void _body_enter_callback(GtkEventControllerMotion *controller,
                                   gdouble x,
                                   gdouble y,
                                   dt_lib_module_t *module)
{
  // set focused module when entering (not when opening popup)
  // only act on non-inferior (not from child) normal crossings
  GdkEvent *event = dt_gui_get_current_event(GTK_EVENT_CONTROLLER(controller));
  if(event)
  {
#if GTK_CHECK_VERSION(4, 0, 0)
    if(gdk_crossing_event_get_detail(event) != GDK_NOTIFY_INFERIOR
       && gdk_crossing_event_get_mode(event) == GDK_CROSSING_NORMAL)
#else
    if(event->crossing.detail != GDK_NOTIFY_INFERIOR
       && event->crossing.mode == GDK_CROSSING_NORMAL)
#endif
      darktable.lib->gui_module = module;
#if !GTK_CHECK_VERSION(4, 0, 0)
    gdk_event_free(event);
#endif
  }
}

static void _body_leave_callback(GtkEventControllerMotion *controller,
                                  dt_lib_module_t *module)
{
  // clear focused module when leaving
  // only act on non-inferior (not to child) normal crossings
  GdkEvent *event = dt_gui_get_current_event(GTK_EVENT_CONTROLLER(controller));
  if(event)
  {
#if GTK_CHECK_VERSION(4, 0, 0)
    if(gdk_crossing_event_get_detail(event) != GDK_NOTIFY_INFERIOR
       && gdk_crossing_event_get_mode(event) == GDK_CROSSING_NORMAL)
#else
    if(event->crossing.detail != GDK_NOTIFY_INFERIOR
       && event->crossing.mode == GDK_CROSSING_NORMAL)
#endif
      darktable.lib->gui_module = NULL;
#if !GTK_CHECK_VERSION(4, 0, 0)
    gdk_event_free(event);
#endif
  }
}

static gboolean _on_drag_motion(GtkWidget *widget,
                                GdkDragContext *dc,
                                gint x, gint y, guint time,
                                dt_lib_module_t *dest)
{
  dt_lib_module_t *src = NULL;
  GtkContainer *src_panel = NULL, *dest_panel = NULL;
  gboolean below = TRUE;
  int dest_pos = 0;

  if(GTK_IS_BOX(dc))
  {
    // propagated from empty panel handler in gtk.c
    src = dest;
    src_panel = GTK_CONTAINER(gtk_widget_get_parent(src->expander));
    dest_panel = GTK_CONTAINER(dc);
  }
  else
  {
    dtgtk_expander_set_drag_hover(DTGTK_EXPANDER(widget), FALSE, TRUE, time);
    gdk_drag_status(dc, 0, time);

    GtkWidget *src_header = gtk_drag_get_source_widget(dc);
    if(!src_header) return TRUE;
    GtkWidget *src_expander = gtk_widget_get_ancestor(src_header, DTGTK_TYPE_EXPANDER);

    for(GList *lib = darktable.lib->plugins; lib; lib = lib->next)
      if(((dt_lib_module_t *)lib->data)->expander == src_expander)
        src = lib->data;

    if(!src_expander || !src || dest == src ) return TRUE;

    src_panel = GTK_CONTAINER(gtk_widget_get_parent(src->expander));
    dest_panel = GTK_CONTAINER(gtk_widget_get_parent(dest->expander));

    int src_pos = G_MAXINT;
    if(dest_panel == src_panel)
      gtk_container_child_get(src_panel, src->expander, "position", &src_pos, NULL);
    gtk_container_child_get(dest_panel, dest->expander, "position", &dest_pos, NULL);

    GtkDarktableExpander *exp = DTGTK_EXPANDER(dest->expander);
    int header_height = gtk_widget_get_allocated_height(dtgtk_expander_get_header(exp));
    below = y > (ABS(dest_pos - src_pos) == 1 && !dtgtk_expander_get_expanded(exp)
                 ? header_height / 2
                 : dest_pos < src_pos
                 ? gtk_widget_get_allocated_height(widget) - header_height
                 : header_height);

    if(below) dest_pos++;
    if(dest_pos > src_pos) dest_pos--;
    if(dest_pos == src_pos) return TRUE;

    if(x != DND_DROP)
    {
      dtgtk_expander_set_drag_hover(DTGTK_EXPANDER(widget), TRUE, below, time);
      gdk_drag_status(dc, GDK_ACTION_COPY, time);

      return TRUE;
    }
  }

  GtkBox *dest_box = GTK_BOX(dest_panel);
  if(dest_panel != src_panel)
  {
    g_object_ref(src->expander);
    gtk_container_remove(src_panel, src->expander);
    gtk_box_pack_start(dest_box, src->expander, FALSE, FALSE, 0);
  }
  gtk_box_reorder_child(dest_box, src->expander, dest_pos);

  GList **list = &darktable.lib->plugins;
  *list = g_list_remove(*list, src);

  GList *dest_list = g_list_find(*list, dest);
  if(below)
    dest = dest_list && dest_list->prev ? dest_list->prev->data : NULL;
  else
    dest_list = dest_list->next;

  int new_pos = dest ? ABS(_lib_position(dest)) + 1 : 1;
  int old_pos = dest_box != dt_ui_get_container(darktable.gui->ui, src->container(src)) ? -1 : +1;
  dt_lib_module_t *cur = src;
  while(new_pos >= ABS(old_pos))
  {
    gchar *key = _get_lib_view_path(cur, NULL, "_position");
    dt_conf_set_int(key, old_pos < 0 ? -new_pos : new_pos);
    g_free(key);

    if(!dest_list) break;

    new_pos++;
    cur = dest_list->data;
    old_pos = _lib_position(cur);
    dest_list = dest_list->next;
  }

  *list = g_list_insert_sorted(*list, src, dt_lib_sort_plugins);

  return TRUE;
}

static gboolean _on_drag_drop(GtkWidget *widget,
                              GdkDragContext *dc,
                              gint x, gint y, guint time,
                              dt_lib_module_t *dest)
{
  return _on_drag_motion(widget, dc, DND_DROP, y, time, dest);
}

GtkWidget *dt_lib_gui_get_expander(dt_lib_module_t *module)
{
  /* check if module is expandable */
  if(!module->expandable(module))
  {
    /* Non-expandable libs (modulegroups, ...) keep their whole widget -- and
     * with it the presets button -- outside an expander, and that widget
     * survives view switches: dt_lib_gui_get_expander() runs once per switch,
     * so the "clicked" wiring and the action registration below must happen
     * only on the first call, or every lighttable<->darkroom round trip would
     * stack one more popup and one more action on the button.  Registering the
     * button with the lib actions lets shortcuts and the action fallback
     * (DT_ACTION_ELEMENT_PRESETS in _action_process) reach it, like the
     * expandable header path does.  GtkButton::clicked is unchanged on GTK4
     * and dt_action_define() is qdata-guarded, so this needs no
     * #if GTK_CHECK_VERSION split. */
    if(module->presets_button
       && !g_object_get_data(G_OBJECT(module->presets_button),
                             "dt-lib-presets-wired"))
    {
      g_signal_connect(G_OBJECT(module->presets_button), "clicked",
                       G_CALLBACK(_presets_popup_callback), module);
      dt_action_define(&module->actions, NULL, NULL, module->presets_button, NULL);
      g_object_set_data(G_OBJECT(module->presets_button),
                        "dt-lib-presets-wired", GINT_TO_POINTER(TRUE));
    }
    module->expander = NULL;
    return NULL;
  }

  GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
  gtk_widget_set_name(GTK_WIDGET(header), "module-header");

  GtkWidget *expander = dtgtk_expander_new(header, module->widget);
  GtkWidget *header_evb = dtgtk_expander_get_header_event_box(DTGTK_EXPANDER(expander));
  GtkWidget *body_evb = dtgtk_expander_get_body_event_box(DTGTK_EXPANDER(expander));
  GtkWidget *pluginui_frame = dtgtk_expander_get_frame(DTGTK_EXPANDER(expander));

  dt_ui_container_t container = module->container(module);
  if(container == DT_UI_CONTAINER_PANEL_LEFT_CENTER || container == DT_UI_CONTAINER_PANEL_RIGHT_CENTER)
  {
    static const GtkTargetEntry target_list[] = { { "lib", GTK_TARGET_SAME_APP, DND_TARGET_LIB } };

    gtk_drag_source_set(header_evb, GDK_BUTTON1_MASK, target_list, 1, GDK_ACTION_COPY);
    gtk_drag_dest_set(expander, GTK_DEST_DEFAULT_DROP | GTK_DEST_DEFAULT_HIGHLIGHT, target_list, 1, GDK_ACTION_COPY);
    g_signal_connect(expander, "drag-motion", G_CALLBACK(_on_drag_motion), module);
    g_signal_connect(expander, "drag-drop", G_CALLBACK(_on_drag_drop), module);
  }

  /* setup the header box */
  dt_gui_connect_click(header_evb, NULL, _lib_plugin_header_button_release_cb, module);
  dt_gui_connect_motion(header_evb, NULL, _header_enter_notify_callback, NULL, GINT_TO_POINTER(DT_ACTION_ELEMENT_SHOW));

  /* (un)focus module when entering/leaving body */
  dt_gui_connect_motion(body_evb, NULL, _body_enter_callback, _body_leave_callback, module);

  /*
   * initialize the header widgets
   */
  /* add the expand indicator icon */
  module->arrow = dtgtk_button_new_full(dtgtk_cairo_paint_solid_arrow, 0, NULL,
      &(dtgtk_button_config_t){
        .tooltip = _("show module"),
        .action = &module->actions,
      });

  dt_gui_connect_click_all(module->arrow, _lib_plugin_arrow_button_press_cb, NULL, module);
  gtk_box_pack_start(GTK_BOX(header), module->arrow, FALSE, FALSE, 0);

  /* add module label */
  GtkWidget *label = gtk_label_new("");
  GtkWidget *label_evb = gtk_event_box_new();
  gtk_container_add(GTK_CONTAINER(label_evb), label);
  gchar *mname = g_markup_escape_text(module->name(module), -1);
  gtk_label_set_markup(GTK_LABEL(label), mname);
  if(module->description)
    gtk_widget_set_tooltip_text(header, module->description(module));
  else
    gtk_widget_set_tooltip_text(header, mname);
  g_free(mname);
  gtk_label_set_ellipsize(GTK_LABEL(label), PANGO_ELLIPSIZE_END);
  g_object_set(G_OBJECT(label), "halign", GTK_ALIGN_START, "xalign", 0.0, (gchar *)0);
  gtk_widget_set_name(label, "lib-panel-label");
  dt_action_define(&module->actions, NULL, NULL, label_evb, NULL);
  gtk_box_pack_start(GTK_BOX(header), label_evb, FALSE, FALSE, 0);

  /* add preset label */
  module->preset_label = gtk_label_new(NULL);
  gtk_widget_set_name(module->preset_label, "lib-module-name");
  gtk_label_set_ellipsize(GTK_LABEL(module->preset_label), PANGO_ELLIPSIZE_MIDDLE);
  gtk_widget_set_valign(module->preset_label, GTK_ALIGN_BASELINE);
  g_object_set(G_OBJECT(module->preset_label), "xalign", 0.0, (gchar *)0);
  gtk_box_pack_start(GTK_BOX(header), module->preset_label, FALSE, FALSE, 0);

  /* add preset button if module has implementation */
  module->presets_button = dtgtk_button_new_full(dtgtk_cairo_paint_presets, 0, NULL,
      &(dtgtk_button_config_t){
        .tooltip = _("presets and preferences"),
        .action = &module->actions,
        .clicked_cb = G_CALLBACK(_presets_popup_callback),
        .clicked_data = module,
      });
  dt_gui_connect_motion(module->presets_button, NULL, _header_enter_notify_callback, NULL, GINT_TO_POINTER(DT_ACTION_ELEMENT_PRESETS));
  if(!module->get_params
     && !module->set_preferences)
    gtk_widget_set_sensitive(GTK_WIDGET(module->presets_button), FALSE);
  gtk_box_pack_end(GTK_BOX(header), module->presets_button, FALSE, FALSE, 0);

  /* add reset button if module has implementation */
  module->reset_button = dtgtk_button_new_full(dtgtk_cairo_paint_reset, 0, NULL,
      &(dtgtk_button_config_t){
        .action = &module->actions,
        .clicked_cb = G_CALLBACK(_lib_gui_reset_button_clicked_callback),
        .clicked_data = module,
      });
  /* "clicked" rather than a custom gesture: see _lib_gui_reset_button_clicked_callback */
  dt_gui_connect_motion(module->reset_button, NULL, _header_enter_notify_callback, NULL, GINT_TO_POINTER(DT_ACTION_ELEMENT_RESET));
  if(!module->gui_reset) gtk_widget_set_sensitive(module->reset_button, FALSE);
  gtk_box_pack_end(GTK_BOX(header), module->reset_button, FALSE, FALSE, 0);

  /* add button box - for module's specific action button */
  if(module->gui_tool_box)
    gtk_box_pack_end(GTK_BOX(header), module->gui_tool_box(module), FALSE, FALSE, 0);

  gtk_widget_show_all(expander);

  if(module->widget)
  {
    dt_gui_add_class(module->widget, "dt_plugin_ui_main");
    gtk_widget_set_hexpand(module->widget, FALSE);
    gtk_widget_set_vexpand(module->widget, FALSE);
  }
  dt_gui_add_class(pluginui_frame, "dt_plugin_ui");
  module->expander = expander;

  // get active preset and set preset_label
  if(module->has_preset_label && module->has_preset_label(module))
  {
    dt_lib_module_info_t *mi = _get_module_info_for_module(module);
    gchar *preset_name = dt_lib_get_active_preset_name(mi);
    if(preset_name)
    {
      _set_module_preset_label(mi->module, preset_name);
      g_free(preset_name);
    }
    _free_module_info(mi);
  }

  return module->expander;
}

void dt_lib_gui_set_label(dt_lib_module_t *module,
                          const char *label)
{
  if(!module->expander) return;
  GtkWidget *header = DTGTK_EXPANDER(module->expander)->header;
  gtk_box_set_center_widget(GTK_BOX(header), gtk_label_new(label));
  gtk_widget_show_all(header);
}

static void _preferences_changed(gpointer instance, gpointer self)
{
  // reload presets if they are based on the actual workflow which
  // could have been changed after editing the preferences.

  dt_lib_t *lib = (dt_lib_t *)self;

  GList *p = lib->plugins;

  while(p)
  {
    dt_lib_module_t *lmod = p->data;

    if(lmod->pref_based_presets)
      dt_lib_init_presets(lmod);

    p = g_list_next(p);
  }
}

void dt_lib_init(dt_lib_t *lib)
{
  // Setting everything to null initially
  memset(lib, 0, sizeof(dt_lib_t));
  darktable.lib->plugins = dt_module_load_modules("/plugins/lighttable",
                                                  sizeof(dt_lib_module_t),
                                                  dt_lib_load_module,
                                                  dt_lib_init_module,
                                                  dt_lib_sort_plugins);
  DT_CONTROL_SIGNAL_CONNECT(DT_SIGNAL_PREFERENCES_CHANGE, _preferences_changed, lib);
}

void dt_lib_cleanup(dt_lib_t *lib)
{
  DT_CONTROL_SIGNAL_DISCONNECT(_preferences_changed, lib);
  while(lib->plugins)
  {
    dt_lib_module_t *module = lib->plugins->data;
    if(module)
    {
      if(module->data != NULL)
      {
        DT_CONTROL_SIGNAL_DISCONNECT_ALL(module, module->plugin_name);
        module->gui_cleanup(module);
        module->data = NULL;
      }
      _lib_unload_module(module);
      free(module);
    }
    lib->plugins = g_list_delete_link(lib->plugins, lib->plugins);
  }
}

void dt_lib_presets_add(const char *name,
                        const char *plugin_name,
                        const int32_t version,
                        const void *params,
                        const int32_t params_size,
                        const gboolean readonly,
                        const dt_gui_presets_format_flag_t format)
{
  dt_lib_presets_remove(name, plugin_name, version);
  dt_presets_add_lib(name, plugin_name, version, params, params_size, readonly, format);
}

static gchar *_get_lib_view_path(const dt_lib_module_t *module,
                                 const dt_view_t *cv,
                                 char *suffix)
{
  if(!cv && darktable.view_manager)
    cv = dt_view_manager_get_current_view(darktable.view_manager);
  if(!cv) return NULL;
  // in lighttable, we store panels states per layout
  char lay[32] = "";
  if(g_strcmp0(cv->module_name, "lighttable") == 0 && !module->expandable((gpointer)module))
  {
    if(dt_view_lighttable_preview_state(darktable.view_manager))
      g_snprintf(lay, sizeof(lay), "preview/");
    else
      g_snprintf(lay, sizeof(lay), "%d/",
                 dt_view_lighttable_get_layout(darktable.view_manager));
  }
  else if(g_strcmp0(cv->module_name, "darkroom") == 0)
  {
    g_snprintf(lay, sizeof(lay), "%d/",
               dt_view_darkroom_get_layout(darktable.view_manager));
  }

  return g_strdup_printf("plugins/%s/%s%s%s", cv->module_name,
                         lay, module->plugin_name, suffix);
}

gboolean dt_lib_is_visible(dt_lib_module_t *module)
{
  return dt_lib_is_visible_in_view(module, dt_view_manager_get_current_view(darktable.view_manager));
}

void dt_lib_set_visible(dt_lib_module_t *module,
                        const gboolean visible)
{
  gchar *key = _get_lib_view_path(module, NULL, "_visible");
  GtkWidget *widget;
  if(key)
    dt_conf_set_bool(key, visible);
  g_free(key);

  if(module->widget)
  {
    if(module->expander)
      widget = module->expander;
    else
      widget = module->widget;

    if(visible)
      gtk_widget_show(GTK_WIDGET(widget));
    else
      gtk_widget_hide(GTK_WIDGET(widget));
  }
}

gchar *dt_lib_get_localized_name(const gchar *plugin_name)
{
  // Prepare mapping op -> localized name
  static GHashTable *module_names = NULL;
  if(module_names == NULL)
  {
    module_names = g_hash_table_new(g_str_hash, g_str_equal);
    for(const GList *lib = darktable.lib->plugins; lib; lib = g_list_next(lib))
    {
      dt_lib_module_t *module = lib->data;
      g_hash_table_insert(module_names, module->plugin_name,
                          g_strdup(module->name(module)));
    }
  }

  return (gchar *)g_hash_table_lookup(module_names, plugin_name);
}

void dt_lib_colorpicker_set_box_area(dt_lib_t *lib,
                                     const dt_pickerbox_t box)
{
  if(!lib || !lib->proxy.colorpicker.module || !lib->proxy.colorpicker.set_sample_box_area) return;
  lib->proxy.colorpicker.set_sample_box_area(lib->proxy.colorpicker.module, box);
  gtk_widget_grab_focus(dt_ui_center(darktable.gui->ui));
}

void dt_lib_colorpicker_set_point(dt_lib_t *lib,
                                  const float pos[2])
{
  if(!lib || !lib->proxy.colorpicker.module || !lib->proxy.colorpicker.set_sample_point) return;
  lib->proxy.colorpicker.set_sample_point(lib->proxy.colorpicker.module, pos);
  gtk_widget_grab_focus(dt_ui_center(darktable.gui->ui));
}

/* clear color picker pos */
void dt_lib_colorpicker_reset_box_area(dt_pickerbox_t box)
{
  dt_boundingbox_t reset = { 0.02f, 0.02f, 0.98f, 0.98f };
  dt_color_picker_backtransform_box(darktable.develop, 2, reset, box);
}

void dt_lib_colorpicker_reset_point(dt_pickerpoint_t pos)
{
  dt_boundingbox_t reset = { 0.5f, 0.5f };
  dt_color_picker_backtransform_box(darktable.develop, 1, reset, pos);
}

void dt_lib_colorpicker_setup(dt_lib_t *lib,
                              const gboolean denoise,
                              const gboolean pick_output)

{
  if(!lib || !lib->proxy.colorpicker.module || !lib->proxy.colorpicker.setup_sample) return;
  lib->proxy.colorpicker.setup_sample(lib->proxy.colorpicker.module, denoise, pick_output);
}

void dt_lib_histogram_get_harmony(dt_lib_t *lib, dt_color_harmony_guide_t *guide)
{
  if(!lib || !lib->proxy.histogram.module || !lib->proxy.histogram.get_harmony) return;
  lib->proxy.histogram.get_harmony(lib->proxy.histogram.module, guide);
}

void dt_lib_histogram_set_harmony(dt_lib_t *lib, const dt_color_harmony_guide_t *guide)
{
  if(!lib || !lib->proxy.histogram.module || !lib->proxy.histogram.set_harmony) return;
  lib->proxy.histogram.set_harmony(lib->proxy.histogram.module, guide);
}

void dt_lib_histogram_set_harmony_callback(dt_lib_t *lib,
    void (*cb)(const dt_color_harmony_guide_t *, void *), void *user_data)
{
  if(!lib || !lib->proxy.histogram.module || !lib->proxy.histogram.set_harmony_callback) return;
  lib->proxy.histogram.set_harmony_callback(lib->proxy.histogram.module, cb, user_data);
}

void dt_lib_histogram_set_scope(dt_lib_t *lib, int scope)
{
  if(!lib || !lib->proxy.histogram.module || !lib->proxy.histogram.set_scope) return;
  lib->proxy.histogram.set_scope(lib->proxy.histogram.module, scope);
}

void dt_lib_histogram_set_type(dt_lib_t *lib, int type)
{
  if(!lib || !lib->proxy.histogram.module || !lib->proxy.histogram.set_type) return;
  lib->proxy.histogram.set_type(lib->proxy.histogram.module, type);
}

void dt_lib_histogram_get_sector_angles(dt_lib_t *lib,
                                        const dt_color_harmony_type_t type,
                                        const int rotation,
                                        float *angles,
                                        int *n)
{
  if(n) *n = 0;
  if(!lib || !lib->proxy.histogram.module || !lib->proxy.histogram.get_sector_angles) return;
  lib->proxy.histogram.get_sector_angles(lib->proxy.histogram.module, type, rotation, angles, n);
}

dt_lib_module_t *dt_lib_get_module(const char *name)
{
  if(!darktable.lib) return NULL;
  /* hide/show modules as last config */
  for(GList *iter = darktable.lib->plugins; iter; iter = g_list_next(iter))
  {
    dt_lib_module_t *plugin = iter->data;
    if(strcmp(plugin->plugin_name, name) == 0)
      return plugin;
  }

  return NULL;
}

gboolean dt_lib_presets_can_autoapply(dt_lib_module_t *mod)
{
  return mod->preset_autoapply(mod);
}

void dt_lib_reset_preset_label(dt_lib_module_t *mod)
{
  if(!mod || !mod->has_preset_label(mod))
    return;

  gtk_label_set_text(GTK_LABEL(mod->preset_label), "");
}

static float _action_process(gpointer target,
                             const dt_action_element_t element,
                             const dt_action_effect_t effect,
                             const float move_size)
{
  dt_lib_module_t *module = target;

  if(DT_PERFORM_ACTION(move_size))
  {
    switch(element)
    {
    case DT_ACTION_ELEMENT_SHOW:
      if(DT_ACTION_TOGGLE_NEEDED(effect, move_size,
           dtgtk_expander_get_expanded(DTGTK_EXPANDER(module->expander))))
        show_module_callback(module);
      break;
    case DT_ACTION_ELEMENT_RESET:
      if(module->gui_reset)
        _lib_gui_reset_callback(NULL, 1, 0.0, 0.0, module);
      break;
    case DT_ACTION_ELEMENT_PRESETS:
      if(module->get_params || module->set_preferences)
        _presets_popup_callback(module->presets_button, module);
      break;
    }
  }

  return element == DT_ACTION_ELEMENT_SHOW
    && dtgtk_expander_get_expanded(DTGTK_EXPANDER(module->expander));
}

static const dt_action_element_def_t _action_elements[]
  = { { N_("show"), dt_action_effect_toggle },
      { N_("reset"), dt_action_effect_activate },
      { N_("presets"), dt_action_effect_presets },
      { NULL } };

static const dt_shortcut_fallback_t _action_fallbacks[]
  = { { .element = DT_ACTION_ELEMENT_SHOW,
        .button = DT_SHORTCUT_LEFT },
      { .element = DT_ACTION_ELEMENT_RESET,
        .button = DT_SHORTCUT_LEFT,
        .click = DT_SHORTCUT_DOUBLE },
      { .element = DT_ACTION_ELEMENT_PRESETS,
        .button = DT_SHORTCUT_RIGHT },
      { } };

const dt_action_def_t dt_action_def_lib
  = { N_("utility module"),
      _action_process,
      _action_elements,
      _action_fallbacks };

gboolean dt_handle_dialog_enter(GtkEventControllerKey *key,
                                guint keyval,
                                guint keycode,
                                GdkModifierType state,
                                gpointer data)
{
  if(keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter)
  {
    gtk_dialog_response(GTK_DIALOG(gtk_event_controller_get_widget(GTK_EVENT_CONTROLLER(key))),
                        GTK_RESPONSE_ACCEPT);
    return TRUE;
  }
  return FALSE;
}

// 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