iop/drawlayer/conf.c

Go to the documentation of this file.

/*
    This file is part of the Ansel project.
    Copyright (C) 2026 Aurélien PIERRE.
 
    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 "iop/drawlayer/conf.h"
 
#include "iop/drawlayer/runtime.h"    // dt_iop_drawlayer_gui_data_t (dereferenced here)
#include "iop/drawlayer/widgets.h"    // DT_DRAWLAYER_COLOR_HISTORY_COUNT, ..._set_color_history()
 
#include "control/redraw.h"           // dt_control_queue_redraw_center()
#include "develop/imageop_gui.h"      // dt_iop_gui_data()
#include "gui/application.h"          // dt_gui_get_global()
#include "widgets/widget_settings.h"  // dt_gui_widgets_suppressed()
#include "widgets/bauhaus.h"          // dt_bauhaus_slider_get(), dt_bauhaus_combobox_get()
 
/*
 * drawlayer config subsystem
 *
 * This file intentionally has no public header/API.
 */
 
void dt_drawlayer_conf_ensure_defaults(void)
{
  if(!dt_conf_key_exists(DRAWLAYER_CONF_BRUSH_SHAPE)) dt_conf_set_int(DRAWLAYER_CONF_BRUSH_SHAPE, DT_DRAWLAYER_BRUSH_SHAPE_LINEAR);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_BRUSH_MODE)) dt_conf_set_int(DRAWLAYER_CONF_BRUSH_MODE, DT_DRAWLAYER_BRUSH_MODE_PAINT);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_COLOR_R)) dt_conf_set_float(DRAWLAYER_CONF_COLOR_R, 1.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_COLOR_G)) dt_conf_set_float(DRAWLAYER_CONF_COLOR_G, 1.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_COLOR_B)) dt_conf_set_float(DRAWLAYER_CONF_COLOR_B, 1.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_SOFTNESS)) dt_conf_set_float(DRAWLAYER_CONF_SOFTNESS, 0.5f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_OPACITY)) dt_conf_set_float(DRAWLAYER_CONF_OPACITY, 100.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_FLOW)) dt_conf_set_float(DRAWLAYER_CONF_FLOW, 100.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_SPRINKLES)) dt_conf_set_float(DRAWLAYER_CONF_SPRINKLES, 0.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_SPRINKLE_SIZE)) dt_conf_set_float(DRAWLAYER_CONF_SPRINKLE_SIZE, 3.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_SPRINKLE_COARSENESS)) dt_conf_set_float(DRAWLAYER_CONF_SPRINKLE_COARSENESS, 50.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_DISTANCE)) dt_conf_set_float(DRAWLAYER_CONF_DISTANCE, 0.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_SMOOTHING)) dt_conf_set_float(DRAWLAYER_CONF_SMOOTHING, 0.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_SIZE)) dt_conf_set_float(DRAWLAYER_CONF_SIZE, 64.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_PICK_SOURCE)) dt_conf_set_int(DRAWLAYER_CONF_PICK_SOURCE, DRAWLAYER_PICK_SOURCE_INPUT);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_HDR_EV)) dt_conf_set_float(DRAWLAYER_CONF_HDR_EV, 0.0f);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_PRESSURE_SIZE)) dt_conf_set_bool(DRAWLAYER_CONF_MAP_PRESSURE_SIZE, FALSE);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_PRESSURE_OPACITY)) dt_conf_set_bool(DRAWLAYER_CONF_MAP_PRESSURE_OPACITY, FALSE);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_PRESSURE_FLOW)) dt_conf_set_bool(DRAWLAYER_CONF_MAP_PRESSURE_FLOW, FALSE);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_PRESSURE_SOFTNESS)) dt_conf_set_bool(DRAWLAYER_CONF_MAP_PRESSURE_SOFTNESS, FALSE);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_TILT_SIZE)) dt_conf_set_bool(DRAWLAYER_CONF_MAP_TILT_SIZE, FALSE);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_TILT_OPACITY)) dt_conf_set_bool(DRAWLAYER_CONF_MAP_TILT_OPACITY, FALSE);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_TILT_FLOW)) dt_conf_set_bool(DRAWLAYER_CONF_MAP_TILT_FLOW, FALSE);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_TILT_SOFTNESS)) dt_conf_set_bool(DRAWLAYER_CONF_MAP_TILT_SOFTNESS, FALSE);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_ACCEL_SIZE))
  {
    const gboolean migrated = dt_conf_key_exists(DRAWLAYER_CONF_BASE "map_speed_size")
                                  ? dt_conf_get_bool(DRAWLAYER_CONF_BASE "map_speed_size")
                                  : FALSE;
    dt_conf_set_bool(DRAWLAYER_CONF_MAP_ACCEL_SIZE, migrated);
  }
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_ACCEL_OPACITY))
  {
    const gboolean migrated = dt_conf_key_exists(DRAWLAYER_CONF_BASE "map_speed_opacity")
                                  ? dt_conf_get_bool(DRAWLAYER_CONF_BASE "map_speed_opacity")
                                  : FALSE;
    dt_conf_set_bool(DRAWLAYER_CONF_MAP_ACCEL_OPACITY, migrated);
  }
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_ACCEL_FLOW))
  {
    const gboolean migrated = dt_conf_key_exists(DRAWLAYER_CONF_BASE "map_speed_flow")
                                  ? dt_conf_get_bool(DRAWLAYER_CONF_BASE "map_speed_flow")
                                  : FALSE;
    dt_conf_set_bool(DRAWLAYER_CONF_MAP_ACCEL_FLOW, migrated);
  }
  if(!dt_conf_key_exists(DRAWLAYER_CONF_MAP_ACCEL_SOFTNESS))
  {
    const gboolean migrated = dt_conf_key_exists(DRAWLAYER_CONF_BASE "map_speed_softness")
                                  ? dt_conf_get_bool(DRAWLAYER_CONF_BASE "map_speed_softness")
                                  : FALSE;
    dt_conf_set_bool(DRAWLAYER_CONF_MAP_ACCEL_SOFTNESS, migrated);
  }
  if(!dt_conf_key_exists(DRAWLAYER_CONF_PRESSURE_PROFILE)) dt_conf_set_int(DRAWLAYER_CONF_PRESSURE_PROFILE, DRAWLAYER_PROFILE_LINEAR);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_TILT_PROFILE)) dt_conf_set_int(DRAWLAYER_CONF_TILT_PROFILE, DRAWLAYER_PROFILE_LINEAR);
  if(!dt_conf_key_exists(DRAWLAYER_CONF_ACCEL_PROFILE)) dt_conf_set_int(DRAWLAYER_CONF_ACCEL_PROFILE, DRAWLAYER_PROFILE_LINEAR);
}
 
