darkroom.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2009-2014, 2018 johannes hanika.
    Copyright (C) 2010-2012 Henrik Andersson.
    Copyright (C) 2010 Stuart Henderson.
    Copyright (C) 2010-2018, 2020 Tobias Ellinghaus.
    Copyright (C) 2011-2012 Antony Dovgal.
    Copyright (C) 2011 Edouard Gomez.
    Copyright (C) 2011, 2013-2015 Jérémy Rosen.
    Copyright (C) 2011 Karl Mikaelsson.
    Copyright (C) 2011 Omari Stephens.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2011 Steven Carter.
    Copyright (C) 2012-2016, 2019-2022 Aldric Renaudin.
    Copyright (C) 2012 Christian Tellefsen.
    Copyright (C) 2012 Frédéric Grollier.
    Copyright (C) 2012-2013 José Carlos García Sogo.
    Copyright (C) 2012-2022 Pascal Obry.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2012-2014 Ulrich Pegelow.
    Copyright (C) 2013 Dennis Gnad.
    Copyright (C) 2013 Pascal de Bruijn.
    Copyright (C) 2013-2017, 2020 Roman Lebedev.
    Copyright (C) 2014, 2017, 2020-2021 Dan Torop.
    Copyright (C) 2014, 2017, 2019 parafin.
    Copyright (C) 2014 Pedro Côrte-Real.
    Copyright (C) 2014 Stéphane Gimenez.
    Copyright (C) 2015 Guillaume Subiron.
    Copyright (C) 2016 Asma.
    Copyright (C) 2016 itinerarium.
    Copyright (C) 2017-2019 Edgardo Hoszowski.
    Copyright (C) 2017 Matthieu Moy.
    Copyright (C) 2017-2019 Peter Budai.
    Copyright (C) 2017 Žilvinas Žaltiena.
    Copyright (C) 2018 Hans Rosenfeld.
    Copyright (C) 2018 rawfiner.
    Copyright (C) 2018 Rikard Öxler.
    Copyright (C) 2019 Alexander Blinne.
    Copyright (C) 2019 Alexis Mousset.
    Copyright (C) 2019-2020, 2022-2026 Aurélien PIERRE.
    Copyright (C) 2019, 2021 Bill Ferguson.
    Copyright (C) 2019-2022 Diederik Ter Rahe.
    Copyright (C) 2019-2022 Hanno Schwalm.
    Copyright (C) 2019-2020 Heiko Bauke.
    Copyright (C) 2019 jakubfi.
    Copyright (C) 2019, 2021 luzpaz.
    Copyright (C) 2019-2020 Philippe Weyland.
    Copyright (C) 2020-2022 Chris Elston.
    Copyright (C) 2020 GrahamByrnes.
    Copyright (C) 2020-2021 Hubert Kowalski.
    Copyright (C) 2020-2021 Marco.
    Copyright (C) 2020-2021 Mark-64.
    Copyright (C) 2020 Miloš Komarčević.
    Copyright (C) 2020 Reinout Nonhebel.
    Copyright (C) 2020 U-DESKTOP-HQME86J\marco.
    Copyright (C) 2021 darkelectron.
    Copyright (C) 2021 lhietal.
    Copyright (C) 2021-2022 Nicolas Auffray.
    Copyright (C) 2021-2022 Ralf Brown.
    Copyright (C) 2021-2022 Sakari Kapanen.
    Copyright (C) 2021 Victor Forsiuk.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2023 Alynx Zhou.
    Copyright (C) 2023 Luca Zulberti.
    Copyright (C) 2023 Maurizio Paglia.
    Copyright (C) 2023 Ricky Moon.
    Copyright (C) 2025-2026 Guillaume Stutin.
    
    darktable is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    darktable is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with darktable.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "bauhaus/bauhaus.h"
#include "common/collection.h"
#include "common/colorspaces.h"
#include "common/darktable.h"
#include "gui/gdkkeys.h"
#include "common/debug.h"
#include "common/file_location.h"
#include "common/history.h"
#include "common/image_cache.h"
#include "common/imageio.h"
#include "common/iop-autoset.h"
#include "common/imageio_module.h"
#include "common/mipmap_cache.h"
#include "common/selection.h"
#include "common/tags.h"
#include "common/undo.h"
#include "control/conf.h"
#include "control/control.h"
#include "control/jobs.h"
#include "develop/blend.h"
#include "develop/dev_pixelpipe.h"
#include "develop/develop.h"
#include "develop/imageop.h"
#include "develop/supervisor.h"
#include "develop/masks.h"
#include "dtgtk/button.h"
#include "dtgtk/thumbtable.h"
 
#include "gui/color_picker_proxy.h"
#include "gui/draw.h"
#include "gui/gtk.h"
#include "gui/gui_throttle.h"
#include "gui/guides.h"
#include "gui/presets.h"
#include "libs/colorpicker.h"
#include "libs/lib.h"
#include "views/dev_backbuf.h"
#include "views/dev_toolbox.h"
#include "views/view.h"
#include "views/view_api.h"
#ifdef GDK_WINDOWING_QUARTZ
#include "osx/osx.h"
#endif
 
#include <gdk/gdkkeysyms.h>
#include <glib.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
#ifndef G_SOURCE_FUNC // Defined for glib >= 2.58
#define G_SOURCE_FUNC(f) ((GSourceFunc) (void (*)(void)) (f))
#endif
 
DT_MODULE(1)
 
typedef struct coords_t
{
  double roi_coord[2];  // coordinates in ROI space
  double roi_delta[2];  // delta in ROI space
  double full_delta[2]; // delta in image space
  double full[2];       // coordinates in image space
}coords_t;
 
#define DARKROOM_EDGE_PAN_INTERVAL_MS 64
#define DARKROOM_EDGE_PAN_MARGIN_PX DT_PIXEL_APPLY_DPI(50)
#define DARKROOM_EDGE_PAN_SPEED_PX_PER_S 360.0f
 
/* signal handler for filmstrip image switching */
static void _view_darkroom_filmstrip_activate_callback(gpointer instance, int32_t imgid, gpointer user_data);
static void _darkroom_image_loaded_callback(gpointer instance, guint request_id, guint result, gpointer user_data);
 
static void _dev_change_image(dt_view_t *self, const int32_t imgid);
static void _darkroom_autoset_popover_rebuild(dt_develop_t *dev);
 
static int _change_scaling(dt_develop_t *dev, const float point[2], const float new_scaling);
static void _release_expose_source_caches(void);
static void _darkroom_set_default_cursor(dt_view_t *self, double x, double y);
 
static int32_t _darkroom_pending_imgid = UNKNOWN_IMAGE;
static dt_iop_module_t *_darkroom_pending_focus_module = NULL;
static GtkWidget *_darkroom_ioporder_button = NULL;
static gboolean _darkroom_center_pan_drag = FALSE;
 
static dt_autoset_manager_t *_autoset_manager = NULL;
static GtkWidget *_darkroom_autoset_button = NULL;
static GtkWidget *_darkroom_autoset_popover = NULL;
static GtkWidget *_darkroom_autoset_list = NULL;
static gboolean _darkroom_autoset_button_is_running = FALSE;
static void _darkroom_autoset_popover_refresh(gpointer instance, gpointer user_data);
static void _darkroom_autoset_button_set_running(const gboolean running);
 
static void _darkroom_ioporder_quickbutton_clicked(GtkButton *button, gpointer user_data)
{
  dt_lib_module_t *module = dt_lib_get_module("ioporder");
  if(module && module->show_popup)
    module->show_popup(module);
}
 
static void _darkroom_autoset_button_set_running(const gboolean running)
{
  if(IS_NULL_PTR(_darkroom_autoset_button)) return;
  if(_darkroom_autoset_button_is_running == running) return;
 
  _darkroom_autoset_button_is_running = running;
 
  gtk_widget_set_sensitive(_darkroom_autoset_button, !running);
  gtk_widget_set_tooltip_text(_darkroom_autoset_button,
                              running ? _("Autoset is running on selected modules")
                                      : _("Run autoset on selected modules\nRight click for options"));
 
  if(running)
    dt_gui_add_class(_darkroom_autoset_button, "active");
  else
    dt_gui_remove_class(_darkroom_autoset_button, "active");
}
 
const char *name(const dt_view_t *self)
{
  return _("Darkroom");
}
 
 
void init(dt_view_t *self)
{
  self->data = malloc(sizeof(dt_develop_t));
  dt_dev_init((dt_develop_t *)self->data, 1);
  darktable.develop = (dt_develop_t *)self->data;
  darktable.view_manager->proxy.darkroom.view = self;
}
 
uint32_t view(const dt_view_t *self)
{
  return DT_VIEW_DARKROOM;
}
 
static void _reset_edge_pan()
{
  dt_gui_gtk_t *gui = darktable.gui;
  if(IS_NULL_PTR(gui)) return;
  if(gui->pan_edge.timeout_source)
  {
    g_source_remove(gui->pan_edge.timeout_source);
  }
  memset(&gui->pan_edge, 0, sizeof(gui->pan_edge));
}
 
void cleanup(dt_view_t *self)
{
  dt_develop_t *dev = (dt_develop_t *)self->data;
 
  // Cancel any pending edge pan timeout and reset the state
  _reset_edge_pan();
 
  _release_expose_source_caches();
  dt_gui_throttle_cancel(dev);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(darktable.signals, G_CALLBACK(_darkroom_autoset_popover_refresh), dev);
  if(_autoset_manager)
  {
    if(!IS_NULL_PTR(_autoset_manager->input_wait))
    {
      dt_dev_pixelpipe_cache_wait_cleanup((dt_dev_pixelpipe_cache_wait_t *)_autoset_manager->input_wait,
                                          "darkroom-cleanup-autoset-manager");
      g_free(_autoset_manager->input_wait);
      _autoset_manager->input_wait = NULL;
    }
    if(_autoset_manager->progress_cursor_active)
    {
      dt_control_log_busy_leave();
      _autoset_manager->progress_cursor_active = FALSE;
    }
    g_list_free(_autoset_manager->iop_to_set);
    dt_free_align(_autoset_manager);
    _autoset_manager = NULL;
  }
  _darkroom_autoset_button_is_running = FALSE;
  _darkroom_autoset_list = NULL;
  _darkroom_autoset_popover = NULL;
 
  // unref the grid lines popover if needed
  if(darktable.view_manager->guides_popover) g_object_unref(darktable.view_manager->guides_popover);
  _darkroom_pending_imgid = UNKNOWN_IMAGE;
  _darkroom_pending_focus_module = NULL;
  dt_dev_cleanup(dev);
  dt_free(dev);
}
 
static cairo_status_t _write_snapshot_data(void *closure, const unsigned char *data, unsigned int length)
{
  const int fd = GPOINTER_TO_INT(closure);
  ssize_t res = write(fd, data, length);
  if(res != length)
    return CAIRO_STATUS_WRITE_ERROR;
  return CAIRO_STATUS_SUCCESS;
}
 
static dt_darkroom_layout_t _lib_darkroom_get_layout(dt_view_t *self)
{
  return DT_DARKROOM_LAYOUT_EDITING;
}
 
static gboolean _darkroom_is_only_selected_sample(gboolean is_primary_sample, dt_colorpicker_sample_t *selected_sample, gboolean display_samples)
{
  return !is_primary_sample && selected_sample && !display_samples;
}
 
static inline void _darkroom_sample_raw_point_to_image_norm(const dt_colorpicker_sample_t *const sample,
                                                            float point[2])
{
  point[0] = sample->point[0];
  point[1] = sample->point[1];
  dt_dev_coordinates_raw_norm_to_image_norm(darktable.develop, point, 1);
}
 
static inline void _darkroom_sample_raw_box_to_image_norm(const dt_colorpicker_sample_t *const sample,
                                                          float box[4])
{
  memcpy(box, sample->box, sizeof(float) * 4);
  dt_dev_coordinates_raw_norm_to_image_norm(darktable.develop, box, 2);
}
 
static void _darkroom_pickers_draw(dt_view_t *self, cairo_t *cri,
                                   int32_t width, int32_t height, int32_t pozx, int32_t pozy,
                                   GSList *samples, gboolean is_primary_sample)
{
  if(IS_NULL_PTR(samples)) return;
 
  dt_develop_t *dev = (dt_develop_t *)self->data;
 
  cairo_save(cri);
  // The colorpicker samples bounding rectangle should only be displayed inside the visible image
 
  const double wd = dev->roi.preview_width;
  const double ht = dev->roi.preview_height;
  const double scale = dt_dev_get_fit_scale(dev);
  const double lw = 1.0 / scale;
  const double dashes[1] = { lw * 4.0 };
 
  dt_dev_rescale_roi(dev, cri, width, height);
 
  // makes point sample crosshair gap look nicer
  cairo_set_line_cap(cri, CAIRO_LINE_CAP_SQUARE);
 
  dt_colorpicker_sample_t *selected_sample = darktable.develop->color_picker.selected_sample;
  const gboolean only_selected_sample
      = _darkroom_is_only_selected_sample(is_primary_sample, selected_sample,
                                          darktable.develop->color_picker.display_samples);
  
  for( ; samples; samples = g_slist_next(samples))
  {
    dt_colorpicker_sample_t *sample = samples->data;
    if(only_selected_sample && (sample != selected_sample))
      continue;
 
    // The picker is at the resolution of the preview pixelpipe. This
    // is width/2 of a preview-pipe pixel in (scaled) user space
    // coordinates. Use half pixel width so rounding to nearest device
    // pixel doesn't make uneven centering.
    double half_px = 0.5;
    const double min_half_px_device = 4.0;
    // FIXME: instead of going to all this effort to show how error-prone a preview pipe sample can be, just produce a better point sample
    gboolean show_preview_pixel_scale = TRUE;
 
    // overlays are aligned with pixels for a clean look
    if(sample->size == DT_LIB_COLORPICKER_SIZE_BOX)
    {
      float image_box[4] = { 0.0f };
      _darkroom_sample_raw_box_to_image_norm(sample, image_box);
      double x = image_box[0] * wd, y = image_box[1] * ht,
        w = image_box[2] * wd, h = image_box[3] * ht;
      cairo_user_to_device(cri, &x, &y);
      cairo_user_to_device(cri, &w, &h);
      x=round(x+0.5)-0.5;
      y=round(y+0.5)-0.5;
      w=round(w+0.5)-0.5;
      h=round(h+0.5)-0.5;
      cairo_device_to_user(cri, &x, &y);
      cairo_device_to_user(cri, &w, &h);
      cairo_rectangle(cri, x, y, w - x, h - y);
      if(is_primary_sample)
      {
        // handles
        const double hw = 5. / scale;
        cairo_rectangle(cri, x - hw, y - hw, 2. * hw, 2. * hw);
        cairo_rectangle(cri, x - hw, h - hw, 2. * hw, 2. * hw);
        cairo_rectangle(cri, w - hw, y - hw, 2. * hw, 2. * hw);
        cairo_rectangle(cri, w - hw, h - hw, 2. * hw, 2. * hw);
      }
    }
    else if(sample->size == DT_LIB_COLORPICKER_SIZE_POINT)
    {
      // FIXME: to be really accurate, the colorpicker should render precisely over the nearest pixelpipe pixel, but this gets particularly tricky to do with iop pickers with transformations after them in the pipeline
      float image_point[2] = { 0.0f };
      _darkroom_sample_raw_point_to_image_norm(sample, image_point);
      double x = image_point[0] * wd;
      double y = image_point[1] * ht;
      cairo_user_to_device(cri, &x, &y);
      x=round(x+0.5)-0.5;
      y=round(y+0.5)-0.5;
      // render picker center a reasonable size in device pixels
      half_px = round(half_px * scale);
      if(half_px < min_half_px_device)
      {
        half_px = min_half_px_device;
        show_preview_pixel_scale = FALSE;
      }
      // crosshair radius
      double crosshair = (is_primary_sample ? 4. : 5.) * half_px;
      if(sample == selected_sample) crosshair *= 2;
      cairo_device_to_user(cri, &x, &y);
      cairo_device_to_user_distance(cri, &crosshair, &half_px);
 
      // "handles"
      if(is_primary_sample)
        cairo_arc(cri, x, y, crosshair, 0., 2. * M_PI);
      // crosshair
      cairo_move_to(cri, x - crosshair, y);
      cairo_line_to(cri, x + crosshair, y);
      cairo_move_to(cri, x, y - crosshair);
      cairo_line_to(cri, x, y + crosshair);
    }
 
    // default is to draw 1 (logical) pixel light lines with 1
    // (logical) pixel dark outline for legibility
    const double line_scale = (sample == selected_sample ? 2.0 : 1.0);
    cairo_set_line_width(cri, lw * 3.0 * line_scale);
    cairo_set_source_rgba(cri, 0.0, 0.0, 0.0, 0.4);
    cairo_stroke_preserve(cri);
 
    const gboolean draw_dashed = !is_primary_sample
                   && sample != selected_sample
                   && sample->size == DT_LIB_COLORPICKER_SIZE_BOX;
    cairo_set_line_width(cri, lw * line_scale);
    cairo_set_dash(cri, dashes, draw_dashed, 0.0);
 
    cairo_set_source_rgba(cri, 1.0, 1.0, 1.0, 0.8);
    cairo_stroke(cri);
 
    // draw the actual color sampled
    // FIXME: if an area sample is selected, when selected should fill it with colorpicker color?
    // NOTE: The sample may be based on outdated data, but still
    // display as it will update eventually. If we only drew on valid
    // data, swatches on point live samples would flicker when the
    // primary sample was drawn, and the primary sample swatch would
    // flicker when an iop is adjusted.
    if(sample->size == DT_LIB_COLORPICKER_SIZE_POINT)
    {
      float image_point[2] = { 0.0f };
      _darkroom_sample_raw_point_to_image_norm(sample, image_point);
      if(sample == selected_sample)
        cairo_arc(cri, image_point[0] * wd, image_point[1] * ht, half_px * 2., 0., 2. * M_PI);
      else if(show_preview_pixel_scale)
        cairo_rectangle(cri, image_point[0] * wd - half_px, image_point[1] * ht - half_px, half_px * 2., half_px * 2.);
      else
        cairo_arc(cri, image_point[0] * wd, image_point[1] * ht, half_px, 0., 2. * M_PI);
 
      set_color(cri, sample->swatch);
      cairo_fill(cri);
    }
  }
 
  cairo_restore(cri);
}
 
