draw.h

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2009-2013, 2016 johannes hanika.
    Copyright (C) 2010-2011 Henrik Andersson.
    Copyright (C) 2010, 2012-2014, 2016, 2018 Tobias Ellinghaus.
    Copyright (C) 2011 Jochen Schroeder.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2014, 2016 Roman Lebedev.
    Copyright (C) 2018-2020, 2025 Aurélien PIERRE.
    Copyright (C) 2019 Andreas Schneider.
    Copyright (C) 2019 Edgardo Hoszowski.
    Copyright (C) 2019 Heiko Bauke.
    Copyright (C) 2019 Jakub Filipowicz.
    Copyright (C) 2019-2020, 2022 Pascal Obry.
    Copyright (C) 2019 Philippe Weyland.
    Copyright (C) 2020, 2022 Chris Elston.
    Copyright (C) 2020-2021 Dan Torop.
    Copyright (C) 2020 Ralf Brown.
    Copyright (C) 2022 Aldric Renaudin.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2025 Alynx Zhou.
    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/>.
*/
 
#ifndef DT_WIDGETS_DRAW_H
#define DT_WIDGETS_DRAW_H
 
/* Cairo drawing shared across the application: grids, histograms, mask overlay shapes, and
 * the spline sampler the tone-curve widgets draw from.
 *
 * This is a leaf header on purpose. Everything it paints with -- the overlay tint, the theme
 * palette, the DPI scale, the mouse hit radius -- is read through widgets/widget_settings.h,
 * which the application pushes into. Nothing here reaches for a global, so no drawing code
 * has to drag in gui/ or develop/ to put a line on screen. The one develop/ type it mentions,
 * dt_develop_t, is an opaque pointer threaded through to shape callbacks and never
 * dereferenced.
 */
 
#include "common/curve_tools.h"
#include "math/splines.h"
#include "system/mem_alloc.h"
#include "system/openmp.h"        // __OMP_DECLARE_SIMD__, __OMP_PARALLEL_FOR_SIMD__
#include "widgets/paint.h"          // DTGTKCairoPaintIconFunc
#include "widgets/stroke_raster.h"  // dt_stroke_raster_path()
#include "widgets/widget_settings.h"
 
#include <cairo.h>
#include <glib.h>
#include <gtk/gtk.h>
#include <math.h>
#include <stdint.h>
#include <stdlib.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct dt_develop_t;
 
#ifndef M_PI
#define M_PI 3.141592654
#endif
 
// TODO: enter directly the values applied to this factor in each following macro later once
//  we're happy with it.
#define DT_DRAW_SIZE_GLOBAL_FACTOR 0.75f
 
#define DT_DRAW_SIZE_LINE                      DT_PIXEL_APPLY_DPI_DPP(1.5f * DT_DRAW_SIZE_GLOBAL_FACTOR)
#define DT_DRAW_SIZE_LINE_SELECTED             DT_PIXEL_APPLY_DPI_DPP(3.0f * DT_DRAW_SIZE_GLOBAL_FACTOR)
#define DT_DRAW_SIZE_LINE_HIGHLIGHT            (DT_PIXEL_APPLY_DPI_DPP(4.0f * DT_DRAW_SIZE_GLOBAL_FACTOR) + DT_DRAW_SIZE_LINE)
#define DT_DRAW_SIZE_LINE_HIGHLIGHT_SELECTED   (DT_PIXEL_APPLY_DPI_DPP(5.0f * DT_DRAW_SIZE_GLOBAL_FACTOR) + DT_DRAW_SIZE_LINE_SELECTED)
#define DT_DRAW_SIZE_CROSS                     DT_PIXEL_APPLY_DPI_DPP(7.0f * DT_DRAW_SIZE_GLOBAL_FACTOR)
 
#define DT_DRAW_SCALE_DASH          DT_PIXEL_APPLY_DPI_DPP(12.0f * DT_DRAW_SIZE_GLOBAL_FACTOR)
#define DT_DRAW_SCALE_ARROW         DT_PIXEL_APPLY_DPI_DPP(18.0f * DT_DRAW_SIZE_GLOBAL_FACTOR)
 
// radius/width of node (handles are set to be 3/4 of a node size)
#define DT_DRAW_RADIUS_NODE          DT_PIXEL_APPLY_DPI_DPP(5.0f * DT_DRAW_SIZE_GLOBAL_FACTOR)
#define DT_DRAW_RADIUS_NODE_SELECTED (1.25f * DT_DRAW_RADIUS_NODE)
 
/***** PRIMITIVES */
 
static inline void dt_draw_star(cairo_t *cr, float x, float y, float r1, float r2)
{
  const float d = 2.0 * M_PI * 0.1f;
  const float dx[10] = { sinf(0.0),   sinf(d),     sinf(2 * d), sinf(3 * d), sinf(4 * d),
                         sinf(5 * d), sinf(6 * d), sinf(7 * d), sinf(8 * d), sinf(9 * d) };
  const float dy[10] = { cosf(0.0),   cosf(d),     cosf(2 * d), cosf(3 * d), cosf(4 * d),
                         cosf(5 * d), cosf(6 * d), cosf(7 * d), cosf(8 * d), cosf(9 * d) };
 
  cairo_move_to(cr, x + r1 * dx[0], y - r1 * dy[0]);
  for(int k = 1; k < 10; k++)
    if(k & 1)
      cairo_line_to(cr, x + r2 * dx[k], y - r2 * dy[k]);
    else
      cairo_line_to(cr, x + r1 * dx[k], y - r1 * dy[k]);
  cairo_close_path(cr);
}
 
static inline void dt_draw_line(cairo_t *cr, float left, float top, float right, float bottom)
{
  cairo_move_to(cr, left, top);
  cairo_line_to(cr, right, bottom);
}
 
