lib.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2009-2011, 2013-2014 johannes hanika.
    Copyright (C) 2010-2012 Henrik Andersson.
    Copyright (C) 2010 Richard Hughes.
    Copyright (C) 2010 Stuart Henderson.
    Copyright (C) 2010-2018 Tobias Ellinghaus.
    Copyright (C) 2011 Antony Dovgal.
    Copyright (C) 2011 Brian Teague.
    Copyright (C) 2011-2012, 2014-2015 Jérémy Rosen.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2011-2012 Ulrich Pegelow.
    Copyright (C) 2012 Ivan Tarozzi.
    Copyright (C) 2012 Petr Styblo.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2013, 2018-2022 Pascal Obry.
    Copyright (C) 2013-2017 Roman Lebedev.
    Copyright (C) 2013 Simon Spannagel.
    Copyright (C) 2014 Edouard Gomez.
    Copyright (C) 2014 Pascal de Bruijn.
    Copyright (C) 2017, 2021 Dan Torop.
    Copyright (C) 2017-2018 parafin.
    Copyright (C) 2019-2022 Aldric Renaudin.
    Copyright (C) 2019, 2022-2023, 2025-2026 Aurélien PIERRE.
    Copyright (C) 2019 Edgardo Hoszowski.
    Copyright (C) 2019 Heiko Bauke.
    Copyright (C) 2019-2022 Philippe Weyland.
    Copyright (C) 2019 Sam Smith.
    Copyright (C) 2020 Chris Elston.
    Copyright (C) 2020-2022 Diederik Ter Rahe.
    Copyright (C) 2020-2021 Hubert Kowalski.
    Copyright (C) 2020 Marco.
    Copyright (C) 2020 Matt Maguire.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2021 Arnaud TANGUY.
    Copyright (C) 2021 Bill Ferguson.
    Copyright (C) 2021 Marco Carrarini.
    Copyright (C) 2021-2022 Nicolas Auffray.
    Copyright (C) 2021 wpferguson.
    Copyright (C) 2022 Martin Bařinka.
    
    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/sentry.h"
#include "widgets/widget_settings.h"
#include "common/telemetry.h"
#include "widgets/gdkkeys.h"
#include "libs/lib.h"
#include "views/view.h"
#include "database/preset_repository.h"
#include "system/macros.h"
#include "common/module.h"
#include "common/module_versioning.h" // dt_version(), used by libs/lib_api.h below
#include "common/conf.h"
#include "control/control.h"
#include "develop/develop.h"
#include "widgets/button.h"
#include "widgets/expander.h"
 
#include "gui/color_picker_proxy.h"
#include "libs/colorpicker.h"
#include "gui/application.h"
#include "gui/presets.h"
#ifdef GDK_WINDOWING_QUARTZ
#include "osx/osx.h"
#endif
#include <stdbool.h>
#include <stdlib.h>
#include "widgets/label.h"
#include "widgets/popup.h"
#include "widgets/widget_style.h"
#include "control/signal.h"
 
 
typedef enum dt_action_element_lib_t
{
  DT_ACTION_ELEMENT_SHOW = 0,
  DT_ACTION_ELEMENT_RESET = 1,
  DT_ACTION_ELEMENT_PRESETS = 2,
} dt_action_element_lib_t;
 
typedef struct dt_lib_module_info_t
{
  char *plugin_name;
  int32_t version;
  char *params;
  int params_size;
  dt_lib_module_t *module;
} dt_lib_module_info_t;
 
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;
 
gboolean dt_lib_is_visible_in_view(dt_lib_module_t *module, const dt_view_t *view)
{
  // No view means nothing is visible in it. Callers in views/view.c guard before calling,
  // but _toggle_expanded() passes dt_view_manager_get_current_view() straight through, and
  // that is NULL mid-switch -- the loop below reads view->module_name.
  if(IS_NULL_PTR(view)) return FALSE;
 
  if(!module->views)
  {
    fprintf(stderr, "module %s doesn't have views flags\n", module->name(module));
    return FALSE;
  }
 
  const char **views = module->views(module);
  for(const char **iter = views; *iter; iter++)
  {
    if(!strcmp(*iter, "*") || !strcmp(*iter, view->module_name)) return TRUE;
  }
  return FALSE;
}
 
static void dt_lib_unload_module(dt_lib_module_t *module);
 
static gchar *get_active_preset_name(dt_lib_module_info_t *minfo)
{
  gchar *name = NULL;
 
  // collect all presets for op from db, and find the one whose params we are showing
  GList *presets = dt_preset_repository_list_for_module(minfo->plugin_name, minfo->version,
                                                        FALSE, FALSE);
  for(GList *l = presets; l; l = g_list_next(l))
  {
    const dt_module_preset_t *p = (const dt_module_preset_t *)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_module_preset_free);
  return name;
}
 
static void edit_preset(const char *name_in, dt_lib_module_info_t *minfo)
{
  // get the original name of the preset
  gchar *name = NULL;
  if(IS_NULL_PTR(name_in))
  {
    name = get_active_preset_name(minfo);
    if(IS_NULL_PTR(name)) return;
  }
  else
    name = g_strdup(name_in);
 
  // find the rowid of the preset
  const int rowid = dt_preset_repository_find_rowid(minfo->plugin_name, minfo->version, name);
 
  // if we don't have a valid rowid, just exit, there's a problem !
  if(rowid < 0) return;
 
  GtkWidget *window = dt_gui_main_window();
  dt_gui_presets_show_edit_dialog(name, minfo->plugin_name, rowid, NULL, NULL, TRUE, TRUE, FALSE,
                                  GTK_WINDOW(window));
}
 