/* Debug-only darkroom expose mode:
 * - no persistent surface locks,
 * - no fallback cache,
 * - no preview substitution,
 * - only main backbuffer if currently available.
 *
 * Set to 1 for baseline debugging when troubleshooting display regressions. */
#ifndef DARKROOM_EXPOSE_DUMB_DEBUG
#define DARKROOM_EXPOSE_DUMB_DEBUG 0
#endif
 
#if DARKROOM_EXPOSE_DUMB_DEBUG
static dt_dev_pixelpipe_cache_wait_t _darkroom_main_debug_wait = { 0 };
 
static void _darkroom_debug_restart_cache_wait(gpointer user_data)
{
  dt_develop_t *dev = (dt_develop_t *)user_data;
  if(IS_NULL_PTR(dev) || !dev->gui_attached) return;
  dt_control_queue_redraw_center();
}
 
static gboolean _render_main_direct_debug(cairo_t *cr, dt_develop_t *dev, const int width, const int height,
                                          const int border, const dt_aligned_pixel_t bg_color)
{
  if(IS_NULL_PTR(cr) || IS_NULL_PTR(dev) || IS_NULL_PTR(dev->pipe)) return FALSE;
 
  cairo_set_source_rgb(cr, bg_color[0], bg_color[1], bg_color[2]);
  cairo_paint(cr);
 
  if(!dt_dev_pixelpipe_is_backbufer_valid(dev->pipe, dev)) return FALSE;
  const uint64_t hash = dt_dev_backbuf_get_hash(&dev->pipe->backbuf);
  if(hash == (uint64_t)-1) return FALSE;
 
  dt_pixel_cache_entry_t *entry = NULL;
  void *data = NULL;
  dt_dev_pixelpipe_cache_wait_set_owner(&_darkroom_main_debug_wait, "darkroom-debug-main", dev);
  if(!dt_dev_pixelpipe_cache_peek_gui(dev->pipe, NULL, &data, &entry,
                                      &_darkroom_main_debug_wait,
                                      _darkroom_debug_restart_cache_wait, dev))
    return FALSE;
 
  dt_dev_pixelpipe_cache_rdlock_entry(darktable.pixelpipe_cache, TRUE, entry);
 
  const int bw = (int)dev->pipe->backbuf.width;
  const int bh = (int)dev->pipe->backbuf.height;
  if(bw <= 0 || bh <= 0)
  {
    dt_dev_pixelpipe_cache_rdlock_entry(darktable.pixelpipe_cache, FALSE, entry);
    return FALSE;
  }
 
  const int stride = cairo_format_stride_for_width(CAIRO_FORMAT_RGB24, bw);
  const size_t required_size = (size_t)stride * (size_t)bh;
  const size_t entry_size = dt_pixel_cache_entry_get_size(entry);
  if(entry_size < required_size || dt_pixel_cache_entry_get_data(entry) != data)
  {
    dt_dev_pixelpipe_cache_rdlock_entry(darktable.pixelpipe_cache, FALSE, entry);
    return FALSE;
  }
 
  cairo_surface_t *surface = cairo_image_surface_create_for_data((unsigned char *)data, CAIRO_FORMAT_RGB24,
                                                                  bw, bh, stride);
  if(IS_NULL_PTR(surface) || cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS)
  {
    if(surface) cairo_surface_destroy(surface);
    dt_dev_pixelpipe_cache_rdlock_entry(darktable.pixelpipe_cache, FALSE, entry);
    return FALSE;
  }
 
  float image_box[4] = { 0.0f };
  dt_dev_get_image_box_in_widget(dev, width, height, image_box);
  const int wd = image_box[2];
  const int ht = image_box[3];
  cairo_translate(cr, image_box[0], image_box[1]);
  if(dev->iso_12646.enabled) dt_dev_draw_iso12646_border(cr, wd, ht, border);
  cairo_surface_set_device_scale(surface, darktable.gui->ppd, darktable.gui->ppd);
  cairo_rectangle(cr, 0, 0, wd, ht);
  cairo_set_source_surface(cr, surface, 0, 0);
  cairo_fill(cr);
 
  cairo_surface_destroy(surface);
  dt_dev_pixelpipe_cache_rdlock_entry(darktable.pixelpipe_cache, FALSE, entry);
  return TRUE;
}
#endif
 
static dt_dev_locked_surface_t _darkroom_main_locked = { .hash = DT_PIXELPIPE_CACHE_HASH_INVALID };
static dt_dev_locked_surface_t _darkroom_preview_locked = { .hash = DT_PIXELPIPE_CACHE_HASH_INVALID };
static dt_dev_pixelpipe_cache_wait_t _darkroom_main_wait = { 0 };
static dt_dev_pixelpipe_cache_wait_t _darkroom_preview_wait = { 0 };
static cairo_surface_t *_darkroom_preview_fallback_surface = NULL;
static int32_t _darkroom_preview_fallback_imgid = UNKNOWN_IMAGE;
static uint64_t _darkroom_preview_fallback_zoom_hash = 0;
static uint64_t _darkroom_preview_fallback_backbuf_hash = 0;
static int _darkroom_preview_fallback_width = 0;
static int _darkroom_preview_fallback_height = 0;
 
static void _release_preview_fallback_surface(void)
{
  if(_darkroom_preview_fallback_surface)
  {
    cairo_surface_destroy(_darkroom_preview_fallback_surface);
    _darkroom_preview_fallback_surface = NULL;
  }
 
  _darkroom_preview_fallback_imgid = UNKNOWN_IMAGE;
  _darkroom_preview_fallback_zoom_hash = 0;
  _darkroom_preview_fallback_backbuf_hash = 0;
  _darkroom_preview_fallback_width = 0;
  _darkroom_preview_fallback_height = 0;
}
 
static void _release_expose_source_caches(void)
{
  dt_dev_release_locked_surface(&_darkroom_main_locked);
  dt_dev_release_locked_surface(&_darkroom_preview_locked);
  dt_dev_pixelpipe_cache_wait_cleanup(&_darkroom_main_wait, "darkroom-release-main");
  dt_dev_pixelpipe_cache_wait_cleanup(&_darkroom_preview_wait, "darkroom-release-preview");
#if DARKROOM_EXPOSE_DUMB_DEBUG
  dt_dev_pixelpipe_cache_wait_cleanup(&_darkroom_main_debug_wait, "darkroom-release-debug");
#endif
  _release_preview_fallback_surface();
}
 
static gboolean _build_preview_fallback_surface(dt_develop_t *dev, const int width, const int height, const int border,
                                                const dt_aligned_pixel_t bg_color, const uint64_t zoom_hash)
{
  if(IS_NULL_PTR(_darkroom_preview_locked.surface)) return FALSE;
  if(IS_NULL_PTR(_darkroom_preview_locked.entry) || _darkroom_preview_locked.hash == (uint64_t)-1) return FALSE;
  if(width <= 0 || height <= 0) return FALSE;
 
  if(IS_NULL_PTR(_darkroom_preview_fallback_surface)
     || _darkroom_preview_fallback_width != width
     || _darkroom_preview_fallback_height != height)
  {
    _release_preview_fallback_surface();
    _darkroom_preview_fallback_surface = dt_cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);
    if(IS_NULL_PTR(_darkroom_preview_fallback_surface)) return FALSE;
    _darkroom_preview_fallback_width = width;
    _darkroom_preview_fallback_height = height;
  }
 
  cairo_t *cr = cairo_create(_darkroom_preview_fallback_surface);
  cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
 
  cairo_set_source_rgb(cr, bg_color[0], bg_color[1], bg_color[2]);
  cairo_paint(cr);
 
  const int wd = _darkroom_preview_locked.width;
  const int ht = _darkroom_preview_locked.height;
  const float ppd = darktable.gui->ppd;
  const float preview_wd = wd / ppd;
  const float preview_ht = ht / ppd;
  const float preview_scale = dev->roi.scaling;
  float image_box[4] = { 0.0f };
  dt_dev_get_image_box_in_widget(dev, width, height, image_box);
 
  if(dev->iso_12646.enabled)
  {
 
 
    if(image_box[2] > 0 && image_box[3] > 0)
    {
      cairo_save(cr);
      cairo_translate(cr, image_box[0], image_box[1]);
      dt_dev_draw_iso12646_border(cr, image_box[2], image_box[3], border);
      cairo_restore(cr);
    }
  }
 
  dt_dev_pixelpipe_cache_rdlock_entry(darktable.pixelpipe_cache, TRUE, _darkroom_preview_locked.entry);
  cairo_surface_set_device_scale(_darkroom_preview_locked.surface, ppd, ppd);
 
  // The preview surface already embeds the fit-to-window scale. To emulate the
  // main pipe while it catches up, we only apply the additional darkroom zoom
  // and pan around the preview image center in GUI logical coordinates.
  const float roi_width = fminf(width, preview_wd * preview_scale);
  const float roi_height = fminf(height, preview_ht * preview_scale);
  const float rec_x = fmaxf(border, (width - roi_width) * 0.5f);
  const float rec_y = fmaxf(border, (height - roi_height) * 0.5f);
  const float rec_w = fminf(width - 2 * border, roi_width);
  const float rec_h = fminf(height - 2 * border, roi_height);
  cairo_rectangle(cr, rec_x, rec_y, rec_w, rec_h);
  cairo_clip(cr);
 
  const float tx = 0.5f * width - dev->roi.x * preview_wd * preview_scale;
  const float ty = 0.5f * height - dev->roi.y * preview_ht * preview_scale;
  cairo_translate(cr, tx, ty);
  cairo_scale(cr, preview_scale, preview_scale);
  cairo_rectangle(cr, 0, 0, preview_wd, preview_ht);
  cairo_set_source_surface(cr, _darkroom_preview_locked.surface, 0, 0);
  cairo_fill(cr);
  dt_dev_pixelpipe_cache_rdlock_entry(darktable.pixelpipe_cache, FALSE, _darkroom_preview_locked.entry);
  cairo_destroy(cr);
 
  _darkroom_preview_fallback_imgid = dev->image_storage.id;
  _darkroom_preview_fallback_zoom_hash = zoom_hash;
  _darkroom_preview_fallback_backbuf_hash = dt_dev_backbuf_get_hash(&dev->preview_pipe->backbuf);
  return TRUE;
}
 
static gboolean _render_preview_fallback_surface(cairo_t *cr)
{
  if(IS_NULL_PTR(cr) || !_darkroom_preview_fallback_surface) return FALSE;
  cairo_set_source_surface(cr, _darkroom_preview_fallback_surface, 0, 0);
  cairo_paint(cr);
  return TRUE;
}
 
static void _paint_all(cairo_t *cri, cairo_t *cr, cairo_surface_t *image_surface)
{
  cairo_destroy(cr);
  if(IS_NULL_PTR(image_surface)) return;
  cairo_set_source_surface(cri, image_surface, 0, 0);
  cairo_paint(cri);
}
 
typedef struct darkroom_expose_state_t
{
  int image_surface_width;
  int image_surface_height;
  int32_t image_surface_imgid;
  gboolean image_surface_has_main;
  uint64_t image_surface_hash;
  uint64_t main_zoom_hash;
  /* Main backbuf hash for which we already asked for a retry redraw after failing
   * to lock/render it. Used to re-queue at most once per distinct main frame so a
   * permanently-unlockable main backbuf (e.g. evicted under memory pressure) does
   * not spin the center redraw at frame-clock rate while we show the preview
   * fallback. Reset whenever a main frame is rendered successfully. */
  uint64_t pending_main_hash;
} darkroom_expose_state_t;
 
static inline gboolean _darkroom_preview_fallback_valid(const dt_develop_t *dev, const int width,
                                                        const int height, const uint64_t zoom_hash)
{
  return dev
         && _darkroom_preview_fallback_surface
         && _darkroom_preview_fallback_imgid == dev->image_storage.id
         && _darkroom_preview_fallback_zoom_hash == zoom_hash
         && _darkroom_preview_fallback_width == width
         && _darkroom_preview_fallback_height == height;
}
 
static inline gboolean _darkroom_locked_main_valid_for_zoom(const darkroom_expose_state_t *state,
                                                            const uint64_t zoom_hash)
{
  return state
         && _darkroom_main_locked.surface
         && _darkroom_main_locked.hash != (uint64_t)-1
         && state->main_zoom_hash == zoom_hash;
}
 
static inline void _darkroom_reset_expose_state(darkroom_expose_state_t *state)
{
  if(IS_NULL_PTR(state)) return;
  state->image_surface_imgid = UNKNOWN_IMAGE;
  state->image_surface_has_main = FALSE;
  state->image_surface_hash = DT_PIXELPIPE_CACHE_HASH_INVALID;
  state->main_zoom_hash = 0;
  state->pending_main_hash = DT_PIXELPIPE_CACHE_HASH_INVALID;
}
 
static void _darkroom_prepare_image_surface(dt_develop_t *dev, const int width, const int height,
                                            darkroom_expose_state_t *state)
{
  if(IS_NULL_PTR(dev) || !state) return;
 
  if(state->image_surface_imgid != dev->image_storage.id
     && state->image_surface_imgid != UNKNOWN_IMAGE)
  {
    _release_expose_source_caches();
    _darkroom_reset_expose_state(state);
  }
 
  if(state->image_surface_width == width
     && state->image_surface_height == height
     && !IS_NULL_PTR(dev->image_surface))
    return;
 
  state->image_surface_width = width;
  state->image_surface_height = height;
  if(dev->image_surface) cairo_surface_destroy(dev->image_surface);
  dev->image_surface = dt_cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);
  state->image_surface_imgid = UNKNOWN_IMAGE;
  state->image_surface_has_main = FALSE;
  state->image_surface_hash = DT_PIXELPIPE_CACHE_HASH_INVALID;
  _release_preview_fallback_surface();
}
 
