src/gui/actions/styles.c

Go to the documentation of this file.

/*
    This file is part of the Ansel project.
    Copyright (C) 2026 Aurélien PIERRE.
    Copyright (C) 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 Ansel.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "widgets/widget_settings.h"
#include "gui/actions/menu.h"
#ifdef __APPLE__
#include "osx/osx.h"   // dt_osx_disallow_fullscreen(), used under GDK_WINDOWING_QUARTZ below
#endif
#include "common/history_actions.h"
#include "gui/application.h"
#include "gui/styles.h"
#include "common/act_on.h"
#include "develop/history_merge.h"
#include "gui/develop/history_merge_gui.h"
#include "common/styles.h"
#include "common/usermanual_url.h"
#include "develop/dev_history.h"
#include "widgets/accelerators.h"
#include "common/conf.h"
#include "control/signal.h"
#include "libs/lib.h"
 
#include <glib.h>
#include "widgets/label.h"
 
static GtkWidget **_styles_menus = NULL;
static GList **_styles_lists = NULL;
static dt_menus_t _styles_index = DT_MENU_STYLES;
static gboolean _styles_signal_connected = FALSE;
static guint _styles_menu_rebuild_source = 0;
 
static gboolean _styles_menu_disabled(GtkWidget *widget)
{
  return FALSE;
}
 
static gboolean _styles_apply_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval,
                                       GdkModifierType mods, gpointer user_data)
{
  const char *style_name = get_custom_data(GTK_WIDGET(user_data));
  if(IS_NULL_PTR(style_name) || !*style_name) return FALSE;
 
  if(dt_conf_get_bool("history/style/ask"))
  {
    gchar *title = g_strdup_printf(_("Apply style \"%s\" — merge settings"), style_name);
    const gboolean ok = dt_gui_merge_options_dialog(title,
                                                    "history/style/mode",
                                                    "history/style/copy_iop_order",
                                                    "history/style/ask",
                                                    dt_styles_has_module_order(style_name));
    dt_free(title);
    if(!ok) return FALSE;
  }
 
  GList *imgs = dt_act_on_get_images();
  const gboolean duplicate = dt_conf_get_bool("ui_last/styles_create_duplicate");
  gboolean is_darkroom_image_in_list = dt_dev_history_is_image_in_dev(imgs);
 
  if(is_darkroom_image_in_list)
  {
    dt_develop_t *const dev = dt_dev_get_global();
    imgs = g_list_remove(imgs, GINT_TO_POINTER(dev->image_storage.id));
    dt_dev_undo_start_record(dev);
    const gboolean applied = dt_history_style_on_image(dev->image_storage.id, style_name, duplicate);
    dt_dev_undo_end_record(dev);
    if(applied)
      dt_apply_dev_history_update(dev);
  }
 
  if(imgs) dt_history_style_on_list(imgs, style_name, duplicate);
 
  g_list_free(imgs);
  imgs = NULL;
 
  return TRUE;
}
 
static gboolean _styles_create_sensitive_callback(GtkWidget *widget)
{
  return dt_act_on_get_images_nb(FALSE, FALSE) == 1;
}
 
static gboolean _styles_create_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval,
                                        GdkModifierType mods, gpointer user_data)
{
  const int32_t imgid = dt_act_on_get_first_image();
  if(imgid <= 0) return FALSE;
 
  dt_gui_styles_dialog_new(imgid);
  return TRUE;
}
 
static void _close_styles_popup(GtkWidget *dialog, gint response_id, gpointer data)
{
  dt_gui_get_global()->styles_popup.module = (GtkWidget *)g_object_ref(dt_gui_get_global()->styles_popup.module);
  GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(dt_gui_get_global()->styles_popup.window));
  gtk_container_remove(GTK_CONTAINER(content), dt_gui_get_global()->styles_popup.module);
  dt_gui_get_global()->styles_popup.window = NULL;
}
 
static gboolean _styles_open_popup_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval,
                                            GdkModifierType mods, gpointer user_data)
{
  if(dt_gui_get_global()->styles_popup.window)
  {
    gtk_window_present_with_time(GTK_WINDOW(dt_gui_get_global()->styles_popup.window), GDK_CURRENT_TIME);
    return TRUE;
  }
 
  dt_lib_module_t *module = dt_lib_get_module("styles");
  if(IS_NULL_PTR(module)) return TRUE;
 
  GtkWidget *w = dt_gui_get_global()->styles_popup.module
                  ? dt_gui_get_global()->styles_popup.module
                  : dt_lib_gui_get_expander(module);
  if(IS_NULL_PTR(w)) return TRUE;
 
  dt_gui_get_global()->styles_popup.module = w;
 
  GtkWidget *dialog = gtk_dialog_new();
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(dialog);
  gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
#endif
  gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);
  gtk_window_set_modal(GTK_WINDOW(dialog), FALSE);
  gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(dt_gui_main_window()));
  gtk_window_set_title(GTK_WINDOW(dialog), _("Ansel - Styles"));
  g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(_close_styles_popup), NULL);
 
  dt_lib_gui_set_expanded(module, TRUE);
  dt_gui_add_help_link(w, dt_get_help_url(module->plugin_name));
  gtk_widget_set_size_request(w, DT_PIXEL_APPLY_DPI(450), -1);
 
  GtkWidget *content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
  gtk_box_pack_start(GTK_BOX(content), w, TRUE, TRUE, 0);
  gtk_widget_set_visible(w, TRUE);
  gtk_widget_show_all(dialog);
 
  dt_gui_get_global()->styles_popup.window = dialog;
  return TRUE;
}
 
static gchar *_styles_build_tooltip(const dt_style_t *style)
{
  char *items_string = dt_styles_get_item_list_as_string(style->name);
  gchar *tooltip = NULL;
 
  if(items_string && *items_string)
  {
    if(style->description && *style->description)
    {
      gchar *desc = g_markup_escape_text(style->description, -1);
      tooltip = g_strconcat("<b>", desc, "</b>\n", items_string, NULL);
      dt_free(desc);
    }
    else
    {
      tooltip = g_strdup(items_string);
    }
  }
  else if(style->description && *style->description)
  {
    tooltip = g_markup_escape_text(style->description, -1);
  }
 
  dt_free(items_string);
  return tooltip;
}
 
static GtkWidget *_styles_get_submenu(GtkWidget **menus, GList **lists, GHashTable *submenus,
                                      GtkWidget *parent, const gchar *path, const gchar *label,
                                      const dt_menus_t index)
{
  if(IS_NULL_PTR(parent) || IS_NULL_PTR(path) || !*path || IS_NULL_PTR(label) || !*label)
    return parent;
 
  GtkWidget *submenu = g_hash_table_lookup(submenus, path);
  if(submenu) return submenu;
 
  gchar *menu_label = g_markup_escape_text(label, -1);
  if(IS_NULL_PTR(menu_label)) menu_label = g_strdup("");
 
  submenu = gtk_menu_new();
  gtk_menu_set_accel_group(GTK_MENU(submenu), dt_gui_get_accels()->global_accels);
 
  gchar *clean_label = strip_markup(menu_label);
  gchar *accel_path = dt_accels_build_path(gtk_menu_get_accel_path(GTK_MENU(parent)), clean_label);
  gtk_menu_set_accel_path(GTK_MENU(submenu), accel_path);
  dt_free(accel_path);
  dt_free(clean_label);
 
  dt_menu_entry_t *entry = set_menu_entry(menus, lists, menu_label, index, GTK_MENU(parent), NULL,
                                          NULL, NULL, NULL, NULL, 0, 0,
                                          dt_gui_get_accels()->global_accels);
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(entry->widget), submenu);
  gtk_menu_shell_append(GTK_MENU_SHELL(parent), entry->widget);
 
  g_hash_table_insert(submenus, g_strdup(path), submenu);
  dt_free(menu_label);
  return submenu;
}
 
static void _styles_add_menu_entry(GtkWidget **menus, GList **lists, GtkWidget *parent, const dt_menus_t index,
                                   const gchar *label, const gchar *tooltip, const gchar *style_name)
{
  dt_menu_entry_t *entry = set_menu_entry(menus, lists, label, index, GTK_MENU(parent), NULL,
                                          _styles_apply_callback, NULL, NULL, has_active_images,
                                          0, 0, dt_gui_get_accels()->global_accels);
 
  gtk_menu_shell_append(GTK_MENU_SHELL(parent), entry->widget);
  gtk_menu_item_set_reserve_indicator(GTK_MENU_ITEM(entry->widget), TRUE);
  g_object_set_data_full(G_OBJECT(entry->widget), "custom-data", g_strdup(style_name), g_free);
 
  if(tooltip)
    gtk_widget_set_tooltip_markup(entry->widget, tooltip);
}
 
static gboolean _styles_history_prepend_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval,
                                                 GdkModifierType mods, gpointer user_data)
{
  dt_conf_set_int("history/style/mode", DT_HISTORY_MERGE_PREPEND);
  return TRUE;
}
 
static gboolean _styles_history_prepend_checked_callback(GtkWidget *widget)
{
  return dt_conf_get_int("history/style/mode") == DT_HISTORY_MERGE_PREPEND;
}
 
static gboolean _styles_history_append_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval,
                                                GdkModifierType mods, gpointer user_data)
{
  dt_conf_set_int("history/style/mode", DT_HISTORY_MERGE_APPEND);
  return TRUE;
}
 
static gboolean _styles_history_append_checked_callback(GtkWidget *widget)
{
  return dt_conf_get_int("history/style/mode") == DT_HISTORY_MERGE_APPEND;
}
 
static gboolean _styles_history_replace_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval,
                                                 GdkModifierType mods, gpointer user_data)
{
  dt_conf_set_int("history/style/mode", DT_HISTORY_MERGE_REPLACE);
  return TRUE;
}
 
static gboolean _styles_history_replace_checked_callback(GtkWidget *widget)
{
  return dt_conf_get_int("history/style/mode") == DT_HISTORY_MERGE_REPLACE;
}
 
static gboolean _styles_copy_iop_order_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval,
                                                GdkModifierType mods, gpointer user_data)
{
  dt_conf_set_bool("history/style/copy_iop_order", !dt_conf_get_bool("history/style/copy_iop_order"));
  return TRUE;
}
 
static gboolean _styles_copy_iop_order_checked_callback(GtkWidget *widget)
{
  return dt_conf_get_bool("history/style/copy_iop_order");
}
 
static gboolean _styles_ask_callback(GtkAccelGroup *group, GObject *acceleratable, guint keyval,
                                     GdkModifierType mods, gpointer user_data)
{
  dt_conf_set_bool("history/style/ask", !dt_conf_get_bool("history/style/ask"));
  return TRUE;
}
 
static gboolean _styles_ask_checked_callback(GtkWidget *widget)
{
  return dt_conf_get_bool("history/style/ask");
}
 
static void _styles_menu_clear(void)
{
  if(IS_NULL_PTR(_styles_menus) || !_styles_lists) return;
 
  GtkWidget *menu = _styles_menus[_styles_index];
  GList *children = gtk_container_get_children(GTK_CONTAINER(menu));
  for(GList *child = children; child; child = g_list_next(child))
    gtk_widget_destroy(GTK_WIDGET(child->data));
  g_list_free(children);
  children = NULL;
 
  if(*_styles_lists)
  {
    // Menu entries are owned by their GtkMenuItem: set_menu_entry() frees the
    // dt_menu_entry_t from the widget "destroy" signal. Only the temporary list
    // nodes need to be released here after destroying the menu children above.
    g_list_free(*_styles_lists);
    *_styles_lists = NULL;
  }
}
 
static gboolean _styles_menu_rebuild_idle(gpointer user_data)
{
  if(IS_NULL_PTR(_styles_menus) || !_styles_lists)
  {
    _styles_menu_rebuild_source = 0;
    return G_SOURCE_REMOVE;
  }
 
  _styles_menu_clear();
  append_styles(_styles_menus, _styles_lists, _styles_index);
  gtk_widget_show_all(_styles_menus[_styles_index]);
  gtk_widget_queue_resize(_styles_menus[_styles_index]);
 
  _styles_menu_rebuild_source = 0;
  return G_SOURCE_REMOVE;
}
 
static void _styles_menu_rebuild_callback(gpointer instance, gpointer user_data)
{
  if(_styles_menu_rebuild_source == 0)
    _styles_menu_rebuild_source = g_idle_add(_styles_menu_rebuild_idle, NULL);
}
 
 
void append_styles(GtkWidget **menus, GList **lists, const dt_menus_t index)
{
  _styles_menus = menus;
  _styles_lists = lists;
  _styles_index = index;
  if(!_styles_signal_connected)
  {
    DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_STYLE_CHANGED,
                                    G_CALLBACK(_styles_menu_rebuild_callback), NULL);
    _styles_signal_connected = TRUE;
  }
 
  GList *styles = dt_styles_get_list("");
 
  if(IS_NULL_PTR(styles))
  {
    add_sub_menu_entry(menus, lists, _("No styles available"), index, NULL, NULL, NULL, NULL,
                       _styles_menu_disabled, 0, 0);
  }
  else
  {
    GHashTable *submenus = g_hash_table_new_full(g_str_hash, g_str_equal, dt_free_gpointer, NULL);
 
    for(GList *iter = styles; iter; iter = g_list_next(iter))
    {
      dt_style_t *style = (dt_style_t *)iter->data;
      if(IS_NULL_PTR(style) || IS_NULL_PTR(style->name)) continue;
 
      gchar **split = g_strsplit(style->name, "|", -1);
      gchar *tooltip = _styles_build_tooltip(style);
 
      int leaf = -1;
      for(int i = 0; split[i]; i++)
        if(split[i][0] != '\0')
          leaf = i;
 
      GtkWidget *parent_menu = menus[index];
      GString *submenu_path = g_string_new(NULL);
      for(int i = 0; i < leaf; i++)
      {
        if(split[i][0] == '\0') continue;
 
        if(submenu_path->len > 0)
          g_string_append_c(submenu_path, '|');
        g_string_append(submenu_path, split[i]);
        parent_menu = _styles_get_submenu(menus, lists, submenus, parent_menu,
                                          submenu_path->str, split[i], index);
      }
 
      gchar *label = g_markup_escape_text(leaf >= 0 ? split[leaf] : style->name, -1);
      if(IS_NULL_PTR(label)) label = g_strdup("");
      _styles_add_menu_entry(menus, lists, parent_menu, index, label, tooltip, style->name);
 
      g_string_free(submenu_path, TRUE);
      dt_free(label);
      dt_free(tooltip);
      g_strfreev(split);
    }
 
    g_hash_table_destroy(submenus);
    g_list_free_full(styles, dt_style_free);
    styles = NULL;
  }
 
  add_menu_separator(menus[index]);
 
  add_top_submenu_entry(menus, lists, _("History pasting mode"), index);
  GtkWidget *parent = get_last_widget(lists);
 
  add_sub_sub_menu_entry(menus, parent, lists, _("Prepend"), index, NULL,
                         _styles_history_prepend_callback, _styles_history_prepend_checked_callback, NULL, NULL, 0, 0);
  gtk_widget_set_tooltip_text(get_last_widget(lists),
                              _("Apply style BEFORE the current history.\n"
                                "CURRENT EDITS are applied afterwards and win conflicts."));
 
  add_sub_sub_menu_entry(menus, parent, lists, _("Append"), index, NULL,
                         _styles_history_append_callback, _styles_history_append_checked_callback, NULL, NULL, 0, 0);
  gtk_widget_set_tooltip_text(get_last_widget(lists),
                              _("Apply style AFTER the current history.\n"
                                "STYLE EDITS are applied afterwards and win conflicts."));
 
  add_sub_sub_menu_entry(menus, parent, lists, _("Replace"), index, NULL,
                         _styles_history_replace_callback, _styles_history_replace_checked_callback, NULL, NULL, 0, 0);
  gtk_widget_set_tooltip_text(get_last_widget(lists),
                              _("Discard the current history and replace it entirely with the style."));
 
  add_top_submenu_entry(menus, lists, _("Nodes pasting mode"), index);
  parent = get_last_widget(lists);
 
  add_sub_sub_menu_entry(menus, parent, lists, _("Copy module order"), index, NULL,
                         _styles_copy_iop_order_callback, _styles_copy_iop_order_checked_callback, NULL, NULL, 0, 0);
 
  add_sub_menu_entry(menus, lists, _("Ask merge settings before apply"), index, NULL,
                     _styles_ask_callback, _styles_ask_checked_callback, NULL, NULL, 0, 0);
 
  add_menu_separator(menus[index]);
  add_sub_menu_entry(menus, lists, _("Create new style..."), index, NULL,
                     _styles_create_callback, NULL, NULL, _styles_create_sensitive_callback, 0, 0);
 
  add_sub_menu_entry(menus, lists, _("Manage styles..."), index, NULL,
                     _styles_open_popup_callback, NULL, NULL, NULL, 0, 0);
}
 
// 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