dt_iop_drawlayer_brush_shape_t dt_drawlayer_conf_brush_shape(void)
{
  return (dt_iop_drawlayer_brush_shape_t)CLAMP(dt_conf_get_int(DRAWLAYER_CONF_BRUSH_SHAPE),
                                               DT_DRAWLAYER_BRUSH_SHAPE_LINEAR, DT_DRAWLAYER_BRUSH_SHAPE_SIGMOIDAL);
}
 
dt_iop_drawlayer_brush_mode_t dt_drawlayer_conf_brush_mode(void)
{
  return (dt_iop_drawlayer_brush_mode_t)CLAMP(dt_conf_get_int(DRAWLAYER_CONF_BRUSH_MODE),
                                              DT_DRAWLAYER_BRUSH_MODE_PAINT, DT_DRAWLAYER_BRUSH_MODE_SMUDGE);
}
 
float dt_drawlayer_conf_size(void)
{
  return CLAMP(dt_conf_get_float(DRAWLAYER_CONF_SIZE), 1.0f, 2048.0f);
}
 
float dt_drawlayer_conf_opacity(void)
{
  return CLAMP(dt_conf_get_float(DRAWLAYER_CONF_OPACITY), 0.0f, 100.0f);
}
 
float dt_drawlayer_conf_flow(void)
{
  return CLAMP(dt_conf_get_float(DRAWLAYER_CONF_FLOW), 0.0f, 100.0f);
}
 
float dt_drawlayer_conf_sprinkles(void)
{
  return CLAMP(dt_conf_get_float(DRAWLAYER_CONF_SPRINKLES), 0.0f, 100.0f);
}
 
float dt_drawlayer_conf_sprinkle_size(void)
{
  return CLAMP(dt_conf_get_float(DRAWLAYER_CONF_SPRINKLE_SIZE), 1.0f, 256.0f);
}
 
float dt_drawlayer_conf_sprinkle_coarseness(void)
{
  return CLAMP(dt_conf_get_float(DRAWLAYER_CONF_SPRINKLE_COARSENESS), 0.0f, 100.0f);
}
 