void expose(
    dt_view_t *self,
    cairo_t *cri,
    int32_t width,
    int32_t height,
    int32_t pointerx,
    int32_t pointery)
{
  dt_times_t start;
  dt_get_times(&start);
 
  cairo_save(cri);
 
  dt_develop_t *dev = (dt_develop_t *)self->data;
 
  const int32_t border = dev->roi.border_size;
 
#if DARKROOM_EXPOSE_DUMB_DEBUG
  dt_aligned_pixel_t bg_color_dbg;
  dt_dev_get_background_color(dev, bg_color_dbg);
  _render_main_direct_debug(cri, dev, width, height, border, bg_color_dbg);
  cairo_restore(cri);
  return;
#endif
 
  static darkroom_expose_state_t expose_state = {
    .image_surface_width = 0,
    .image_surface_height = 0,
    .image_surface_imgid = UNKNOWN_IMAGE,
    .image_surface_has_main = FALSE,
    .image_surface_hash = DT_PIXELPIPE_CACHE_HASH_INVALID,
    .main_zoom_hash = 0,
    .pending_main_hash = DT_PIXELPIPE_CACHE_HASH_INVALID,
  };
  const uint64_t zoom_hash = dt_hash(5381, (char *)&dev->roi, sizeof(dev->roi));
  const gboolean roi_changed = !_darkroom_locked_main_valid_for_zoom(&expose_state, zoom_hash);
 
  _darkroom_prepare_image_surface(dev, width, height, &expose_state);
 
  cairo_t *cr = cairo_create(dev->image_surface);
  const int full_width = dev->roi.preview_width;
  const int full_height = dev->roi.preview_height;
  const uint64_t main_backbuf_hash = dt_dev_backbuf_get_hash(&dev->pipe->backbuf);
  const uint64_t preview_backbuf_hash = dt_dev_backbuf_get_hash(&dev->preview_pipe->backbuf);
  const gboolean main_has_backbuf = main_backbuf_hash != DT_PIXELPIPE_CACHE_HASH_INVALID;
  const gboolean preview_has_backbuf = preview_backbuf_hash != DT_PIXELPIPE_CACHE_HASH_INVALID;
  // Compare main against the last main surface, not against the last source painted into
  // image_surface. At fit the latter may be the preview pipe, whose different hash would make an
  // old main backbuffer look new and briefly restore the previous zoom size.
  const gboolean main_backbuf_is_newer
      = main_has_backbuf && main_backbuf_hash != _darkroom_main_locked.hash;
  const gboolean main_ready_for_current_view
      = main_has_backbuf && (!roi_changed || main_backbuf_is_newer || !_darkroom_main_locked.surface);
  const gboolean preview_matches_full_image
      = preview_has_backbuf && dt_dev_pipelines_share_preview_output(dev)
        && full_width > 0 && full_height > 0
        && dev->preview_pipe->backbuf.width == full_width
        && dev->preview_pipe->backbuf.height == full_height;
  const gboolean full_image_backbuf_ready = main_ready_for_current_view || preview_matches_full_image;
 
  dt_aligned_pixel_t bg_color = { 0.0f };
  const char *draw_source = "background only";
  uint64_t draw_hash = (uint64_t)-1;
  gboolean drawn = FALSE;
  gboolean drawn_from_main = FALSE;
 
  dt_dev_get_background_color(dev, bg_color);
 
  cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
 
  /* Selection policy, kept intentionally linear:
   * 1. Prefer the main pipe whenever it already has the backbuf for the
   *    current darkroom view. We do not guess that from size. If ROI did not
   *    change, the existing main frame stays authoritative. If ROI changed, a
   *    new main backbuf hash means the updated main frame arrived.
   * 2. If preview produced the exact same full-image buffer size first
   *    (zoom-to-fit / same ROI), treat it exactly like main.
   * 3. Only when zoom/pan changed and main has not caught up yet, use a scaled
   *    preview fallback surface. This gives immediate ROI feedback without
   *    discarding the last valid main image for pure history changes.
   * 4. If nothing newer is ready, keep showing the last valid composed frame to
   *    avoid flashing the background. */
 
  /* Once a full-image backbuf exists again, the ROI-scaled preview fallback is
   * obsolete. Keep main/preview selection simple and never let the fallback
   * outlive a valid full-image source. */
  if(full_image_backbuf_ready)
    _release_preview_fallback_surface();
 
  /* Rule 1: main wins whenever it is ready for the current view. During a
   * zoom/pan/widget-size transition, the previous main hash stays visible until
   * a different main hash is published; only then does main override preview
   * fallback again. */
  if(main_ready_for_current_view)
  {
    if(dt_dev_lock_pipe_surface(dev, dev->pipe, &_darkroom_main_locked, &_darkroom_main_wait, "darkroom-main", FALSE)
       && _darkroom_main_locked.surface
       && dt_dev_render_locked_surface(cr, dev, &_darkroom_main_locked, width, height, border, bg_color))
    {
      expose_state.main_zoom_hash = zoom_hash;
      expose_state.image_surface_imgid = dev->image_storage.id;
      expose_state.image_surface_has_main = TRUE;
      expose_state.pending_main_hash = DT_PIXELPIPE_CACHE_HASH_INVALID;
      _release_preview_fallback_surface();
      drawn = TRUE;
      drawn_from_main = TRUE;
      draw_source = "fresh main backbuf";
      draw_hash = _darkroom_main_locked.hash;
    }
    else if(main_backbuf_is_newer && expose_state.pending_main_hash != main_backbuf_hash)
    {
      /* The main backbuf hash advanced but its cacheline could not be locked this
       * frame. Ask for one retry, then remember the hash: if the same main frame
       * stays unlockable (e.g. evicted under memory pressure), we keep presenting
       * the preview fallback below instead of re-queueing a redraw every frame.
       * A genuinely new main frame (different hash) re-arms the retry, and the
       * pipeline itself re-queues a redraw when it publishes a fresh backbuf. */
      expose_state.pending_main_hash = main_backbuf_hash;
      dt_control_queue_redraw_center();
    }
  }
 
  /* Rule 2: preview is directly equivalent to main only when both pipes target
   * the same ROI. An uncropped edit mode changes the module contract, not the
   * current zoom: once zoomed, preview must use the scaled fallback below. */
  if(!drawn && preview_matches_full_image)
  {
    if(dt_dev_lock_pipe_surface(dev, dev->preview_pipe, &_darkroom_preview_locked, &_darkroom_preview_wait,
                                "darkroom-preview", FALSE)
       && _darkroom_preview_locked.surface
       && dt_dev_render_locked_surface(cr, dev, &_darkroom_preview_locked, width, height, border, bg_color))
    {
      // This frame validates the composed image, not the locked main surface. Keep main_zoom_hash
      // unchanged so the old main backbuffer cannot be reused as if it had been rendered at fit.
      expose_state.image_surface_imgid = dev->image_storage.id;
      expose_state.image_surface_has_main = TRUE;
      _release_preview_fallback_surface();
      drawn = TRUE;
      drawn_from_main = TRUE;
      draw_source = "fresh full-size preview backbuf";
      draw_hash = _darkroom_preview_locked.hash;
    }
  }
 
  /* Rule 3: scaled preview fallback is only for ROI changes. If the user just
   * zoomed/panned and main has not recomputed yet, rebuild a ROI-scaled preview
   * placeholder so navigation remains responsive. */
  if(!drawn && roi_changed && !full_image_backbuf_ready && preview_has_backbuf)
  {
    if(dt_dev_lock_pipe_surface(dev, dev->preview_pipe, &_darkroom_preview_locked, &_darkroom_preview_wait,
                                "darkroom-preview", TRUE)
       && _build_preview_fallback_surface(dev, width, height, border, bg_color, zoom_hash)
       && _render_preview_fallback_surface(cr))
    {
      expose_state.image_surface_imgid = dev->image_storage.id;
      expose_state.image_surface_has_main = FALSE;
      drawn = TRUE;
      drawn_from_main = FALSE;
      draw_source = "fresh preview fallback";
      draw_hash = _darkroom_preview_fallback_backbuf_hash;
    }
  }
 
  /* Reuse the cached ROI-scaled preview fallback if it is still geometrically
   * valid for this zoom/pan. This avoids rebuilding it every expose while main
   * is still catching up. */
  if(!drawn && roi_changed && !full_image_backbuf_ready
     && _darkroom_preview_fallback_valid(dev, width, height, zoom_hash)
     && _render_preview_fallback_surface(cr))
  {
    expose_state.image_surface_imgid = dev->image_storage.id;
    expose_state.image_surface_has_main = FALSE;
    drawn = TRUE;
    drawn_from_main = FALSE;
    draw_source = "reused preview fallback";
    draw_hash = _darkroom_preview_fallback_backbuf_hash;
  }
 
  /* Rule 4: if no newer source is ready, keep the last valid main frame for
   * the same zoom/pan. History-only changes should not glitch to preview or
   * background while the new main backbuf is still being produced. */
  if(!drawn && _darkroom_locked_main_valid_for_zoom(&expose_state, zoom_hash)
     && dt_dev_render_locked_surface(cr, dev, &_darkroom_main_locked, width, height, border, bg_color))
  {
    expose_state.image_surface_imgid = dev->image_storage.id;
    expose_state.image_surface_has_main = TRUE;
    drawn = TRUE;
    drawn_from_main = TRUE;
    draw_source = "reused last main backbuf";
    draw_hash = _darkroom_main_locked.hash;
  }
 
  if(drawn)
  {
    /* Persist the last composed frame so later exposes can reuse it if the
     * next requested source is temporarily unavailable. */
    expose_state.image_surface_has_main = drawn_from_main;
    expose_state.image_surface_hash = draw_hash;
    _paint_all(cri, cr, dev->image_surface);
    dt_print(DT_DEBUG_DEV, "[darkroom] expose drew %s (backbuf hash=%" PRIu64 ")\n",
             draw_source, draw_hash);
    cairo_restore(cri);
  }
  else if(dev->image_surface && expose_state.image_surface_imgid == dev->image_storage.id)
  {
    /* No fresh source this time: repaint the last composed image surface
     * rather than clearing to background and waiting for another expose. */
    draw_source = expose_state.image_surface_has_main ? "reused last main surface"
                                                      : "reused last preview surface";
    draw_hash = expose_state.image_surface_hash;
    _paint_all(cri, cr, dev->image_surface);
    dt_print(DT_DEBUG_DEV, "[darkroom] expose drew %s (backbuf hash=%" PRIu64 ")\n",
             draw_source, draw_hash);
    cairo_restore(cri);
  }
  else
  {
    /* Cold-start / no valid frame cached anywhere yet. */
    cairo_set_source_rgb(cr, bg_color[0], bg_color[1], bg_color[2]);
    cairo_paint(cr);
    _paint_all(cri, cr, dev->image_surface);
    dt_print(DT_DEBUG_DEV, "[darkroom] expose drew %s (backbuf hash=%" PRIu64 ")\n",
             draw_source, draw_hash);
    cairo_restore(cri);
  }
 
  /* check if we should create a snapshot of view */
  if(darktable.develop->proxy.snapshot.request)
  {
    /* reset the request */
    darktable.develop->proxy.snapshot.request = FALSE;
 
    /* validation of snapshot filename */
    g_assert(!IS_NULL_PTR(darktable.develop->proxy.snapshot.filename));
 
    /* Store current image surface to snapshot file.
       FIXME: add checks so that we don't make snapshots of preview pipe image surface.
    */
    const int fd = g_open(darktable.develop->proxy.snapshot.filename, O_CREAT | O_WRONLY | O_BINARY, 0600);
    cairo_surface_write_to_png_stream(dev->image_surface, _write_snapshot_data, GINT_TO_POINTER(fd));
    close(fd);
  }
 
  // Displaying sample areas if enabled
  if(darktable.develop->color_picker.samples
     && (darktable.develop->color_picker.display_samples
         || (darktable.develop->color_picker.selected_sample &&
             darktable.develop->color_picker.selected_sample != darktable.develop->color_picker.primary_sample)))
  {
    _darkroom_pickers_draw(self, cri, width, height, pointerx, pointery, darktable.develop->color_picker.samples, FALSE);
  }
 
  // draw guide lines if needed
  if(!dev->gui_module || !(dev->gui_module->flags() & IOP_FLAGS_GUIDES_SPECIAL_DRAW))
  {
    const float wd = dev->roi.preview_width;
    const float ht = dev->roi.preview_height;
    const float scaling = dt_dev_get_overlay_scale(dev);
 
    cairo_save(cri);
    // don't draw guides on image margins
    dt_dev_clip_roi(dev, cri, width, height);
    // place origin at top-left corner of image
    dt_dev_rescale_roi(dev, cri, width, height);
 
    // draw guides with backbuffer dimensions, positioning and scaling handled by transformations
    dt_guides_draw(cri, 0, 0, wd, ht, scaling);
    cairo_restore(cri);
  }
 
  const gboolean picker_active = dt_iop_color_picker_is_visible(dev);
 
  // draw colorpicker for in focus module or execute module callback hook
  // FIXME: draw picker in gui_post_expose() hook in libs/colorpicker.c -- catch would be that live samples would appear over guides, softproof/gamut text overlay would be hidden by picker
  if(picker_active)
  {
    GSList samples = { .data = darktable.develop->color_picker.primary_sample, .next = NULL };
    _darkroom_pickers_draw(self, cri, width, height, pointerx, pointery, &samples, TRUE);
  }
  else
  {
    // display mask if we have a current module activated or if the masks manager module is expanded
    const gboolean display_masks = (dev->gui_module && dev->gui_module->enabled)
                                 || dt_lib_gui_get_expanded(dt_lib_get_module("masks"));
 
    if(dt_masks_get_visible_form(dev) && display_masks)
      dt_masks_events_post_expose(dev->gui_module, cri, width, height, pointerx, pointery);
      
    // module
    if(dev->gui_module && dev->gui_module->enabled && dev->gui_module->gui_post_expose)
      dev->gui_module->gui_post_expose(dev->gui_module, cri, width, height, pointerx, pointery);
  }
 
  // indicate if we are in gamut check or softproof mode
  dt_dev_draw_profile_mode_label(cri, height);
 
  dt_show_times_f(&start, "[darkroom]", "redraw");
}
 
void reset(dt_view_t *self)
{
  dt_dev_reset_roi((dt_develop_t *)self->data);
}
 
static void _darkroom_log_image_load_error(const int ret)
{
  switch(ret)
  {
    case DT_DEV_IMAGE_STORAGE_MIPMAP_NOT_FOUND:
      dt_control_log(_("Could not load the image source data."));
      break;
    case DT_DEV_IMAGE_STORAGE_DB_NOT_READ:
      dt_control_log(_("Could not read image information from the database."));
      break;
    default:
      dt_control_log(_("We could not load the image."));
      break;
  }
}
 
static void _darkroom_image_loaded_callback(gpointer instance, guint request_id, guint result, gpointer user_data)
{
  dt_view_t *self = (dt_view_t *)user_data;
  dt_develop_t *dev = (dt_develop_t *)self->data;
  if(request_id == 0) return;
  if(darktable.view_manager->current_view != self) return;
 
 
  if(result)
  {
    _darkroom_log_image_load_error((int)result);
    return;
  }
 
  darktable.develop->proxy.wb_coeffs[0] = 0.f;
 
  // synch gui and flag pipe as dirty
  // this is done here and not in dt_read_history, as it would else be triggered before module->gui_init.
  // locks history mutex internally
  dt_dev_pop_history_items(dev);
  dt_dev_history_gui_update(dev);
 
  dt_dev_pixelpipe_rebuild_all(dev);
  dt_dev_get_thumbnail_size(dev);
 
  if(_darkroom_pending_focus_module && g_list_find(dev->iop, _darkroom_pending_focus_module))
    dt_iop_request_focus(_darkroom_pending_focus_module);
  _darkroom_pending_focus_module = NULL;
 
  // Clean & Init the starting point of undo/redo
  dt_undo_clear(darktable.undo, DT_UNDO_DEVELOP);
  dt_dev_undo_start_record(dev);
  dt_dev_undo_end_record(dev);
 
  /* signal that darktable.develop is initialized and ready to be used */
  DT_DEBUG_CONTROL_SIGNAL_RAISE(darktable.signals, DT_SIGNAL_DEVELOP_INITIALIZE);
 
  dt_image_check_camera_missing_sample(&dev->image_storage);
 
  // clear selection, we don't want selections in darkroom
  dt_selection_clear(darktable.selection);
 
  // change active image for global actions (menu)
  dt_view_active_images_reset(FALSE);
  dt_view_active_images_add(dev->image_storage.id, TRUE);
 
  dt_control_queue_redraw_center();
 
  DT_DEBUG_CONTROL_SIGNAL_RAISE(darktable.signals, DT_SIGNAL_DEVELOP_IMAGE_CHANGED);
 
  dt_view_image_info_update(dev->image_storage.id);
 
  dt_dev_start_all_pipelines(dev);
}
 