static inline void set_color(cairo_t *cr, GdkRGBA color)
{
  cairo_set_source_rgba(cr, color.red, color.green, color.blue, color.alpha);
}
 
 
typedef enum dt_draw_dash_type_t
{
  DT_MASKS_NO_DASH = 0,
  DT_MASKS_DASH_STICK = 1,
  DT_MASKS_DASH_ROUND = 2
} dt_draw_dash_type_t;
 
typedef struct dt_draw_curve_t
{
  CurveData c;
  CurveSample csample;
} dt_draw_curve_t;
 
static inline void dt_draw_set_color_overlay(cairo_t *cr, gboolean bright, double alpha)
{
  const dt_widget_overlay_color_t *overlay = dt_widget_overlay_color();
  const double amt = bright ? 0.5 + overlay->contrast * 0.5
                            : (1.0 - overlay->contrast) * 0.5;
 
  cairo_set_source_rgba(cr, overlay->red * amt, overlay->green * amt, overlay->blue * amt, alpha);
}
 
 
 
static inline void dt_draw_grid(cairo_t *cr, const int num, const int left, const int top, const int right,
                                const int bottom)
{
  float width = right - left;
  float height = bottom - top;
 
  for(int k = 1; k < num; k++)
  {
    dt_draw_line(cr, left + k / (float)num * width, top, left + k / (float)num * width, bottom);
    cairo_stroke(cr);
    dt_draw_line(cr, left, top + k / (float)num * height, right, top + k / (float)num * height);
    cairo_stroke(cr);
  }
}
 
static inline float dt_curve_to_mouse(const float x, const float zoom_factor, const float offset)
{
  return (x - offset) * zoom_factor;
}
 
/* left, right, top, bottom are in curve coordinates [0..1] */
static inline void dt_draw_grid_zoomed(cairo_t *cr, const int num, const float left, const float top,
                                       const float right, const float bottom, const float width,
                                       const float height, const float zoom_factor, const float zoom_offset_x,
                                       const float zoom_offset_y)
{
  for(int k = 1; k < num; k++)
  {
    dt_draw_line(cr, dt_curve_to_mouse(left + k / (float)num, zoom_factor, zoom_offset_x) * width,
                 dt_curve_to_mouse(top, zoom_factor, zoom_offset_y) * -height,
                 dt_curve_to_mouse(left + k / (float)num, zoom_factor, zoom_offset_x) * width,
                 dt_curve_to_mouse(bottom, zoom_factor, zoom_offset_y) * -height);
    cairo_stroke(cr);
 
    dt_draw_line(cr, dt_curve_to_mouse(left, zoom_factor, zoom_offset_x) * width,
                 dt_curve_to_mouse(top + k / (float)num, zoom_factor, zoom_offset_y) * -height,
                 dt_curve_to_mouse(right, zoom_factor, zoom_offset_x) * width,
                 dt_curve_to_mouse(top + k / (float)num, zoom_factor, zoom_offset_y) * -height);
    cairo_stroke(cr);
  }
}
 
__OMP_DECLARE_SIMD__(uniform(base))
static inline float dt_log_scale_axis(const float x, const float base)
{
  return logf(x * (base - 1.0f) + 1.f) / logf(base);
}
 
static inline void dt_draw_loglog_grid(cairo_t *cr, const int num, const int left, const int top, const int right,
                                       const int bottom, const float base)
{
  float width = right - left;
  float height = bottom - top;
 
  for(int k = 1; k < num; k++)
  {
    const float x = dt_log_scale_axis(k / (float)num, base);
    dt_draw_line(cr, left + x * width, top, left + x * width, bottom);
    cairo_stroke(cr);
    dt_draw_line(cr, left, top + x * height, right, top + x * height);
    cairo_stroke(cr);
  }
}
 
static inline void dt_draw_semilog_x_grid(cairo_t *cr, const int num, const int left, const int top,
                                          const int right, const int bottom, const float base)
{
  float width = right - left;
  float height = bottom - top;
 
  for(int k = 1; k < num; k++)
  {
    const float x = dt_log_scale_axis(k / (float)num, base);
    dt_draw_line(cr, left + x * width, top, left + x * width, bottom);
    cairo_stroke(cr);
    dt_draw_line(cr, left, top + k / (float)num * height, right, top + k / (float)num * height);
    cairo_stroke(cr);
  }
}
 
static inline void dt_draw_semilog_y_grid(cairo_t *cr, const int num, const int left, const int top,
                                          const int right, const int bottom, const float base)
{
  float width = right - left;
  float height = bottom - top;
 
  for(int k = 1; k < num; k++)
  {
    const float x = dt_log_scale_axis(k / (float)num, base);
    dt_draw_line(cr, left + k / (float)num * width, top, left + k / (float)num * width, bottom);
    cairo_stroke(cr);
    dt_draw_line(cr, left, top + x * height, right, top + x * height);
    cairo_stroke(cr);
  }
}
 
 
static inline void dt_draw_vertical_lines(cairo_t *cr, const int num, const int left, const int top,
                                          const int right, const int bottom)
{
  float width = right - left;
 
  for(int k = 1; k < num; k++)
  {
    cairo_move_to(cr, left + k / (float)num * width, top);
    cairo_line_to(cr, left + k / (float)num * width, bottom);
    cairo_stroke(cr);
  }
}
 
static inline void dt_draw_horizontal_lines(cairo_t *cr, const int num, const int left, const int top,
                                            const int right, const int bottom)
{
  float height = bottom - top;
 
  for(int k = 1; k < num; k++)
  {
    cairo_move_to(cr, left, top + k / (float)num * height);
    cairo_line_to(cr, right, top + k / (float)num * height);
    cairo_stroke(cr);
  }
}
 
static inline dt_draw_curve_t *dt_draw_curve_new(const float min, const float max, unsigned int type)
{
  dt_draw_curve_t *c = (dt_draw_curve_t *)malloc(sizeof(dt_draw_curve_t));
  c->csample.m_samplingRes = 0x10000;
  c->csample.m_outputRes = 0x10000;
  c->csample.m_Samples = (uint16_t *)malloc(sizeof(uint16_t) * 0x10000);
 
  c->c.m_spline_type = type;
  c->c.m_numAnchors = 0;
  c->c.m_min_x = 0.0;
  c->c.m_max_x = 1.0;
  c->c.m_min_y = 0.0;
  c->c.m_max_y = 1.0;
  return c;
}
 