float dt_drawlayer_conf_distance(void)
{
  return CLAMP(dt_conf_get_float(DRAWLAYER_CONF_DISTANCE), 0.0f, 100.0f);
}
 
float dt_drawlayer_conf_smoothing(void)
{
  return CLAMP(dt_conf_get_float(DRAWLAYER_CONF_SMOOTHING), 0.0f, 100.0f);
}
 
static float _conf_softness(void)
{
  return _clamp01(dt_conf_get_float(DRAWLAYER_CONF_SOFTNESS));
}
 
float dt_drawlayer_conf_hardness(void)
{
  return 1.0f - _conf_softness();
}
 
float dt_drawlayer_conf_hdr_exposure(void)
{
  return CLAMP(dt_conf_get_float(DRAWLAYER_CONF_HDR_EV), 0.0f, 4.0f);
}
 
drawlayer_pick_source_t dt_drawlayer_conf_pick_source(void)
{
  return (drawlayer_pick_source_t)CLAMP(dt_conf_get_int(DRAWLAYER_CONF_PICK_SOURCE),
                                        DRAWLAYER_PICK_SOURCE_INPUT, DRAWLAYER_PICK_SOURCE_OUTPUT);
}
 
drawlayer_mapping_profile_t dt_drawlayer_conf_mapping_profile(const char *key)
{
  return (drawlayer_mapping_profile_t)CLAMP(dt_conf_get_int(key), DRAWLAYER_PROFILE_LINEAR,
                                            DRAWLAYER_PROFILE_INV_QUADRATIC);
}
 
void dt_drawlayer_conf_display_color(float rgb[3])
{
  rgb[0] = _clamp01(dt_conf_get_float(DRAWLAYER_CONF_COLOR_R));
  rgb[1] = _clamp01(dt_conf_get_float(DRAWLAYER_CONF_COLOR_G));
  rgb[2] = _clamp01(dt_conf_get_float(DRAWLAYER_CONF_COLOR_B));
}
 
static void _color_history_key(const int index, const char channel, char *key, const size_t key_size)
{
  g_snprintf(key, key_size, DRAWLAYER_CONF_BASE "color_history_%d_%c", index, channel);
}
 
static void _color_history_valid_key(const int index, char *key, const size_t key_size)
{
  g_snprintf(key, key_size, DRAWLAYER_CONF_BASE "color_history_%d_valid", index);
}
 
void dt_drawlayer_conf_load_color_history(dt_iop_drawlayer_gui_data_t *g)
{
  if(IS_NULL_PTR(g) || !g->ui.widgets) return;
 
  float history[DT_DRAWLAYER_COLOR_HISTORY_COUNT][3] = { { 0.0f } };
  gboolean valid[DT_DRAWLAYER_COLOR_HISTORY_COUNT] = { FALSE };
 
  char key[128] = { 0 };
  for(int i = 0; i < DT_DRAWLAYER_COLOR_HISTORY_COUNT; i++)
  {
    _color_history_valid_key(i, key, sizeof(key));
    valid[i] = dt_conf_key_exists(key) ? dt_conf_get_bool(key) : FALSE;
 
    _color_history_key(i, 'r', key, sizeof(key));
    history[i][0] = _clamp01(dt_conf_key_exists(key) ? dt_conf_get_float(key) : 0.0f);
    _color_history_key(i, 'g', key, sizeof(key));
    history[i][1] = _clamp01(dt_conf_key_exists(key) ? dt_conf_get_float(key) : 0.0f);
    _color_history_key(i, 'b', key, sizeof(key));
    history[i][2] = _clamp01(dt_conf_key_exists(key) ? dt_conf_get_float(key) : 0.0f);
  }
  dt_drawlayer_widgets_set_color_history(g->ui.widgets, history, valid);
}
 
static void _store_color_history(const dt_iop_drawlayer_gui_data_t *g)
{
  if(IS_NULL_PTR(g) || !g->ui.widgets) return;
 
  float history[DT_DRAWLAYER_COLOR_HISTORY_COUNT][3] = { { 0.0f } };
  gboolean valid[DT_DRAWLAYER_COLOR_HISTORY_COUNT] = { FALSE };
  dt_drawlayer_widgets_get_color_history(g->ui.widgets, history, valid);
 
  char key[128] = { 0 };
  for(int i = 0; i < DT_DRAWLAYER_COLOR_HISTORY_COUNT; i++)
  {
    _color_history_valid_key(i, key, sizeof(key));
    dt_conf_set_bool(key, valid[i]);
 
    _color_history_key(i, 'r', key, sizeof(key));
    dt_conf_set_float(key, history[i][0]);
    _color_history_key(i, 'g', key, sizeof(key));
    dt_conf_set_float(key, history[i][1]);
    _color_history_key(i, 'b', key, sizeof(key));
    dt_conf_set_float(key, history[i][2]);
  }
}
 