int try_enter(dt_view_t *self)
{
  uint32_t num_selected = dt_selection_get_length(darktable.selection);
  int32_t imgid = dt_control_get_mouse_over_id();
  (void)self;
 
  _darkroom_pending_imgid = UNKNOWN_IMAGE;
 
  if(imgid != UNKNOWN_IMAGE)
  {
    ; // Needed to open image from filmstrip
  }
  else if(num_selected > 1)
  {
    dt_control_log(_("The current selection contains more than one image, which is ambiguous.\n"
                     "Select exactly one image to enter the darkroom."));
    return 1;
  }
  else if(num_selected == 0 && imgid == UNKNOWN_IMAGE)
  {
    dt_control_log(_("There is no image selected.\n"
                    "Select exactly one image to enter the darkroom."));
    return 1;
  }
  else
  {
    // Needed to open image at startup
    imgid = dt_selection_get_first_id(darktable.selection);
  }
 
  dt_view_active_images_reset(FALSE);
 
  if(imgid < 0)
  {
    // fail :(
    dt_control_log(_("No image to open !"));
    return 1;
  }
 
  _darkroom_pending_imgid = imgid;
  return 0;
}
 
static void _dev_change_image(dt_view_t *self, int32_t imgid)
{
  // Lazy trick to cleanup, reset, reinit, reload everything without
  // having to duplicate most of (but not all) the code in leave(),
  // try_enter() and enter() : simulate a roundtrip through lighttable.
  // This way, all images are loaded through the same path, handled at an higher level.
  // It's more robust, although slightly slower than re-initing only what is needed.
  dt_view_manager_switch(darktable.view_manager, "lighttable");
  dt_control_set_mouse_over_id(imgid);
  dt_view_manager_switch(darktable.view_manager, "darkroom");
}
 
static void _view_darkroom_filmstrip_activate_callback(gpointer instance, int32_t imgid, gpointer user_data)
{
  if(imgid > UNKNOWN_IMAGE)
  {
    // switch images in darkroom mode:
    _dev_change_image(user_data, imgid);
  }
}
 
static void _guides_popover_preshow(gpointer user_data)
{
  dt_guides_update_popover_values();
}
 
static void _autoset_popover_preshow(gpointer user_data)
{
  _darkroom_autoset_popover_rebuild(darktable.develop);
}
 
/* overlay color */
static void _guides_quickbutton_clicked(GtkWidget *widget, gpointer user_data)
{
  dt_guides_button_toggled(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
  dt_control_queue_redraw_center();
}
 
static void _guides_view_changed(gpointer instance, dt_view_t *old_view, dt_view_t *new_view, dt_lib_module_t *self)
{
  dt_guides_update_button_state();
}
 
/* display: darkroom-only extras appended to the popover dt_dev_toolbox_create() builds */
 
static void display_mask_checker_1_callback(GtkColorButton *widget, gpointer user_data)
{
  dt_develop_t *d = (dt_develop_t *)user_data;
  GdkRGBA color;
  gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), &color);
  dt_conf_set_float("plugins/darkroom/colorbalancergb/checker1/red", color.red);
  dt_conf_set_float("plugins/darkroom/colorbalancergb/checker1/green", color.green);
  dt_conf_set_float("plugins/darkroom/colorbalancergb/checker1/blue", color.blue);
  dt_atomic_add_int(&d->mask_preview_settings_revision, 1);
  dt_dev_pixelpipe_resync_history_main(d);
}
 
static void display_mask_checker_2_callback(GtkColorButton *widget, gpointer user_data)
{
  dt_develop_t *d = (dt_develop_t *)user_data;
  GdkRGBA color;
  gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), &color);
  dt_conf_set_float("plugins/darkroom/colorbalancergb/checker2/red", color.red);
  dt_conf_set_float("plugins/darkroom/colorbalancergb/checker2/green", color.green);
  dt_conf_set_float("plugins/darkroom/colorbalancergb/checker2/blue", color.blue);
  dt_atomic_add_int(&d->mask_preview_settings_revision, 1);
  dt_dev_pixelpipe_resync_history_main(d);
}
 
static void display_mask_checker_size_callback(GtkWidget *slider, gpointer user_data)
{
  dt_develop_t *d = (dt_develop_t *)user_data;
  dt_conf_set_int("plugins/darkroom/colorbalancergb/checker/size", (int)dt_bauhaus_slider_get(slider));
  dt_atomic_add_int(&d->mask_preview_settings_revision, 1);
  dt_dev_pixelpipe_resync_history_main(d);
}
 
static void display_mask_black_and_white_callback(GtkToggleButton *toggle, gpointer user_data)
{
  dt_develop_t *d = (dt_develop_t *)user_data;
  dt_conf_set_bool("plugins/darkroom/colorbalancergb/mask_preview/greyscaled",
                   gtk_toggle_button_get_active(toggle));
  dt_atomic_add_int(&d->mask_preview_settings_revision, 1);
  dt_dev_pixelpipe_resync_history_main(d);
}
 
static void _darkroom_change_rendering_size(GtkWidget *combobox, gpointer user_data)
{
  dt_develop_t *d = (dt_develop_t *)user_data;
  dt_conf_set_int("darkroom/render_size", dt_bauhaus_combobox_get(combobox));
  dt_dev_pixelpipe_resync_history_main(d);
}
 
#if 0
 
static void _overlay_cycle_callback(dt_action_t *action)
{
  const int currentval = dt_conf_get_int("darkroom/ui/overlay_color");
  const int nextval = (currentval + 1) % 6; // colors can go from 0 to 5
  dt_conf_set_int("darkroom/ui/overlay_color", nextval);
  dt_guides_set_overlay_colors();
  dt_control_queue_redraw_center();
}
 
static void _toggle_mask_visibility_callback(dt_action_t *action)
{
  if(dt_gui_widgets_suppressed()) return;
 
  dt_develop_t *dev = dt_action_view(action)->data;
  dt_iop_module_t *mod = dev->gui_module;
 
  //retouch and spot removal module use masks differently and have different buttons associated
  //keep the shortcuts independent
  if(mod && strcmp(mod->so->op, "spots") != 0 && strcmp(mod->so->op, "retouch") != 0)
  {
    dt_iop_gui_blend_data_t *bd = (dt_iop_gui_blend_data_t *)mod->blend_data;
 
    dt_gui_freeze_begin();
 
    dt_iop_color_picker_reset(mod, TRUE);
 
    dt_masks_form_t *grp = dt_masks_get_from_id(darktable.develop, mod->blend_params->mask_id);
    if(grp && (grp->type & DT_MASKS_GROUP) && grp->points)
    {
      if(bd->masks_shown == DT_MASKS_EDIT_OFF)
        bd->masks_shown = DT_MASKS_EDIT_FULL;
      else
        bd->masks_shown = DT_MASKS_EDIT_OFF;
 
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bd->masks_edit), bd->masks_shown != DT_MASKS_EDIT_OFF);
      dt_masks_set_edit_mode(mod, bd->masks_shown);
 
      // set all add shape buttons to inactive
      for(int n = 0; n < DEVELOP_MASKS_NB_SHAPES; n++)
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bd->masks_shapes[n]), FALSE);
    }
 
    dt_gui_freeze_end();
  }
}
 
 
#endif
 
gboolean _focus_main_image(GtkAccelGroup *accel_group, GObject *accelerable, guint keyval,
                           GdkModifierType modifier, gpointer data)
{
  gtk_widget_grab_focus(dt_ui_center(darktable.gui->ui));
  return TRUE;
}
 
gboolean _switch_to_next_picture(GtkAccelGroup *accel_group, GObject *accelerable, guint keyval,
                                 GdkModifierType modifier, gpointer data)
{
  dt_view_t *view = (dt_view_t *)data;
  dt_develop_t *dev = (dt_develop_t *)view->data;
  int32_t current_img = dev->image_storage.id;
  GList *current_collection = dt_collection_get_all(darktable.collection, -1);
  GList *current_item = g_list_find(current_collection, GINT_TO_POINTER(current_img));
 
  if(current_item && current_item->next)
  {
    int32_t next_img = GPOINTER_TO_INT(current_item->next->data);
    g_list_free(current_collection);
    current_collection = NULL;
    _dev_change_image(data, next_img);
  }
  else
  {
    g_list_free(current_collection);
    current_collection = NULL;
  }
 
  return TRUE;
}
 
gboolean _switch_to_prev_picture(GtkAccelGroup *accel_group, GObject *accelerable, guint keyval,
                                 GdkModifierType modifier, gpointer data)
{
  dt_view_t *view = (dt_view_t *)data;
  dt_develop_t *dev = (dt_develop_t *)view->data;
  int32_t current_img = dev->image_storage.id;
  GList *current_collection = dt_collection_get_all(darktable.collection, -1);
  GList *current_item = g_list_find(current_collection, GINT_TO_POINTER(current_img));
 
  if(current_item && current_item->prev)
  {
    int32_t prev_img = GPOINTER_TO_INT(current_item->prev->data);
    g_list_free(current_collection);
    current_collection = NULL;
    _dev_change_image(data, prev_img);
  }
  else
  {
    g_list_free(current_collection);
    current_collection = NULL;
  }
 
  return TRUE;
}
 
static void _preview_pipe_finished(gpointer instance, gpointer user_data)
{
  // Get the mip size that is at most as big as our pipeline backbuf
  dt_dev_pixelpipe_t *pipe = darktable.develop->preview_pipe;
  const gboolean autoset_running_before
      = !IS_NULL_PTR(_autoset_manager) && _autoset_manager->progress_cursor_active;
  const int32_t imgid = darktable.develop->image_storage.id;
  dt_mipmap_size_t mip = dt_mipmap_cache_get_fitting_size(darktable.mipmap_cache, pipe->backbuf.width, pipe->backbuf.height, imgid);
 
  // Check if the cache is ready for that mipmap size.
  dt_mipmap_buffer_t tmp;
  dt_mipmap_cache_get(darktable.mipmap_cache, &tmp, imgid, mip, DT_MIPMAP_TESTLOCK, 'r');
  gboolean cache_ready = !IS_NULL_PTR(tmp.buf);
  dt_mipmap_cache_release(darktable.mipmap_cache, &tmp);
 
  if(pipe->autoset)
  {
    dt_iop_autoset_advance(darktable.develop, _autoset_manager);
    _darkroom_autoset_button_set_running(_autoset_manager && _autoset_manager->progress_cursor_active);
  }
 
  const gboolean autoset_running_after
      = !IS_NULL_PTR(_autoset_manager) && _autoset_manager->progress_cursor_active;
 
  // While autoset iterates over modules, avoid spawning thumbnail refresh jobs on each preview completion.
  // We refresh once the autoset run is finished and the preview cache reached a stable state.
  if(cache_ready && !autoset_running_after)
  {
    const gboolean autoset_just_finished = autoset_running_before && !autoset_running_after;
    if(!autoset_running_before || autoset_just_finished)
    {
      dt_thumbtable_refresh_thumbnail(darktable.gui->ui->thumbtable_lighttable, imgid, TRUE);
      dt_thumbtable_refresh_thumbnail(darktable.gui->ui->thumbtable_filmstrip, imgid, TRUE);
    }
  }
}
 
/*
static gboolean _darkroom_toolbox_button_activate_accel(GtkAccelGroup *accel_group, GObject *accelerable,
                                                        guint keyval, GdkModifierType modifier,
                                                        gpointer data)
{
  GtkWidget *button = GTK_WIDGET(data);
  if(IS_NULL_PTR(button) || !gtk_widget_is_visible(button) || !gtk_widget_is_sensitive(button)) return FALSE;
 
  gtk_button_clicked(GTK_BUTTON(button));
  return TRUE;
}
*/
 
static void _darkroom_autoset_quickbutton_clicked(GtkButton *button, gpointer user_data)
{
  dt_iop_autoset_build_list(darktable.develop, _autoset_manager);
  _darkroom_autoset_button_set_running(_autoset_manager && _autoset_manager->progress_cursor_active);
  fprintf(stdout, "lauching autoset\n");
}
 
static gchar *_darkroom_autoset_label(const dt_iop_module_t *module)
{
  gchar *clean_name = dt_history_item_get_name(module);
  gchar *label = g_strdup_printf("%s (%i)", clean_name, module->multi_priority);
  dt_free(clean_name);
  return label;
}
 
static void _darkroom_autoset_module_toggled(GtkToggleButton *toggle, gpointer user_data)
{
  dt_iop_module_t *module = (dt_iop_module_t *)user_data;
  dt_iop_autoset_module_set_enabled(module, gtk_toggle_button_get_active(toggle));
}
 
static void _darkroom_autoset_popover_rebuild(dt_develop_t *dev)
{
  if(IS_NULL_PTR(_darkroom_autoset_list) || IS_NULL_PTR(dev)) return;
 
  GList *children = gtk_container_get_children(GTK_CONTAINER(_darkroom_autoset_list));
  for(GList *child = children; child; child = g_list_next(child))
    gtk_widget_destroy(GTK_WIDGET(child->data));
  g_list_free(children);
 
  GtkWidget *title = gtk_label_new(_("Module instances to autoset"));
  gtk_box_pack_start(GTK_BOX(_darkroom_autoset_list), title, FALSE, FALSE, 0);
  dt_gui_add_class(title, "dt_section_label");
 
  for(GList *modules = g_list_last(dev->iop); modules; modules = g_list_previous(modules))
  {
    dt_iop_module_t *module = (dt_iop_module_t *)modules->data;
    if(IS_NULL_PTR(module->autoset)) continue;
 
    gchar *label = _darkroom_autoset_label(module);
    GtkWidget *toggle = gtk_check_button_new_with_label(label);
    g_free(label);
 
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), dt_iop_autoset_module_is_enabled(module));
    gtk_box_pack_start(GTK_BOX(_darkroom_autoset_list), toggle, FALSE, FALSE, 0);
    g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(_darkroom_autoset_module_toggled), module);
  }
 
  gtk_widget_show_all(_darkroom_autoset_list);
}
 
static void _darkroom_autoset_popover_refresh(gpointer instance, gpointer user_data)
{
  _darkroom_autoset_popover_rebuild((dt_develop_t *)user_data);
}
 