static inline void dt_draw_curve_destroy(dt_draw_curve_t *c)
{
  dt_free(c->csample.m_Samples);
  dt_free(c);
}
 
static inline void dt_draw_curve_set_point(dt_draw_curve_t *c, const int num, const float x, const float y)
{
  c->c.m_anchors[num].x = x;
  c->c.m_anchors[num].y = y;
}
 
static inline void dt_draw_curve_smaple_values(dt_draw_curve_t *c, const float min, const float max, const int res,
                                               float *x, float *y)
{
  if(x)
  {
    __OMP_PARALLEL_FOR_SIMD__()
    for(int k = 0; k < res; k++) x[k] = k * (1.0f / res);
  }
  if(y)
  {
    __OMP_PARALLEL_FOR_SIMD__()
    for(int k = 0; k < res; k++) y[k] = min + (max - min) * c->csample.m_Samples[k] * (1.0f / 0x10000);
  }
}
 
static inline void dt_draw_curve_calc_values(dt_draw_curve_t *c, const float min, const float max, const int res,
                                             float *x, float *y)
{
  c->csample.m_samplingRes = res;
  c->csample.m_outputRes = 0x10000;
  CurveDataSample(&c->c, &c->csample);
  dt_draw_curve_smaple_values(c, min, max, res, x, y);
}
 
static inline void dt_draw_curve_calc_values_V2_nonperiodic(dt_draw_curve_t *c, const float min, const float max,
                                                            const int res, float *x, float *y)
{
  c->csample.m_samplingRes = res;
  c->csample.m_outputRes = 0x10000;
  CurveDataSampleV2(&c->c, &c->csample);
  dt_draw_curve_smaple_values(c, min, max, res, x, y);
}
 
static inline void dt_draw_curve_calc_values_V2_periodic(dt_draw_curve_t *c, const float min, const float max,
                                                         const int res, float *x, float *y)
{
  c->csample.m_samplingRes = res;
  c->csample.m_outputRes = 0x10000;
  CurveDataSampleV2Periodic(&c->c, &c->csample);
  dt_draw_curve_smaple_values(c, min, max, res, x, y);
}
 
static inline void dt_draw_curve_calc_values_V2(dt_draw_curve_t *c, const float min, const float max,
                                                const int res, float *x, float *y, const gboolean periodic)
{
  if(periodic)
    dt_draw_curve_calc_values_V2_periodic(c, min, max, res, x, y);
  else
    dt_draw_curve_calc_values_V2_nonperiodic(c, min, max, res, x, y);
 }
 
static inline float dt_draw_curve_calc_value(dt_draw_curve_t *c, const float x)
{
  float xa[20], ya[20];
  float val = 0.f;
  float *ypp = NULL;
  for(int i = 0; i < c->c.m_numAnchors; i++)
  {
    xa[i] = c->c.m_anchors[i].x;
    ya[i] = c->c.m_anchors[i].y;
  }
  ypp = interpolate_set(c->c.m_numAnchors, xa, ya, c->c.m_spline_type);
  if(ypp)
  {
    val = interpolate_val(c->c.m_numAnchors, xa, x, ya, ypp, c->c.m_spline_type);
    dt_free(ypp);
  }
  return MIN(MAX(val, c->c.m_min_y), c->c.m_max_y);
}
 
static inline int dt_draw_curve_add_point(dt_draw_curve_t *c, const float x, const float y)
{
  c->c.m_anchors[c->c.m_numAnchors].x = x;
  c->c.m_anchors[c->c.m_numAnchors].y = y;
  c->c.m_numAnchors++;
  return 0;
}
 
// linear x linear y
static inline void dt_draw_histogram_8_linxliny(cairo_t *cr, const uint32_t *hist, int32_t channels,
                                                int32_t channel)
{
  cairo_move_to(cr, 0, 0);
  for(int k = 0; k < 256; k++) cairo_line_to(cr, k, hist[channels * k + channel]);
  cairo_line_to(cr, 255, 0);
  cairo_close_path(cr);
  cairo_fill(cr);
}
 
static inline void dt_draw_histogram_8_zoomed(cairo_t *cr, const uint32_t *hist, int32_t channels, int32_t channel,
                                              const float zoom_factor, const float zoom_offset_x,
                                              const float zoom_offset_y, gboolean linear)
{
  cairo_move_to(cr, -zoom_offset_x, -zoom_offset_y);
  for(int k = 0; k < 256; k++)
  {
    const float value = ((float)hist[channels * k + channel] - zoom_offset_y) * zoom_factor;
    const float hist_value = value < 0 ? 0.f : value;
    cairo_line_to(cr, ((float)k - zoom_offset_x) * zoom_factor, linear ? hist_value : logf(1.0f + hist_value));
  }
  cairo_line_to(cr, (255.f - zoom_offset_x), -zoom_offset_y * zoom_factor);
  cairo_close_path(cr);
  cairo_fill(cr);
}
 
// log x (scalable) & linear y
static inline void dt_draw_histogram_8_logxliny(cairo_t *cr, const uint32_t *hist, int32_t channels,
                                                int32_t channel, float base_log)
{
  cairo_move_to(cr, 0, 0);
  for(int k = 0; k < 256; k++)
  {
    const float x = logf((float)k / 255.0f * (base_log - 1.0f) + 1.0f) / logf(base_log) * 255.0f;
    const float y = hist[channels * k + channel];
    cairo_line_to(cr, x, y);
  }
  cairo_line_to(cr, 255, 0);
  cairo_close_path(cr);
  cairo_fill(cr);
}
 
