masks_gui.c

Go to the documentation of this file.

/*
    This file is part of Ansel
    Copyright (C) 2022-2023, 2025-2026 Aurélien PIERRE.
    Copyright (C) 2025-2026 Guillaume Stutin.
    
    Ansel is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    Ansel is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with darktable.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "common/darktable.h"
#include "develop/masks.h"
#include "bauhaus/bauhaus.h"
#include "common/debug.h"
#include "control/signal.h"
#include "develop/imageop_gui.h"
#include "dtgtk/button.h"
#include "dtgtk/paint.h"
#include "gui/actions/menu.h"
#include "gui/draw.h"
#include "gui/gtk.h"
 
#include <math.h>
#include <stdlib.h>
 
#define DT_MASKS_SHAPE_BUTTON_COUNT 5
 
typedef struct dt_masks_shape_button_def_t
{
  int index;
  guint flag;
  dt_masks_type_t type;
  const gchar *label;
  const gchar *ctrl_label;
  DTGTKCairoPaintIconFunc paint;
} dt_masks_shape_button_def_t;
 
typedef struct dt_masks_shape_buttons_data_t
{
  GtkWidget *box;
  GtkWidget *buttons[DT_MASKS_SHAPE_BUTTON_COUNT];
  int types[DT_MASKS_SHAPE_BUTTON_COUNT];
  dt_masks_shape_buttons_config_t config;
} dt_masks_shape_buttons_data_t;
 
static const dt_masks_shape_button_def_t _masks_shape_button_defs[] = {
  { DT_MASKS_SHAPE_INDEX_GRADIENT, DT_MASKS_SHAPE_BUTTONS_GRADIENT, DT_MASKS_GRADIENT,
    N_("add gradient"), N_("add multiple gradients"), dtgtk_cairo_paint_masks_gradient },
  { DT_MASKS_SHAPE_INDEX_BRUSH, DT_MASKS_SHAPE_BUTTONS_BRUSH, DT_MASKS_BRUSH,
    N_("add brush"), N_("add multiple brush strokes"), dtgtk_cairo_paint_masks_brush },
  { DT_MASKS_SHAPE_INDEX_POLYGON, DT_MASKS_SHAPE_BUTTONS_POLYGON, DT_MASKS_POLYGON,
    N_("add polygon"), N_("add multiple polygons"), dtgtk_cairo_paint_masks_polygon },
  { DT_MASKS_SHAPE_INDEX_ELLIPSE, DT_MASKS_SHAPE_BUTTONS_ELLIPSE, DT_MASKS_ELLIPSE,
    N_("add ellipse"), N_("add multiple ellipses"), dtgtk_cairo_paint_masks_ellipse },
  { DT_MASKS_SHAPE_INDEX_CIRCLE, DT_MASKS_SHAPE_BUTTONS_CIRCLE, DT_MASKS_CIRCLE,
    N_("add circle"), N_("add multiple circles"), dtgtk_cairo_paint_masks_circle },
};
 
static void _masks_shape_buttons_deactivate(GtkWidget *active_button, dt_masks_shape_buttons_data_t *data)
{
  if(IS_NULL_PTR(data)) return;
 
  // Walk all buttons in this group so any caller can reset every masks shape toolbar through the shared signal.
  for(int i = 0; i < DT_MASKS_SHAPE_BUTTON_COUNT; i++)
  {
    GtkWidget *button = data->buttons[i];
    if(GTK_IS_TOGGLE_BUTTON(button) && button != active_button)
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE);
  }
}
 
static void _masks_shape_buttons_deactivate_signal(gpointer instance, GtkWidget *active_button,
                                                   dt_masks_shape_buttons_data_t *data)
{
  _masks_shape_buttons_deactivate(active_button, data);
}
 
void dt_masks_shape_buttons_deactivate_all(GtkWidget *active_button)
{
  DT_DEBUG_CONTROL_SIGNAL_RAISE(darktable.signals, DT_SIGNAL_MASK_SHAPE_BUTTONS_DEACTIVATE, active_button);
}
 
static int _masks_shape_button_index(const dt_masks_shape_buttons_data_t *data, GtkWidget *button)
{
  if(IS_NULL_PTR(data)) return -1;
 
  // Search the stored button pointers because callers may keep their own storage arrays.
  for(int i = 0; i < DT_MASKS_SHAPE_BUTTON_COUNT; i++)
    if(data->buttons[i] == button) return i;
 
  return -1;
}
 
static gboolean _masks_shape_button_is_current_creation(const dt_masks_shape_buttons_data_t *data,
                                                        const int button_index)
{
  dt_masks_form_gui_t *mask_gui = darktable.develop->form_gui;
  dt_masks_form_t *visible_form = dt_masks_get_visible_form(darktable.develop);
 
  return !IS_NULL_PTR(mask_gui) && mask_gui->creation
         && mask_gui->creation_module == data->config.creation_module
         && !IS_NULL_PTR(visible_form)
         && (visible_form->type & data->types[button_index]);
}
 
static gboolean _masks_shape_button_pressed(GtkWidget *button, GdkEventButton *event, gpointer user_data)
{
  if(darktable.gui->reset || event->button != GDK_BUTTON_PRIMARY) return TRUE;
 
  dt_masks_shape_buttons_data_t *data =
      (dt_masks_shape_buttons_data_t *)g_object_get_data(G_OBJECT(button), "dt-masks-shape-buttons-data");
  const int button_index = _masks_shape_button_index(data, button);
  if(button_index < 0) return FALSE;
 
  dt_masks_type_t type = data->types[button_index];
  dt_iop_module_t *module = data->config.creation_module;
  dt_masks_form_gui_t *mask_gui = darktable.develop->form_gui;
 
  if(_masks_shape_button_is_current_creation(data, button_index))
  {
    dt_masks_shape_buttons_deactivate_all(NULL);
    dt_masks_form_exit_creation(module, mask_gui);
    if(data->config.exited) data->config.exited(button, module, type, data->config.user_data);
    dt_control_queue_redraw_center();
    return TRUE;
  }
 
  if(data->config.can_start && !data->config.can_start(button, module, type, data->config.user_data))
  {
    dt_masks_shape_buttons_deactivate_all(NULL);
    dt_control_queue_redraw_center();
    return TRUE;
  }
 
  if(data->config.form_type) type = data->config.form_type(module, type, data->config.user_data);
 
  dt_masks_shape_buttons_deactivate_all(button);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), TRUE);
 
  if(dt_masks_creation_mode_enter(module, type))
  {
    if(data->config.started)
    {
      data->config.started(button, module, type, data->config.user_data);
      // Force focus back to the drawing area after creation mode enabling
      gtk_widget_grab_focus(dt_ui_center(darktable.gui->ui));
    }
  }
  else
  {
    dt_masks_shape_buttons_deactivate_all(NULL);
  }
 
  dt_control_queue_redraw_center();
  return TRUE;
}
 
static void _masks_shape_buttons_destroy(GtkWidget *widget, dt_masks_shape_buttons_data_t *data)
{
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(darktable.signals, G_CALLBACK(_masks_shape_buttons_deactivate_signal), data);
  dt_free(data);
}
 
GtkWidget *dt_masks_shape_buttons_create(const dt_masks_shape_buttons_config_t *config)
{
  if(IS_NULL_PTR(config)) return NULL;
 
  dt_masks_shape_buttons_data_t *data = calloc(1, sizeof(dt_masks_shape_buttons_data_t));
  if(IS_NULL_PTR(data)) return NULL;
 
  data->config = *config;
  data->box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_widget_set_halign(data->box, GTK_ALIGN_END);
  gtk_widget_set_valign(data->box, GTK_ALIGN_CENTER);
 
  const char *action_section = config->action_section ? config->action_section : N_("shapes");
  const size_t button_defs_count = sizeof(_masks_shape_button_defs) / sizeof(_masks_shape_button_defs[0]);
 
  // Create buttons in the same visible order used by the module-local toolbars.
  for(size_t i = 0; i < button_defs_count; i++)
  {
    const dt_masks_shape_button_def_t *def = &_masks_shape_button_defs[i];
    if(!(config->flags & def->flag)) continue;
 
    GtkWidget *button = NULL;
    if(config->owner_module)
    {
      const gboolean register_button = (config->register_flags & def->flag);
      if(register_button)
      {
        button = dt_iop_togglebutton_new(config->owner_module, action_section, def->label, def->ctrl_label,
                                         G_CALLBACK(_masks_shape_button_pressed), config->local,
                                         0, 0, def->paint, data->box);
      }
      else
      {
        button = dt_iop_togglebutton_new_no_register(config->owner_module, action_section, def->label, def->ctrl_label,
                                                     G_CALLBACK(_masks_shape_button_pressed), config->local,
                                                     0, 0, def->paint, data->box);
      }
    }
    else
    {
      button = dtgtk_togglebutton_new(def->paint, 0, NULL);
      gtk_widget_set_tooltip_text(button, _(def->label));
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE);
      gtk_box_pack_end(GTK_BOX(data->box), button, FALSE, FALSE, 0);
      g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(_masks_shape_button_pressed), NULL);
    }
 
    gtk_widget_set_can_focus(button, FALSE);
    g_object_set_data(G_OBJECT(button), "dt-masks-shape-buttons-data", data);
 
    data->buttons[def->index] = button;
    data->types[def->index] = def->type;
    if(config->buttons) config->buttons[def->index] = button;
    if(config->types) config->types[def->index] = def->type;
  }
 
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(darktable.signals, DT_SIGNAL_MASK_SHAPE_BUTTONS_DEACTIVATE,
                                  G_CALLBACK(_masks_shape_buttons_deactivate_signal), data);
  g_signal_connect(G_OBJECT(data->box), "destroy", G_CALLBACK(_masks_shape_buttons_destroy), data);
 
  return data->box;
}
 
typedef struct dt_masks_gui_interaction_slider_t
{
  dt_masks_form_group_t *form_group;
  dt_masks_form_gui_t *gui;
  dt_iop_module_t *module;
  dt_masks_interaction_t interaction;
  dt_masks_increment_t increment;
  float last_value;
  GtkWidget *slider;
} dt_masks_gui_interaction_slider_t;
 
// Push the new value to history (so the pipeline re-renders) and refresh the mask
// treeviews (opacity text, etc.).
//
// This is called from the slider "value-changed" handler. The bauhaus slider already
// throttles that emission through dt_gui_throttle_queue() while dragging, so the commit
// is debounced at the slider-value level: transient values do not flood the pipeline with
// renders, yet the image updates without waiting for the context menu to be closed.
static void _masks_gui_interaction_commit(dt_masks_gui_interaction_slider_t *data)
{
  if(IS_NULL_PTR(data) || IS_NULL_PTR(data->form_group)) return;
 
  dt_dev_add_history_item(darktable.develop, data->module, TRUE, TRUE);
  DT_DEBUG_CONTROL_SIGNAL_RAISE(darktable.signals, DT_SIGNAL_MASK_CHANGED,
                                data->form_group->formid, data->form_group->parentid,
                                DT_MASKS_EVENT_UPDATE);
}
 
static void _masks_gui_interaction_apply_value(dt_masks_gui_interaction_slider_t *data, float value)
{
  if(IS_NULL_PTR(data) || IS_NULL_PTR(data->form_group)) return;
 
  if(data->increment == DT_MASKS_INCREMENT_ABSOLUTE) // aka opacity
  {
    dt_masks_form_set_interaction_value(data->form_group, data->interaction, value,
                                        data->increment, 1, data->gui, data->module);
    data->last_value = value;
    _masks_gui_interaction_commit(data);
    return;
  }
 
  const float delta = value - data->last_value;
  if(fabsf(delta) < 1e-6f) return;
 
  // Slider value is a log2 scale factor in [-3;3], so apply the delta in log space.
  const float scale = exp2f(delta);
  dt_masks_form_set_interaction_value(data->form_group, data->interaction, scale,
                                      DT_MASKS_INCREMENT_SCALE, 1.f, data->gui, data->module);
  data->last_value = value;
  _masks_gui_interaction_commit(data);
}
 
static void _masks_gui_menu_item_block_activate(GtkWidget *widget, gpointer user_data)
{
  g_signal_stop_emission_by_name(widget, "activate");
}
 
static gboolean _masks_gui_menu_item_forward_event(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
  dt_masks_gui_interaction_slider_t *data = (dt_masks_gui_interaction_slider_t *)user_data;
  if(IS_NULL_PTR(data) || !data->slider) return FALSE;
 
  GdkEvent *copy = gdk_event_copy(event);
  if(IS_NULL_PTR(copy)) return FALSE;
 
  double x = 0.0, y = 0.0;
  gboolean has_coords = FALSE;
  switch(copy->type)
  {
    case GDK_BUTTON_PRESS:
    case GDK_2BUTTON_PRESS:
    case GDK_3BUTTON_PRESS:
    case GDK_BUTTON_RELEASE:
      x = copy->button.x;
      y = copy->button.y;
      has_coords = TRUE;
      break;
    case GDK_MOTION_NOTIFY:
      x = copy->motion.x;
      y = copy->motion.y;
      has_coords = TRUE;
      break;
    case GDK_SCROLL:
      x = copy->scroll.x;
      y = copy->scroll.y;
      has_coords = TRUE;
      break;
    default:
      break;
  }
 
  if(has_coords)
  {
    int sx = 0, sy = 0;
    if(gtk_widget_translate_coordinates(widget, data->slider, (int)x, (int)y, &sx, &sy))
    {
      switch(copy->type)
      {
        case GDK_BUTTON_PRESS:
        case GDK_2BUTTON_PRESS:
        case GDK_3BUTTON_PRESS:
        case GDK_BUTTON_RELEASE:
          copy->button.x = sx;
          copy->button.y = sy;
          break;
        case GDK_MOTION_NOTIFY:
          copy->motion.x = sx;
          copy->motion.y = sy;
          break;
        case GDK_SCROLL:
          copy->scroll.x = sx;
          copy->scroll.y = sy;
          break;
        default:
          break;
      }
    }
  }
 
  GdkWindow *slider_window = gtk_widget_get_window(data->slider);
  if(slider_window)
  {
    if(copy->any.window) g_object_unref(copy->any.window);
    copy->any.window = g_object_ref(slider_window);
    copy->any.send_event = TRUE;
  }
 
  gtk_widget_event(data->slider, copy);
  gdk_event_free(copy);
  return TRUE;
}
 
static void _masks_gui_interaction_slider_changed(GtkWidget *widget, gpointer user_data)
{
  dt_masks_gui_interaction_slider_t *data = (dt_masks_gui_interaction_slider_t *)user_data;
  if(IS_NULL_PTR(data) || IS_NULL_PTR(data->form_group)) return;
 
  _masks_gui_interaction_apply_value(data, dt_bauhaus_slider_get(widget));
}
 
static GtkWidget *_masks_gui_add_interaction_slider(GtkWidget *menu, const char *label, dt_masks_form_group_t *form_group,
                                                    dt_masks_interaction_t interaction, dt_masks_increment_t increment,
                                                    float min, float max, float step, float value, int digits,
                                                    const char *format, float factor,
                                                    dt_masks_form_gui_t *gui, dt_iop_module_t *module)
{
  GtkWidget *menu_item = gtk_menu_item_new();
  GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
 
  gtk_widget_set_can_focus(menu_item, FALSE);
  g_signal_connect(G_OBJECT(menu_item), "activate",
                   G_CALLBACK(_masks_gui_menu_item_block_activate), NULL);
  gtk_widget_add_events(menu_item, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
                                   | GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK);
 
  GtkWidget *slider = dt_bauhaus_slider_new_with_range(darktable.bauhaus, module ? DT_GUI_MODULE(module) : NULL,
                                                       min, max, step, value, digits);
  dt_bauhaus_widget_set_label(slider, label);
  dt_bauhaus_slider_set_digits(slider, digits);
  if(format && format[0] != '\0') dt_bauhaus_slider_set_format(slider, format);
  if(factor != 1.0f) dt_bauhaus_slider_set_factor(slider, factor);
  dt_bauhaus_slider_set(slider, value);
  DT_BAUHAUS_WIDGET(slider)->expand = TRUE;
  gtk_widget_set_hexpand(slider, TRUE);
  gtk_widget_set_halign(slider, GTK_ALIGN_FILL);
  gtk_widget_set_valign(slider, GTK_ALIGN_CENTER);
  gtk_widget_set_size_request(slider, DT_PIXEL_APPLY_DPI(220), DT_PIXEL_APPLY_DPI(28));
  gtk_widget_set_can_focus(slider, TRUE);
 
  dt_masks_gui_interaction_slider_t *data = g_malloc0(sizeof(dt_masks_gui_interaction_slider_t));
  data->form_group = form_group;
  data->gui = gui;
  data->module = module;
  data->interaction = interaction;
  data->increment = increment;
  data->last_value = value;
  data->slider = slider;
  g_signal_connect_data(G_OBJECT(slider), "value-changed",
                        G_CALLBACK(_masks_gui_interaction_slider_changed),
                        data, (GClosureNotify)g_free, 0);
  g_signal_connect(G_OBJECT(menu_item), "button-press-event",
                   G_CALLBACK(_masks_gui_menu_item_forward_event), data);
  g_signal_connect(G_OBJECT(menu_item), "button-release-event",
                   G_CALLBACK(_masks_gui_menu_item_forward_event), data);
  g_signal_connect(G_OBJECT(menu_item), "motion-notify-event",
                   G_CALLBACK(_masks_gui_menu_item_forward_event), data);
  g_signal_connect(G_OBJECT(menu_item), "scroll-event",
                   G_CALLBACK(_masks_gui_menu_item_forward_event), data);
 
  gtk_box_pack_start(GTK_BOX(box), slider, TRUE, TRUE, 0);
  gtk_container_add(GTK_CONTAINER(menu_item), box);
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
 
  return menu_item;
}
 
int dt_masks_gui_confirm_delete_form_dialog(const char *form_name)
{
  if(IS_NULL_PTR(darktable.gui) || IS_NULL_PTR(darktable.gui->ui)) return GTK_RESPONSE_NO;
 
  GtkWidget *dialog = gtk_message_dialog_new(
      GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)),
      GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
      GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, _("Delete the shape '%s' ?"), form_name);
  gtk_message_dialog_format_secondary_text(
      GTK_MESSAGE_DIALOG(dialog), "'%s' %s\n\n%s", form_name,
      _("will no longer be used."),
      _("Do you want to permanently delete it, or keep it unused for potential reuse?"));
 
  gtk_dialog_add_button(GTK_DIALOG(dialog), _("Delete shape"), GTK_RESPONSE_YES);
  gtk_dialog_add_button(GTK_DIALOG(dialog), _("Keep unused shape"), GTK_RESPONSE_NO);
  gtk_dialog_add_button(GTK_DIALOG(dialog), _("Cancel"), GTK_RESPONSE_CANCEL);
  gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
 
  const int response = gtk_dialog_run(GTK_DIALOG(dialog));
  gtk_widget_destroy(dialog);
 
  return response;
}
 
static void _masks_gui_delete_form_callback(GtkWidget *menu, gpointer user_data)
{
  dt_masks_form_gui_t *gui = (dt_masks_form_gui_t *)user_data;
  if(IS_NULL_PTR(gui)) return;
  dt_masks_form_t *forms = dt_masks_get_visible_form(darktable.develop);
  if(IS_NULL_PTR(forms)) return;
 
  if(gui->group_selected >= 0)
  {
    // Delete shape from current group
    dt_masks_form_group_t *fpt = dt_masks_form_get_selected_group(forms, gui);
    if(IS_NULL_PTR(fpt)) return;
    dt_iop_module_t *module = darktable.develop->gui_module;
    if(IS_NULL_PTR(module)) return;
    dt_masks_form_t *sel = dt_masks_get_from_id(darktable.develop, fpt->formid);
    if(IS_NULL_PTR(sel)) return;
 
    const int parentid = fpt->parentid;
    const int formid = fpt->formid;
  
    dt_masks_remove_or_delete(module, sel, parentid, gui, formid);
 
  }
}
 
void _masks_gui_delete_node_callback(GtkWidget *menu, gpointer user_data)
{
  dt_masks_form_gui_t *gui = (dt_masks_form_gui_t *)user_data;
  if(IS_NULL_PTR(gui)) return;
  dt_masks_form_t *forms = dt_masks_get_visible_form(darktable.develop);
  if(IS_NULL_PTR(forms)) return;
 
  dt_iop_module_t *module = darktable.develop->gui_module;
  if(IS_NULL_PTR(module)) return;
 
  if(gui->creation)
  {
    // Minimum points to create a polygon
    if(gui->node_dragging < 1)
    {
      dt_masks_form_exit_creation(module, gui);
      return;
    }
    dt_masks_form_t *sel = dt_masks_get_visible_form(darktable.develop);
    if(sel)
      dt_masks_remove_node(module, sel, 0, gui, 0, gui->node_dragging);
    gui->node_dragging -= 1;
  }
  else if(gui->group_selected >= 0)
  {
    // Delete shape from current group
 
    dt_masks_form_group_t *fpt = dt_masks_form_get_selected_group(forms, gui);
    if(IS_NULL_PTR(fpt)) return;
    dt_masks_form_t *sel = dt_masks_get_from_id(darktable.develop, fpt->formid);
    if(sel)
      dt_masks_remove_node(module, sel, fpt->parentid, gui, gui->group_selected, gui->node_hovered);
 
    dt_dev_add_history_item(darktable.develop, module, TRUE, TRUE);
  }
}
 
static void _masks_gui_exit_creation_callback(GtkWidget *menu, gpointer user_data)
{
  dt_masks_form_gui_t *gui = (dt_masks_form_gui_t *)user_data;
  dt_iop_module_t *module = darktable.develop->gui_module;
  dt_masks_form_exit_creation(module, gui);
}
 
static void _masks_move_up_down_callback(gpointer user_data, const int up)
{
  dt_masks_form_gui_t *gui = (dt_masks_form_gui_t *)user_data;
  if(IS_NULL_PTR(gui)) return;
  if(gui->group_selected < 0) return;
 
  dt_iop_module_t *module = darktable.develop->gui_module;
  if(IS_NULL_PTR(module)) return;
 
  dt_masks_form_t *forms = dt_masks_get_visible_form(darktable.develop);
  if(IS_NULL_PTR(forms)) return;
  dt_masks_form_group_t *fpt = dt_masks_form_get_selected_group(forms, gui);
  if(IS_NULL_PTR(fpt)) return;
  dt_masks_form_t *grp = dt_masks_get_from_id(darktable.develop, fpt->parentid);
  if(IS_NULL_PTR(grp) || !(grp->type & DT_MASKS_GROUP)) return;
 
  dt_masks_form_move(grp, fpt->formid, up);
 
  DT_DEBUG_CONTROL_SIGNAL_RAISE(darktable.signals, DT_SIGNAL_MASK_CHANGED, fpt->formid, fpt->parentid, DT_MASKS_EVENT_CHANGE);
}
 
static void _masks_moveup_callback(GtkWidget *menu, gpointer user_data)
{
  _masks_move_up_down_callback(user_data, 0);
}
 
static void _masks_movedown_callback(GtkWidget *menu, gpointer user_data)
{
  _masks_move_up_down_callback(user_data, 1);
}
 
static void _masks_operation_callback(GtkWidget *menu, gpointer user_data)
{
  dt_masks_form_gui_t *gui = (dt_masks_form_gui_t *)user_data;
  if(IS_NULL_PTR(gui) || IS_NULL_PTR(menu)) return;
 
  const guint form_pos = GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(menu), "form_pos"));
  const dt_masks_state_t state_op = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu), "state_op"));
  // Advert the user if it will have no effect
  if(form_pos == 0 && (state_op & DT_MASKS_STATE_IS_COMBINE_OP) != 0)
  {
    dt_control_log(_("Applying a boolean operation has no effect on the first shape of a group.\n"
         "Move it to at least the 2nd position if you need to use boolean operations"));
  }
 
  dt_masks_form_group_t *form_op = (dt_masks_form_group_t *)g_object_get_data(G_OBJECT(menu), "op_form");
  if(IS_NULL_PTR(form_op)) return;
 
  apply_operation(form_op, state_op);
 
  DT_DEBUG_CONTROL_SIGNAL_RAISE(darktable.signals, DT_SIGNAL_MASK_CHANGED, form_op->formid, form_op->parentid, DT_MASKS_EVENT_UPDATE);
}
 
#define masks_gtk_menu_item_new_bold(label, selected, state, icon)                                        \
{                                                                                                         \
  gchar *op_label = g_strdup(label);                                                                      \
  menu_item = ctx_gtk_check_menu_item_new_with_markup_and_pixbuf(op_label, icon,                          \
                                                                    sub_menu,                             \
                                                                    _masks_operation_callback, gui,       \
                                                                    (selected != 0),                      \
                                                                    ((state) == DT_MASKS_STATE_INVERSE)); \
  dt_free(op_label);                                                                                       \
  op_label = NULL;                                                                                        \
  g_object_set_data(G_OBJECT(menu_item), "state_op", GINT_TO_POINTER(state));                             \
  g_object_set_data(G_OBJECT(menu_item), "op_form", op_form);                                             \
  g_object_set_data(G_OBJECT(menu_item), "form_pos", GINT_TO_POINTER(form_pos));                          \
}
 
 
GtkWidget *dt_masks_create_menu(dt_masks_form_gui_t *gui, dt_masks_form_t *form, const dt_masks_form_group_t *formgroup,
                                const float pzx, const float pzy)
{
  assert(gui);
  assert(form);
  // Always re-create the menu when we show it because we don't bother updating info during the lifetime of the mask
  GtkWidget *menu = gtk_menu_new();
  gtk_style_context_add_class(gtk_widget_get_style_context(menu), "dt-masks-context-menu");
 
  // Create an array of icons for the operations
  const int bs2 = DT_PIXEL_APPLY_DPI(13);
  GdkPixbuf *op_icon[DT_MASKS_STATE_EXCLUSION + 1] = { 0 };
  int width = bs2 * 2;
  op_icon[DT_MASKS_STATE_INVERSE] = dt_draw_get_pixbuf_from_cairo(dtgtk_cairo_paint_masks_inverse, width, bs2);
  op_icon[DT_MASKS_STATE_UNION] = dt_draw_get_pixbuf_from_cairo(dtgtk_cairo_paint_masks_union, width, bs2);
  op_icon[DT_MASKS_STATE_INTERSECTION] = dt_draw_get_pixbuf_from_cairo(dtgtk_cairo_paint_masks_intersection, width, bs2);
  op_icon[DT_MASKS_STATE_DIFFERENCE] = dt_draw_get_pixbuf_from_cairo(dtgtk_cairo_paint_masks_difference, width, bs2);
  op_icon[DT_MASKS_STATE_EXCLUSION] = dt_draw_get_pixbuf_from_cairo(dtgtk_cairo_paint_masks_exclusion, width, bs2);
 
  // Get the current group to apply operations on it if needed
  dt_masks_form_group_t *op_form = NULL;
  dt_masks_form_t *grp = formgroup ? dt_masks_get_from_id(darktable.develop, formgroup->parentid) : NULL;
  if(grp && (grp->type & DT_MASKS_GROUP))
    op_form = dt_masks_form_group_from_parentid(grp->formid, form->formid);
  if(IS_NULL_PTR(op_form) && !gui->creation)
  {
    for(size_t k = 0; k < G_N_ELEMENTS(op_icon); k++)
      g_clear_object(&op_icon[k]);
    gtk_widget_destroy(menu);
    return NULL;
  }
 
  // Find the position of the current form in the group
  guint form_pos = 0;
  gboolean form_found = FALSE;
  if(grp && (grp->type & DT_MASKS_GROUP))
  {
    for(GList *fpts = grp->points; fpts; fpts = g_list_next(fpts))
    {
      dt_masks_form_group_t *fpt = (dt_masks_form_group_t *)fpts->data;
      if(fpt->formid == form->formid)
      {
        form_found = TRUE;
        break;
      }
      form_pos++;
    }
  }
 
  // Get the number of shapes in the group
  guint list_length = (form_found && grp) ? g_list_length(grp->points) : 0;
 
 
  // Title
  gchar *form_name = NULL;
  if(form->name[0])
    form_name = g_strdup(form->name);
  else if(gui->creation)
  {
    // if no name, we are probably creating a new form, we create one based on the type
    form_name = g_strdup(_("New "));
    switch (form->type)
    {
      case DT_MASKS_CIRCLE:
        form_name = g_strconcat(form_name, _("circle"), NULL);
        break;
      case DT_MASKS_ELLIPSE:
        form_name = g_strconcat(form_name, _("ellipse"), NULL);
        break;
      case DT_MASKS_POLYGON:
        form_name = g_strconcat(form_name, _("polygon"), NULL);
        break;
      case DT_MASKS_BRUSH:
        form_name = g_strconcat(form_name, _("brush"), NULL);
        break;
      case DT_MASKS_GRADIENT:
        form_name = g_strconcat(form_name, _("gradient"), NULL);
        break;
      case DT_MASKS_GROUP:
        form_name = g_strconcat(form_name, _("mask"), NULL);
        break;
      default:
        dt_free(form_name); // Erase the "New " prefix
        form_name = g_strdup(_("Unknown shape"));
        break;
    }
  }
 
  // Create the main label string
  gchar *item_str = NULL;
  if(gui->node_hovered >= 0 || gui->seg_hovered >= 0)
  {
    const int item_index = (gui->node_hovered >= 0) ? gui->node_hovered : gui->seg_hovered;
    item_str = g_strdup_printf("%s %d - ", gui->node_hovered >= 0 ? _("Node") : _("Segment"), item_index);
  }
  else
    item_str = g_strdup("");
 
  // Create an assembled image if we have an inverse state to show
  const dt_masks_state_t state = IS_NULL_PTR(op_form) ? 0 : op_form->state & DT_MASKS_STATE_IS_COMBINE_OP;
  const gboolean has_inverse = !IS_NULL_PTR(op_form) && (op_form->state & DT_MASKS_STATE_INVERSE) != 0;
  GdkPixbuf *icon = (state <= DT_MASKS_STATE_EXCLUSION) ? op_icon[state] : NULL;
  GdkPixbuf *composed_icon = NULL;
  if(has_inverse && op_icon[DT_MASKS_STATE_INVERSE])
  {
    if(icon)
    {
      const int base_w = gdk_pixbuf_get_width(icon);
      const int base_h = gdk_pixbuf_get_height(icon);
      const int inv_w = gdk_pixbuf_get_width(op_icon[DT_MASKS_STATE_INVERSE]);
      const int inv_h = gdk_pixbuf_get_height(op_icon[DT_MASKS_STATE_INVERSE]);
      const int out_w = base_w + inv_w;
      const int out_h = MAX(base_h, inv_h);
 
      composed_icon = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, out_w, out_h);
      if(composed_icon)
      {
        gdk_pixbuf_fill(composed_icon, 0x00000000);
        gdk_pixbuf_copy_area(icon, 0, 0, base_w, base_h, composed_icon, 0, 0);
        gdk_pixbuf_copy_area(op_icon[DT_MASKS_STATE_INVERSE], 0, 0, inv_w, inv_h, composed_icon, base_w, 0);
        icon = composed_icon;
      }
    }
    else
      icon = op_icon[DT_MASKS_STATE_INVERSE];
  }
 
  const gboolean draw_icon = !IS_NULL_PTR(op_form) && form_pos > 0;
  gchar *title = g_strdup_printf("<b><big>%s%s</big></b>", item_str, form_name);
  GtkWidget *menu_item = ctx_gtk_menu_item_new_with_markup_and_pixbuf(title, (draw_icon) ? icon : NULL, menu, NULL, gui);
  gtk_widget_set_sensitive(menu_item, FALSE);
  dt_free(item_str);
  dt_free(title);
  dt_free(form_name);
 
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
 
    // Common menu items
  if(!gui->creation && (gui->form_selected || gui->node_selected) && op_form)
  {
    const float opacity = dt_masks_form_get_interaction_value(op_form, DT_MASKS_INTERACTION_OPACITY);
    const float hardness = dt_masks_form_get_interaction_value(op_form, DT_MASKS_INTERACTION_HARDNESS);
 
    _masks_gui_add_interaction_slider(menu, _("Size"), op_form, DT_MASKS_INTERACTION_SIZE,
                                      DT_MASKS_INCREMENT_SCALE, -4.f, 4.0f, 0.01f, 0.0f, 2, "x", 1.0f,
                                      gui, darktable.develop->gui_module);
    _masks_gui_add_interaction_slider(menu, _("Fading"), op_form, DT_MASKS_INTERACTION_HARDNESS,
                                      DT_MASKS_INCREMENT_ABSOLUTE, 0.f, 1.0f, 0.01f,
                                      isfinite(hardness) ? hardness : 1.0f, 3, "%", 100.0f,
                                      gui, darktable.develop->gui_module);
    _masks_gui_add_interaction_slider(menu, _("Opacity"), op_form, DT_MASKS_INTERACTION_OPACITY,
                                      DT_MASKS_INCREMENT_ABSOLUTE, 0.0f, 1.0f, 0.01f,
                                      isfinite(opacity) ? opacity : 1.0f, 3, "%", 100.0f,
                                      gui, darktable.develop->gui_module);
 
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
  }
 
  // Shape specific menu items
  if(!IS_NULL_PTR(form) && form->functions && form->functions->populate_context_menu)
    if(form->functions->populate_context_menu(menu, form, gui, pzx, pzy))
    {
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
    }
 
 
  /* Module specific */
  {
    dt_iop_module_t *module = darktable.develop->gui_module;
    if(!IS_NULL_PTR(module) && module->populate_masks_context_menu)
      if(module->populate_masks_context_menu(module, menu, form->formid, pzx, pzy))
      {
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
      }
  }
 
  /*  Operation */
 
  if(!gui->creation && !(form->type & DT_MASKS_IS_RETOUCHE) && (op_form) && !gui->node_selected)
  {
    menu_item = ctx_gtk_menu_item_new_with_markup(_("Operation"), menu, NULL, gui);
    GtkWidget *sub_menu = gtk_menu_new();
    gtk_style_context_add_class(gtk_widget_get_style_context(sub_menu), "dt-masks-context-menu");
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), sub_menu);
 
    masks_gtk_menu_item_new_bold(_("Invert"), (op_form->state & DT_MASKS_STATE_INVERSE), DT_MASKS_STATE_INVERSE,
                                 op_icon[DT_MASKS_STATE_INVERSE]);
    gtk_menu_shell_append(GTK_MENU_SHELL(sub_menu), gtk_separator_menu_item_new());
    masks_gtk_menu_item_new_bold(_("Union"), (op_form->state & DT_MASKS_STATE_UNION), DT_MASKS_STATE_UNION,
                                 op_icon[DT_MASKS_STATE_UNION]);
    masks_gtk_menu_item_new_bold(_("Intersection"), (op_form->state & DT_MASKS_STATE_INTERSECTION), DT_MASKS_STATE_INTERSECTION,
                                 op_icon[DT_MASKS_STATE_INTERSECTION]);
    masks_gtk_menu_item_new_bold(_("Difference"), (op_form->state & DT_MASKS_STATE_DIFFERENCE), DT_MASKS_STATE_DIFFERENCE,
                                 op_icon[DT_MASKS_STATE_DIFFERENCE]);
    masks_gtk_menu_item_new_bold(_("Exclusion"), (op_form->state & DT_MASKS_STATE_EXCLUSION), DT_MASKS_STATE_EXCLUSION,
                                 op_icon[DT_MASKS_STATE_EXCLUSION]);
 
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
  }
 
  if(!gui->creation && gui->form_selected)
  {
    menu_item = ctx_gtk_menu_item_new_with_markup(_("Move up"), menu, _masks_moveup_callback, gui);
    gtk_widget_set_sensitive(menu_item, (form_pos > 0));
    menu_item = ctx_gtk_menu_item_new_with_markup(_("Move down"), menu, _masks_movedown_callback, gui);
    gtk_widget_set_sensitive(menu_item, (form_pos < list_length - 1));
 
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
  }
 
  // Risky stuff at the end
  if(gui->creation)
  {
    menu_item = ctx_gtk_menu_item_new_with_markup(_("Done shape creation"), menu,
                                                  _masks_gui_exit_creation_callback, gui);
    menu_item_set_fake_accel(menu_item, GDK_KEY_Escape, 0);
  }
  else
  {
    if(gui->node_hovered >= 0)
    {
      menu_item = ctx_gtk_menu_item_new_with_markup(_("Delete node"), menu, _masks_gui_delete_node_callback, gui);
      menu_item_set_fake_accel(menu_item, GDK_KEY_Delete, 0);
    }
    else
    {
      menu_item = ctx_gtk_menu_item_new_with_markup(_("Remove shape from mask"), menu, _masks_gui_delete_form_callback, gui);
      menu_item_set_fake_accel(menu_item, GDK_KEY_Delete, 0);
      gtk_widget_set_sensitive(menu_item, gui->form_selected >= 0);
    }
  }
 
  for(size_t k = 0; k < G_N_ELEMENTS(op_icon); k++)
    g_clear_object(&op_icon[k]);
  g_clear_object(&composed_icon);
 
  gtk_widget_show_all(menu);
  return menu;
}
 
// 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