static void menuitem_update_preset(GtkMenuItem *menuitem, dt_lib_module_info_t *minfo)
{
  char *name = g_object_get_data(G_OBJECT(menuitem), "dt-preset-name");
 
  gint res = GTK_RESPONSE_YES;
 
  if(dt_conf_get_bool("plugins/lighttable/preset/ask_before_delete_preset"))
  {
    GtkWidget *window = dt_gui_main_window();
    GtkWidget *dialog
      = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
                               GTK_BUTTONS_YES_NO, _("do you really want to update the preset `%s'?"), name);
#ifdef GDK_WINDOWING_QUARTZ
    dt_osx_disallow_fullscreen(dialog);
#endif
    gtk_window_set_title(GTK_WINDOW(dialog), _("update preset?"));
    res = gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
  }
 
  if(res == GTK_RESPONSE_YES)
  {
    // commit all the module fields
    dt_preset_repository_update_module_params(minfo->plugin_name, name, minfo->version,
                                              minfo->params, minfo->params_size);
    DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_PRESETS_CHANGED,
                                  g_strdup(minfo->plugin_name));
  }
}
 
static void menuitem_new_preset(GtkMenuItem *menuitem, dt_lib_module_info_t *minfo)
{
  dt_lib_presets_remove(_("new preset"), minfo->plugin_name, minfo->version);
 
  // add new preset
  dt_preset_repository_add_module_preset(_("new preset"), minfo->plugin_name, minfo->version,
                                         minfo->params, minfo->params_size);
  // create a shortcut for the new entry
 
  // then show edit dialog
  edit_preset(_("new preset"), minfo);
}
 
static void menuitem_edit_preset(GtkMenuItem *menuitem, dt_lib_module_info_t *minfo)
{
  edit_preset(NULL, minfo);
}
 
static void menuitem_manage_presets(GtkMenuItem *menuitem, dt_lib_module_info_t *minfo)
{
  if(minfo->module->manage_presets) minfo->module->manage_presets(minfo->module);
}
 
static void menuitem_delete_preset(GtkMenuItem *menuitem, dt_lib_module_info_t *minfo)
{
  gchar *name = get_active_preset_name(minfo);
  if(IS_NULL_PTR(name)) return;
 
  gint res = GTK_RESPONSE_YES;
 
  if(dt_conf_get_bool("plugins/lighttable/preset/ask_before_delete_preset"))
  {
    GtkWidget *window = dt_gui_main_window();
    GtkWidget *dialog
      = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
                               GTK_BUTTONS_YES_NO, _("do you really want to delete the preset `%s'?"), name);
#ifdef GDK_WINDOWING_QUARTZ
    dt_osx_disallow_fullscreen(dialog);
#endif
    gtk_window_set_title(GTK_WINDOW(dialog), _("delete preset?"));
    res = gtk_dialog_run(GTK_DIALOG(dialog));
    gtk_widget_destroy(dialog);
  }
 
  if(res == GTK_RESPONSE_YES)
  {
    dt_lib_presets_remove(name, minfo->plugin_name, minfo->version);
 
    DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_PRESETS_CHANGED,
                                  g_strdup(minfo->plugin_name));
  }
  dt_free(name);
}
 
gchar *dt_lib_presets_duplicate(const gchar *preset, const gchar *module_name, int module_version)
{
  // find the new name
  int i = 0;
  gboolean ko = TRUE;
  while(ko)
  {
    i++;
    gchar *tx = g_strdup_printf("%s_%d", preset, i);
    if(!dt_preset_repository_module_preset_exists(module_name, module_version, tx)) ko = FALSE;
    dt_free(tx);
  }
  gchar *nname = g_strdup_printf("%s_%d", preset, i);
 
  // and we duplicate the entry
  dt_preset_repository_duplicate_module_preset(module_name, module_version, preset, nname);
 
  return nname;
}
 
void dt_lib_presets_remove(const gchar *preset, const gchar *module_name, int module_version)
{
  dt_preset_repository_delete_module_preset(module_name, module_version, preset);
}
 
gboolean dt_lib_presets_apply(const gchar *preset, const gchar *module_name, int module_version)
{
  gboolean ret = TRUE;
  dt_module_preset_t *p = dt_preset_repository_get_module_preset(module_name, module_version, preset);
 
  int res = 0;
  if(p)
  {
    const void *blob = p->op_params;
    int length = p->op_params_size;
    int writeprotect = p->writeprotect;
    if(blob)
    {
      for(const GList *it = dt_lib_get_global()->plugins; it; it = g_list_next(it))
      {
        dt_lib_module_t *module = (dt_lib_module_t *)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);
          dt_free(tx);
          res = module->set_params(module, blob, length);
          break;
        }
      }
    }
 
    if(!writeprotect) dt_gui_store_last_preset(preset);
  }
  else
    ret = FALSE;
  dt_module_preset_free(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, int module_version, const gchar *newname,
                           const gchar *desc, const void *params, const int32_t params_size)
{
  dt_preset_repository_rename_module_preset(module_name, module_version, preset, newname,
                                            desc, params, params_size);
}
 
static void pick_callback(GtkMenuItem *menuitem, dt_lib_module_info_t *minfo)
{
  // apply preset via set_params
  const char *pn = g_object_get_data(G_OBJECT(menuitem), "dt-preset-name");
  dt_lib_presets_apply(pn, minfo->plugin_name, minfo->version);
}
 