// log x (scalable) & log y
static inline void dt_draw_histogram_8_logxlogy(cairo_t *cr, const uint32_t *hist, int32_t channels,
                                                int32_t channel, float base_log)
{
  cairo_move_to(cr, 0, 0);
  for(int k = 0; k < 256; k++)
  {
    const float x = logf((float)k / 255.0f * (base_log - 1.0f) + 1.0f) / logf(base_log) * 255.0f;
    const float y = logf(1.0 + hist[channels * k + channel]);
    cairo_line_to(cr, x, y);
  }
  cairo_line_to(cr, 255, 0);
  cairo_close_path(cr);
  cairo_fill(cr);
}
 
// linear x log y
static inline void dt_draw_histogram_8_linxlogy(cairo_t *cr, const uint32_t *hist, int32_t channels,
                                                int32_t channel)
{
  cairo_move_to(cr, 0, 0);
  for(int k = 0; k < 256; k++) cairo_line_to(cr, k, logf(1.0 + hist[channels * k + channel]));
  cairo_line_to(cr, 255, 0);
  cairo_close_path(cr);
  cairo_fill(cr);
}
 
// log x (scalable)
static inline void dt_draw_histogram_8_log_base(cairo_t *cr, const uint32_t *hist, int32_t channels,
                                                int32_t channel, const gboolean linear, float base_log)
{
 
  if(linear) // linear y
    dt_draw_histogram_8_logxliny(cr, hist, channels, channel, base_log);
  else // log y
    dt_draw_histogram_8_logxlogy(cr, hist, channels, channel, base_log);
}
 
// linear x
static inline void dt_draw_histogram_8(cairo_t *cr, const uint32_t *hist, int32_t channels, int32_t channel,
                                       const gboolean linear)
{
  if(linear) // linear y
    dt_draw_histogram_8_linxliny(cr, hist, channels, channel);
  else // log y
    dt_draw_histogram_8_linxlogy(cr, hist, channels, channel);
}
 
static inline void dt_draw_cairo_to_gdk_pixbuf(uint8_t *data, unsigned int width, unsigned int height)
{
  for(uint32_t y = 0; y < height; y++)
    for(uint32_t x = 0; x < width; x++)
    {
      uint8_t *r, *g, *b, *a, tmp;
      r = &data[(y * width + x) * 4 + 0];
      g = &data[(y * width + x) * 4 + 1];
      b = &data[(y * width + x) * 4 + 2];
      a = &data[(y * width + x) * 4 + 3];
 
      // switch r and b
      tmp = *r;
      *r = *b;
      *b = tmp;
 
      // cairo uses premultiplied alpha, reverse that
      if(*a != 0)
      {
        float inv_a = 255.0 / *a;
        *r *= inv_a;
        *g *= inv_a;
        *b *= inv_a;
      }
    }
}
 
static inline void dt_cairo_perceptual_gradient(cairo_pattern_t *grad, double alpha)
{
  // Create a linear gradient from black to white
  cairo_pattern_add_color_stop_rgba(grad, 0.0, 0.0, 0.0, 0.0, alpha);
  cairo_pattern_add_color_stop_rgba(grad, 1.0, 1.0, 1.0, 1.0, alpha);
}
 
static inline GdkPixbuf *dt_draw_paint_to_pixbuf
 (GtkWidget *widget, const guint pixbuf_size, const int flags,
  void (*dtgtk_cairo_paint_fct)(cairo_t *cr, gint x, gint y, gint w, gint h, gint flags, void *data))
{
  GdkRGBA fg_color;
  GtkStyleContext *context = gtk_widget_get_style_context(widget);
  GtkStateFlags state = gtk_widget_get_state_flags(widget);
  gtk_style_context_get_color(context, state, &fg_color);
 
  const int dim = DT_PIXEL_APPLY_DPI(pixbuf_size);
  cairo_surface_t *cst = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, dim, dim);
  cairo_t *cr = cairo_create(cst);
  gdk_cairo_set_source_rgba(cr, &fg_color);
  (*dtgtk_cairo_paint_fct)(cr, 0, 0, dim, dim, flags, NULL);
  cairo_destroy(cr);
  uint8_t *data = cairo_image_surface_get_data(cst);
  dt_draw_cairo_to_gdk_pixbuf(data, dim, dim);
  const size_t size = (size_t)dim * dim * 4;
  uint8_t *buf = (uint8_t *)malloc(size);
  memcpy(buf, data, size);
  GdkPixbuf *pixbuf = gdk_pixbuf_new_from_data(buf, GDK_COLORSPACE_RGB, TRUE, 8, dim, dim, dim * 4,
                                               (GdkPixbufDestroyNotify)free, NULL);
  cairo_surface_destroy(cst);
  return pixbuf;
}
 
static inline void dt_draw_rounded_rectangle_path(cairo_t *cr, float x, float y, float width, float height,
                                                  float radius)
{
  const float degrees = M_PI / 180.0;
  cairo_new_sub_path(cr);
  cairo_arc(cr, x + width - radius, y + radius, radius, -90 * degrees, 0 * degrees);
  cairo_arc(cr, x + width - radius, y + height - radius, radius, 0 * degrees, 90 * degrees);
  cairo_arc(cr, x + radius, y + height - radius, radius, 90 * degrees, 180 * degrees);
  cairo_arc(cr, x + radius, y + radius, radius, 180 * degrees, 270 * degrees);
  cairo_close_path(cr);
}
 
static inline void dt_gui_draw_rounded_rectangle(cairo_t *cr, float width, float height, float x, float y)
{
  dt_draw_rounded_rectangle_path(cr, x, y, width, height, height / 5.0f);
  cairo_fill(cr);
}
 
static inline void dt_draw_plus_sign(cairo_t *cr, float x, float y, float size, float line_width_scale)
{
  const float base_line_width = cairo_get_line_width(cr);
  cairo_set_line_width(cr, base_line_width * line_width_scale);
 
  cairo_move_to(cr, x, y - size);
  cairo_line_to(cr, x, y + size);
  cairo_move_to(cr, x - size, y);
  cairo_line_to(cr, x + size, y);
 
  cairo_stroke(cr);
  cairo_set_line_width(cr, base_line_width);
}
 