void gui_init(dt_view_t *self)
{
  dt_develop_t *dev = (dt_develop_t *)self->data;
 
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(darktable.signals, DT_SIGNAL_DEVELOP_PREVIEW_PIPE_FINISHED,
                                  G_CALLBACK(_preview_pipe_finished), self);
 
  dt_accels_new_darkroom_action(_switch_to_next_picture, self, N_("Darkroom/Actions"),
                                N_("Switch to the next picture"), GDK_KEY_Right, GDK_MOD1_MASK, _("Triggers the action"));
  dt_accels_new_darkroom_action(_switch_to_prev_picture, self, N_("Darkroom/Actions"),
                                N_("Switch to the previous picture"), GDK_KEY_Left, GDK_MOD1_MASK, _("Triggers the action"));
 
  gchar *path = dt_accels_build_path(_("Darkroom/Actions"), _("Give focus to the main image"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Return, 0);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move up"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Up, 0);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move up (coarse step)"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Up, GDK_SHIFT_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move up (fine step)"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Up, GDK_CONTROL_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move down"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Down, 0);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move down (coarse step)"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Down, GDK_SHIFT_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move down (fine step)"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Down, GDK_CONTROL_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move left"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Left, 0);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move left (coarse step)"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Left, GDK_SHIFT_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move left (fine step)"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Left, GDK_CONTROL_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move right"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Right, 0);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move right (coarse step)"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Right, GDK_SHIFT_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move right (fine step)"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_Right, GDK_CONTROL_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Zoom in"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_plus, GDK_CONTROL_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Zoom out"));
  dt_accels_new_virtual_shortcut(darktable.gui->accels, darktable.gui->accels->darkroom_accels,
                                 path, dt_ui_center(darktable.gui->ui), GDK_KEY_minus, GDK_CONTROL_MASK);
  dt_free(path);
  /*
   * Add view specific tool buttons
   */
 
  static const dt_dev_toolbox_button_t darkroom_toolbox_buttons[]
      = { DT_DEV_TOOLBOX_ISO_12646,     DT_DEV_TOOLBOX_DISPLAY, DT_DEV_TOOLBOX_RAWOVEREXPOSED,
          DT_DEV_TOOLBOX_OVEREXPOSED, DT_DEV_TOOLBOX_SOFTPROOF, DT_DEV_TOOLBOX_GAMUT };
  dt_dev_toolbox_create(dev, DT_VIEW_DARKROOM, darkroom_toolbox_buttons,
                        G_N_ELEMENTS(darkroom_toolbox_buttons));
  dt_dev_toolbox_add_accels(dev, darktable.gui->accels->darkroom_accels, N_("Darkroom/Toolbox"),
                            darkroom_toolbox_buttons, G_N_ELEMENTS(darkroom_toolbox_buttons));
 
  /* display background options: dt_dev_toolbox_create() already built the
   * button and a popover with the generic controls (brightness, margins);
   * append darkroom-only extras (rendering size, mask preview) to that same
   * popover's content box. */
  {
    GtkWidget *vbox = gtk_bin_get_child(GTK_BIN(dev->display.floating_window));
 
    GtkWidget *rendering;
    DT_BAUHAUS_COMBOBOX_NEW_FULL(darktable.bauhaus, rendering, NULL, 
                                N_("Rendering size"), 
                                _("Choose at what size the main preview is rendered.\n"
                                  "Full resolution renders the pipeline at the raw original resolution.\n"
                                  "It is pixel-perfect, especially regarding denoising and deblurring, but very slow.\n"
                                  "Scaled renders at screen resolution and is the best trade-off.\n"
                                  "Pixel-level accuracy is guaranteed only when zoomed-in at 100%."),
                                dt_conf_get_int("darkroom/render_size"),
                                _darkroom_change_rendering_size, dev,
                                N_("full resolution (slow)"),
                                N_("scaled (default)")
                              );
    gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(rendering), TRUE, TRUE, 0);
 
    gtk_box_pack_start(GTK_BOX(vbox), dt_ui_section_label_new(_("Mask preview settings")), FALSE, FALSE, 0);
 
    GtkWidget *checker_1_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
    gtk_box_pack_start(GTK_BOX(checker_1_row), dt_ui_label_new(_("Checkerboard color 1")), TRUE, TRUE, 0);
    GtkWidget *checker_1 = gtk_color_button_new();
    GdkRGBA checker_color = {
      .red = dt_conf_get_float("plugins/darkroom/colorbalancergb/checker1/red"),
      .green = dt_conf_get_float("plugins/darkroom/colorbalancergb/checker1/green"),
      .blue = dt_conf_get_float("plugins/darkroom/colorbalancergb/checker1/blue"),
      .alpha = 1.0
    };
    gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(checker_1), &checker_color);
    gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(checker_1), FALSE);
    gtk_color_button_set_title(GTK_COLOR_BUTTON(checker_1),
                               _("Select color of the checkerboard from a swatch"));
    g_signal_connect(G_OBJECT(checker_1), "color-set", G_CALLBACK(display_mask_checker_1_callback), dev);
    gtk_box_pack_start(GTK_BOX(checker_1_row), checker_1, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(vbox), checker_1_row, FALSE, FALSE, 0);
 
    GtkWidget *checker_2_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
    gtk_box_pack_start(GTK_BOX(checker_2_row), dt_ui_label_new(_("Checkerboard color 2")), TRUE, TRUE, 0);
    GtkWidget *checker_2 = gtk_color_button_new();
    checker_color.red = dt_conf_get_float("plugins/darkroom/colorbalancergb/checker2/red");
    checker_color.green = dt_conf_get_float("plugins/darkroom/colorbalancergb/checker2/green");
    checker_color.blue = dt_conf_get_float("plugins/darkroom/colorbalancergb/checker2/blue");
    gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(checker_2), &checker_color);
    gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(checker_2), FALSE);
    gtk_color_button_set_title(GTK_COLOR_BUTTON(checker_2),
                               _("Select color of the checkerboard from a swatch"));
    g_signal_connect(G_OBJECT(checker_2), "color-set", G_CALLBACK(display_mask_checker_2_callback), dev);
    gtk_box_pack_start(GTK_BOX(checker_2_row), checker_2, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(vbox), checker_2_row, FALSE, FALSE, 0);
 
    GtkWidget *checker_size
        = dt_bauhaus_slider_new_with_range(darktable.bauhaus, DT_GUI_MODULE(NULL), 2., 32., 1., 8., 0);
    dt_bauhaus_slider_set(checker_size,
                          dt_conf_get_int("plugins/darkroom/colorbalancergb/checker/size"));
    dt_bauhaus_slider_set_format(checker_size, " px");
    dt_bauhaus_widget_set_label(checker_size, _("Checkerboard size"));
    g_signal_connect(G_OBJECT(checker_size), "value-changed",
                     G_CALLBACK(display_mask_checker_size_callback), dev);
    gtk_box_pack_start(GTK_BOX(vbox), checker_size, TRUE, TRUE, 0);
 
    GtkWidget *black_and_white = gtk_check_button_new_with_label(_("Show a greyscaled mask image"));
    gtk_toggle_button_set_active(
        GTK_TOGGLE_BUTTON(black_and_white),
        dt_conf_get_bool("plugins/darkroom/colorbalancergb/mask_preview/greyscaled"));
    g_signal_connect(G_OBJECT(black_and_white), "toggled",
                     G_CALLBACK(display_mask_black_and_white_callback), dev);
    gtk_box_pack_start(GTK_BOX(vbox), black_and_white, FALSE, FALSE, 0);
 
    gtk_widget_show_all(vbox);
  }
 
  _darkroom_ioporder_button = dtgtk_button_new(dtgtk_cairo_paint_flowchart, 0, NULL);
  gtk_widget_set_tooltip_text(_darkroom_ioporder_button, _("show the pipeline node graph"));
  g_signal_connect(G_OBJECT(_darkroom_ioporder_button), "clicked",
                   G_CALLBACK(_darkroom_ioporder_quickbutton_clicked), dev);
  dt_view_manager_module_toolbox_add(darktable.view_manager, _darkroom_ioporder_button, DT_VIEW_DARKROOM);
  dt_accels_new_darkroom_action(dt_dev_toolbox_activate_accel, _darkroom_ioporder_button,
                                N_("Darkroom/Toolbox"),
                                N_("Show the pipeline node graph"), 0, 0,
                                _("Triggers the action"));
 
  /* create grid changer popup tool */
  {
    // the button
    darktable.view_manager->guides_toggle = dtgtk_togglebutton_new(dtgtk_cairo_paint_grid, 0, NULL);
    gtk_widget_set_tooltip_text(darktable.view_manager->guides_toggle,
                                _("toggle guide lines\nright click for guides options"));
    darktable.view_manager->guides_popover = dt_guides_popover(self, darktable.view_manager->guides_toggle);
    g_object_ref(darktable.view_manager->guides_popover);
    g_signal_connect(G_OBJECT(darktable.view_manager->guides_toggle), "clicked",
                     G_CALLBACK(_guides_quickbutton_clicked), dev);
    dt_dev_toolbox_connect_popover(darktable.view_manager->guides_toggle, darktable.view_manager->guides_popover);
    dt_dev_toolbox_popover_set_preshow(darktable.view_manager->guides_popover, _guides_popover_preshow, NULL);
    g_object_set_data(G_OBJECT(darktable.view_manager->guides_toggle), DT_DEV_TOOLBOX_POPOVER_KEY,
                      darktable.view_manager->guides_popover);
    dt_view_manager_module_toolbox_add(darktable.view_manager, darktable.view_manager->guides_toggle,
                                       DT_VIEW_DARKROOM | DT_VIEW_STUDIO_CAPTURE);
    dt_accels_new_darkroom_action(dt_dev_toolbox_activate_accel,
                                  darktable.view_manager->guides_toggle, N_("Darkroom/Toolbox"),
                                  N_("Toggle guide lines"), 0, 0,
                                  _("Triggers the action"));
    dt_accels_new_darkroom_action(dt_dev_toolbox_focus_accel,
                                  darktable.view_manager->guides_toggle, N_("Darkroom/Toolbox"),
                                  N_("Focus guide lines options"), 0, 0,
                                  _("Shows the options popover"));
    // we want to update button state each time the view change
    DT_DEBUG_CONTROL_SIGNAL_CONNECT(darktable.signals, DT_SIGNAL_VIEWMANAGER_VIEW_CHANGED,
                                    G_CALLBACK(_guides_view_changed), dev);
  }
 
  // Auto-set feature
  {
    _autoset_manager = dt_calloc_align(sizeof(dt_autoset_manager_t));
 
    _darkroom_autoset_button = dtgtk_togglebutton_new(dtgtk_cairo_paint_wand, 0, NULL);
    gtk_widget_set_tooltip_text(_darkroom_autoset_button, _("Run autoset on selected modules\nRight click for options"));
    g_signal_connect(G_OBJECT(_darkroom_autoset_button), "clicked",
                    G_CALLBACK(_darkroom_autoset_quickbutton_clicked), dev);
    /* Ensure autoset button is placed first in the toolbox. */
    g_object_set_data(G_OBJECT(_darkroom_autoset_button), "dt-toolbox-priority", GINT_TO_POINTER(1));
    dt_view_manager_module_toolbox_add(darktable.view_manager, _darkroom_autoset_button, DT_VIEW_DARKROOM);
 
    _darkroom_autoset_popover = gtk_popover_new(_darkroom_autoset_button);
    dt_dev_toolbox_connect_popover(_darkroom_autoset_button, _darkroom_autoset_popover);
    dt_dev_toolbox_popover_set_preshow(_darkroom_autoset_popover, _autoset_popover_preshow, NULL);
    g_object_set_data(G_OBJECT(_darkroom_autoset_button), DT_DEV_TOOLBOX_POPOVER_KEY,
                      _darkroom_autoset_popover);
    /*
    dt_accels_new_darkroom_action(dt_dev_toolbox_activate_accel, _darkroom_autoset_button,
                                  N_("Darkroom/Toolbox"),
                                  N_("Show the pipeline node graph"), 0, 0,
                                  _("Triggers the action"));
    */
    _darkroom_autoset_list = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
    gtk_container_add(GTK_CONTAINER(_darkroom_autoset_popover), _darkroom_autoset_list);
    _darkroom_autoset_popover_rebuild(dev);
    _darkroom_autoset_button_set_running(FALSE);
 
    DT_DEBUG_CONTROL_SIGNAL_CONNECT(darktable.signals, DT_SIGNAL_DEVELOP_HISTORY_CHANGE,
                                    G_CALLBACK(_darkroom_autoset_popover_refresh), dev);
    DT_DEBUG_CONTROL_SIGNAL_CONNECT(darktable.signals, DT_SIGNAL_DEVELOP_IMAGE_CHANGED,
                                    G_CALLBACK(_darkroom_autoset_popover_refresh), dev);
    DT_DEBUG_CONTROL_SIGNAL_CONNECT(darktable.signals, DT_SIGNAL_DEVELOP_MODULE_REMOVE,
                                    G_CALLBACK(_darkroom_autoset_popover_refresh), dev);
  }
 
  darktable.view_manager->proxy.darkroom.get_layout = _lib_darkroom_get_layout;
  darktable.view_manager->proxy.darkroom.set_default_cursor = _darkroom_set_default_cursor;
  dev->roi.border_size = DT_PIXEL_APPLY_DPI(dt_conf_get_int("plugins/darkroom/ui/border_size"));
}
 
static gboolean _is_scroll_captured_by_widget()
{
  dt_accels_t *accels = darktable.gui->accels;
  if(!darktable.gui->has_scroll_focus || accels->active_key.accel_key == 0) return FALSE;
 
  // When declaring shortcuts, bauhaus widgets write their accel path into a private data field
  gchar *accel_path = g_object_get_data(G_OBJECT(darktable.gui->has_scroll_focus), "accel-path");
 
  // Find if the registered accel keys matches currently pressed keys
  GtkAccelKey key = { 0 };
  return gtk_accel_map_lookup_entry(accel_path, &key)
    && key.accel_key == accels->active_key.accel_key
    && key.accel_mods == accels->active_key.accel_mods;
}
 
 
// If a bauhaus widget has the scroll focus from a keyboard shortcut,
// and the combination of keys attached to its accel path
// is still pressed, then we redirect any scroll event in the window to this widget.
// Warning: if mouse is over the central widget, central widget takes precedence over scrolling.
gboolean _scroll_on_focus(GdkEventScroll event, void *data)
{
  if(_is_scroll_captured_by_widget())
  {
    // Pass-through the scrolling event to the scrolling handler of the widget
    gboolean ret;
    g_signal_emit_by_name(G_OBJECT(darktable.gui->has_scroll_focus), "scroll-event", &event, &ret);
    return ret;
  }
 
  return FALSE;
}
 
 
void enter(dt_view_t *self)
{
  // Flush all background jobs (thumbnails generation) to spare resources for interactivity
  dt_control_flush_jobs_queue(darktable.control, DT_JOB_QUEUE_SYSTEM_FG);
  
  dt_print(DT_DEBUG_CONTROL, "[run_job+] 11 %f in darkroom mode\n", dt_get_wtime());
  dt_develop_t *dev = (dt_develop_t *)self->data;
  dev->exit = 0;
  _darkroom_pending_focus_module = NULL;
 
  // We need to init forms before we init module blending GUI
  dt_masks_gui_init(dev);
  dev->gui_module = NULL;
 
  if(IS_NULL_PTR(dev->iop))
    dev->iop = dt_dev_load_modules(dev);
 
  // Add IOP modules to the plugin list
  char option[1024];
  const char *active_plugin = dt_conf_get_string_const("plugins/darkroom/active");
  for(const GList *modules = g_list_first(dev->iop); modules; modules = g_list_next(modules))
  {
    dt_iop_module_t *module = (dt_iop_module_t *)(modules->data);
 
    /* initialize gui if iop have one defined */
    if(!dt_iop_is_hidden(module))
    {
      dt_iop_gui_init(module);
      dt_iop_gui_set_expander(module);
 
      if(module->multi_priority == 0)
      {
        snprintf(option, sizeof(option), "plugins/darkroom/%s/expanded", module->op);
        module->expanded = dt_conf_get_bool(option);
        dt_iop_gui_update_expanded(module);
 
        if(active_plugin && !strcmp(module->op, active_plugin))
          _darkroom_pending_focus_module = module;
      }
    }
  }
 
  // just make sure at this stage we have only history info into the undo, all automatic
  // tagging should be ignored.
  dt_undo_clear(darktable.undo, DT_UNDO_TAGS);
 
  dt_iop_color_picker_init();
 
  // Reset focus to center view
  dt_gui_refocus_center();
 
  // Attach shortcuts to new widgets
  dt_accels_connect_accels(darktable.gui->accels);
  dt_accels_connect_active_group(darktable.gui->accels, "darkroom");
  dt_accels_attach_scroll_handler(darktable.gui->accels, _scroll_on_focus, dev);
 
  // Attach bauhaus default signal callback to IOP
  darktable.bauhaus->default_value_changed_callback = dt_bauhaus_value_changed_default_callback;
 
  // This gets the first selected ID to scroll where relevant, so
  // runs it before clearing the selection
  dt_thumbtable_show(darktable.gui->ui->thumbtable_filmstrip);
  gtk_widget_show(dt_ui_center(darktable.gui->ui));
  dt_thumbtable_update_parent(darktable.gui->ui->thumbtable_filmstrip);
 
  /* connect signal for filmstrip image activate */
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(darktable.signals, DT_SIGNAL_VIEWMANAGER_THUMBTABLE_ACTIVATE,
                                  G_CALLBACK(_view_darkroom_filmstrip_activate_callback), self);
 
  gtk_widget_grab_focus(dt_ui_center(darktable.gui->ui)); // ensure the center view has focus for keybindings to work
 
  const int32_t imgid = _darkroom_pending_imgid;
  _darkroom_pending_imgid = UNKNOWN_IMAGE;
  dt_control_set_mouse_over_id(imgid);
  dt_control_set_keyboard_over_id(imgid);
  g_idle_add((GSourceFunc)dt_thumbtable_scroll_to_selection, darktable.gui->ui->thumbtable_filmstrip);
  int ret = dt_dev_load_image(darktable.develop, imgid);
  _darkroom_image_loaded_callback(NULL, imgid, ret, self);
}
 
