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 "develop/imageop_gui.h"
#include "widgets/bauhaus.h"
#include "widgets/accelerators.h"
#include "widgets/widget_settings.h"
#include <glib/gstdio.h>
#include "common/paths.h"
#include "common/collection.h"
#include "widgets/gdkkeys.h"
#include "common/hash.h"
#include "common/iop-autoset.h"
#include "imageio/imageio_module.h"
#include "caches/mipmap_cache.h"
#include "common/module_versioning.h"
#include "common/selection.h"
#include "common/undo.h"
#include "common/conf.h"
#include "control/input.h"
#include "control/control.h"
#include "control/jobs.h"
#include "develop/dev_pixelpipe.h"
#include "develop/dev_history.h"
#include "develop/pixelpipe_hb.h"
#include "develop/develop.h"
#include "develop/dev_history_gui.h"
#include "develop/imageop.h"
#include "develop/supervisor.h"
#include "develop/masks.h"
#include "develop/masks_gui.h"
#include "widgets/button.h"
#include "gui/dtgtk/thumbtable.h"
 
#include "gui/color_picker_proxy.h"
#include "gui/application.h"
#include "develop/gui_throttle.h"
// include-cleaner reports this unused while dt_iop_gui_blend_data_t is dereferenced
// six times in _toggle_mask_visibility_callback() -- the cast from the void*
// mod->blend_data seems to defeat its attribution. The definition is required.
#include "develop/blend_gui.h"  // NOLINT(misc-include-cleaner)
#include "gui/guides.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
#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 <fcntl.h>
#include "widgets/label.h"
#include "widgets/widget_style.h"
#include "gui/screen_metrics.h"
#include "widgets/togglebutton.h"
#include "control/signal.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);
  dt_dev_set_global((dt_develop_t *)self->data);
  dt_view_manager_get_global()->proxy.darkroom.view = self;
}
 
uint32_t view(const dt_view_t *self)
{
  return DT_VIEW_DARKROOM;
}
 
uint32_t flags()
{
  /* expose() composes background and image over the whole centre itself */
  return VIEW_FLAGS_PAINTS_WHOLE_AREA;
}
 