/***** SHAPES */
 
// Helper that fills the current path with CAIRO_OPERATOR_CLEAR,
// effectively erasing all drawings below,
// but preserving the path for further drawing.
static void _draw_fill_clear(cairo_t *cr, gboolean preserve)
{
  cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
  if(preserve)
    cairo_fill_preserve(cr);
  else
    cairo_fill(cr);
  cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
}
 
static void _fill_clear(cairo_t *cr)
{
  _draw_fill_clear(cr, FALSE);
}
 
static void _fill_clear_preserve(cairo_t *cr)
{
  _draw_fill_clear(cr, TRUE);
}
 
static inline void dt_draw_dash_lengths(const dt_draw_dash_type_t type, const float zoom_scale, double *on, double *off)
{
  *on = 0.0;
  *off = 0.0;
  switch(type)
  {
    case DT_MASKS_DASH_STICK:
      *on = DT_DRAW_SCALE_DASH / zoom_scale;
      *off = DT_DRAW_SCALE_DASH / zoom_scale;
      break;
    case DT_MASKS_DASH_ROUND:
      *on = (DT_DRAW_SCALE_DASH * 0.25f) / zoom_scale;
      *off = DT_DRAW_SCALE_DASH / zoom_scale;
      break;
    default:
      break;
  }
}
 
static inline void dt_draw_set_dash_style(cairo_t *cr, dt_draw_dash_type_t type, float zoom_scale)
{
  // return early if no dash is needed
  if(type == DT_MASKS_NO_DASH)
  {
    cairo_set_dash(cr, NULL, 0, 0);
    return;
  }
 
  double pattern[2];
 
  switch(type)
  {
    case DT_MASKS_NO_DASH:
      pattern[0] = 0.0f;
      pattern[1] = 0.0f;
      break;
 
    case DT_MASKS_DASH_STICK:
      pattern[0] = DT_DRAW_SCALE_DASH / zoom_scale;
      pattern[1] = DT_DRAW_SCALE_DASH / zoom_scale;
      break;
 
    case DT_MASKS_DASH_ROUND:
      pattern[0] = (DT_DRAW_SCALE_DASH * 0.25f) / zoom_scale;
      pattern[1] = (DT_DRAW_SCALE_DASH) / zoom_scale;
      break;
 
    default:
      cairo_set_dash(cr, NULL, 0, 0);
      return;
      
  }
  const int pattern_len = 2;
  cairo_set_dash(cr, pattern, pattern_len, 0);
}
 
static inline void dt_draw_node(cairo_t *cr, const gboolean square, const gboolean point_action, const gboolean selected, const float zoom_scale, const float x, const float y)
{
  cairo_save(cr);
 
  // See dt_draw_rounded_rectangle_path() for the same guard: cairo_arc() appends a line from
  // whatever current point a caller's unrelated, unclosed path left behind. cairo_new_sub_path(),
  // not cairo_new_path(): starts fresh without discarding a path a caller may still be building.
  cairo_new_sub_path(cr);
 
  const float node_width = (selected || point_action) ? DT_DRAW_RADIUS_NODE_SELECTED / zoom_scale : DT_DRAW_RADIUS_NODE / zoom_scale;
  // square for corner nodes, circle for others (curve)
  if(square)
  {
    const float pos = node_width * 0.7071f; // radius * sin(45°) to have the same diagonal as the circle
    cairo_rectangle(cr, x - pos, y - pos, node_width * 2.f, node_width * 2.f);
  }
  else
    cairo_arc(cr, x, y, node_width * 1.2f, 0.0, 2.0 * M_PI);
 
  // Erase all drawings below
  _fill_clear_preserve(cr);
 
  const float line_width = (point_action && selected) ? DT_DRAW_SIZE_LINE_SELECTED / zoom_scale
                                          : DT_DRAW_SIZE_LINE / zoom_scale;
 
  cairo_set_line_width(cr, line_width);
  dt_draw_set_color_overlay(cr, TRUE, selected || point_action ? 1 : 0.8);
  cairo_fill_preserve(cr);
 
  // draw dark border
  cairo_set_line_width(cr, (selected && !point_action) ? line_width * 2. : line_width);
  dt_draw_set_color_overlay(cr, FALSE, 0.8);
  cairo_stroke(cr);
 
  if(dt_widget_debug_overlays())
  {
    const float debug_radius = DT_GUI_MOUSE_EFFECT_RADIUS;
    cairo_arc(cr, x, y, debug_radius, 0.0, 2.0 * M_PI);
    cairo_set_line_width(cr, line_width);
    cairo_set_source_rgba(cr, 0.0, 1.0, 0.0, 1.0);
    cairo_stroke(cr);
  }
 
  cairo_restore(cr);
}
 
