signal.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2011-2012 Henrik Andersson.
    Copyright (C) 2011-2012 johannes hanika.
    Copyright (C) 2012 Ivan Tarozzi.
    Copyright (C) 2012 José Carlos García Sogo.
    Copyright (C) 2012-2015 Jérémy Rosen.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2012-2016 Tobias Ellinghaus.
    Copyright (C) 2014, 2016 Roman Lebedev.
    Copyright (C) 2014 Ronny Kahl.
    Copyright (C) 2015 Edouard Gomez.
    Copyright (C) 2016, 2019-2021 Pascal Obry.
    Copyright (C) 2018-2019 Edgardo Hoszowski.
    Copyright (C) 2018 Rikard Öxler.
    Copyright (C) 2019-2022 Aldric Renaudin.
    Copyright (C) 2019 Ulrich Pegelow.
    Copyright (C) 2020 Chris Elston.
    Copyright (C) 2020 Hanno Schwalm.
    Copyright (C) 2020 Hubert Kowalski.
    Copyright (C) 2020-2021 Philippe Weyland.
    Copyright (C) 2021 Ralf Brown.
    Copyright (C) 2022-2023, 2025 Aurélien PIERRE.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2026 Guillaume Stutin.
    
    darktable is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    darktable is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with darktable.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "common/logging.h"
#include "system/macros.h"
#include "system/mem_alloc.h"
#include "control/signal.h"
#include "control/control.h"
#include <glib.h>
#include <string.h>
 
#ifdef DT_HAVE_SIGNAL_TRACE
#include <execinfo.h>
#endif
 
typedef struct dt_control_signal_t
{
  /* the sinks for the signals */
  GObject *sink;
} dt_control_signal_t;
 
/*
                                                         GSignalFlags signal_flags,
                                                         ...);
   */
typedef struct dt_signal_description
{
  const char *name;
  GSignalAccumulator accumulator;
  gpointer accu_data;
  GType return_type;
  GSignalCMarshaller c_marshaller;
  guint n_params;
  GType *param_types;
  GCallback destructor;
  gboolean synchronous;
} dt_signal_description;
 
 
static GType uint_arg[] = { G_TYPE_UINT };
static GType uint64_2arg[] = { G_TYPE_UINT64, G_TYPE_UINT64 };
static GType int_arg[] = { G_TYPE_INT };
static GType uint_2arg[] = { G_TYPE_UINT, G_TYPE_UINT };
static GType pointer_arg[] = { G_TYPE_POINTER };
static GType pointer_2arg[] = { G_TYPE_POINTER, G_TYPE_POINTER };
static GType collection_args[] = { G_TYPE_UINT, G_TYPE_UINT, G_TYPE_POINTER, G_TYPE_UINT };
static GType image_export_arg[]
    = { G_TYPE_UINT, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER };
static GType history_will_change_arg[]
= { G_TYPE_POINTER, G_TYPE_UINT, G_TYPE_POINTER };
static GType geotag_arg[] = { G_TYPE_POINTER, G_TYPE_UINT };
static GType file_crawling_arg[] = { G_TYPE_POINTER, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT };
static GType mask_change_arg[] = { G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_UINT };
 
// callback for the destructor of DT_SIGNAL_COLLECTION_CHANGED
static void _collection_changed_destroy_callback(gpointer instance, int query_change, int changed_property,
                                                 gpointer imgs, const int next, gpointer user_data)
{
  if(imgs)
  {
    g_list_free(imgs);
    imgs = NULL;
  }
}
 
// callback for the destructor of DT_SIGNAL_IMAGE_INFO_CHANGED
static void _image_info_changed_destroy_callback(gpointer instance, gpointer imgs, gpointer user_data)
{
  if(!IS_NULL_PTR(imgs))
  {
    g_list_free(imgs);
    imgs = NULL;
  }
}
 