void dt_drawlayer_conf_remember_display_color(dt_iop_module_t *self, const float display_rgb[3])
{
  dt_iop_drawlayer_gui_data_t *g = self ? (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self) : NULL;
  if(IS_NULL_PTR(g) || !g->ui.widgets || !display_rgb) return;
 
  if(!dt_drawlayer_widgets_push_color_history(g->ui.widgets, display_rgb)) return;
  _store_color_history(g);
  if(g->controls.color_swatch) gtk_widget_queue_draw(g->controls.color_swatch);
}
 
void dt_drawlayer_conf_apply_display_brush_color(dt_iop_module_t *self, const float display_rgb[3], const gboolean remember)
{
  dt_iop_drawlayer_gui_data_t *g = self ? (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self) : NULL;
  if(IS_NULL_PTR(self) || IS_NULL_PTR(g) || !g->ui.widgets || !display_rgb) return;
 
  dt_drawlayer_invalidate_brush_settings_cache(g);
  dt_conf_set_float(DRAWLAYER_CONF_COLOR_R, _clamp01(display_rgb[0]));
  dt_conf_set_float(DRAWLAYER_CONF_COLOR_G, _clamp01(display_rgb[1]));
  dt_conf_set_float(DRAWLAYER_CONF_COLOR_B, _clamp01(display_rgb[2]));
  dt_drawlayer_sync_cached_brush_colors(self, display_rgb);
 
  dt_drawlayer_widgets_set_display_color(g->ui.widgets, display_rgb);
  dt_drawlayer_ui_cursor_clear(&g->ui);
 
  if(remember) dt_drawlayer_conf_remember_display_color(self, display_rgb);
 
  if(g->controls.color) gtk_widget_queue_draw(g->controls.color);
  if(g->controls.color_swatch) gtk_widget_queue_draw(g->controls.color_swatch);
  dt_control_queue_redraw_center();
}
 
void dt_drawlayer_conf_sync_color_picker(dt_iop_module_t *self)
{
  dt_iop_drawlayer_gui_data_t *g = self ? (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self) : NULL;
  if(IS_NULL_PTR(g) || !g->ui.widgets) return;
 
  float display_rgb[3] = { 0.0f };
  dt_drawlayer_conf_display_color(display_rgb);
  dt_drawlayer_sync_cached_brush_colors(self, display_rgb);
 
  dt_drawlayer_widgets_set_display_color(g->ui.widgets, display_rgb);
  if(g->controls.color_swatch) gtk_widget_queue_draw(g->controls.color_swatch);
}
 
 
void dt_drawlayer_mapping_rows(dt_iop_drawlayer_gui_data_t *g,
                                    dt_drawlayer_mapping_row_t rows[DT_DRAWLAYER_MAPPING_ROWS])
{
  if(IS_NULL_PTR(g) || IS_NULL_PTR(rows)) return;
 
  rows[0] = (dt_drawlayer_mapping_row_t){
    .targets = { { &g->controls.map_pressure_size, DRAWLAYER_CONF_MAP_PRESSURE_SIZE },
                 { &g->controls.map_pressure_opacity, DRAWLAYER_CONF_MAP_PRESSURE_OPACITY },
                 { &g->controls.map_pressure_flow, DRAWLAYER_CONF_MAP_PRESSURE_FLOW },
                 { &g->controls.map_pressure_softness, DRAWLAYER_CONF_MAP_PRESSURE_SOFTNESS } },
    .profile = { &g->controls.pressure_profile, DRAWLAYER_CONF_PRESSURE_PROFILE },
  };
  rows[1] = (dt_drawlayer_mapping_row_t){
    .targets = { { &g->controls.map_tilt_size, DRAWLAYER_CONF_MAP_TILT_SIZE },
                 { &g->controls.map_tilt_opacity, DRAWLAYER_CONF_MAP_TILT_OPACITY },
                 { &g->controls.map_tilt_flow, DRAWLAYER_CONF_MAP_TILT_FLOW },
                 { &g->controls.map_tilt_softness, DRAWLAYER_CONF_MAP_TILT_SOFTNESS } },
    .profile = { &g->controls.tilt_profile, DRAWLAYER_CONF_TILT_PROFILE },
  };
  rows[2] = (dt_drawlayer_mapping_row_t){
    .targets = { { &g->controls.map_accel_size, DRAWLAYER_CONF_MAP_ACCEL_SIZE },
                 { &g->controls.map_accel_opacity, DRAWLAYER_CONF_MAP_ACCEL_OPACITY },
                 { &g->controls.map_accel_flow, DRAWLAYER_CONF_MAP_ACCEL_FLOW },
                 { &g->controls.map_accel_softness, DRAWLAYER_CONF_MAP_ACCEL_SOFTNESS } },
    .profile = { &g->controls.accel_profile, DRAWLAYER_CONF_ACCEL_PROFILE },
  };
}
 