static void free_module_info(GtkWidget *widget, gpointer user_data)
{
  dt_lib_module_info_t *minfo = (dt_lib_module_info_t *)user_data;
  dt_free(minfo->plugin_name);
  dt_free(minfo->params);
  dt_free(minfo);
}
 
static void dt_lib_presets_popup_menu_show(dt_lib_module_info_t *minfo)
{
  GtkMenu *menu = dt_gui_get_global()->presets_popup_menu;
  if(menu) gtk_widget_destroy(GTK_WIDGET(menu));
  dt_gui_get_global()->presets_popup_menu = GTK_MENU(gtk_menu_new());
  menu = dt_gui_get_global()->presets_popup_menu;
 
  const gboolean hide_default = dt_conf_get_bool("plugins/lighttable/hide_default_presets");
  const gboolean default_first = dt_conf_get_bool("modules/default_presets_first");
 
  g_signal_connect(G_OBJECT(menu), "destroy", G_CALLBACK(free_module_info), minfo);
 
  GtkWidget *mi;
  int active_preset = -1, cnt = 0;
  gboolean selected_writeprotect = FALSE;
  // order like the pref value
  GList *presets = dt_preset_repository_list_for_module(minfo->plugin_name, minfo->version,
                                                        TRUE, default_first);
 
  // collect all presets for op from db
  int found = 0;
  int last_wp = -1;
  for(GList *l = presets; l; l = g_list_next(l))
  {
    const dt_module_preset_t *p = (const dt_module_preset_t *)l->data;
    // default vs built-in stuff
    const gboolean writeprotect = p->writeprotect;
    if(hide_default && writeprotect)
    {
      // skip default module if set to hide them.
      continue;
    }
    if(last_wp == -1)
    {
      last_wp = writeprotect;
    }
    else if(last_wp != writeprotect)
    {
      last_wp = writeprotect;
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
    }
 
    void *op_params = p->op_params;
    int32_t op_params_size = p->op_params_size;
    const char *name = p->name;
 
    if(dt_gui_get_global()->last_preset && strcmp(dt_gui_get_global()->last_preset, name) == 0) found = 1;
 
    // selected in bold:
    // printf("comparing %d bytes to %d\n", op_params_size, minfo->params_size);
    // for(int k=0;k<op_params_size && !memcmp(minfo->params, op_params, k);k++) printf("compare [%c %c] %d:
    // %d\n",
    // ((const char*)(minfo->params))[k],
    // ((const char*)(op_params))[k],
    // k, memcmp(minfo->params, op_params, k));
    if(op_params_size == minfo->params_size && !memcmp(minfo->params, op_params, op_params_size))
    {
      active_preset = cnt;
      selected_writeprotect = writeprotect;
      mi = gtk_check_menu_item_new_with_label(name);
 
      gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(mi), TRUE);
      dt_gui_add_class(mi, "active_menu_item");
    }
    else
    {
      mi = gtk_menu_item_new_with_label((const char *)name);
    }
    g_object_set_data_full(G_OBJECT(mi), "dt-preset-name", g_strdup(name), g_free);
    g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(pick_callback), minfo);
    gtk_widget_set_tooltip_text(mi, p->description);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
    cnt++;
  }
  g_list_free_full(presets, dt_module_preset_free);
 
  if(cnt > 0)
  {
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
    cnt = 0;
  }
 
  if(minfo->module->manage_presets)
  {
    mi = gtk_menu_item_new_with_label(_("manage presets..."));
    g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_manage_presets), minfo);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
    cnt++;
  }
  else if(active_preset >= 0) // FIXME: this doesn't seem to work.
  {
    if(!selected_writeprotect)
    {
      mi = gtk_menu_item_new_with_label(_("edit this preset.."));
      g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_edit_preset), minfo);
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
 
      mi = gtk_menu_item_new_with_label(_("delete this preset"));
      g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_delete_preset), minfo);
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
      cnt++;
    }
  }
  else
  {
    mi = gtk_menu_item_new_with_label(_("store new preset.."));
    if(minfo->params_size == 0)
    {
      gtk_widget_set_sensitive(GTK_WIDGET(mi), FALSE);
      gtk_widget_set_tooltip_text(mi, _("nothing to save"));
    }
    else
      g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_new_preset), minfo);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
 
    if(dt_gui_get_global()->last_preset && found)
    {
      char *markup = g_markup_printf_escaped("%s <span weight=\"bold\">%s</span>", _("update preset"),
                                             dt_gui_get_global()->last_preset);
      mi = gtk_menu_item_new_with_label("");
      gtk_widget_set_sensitive(GTK_WIDGET(mi), minfo->params_size > 0);
      gtk_label_set_markup(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mi))), markup);
      g_object_set_data_full(G_OBJECT(mi), "dt-preset-name", g_strdup(dt_gui_get_global()->last_preset), g_free);
      g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_update_preset), minfo);
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
      dt_free(markup);
    }
    cnt++;
  }
 
  if(minfo->module->set_preferences)
  {
    if(cnt>0)
    {
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
    }
    minfo->module->set_preferences(GTK_MENU_SHELL(menu), minfo->module);
  }
}
 
gint dt_lib_sort_plugins(gconstpointer a, gconstpointer b)
{
  const dt_lib_module_t *am = (const dt_lib_module_t *)a;
  const dt_lib_module_t *bm = (const dt_lib_module_t *)b;
  const int apos = (am && am->position) ? am->position() : 0;
  const int bpos = (bm && bm->position) ? bm->position() : 0;
  return apos - bpos;
}
 