// callback for the destructor of DT_SIGNAL_PRESETS_CHANGED
static void _presets_changed_destroy_callback(gpointer instance, gpointer module, gpointer user_data)
{
  dt_free(module);
}
 
// callback for the destructor of DT_SIGNAL_GEOTAG_CHANGED
static void _image_geotag_destroy_callback(gpointer instance, gpointer imgs, const int locid, gpointer user_data)
{
  if(!IS_NULL_PTR(imgs))
  {
    g_list_free(imgs);
    imgs = NULL;
  }
}
 
static dt_signal_description _signal_description[DT_SIGNAL_COUNT] = {
  /* Global signals */
  { "dt-global-mouse-over-image-change", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE
  { "dt-global-active-images-change", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_ACTIVE_IMAGES_CHANGE
 
  { "dt-control-redraw-all", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_CONTROL_REDRAW_ALL
  { "dt-control-redraw-center", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_CONTROL_REDRAW_CENTER
 
  { "dt-viewmanager-view-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 2, pointer_2arg, NULL,
    FALSE }, // DT_SIGNAL_VIEWMANAGER_VIEW_CHANGED
  { "dt-viewmanager-view-cannot-change", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 2, pointer_2arg,
    NULL, FALSE }, // DT_SIGNAL_VIEWMANAGER_VIEW_CANNOT_CHANGE
  { "dt-viewmanager-thumbtable-activate", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__UINT, 1, uint_arg,
    NULL, FALSE }, // DT_SIGNAL_VIEWMANAGER_THUMBTABLE_ACTIVATE
  { "dt-viewmanager-filmstrip-activate", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__UINT, 1, uint_arg,
    NULL, FALSE }, // DT_SIGNAL_VIEWMANAGER_FILMSTRIP_ACTIVATE
  { "dt-viewmanager-filmstrip-drag-begin", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__UINT, 1, uint_arg,
    NULL, FALSE }, // DT_SIGNAL_VIEWMANAGER_FILMSTRIP_DRAG_BEGIN
 
  { "dt-collection-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 4, collection_args,
    G_CALLBACK(_collection_changed_destroy_callback), FALSE }, // DT_SIGNAL_COLLECTION_CHANGED
  { "dt-selection-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_SELECTION_CHANGED
  { "dt-tag-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_TAG_CHANGED
  { "dt-geotag-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 2, geotag_arg,
    G_CALLBACK(_image_geotag_destroy_callback), FALSE }, // DT_SIGNAL_GEOTAG_CHANGED
  { "dt-metadata-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__UINT, 1, uint_arg, NULL,
    FALSE }, // DT_SIGNAL_METADATA_CHANGED
  { "dt-image-info-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 1, pointer_arg,
    G_CALLBACK(_image_info_changed_destroy_callback), FALSE }, // DT_SIGNAL_IMAGE_INFO_CHANGED
  { "dt-style-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_STYLE_CHANGED
  { "dt-images-order-change", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 1, pointer_arg, NULL,
    FALSE }, // DT_SIGNAL_IMAGES_ORDER_CHANGE
  { "dt-filmrolls-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_FILMROLLS_CHANGED
  { "dt-filmrolls-removed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_FILMROLLS_REMOVED
  { "dt-presets-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 1, pointer_arg,
    G_CALLBACK(_presets_changed_destroy_callback), FALSE }, // DT_SIGNAL_PRESETS_CHANGED
 
  /* Develop related signals */
  { "dt-develop-initialized", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_DEVELOP_INITIALIZED
  { "dt-develop-preview-pipe-finished", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_DEVELOP_PREVIEW_PIPE_FINISHED
  { "dt-develop-ui-pipe-finished", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_DEVELOP_UI_PIPE_FINISHED
  { "dt-cacheline-ready", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 2, uint64_2arg, NULL,
    FALSE }, // DT_SIGNAL_CACHELINE_READY (hash, producer_node_key)
  { "dt-develop-modulegroups-set", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__POINTER, 1, pointer_arg, NULL,
    FALSE }, // DT_SIGNAL_DEVELOP_MODULEGROUPS_SET
  { "dt-develop-history-will-change", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 3,
    history_will_change_arg, NULL, FALSE }, // DT_SIGNAL_HISTORY_WILL_CHANGE
  { "dt-develop-history-change", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_HISTORY_CHANGE
  { "dt-history-resync", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_HISTORY_RESYNC
  { "dt-develop-module-remove", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 1, pointer_arg, NULL,
    TRUE }, // DT_SIGNAL_MODULE_REMOVE
  { "dt-develop-module-moved", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_DEVELOP_MODULE_MOVED
  { "dt-develop-image-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_DEVELOP_IMAGE_CHANGED
  { "dt-darkroom-ui-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL, 
    FALSE}, // DT_SIGNAL_DARKROOM_UI_CHANGED
  { "dt-image-loaded", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 2, uint_2arg,
    NULL, FALSE }, // DT_SIGNAL_IMAGE_LOADED
  { "dt-control-profile-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_CONTROL_PROFILE_CHANGED
  { "dt-control-profile-user-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__UINT, 1, uint_arg, NULL,
    FALSE }, // DT_SIGNAL_CONTROL_PROFILE_USER_CHANGED
  { "dt-image-import", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__INT, 1, int_arg, NULL,
    FALSE }, // DT_SIGNAL_IMAGE_IMPORT
  { "dt-image-export-tmpfile", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 6, image_export_arg, NULL,
    TRUE }, // DT_SIGNAL_IMAGE_EXPORT_TMPFILE
  { "dt-imageio-storage-change", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_IMAGEIO_STORAGE_CHANGE
 
 
  { "dt-preferences-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_PREFERENCES_CHANGE
 
 
  { "dt-control-navigation-redraw", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_CONTROL_NAVIGATION_REDRAW
 
  { "dt-control-log-redraw", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_CONTROL_LOG_REDRAW
 
  { "dt-control-toast-redraw", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_CONTROL_TOAST_REDRAW
 
  { "dt-control-pickerdata-ready", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    TRUE }, // DT_SIGNAL_CONTROL_PICKERDATA_REAEDY
 
  { "dt-control-notebook-tab-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 1, pointer_arg, NULL,
    FALSE }, // DT_SIGNAL_CONTROL_NOTEBOOK_TAB_CHANGED (owner)
 
  { "dt-metadata-update", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_METADATA_UPDATE
 
  { "dt-location-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 1, pointer_arg, NULL,
    TRUE }, // DT_SIGNAL_LOCATION_CHANGED
 
  { "dt-mask-selection-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 2, pointer_2arg, NULL,
    TRUE }, // DT_SIGNAL_MASK_SELECTION_CHANGED
  { "dt-mask-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 3, mask_change_arg, NULL,
    FALSE }, //DT_SIGNAL_MASK_CHANGED
  { "dt-mask-shape-buttons-deactivate", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 1, pointer_arg, NULL,
    FALSE }, // DT_SIGNAL_MASK_SHAPE_BUTTONS_DEACTIVATE
  { "dt-mask-shape-buttons-sync", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_MASK_SHAPE_BUTTONS_SYNC
  { "dt-develop-masks-gui-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_DEVELOP_MASKS_GUI_CHANGED
 
  { "dt-control-filelist-update", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_generic, 4, file_crawling_arg, NULL,
    TRUE }, // DT_SIGNAL_FILELIST_UPDATED: synchronous so crawler-owned pointers stay valid until handlers return.
    // 4th param (scan_errors) added for the import dialog's recursive-scan error count; this
    // signal is exclusively raised/consumed by common/import.c.
 
  { "dt-folder-survey-changed", NULL, NULL, G_TYPE_NONE, g_cclosure_marshal_VOID__VOID, 0, NULL, NULL,
    FALSE }, // DT_SIGNAL_FOLDER_SURVEY_CHANGED
};
 
static GType _signal_type;
 
dt_control_signal_t *dt_control_signal_init()
{
  dt_control_signal_t *ctlsig = g_malloc0(sizeof(dt_control_signal_t));
 
  /* setup dummy gobject typeinfo */
  GTypeQuery query;
  GTypeInfo type_info = { 0, (GBaseInitFunc)NULL, (GBaseFinalizeFunc)NULL, (GClassInitFunc)NULL,
                          (GClassFinalizeFunc)NULL, NULL, 0, 0, (GInstanceInitFunc)NULL };
 
  g_type_query(G_TYPE_OBJECT, &query);
  type_info.class_size = query.class_size;
  type_info.instance_size = query.instance_size;
  _signal_type = g_type_register_static(G_TYPE_OBJECT, "DarktableSignals", &type_info, 0);
 
  /* create our pretty empty gobject */
  ctlsig->sink = g_object_new(_signal_type, NULL);
 
  /* create the signals */
  for(int k = 0; k < DT_SIGNAL_COUNT; k++)
  {
    g_signal_newv(_signal_description[k].name, _signal_type, G_SIGNAL_RUN_LAST, 0,
        _signal_description[k].accumulator, _signal_description[k].accu_data,
        _signal_description[k].c_marshaller, _signal_description[k].return_type,
        _signal_description[k].n_params, _signal_description[k].param_types);
    if(_signal_description[k].destructor)
    {
      g_signal_connect_after(G_OBJECT(ctlsig->sink), _signal_description[k].name,
                             _signal_description[k].destructor, NULL);
    }
  }
  return ctlsig;
}
 
void dt_control_signal_cleanup(dt_control_signal_t *ctlsig)
{
  if(IS_NULL_PTR(ctlsig)) return;
  if(!IS_NULL_PTR(ctlsig->sink)) g_object_unref(ctlsig->sink);
  dt_free(ctlsig);
}
 
typedef struct _signal_param_t
{
  GValue *instance_and_params;
  guint signal_id;
  guint n_params;
} _signal_param_t;
 
static gboolean _signal_emit(gpointer user_data)
{
  _signal_param_t *params = (_signal_param_t *)user_data;
  g_signal_emitv(params->instance_and_params, params->signal_id, 0, NULL);
  return G_SOURCE_REMOVE;
}
 
static void _signal_param_cleanup(gpointer user_data)
{
  _signal_param_t *params = (_signal_param_t *)user_data;
  if(IS_NULL_PTR(params)) return;
  // We iterate over the whole emitted argument vector (instance at index 0 + signal params)
  // and only unset slots that currently hold a valid GValue type.
  for(int i = 0; i <= params->n_params; i++)
  {
    GValue *value = &params->instance_and_params[i];
    const GType value_type = G_VALUE_TYPE(value);
    if(value_type == G_TYPE_INVALID) continue;
    if(!g_type_check_is_value_type(value_type)) continue;
    g_value_unset(value);
  }
  dt_free(params->instance_and_params);
  dt_free(params);
}
 
typedef struct async_com_data
{
  GCond end_cond;
  GMutex end_mutex;
  gpointer user_data;
} async_com_data;
 
gboolean _async_com_callback(gpointer data)
{
  async_com_data *communication = (async_com_data*)data;
  g_mutex_lock(&communication->end_mutex);
  _signal_emit(communication->user_data);
  _signal_param_cleanup(communication->user_data);
 
  g_cond_signal(&communication->end_cond);
  g_mutex_unlock(&communication->end_mutex);
  return FALSE;
}
 
static void _print_trace (const char* op)
{
#ifdef DT_HAVE_SIGNAL_TRACE
  if(dt_get_signal_debug_acts() & DT_DEBUG_SIGNAL_ACT_PRINT_TRACE)
  {
    void *array[10];
    size_t size;
    char **strings;
    size_t i;
 
    size = backtrace (array, 10);
    strings = backtrace_symbols (array, size);
 
    for (i = 0; i < size; i++)
      dt_print(DT_DEBUG_SIGNAL, "[signal-trace-%s]: %s\n", op, strings[i]);
 
    dt_free(strings);
  }
#endif
}
 
// A signal that is not emitted still owes what its destructor releases after an emission: the
// same handler runs on the same arguments. The instance slot holds NULL, which no destructor reads.
static void _signal_release_unsent(const dt_signal_description *signal_description,
                                   const GValue *instance_and_params)
{
  if(IS_NULL_PTR(signal_description->destructor)) return;
 
  GClosure *closure = g_cclosure_new(signal_description->destructor, NULL, NULL);
  g_closure_ref(closure);
  g_closure_sink(closure);
  g_closure_set_marshal(closure, signal_description->c_marshaller);
  g_closure_invoke(closure, NULL, 1 + signal_description->n_params, instance_and_params, NULL);
  g_closure_unref(closure);
}
 
void dt_control_signal_raise(const dt_control_signal_t *ctlsig, dt_signal_t signal, ...)
{
  // Nothing is emitted in a process without a signal system (GUI-less), nor on shutdown. The
  // arguments are collected anyway, since the signal owns some of them.
  const gboolean emit = !IS_NULL_PTR(ctlsig) && dt_control_running();
 
  dt_signal_description *signal_description = &_signal_description[signal];
 
  _signal_param_t *params = (_signal_param_t *)malloc(sizeof(_signal_param_t));
  if(IS_NULL_PTR(params)) return;
 
  GValue *instance_and_params = calloc(1 + signal_description->n_params, sizeof(GValue));
  if(IS_NULL_PTR(instance_and_params))
  {
    dt_free(params);
    return;
  }
 
  // 0th element has to be the instance to call
  if(emit)
  {
    g_value_init(instance_and_params, _signal_type);
    g_value_set_object(instance_and_params, ctlsig->sink);
  }
  else
    g_value_init(instance_and_params, G_TYPE_POINTER);
 
  // the rest of instance_and_params will be the params for the callback
  va_list extra_args;
  va_start(extra_args, signal);
 
  for(int i = 1; i <= signal_description->n_params; i++)
  {
    GType type = signal_description->param_types[i-1];
    g_value_init(&instance_and_params[i], type);
    switch(type)
    {
      case G_TYPE_UINT:
        g_value_set_uint(&instance_and_params[i], va_arg(extra_args, guint));
        break;
      case G_TYPE_UINT64:
        g_value_set_uint64(&instance_and_params[i], va_arg(extra_args, guint64));
        break;
      case G_TYPE_STRING:
        g_value_set_string(&instance_and_params[i], va_arg(extra_args, const char *));
        break;
      case G_TYPE_INT:
        g_value_set_int(&instance_and_params[i], va_arg(extra_args, int));
        break;
      case G_TYPE_POINTER:
        g_value_set_pointer(&instance_and_params[i], va_arg(extra_args, void *));
        break;
      default:
        fprintf(stderr, "error: unsupported parameter type `%s' for signal `%s'\n",
                g_type_name(type), signal_description->name);
        va_end(extra_args);
        for(int j = 0; j <= i; j++) g_value_unset(&instance_and_params[j]);
        dt_free(instance_and_params);
        dt_free(params);
        return;
    }
  }
 
  va_end(extra_args);
 
  params->instance_and_params = instance_and_params;
  params->n_params = signal_description->n_params;
 
  if(!emit)
  {
    _signal_release_unsent(signal_description, instance_and_params);
    _signal_param_cleanup(params);
    return;
  }
 
  if(dt_get_signal_debug_acts() & DT_DEBUG_SIGNAL_ACT_RAISE && dt_get_signal_debug(signal))
  {
    dt_print(DT_DEBUG_SIGNAL, "[signal] raised: %s\n", signal_description->name);
    _print_trace("raise");
  }
 
  params->signal_id = g_signal_lookup(_signal_description[signal].name, _signal_type);
 
  if(!signal_description->synchronous)
  {
    g_main_context_invoke_full(NULL, G_PRIORITY_DEFAULT, _signal_emit, params, _signal_param_cleanup);
  }
  else
  {
    if(pthread_equal(dt_control_get_global()->gui_thread, pthread_self()))
    {
      _signal_emit(params);
      _signal_param_cleanup(params);
    }
    else
    {
      async_com_data communication;
      g_mutex_init(&communication.end_mutex);
      g_cond_init(&communication.end_cond);
      g_mutex_lock(&communication.end_mutex);
      communication.user_data = params;
      g_main_context_invoke(NULL,_async_com_callback,&communication);
      g_cond_wait(&communication.end_cond,&communication.end_mutex);
      g_mutex_unlock(&communication.end_mutex);
      g_mutex_clear(&communication.end_mutex);
    }
  }
}
 
void dt_control_signal_connect(const dt_control_signal_t *ctlsig, dt_signal_t signal, GCallback cb,
                               gpointer user_data)
{
  if(IS_NULL_PTR(ctlsig)) return;
  if(dt_get_signal_debug_acts() & DT_DEBUG_SIGNAL_ACT_CONNECT && dt_get_signal_debug(signal))
  {
    dt_print(DT_DEBUG_SIGNAL, "[signal] connected: %s\n", _signal_description[signal].name);
    _print_trace("connect");
  }
  g_signal_connect(G_OBJECT(ctlsig->sink), _signal_description[signal].name, G_CALLBACK(cb), user_data);
}
 
void dt_control_signal_disconnect(const struct dt_control_signal_t *ctlsig, GCallback cb, gpointer user_data)
{
  if(IS_NULL_PTR(ctlsig)) return;
  if(dt_get_signal_debug_acts() & DT_DEBUG_SIGNAL_ACT_DISCONNECT)
  {
    dt_print(DT_DEBUG_SIGNAL, "[signal] disconnected\n");
    _print_trace("disconnect");
  }
  g_signal_handlers_disconnect_matched(G_OBJECT(ctlsig->sink), G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0,
                                       0, NULL, cb, user_data);
}
 
void dt_control_signal_disconnect_all(const struct dt_control_signal_t *ctlsig, gpointer user_data)
{
  if(IS_NULL_PTR(ctlsig) || IS_NULL_PTR(user_data)) return;
  if(dt_get_signal_debug_acts() & DT_DEBUG_SIGNAL_ACT_DISCONNECT)
  {
    dt_print(DT_DEBUG_SIGNAL, "[signal] disconnected all\n");
    _print_trace("disconnect_all");
  }
  // G_SIGNAL_MATCH_DATA only: matches on user_data alone, across every signal id and callback
  // function ever connected on this sink for that data -- the blanket variant of the (func, data)
  // matched disconnect above.
  g_signal_handlers_disconnect_matched(G_OBJECT(ctlsig->sink), G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL,
                                       user_data);
}
 
void dt_control_signal_block_by_func(const struct dt_control_signal_t *ctlsig, GCallback cb, gpointer user_data)
{
  if(IS_NULL_PTR(ctlsig)) return;
  g_signal_handlers_block_by_func(G_OBJECT(ctlsig->sink), cb, user_data);
}
 
void dt_control_signal_unblock_by_func(const struct dt_control_signal_t *ctlsig, GCallback cb, gpointer user_data)
{
  if(IS_NULL_PTR(ctlsig)) return;
  g_signal_handlers_unblock_by_func(G_OBJECT(ctlsig->sink), cb, user_data);
}
 
// 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