static inline void dt_draw_handle(cairo_t *cr, const float pt[2], const float zoom_scale,
                                  const float handle[2], const gboolean selected, const gboolean square)
{
  cairo_save(cr);
 
 
  // Draw only if the line is long enough
  // and shorten the line by the size of the nodes so it does not overlap with them
  //float shorten = 0; //(DT_DRAW_RADIUS_NODE / zoom_scale) * 0.5f;
  //float f = shorten / tail_len;
  if(pt)
  {
    float delta_x = handle[0] - pt[0];
    float delta_y = handle[1] - pt[1];
    float start_x = pt[0] + delta_x;
    float start_y = pt[1] + delta_y;
    float end_x = handle[0] - delta_x;
    float end_y = handle[1] - delta_y;
    cairo_move_to(cr, start_x, start_y);
    cairo_line_to(cr, end_x, end_y);
  
    cairo_set_line_width(cr, DT_DRAW_SIZE_LINE_HIGHLIGHT * 0.6 / zoom_scale);
    dt_draw_set_color_overlay(cr, FALSE, 0.6);
    cairo_stroke_preserve(cr);
    cairo_set_line_width(cr, DT_DRAW_SIZE_LINE * 0.6 / zoom_scale);
    dt_draw_set_color_overlay(cr, TRUE, 0.8);
    cairo_stroke(cr);
  }
  
  // Draw the control handle (1/4 smaller than a node)
  const float handle_radius = 0.75 * (selected ? DT_DRAW_RADIUS_NODE_SELECTED / zoom_scale
                                       : DT_DRAW_RADIUS_NODE / zoom_scale);
 
  // Same guard as dt_draw_node(): when pt is NULL the tail above is skipped, so nothing has
  // cleared a caller's dangling current point yet before this cairo_arc(). See there for why.
  cairo_new_sub_path(cr);
 
  if(square)
  {
    const float square_width = handle_radius * 0.7071f; // handle_radius * sin(45°) to have the same diagonal as the circle
    cairo_rectangle(cr, handle[0] - square_width, handle[1] - square_width, square_width * 2.f, square_width * 2.f);
  }
  else
    cairo_arc(cr, handle[0], handle[1], handle_radius, 0, 2.0 * M_PI);
 
  const float line_width_dark = selected
                  ? (DT_DRAW_SIZE_LINE_HIGHLIGHT_SELECTED / zoom_scale)
                  : (DT_DRAW_SIZE_LINE_HIGHLIGHT / zoom_scale);
  const float line_width_bright = selected
                  ? (DT_DRAW_SIZE_LINE_SELECTED / zoom_scale)
                  : (DT_DRAW_SIZE_LINE / zoom_scale);
 
  // OUTLINE (dark)
  cairo_set_line_width(cr, line_width_dark * 1.125);
  dt_draw_set_color_overlay(cr, FALSE, 0.5);
  cairo_stroke_preserve(cr);
  // NORMAL (bright)
  cairo_set_line_width(cr, line_width_bright * 1.5);
  dt_draw_set_color_overlay(cr, TRUE, 0.8);
  cairo_stroke_preserve(cr);
  // Erase all drawings below
  _fill_clear(cr);
 
 
  // uncomment this part if you want to see "real" control points
  /*cairo_move_to(cr, gpt->points[n*6+2],gpt->points[n*6+3]);
  cairo_line_to(cr, gpt->points[n*6],gpt->points[n*6+1]);
  cairo_stroke(cr);
  cairo_move_to(cr, gpt->points[n*6+2],gpt->points[n*6+3]);
  cairo_line_to(cr, gpt->points[n*6+4],gpt->points[n*6+5]);
  cairo_stroke(cr);*/
 
  cairo_restore(cr);
}
 
// dev is the develop instance owning the shape being drawn. It is threaded explicitly so shape
// drawing code never has to reach for the darktable.develop global (which would couple every
// shape file to the whole application and hide which instance is read).
//
// skips/skip_count are the shape's EXCLUSION LIST: the spans of the outline that must not be
// drawn, because the offset curve doubles back on itself there. They travel alongside the buffer
// rather than inside it -- the alternative, and what this replaced, was blanking those samples to
// NaN and having every walker test for it. That encoding hides in a buffer of plain floats, has
// to be re-learned by each new consumer, and is silently wrong for any consumer that forgets:
// see the entry in masks_types.h for the two bugs it hosted. A shape with nothing to exclude
// passes NULL and 0.
//
// Declared as a struct tag so this header stays free of masks_types.h -- a widget helper has no
// business inheriting the masks vocabulary.
struct dt_masks_skip_range_t;
typedef void (*shape_draw_function_t)(struct dt_develop_t *dev, cairo_t *cr, const float *points, const int points_count, const int nb, const gboolean border, const gboolean source,
                                      const struct dt_masks_skip_range_t *skips, const int skip_count);
 
static inline void dt_draw_shape_lines(struct dt_develop_t *dev, const dt_draw_dash_type_t dash_type, const gboolean source, cairo_t *cr, const int nb, const gboolean selected,
                const float zoom_scale, const float *points, const int points_count, const shape_draw_function_t *draw_shape_func, const cairo_line_cap_t line_cap,
                const struct dt_masks_skip_range_t *skips, const int skip_count)
{
  cairo_save(cr);
 
  /* An overlay is guide lines about a pixel wide, not artwork: cairo's best-quality analytic
   * coverage buys nothing visible here and costs about half the time of drawing them. Measured
   * per shape per frame at fit zoom on issue #1313's raw: 2.05 -> 1.20 ms for the brush's border,
   * 1.39 -> 0.78 ms for polygon #2's. Scoped by the cairo_save() above, so nothing else -- the
   * node handles in particular, which are small filled discs where the difference would show --
   * inherits it. */
  cairo_set_antialias(cr, CAIRO_ANTIALIAS_FAST);
 
  cairo_set_line_cap(cr, line_cap);
  // Are we drawing a border ?
  const gboolean border = (dash_type != DT_MASKS_NO_DASH);
 
  // Draw the shape from the integrated function if any
  if(points && points_count >= 2 && draw_shape_func)
    (*draw_shape_func)(dev, cr, points, points_count, nb, border, FALSE, skips, skip_count);
 
  const dt_draw_dash_type_t dash = (dash_type && !source)
                                  ? dash_type : DT_MASKS_NO_DASH;
 
  dt_draw_set_dash_style(cr, dash, zoom_scale);
 
  const float line_width_dark = selected
                  ? DT_DRAW_SIZE_LINE_HIGHLIGHT_SELECTED / zoom_scale
                  : DT_DRAW_SIZE_LINE_HIGHLIGHT / zoom_scale;
  const float line_width_bright = selected
                  ? DT_DRAW_SIZE_LINE_SELECTED / zoom_scale
                  : DT_DRAW_SIZE_LINE / zoom_scale;
 
  float alpha = dash_type ? 0.3f : 0.9f;
  if(source) alpha *= 0.5f;
  const float alpha_bright = source ? 0.4f : 0.8f;
 
  /* The path is pixels already: the outline was sampled at the resolution it is drawn at.
   * Paint it as such wherever the surface allows -- the overlay's own canvas, any image
   * surface, the group cairo pushed on one -- and keep the cairo strokes below for every other
   * target. The rasteriser reproduces exactly these: the same two passes, widths, colours,
   * dashes and caps. */
  dt_stroke_style_t style = { 0 };
  const dt_widget_overlay_color_t *overlay = dt_widget_overlay_color();
  const double dark_amount = (1.0 - overlay->contrast) * 0.5;
  const double bright_amount = 0.5 + overlay->contrast * 0.5;
  style.dark = (dt_stroke_pass_t){ .width = line_width_dark,
                                   .red = overlay->red * dark_amount,
                                   .green = overlay->green * dark_amount,
                                   .blue = overlay->blue * dark_amount,
                                   .alpha = alpha };
  style.bright = (dt_stroke_pass_t){ .width = line_width_bright,
                                     .red = overlay->red * bright_amount,
                                     .green = overlay->green * bright_amount,
                                     .blue = overlay->blue * bright_amount,
                                     .alpha = alpha_bright };
  dt_draw_dash_lengths(dash, zoom_scale, &style.dash_on, &style.dash_off);
  style.round_caps = (line_cap == CAIRO_LINE_CAP_ROUND);
  if(dt_stroke_raster_path(cr, &style))
  {
    cairo_restore(cr);
    return;
  }
 
  // OUTLINE (dark)
  cairo_set_line_width(cr, line_width_dark);
  dt_draw_set_color_overlay(cr, FALSE, alpha);
  cairo_stroke_preserve(cr);
 
  // NORMAL (bright)
  cairo_set_line_width(cr, line_width_bright);
  dt_draw_set_color_overlay(cr, TRUE, alpha_bright);
  cairo_stroke(cr);
 
  cairo_restore(cr);
}
 