void leave(dt_view_t *self)
{
  dt_develop_t *dev = (dt_develop_t *)self->data;
  if(!IS_NULL_PTR(_autoset_manager) && !IS_NULL_PTR(_autoset_manager->input_wait))
    dt_dev_pixelpipe_cache_wait_cleanup((dt_dev_pixelpipe_cache_wait_t *)_autoset_manager->input_wait,
                                        "darkroom-leave-autoset");
  dt_control_mouse_is_dragging(FALSE);
  dt_control_mouse_is_painting(FALSE);
  _darkroom_center_pan_drag = FALSE;
  _reset_edge_pan();
  dt_gui_throttle_cancel(dev);
 
  _release_expose_source_caches();
  if(dev->image_surface) cairo_surface_destroy(dev->image_surface);
  dev->image_surface = NULL;
 
  // Send all pipeline shutdown signals first
  dev->exit = 1;
  dt_atomic_set_int(&dev->pipe->shutdown, TRUE);
  dt_atomic_set_int(&dev->preview_pipe->shutdown, TRUE);
  if(dev->virtual_pipe) dt_atomic_set_int(&dev->virtual_pipe->shutdown, TRUE);
  dev->pipelines_started = FALSE;
 
  /* dev->exit / the shutdown atomics above are only checked by the darkroom worker thread
   * (dt_dev_darkroom_pipeline(), running in the DT_CTL_WORKER_DARKROOM job) between loop
   * iterations and between servicing each pipe -- they do not preempt it mid-flight. Below,
   * this function tears down dev->pipe/preview_pipe nodes, dev->iop and dev->history straight
   * from the GUI thread. Proceeding before that worker thread has actually returned races it:
   * dt_dev_pixelpipe_set_input() and the history-hash resync in _resync_pipe_with_history() touch
   * pipe->nodes and pipe->dev->iop without holding busy_mutex, so the worker can still be
   * mid-access on structures we are about to free, corrupting unrelated heap state (observed as
   * a crash inside an IOP module's cleanup_pipe() far away from the actual race). Block here
   * until the worker has fully exited both pipes' service loop. */
  while((dt_atomic_get_int(&dev->pipe->running) || dt_atomic_get_int(&dev->preview_pipe->running))
        && dt_control_running())
    dt_iop_nap(10000); // 10 ms
 
  dt_dev_pixelpipe_cache_wait_dump_pending("darkroom-leave-before-cleanup");
 
  /* Stop module-owned background threads that may still be mutating the pipe, dev or history (e.g.
   * drawlayer's asynchronous paint/commit worker) BEFORE we tear down pipeline nodes and history
   * below. Otherwise an in-flight commit resync can run a pipeline synch against pieces this function
   * is about to free, faulting in whatever module commits next. */
  for(GList *m = dev->iop; m; m = g_list_next(m))
  {
    dt_iop_module_t *mod = (dt_iop_module_t *)m->data;
    if(mod && mod->quiesce) mod->quiesce(mod);
  }
 
  _darkroom_pending_focus_module = NULL;
 
  // While we wait for possible pipelines to finish,
  // do the GUI cleaning.
 
  // store last active plugin:
  if(darktable.develop->gui_module)
    dt_conf_set_string("plugins/darkroom/active", darktable.develop->gui_module->op);
  else
    dt_conf_set_string("plugins/darkroom/active", "");
 
  // Hide the popover floating windows
  gtk_widget_hide(dev->overexposed.floating_window);
  gtk_widget_hide(dev->rawoverexposed.floating_window);
  gtk_widget_hide(dev->profile.floating_window);
 
  // Detach the default callback for bauhaus widgets
  dt_accels_detach_scroll_handler(darktable.gui->accels);
 
  /* disconnect from filmstrip image activate */
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(darktable.signals, G_CALLBACK(_view_darkroom_filmstrip_activate_callback),
  (gpointer)self);
 
  dt_iop_color_picker_cleanup();
 
  if(darktable.develop->color_picker.picker)
    dt_iop_color_picker_reset(darktable.develop->color_picker.picker->module, FALSE);
 
  // Detach shortcuts
  dt_accels_disconnect_active_group(darktable.gui->accels);
 
  // Restore the previous selection
  dt_selection_select_single(darktable.selection, dt_view_active_images_get_first());
  dt_view_active_images_reset(FALSE);
 
  dt_thumbtable_hide(darktable.gui->ui->thumbtable_filmstrip);
  gtk_widget_hide(dt_ui_center(darktable.gui->ui));
 
  // Pipeline nodes reference modules from dev->iop
  // we need to destroy objects referencing modules
  // before destroying the actual modules being referenced.
  dt_pthread_mutex_lock(&dev->pipe->busy_mutex);
  dt_dev_pixelpipe_cleanup_nodes(dev->pipe);
  dt_dev_pixelpipe_cache_unref_hash(darktable.pixelpipe_cache, dt_dev_backbuf_get_hash(&dev->pipe->backbuf));
  dt_dev_set_backbuf(&dev->pipe->backbuf, 0, 0, 0, DT_PIXELPIPE_CACHE_HASH_INVALID, DT_PIXELPIPE_CACHE_HASH_INVALID);
  dt_pthread_mutex_unlock(&dev->pipe->busy_mutex);
 
  dt_pthread_mutex_lock(&dev->preview_pipe->busy_mutex);
  dt_dev_pixelpipe_cleanup_nodes(dev->preview_pipe);
  dt_dev_pixelpipe_cache_unref_hash(darktable.pixelpipe_cache, dt_dev_backbuf_get_hash(&dev->preview_pipe->backbuf));
  dt_dev_set_backbuf(&dev->preview_pipe->backbuf, 0, 0, 0, DT_PIXELPIPE_CACHE_HASH_INVALID,
                     DT_PIXELPIPE_CACHE_HASH_INVALID);
  dt_pthread_mutex_unlock(&dev->preview_pipe->busy_mutex);
 
  dt_pthread_mutex_lock(&dev->virtual_pipe->busy_mutex);
  dt_dev_pixelpipe_cleanup_nodes(dev->virtual_pipe);
  dt_dev_pixelpipe_cache_unref_hash(darktable.pixelpipe_cache, dt_dev_backbuf_get_hash(&dev->virtual_pipe->backbuf));
  dt_dev_set_backbuf(&dev->virtual_pipe->backbuf, 0, 0, 0, DT_PIXELPIPE_CACHE_HASH_INVALID,
                     DT_PIXELPIPE_CACHE_HASH_INVALID);
  dt_pthread_mutex_unlock(&dev->virtual_pipe->busy_mutex);
 
  /* Device-side cache payloads are only an acceleration layer. Once darkroom
   * leaves, drop the cl_mem objects these pipes produced -- but only on the
   * device(s) they themselves last ran on, so we never touch cache entries
   * another, still-running pipe (e.g. a background thumbnail export) holds on
   * its own OpenCL device. */
  dt_dev_pixelpipe_cache_flush_clmem_for_pipe(darktable.pixelpipe_cache, dev->pipe->last_devid);
  if(dev->preview_pipe->last_devid != dev->pipe->last_devid)
    dt_dev_pixelpipe_cache_flush_clmem_for_pipe(darktable.pixelpipe_cache, dev->preview_pipe->last_devid);
 
  dt_pthread_rwlock_wrlock(&dev->history_mutex);
  dt_dev_history_free_history(dev);
  dt_pthread_rwlock_unlock(&dev->history_mutex);
 
  // Not sure why using g_list_free_full() here shits the bed
  while(dev->iop)
  {
    dt_iop_module_t *module = (dt_iop_module_t *)(dev->iop->data);
    if(!dt_iop_is_hidden(module)) dt_iop_gui_cleanup_module(module);
    dt_iop_cleanup_module(module);
    dt_free(module);
    dev->iop = g_list_delete_link(dev->iop, dev->iop);
  }
  while(dev->alliop)
  {
    dt_iop_cleanup_module((dt_iop_module_t *)dev->alliop->data);
    dt_free(dev->alliop->data);
    dev->alliop = g_list_delete_link(dev->alliop, dev->alliop);
  }
  dev->iop = dev->alliop = NULL;
 
  // cleanup visible masks
  if(dev->form_gui)
  {
    dev->gui_module = NULL; // modules have already been g_free()
    dt_masks_gui_cleanup(dev);
  }
 
  // clear masks
  dt_pthread_rwlock_wrlock(&dev->masks_mutex);
  // dev->forms and dev->allforms are independent claims on possibly-shared objects:
  // release both, do not unconditionally free -- a form referenced by both only
  // reaches refcount 0 once (mirrors dt_dev_cleanup() in develop.c).
  g_list_free_full(dev->forms, (void (*)(void *))dt_masks_form_unref);
  dev->forms = NULL;
  g_list_free_full(dev->allforms, (void (*)(void *))dt_masks_form_unref);
  dev->allforms = NULL;
  dt_pthread_rwlock_unlock(&dev->masks_mutex);
 
  // Fetch the new thumbnail if needed. Ensure it runs after we save history.
  dt_thumbtable_refresh_thumbnail(darktable.gui->ui->thumbtable_lighttable, darktable.develop->image_storage.id, TRUE);
  darktable.develop->image_storage.id = -1;
 
  // Release the cache entries for histogram buffers
  dt_dev_pixelpipe_cache_unref_hash(darktable.pixelpipe_cache, dt_dev_backbuf_get_hash(&dev->raw_histogram));
  dt_dev_backbuf_set_hash(&dev->raw_histogram, -1);
 
  dt_dev_pixelpipe_cache_unref_hash(darktable.pixelpipe_cache, dt_dev_backbuf_get_hash(&dev->output_histogram));
  dt_dev_backbuf_set_hash(&dev->output_histogram, -1);
 
  dt_dev_pixelpipe_cache_unref_hash(darktable.pixelpipe_cache, dt_dev_backbuf_get_hash(&dev->display_histogram));
  dt_dev_backbuf_set_hash(&dev->display_histogram, -1);
 
  /* GUI backbuffers were already released when each pipeline was quiesced above. Keep the view-side teardown
   * free of extra unref paths so pipeline ownership stays centralized. */
 
 
  dt_print(DT_DEBUG_CONTROL, "[run_job-] 11 %f in darkroom mode\n", dt_get_wtime());
}
 
// Leave central view
void mouse_leave(dt_view_t *self)
{
  // if we are not hovering over a thumbnail in the filmstrip -> show metadata of opened image.
  dt_develop_t *dev = (dt_develop_t *)self->data;
  dt_control_t *ctl = darktable.control;
  dt_gui_gtk_t *gui = darktable.gui;
  dt_control_mouse_is_dragging(FALSE);
  dt_control_mouse_is_painting(FALSE);
 
  _darkroom_center_pan_drag = FALSE;
 
  if(gui->pan_edge.timeout_source
     && gui->pan_edge.block_normal_pan
     && !IS_NULL_PTR(ctl) && ctl->button_down && ctl->button_down_which == 1)
  {
    gui->pan_edge.velocity[0] = 0.0f;
    gui->pan_edge.velocity[1] = 0.0f;
    gui->pan_edge.last_time_us = 0;
    if(gui->pan_edge.timeout_source)
    {
      g_source_remove(gui->pan_edge.timeout_source);
      gui->pan_edge.timeout_source = 0;
    }
    gui->pan_edge.view = NULL;
    gui->pan_edge.block_normal_pan = FALSE;
  }
  else
    _reset_edge_pan();
 
  // masks
  gboolean handled = FALSE;
  if(dt_masks_get_visible_form(dev) && dt_masks_events_mouse_leave(dev->gui_module))
    handled = TRUE;
  // module
  else if(dev->gui_module && dev->gui_module->mouse_leave
          && dev->gui_module->mouse_leave(dev->gui_module))
    handled = TRUE;
 
  if(handled)
    dt_control_queue_redraw_center();
 
  // reset any changes the selected plugin might have made.
  dt_control_set_cursor_visible(TRUE);
  dt_control_change_cursor(GDK_LEFT_PTR);
}
 
static gboolean _is_in_frame(const int width, const int height, const int x, const int y)
{
  return !((x < -DT_PIXEL_APPLY_DPI(2)) ||
           (x > (width + DT_PIXEL_APPLY_DPI(4))) ||
           (y < -DT_PIXEL_APPLY_DPI(2)) ||
           (y > (height + DT_PIXEL_APPLY_DPI(4))));
}
 
/* This helper function tests for a position to be within the displayed area
   of an image. To avoid "border cases" we accept values to be slightly out of area too.
*/
static gboolean mouse_in_imagearea(dt_view_t *self, double x, double y)
{
  dt_develop_t *dev = (dt_develop_t *)self->data;
  float image_box[4] = { 0.0f };
  dt_dev_get_image_box_in_widget(dev, self->width, self->height, image_box);
 
  return _is_in_frame(image_box[2], image_box[3], round(x - image_box[0]), round(y - image_box[1]));
}
 
static gboolean mouse_in_actionarea(dt_view_t *self, double x, double y)
{
  return _is_in_frame(self->width, self->height, round(x), round(y));
}
 
static void _darkroom_set_default_cursor(dt_view_t *self, double x, double y)
{
  if(mouse_in_imagearea(self, x, y))
    dt_control_queue_cursor_by_name("dot");
  else if(mouse_in_actionarea(self, x, y))
    dt_control_queue_cursor_by_name("crosshair");
  else
    dt_control_queue_cursor_by_name("left_ptr");
}
 
void mouse_enter(dt_view_t *self)
{
  dt_develop_t *dev = (dt_develop_t *)self->data;
  dt_masks_events_mouse_enter(dev->gui_module);
}
 
static void _delayed_history_commit(gpointer data)
{
  dt_develop_t *dev = (dt_develop_t *)data;
 
  // Figure out if an history item needs to be added
  // aka drawn masks have changed somehow. This is more expensive
  // but more reliable than handling individually all editing operations
  // in all callbacks in all possible mask types.
  // (dt_dev_masks_update_hash takes its own, correctly-scoped masks_mutex lock.)
  dt_dev_masks_update_hash(dev);
 
  if(dev->forms_changed)
    dt_dev_add_history_item(dev, dev->gui_module, FALSE, TRUE);
}
 
typedef struct darkroom_edge_pan_test_t
{
  dt_develop_t *dev;
  gboolean drag;
  gboolean inside_image;
  gboolean in_margin;
  float margin;
  float velocity[2];
} darkroom_edge_pan_test_t;
 
static float _darkroom_edge_pan_velocity(const double position, const double size, const float margin)
{
  const double near_edge = position < margin ? margin - position
                         : position > size - margin ? position - (size - margin)
                         : 0.0;
  if(near_edge <= 0.0) return 0.0f;
 
  const float edge_distance = CLAMPF(near_edge / margin, 0.0f, 1.0f);
  const float velocity = 0.10f + 0.90f * edge_distance * edge_distance;
  return position < margin ? -velocity : velocity;
}
 