static void _reset_edge_pan()
{
  dt_gui_gtk_t *gui = dt_gui_get_global();
  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_dev_history_drop_pending_commits(dev);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), 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(dt_view_manager_get_global()->guides_popover) g_object_unref(dt_view_manager_get_global()->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(dt_dev_get_global(), 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(dt_dev_get_global(), 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 = dt_dev_roi_request_preview_width(dev);
  const double ht = dt_dev_roi_request_preview_height(dev);
  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 = dt_dev_get_global()->color_picker.selected_sample;
  const gboolean only_selected_sample
      = _darkroom_is_only_selected_sample(is_primary_sample, selected_sample,
                                          dt_dev_get_global()->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;
  // One read of the publication: the hash and the shape must come from the same frame (dt_backbuf_t).
  const dt_backbuf_state_t published = dt_dev_backbuf_snapshot(&dev->pipe->backbuf);
  const uint64_t hash = published.hash;
  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(TRUE, entry);
 
  const int bw = (int)published.width;
  const int bh = (int)published.height;
  if(bw <= 0 || bh <= 0)
  {
    dt_dev_pixelpipe_cache_rdlock_entry(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(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(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, dt_gui_get_global()->ppd, dt_gui_get_global()->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(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_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 = dt_gui_get_global()->ppd;
  const float preview_wd = wd / ppd;
  const float preview_ht = ht / ppd;
  const float preview_scale = dt_dev_viewport_scaling(dev);
  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(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 - dt_dev_viewport_center_x(dev) * preview_wd * preview_scale;
  const float ty = 0.5f * height - dt_dev_viewport_center_y(dev) * 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);
  /* A placeholder while the main pipe catches up, resampled by the zoom: nearest neighbour,
   * on the pattern that actually scales. This filter used to be set on the context's default
   * solid source before the surface replaced it, so the scaling ran with cairo's default GOOD
   * filter -- measured at a 2560x1440 window on a 2x screen: 262 ms per frame zooming out,
   * 120 ms zooming in, against 4 and 8 ms with the filter that was meant. */
  cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
  cairo_fill(cr);
  dt_dev_pixelpipe_cache_rdlock_entry(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;
  /* What dev->image_surface currently holds: the source frame, the viewport, the colours and
   * the frame size it was composed for. A frame with the same key is already on it, and an
   * expose that only moved an overlay repaints from it without composing again -- composing
   * was a full-window fill and a full-window blit on every frame, for an image that had not
   * changed. */
  uint64_t composed_key;
} darkroom_expose_state_t;
 
/* Everything the composed image depends on, and nothing else. */
static uint64_t _darkroom_compose_key(const uint64_t source_hash, const uint64_t zoom_hash,
                                      const dt_aligned_pixel_t bg_color, const int border, const gboolean iso,
                                      const int width, const int height)
{
  uint64_t key = 5381;
  key = dt_hash(key, (const char *)&source_hash, sizeof(source_hash));
  key = dt_hash(key, (const char *)&zoom_hash, sizeof(zoom_hash));
  key = dt_hash(key, (const char *)bg_color, 3 * sizeof(float));
  key = dt_hash(key, (const char *)&border, sizeof(border));
  key = dt_hash(key, (const char *)&iso, sizeof(iso));
  key = dt_hash(key, (const char *)&width, sizeof(width));
  key = dt_hash(key, (const char *)&height, sizeof(height));
  return key;
}
 
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 uint64_t _darkroom_zoom_hash(const dt_develop_t *dev)
{
  uint64_t hash = 5381;
 
  // Three coherent reads, hashed as the three records they are. Hashing field by field through
  // accessors would let a publication land between two of them and key the cached surface to a
  // viewport that never existed -- which is the same tearing the objects were built to remove.
  const dt_dev_viewport_state_t viewport = dt_dev_viewport_get(dev);
  hash = dt_hash(hash, (const char *)&viewport, sizeof(viewport));
 
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  hash = dt_hash(hash, (const char *)&geometry, sizeof(geometry));
 
  // The request's generation, not its bytes: the record carries four bytes of tail padding
  // (its uint64_t forces 8-byte alignment) whose contents C does not define across a copy, so
  // hashing it raw could key the cached surface differently for identical content. The
  // generation exists precisely to answer "did this change", and advances only when it did.
  // dt_dev_viewport_state_t and dt_dev_image_geometry_t above are padding-free, so their bytes
  // are safe to hash directly -- checked, not assumed.
  const dt_dev_roi_request_t request = dt_dev_roi_request_get(dev);
  hash = dt_hash(hash, (const char *)&request.generation, sizeof(request.generation));
  return hash;
}
 
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;
  state->composed_key = 0;
}
 
/* One expose's composition: the context of the image surface, the frame and the colours it
 * is composed for, and the state that remembers what it holds. */
typedef struct _darkroom_compose_t
{
  cairo_t *cr;
  const dt_develop_t *dev;
  darkroom_expose_state_t *state;
  int width;
  int height;
  int border;
  uint64_t zoom_hash;
  const float *bg_color;
} _darkroom_compose_t;
 
static uint64_t _darkroom_compose_key_of(const _darkroom_compose_t *const c, const uint64_t source_hash)
{
  return _darkroom_compose_key(source_hash, c->zoom_hash, c->bg_color, c->border, c->dev->iso_12646.enabled,
                               c->width, c->height);
}
 
static gboolean _darkroom_composed_already(const _darkroom_compose_t *const c, const uint64_t key)
{
  return c->state->composed_key == key && c->state->image_surface_imgid == c->dev->image_storage.id;
}
 
/* Compose @p locked into the image surface unless the frame it would compose is already
 * there. */
static gboolean _darkroom_compose_locked(const _darkroom_compose_t *const c, dt_dev_locked_surface_t *locked)
{
  if(IS_NULL_PTR(locked) || IS_NULL_PTR(locked->surface)) return FALSE;
  const uint64_t key = _darkroom_compose_key_of(c, locked->hash);
  if(_darkroom_composed_already(c, key)) return TRUE;
  if(!dt_dev_render_locked_surface(c->cr, c->dev, locked, c->width, c->height, c->border, c->bg_color)) return FALSE;
  c->state->composed_key = key;
  return TRUE;
}
 
/* Copy the cached fallback into the image surface unless it is already the frame there. */
static gboolean _darkroom_compose_fallback(const _darkroom_compose_t *const c)
{
  /* salted: a fallback is not the same frame as a main backbuf that happened to hash alike */
  const uint64_t source = _darkroom_preview_fallback_backbuf_hash ^ 0x9e3779b97f4a7c15ULL;
  const uint64_t key = _darkroom_compose_key_of(c, source);
  if(_darkroom_composed_already(c, key)) return TRUE;
  if(!_render_preview_fallback_surface(c->cr)) return FALSE;
  c->state->composed_key = key;
  return TRUE;
}
 
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;
  state->composed_key = 0;
  _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 = dt_dev_viewport_border_size(dev);
 
#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,
    .composed_key = 0,
  };
  const uint64_t zoom_hash = _darkroom_zoom_hash(dev);
  const gboolean roi_changed = !_darkroom_locked_main_valid_for_zoom(&expose_state, zoom_hash);
 
  /* The expose is timed as a whole and nothing inside it is, which is why a redraw that grows
   * from 11 ms to 400 ms across a drawing session cannot be attributed: the mask overlay reports
   * 1.5 ms of it and the rest is dark. Three stages, so the next log says which. */
  dt_times_t stage = { 0 };
  dt_get_times(&stage);
 
  _darkroom_prepare_image_surface(dev, width, height, &expose_state);
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF) dt_show_times(&stage, "[darkroom] surface prepared");
  dt_get_times(&stage);
 
  cairo_t *cr = cairo_create(dev->image_surface);
  const int full_width = dt_dev_roi_request_preview_width(dev);
  const int full_height = dt_dev_roi_request_preview_height(dev);
  const dt_backbuf_state_t preview_published = dt_dev_backbuf_snapshot(&dev->preview_pipe->backbuf);
  const uint64_t main_backbuf_hash = dt_dev_backbuf_get_hash(&dev->pipe->backbuf);
  const uint64_t preview_backbuf_hash = preview_published.hash;
  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
        && preview_published.width == (size_t)full_width
        && preview_published.height == (size_t)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);
  const _darkroom_compose_t compose = { .cr = cr, .dev = dev, .state = &expose_state, .width = width,
                                        .height = height, .border = border, .zoom_hash = zoom_hash,
                                        .bg_color = bg_color };
 
  /* 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
       && _darkroom_compose_locked(&compose, &_darkroom_main_locked))
    {
      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
       && _darkroom_compose_locked(&compose, &_darkroom_preview_locked))
    {
      // 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)
       && _darkroom_compose_fallback(&compose))
    {
      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)
     && _darkroom_compose_fallback(&compose))
  {
    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)
     && _darkroom_compose_locked(&compose, &_darkroom_main_locked))
  {
    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);
    expose_state.composed_key = 0;
    _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(dt_dev_get_global()->proxy.snapshot.request)
  {
    /* reset the request */
    dt_dev_get_global()->proxy.snapshot.request = FALSE;
 
    /* validation of snapshot filename */
    g_assert(!IS_NULL_PTR(dt_dev_get_global()->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(dt_dev_get_global()->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(dt_dev_get_global()->color_picker.samples
     && (dt_dev_get_global()->color_picker.display_samples
         || (dt_dev_get_global()->color_picker.selected_sample &&
             dt_dev_get_global()->color_picker.selected_sample != dt_dev_get_global()->color_picker.primary_sample)))
  {
    _darkroom_pickers_draw(self, cri, width, height, pointerx, pointery, dt_dev_get_global()->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 = dt_dev_roi_request_preview_width(dev);
    const float ht = dt_dev_roi_request_preview_height(dev);
    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);
  }
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF) dt_show_times(&stage, "[darkroom] image painted");
  dt_get_times(&stage);
 
  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 = dt_dev_get_global()->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 shape manager window is open
    const gboolean display_masks = (dev->gui_module && dev->gui_module->enabled)
                                 || dt_dev_masks_manager_is_visible(dev);
 
    if(dt_get_debug_flags() & DT_DEBUG_PERF) dt_show_times(&stage, "[darkroom] overlay predicates");
 
    if(dt_masks_get_visible_form(dev) && display_masks)
      dt_masks_events_post_expose(dev, dev->gui_module, cri, width, height, pointerx, pointery);
      
    if(dt_get_debug_flags() & DT_DEBUG_PERF) dt_show_times(&stage, "[darkroom] overlays drawn");
    dt_get_times(&stage);
 
    // 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);
 
      if(dt_get_debug_flags() & DT_DEBUG_PERF)
        dt_show_times_f(&stage, "[darkroom]", "module %s gui_post_expose", dev->gui_module->op);
    }
  }
 
  // 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(dt_view_manager_get_global()->current_view != self) return;
 
 
  if(result)
  {
    _darkroom_log_image_load_error((int)result);
    return;
  }
 
  dt_dev_get_global()->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(dt_undo_get_global(), 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(dt_control_signal_get_global(), 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(dt_selection_get_global());
 
  // 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(dt_control_signal_get_global(), 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(dt_selection_get_global());
  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(dt_selection_get_global());
  }
 
  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(dt_view_manager_get_global(), "lighttable");
  dt_control_set_mouse_over_id(imgid);
  dt_view_manager_switch(dt_view_manager_get_global(), "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(dt_dev_get_global());
}
 
/* 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);
}
 
static void _darkroom_change_mask_rasterization(GtkWidget *combobox, gpointer user_data)
{
  dt_develop_t *d = (dt_develop_t *)user_data;
  dt_conf_set_string("plugins/darkroom/masks/rasterization",
                     (dt_bauhaus_combobox_get(combobox) == 0) ? "auto" : "never");
  /* The step itself is recomputed by dt_dev_roi_request_publish(), on this thread. Only the
   * MAIN pipe is affected: the preview's step is always automatic, set from its own ROI, so
   * this preference cannot change it and resyncing it would be wasted work. */
  dt_dev_roi_request_publish(d);
  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(dt_dev_get_global(), 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_gui_center_widget());
  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(dt_collection_get_global(), -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(dt_collection_get_global(), -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 = dt_dev_get_global()->preview_pipe;
  const gboolean autoset_running_before
      = !IS_NULL_PTR(_autoset_manager) && _autoset_manager->progress_cursor_active;
  const int32_t imgid = dt_dev_get_global()->image_storage.id;
  const dt_backbuf_state_t published = dt_dev_backbuf_snapshot(&pipe->backbuf);
  dt_mipmap_size_t mip = dt_mipmap_cache_get_fitting_size(published.width, published.height, imgid);
 
  // Check if the cache is ready for that mipmap size.
  dt_mipmap_buffer_t tmp;
  dt_mipmap_cache_get(&tmp, imgid, mip, DT_MIPMAP_TESTLOCK, 'r');
  gboolean cache_ready = !IS_NULL_PTR(tmp.buf);
  dt_mipmap_cache_release(&tmp);
 
  if(pipe->autoset)
  {
    dt_iop_autoset_advance(dt_dev_get_global(), _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(dt_gui_get_ui()->thumbtable_lighttable, imgid, TRUE);
      dt_thumbtable_refresh_thumbnail(dt_gui_get_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(dt_dev_get_global(), _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;
 
  // Register the GTK-driving handlers for history commits and undo restores (the inverted
  // dependency dev_history.c exposes). Done here, not in dt_init(): the call sites
  // NULL-check, so a GUI-less process runs with the slots empty instead of registering
  // callbacks that must never fire.
  dt_dev_history_gui_init();
 
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_DEVELOP_PREVIEW_PIPE_FINISHED,
                                  G_CALLBACK(_preview_pipe_finished), self);
 
  dt_accels_new_darkroom_action(_switch_to_next_picture, self, NULL, 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, NULL, 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(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), GDK_KEY_Return, 0);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move up"));
  dt_accels_new_virtual_shortcut(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), GDK_KEY_Up, 0);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move up (coarse step)"));
  dt_accels_new_virtual_shortcut(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), 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(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), GDK_KEY_Up, DT_PRIMARY_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move down"));
  dt_accels_new_virtual_shortcut(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), GDK_KEY_Down, 0);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move down (coarse step)"));
  dt_accels_new_virtual_shortcut(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), 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(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), GDK_KEY_Down, DT_PRIMARY_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move left"));
  dt_accels_new_virtual_shortcut(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), GDK_KEY_Left, 0);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move left (coarse step)"));
  dt_accels_new_virtual_shortcut(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), 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(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), GDK_KEY_Left, DT_PRIMARY_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move right"));
  dt_accels_new_virtual_shortcut(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), GDK_KEY_Right, 0);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Move right (coarse step)"));
  dt_accels_new_virtual_shortcut(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), 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(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), GDK_KEY_Right, DT_PRIMARY_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Zoom in"));
  dt_accels_new_virtual_shortcut(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), GDK_KEY_plus, DT_PRIMARY_MASK);
  dt_free(path);
 
  path = dt_accels_build_path(_("Darkroom/Main image"), _("Zoom out"));
  dt_accels_new_virtual_shortcut(dt_gui_get_accels(), dt_gui_get_accels()->darkroom_accels,
                                 path, dt_gui_center_widget(), GDK_KEY_minus, DT_PRIMARY_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, dt_gui_get_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(dt_bauhaus_get_global(), 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);
 
    gchar *rasterization = dt_conf_get_string("plugins/darkroom/masks/rasterization");
    const int rasterization_index = (!IS_NULL_PTR(rasterization) && !strcmp(rasterization, "never")) ? 1 : 0;
    g_free(rasterization);
 
    GtkWidget *mask_rasterization;
    DT_BAUHAUS_COMBOBOX_NEW_FULL(dt_bauhaus_get_global(), mask_rasterization, NULL,
                                N_("Fast drawn mask rasterization"),
                                _("Choose how finely brush and polygon masks are drawn in the darkroom.\n"
                                  "Auto samples one point per displayed pixel: zoomed out costs less,\n"
                                  "and at 100% or closer masks are pixel-accurate.\n"
                                  "Never keeps pixel accuracy at every zoom level, at some cost when zoomed out.\n"
                                  "Exports, thumbnails and snapshots are always pixel-accurate either way."),
                                rasterization_index,
                                _darkroom_change_mask_rasterization, dev,
                                N_("auto (default)"),
                                N_("never")
                              );
    gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(mask_rasterization), 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(dt_bauhaus_get_global(), 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(dt_view_manager_get_global(), _darkroom_ioporder_button, DT_VIEW_DARKROOM);
  dt_accels_new_darkroom_action(dt_dev_toolbox_activate_accel, _darkroom_ioporder_button,
                                _darkroom_ioporder_button, N_("Darkroom/Toolbox"),
                                N_("Show the pipeline node graph"), 0, 0,
                                _("Triggers the action"));
 
  /* create grid changer popup tool */
  {
    // the button
    dt_view_manager_t *vm = dt_view_manager_get_global();
    vm->guides_toggle = dtgtk_togglebutton_new(dtgtk_cairo_paint_grid, 0, NULL);
    gtk_widget_set_tooltip_text(vm->guides_toggle,
                                _("toggle guide lines\nright click for guides options"));
    vm->guides_popover = dt_guides_popover(self, vm->guides_toggle);
    g_object_ref(vm->guides_popover);
    g_signal_connect(G_OBJECT(vm->guides_toggle), "clicked",
                     G_CALLBACK(_guides_quickbutton_clicked), dev);
    dt_dev_toolbox_connect_popover(vm->guides_toggle, vm->guides_popover);
    dt_dev_toolbox_popover_set_preshow(vm->guides_popover, _guides_popover_preshow, NULL);
    g_object_set_data(G_OBJECT(vm->guides_toggle), DT_DEV_TOOLBOX_POPOVER_KEY,
                      vm->guides_popover);
    dt_view_manager_module_toolbox_add(vm, vm->guides_toggle,
                                       DT_VIEW_DARKROOM | DT_VIEW_STUDIO_CAPTURE);
    dt_accels_new_darkroom_action(dt_dev_toolbox_activate_accel,
                                  vm->guides_toggle, vm->guides_toggle, N_("Darkroom/Toolbox"),
                                  N_("Toggle guide lines"), 0, 0,
                                  _("Triggers the action"));
    dt_accels_new_darkroom_action(dt_dev_toolbox_focus_accel,
                                  vm->guides_toggle, vm->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(dt_control_signal_get_global(), 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(dt_view_manager_get_global(), _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,
                                  _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(dt_control_signal_get_global(), DT_SIGNAL_DEVELOP_HISTORY_CHANGE,
                                    G_CALLBACK(_darkroom_autoset_popover_refresh), dev);
    DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_DEVELOP_IMAGE_CHANGED,
                                    G_CALLBACK(_darkroom_autoset_popover_refresh), dev);
    DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_DEVELOP_MODULE_REMOVE,
                                    G_CALLBACK(_darkroom_autoset_popover_refresh), dev);
  }
 
  dt_view_manager_get_global()->proxy.darkroom.get_layout = _lib_darkroom_get_layout;
  dt_view_manager_get_global()->proxy.darkroom.set_default_cursor = _darkroom_set_default_cursor;
  dt_dev_viewport_set_border(dev, DT_PIXEL_APPLY_DPI(dt_conf_get_int("plugins/darkroom/ui/border_size")));
}
 
static gboolean _is_scroll_captured_by_widget()
{
  dt_accels_t *accels = dt_gui_get_accels();
  if(!dt_widget_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(dt_widget_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(dt_widget_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(dt_control_get_global(), 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->gui->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(dt_undo_get_global(), 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(dt_gui_get_accels());
  dt_accels_connect_active_group(dt_gui_get_accels(), "darkroom");
  dt_accels_attach_scroll_handler(dt_gui_get_accels(), _scroll_on_focus, dev);
 
  // Attach bauhaus default signal callback to IOP
  dt_bauhaus_get_global()->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(dt_gui_get_ui()->thumbtable_filmstrip);
  gtk_widget_show(dt_gui_center_widget());
  dt_thumbtable_update_parent(dt_gui_get_ui()->thumbtable_filmstrip);
 
  /* connect signal for filmstrip image activate */
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_VIEWMANAGER_THUMBTABLE_ACTIVATE,
                                  G_CALLBACK(_view_darkroom_filmstrip_activate_callback), self);
 
  gtk_widget_grab_focus(dt_gui_center_widget()); // 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, dt_gui_get_ui()->thumbtable_filmstrip);
  int ret = dt_dev_load_image(dt_dev_get_global(), 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);
  // Last moment at which committing is still safe -- everything below tears down
  // dev->pipe / dev->iop / dev->history. Run the pending edit rather than lose it.
  dt_dev_history_flush_pending_commits(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);
  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(dt_dev_get_global()->gui_module)
    dt_conf_set_string("plugins/darkroom/active", dt_dev_get_global()->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(dt_gui_get_accels());
 
  /* disconnect from filmstrip image activate */
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_view_darkroom_filmstrip_activate_callback),
  (gpointer)self);
 
  dt_iop_color_picker_cleanup();
 
  if(dt_dev_get_global()->color_picker.picker)
    dt_iop_color_picker_reset(dt_dev_get_global()->color_picker.picker->module, FALSE);
 
  // Detach shortcuts
  dt_accels_disconnect_active_group(dt_gui_get_accels());
 
  // Restore the previous selection
  dt_selection_select_single(dt_selection_get_global(), dt_view_active_images_get_first());
  dt_view_active_images_reset(FALSE);
 
  dt_thumbtable_hide(dt_gui_get_ui()->thumbtable_filmstrip);
  gtk_widget_hide(dt_gui_center_widget());
 
  // 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(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(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);
 
  /* 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(dev->pipe->last_devid);
  if(dev->preview_pipe->last_devid != dev->pipe->last_devid)
    dt_dev_pixelpipe_cache_flush_clmem_for_pipe(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_masks_release_all_forms(dev);
 
  // Fetch the new thumbnail if needed. Ensure it runs after we save history.
  dt_thumbtable_refresh_thumbnail(dt_gui_get_ui()->thumbtable_lighttable, dt_dev_get_global()->image_storage.id, TRUE);
  dt_dev_get_global()->image_storage.id = -1;
 
  // Release the cache entries for histogram buffers
  dt_dev_pixelpipe_cache_unref_hash(dt_dev_backbuf_get_hash(&dev->raw_histogram));
  dt_dev_backbuf_set_hash(&dev->raw_histogram, -1);
 
  dt_dev_pixelpipe_cache_unref_hash(dt_dev_backbuf_get_hash(&dev->output_histogram));
  dt_dev_backbuf_set_hash(&dev->output_histogram, -1);
 
  dt_dev_pixelpipe_cache_unref_hash(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_gui_gtk_t *gui = dt_gui_get_global();
  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
     && dt_control_button_down(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);
}
 
// The module the pending mask-edit history commit must be addressed to, captured when the
// commit is queued (i.e. when the mask event actually happened). The commit itself fires after
// an adaptive throttle timeout, and dev->gui_module may have moved to another module meanwhile:
// addressing the commit to the *new* focus then records the mask edit on a module that owns no
// forms, whose history item hash does not change — the resync takes the cheap top-item path and
// the real owner's piece hash is never refreshed, so the pipe keeps serving the pre-edit
// cacheline (issue #1060 family: "the mask does nothing until you nudge a slider").
static dt_iop_module_t *_pending_mask_commit_module = NULL;
 
/* Re-render the mask's owner from the LIVE geometry, without writing history.
 *
 * A drawn shape's geometry lives in dev->forms, not in any module's params, and the pipe reads
 * it fresh on every recompute (dt_dev_pixelpipe_process() re-snapshots pipe->forms). What the
 * pipe does NOT do on its own is notice that the geometry moved: a piece is re-keyed only when
 * its history item changes, so a drag used to be made visible by committing history on a
 * throttle, mid-drag -- one history rewrite, one DB write job and one full synch_top per
 * throttle tick, with the mask's owner re-hashed against the forms as a side effect.
 *
 * This is the drawlayer brush's route instead (see _publish_backend_progress() in
 * iop/drawlayer/worker.c): publish the owner's params through the transient channel and flag
 * the main pipe TOP_CHANGED. That routes the resync through _sync_focused_in_place(), which
 * re-commits the ONE focused piece against the live dev->forms -- dt_iop_compute_blendop_hash()
 * folds the group's geometry in -- so the piece re-keys from the moved shape and only it and
 * its downstream recompute. The params published are the module's own, unchanged: it is the
 * forms that moved, and the transient slot is only the ticket onto the focused-piece path.
 *
 * Flagged without the killswitch (dt_dev_pixelpipe_or_changed, not _change_pipe), as the
 * drawlayer heartbeat does: a fast drag must not abort every in-flight render or none would
 * ever finish. History is written once, when the interaction ends -- see the commit below,
 * which clears this slot so the pipe goes back to rendering the committed state. */
static void _publish_mask_edit_transient(dt_develop_t *dev)
{
  dt_iop_module_t *module = dev->gui_module;
  if(IS_NULL_PTR(module) || IS_NULL_PTR(module->params) || module->params_size <= 0) return;
  dt_dev_transient_params_set(module, module->params, (size_t)module->params_size, NULL, 0);
  dt_dev_pixelpipe_or_changed(dev->pipe, DT_DEV_PIPE_TOP_CHANGED);
}
 
static void _delayed_history_commit(gpointer data)
{
  dt_develop_t *dev = (dt_develop_t *)data;
 
  /* Not while a shape is still being dragged. The throttle fires about once per pipe render,
   * which used to land a history commit -- and the resync it triggers -- in the middle of the
   * drag; the transient publish above is what feeds the pipe meanwhile, so the commit can wait
   * for the button to come up. Re-queueing re-arms the throttle; the pending module is left in
   * place so the eventual commit still lands on the owner of the interaction. */
  if(!IS_NULL_PTR(dev->form_gui) && dt_masks_gui_is_dragging(dev->form_gui))
  {
    dt_gui_throttle_queue(dev, _delayed_history_commit, dev);
    return;
  }
 
  dt_iop_module_t *module = _pending_mask_commit_module;
  _pending_mask_commit_module = NULL;
  // The captured module can be gone by now (image switch, instance removal): only trust it if
  // it is still a live member of dev->iop, else fall back to the current focus.
  if(IS_NULL_PTR(module) || IS_NULL_PTR(g_list_find(dev->iop, module)))
    module = dev->gui_module;
 
  // The interaction is over: drop the transient ticket so the pipe renders the committed
  // history state again. Cleared BEFORE the commit, whose resync must come from history --
  // and cleared even when nothing changed, so a no-op drag does not leave the slot occupied.
  const gboolean was_transient = !IS_NULL_PTR(module) && dt_dev_transient_params_active(dev, module);
  if(was_transient) dt_dev_transient_params_clear(module);
 
  // 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, module, FALSE, TRUE);
  else if(was_transient)
    // Nothing to commit, but the pipe was rendering from the transient slot: re-sync it from
    // history so it does not keep a render keyed to a slot that no longer exists.
    dt_dev_pixelpipe_update_history_main(dev);
}
 
// Queue the throttled mask-edit history commit, capturing its target module NOW. Every mask
// event handler must use this instead of calling dt_gui_throttle_queue() directly, so the
// commit lands on the module that owned the mask interaction, not on whichever module holds
// the focus when the throttle fires.
static void _queue_delayed_history_commit(dt_develop_t *dev)
{
  _pending_mask_commit_module = dev->gui_module;
  dt_gui_throttle_queue(dev, _delayed_history_commit, dev);
}
 
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 = dt_gui_get_global();
  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 = dt_gui_get_global();
  dt_control_t *ctl = dt_control_get_global();
  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(dt_view_manager_get_global()) != self
     || dt_dev_viewport_scaling(dev) <= 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 = dt_gui_get_global();
  dt_control_t *ctl = dt_control_get_global();
  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] = { dt_dev_viewport_center_x(dev) + delta[0] / (float)dt_dev_geometry_processed_width(dev),
                   dt_dev_viewport_center_y(dev) + delta[1] / (float)dt_dev_geometry_processed_height(dev)
                 };
  dt_dev_check_zoom_pos_bounds(dev, &roi[0], &roi[1], NULL, NULL);
 
  ctl->button_x = pointer_x;
  ctl->button_y = pointer_y;
 
  if(dt_dev_viewport_center_x(dev) != roi[0] || dt_dev_viewport_center_y(dev) != roi[1])
  {
    dt_dev_viewport_set_center(dev, roi[0], 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 = dt_gui_get_global();
  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_gui_center_widget();
  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 = dt_control_get_global();
  dt_gui_gtk_t *gui = dt_gui_get_global();
 
  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;
  gboolean masks_handled = FALSE;
 
  if(picker_active && dt_control_button_down(1))
  {
    // module requested a color box
    if(mouse_in_imagearea(self, x, y))
    {
      dt_colorpicker_sample_t *const sample = dt_dev_get_global()->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 / dt_dev_geometry_processed_width(dev),
        1.0f / dt_dev_geometry_processed_height(dev)
      };
 
      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(dt_lib_get_global(), 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(dt_lib_get_global(), 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, dev->gui_module, x, y, pressure, which))
  {
    masks_handled = TRUE;
    // There is no shape dragging in creation mode, so no need to commit history.
    if(!dev->form_gui->creation)
    {
      // A shape being dragged is re-rendered live from the transient slot on every motion;
      // hover motion changes no geometry and gets nothing. The history commit queued below
      // defers itself until the drag ends (see _delayed_history_commit).
      if(dt_masks_gui_is_dragging(dev->form_gui))
        _publish_mask_edit_transient(dev);
      _queue_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 && dt_control_button_down(1) && dt_dev_viewport_scaling(dev) > 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] = { dt_dev_viewport_center_x(dev) - (delta[0] / dt_dev_geometry_processed_width(dev)),
                     dt_dev_viewport_center_y(dev) - (delta[1] / dt_dev_geometry_processed_height(dev)) };
    dt_dev_check_zoom_pos_bounds(dev, &roi[0], &roi[1], NULL, NULL);
 
    dt_dev_viewport_set_center(dev, roi[0], roi[1]);
    ctl->button_x = x;
    ctl->button_y = y;
 
    dt_dev_pixelpipe_change_zoom_main(dev);
    return;
  }
 
  if(handled)
  {
    /* a motion the masks handled changed the overlay and nothing else: repaint what it touched,
     * not the image under the whole window */
    if(masks_handled)
      dt_masks_overlay_queue_redraw(dt_gui_center_widget());
    else
      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.
  // _darkroom_center_pan_drag is what makes this OUR drag: dt_control_button_down() reports the
  // device's state, so without it a button pressed elsewhere and still held on entry would pan
  // the image from a stale ctl->button_x/y anchor. The sibling path at :2563 always had this
  // guard; here it was implicit, back when button_down was set only by our own press handler.
  if(_darkroom_center_pan_drag && dt_control_button_down(1) && dt_dev_viewport_scaling(dev) > 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] = { dt_dev_viewport_center_x(dev) - (delta[0] / dt_dev_geometry_processed_width(dev)),
                     dt_dev_viewport_center_y(dev) - (delta[1] / dt_dev_geometry_processed_height(dev)) };
    dt_dev_check_zoom_pos_bounds(dev, &roi[0], &roi[1], NULL, NULL);
 
    dt_dev_viewport_set_center(dev, roi[0], 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(dt_dev_get_global()->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, dev->gui_module, x, y, which, state))
  {
    // Change on mask parameters and image output.
    _queue_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 = dt_dev_get_global()->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_gui_center_widget());
  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] /= dt_dev_geometry_processed_width(dev);
    handle[1] /= dt_dev_geometry_processed_height(dev);
 
    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)dt_dev_geometry_processed_width(dev) / (float)dt_dev_geometry_processed_height(dev);
 
        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(dt_lib_get_global(), 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(dt_lib_get_global(), 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 = dt_dev_get_global()->color_picker.picker;
      if(dt_dev_get_global()->color_picker.display_samples && mouse_in_imagearea(self, x, y))
        for(GSList *samples = dt_dev_get_global()->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(dt_lib_get_global(), 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] /= dt_dev_geometry_processed_width(dev);
            slop[1] /= dt_dev_geometry_processed_height(dev);
            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(dt_lib_get_global(), 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(dt_lib_get_global(), reset);
      }
      return 1;
    }
  }
 
  // masks
  if(dt_masks_get_visible_form(dev)
     && dt_masks_events_button_pressed(dev, dev->gui_module, x, y, pressure, which, type, state))
  {
    if(!dt_dev_get_global()->form_gui->creation)
      _queue_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 && dt_dev_viewport_scaling(dev) > 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(dt_dev_viewport_scaling(dev) < 1.f || dt_dev_viewport_scaling(dev) > 7.f / dt_dev_roi_request_natural_scale(dev))
      new_scale = 1.f; // zoom to fit
    else if(dt_dev_viewport_scaling(dev) * dt_dev_roi_request_natural_scale(dev) < 1.f)
      new_scale = 1.f / dt_dev_roi_request_natural_scale(dev); // 100 %
    else
      new_scale = floorf(dt_dev_viewport_scaling(dev) * dt_dev_roi_request_natural_scale(dev)) * 2.f / dt_dev_roi_request_natural_scale(dev);
 
    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 = dt_dev_viewport_scaling(dev);
 
  // Round scaling to 1.0 (fit) if close enough
  const float epsilon = fabsf(old_scaling - new_scaling);
  if(fabsf(new_scaling - 1.0f) < epsilon)
    dt_dev_viewport_set_scaling(dev, 1.0f);
  else
    dt_dev_viewport_set_scaling(dev, 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, dt_dev_viewport_scaling(dev));
    if(old_zoom <= 1e-6f || new_zoom <= 1e-6f)
    {
      dt_dev_viewport_set_scaling(dev, 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);
    const dt_dev_viewport_state_t anchored = dt_dev_viewport_get(dev);
    dt_dev_viewport_set_center(dev,
                               anchored.center_x + mouse_offset[0] * (1.f / old_zoom - 1.f / new_zoom) / proc_w,
                               anchored.center_y + mouse_offset[1] * (1.f / old_zoom - 1.f / new_zoom) / proc_h);
    
    dt_dev_clamp_viewport_center(dev);
    dt_dev_pixelpipe_change_zoom_main(dev);
    return 1;
  }
  else
  {
    // Invalid zoom level, keep previous value
    dt_dev_viewport_set_scaling(dev, 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 = dt_dev_get_global();
 
  // Commit the new scaling
  const float step = 1.02f;
  const float new_scaling = dt_dev_viewport_scaling(dev) * 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, dev->gui_module, x, y, up, state, delta_y))
  {
    dt_control_queue_redraw_center();
    if(!dev->form_gui->creation)
    {
      // Every scroll step changes the shape (size, feather or opacity) and is rendered live
      // from the transient slot at once; a burst of steps then lands ONE history commit when
      // the throttle fires after the last one, which also clears the slot. Scrolling has no
      // "release" the way a drag does, so the throttle is what marks the end of the burst.
      _publish_mask_edit_transient(dev);
      _queue_delayed_history_commit(dev);
    }
 
    return TRUE;
  }
 
  // module -- skip while the color picker overlay is active, consistent with button_pressed/
  // button_released/mouse_moved above, which all give the picker priority over the module.
  // Unlike those three, a module's own scrolled() has no reliable way to know the picker is
  // showing unless it checks dt_iop_color_picker_is_visible() itself, and not every module does.
  if(!dt_iop_color_picker_is_visible(dev)
     && 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_clamp_viewport_center(dev);
  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(dt_gui_get_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, dev->gui_module, event))
  {
    _queue_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))
  {
    _queue_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, DT_PRIMARY_MASK);
  const gboolean ctrl_any = dt_modifiers_include(event->state, DT_PRIMARY_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, dt_dev_viewport_scaling(dev) * zoom_step);
      case GDK_KEY_minus:
        return _change_scaling(dev, center, dt_dev_viewport_scaling(dev) / 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:
    {
      dt_dev_viewport_set_center(dev, dt_dev_viewport_center_x(dev),
                                 dt_dev_viewport_center_y(dev)
                                     - delta[1] / (float)dt_dev_geometry_processed_height(dev));
      _key_scroll(dev);
      return 1;
    }
    case GDK_KEY_Down:
    {
      dt_dev_viewport_set_center(dev, dt_dev_viewport_center_x(dev),
                                 dt_dev_viewport_center_y(dev)
                                     + delta[1] / (float)dt_dev_geometry_processed_height(dev));
      _key_scroll(dev);
      return 1;
    }
    case GDK_KEY_Left:
    {
      dt_dev_viewport_set_center(dev, dt_dev_viewport_center_x(dev)
                                     - delta[0] / (float)dt_dev_geometry_processed_width(dev),
                                 dt_dev_viewport_center_y(dev));
      _key_scroll(dev);
      return 1;
    }
    case GDK_KEY_Right:
    {
      dt_dev_viewport_set_center(dev, dt_dev_viewport_center_x(dev)
                                     + delta[0] / (float)dt_dev_geometry_processed_width(dev),
                                 dt_dev_viewport_center_y(dev));
      _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(dt_view_manager_get_global()) == self)
  {
    // Reference dimensions before ISO 12646 mode
    dt_dev_viewport_set_widget_size(dev, wd, ht);
    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