static inline double dt_draw_min_emit_step(cairo_t *cr)
{
  /* ONE device pixel, not half of one.
   *
   * Nothing an overlay draws is finer than the 1 px line it is drawn with, so a chord shorter
   * than a pixel cannot show: the deviation a straight chord makes from the curve it replaces is
   * step^2 / 8R, which for a 1 px chord is under an eighth of a pixel for any curve of radius
   * 1 px or more. What it costs is real -- measured on issue #1313's brush at fit zoom, the
   * dashed border went from 2163 segments and 2.05 ms per frame to 1098 and 1.85 ms with the
   * default antialiasing, and 1.20 -> 0.76 ms with ANTIALIAS_FAST below.
   *
   * Do NOT read that as "coarser is always better". The cost is not per-segment: the same
   * polyline split into 1, 11 or 57 separately stroked pieces measures 4.9, 3.8 and 3.7 ms, so
   * batching strokes buys nothing and the per-segment styling that costs is free. What the step
   * buys is fewer edges for the rasteriser, and it stops paying well before it starts to show. */
  double dx = 1.0, dy = 1.0;
  cairo_device_to_user_distance(cr, &dx, &dy);
  const double step = fmin(fabs(dx), fabs(dy));
  return isfinite(step) ? step : 0.0;
}
 
static inline void dt_draw_stroke_line(const dt_draw_dash_type_t dash_type, const gboolean source, cairo_t *cr,
                          const gboolean selected, const float zoom_scale, const cairo_line_cap_t line_cap)
{
  dt_draw_shape_lines(NULL, dash_type, source, cr, 0, selected, zoom_scale, NULL, 0, NULL, line_cap, NULL, 0);
}
 
static void _draw_arrow_head(cairo_t *cr, const float arrow[2], const float arrow_x_a, const float arrow_y_a,
                             const float arrow_x_b, const float arrow_y_b)
{
  //draw the arrow head
  cairo_move_to(cr, arrow_x_a, arrow_y_a);
  cairo_line_to(cr, arrow[0], arrow[1]);
  cairo_line_to(cr, arrow_x_b, arrow_y_b);
  // close the arrow head
  cairo_close_path(cr);
}
 
static void _draw_arrow_tail(cairo_t *cr, const float arrow_bud_x, const float arrow_bud_y,
                             const float tail[2], const gboolean draw_tail)
{
  if(draw_tail) dt_draw_line(cr, arrow_bud_x, arrow_bud_y, tail[0], tail[1]);
}
 