static gboolean _darkroom_edge_pan_enable_check(dt_develop_t *dev)
{
  dt_gui_gtk_t *gui = darktable.gui;
  if(IS_NULL_PTR(gui) || IS_NULL_PTR(dev)) return FALSE;
 
  dt_masks_form_gui_t *form_gui = dev->form_gui;
  const gboolean mouse_action = gui->mouse.is_dragging && !gui->mouse.is_painting;
  const gboolean creating_shape_mode = !IS_NULL_PTR(form_gui) && form_gui->creation && !gui->mouse.is_painting;
 
  return  creating_shape_mode || mouse_action;
}
 
static void _darkroom_edge_pan_update_state(dt_view_t *self,
                                            const double pointer_x,
                                            const double pointer_y,
                                            const int width,
                                            const int height,
                                            darkroom_edge_pan_test_t *edge)
{
  dt_gui_gtk_t *gui = darktable.gui;
  dt_control_t *ctl = darktable.control;
  if(IS_NULL_PTR(gui) || IS_NULL_PTR(ctl) || IS_NULL_PTR(self)) return;
 
  dt_develop_t *dev = (dt_develop_t *)self->data;
  if(IS_NULL_PTR(dev)) return;
 
  // recheck the global eligibility conditions
  gui->pan_edge.enabled = _darkroom_edge_pan_enable_check(dev);
 
  if(!gui->pan_edge.enabled
     || dt_view_manager_get_current_view(darktable.view_manager) != self
     || dev->roi.scaling <= 1.0f)
    return;
 
  float image_box[4] = { 0.0f };
  dt_dev_get_image_box_in_widget(dev, width, height, image_box);
  const double image_x = pointer_x - image_box[0];
  const double image_y = pointer_y - image_box[1];
 
  edge->dev = dev;
  edge->drag = TRUE;
  edge->inside_image = mouse_in_imagearea(self, pointer_x, pointer_y);
  const gboolean inside_action_area = mouse_in_actionarea(self, pointer_x, pointer_y)
                                      && image_box[2] > 0.0f && image_box[3] > 0.0f;
  edge->margin = inside_action_area
                 ? CLAMPF(MIN(image_box[2], image_box[3]) / 3, 1, DARKROOM_EDGE_PAN_MARGIN_PX)
                 : 0.0f;
  edge->in_margin = inside_action_area
                    && edge->margin > 0.0f
                    && (image_x < edge->margin
                        || image_x > (double)image_box[2] - edge->margin
                        || image_y < edge->margin
                        || image_y > (double)image_box[3] - edge->margin);
 
  if(!edge->in_margin) return;
 
  edge->velocity[0] = _darkroom_edge_pan_velocity(image_x, image_box[2], edge->margin);
  edge->velocity[1] = _darkroom_edge_pan_velocity(image_y, image_box[3], edge->margin);
}
 
static gboolean _darkroom_edge_pan_apply(dt_view_t *self,
                                         const double pointer_x,
                                         const double pointer_y,
                                         const int width,
                                         const int height)
{
  dt_gui_gtk_t *gui = darktable.gui;
  dt_control_t *ctl = darktable.control;
  darkroom_edge_pan_test_t edge = { 0 };
  _darkroom_edge_pan_update_state(self, pointer_x, pointer_y, width, height, &edge);
 
  if(IS_NULL_PTR(gui))
    return FALSE;
 
  // reset and exit conditions
  if(!gui->pan_edge.enabled || IS_NULL_PTR(self) || IS_NULL_PTR(ctl) || !edge.drag)
  {
    gui->pan_edge.timeout_source = 0;
    _reset_edge_pan();
    return FALSE;
  }
 
  if(!edge.in_margin)
  {
    // Leaving the edge band stops automatic ROI motion and immediately hands
    // control back to the regular drag path.
    gui->pan_edge.timeout_source = 0;
    gui->pan_edge.view = self;
    gui->pan_edge.velocity[0] = 0.0f;
    gui->pan_edge.velocity[1] = 0.0f;
    gui->pan_edge.last_time_us = 0;
    gui->pan_edge.block_normal_pan = FALSE;
    ctl->button_x = pointer_x;
    ctl->button_y = pointer_y;
    return FALSE;
  }
 
  if(gui->pan_edge.velocity[0] == 0.0f && gui->pan_edge.velocity[1] == 0.0f)
  {
    // A mouse event may have stopped edge-pan before this tick runs.
    // End the timeout without releasing the stored drag reference position.
    gui->pan_edge.timeout_source = 0;
    gui->pan_edge.last_time_us = 0;
    ctl->button_x = pointer_x;
    ctl->button_y = pointer_y;
    return FALSE;
  }
 
  const gint64 now_us = g_get_monotonic_time();
  const float elapsed_s = CLAMPF((now_us - gui->pan_edge.last_time_us) / 1000000.0f, 0.001f, 0.100f);
  gui->pan_edge.last_time_us = now_us;
 
  float delta[2] = { gui->pan_edge.velocity[0] * DARKROOM_EDGE_PAN_SPEED_PX_PER_S * elapsed_s,
                     gui->pan_edge.velocity[1] * DARKROOM_EDGE_PAN_SPEED_PX_PER_S * elapsed_s
                   };
  dt_develop_t *dev = edge.dev;
  dt_dev_coordinates_widget_delta_to_image_delta(dev, delta, 1);
 
  float roi[2] = { dev->roi.x + delta[0] / (float)dev->roi.processed_width,
                   dev->roi.y + delta[1] / (float)dev->roi.processed_height
                 };
  dt_dev_check_zoom_pos_bounds(dev, &roi[0], &roi[1], NULL, NULL);
 
  ctl->button_x = pointer_x;
  ctl->button_y = pointer_y;
 
  if(dev->roi.x != roi[0] || dev->roi.y != roi[1])
  {
    dev->roi.x = roi[0];
    dev->roi.y = roi[1];
    // Updating ctl->button_x/y changes the cursor position, which is the same as a mouse move event.
    mouse_moved(self, pointer_x, pointer_y, 1.0, 0);
    //dt_control_queue_redraw_center();
    dt_dev_pixelpipe_change_zoom_main(dev);
  }
 
  return TRUE;
}
 
static gboolean _darkroom_edge_pan_tick(gpointer user_data)
{
  dt_gui_gtk_t *gui = darktable.gui;
  if(IS_NULL_PTR(gui))
    return FALSE;
 
  
  // Read the live pointer position instead of ctl->button_x/y: the latter only
  // stores the last mouse event, while the timeout must stop even if no event follows.
  dt_view_t *self = gui->pan_edge.view;
  GtkWidget *center = dt_ui_center(darktable.gui->ui);
  GdkWindow *window = IS_NULL_PTR(center) ? NULL : gtk_widget_get_window(center);
  GdkDisplay *display = IS_NULL_PTR(window) ? NULL : gdk_window_get_display(window);
  GdkSeat *seat = IS_NULL_PTR(display) ? NULL : gdk_display_get_default_seat(display);
  GdkDevice *pointer = IS_NULL_PTR(seat) ? NULL : gdk_seat_get_pointer(seat);
  int pointer_x = 0;
  int pointer_y = 0;
  GtkAllocation allocation = { 0 };
 
  if(IS_NULL_PTR(window) || IS_NULL_PTR(pointer))
  {
    gui->pan_edge.timeout_source = 0;
    _reset_edge_pan();
    return FALSE;
  }
 
  gdk_window_get_device_position(window, pointer, &pointer_x, &pointer_y, NULL);
  gtk_widget_get_allocation(center, &allocation);
 
  return _darkroom_edge_pan_apply(self, pointer_x, pointer_y, allocation.width, allocation.height);
}
 