void dt_drawlayer_conf_sync_params_from_gui(dt_iop_module_t *self, const gboolean record_history)
{
  dt_iop_drawlayer_gui_data_t *g = (dt_iop_drawlayer_gui_data_t *)dt_iop_gui_data(self);
  (void)record_history;
  if(IS_NULL_PTR(g) || (dt_gui_get_global() && dt_gui_widgets_suppressed())) return;
 
  /* Every widget edit lands here, so this is where the resolved-brush cache goes stale. */
  dt_drawlayer_invalidate_brush_settings_cache(g);
  dt_conf_set_int(DRAWLAYER_CONF_BRUSH_SHAPE, dt_drawlayer_widgets_get_brush_profile_selection(g->ui.widgets));
  dt_conf_set_int(DRAWLAYER_CONF_BRUSH_MODE, dt_bauhaus_combobox_get(g->controls.brush_mode));
  dt_conf_set_float(DRAWLAYER_CONF_SIZE, dt_bauhaus_slider_get(g->controls.size));
  dt_conf_set_float(DRAWLAYER_CONF_DISTANCE, dt_bauhaus_slider_get(g->controls.distance));
  dt_conf_set_float(DRAWLAYER_CONF_SMOOTHING, dt_bauhaus_slider_get(g->controls.smoothing));
  dt_conf_set_float(DRAWLAYER_CONF_OPACITY, dt_bauhaus_slider_get(g->controls.opacity));
  dt_conf_set_float(DRAWLAYER_CONF_FLOW, dt_bauhaus_slider_get(g->controls.flow));
  dt_conf_set_float(DRAWLAYER_CONF_SPRINKLES, dt_bauhaus_slider_get(g->controls.sprinkles));
  dt_conf_set_float(DRAWLAYER_CONF_SPRINKLE_SIZE, dt_bauhaus_slider_get(g->controls.sprinkle_size));
  dt_conf_set_float(DRAWLAYER_CONF_SPRINKLE_COARSENESS, dt_bauhaus_slider_get(g->controls.sprinkle_coarseness));
  dt_conf_set_float(DRAWLAYER_CONF_SOFTNESS, 1.0f - dt_bauhaus_slider_get(g->controls.softness));
  if(g->controls.image_colorpicker_source)
    dt_conf_set_int(DRAWLAYER_CONF_PICK_SOURCE, dt_bauhaus_combobox_get(g->controls.image_colorpicker_source));
  dt_conf_set_float(DRAWLAYER_CONF_HDR_EV, dt_bauhaus_slider_get(g->controls.hdr_exposure));
 
  /* The targets are read unguarded and the profiles behind a NULL check, exactly as the
   * fifteen unrolled lines this replaced did. */
  dt_drawlayer_mapping_row_t mapping[DT_DRAWLAYER_MAPPING_ROWS];
  dt_drawlayer_mapping_rows(g, mapping);
  for(int r = 0; r < DT_DRAWLAYER_MAPPING_ROWS; r++)
  {
    for(int c = 0; c < DT_DRAWLAYER_MAPPING_TARGETS; c++)
      dt_conf_set_bool(mapping[r].targets[c].conf_key,
                       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(*mapping[r].targets[c].widget)));
    if(*mapping[r].profile.widget)
      dt_conf_set_int(mapping[r].profile.conf_key, dt_bauhaus_combobox_get(*mapping[r].profile.widget));
  }
}