/* 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;
}
 
int default_lib_focus(dt_gui_module_t *m, gboolean toogle)
{
  dt_lib_module_t *module = (dt_lib_module_t *) m;
  dt_lib_gui_set_expanded(module, !dt_lib_gui_get_expanded(module));
  return 1;
}
 
static int _lib_plugin_body_button_press(GtkWidget *w, GdkEventButton *e, gpointer user_data)
{
  /* Reset the scrolling focus. If the click happened on any bauhaus element,
   * its internal button_press method will set it for itself */
  dt_widget_set_scroll_focus(NULL);
  int handled = FALSE;
  return handled;
}
 
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;
 
#define INCLUDE_API_FROM_MODULE_LOAD "lib_load_module"
#include "libs/lib_api.h"
 
  // Load modules only if they belong to a loaded view.
  // Designed for print settings, which loads all installed CUPS printers at gui_init() time,
  // which can take some time.
  gboolean load = FALSE;
  for(const char **view_m = module->views(module); *view_m; ++view_m)
  {
    for(GList *iter = dt_view_manager_get_global()->views; iter; iter = g_list_next(iter))
    {
      dt_view_t *view = (dt_view_t *)iter->data;
      if(!g_strcmp0(view->module_name, *view_m) || !g_strcmp0("*", *view_m) || !g_strcmp0("special", *view_m))
      {
        load = TRUE;
        break;
      }
    }
    if(load) break;
  }
 
  if(!load) return 1;
 
  g_strlcpy(module->plugin_name, module_name, sizeof(module->plugin_name));
 
  if(((!module->get_params || !module->set_params)
      && (module->legacy_params || module->set_params || module->get_params))
     || (!module->init_presets && module->manage_presets))
  {
    fprintf(stderr,"[dt_lib_load_module] illegal method combination in '%s'\n", 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->reset_button = NULL;
  module->presets_button = NULL;
  
  if(module->init) module->init(module);
 
  /* pass on the dt_gui_module_t args for bauhaus widgets */
  module->common_fields.name = g_strdup(module->name(module));
  module->common_fields.view = NULL; // view is set at gui_init time
  module->common_fields.widget_list = NULL;
  module->common_fields.widget_list_bh = NULL;
  module->common_fields.focus = module->lib_focus;
  module->common_fields.deprecated = FALSE;
 
  return 0;
}
 
static void *_update_params(dt_lib_module_t *module,
                            const void *const old_params, size_t old_params_size, int old_version,
                            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(IS_NULL_PTR(params)) 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);
    dt_free(params);
    if(IS_NULL_PTR(new_params)) 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(IS_NULL_PTR(module->set_params))
  {
    dt_preset_repository_delete_all_for_module(module->plugin_name);
  }
  else
  {
    GList *presets = dt_preset_repository_list_all_versions(module->plugin_name);
    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 version = module->version();
 
      if(p->op_version < version)
      {
        size_t new_params_size = 0;
        void *new_params = NULL;
 
        if(module->legacy_params
          && (new_params = _update_params(module, p->op_params, p->op_params_size, p->op_version, version,
                                          &new_params_size)))
        {
          // write the updated preset back to db
          fprintf(stderr,
                  "[lighttable_init_presets] updating '%s' preset '%s' from version %d to version %d\n",
                  module->plugin_name, p->name, p->op_version, version);
          dt_preset_repository_update_params_by_rowid(p->rowid, version, new_params, new_params_size);
        }
        else
        {
          // delete the preset
          fprintf(stderr, "[lighttable_init_presets] Can't upgrade '%s' preset '%s' from version %d to %d, "
                          "no legacy_params() implemented or unable to update\n",
                  module->plugin_name, p->name, p->op_version, version);
          dt_preset_repository_delete_by_rowid(p->rowid);
        }
        dt_free(new_params);
      }
    }
    g_list_free_full(presets, dt_module_preset_free);
  }
 
  if(module->init_presets)
    module->init_presets(module);
 
  DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_PRESETS_CHANGED,
                                g_strdup(module->plugin_name));
}
 
 
static gboolean _lib_plugin_focus_accel(GtkAccelGroup *accel_group, GObject *accelerable, guint keyval,
                                        GdkModifierType modifier, gpointer data)
{
  dt_gui_module_t *module = (dt_gui_module_t *)data;
  if(!module || !module->focus) return FALSE;
  return module->focus(module, FALSE);
}
 
 
static void dt_lib_init_module(void *m)
{
  dt_lib_module_t *module = (dt_lib_module_t *)m;
  dt_lib_init_presets(module);
 
  if(dt_gui_get_global())
  {
    module->gui_init(module);
    if(module->widget) g_object_ref_sink(module->widget);
 
    // TODO: look for active view. Do we know it at init time ?
    module->common_fields.view = g_strdup(_("Lighttable"));
 
    if(!module->views || (module->expandable && !module->expandable(module))) return; // We are done
    // Else: add accel pathes
 
    gchar *clean_name = delete_underscore(module->name(module));
    dt_capitalize_label(clean_name);
 
    // slash is not allowed in module names because that makes accel pathes fail
    assert(g_strrstr(clean_name, "/") == NULL);
 
    const char **views = module->views(module);
 
    // We add one accel path per view
    for(const char **view = views; *view; ++view)
    {
      GtkAccelGroup *accel_group = NULL;
      gchar *label = NULL;
      if(!g_strcmp0(*view, "darkroom"))
      {
        accel_group = dt_gui_get_accels()->darkroom_accels;
        label = g_strdup("Darkroom/Toolboxes");
      }
      else if(!g_strcmp0(*view, "lighttable"))
      {
        accel_group = dt_gui_get_accels()->lighttable_accels;
        label = g_strdup("Lighttable/Toolboxes");
      }
      else if(!g_strcmp0(*view, "map"))
      {
        accel_group = dt_gui_get_accels()->map_accels;
        label = g_strdup("Map/Toolboxes");
      }
      else if(!g_strcmp0(*view, "print"))
      {
        accel_group = dt_gui_get_accels()->print_accels;
        label = g_strdup("Print/Toolboxes");
      }
      else if(!g_strcmp0(*view, "slideshow"))
      {
        accel_group = dt_gui_get_accels()->slideshow_accels;
        label = g_strdup("Slideshow/Toolboxes");
      }
 
      if(accel_group && label)
        dt_accels_new_action_shortcut(dt_gui_get_accels(), _lib_plugin_focus_accel, m, NULL,
                                      accel_group, label, clean_name, 0, 0, FALSE,
                                      _("Focuses the module"));
      dt_free(label);
    }
 
    dt_free(clean_name);
  }
}
 