static inline void dt_draw_arrow(cairo_t *cr, const float zoom_scale,const gboolean selected, const gboolean draw_tail,
              const dt_draw_dash_type_t dash_style, const float arrow[2], const float tail[2], const float angle)
{
  // calculate the coordinates of the two base points of the arrow head
  const float arrow_x_a = arrow[0] + (DT_DRAW_SCALE_ARROW / zoom_scale) * cosf(angle + (0.4f));
  const float arrow_y_a = arrow[1] + (DT_DRAW_SCALE_ARROW / zoom_scale) * sinf(angle + (0.4f));
  const float arrow_x_b = arrow[0] + (DT_DRAW_SCALE_ARROW / zoom_scale) * cosf(angle - (0.4f));
  const float arrow_y_b = arrow[1] + (DT_DRAW_SCALE_ARROW / zoom_scale) * sinf(angle - (0.4f));
  // Calculate the coordinates of the arrow base's midpoint
  const float arrow_bud_x = (arrow_x_a + arrow_x_b) * 0.5f;
  const float arrow_bud_y = (arrow_y_a + arrow_y_b) * 0.5f;
 
  cairo_save(cr);
  cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
 
  // we need to draw the arrow head and tail in two passes to get the dark and bright effect correctly
  
  // dark
  {
    // arrow head
    _draw_arrow_head(cr, arrow, arrow_x_a, arrow_y_a, arrow_x_b, arrow_y_b);
    // Erase all drawings below
    _fill_clear_preserve(cr);
 
    dt_draw_set_dash_style(cr, DT_MASKS_NO_DASH, zoom_scale);
    dt_draw_set_color_overlay(cr, FALSE, 0.6);
 
    if(selected)
      cairo_set_line_width(cr, 0.8f * DT_DRAW_SIZE_LINE_HIGHLIGHT_SELECTED / zoom_scale);
    else
      cairo_set_line_width(cr, 0.8f * DT_DRAW_SIZE_LINE_HIGHLIGHT / zoom_scale);
    cairo_stroke(cr);
 
    // arrow tail
    _draw_arrow_tail(cr, arrow_bud_x, arrow_bud_y, tail, draw_tail);
    dt_draw_set_dash_style(cr, dash_style, zoom_scale);
    dt_draw_set_color_overlay(cr, FALSE, 0.6);
    if(selected)
      cairo_set_line_width(cr, DT_DRAW_SIZE_LINE_HIGHLIGHT_SELECTED / zoom_scale);
    else
      cairo_set_line_width(cr, DT_DRAW_SIZE_LINE_HIGHLIGHT / zoom_scale);
    cairo_stroke(cr);
  }
 
  // bright
  {
    // arrow head
    _draw_arrow_head(cr, arrow, arrow_x_a, arrow_y_a, arrow_x_b, arrow_y_b);
    // erase all drawings below
    cairo_set_source_rgba(cr, 0., 0., 0., 0.);
    cairo_fill_preserve(cr);
 
    dt_draw_set_color_overlay(cr, TRUE, 0.8);
    dt_draw_set_dash_style(cr, DT_MASKS_NO_DASH, zoom_scale);
    if(selected)
      cairo_set_line_width(cr, (2 * DT_DRAW_SIZE_LINE) / zoom_scale);
    else
      cairo_set_line_width(cr, (DT_DRAW_SIZE_LINE) / zoom_scale);
    cairo_stroke(cr);
 
    // arrow tail
    _draw_arrow_tail(cr, arrow_bud_x, arrow_bud_y, tail, draw_tail);
    dt_draw_set_dash_style(cr, dash_style, zoom_scale);
    dt_draw_set_color_overlay(cr, TRUE, 0.8);
    if(selected)
      cairo_set_line_width(cr, (3 * DT_DRAW_SIZE_LINE) / zoom_scale);
    else
      cairo_set_line_width(cr, (2 * DT_DRAW_SIZE_LINE) / zoom_scale);
    cairo_stroke(cr);
  }
  cairo_restore(cr);
}
 
static inline void dt_draw_cross(cairo_t *cr, const float zoom_scale, const float x, const float y)
{
  const float dx = DT_DRAW_SIZE_CROSS / zoom_scale;
  const float dy = DT_DRAW_SIZE_CROSS / zoom_scale;
  cairo_save(cr);
 
  cairo_set_line_cap(cr, CAIRO_LINE_CAP_SQUARE);
  dt_draw_set_dash_style(cr, DT_MASKS_NO_DASH, zoom_scale);
  cairo_set_line_width(cr, DT_DRAW_SIZE_LINE_HIGHLIGHT / zoom_scale);
  dt_draw_set_color_overlay(cr, FALSE, 0.8);
 
  cairo_move_to(cr, x + dx, y);
  cairo_line_to(cr, x - dx, y);
  cairo_move_to(cr, x, y + dy);
  cairo_line_to(cr, x, y - dy);
  cairo_stroke_preserve(cr);
 
  cairo_set_line_width(cr, DT_DRAW_SIZE_LINE / zoom_scale);
  dt_draw_set_color_overlay(cr, TRUE, 0.8);
  cairo_stroke(cr);
 
  cairo_restore(cr);
}
 
static inline void dt_draw_source_shape(struct dt_develop_t *dev, cairo_t *cr, const float zoom_scale, const gboolean selected,
  const float *source_pts, const int source_pts_count, const int nodes_nb, const shape_draw_function_t *draw_shape_func)
{
  cairo_save(cr);
 
  cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
  dt_draw_set_dash_style(cr, DT_MASKS_NO_DASH, zoom_scale);
 
  if(draw_shape_func)
    /* a source outline is a copy of the shape placed elsewhere; it carries no cuts */
    (*draw_shape_func)(dev, cr, source_pts, source_pts_count, nodes_nb, FALSE, TRUE, NULL, 0);
 
  //dark line
  if(selected)
    cairo_set_line_width(cr, DT_DRAW_SIZE_LINE_HIGHLIGHT_SELECTED / zoom_scale);
  else
    cairo_set_line_width(cr, DT_DRAW_SIZE_LINE_HIGHLIGHT / zoom_scale);
  dt_draw_set_color_overlay(cr, FALSE, 0.6);
  cairo_stroke_preserve(cr);
 
  //bright line
  if(selected)
    cairo_set_line_width(cr, DT_DRAW_SIZE_LINE_SELECTED / zoom_scale);
  else
    cairo_set_line_width(cr, (1.5f * DT_DRAW_SIZE_LINE) / zoom_scale);
  dt_draw_set_color_overlay(cr, TRUE, 0.8);
  cairo_stroke(cr);
  
  cairo_restore(cr);
}
 
static inline GdkPixbuf *dt_draw_get_pixbuf_from_cairo(DTGTKCairoPaintIconFunc paint, const int width, const int height)
{
  cairo_surface_t *cst = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
  cairo_t *cr = cairo_create(cst);
  dt_widget_set_source_rgba(cr, DT_GUI_COLOR_BUTTON_FG, 1.0);
  paint(cr, 0, 0, width, height, 0, NULL);
  cairo_destroy(cr);
 
  guchar *data = cairo_image_surface_get_data(cst);
  dt_draw_cairo_to_gdk_pixbuf(data, width, height);
  const int stride = cairo_image_surface_get_stride(cst);
  const size_t size = (size_t)stride * height;
  guchar *buf = (guchar *)malloc(size);
  memcpy(buf, data, size);
  cairo_surface_destroy(cst);
 
  return gdk_pixbuf_new_from_data(buf, GDK_COLORSPACE_RGB, TRUE, 8, width, height,
                                  stride, (GdkPixbufDestroyNotify)free, NULL);
}
 
#ifdef __cplusplus
}
#endif
 
#endif // DT_WIDGETS_DRAW_H
 
// 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