void mouse_moved(dt_view_t *self, double x, double y, double pressure, int which)
{
  dt_develop_t *dev = (dt_develop_t *)self->data;
  dt_control_t *ctl = darktable.control;
  dt_gui_gtk_t *gui = darktable.gui;
 
  const gboolean picker_active = dt_iop_color_picker_is_visible(dev);
 
  // change cursor appearance by default
  _darkroom_set_default_cursor(self, x, y);
  gboolean handled = FALSE;
 
  if(picker_active && ctl->button_down && ctl->button_down_which == 1)
  {
    // module requested a color box
    if(mouse_in_imagearea(self, x, y))
    {
      dt_colorpicker_sample_t *const sample = darktable.develop->color_picker.primary_sample;
      gboolean sample_changed = FALSE;
      float mouse_point[2] = { (float)x, (float)y };
      dt_dev_coordinates_widget_to_image_norm(dev, mouse_point, 1);
      const float delta[2] = {
        1.0f / dev->roi.processed_width,
        1.0f / dev->roi.processed_height
      };
 
      if(sample->size == DT_LIB_COLORPICKER_SIZE_BOX)
      {
        float anchor[2] = { 0.0f };
        _darkroom_sample_raw_point_to_image_norm(sample, anchor);
        const float box[4] = {
          fmaxf(0.0, MIN(anchor[0], mouse_point[0]) - delta[0]),
          fmaxf(0.0, MIN(anchor[1], mouse_point[1]) - delta[1]),
          fminf(1.0, MAX(anchor[0], mouse_point[0]) + delta[0]),
          fminf(1.0, MAX(anchor[1], mouse_point[1]) + delta[1])
        };
        dt_boundingbox_t image_box = { sample->box[0], sample->box[1], sample->box[2], sample->box[3] };
        dt_dev_coordinates_raw_norm_to_image_norm(dev, image_box, 2);
 
        for(int k = 0; k < 4; k++)
          sample_changed |= (image_box[k] != box[k]);
 
        if(sample_changed)
          dt_lib_colorpicker_set_box_area(darktable.lib, box);
      }
      else if(sample->size == DT_LIB_COLORPICKER_SIZE_POINT)
      {
        float image_point[2] = { 0.0f };
        _darkroom_sample_raw_point_to_image_norm(sample, image_point);
        sample_changed = memcmp(image_point, mouse_point, sizeof(mouse_point)) != 0;
        if(sample_changed)
          dt_lib_colorpicker_set_point(darktable.lib, mouse_point);
      }
    }
    handled = TRUE;
  }
  else if(picker_active)
  {
    // Keep module-specific hover overlays and live-edit cursors disabled while the picker owns the center view.
    handled = TRUE;
  }
 
  // masks
  else if(dt_masks_get_visible_form(dev)
          && dt_masks_events_mouse_moved(dev->gui_module, x, y, pressure, which))
  {
    // There is no shape dragging in creation mode, so no need to commit history.
    if(!dev->form_gui->creation)
      dt_gui_throttle_queue(dev, _delayed_history_commit, dev);
      
    handled = TRUE;
  }
 
  // module
  else if(dev->gui_module && dev->gui_module->mouse_moved
    &&dev->gui_module->mouse_moved(dev->gui_module, x, y, pressure, which))
  {
    handled = TRUE;
  }
 
  darkroom_edge_pan_test_t edge = { 0 };
  _darkroom_edge_pan_update_state(self, x, y, self->width, self->height, &edge);
 
  if(!edge.drag && (gui->pan_edge.timeout_source || gui->pan_edge.block_normal_pan))
  {
    _reset_edge_pan();
  }
 
  if(edge.drag && !edge.in_margin && gui->pan_edge.timeout_source)
  {
    /* The drag has already activated edge-pan. Leaving the edge band must stop
       timeout-driven ROI motion immediately and restore normal pan right away. */
    gui->pan_edge.view = self;
    gui->pan_edge.velocity[0] = 0.0f;
    gui->pan_edge.velocity[1] = 0.0f;
    gui->pan_edge.last_time_us = 0;
    gui->pan_edge.block_normal_pan = FALSE;
    if(gui->pan_edge.timeout_source)
    {
      g_source_remove(gui->pan_edge.timeout_source);
      gui->pan_edge.timeout_source = 0;
    }
    ctl->button_x = x;
    ctl->button_y = y;
  }
 
  // While a left-button drag is in the edge band, the timeout owns ROI motion.
  // The current mouse position only updates the velocity that each tick applies.
  if(edge.in_margin)
  {
    gui->pan_edge.view = self;
    gui->pan_edge.block_normal_pan = TRUE;
    gui->pan_edge.velocity[0] = edge.velocity[0];
    gui->pan_edge.velocity[1] = edge.velocity[1];
    if(!gui->pan_edge.timeout_source)
    {
      gui->pan_edge.last_time_us = g_get_monotonic_time();
      gui->pan_edge.timeout_source = g_timeout_add(DARKROOM_EDGE_PAN_INTERVAL_MS,
                                                   _darkroom_edge_pan_tick, &gui->pan_edge);
    }
  }
 
  dt_control_commit_cursor();
 
  if(_darkroom_center_pan_drag && darktable.control->button_down
     && darktable.control->button_down_which == 1 && dev->roi.scaling > 1)
  {
    float delta[2] = { x - ctl->button_x, y - ctl->button_y };
    dt_dev_coordinates_widget_delta_to_image_delta(dev, delta, 1);
 
    float roi[2] = { dev->roi.x - (delta[0] / dev->roi.processed_width),
                     dev->roi.y - (delta[1] / dev->roi.processed_height) };
    dt_dev_check_zoom_pos_bounds(dev, &roi[0], &roi[1], NULL, NULL);
 
    dev->roi.x = roi[0];
    dev->roi.y = roi[1];
    ctl->button_x = x;
    ctl->button_y = y;
 
    dt_dev_pixelpipe_change_zoom_main(dev);
    return;
  }
 
  if(handled)
  {
    dt_control_queue_redraw_center();
    return;
  }
 
  // Edge-pan owns ROI motion only while the timeout is actively driving updates.
  if(gui->pan_edge.block_normal_pan && gui->pan_edge.timeout_source)
  {
    ctl->button_x = x;
    ctl->button_y = y;
    return;
  }
 
  // panning with left mouse button
  if(darktable.control->button_down && darktable.control->button_down_which == 1 && dev->roi.scaling > 1)
  {
    float delta[2] = { x - ctl->button_x, y - ctl->button_y };
    dt_dev_coordinates_widget_delta_to_image_delta(dev, delta, 1);
 
    // new roi position in full image scale
    float roi[2] = { dev->roi.x - (delta[0] / dev->roi.processed_width),
                     dev->roi.y - (delta[1] / dev->roi.processed_height) };
    dt_dev_check_zoom_pos_bounds(dev, &roi[0], &roi[1], NULL, NULL);
 
    dev->roi.x = roi[0];
    dev->roi.y = roi[1];
 
    // update clicked position
    ctl->button_x = x;
    ctl->button_y = y;
 
    dt_dev_pixelpipe_change_zoom_main(dev);
  }
}
 
 
int button_released(dt_view_t *self, double x, double y, int which, uint32_t state)
{
  dt_develop_t *dev = (dt_develop_t *)self->data;
 
  dt_print(DT_DEBUG_INPUT, "[darkroom] button released which: %d state: %d x: %.2f y: %.2f\n",
           which, state, x, y);
 
  if(which == 1)
  {
    _darkroom_center_pan_drag = FALSE;
    dt_control_mouse_is_dragging(FALSE);
    dt_control_mouse_is_painting(FALSE);
 
    _reset_edge_pan();
  }
 
  if(dt_iop_color_picker_is_visible(dev) && which == 1)
  {
    // only sample box picker at end, for speed
    if(darktable.develop->color_picker.primary_sample->size == DT_LIB_COLORPICKER_SIZE_BOX)
      dt_control_queue_cursor(GDK_LEFT_PTR);
 
    dt_control_queue_redraw_center();
    return 1;
  }
  // masks
  if(dt_masks_get_visible_form(dev)
     && dt_masks_events_button_released(dev->gui_module, x, y, which, state))
  {
    // Change on mask parameters and image output.
    dt_gui_throttle_queue(dev, _delayed_history_commit, dev);
    dt_dev_pixelpipe_update_history_preview(dev); // Needed if mask selection changed
    dt_control_queue_redraw_center();
    return 1;
  }
 
  // module
  if(dev->gui_module && dev->gui_module->enabled && dev->gui_module->button_released
     && dev->gui_module->button_released(dev->gui_module, x, y, which, state))
  {
    // Click in modules should handle history changes internally.
    return 1;
  }
 
  return 0;
}
 
 
int button_pressed(dt_view_t *self, double x, double y, double pressure, int which, int type, uint32_t state)
{
  dt_colorpicker_sample_t *const sample = darktable.develop->color_picker.primary_sample;
  dt_develop_t *dev = (dt_develop_t *)self->data;
 
  dt_print(DT_DEBUG_INPUT, "[darkroom] button pressed  which: %d  type: %d x: %.2f y: %.2f pressure: %f\n",
           which, type, x, y, pressure);
 
  // Grab focus on any click so we can interact from keyboard
  gtk_widget_grab_focus(dt_ui_center(darktable.gui->ui));
  if(which == 1)
  {
    _darkroom_center_pan_drag = FALSE;
    dt_control_mouse_is_dragging(FALSE);
    dt_control_mouse_is_painting(FALSE);
 
  }
 
  if(dt_iop_color_picker_is_visible(dev))
  {
    float point[2] = { (float)x, (float)y };
    dt_dev_coordinates_widget_to_image_norm(dev, point, 1);
 
    const float zoom_scale = dt_dev_get_fit_scale(dev);
    float handle[2] = { 6.0f, 6.0f };
    dt_dev_coordinates_widget_delta_to_image_delta(dev, handle, 1);
    handle[0] /= dev->roi.processed_width;
    handle[1] /= dev->roi.processed_height;
 
    if(which == 1)
    {
      if(mouse_in_imagearea(self, x, y))
      {
        // The default box will be a square with 1% of the image width
        const float delta_x = 0.01f;
        const float delta_y = delta_x * (float)dev->roi.processed_width / (float)dev->roi.processed_height;
 
        if(sample->size == DT_LIB_COLORPICKER_SIZE_BOX)
        {
          /* Box drags need one anchor corner stored in sample->point so mouse motion can stretch
             the rectangle against that fixed corner. Keep that anchor local to the darkroom drag
             state, but let the picker API own the actual sampling geometry and update signaling. */
          float raw_point[2] = { point[0], point[1] };
          dt_dev_coordinates_image_norm_to_raw_norm(dev, raw_point, 1);
          memcpy(sample->point, raw_point, sizeof(raw_point));
 
          dt_boundingbox_t image_box = { sample->box[0], sample->box[1], sample->box[2], sample->box[3] };
          dt_dev_coordinates_raw_norm_to_image_norm(dev, image_box, 2);
 
          // this is slightly more than as drawn, to give room for slop
          gboolean on_corner_prev_box = TRUE;
          float opposite[2] = { 0.0f };
 
          if(fabsf(point[0] - image_box[0]) <= handle[0])
            opposite[0] = image_box[2];
          else if(fabsf(point[0] - image_box[2]) <= handle[0])
            opposite[0] = image_box[0];
          else
            on_corner_prev_box = FALSE;
 
          if(fabsf(point[1] - image_box[1]) <= handle[1])
            opposite[1] = image_box[3];
          else if(fabsf(point[1] - image_box[3]) <= handle[1])
            opposite[1] = image_box[1];
          else
            on_corner_prev_box = FALSE;
 
          if(on_corner_prev_box)
          {
            float raw_opposite[2] = { opposite[0], opposite[1] };
            dt_dev_coordinates_image_norm_to_raw_norm(dev, raw_opposite, 1);
            memcpy(sample->point, raw_opposite, sizeof(raw_opposite));
          }
          else
          {
            const dt_boundingbox_t box = {
              fmaxf(0.0, point[0] - delta_x),
              fmaxf(0.0, point[1] - delta_y),
              fminf(1.0, point[0] + delta_x),
              fminf(1.0, point[1] + delta_y)
            };
            dt_lib_colorpicker_set_box_area(darktable.lib, box);
          }
          dt_control_queue_cursor(GDK_FLEUR);
        }
        else
        {
          /* Point pickers must not pre-write sample->point before going through the picker API,
             otherwise the setter sees no geometry change and skips the resample request. */
          dt_lib_colorpicker_set_point(darktable.lib, point);
        }
      }
      dt_control_mouse_is_dragging(TRUE);
      return 1;
    }
 
    if(which == 3)
    {
      // apply a live sample's area to the active picker?
      // FIXME: this is a naive implementation, nicer would be to cycle through overlapping samples then reset
      dt_iop_color_picker_t *picker = darktable.develop->color_picker.picker;
      if(darktable.develop->color_picker.display_samples && mouse_in_imagearea(self, x, y))
        for(GSList *samples = darktable.develop->color_picker.samples; samples; samples = g_slist_next(samples))
        {
          dt_colorpicker_sample_t *live_sample = samples->data;
          if(live_sample->size == DT_LIB_COLORPICKER_SIZE_BOX && picker->kind != DT_COLOR_PICKER_POINT)
          {
            dt_boundingbox_t live_box = { live_sample->box[0], live_sample->box[1], live_sample->box[2], live_sample->box[3] };
            dt_dev_coordinates_raw_norm_to_image_norm(dev, live_box, 2);
            if(point[0] < live_box[0] || point[0] > live_box[2]
               || point[1] < live_box[1] || point[1] > live_box[3])
              continue;
            dt_lib_colorpicker_set_box_area(darktable.lib, live_box);
          }
          else if(live_sample->size == DT_LIB_COLORPICKER_SIZE_POINT && picker->kind != DT_COLOR_PICKER_AREA)
          {
            // magic values derived from _darkroom_pickers_draw
            float slop[2] = {
              MAX(26.0f, roundf(3.0f * zoom_scale)),
              MAX(26.0f, roundf(3.0f * zoom_scale))
            };
            dt_dev_coordinates_widget_delta_to_image_delta(dev, slop, 1);
            slop[0] /= dev->roi.processed_width;
            slop[1] /= dev->roi.processed_height;
            float live_point[2] = { live_sample->point[0], live_sample->point[1] };
            dt_dev_coordinates_raw_norm_to_image_norm(dev, live_point, 1);
            if(fabsf(point[0] - live_point[0]) > slop[0]
               || fabsf(point[1] - live_point[1]) > slop[1])
              continue;
            dt_lib_colorpicker_set_point(darktable.lib, live_point);
          }
          else
            continue;
          return 1;
        }
 
      if(sample->size == DT_LIB_COLORPICKER_SIZE_BOX)
      {
        // default is hardcoded this way
        // FIXME: color_pixer_proxy should have an dt_iop_color_picker_clear_area() function for this
        dt_boundingbox_t reset = { 0.01f, 0.01f, 0.99f, 0.99f };
        dt_lib_colorpicker_set_box_area(darktable.lib, reset);
      }
      return 1;
    }
  }
 
  // masks
  if(dt_masks_get_visible_form(dev)
     && dt_masks_events_button_pressed(dev->gui_module, x, y, pressure, which, type, state))
  {
    if(!darktable.develop->form_gui->creation)
      dt_gui_throttle_queue(dev, _delayed_history_commit, dev);
    return 1;
  }
  // module
  if(dev->gui_module && dev->gui_module->enabled && dev->gui_module->button_pressed
     && dev->gui_module->button_pressed(dev->gui_module, x, y, pressure, which, type, state))
  {
    return 1;
  }
 
  if(which == 1 && dev->roi.scaling > 1.0f && mouse_in_imagearea(self, x, y))
    _darkroom_center_pan_drag = TRUE;
 
  if(which == 2)
  {
    // Incremental zoom-in on middle button click, from fit to 800% 
    // by power of 2 increments (100%, 200%, 400%, 800%).
    float new_scale = 1.f;
    if(dev->roi.scaling < 1.f || dev->roi.scaling > 7.f / dev->roi.natural_scale)
      new_scale = 1.f; // zoom to fit
    else if(dev->roi.scaling * dev->roi.natural_scale < 1.f)
      new_scale = 1.f / dev->roi.natural_scale; // 100 %
    else
      new_scale = floorf(dev->roi.scaling * dev->roi.natural_scale) * 2.f / dev->roi.natural_scale;
 
    const float point[2] = { x, y };
    return _change_scaling(dev, point, new_scale);
  }
 
  return 0;
}
 
static int _change_scaling(dt_develop_t *dev, const float point[2], const float new_scaling)
{
  const float old_scaling = dev->roi.scaling;
 
  // Round scaling to 1.0 (fit) if close enough
  const float epsilon = fabsf(old_scaling - new_scaling);
  if(fabsf(new_scaling - 1.0f) < epsilon)
    dev->roi.scaling = 1.0f;
  else
    dev->roi.scaling = new_scaling;
 
  if(!dt_dev_check_zoom_scale_bounds(dev))
  { 
    // Calculate zoom position offset to keep mouse position fixed during zoom
    float center[2] = { 0.0f };
    float mouse_offset[2] = { point[0], point[1] };
    dt_dev_get_widget_center(dev, center);
    mouse_offset[0] -= center[0];
    mouse_offset[1] -= center[1];
 
    
    // Keep the image point under the mouse fixed in widget coordinates while
    // the pipeline zoom stays DPI-invariant.
    const float old_zoom = dt_dev_get_widget_zoom_scale(dev, old_scaling);
    const float new_zoom = dt_dev_get_widget_zoom_scale(dev, dev->roi.scaling);
    if(old_zoom <= 1e-6f || new_zoom <= 1e-6f)
    {
      dev->roi.scaling = old_scaling;
      return 0;
    }
 
    // Adjust the center to compensate for the scale change
    int proc_w = 0.f, proc_h = 0.f;
    dt_dev_get_processed_size(dev, &proc_w, &proc_h);
    dev->roi.x += mouse_offset[0] * (1.f / old_zoom - 1.f / new_zoom) / proc_w;
    dev->roi.y += mouse_offset[1] * (1.f / old_zoom - 1.f / new_zoom) / proc_h;
    
    dt_dev_check_zoom_pos_bounds(dev, &dev->roi.x, &dev->roi.y, NULL, NULL);
    dt_dev_pixelpipe_change_zoom_main(dev);
    return 1;
  }
  else
  {
    // Invalid zoom level, keep previous value
    dev->roi.scaling = old_scaling;
    return 0;
  }
}
 
static gboolean _center_view_free_zoom(dt_view_t *self, double x, double y, int up, int state, int flow)
{
  dt_develop_t *dev = darktable.develop;
 
  // Commit the new scaling
  const float step = 1.02f;
  const float new_scaling = dev->roi.scaling * powf(step, (float)-flow);
  const float point[2] = { x, y };
  return _change_scaling(dev, point, new_scaling);
}
 
 
int scrolled(dt_view_t *self, double x, double y, int up, int state, int delta_y)
{
  if(_is_scroll_captured_by_widget()) return FALSE;
 
  dt_develop_t *dev = (dt_develop_t *)self->data;
 
  dt_print(DT_DEBUG_INPUT, "[darkroom] scrolled: up: %i x: %.2f y: %.2f state: %i flow: %i\n",
           up, x, y, state, delta_y);
 
  // masks
  if(dt_masks_get_visible_form(dev)
     && dt_masks_events_mouse_scrolled(dev->gui_module, x, y, up, state, delta_y))
  {
    dt_control_queue_redraw_center();
    if(!dev->form_gui->creation)
      dt_gui_throttle_queue(dev, _delayed_history_commit, dev);
 
    return TRUE;
  }
 
  // module
  if(dev->gui_module && dev->gui_module->enabled && dev->gui_module->scrolled && dev->gui_module->scrolled(dev->gui_module, x, y, up, state))
  {
    // Scroll in modules should handle history changes internally.
    return TRUE;
  }
 
  // free zoom
  return _center_view_free_zoom(self, x, y, up, state, delta_y);
}
 
static void _key_scroll(dt_develop_t *dev)
{
  dt_dev_check_zoom_pos_bounds(dev, &dev->roi.x, &dev->roi.y, NULL, NULL);
  dt_control_queue_redraw_center();
  dt_dev_pixelpipe_change_zoom_main(dev);
}
 
 
int key_pressed(dt_view_t *self, GdkEventKey *event)
{
  if(!gtk_window_is_active(GTK_WINDOW(darktable.gui->ui->main_window))) return FALSE;
 
  dt_develop_t *dev = (dt_develop_t *)self->data;
 
  if(dt_masks_get_visible_form(dev) && dt_masks_events_key_pressed(dev->gui_module, event))
  {
    dt_gui_throttle_queue(dev, _delayed_history_commit, dev);
    return 1;
  }
 
  // module
  else if(!IS_NULL_PTR(dev->gui_module)
          && !IS_NULL_PTR(dev->gui_module->key_pressed)
          && dev->gui_module->key_pressed(dev->gui_module, event))
  {
    dt_gui_throttle_queue(dev, _delayed_history_commit, dev);
    return 1;
  }
 
  const gboolean shift = dt_modifier_is(event->state, GDK_SHIFT_MASK);
  const gboolean ctrl = dt_modifier_is(event->state, GDK_CONTROL_MASK);
  const gboolean ctrl_any = dt_modifiers_include(event->state, GDK_CONTROL_MASK);
  guint key = dt_keys_mainpad_alternatives(event->keyval);
 
  if(ctrl_any)
  {
    const float zoom_step = 1.1f;
    float center[2] = { 0.0f };
    dt_dev_get_widget_center(dev, center);
 
    switch(key)
    {
      case GDK_KEY_plus:
        return _change_scaling(dev, center, dev->roi.scaling * zoom_step);
      case GDK_KEY_minus:
        return _change_scaling(dev, center, dev->roi.scaling / zoom_step);
    }
  }
 
  float multiplier = (shift) ? 4.f :
                     (ctrl) ? 0.5f :
                     1.f;
 
  float delta[2] = { 10.f * multiplier, 10.f * multiplier };
  dt_dev_coordinates_widget_delta_to_image_delta(dev, delta, 1);
 
  switch(key)
  {
    case GDK_KEY_Up:
    {
      dev->roi.y -= delta[1] / (float)dev->roi.processed_height;
      _key_scroll(dev);
      return 1;
    }
    case GDK_KEY_Down:
    {
      dev->roi.y += delta[1] / (float)dev->roi.processed_height;
      _key_scroll(dev);
      return 1;
    }
    case GDK_KEY_Left:
    {
      dev->roi.x -= delta[0] / (float)dev->roi.processed_width;
      _key_scroll(dev);
      return 1;
    }
    case GDK_KEY_Right:
    {
      dev->roi.x += delta[0] / (float)dev->roi.processed_width;
      _key_scroll(dev);
      return 1;
    }
    case GDK_KEY_Escape:
    {
      dt_ctl_switch_mode_to("lighttable");
      return TRUE;
    }
  }
 
  return 0;
}
 
void configure(dt_view_t *self, int wd, int ht)
{
  dt_develop_t *dev = (dt_develop_t *)self->data;
 
  // Configure event is called when initing the view AND upon window resizes events (through Gtk widget/window resize commands).
  // At init time, final window size may not be correct just yet.
  // It will be when we call dt_ui_restore_panels(), which will resize stuff properly,
  // but that will be only when entering the current view.
  // Until we run dt_dev_configure(), main preview pipe gets output size -1×-1 px
  // which aborts the pipe recompute early. As soon as we init
  // sizes with something "valid" with regard to the pipe, pipeline runs.
  // Problem is it will not be valid with regard to the window size and the output will be thrown out
  // until we get the final size.
  // TD;DR: until we get the final window size, which happens
  // only when entering the view, don't configure the main preview pipeline, which will disable useless recomputes.
  if(dt_view_manager_get_current_view(darktable.view_manager) == self)
  {
    // Reference dimensions before ISO 12646 mode
    dev->roi.orig_height = ht;
    dev->roi.orig_width = wd;
    dt_dev_toolbox_apply_iso_12646_size(dev);
  }
}
 
// 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