void dt_lib_unload_module(dt_lib_module_t *module)
{
  GtkWidget *retained_widget = module->widget;
 
  if(dt_gui_get_global() && dt_gui_get_accels() && module->views)
  {
    gchar *clean_name = delete_underscore(module->name(module));
    dt_capitalize_label(clean_name);
 
    const char **views = module->views(module);
    for(const char **view = views; view && *view; ++view)
    {
      const char *scope = NULL;
      if(!g_strcmp0(*view, "darkroom")) scope = "Darkroom/Toolboxes";
      else if(!g_strcmp0(*view, "lighttable")) scope = "Lighttable/Toolboxes";
      else if(!g_strcmp0(*view, "map")) scope = "Map/Toolboxes";
      else if(!g_strcmp0(*view, "print")) scope = "Print/Toolboxes";
      else if(!g_strcmp0(*view, "slideshow")) scope = "Slideshow/Toolboxes";
 
      if(scope)
      {
        gchar *path = dt_accels_build_path(scope, clean_name);
        dt_accels_remove_shortcut(dt_gui_get_accels(), path);
        dt_free(path);
      }
    }
 
    dt_free(clean_name);
  }
 
  dt_gui_module_t *m = DT_GUI_MODULE(module);
  g_list_free(m->widget_list);
  m->widget_list = NULL;
  g_list_free(m->widget_list_bh);
  m->widget_list_bh = NULL;
  dt_free(m->name);
  dt_free(m->view);
 
  if(!IS_NULL_PTR(module->expander) && GTK_IS_WIDGET(module->expander))
  {
    GtkWidget *expander = module->expander;
    g_object_ref_sink(expander);
    gtk_widget_destroy(expander);
    g_object_unref(expander);
  }
  else if(!IS_NULL_PTR(module->widget) && GTK_IS_WIDGET(module->widget))
  {
    GtkWidget *widget = module->widget;
    g_object_ref_sink(widget);
    gtk_widget_destroy(widget);
    g_object_unref(widget);
  }
  module->expander = NULL;
  module->widget = NULL;
  if(!IS_NULL_PTR(retained_widget) && G_IS_OBJECT(retained_widget))
    g_object_unref(retained_widget);
 
  if(module->module) g_module_close(module->module);
}
 
static void dt_lib_gui_reset_callback(GtkButton *button, gpointer user_data)
{
  dt_lib_module_t *module = (dt_lib_module_t *)user_data;
  module->gui_reset(module);
}
 
static void presets_popup_callback(GtkButton *button, dt_lib_module_t *module)
{
  dt_lib_module_info_t *mi = (dt_lib_module_info_t *)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(IS_NULL_PTR(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;
  }
  dt_lib_presets_popup_menu_show(mi);
 
  dt_gui_menu_popup(dt_gui_get_global()->presets_popup_menu, GTK_WIDGET(button), GDK_GRAVITY_SOUTH_EAST, GDK_GRAVITY_NORTH_EAST);
 
  if(button) dtgtk_button_set_active(DTGTK_BUTTON(button), FALSE);
}
 
static void _lib_module_expander_gone(gpointer user_data, GObject *where_the_object_was)
{
  dt_lib_module_t *module = (dt_lib_module_t *)user_data;
  if(IS_NULL_PTR(module)) return;
  if(module->expander == (GtkWidget *)where_the_object_was) module->expander = NULL;
  if(dt_gui_get_global())
  {
    if(dt_gui_get_global()->scroll_to[0] == (GtkWidget *)where_the_object_was) dt_gui_get_global()->scroll_to[0] = NULL;
    if(dt_gui_get_global()->scroll_to[1] == (GtkWidget *)where_the_object_was) dt_gui_get_global()->scroll_to[1] = NULL;
  }
}
 
 
void dt_lib_gui_set_expanded(dt_lib_module_t *module, gboolean expanded)
{
  if(IS_NULL_PTR(module->expander)) return;
  if(!DTGTK_IS_EXPANDER(module->expander))
  {
    module->expander = NULL;
    return;
  }
 
  dtgtk_expander_set_expanded(DTGTK_EXPANDER(module->expander), expanded);
 
  /* record lib panel usage for crash reports and usage analytics */
  if(expanded)
  {
    dt_sentry_record_module_usage("lib", module->plugin_name);
    dt_telemetry_record_module_usage("lib", module->plugin_name);
  }
 
  /* show / hide plugin widget */
  if(expanded)
  {
    /* register to receive draw events */
    dt_lib_get_global()->gui_module = module;
    dt_gui_get_global()->scroll_to[1] = module->expander;
    gtk_widget_grab_focus(GTK_WIDGET(module->expander));
  }
  else
  {
    if(dt_lib_get_global()->gui_module == module)
    {
      dt_lib_get_global()->gui_module = NULL;
      dt_control_queue_redraw();
    }
    dt_gui_refocus_center();
  }
 
  if(expanded)
    dt_gui_add_class(module->expander, "expanded");
  else
    dt_gui_remove_class(module->expander, "expanded");
 
  // Update expander arrow state
  // Note: directions are inverted in drawing method for some reason.
  dtgtk_button_set_paint(DTGTK_BUTTON(module->arrow), 
                         dtgtk_cairo_paint_arrow,
                         (expanded ? CPF_DIRECTION_UP : CPF_DIRECTION_LEFT), 
                         NULL);
 
  /* store expanded state of module */
  char var[1024];
  const dt_view_t *current_view = dt_view_manager_get_current_view(dt_view_manager_get_global());
  // There is no current view while the view manager is switching between them, and the conf
  // key is built from its name -- so with no view there is no key to write, and nothing to
  // store. dt_lib_gui_get_expanded() below makes the same check on the reading side, where
  // omitting it crashed (Sentry 139067518).
  if(IS_NULL_PTR(current_view)) return;
  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(IS_NULL_PTR(module->expander)) return true;
  if(!DTGTK_IS_EXPANDER(module->expander))
  {
    module->expander = NULL;
    if(!module->widget)
    {
      char var[1024];
      const dt_view_t *current_view = dt_view_manager_get_current_view(dt_view_manager_get_global());
      if(IS_NULL_PTR(current_view)) return true;
      snprintf(var, sizeof(var), "plugins/%s/%s/expanded", current_view->module_name, module->plugin_name);
      return dt_conf_get_bool(var);
    }
    return true;
  }
  if(!module->widget)
  {
    char var[1024];
    const dt_view_t *current_view = dt_view_manager_get_current_view(dt_view_manager_get_global());
    // Same check the identical block above already makes. There is no current view while the
    // manager is switching between them, and this is called from the darkroom expose --
    // Sentry 139067518: EXCEPTION_ACCESS_VIOLATION reading current_view->module_name here.
    if(IS_NULL_PTR(current_view)) return true;
    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 _toggle_expanded(dt_lib_module_t *module, gboolean close_all)
{
  if(close_all)
  {
    const dt_view_t *v = dt_view_manager_get_current_view(dt_view_manager_get_global());
    gboolean all_other_closed = TRUE;
    uint32_t container = module->container(module);
 
    for(const GList *it = dt_lib_get_global()->plugins; it; it = g_list_next(it))
    {
      dt_lib_module_t *m = (dt_lib_module_t *)it->data;
 
      if(m != module && container == m->container(m) && m->expandable(m) && dt_lib_is_visible_in_view(m, v))
      {
        if(m->expander && DTGTK_IS_EXPANDER(m->expander))
          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, !dt_lib_gui_get_expanded(module));
    else
      dt_lib_gui_set_expanded(module, TRUE);
  }
  else
  {
    /* else just toggle */
    dt_lib_gui_set_expanded(module, !dt_lib_gui_get_expanded(module));
  }
}
 
static void expand_callback(GtkButton *button, dt_lib_module_t *module)
{
  _toggle_expanded(module, FALSE);
}
 
static gboolean _lib_plugin_header_button_press(GtkWidget *w, GdkEventButton *e, gpointer user_data)
{
  if(e->type == GDK_2BUTTON_PRESS || e->type == GDK_3BUTTON_PRESS) return TRUE;
 
  dt_lib_module_t *module = (dt_lib_module_t *)user_data;
 
  /* Reset the scrolling focus. If the click happened on any bauhaus element,
   * its internal button_press method will set it for itself */
  dt_widget_set_scroll_focus(NULL);
 
  if(e->button == 1)
  {
    /* bail out if module is static */
    if(!module->expandable(module)) return FALSE;
 
    // make gtk scroll to the module once it updated its allocation size
    uint32_t container = module->container(module);
    if(container == DT_UI_CONTAINER_PANEL_LEFT_CENTER)
      dt_gui_get_global()->scroll_to[0] = module->expander;
    else if(container == DT_UI_CONTAINER_PANEL_RIGHT_CENTER)
      dt_gui_get_global()->scroll_to[1] = module->expander;
 
    gtk_widget_grab_focus(GTK_WIDGET(module->expander));
 
    /* handle shiftclick on expander, hide all except this */
    _toggle_expanded(module, dt_modifier_is(e->state, GDK_SHIFT_MASK));
 
    return TRUE;
  }
  else if(e->button == 3)
  {
    if(gtk_widget_get_sensitive(module->presets_button))
      presets_popup_callback(NULL, module);
 
    return TRUE;
  }
  return FALSE;
}
 
#if 0
static void show_module_callback(dt_lib_module_t *module)
{
  /* bail out if module is static */
  if(!module->expandable(module)) return;
 
  // make gtk scroll to the module once it updated its allocation size
  uint32_t container = module->container(module);
  if(container == DT_UI_CONTAINER_PANEL_LEFT_CENTER)
    dt_gui_get_global()->scroll_to[0] = module->expander;
  else if(container == DT_UI_CONTAINER_PANEL_RIGHT_CENTER)
    dt_gui_get_global()->scroll_to[1] = module->expander;
 
  dt_lib_gui_set_expanded(module, !dtgtk_expander_get_expanded(DTGTK_EXPANDER(module->expander)));
}
 
#endif
 
GtkWidget *dt_lib_gui_get_expander(dt_lib_module_t *module)
{
  /* check if module is expandable */
  if(!module->expandable(module))
  {
    if(module->presets_button)
    {
      // FIXME separately define as darkroom widget shortcut/action, because not automatically registered via lib
      // if presets btn has been loaded to be shown outside expander
      g_signal_connect(G_OBJECT(module->presets_button), "clicked", G_CALLBACK(presets_popup_callback), module);
    }
    module->expander = NULL;
    return NULL;
  }
 
  GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING / 2.);
  gtk_widget_set_name(GTK_WIDGET(header), "module-header");
 
  GtkWidget *expander = dtgtk_expander_new(header, module->widget);
  dt_gui_add_class(expander, "dt_module_frame");
  dt_gui_add_class(expander, "dt_lib_module");
 
  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_gui_add_class(pluginui_frame, "dt_plugin_ui");
 
  /* setup the header box */
  g_signal_connect(G_OBJECT(header_evb), "button-press-event", G_CALLBACK(_lib_plugin_header_button_press),
                   module);
 
  /* connect mouse button callbacks for focus and presets */
  g_signal_connect(G_OBJECT(body_evb), "button-press-event", G_CALLBACK(_lib_plugin_body_button_press), module);
  gtk_widget_add_events(body_evb, GDK_POINTER_MOTION_MASK);
 
  /*
   * initialize the header widgets
   */
 
  /* add collapsing arrow */
  if(module->expandable(module))
  {
    module->arrow = dtgtk_button_new(dtgtk_cairo_paint_arrow, 0, NULL);
    g_signal_connect(G_OBJECT(module->arrow), "clicked", G_CALLBACK(expand_callback), module);
    gtk_box_pack_start(GTK_BOX(header), module->arrow, FALSE, FALSE, 0);
    dt_gui_add_class(module->arrow, "dt-collapse-arrow");
  }
 
  /* 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);
  dt_capitalize_label(mname);
  gtk_label_set_markup(GTK_LABEL(label), mname);
  dt_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");
  gtk_box_pack_start(GTK_BOX(header), label_evb, FALSE, FALSE, 0);
 
  /* add preset button if module has implementation */
  module->presets_button = dtgtk_button_new(dtgtk_cairo_paint_presets, 0, NULL);
  g_signal_connect(G_OBJECT(module->presets_button), "clicked", G_CALLBACK(presets_popup_callback), module);
  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(dtgtk_cairo_paint_reset, 0, NULL);
  g_signal_connect(G_OBJECT(module->reset_button), "clicked", G_CALLBACK(dt_lib_gui_reset_callback), module);
  if(!module->gui_reset) gtk_widget_set_sensitive(GTK_WIDGET(module->reset_button), FALSE);
  gtk_box_pack_end(GTK_BOX(header), module->reset_button, FALSE, FALSE, 0);
 
  gtk_widget_show_all(GTK_WIDGET(module->widget));
  dt_gui_add_class(module->widget, "dt_plugin_ui_main");
  module->expander = expander;
  g_object_weak_ref(G_OBJECT(expander), _lib_module_expander_gone, module);
 
  gtk_widget_set_hexpand(module->widget, FALSE);
  gtk_widget_set_vexpand(module->widget, FALSE);
 
  return module->expander;
}
 
void dt_lib_init(dt_lib_t *lib)
{
  // Setting everything to null initially
  memset(lib, 0, sizeof(dt_lib_t));
  dt_lib_get_global()->plugins = dt_module_load_modules("/plugins/lighttable", sizeof(dt_lib_module_t),
                                                  dt_lib_load_module, dt_lib_init_module, dt_lib_sort_plugins);
}
 
void dt_lib_cleanup(dt_lib_t *lib)
{
  while(lib->plugins)
  {
    dt_lib_module_t *module = (dt_lib_module_t *)(lib->plugins->data);
    if(module)
    {
      if(module->gui_cleanup)
        module->gui_cleanup(module);
      module->data = NULL;
      dt_free(module->common_fields.view);
      module->common_fields.view = NULL;
      dt_lib_unload_module(module);
      dt_free(module);
    }
    lib->plugins = g_list_delete_link(lib->plugins, lib->plugins);
  }
 
  dt_preset_repository_cleanup();
}
 
void dt_lib_presets_add(const char *name, const char *plugin_name, const int32_t version, const void *params,
                        const int32_t params_size, gboolean readonly)
{
  dt_lib_presets_remove(name, plugin_name, version);
  dt_preset_repository_add_shipped_preset(name, plugin_name, version, params, params_size, readonly);
}
 
static gchar *_get_lib_view_path(dt_lib_module_t *module, char *suffix)
{
  if(IS_NULL_PTR(dt_view_manager_get_global()) || !module || IS_NULL_PTR(suffix) || module->plugin_name[0] == '\0') return NULL;
  const dt_view_t *cv = dt_view_manager_get_current_view(dt_view_manager_get_global());
  if(IS_NULL_PTR(cv) || cv->module_name[0] == '\0') return NULL;
  // in lighttable, we store panels states per layout
  char lay[32] = "";
  if(g_strcmp0(cv->module_name, "lighttable") == 0)
  {
    g_snprintf(lay, sizeof(lay), "%d/", 0);
  }
  else if(g_strcmp0(cv->module_name, "darkroom") == 0)
  {
    g_snprintf(lay, sizeof(lay), "%d/", dt_view_darkroom_get_layout(dt_view_manager_get_global()));
  }
 
  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)
{
  gchar *key = _get_lib_view_path(module, "_visible");
  gboolean ret = TRUE; /* if not key found, always make module visible */
  if(key && dt_conf_key_exists(key)) ret = dt_conf_get_bool(key);
  dt_free(key);
 
  return ret;
}
 
void dt_lib_set_visible(dt_lib_module_t *module, gboolean visible)
{
  gchar *key = _get_lib_view_path(module, "_visible");
  GtkWidget *widget;
  if(key)
  {
    dt_conf_set_bool(key, visible);
    dt_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(IS_NULL_PTR(module_names))
  {
    module_names = g_hash_table_new(g_str_hash, g_str_equal);
    for(const GList *lib = dt_lib_get_global()->plugins; lib; lib = g_list_next(lib))
    {
      dt_lib_module_t *module = (dt_lib_module_t *)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_boundingbox_t box)
{
  dt_develop_t *const dev = dt_dev_get_global();
  dt_colorpicker_sample_t *const sample = dev ? dev->color_picker.primary_sample : NULL;
  if(IS_NULL_PTR(sample)) return;
 
  dt_boundingbox_t raw_box = { box[0], box[1], box[2], box[3] };
  dt_dev_coordinates_image_norm_to_raw_norm(dev, raw_box, 2);
 
  gboolean changed = (sample->size != DT_LIB_COLORPICKER_SIZE_BOX);
  sample->size = DT_LIB_COLORPICKER_SIZE_BOX;
  for(int k = 0; k < 4; k++)
  {
    changed |= (sample->box[k] != raw_box[k]);
    sample->box[k] = raw_box[k];
  }
 
  if(!changed) return;
  dt_iop_color_picker_request_update();
  dt_gui_refocus_center();
}
 
void dt_lib_colorpicker_set_point(dt_lib_t *lib, const float pos[2])
{
  dt_develop_t *const dev = dt_dev_get_global();
  dt_colorpicker_sample_t *const sample = dev ? dev->color_picker.primary_sample : NULL;
  if(IS_NULL_PTR(sample)) return;
 
  float raw_pos[2] = { pos[0], pos[1] };
  dt_dev_coordinates_image_norm_to_raw_norm(dev, raw_pos, 1);
 
  const gboolean changed = sample->size != DT_LIB_COLORPICKER_SIZE_POINT
                        || sample->point[0] != raw_pos[0]
                        || sample->point[1] != raw_pos[1];
  sample->size = DT_LIB_COLORPICKER_SIZE_POINT;
  sample->point[0] = raw_pos[0];
  sample->point[1] = raw_pos[1];
 
  if(!changed) return;
  dt_iop_color_picker_request_update();
  dt_gui_refocus_center();
}
 
dt_lib_module_t *dt_lib_get_module(const char *name)
{
  /* hide/show modules as last config */
  for(GList *iter = dt_lib_get_global()->plugins; iter; iter = g_list_next(iter))
  {
    dt_lib_module_t *plugin = (dt_lib_module_t *)(iter->data);
    if(strcmp(plugin->plugin_name, name) == 0)
      return plugin;
  }
 
  return NULL;
}
 
/* callback function for delayed update after user interaction */
static gboolean _postponed_update(gpointer data)
{
  dt_lib_module_t *self = (dt_lib_module_t *)data;
  self->timeout_handle = 0;
  if(self->_postponed_update)
    self->_postponed_update(self);
 
  return FALSE; // cancel the timer
}
 
void dt_lib_queue_postponed_update(dt_lib_module_t *mod, void (*update_fn)(dt_lib_module_t *self))
{
  if(mod->timeout_handle)
  {
    // here we're making sure the event fires at last hover
    // and we won't have avalanche of events in the mean time.
    g_source_remove(mod->timeout_handle);
  }
  mod->_postponed_update = update_fn;
  mod->timeout_handle = g_timeout_add(dt_conf_get_int("processing/timeout"), _postponed_update, mod);
}
 
void dt_lib_cancel_postponed_update(dt_lib_module_t *mod)
{
  mod->_postponed_update = NULL;
  if(mod->timeout_handle)
  {
    g_source_remove(mod->timeout_handle);
    mod->timeout_handle = 0;
  }
}
 
gboolean dt_lib_presets_can_autoapply(dt_lib_module_t *mod)
{
  return mod->preset_autoapply(mod);
}
 
gboolean dt_handle_dialog_enter(GtkWidget *widget, GdkEventKey *event, gpointer data)
{
  guint key = dt_keys_mainpad_alternatives(event->keyval);
 
  if(key == GDK_KEY_Return)
  {
    gtk_dialog_response(GTK_DIALOG(widget), GTK_RESPONSE_ACCEPT);
    return TRUE;
  }
  return FALSE;
}
 
GtkWidget *dt_action_button_new(dt_lib_module_t *self, const gchar *label, gpointer callback, gpointer data, const gchar *tooltip, guint accel_key, GdkModifierType mods)
{
  gchar *label_copy = g_strdup(label);
  dt_capitalize_label(label_copy);
  GtkWidget *button = gtk_button_new_with_label(label_copy);
  dt_free(label_copy);
 
  gtk_widget_set_valign(GTK_WIDGET(button), GTK_ALIGN_CENTER);
  gtk_widget_set_halign(GTK_WIDGET(button), GTK_ALIGN_CENTER);
  gtk_widget_set_vexpand(GTK_WIDGET(button), FALSE);
  gtk_widget_set_hexpand(GTK_WIDGET(button), FALSE);
 
  gtk_label_set_ellipsize(GTK_LABEL(gtk_bin_get_child(GTK_BIN(button))), PANGO_ELLIPSIZE_END);
 
  if(tooltip) gtk_widget_set_tooltip_text(button, tooltip);
 
  g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(callback), data);
 
  return button;
}
 
 
 
// 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