navigation.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2009-2012, 2016, 2018 johannes hanika.
    Copyright (C) 2010-2012 Henrik Andersson.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2012-2014, 2016-2017 Tobias Ellinghaus.
    Copyright (C) 2013, 2015, 2019-2020 Aldric Renaudin.
    Copyright (C) 2013 Josef Wells.
    Copyright (C) 2013 Pascal de Bruijn.
    Copyright (C) 2013-2016 Roman Lebedev.
    Copyright (C) 2014 parafin.
    Copyright (C) 2014-2015 Ulrich Pegelow.
    Copyright (C) 2016 Asma.
    Copyright (C) 2018 Maurizio Paglia.
    Copyright (C) 2018-2021 Pascal Obry.
    Copyright (C) 2018 rawfiner.
    Copyright (C) 2018 Sam Smith.
    Copyright (C) 2019 Alexis Mousset.
    Copyright (C) 2019, 2023, 2025-2026 Aurélien PIERRE.
    Copyright (C) 2019 Edgardo Hoszowski.
    Copyright (C) 2019 yuri1969.
    Copyright (C) 2020 Chris Elston.
    Copyright (C) 2020 Hubert Kowalski.
    Copyright (C) 2021 Dan Torop.
    Copyright (C) 2021-2022 Diederik Ter Rahe.
    Copyright (C) 2021 Hanno Schwalm.
    Copyright (C) 2021 Paolo DePetrillo.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2023 Alynx Zhou.
    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 "widgets/bauhaus.h"
#include "system/macros.h"
#include "common/module_versioning.h"
#include "common/times.h"
#include "common/hash.h"
#include "control/control.h"
#include "caches/pixelpipe_cache.h"
#include "develop/dev_pixelpipe.h"
#include "develop/develop.h"
 
#include "libs/lib.h"
#include "libs/lib_api.h"
#include "gui/window_manager.h"
#include "widgets/popup.h"
#include "widgets/scroll_wrap.h"
#include "gui/screen_metrics.h"
#include "control/signal.h"
 
DT_MODULE(1)
 
#define DT_NAVIGATION_INSET 5
 
typedef struct dt_lib_navigation_t
{
  GtkWidget *area;    // the drawing area (self->widget is the resizable wrapper around it)
  int dragging;
  int zoom_w, zoom_h; // size of the zoom button
  cairo_surface_t *image_surface;   // the preview frame, scaled to the widget
  /* The whole picture this widget shows -- background, thumbnail, viewport box, zoom label,
   * arrow -- composed once per state and blitted on every later expose. Keyed on everything it
   * depends on (_lib_navigation_picture_key()): an expose that changes none of it costs one
   * blit, where it used to cost a fresh full-size surface, a background render, a pango layout
   * and the thumbnail copy. Such exposes are the rule, not the exception: the resize grip
   * floating over this area is translucent, so GTK repaints what lies under it every time the
   * grip is hovered, and a panel that moved redraws the whole window with it. */
  cairo_surface_t *composed;
  uint64_t composed_key;
  int composed_width;
  int composed_height;
  dt_dev_pixelpipe_cache_wait_t preview_wait;
} dt_lib_navigation_t;
 
typedef enum dt_lib_zoom_t
{
  LIB_ZOOM_SMALL = 0,
  LIB_ZOOM_FIT,
  LIB_ZOOM_25,
  LIB_ZOOM_33,
  LIB_ZOOM_50,
  LIB_ZOOM_100,
  LIB_ZOOM_200,
  LIB_ZOOM_400,
  LIB_ZOOM_800,
  LIB_ZOOM_1600,
  LIB_ZOOM_LAST
} dt_lib_zoom_t;
 
 
/* expose function for navigation module */
static gboolean _lib_navigation_draw_callback(GtkWidget *widget, cairo_t *crf, gpointer user_data);
/* motion notify callback handler*/
static gboolean _lib_navigation_motion_notify_callback(GtkWidget *widget, GdkEventMotion *event,
                                                       gpointer user_data);
/* button press callback */
static gboolean _lib_navigation_button_press_callback(GtkWidget *widget, GdkEventButton *event,
                                                      gpointer user_data);
/* button release callback */
static gboolean _lib_navigation_button_release_callback(GtkWidget *widget, GdkEventButton *event,
                                                        gpointer user_data);
/* leave notify callback */
static gboolean _lib_navigation_leave_notify_callback(GtkWidget *widget, GdkEventCrossing *event,
                                                      gpointer user_data);
 
/* helper function for position set */
static void _lib_navigation_set_position(struct dt_lib_module_t *self, double x, double y, int alloc_wd, int alloc_ht);
 
const char *name(struct dt_lib_module_t *self)
{
  return _("navigation");
}
 
const char **views(dt_lib_module_t *self)
{
  static const char *v[] = {"darkroom", NULL};
  return v;
}
 
uint32_t container(dt_lib_module_t *self)
{
  return DT_UI_CONTAINER_PANEL_LEFT_TOP;
}
 
int expandable(dt_lib_module_t *self)
{
  return 0;
}
 
int position()
{
  return 1001;
}
 
 
static void _lib_navigation_control_redraw_callback(gpointer instance, gpointer user_data)
{
  (void)instance;
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  dt_lib_navigation_t *d = (dt_lib_navigation_t *)self->data;
  dt_control_queue_redraw_widget(d->area);
}
 
static void _lib_navigation_restart_cache_wait(gpointer user_data)
{
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  if(IS_NULL_PTR(self)) return;
  dt_lib_navigation_t *d = (dt_lib_navigation_t *)self->data;
  dt_control_queue_redraw_widget(d->area);
}
 
static void _lib_navigation_history_resync_callback(gpointer instance, gpointer user_data)
{
  (void)instance;
 
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  dt_lib_navigation_t *d = (dt_lib_navigation_t *)self->data;
  dt_develop_t *dev = dt_dev_get_global();
  if(IS_NULL_PTR(d) || IS_NULL_PTR(dev) || IS_NULL_PTR(dev->preview_pipe)) return;
 
  dt_dev_pixelpipe_cache_wait_set_owner(&d->preview_wait, "navigation-preview", self);
  if(dt_dev_pixelpipe_cache_peek_gui(dev->preview_pipe, NULL, NULL, NULL, &d->preview_wait,
                                     _lib_navigation_restart_cache_wait, self))
    dt_control_queue_redraw_widget(d->area);
}
 
 
void gui_init(dt_lib_module_t *self)
{
  /* initialize ui widgets */
  dt_lib_navigation_t *d = (dt_lib_navigation_t *)g_malloc0(sizeof(dt_lib_navigation_t));
  self->data = (void *)d;
  d->image_surface = NULL;
 
  /* create drawingarea */
  d->area = gtk_drawing_area_new();
  gtk_widget_set_events(d->area, GDK_EXPOSURE_MASK | GDK_ENTER_NOTIFY_MASK
                                      | GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK
                                      | GDK_BUTTON_RELEASE_MASK | GDK_STRUCTURE_MASK);
 
  /* connect callbacks */
  gtk_widget_set_app_paintable(d->area, TRUE);
  g_signal_connect(G_OBJECT(d->area), "draw", G_CALLBACK(_lib_navigation_draw_callback), self);
  g_signal_connect(G_OBJECT(d->area), "button-press-event",
                   G_CALLBACK(_lib_navigation_button_press_callback), self);
  g_signal_connect(G_OBJECT(d->area), "button-release-event",
                   G_CALLBACK(_lib_navigation_button_release_callback), self);
  g_signal_connect(G_OBJECT(d->area), "motion-notify-event",
                   G_CALLBACK(_lib_navigation_motion_notify_callback), self);
  g_signal_connect(G_OBJECT(d->area), "leave-notify-event",
                   G_CALLBACK(_lib_navigation_leave_notify_callback), self);
 
  gtk_widget_set_name(GTK_WIDGET(d->area), "navigation-module");
 
  /* make the navigation preview vertically resizable, persisting its height */
  self->widget = dt_ui_resizable_drawing_area(d->area, "plugins/darkroom/navigation/height", 175, 100);
 
  /* connect redraw callbacks to targeted preview cache publication and explicit redraw requests */
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_HISTORY_RESYNC,
                            G_CALLBACK(_lib_navigation_history_resync_callback), self);
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_CONTROL_NAVIGATION_REDRAW,
                            G_CALLBACK(_lib_navigation_control_redraw_callback), self);
 
  dt_lib_get_global()->proxy.navigation.module = self;
}
 
void gui_cleanup(dt_lib_module_t *self)
{
  if(IS_NULL_PTR(self->data)) return;
  dt_lib_navigation_t *d = (dt_lib_navigation_t *)self->data;
 
  /* disconnect from signal */
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_lib_navigation_control_redraw_callback), self);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_lib_navigation_history_resync_callback), self);
  dt_dev_pixelpipe_cache_wait_cleanup(&d->preview_wait, "navigation-gui-cleanup");
 
  if(!IS_NULL_PTR(d->image_surface)) cairo_surface_destroy(d->image_surface);
  d->image_surface = NULL;
  if(!IS_NULL_PTR(d->composed)) cairo_surface_destroy(d->composed);
  d->composed = NULL;
 
  dt_free(self->data);
}
 
void gui_reset(dt_lib_module_t *self)
{
  dt_lib_navigation_t *d = (dt_lib_navigation_t *)self->data;
  if(!IS_NULL_PTR(d->image_surface)) cairo_surface_destroy(d->image_surface);
  d->image_surface = NULL;
}
 
/* Everything the picture this widget shows depends on, folded into one key: the preview frame,
 * the widget's size, the image, the viewport (zoom, pan, box, border) and the preview's plan.
 * Equal keys are equal pictures. */
static uint64_t _lib_navigation_picture_key(const dt_develop_t *dev, const int width, const int height,
                                            const gboolean has_preview_image)
{
  uint64_t key = has_preview_image ? dt_dev_backbuf_get_hash(&dev->preview_pipe->backbuf) : 0;
  key = dt_hash(key, (const char *)&width, sizeof(width));
  key = dt_hash(key, (const char *)&height, sizeof(height));
  key = dt_hash(key, (const char *)&has_preview_image, sizeof(has_preview_image));
  const int32_t imgid = dev->image_storage.id;
  key = dt_hash(key, (const char *)&imgid, sizeof(imgid));
  // padding-free, hashed whole the way the darkroom keys its own composition
  const dt_dev_viewport_state_t viewport = dt_dev_viewport_get(dev);
  key = dt_hash(key, (const char *)&viewport, sizeof(viewport));
  const float natural_scale = dt_dev_roi_request_natural_scale(dev);
  key = dt_hash(key, (const char *)&natural_scale, sizeof(natural_scale));
  const int preview_width = dt_dev_roi_request_preview_width(dev);
  const int preview_height = dt_dev_roi_request_preview_height(dev);
  key = dt_hash(key, (const char *)&preview_width, sizeof(preview_width));
  key = dt_hash(key, (const char *)&preview_height, sizeof(preview_height));
  return key;
}
 
/* Compose the picture for @p key into a fresh surface and make it the current one. Returns
 * FALSE, leaving the previous picture in place, when the preview frame cannot be read yet. */
static gboolean _lib_navigation_compose(GtkWidget *widget, dt_lib_module_t *self, dt_develop_t *dev,
                                        const int width, const int height, const gboolean has_preview_image,
                                        const uint64_t key)
{
  dt_lib_navigation_t *d = (dt_lib_navigation_t *)self->data;
 
  static uint64_t image_hash = -1;
  static int wd = 0;
  static int ht = 0;
  static float scale = 1.f;
  static int32_t imgid = UNKNOWN_IMAGE;
 
  const gboolean changed = (d->composed_width != width) || (d->composed_height != height);
 
  cairo_surface_t *target = dt_cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
  cairo_t *cr = cairo_create(target);
  GtkStyleContext *context = gtk_widget_get_style_context(widget);
  gtk_render_background(context, cr, 0, 0, width, height);
  cairo_save(cr);
  
  if(has_preview_image
     && (!d->image_surface || image_hash != dt_dev_backbuf_get_hash(&dev->preview_pipe->backbuf) || changed))
  {
    if(d->image_surface) cairo_surface_destroy(d->image_surface);
    d->image_surface = dt_cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
 
    // Fetch the backbuffer. The preview pipe backbuffer already owns the cache keepalive ref:
    // navigation only needs a short read-only critical section while it copies into its own cairo surface.
    struct dt_pixel_cache_entry_t *cache_entry = NULL;
    void *data = NULL;
    dt_dev_pixelpipe_cache_wait_set_owner(&d->preview_wait, "navigation-preview", self);
    if(!dt_dev_pixelpipe_cache_peek_gui(dev->preview_pipe, NULL, &data, &cache_entry, &d->preview_wait,
                                        _lib_navigation_restart_cache_wait, self))
    {
      /* the frame is not published yet: the wait above redraws when it is, and until then the
       * previous picture stands (this used to return with the surface and its context leaked) */
      cairo_destroy(cr);
      cairo_surface_destroy(target);
      return FALSE;
    }
 
    dt_dev_pixelpipe_cache_rdlock_entry(TRUE, cache_entry);
 
    /* One read of the publication: the cacheline just resolved and the shape its pixels are in
     * have to come from the same frame, or the stride below is computed from the next frame's
     * width and this paints diagonal striping. See dt_backbuf_t. */
    const dt_backbuf_state_t published = dt_dev_backbuf_snapshot(&dev->preview_pipe->backbuf);
    wd = published.width;
    ht = published.height;
    const int stride = cairo_format_stride_for_width(CAIRO_FORMAT_RGB24, wd);
 
    /* Can this cacheline hold an image of those dimensions at all?
     *
     * The centre view asks the same question before it paints (dt_dev_lock_pipe_surface); this
     * widget did not, and handed cairo a buffer to walk with a stride computed from a width the
     * data need not have. When they disagree the thumbnail is striped diagonally, and the read
     * runs past the allocation whenever the recorded dimensions are the larger pair.
     *
     * The way they came to disagree -- a hash resolved from one publication paired with
     * dimensions from the next -- is closed by the snapshot above. This stays because it answers
     * a different question: whether the cacheline this hash names is big enough at all, which
     * neither the snapshot nor the cache can tell. Keep the previous thumbnail and come back on
     * the next expose rather than draw garbage. */
    const size_t required_size = (size_t)stride * (size_t)ht;
    if(wd <= 0 || ht <= 0 || dt_pixel_cache_entry_get_size(cache_entry) < required_size
       || dt_pixel_cache_entry_get_data(cache_entry) != data)
    {
      dt_dev_pixelpipe_cache_rdlock_entry(FALSE, cache_entry);
      cairo_destroy(cr);
      cairo_surface_destroy(target);
      return FALSE;
    }
 
    scale = fminf(width / (float)wd, height / (float)ht);
    cairo_surface_t *tmp_surface = cairo_image_surface_create_for_data(data, CAIRO_FORMAT_RGB24, wd, ht, stride);
 
    image_hash = published.hash;
 
    cairo_t *cri = cairo_create(d->image_surface);
    cairo_rectangle(cri, 0, 0, width, height);
    cairo_translate(cri, width / 2., height / 2.);
    cairo_scale(cri, scale, scale);
    cairo_translate(cri, -wd / 2., -ht / 2.);
    cairo_set_source_surface(cri, tmp_surface, 0, 0);
    cairo_fill(cri);
    cairo_surface_destroy(tmp_surface);
    cairo_destroy(cri);
 
    dt_dev_pixelpipe_cache_rdlock_entry(FALSE, cache_entry);
 
    imgid = dev->image_storage.id;
  }
  else
  {
    wd = dt_dev_roi_request_preview_width(dev);
    ht = dt_dev_roi_request_preview_height(dev);
  }
 
  if(d->image_surface && imgid == dev->image_storage.id)
  {
    cairo_rectangle(cr, 0, 0, width, height);
    cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_NEAREST);
    cairo_set_source_surface(cr, d->image_surface, 0, 0);
    cairo_fill(cr);
  }
 
  cairo_translate(cr, width / 2., height / 2.);
  cairo_scale(cr, scale, scale);
  cairo_translate(cr, -wd / 2., -ht / 2.);
 
  // Calculate the thickness in user space (not affected by scale)
  double line_width = DT_PIXEL_APPLY_DPI(1);
  {
    double dx = line_width, dy = 0;
    cairo_device_to_user_distance(cr, &dx, &dy);
    line_width = dx;
  }
 
  // draw box where we are
  if(dt_dev_viewport_scaling(dev) > 1.f)
  {
    // Add a dark overlay on the picture to make it fade
    cairo_rectangle(cr, 0, 0, wd, ht);
    cairo_set_source_rgba(cr, 0, 0, 0, 0.5);
 
    // clip dimensions to navigation area
    float boxw = 1, boxh = 1;
    // Reads the box; the centre clamp it also performed is kept, because removing a
    // mutation from a paint handler is a behaviour change that belongs with the setter work,
    // not with the relocation.
    float clamped_x = dt_dev_viewport_center_x(dev);
    float clamped_y = dt_dev_viewport_center_y(dev);
    dt_dev_check_zoom_pos_bounds(dev, &clamped_x, &clamped_y, &boxw, &boxh);
    dt_dev_viewport_set_center(dev, clamped_x, clamped_y);
    const float roi_w = MIN(boxw * wd, wd);
    const float roi_h = MIN(boxh * ht, ht);
    const float roi_x = dt_dev_viewport_center_x(dev) * wd - roi_w * 0.5f;
    const float roi_y = dt_dev_viewport_center_y(dev) * ht - roi_h * 0.5f;
    cairo_rectangle(cr, roi_x - 1, roi_y - 1, roi_w + 2, roi_h + 2);
 
    /* Use even–odd rule to punch the hole */
    cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);
    cairo_fill(cr);
 
    cairo_set_fill_rule(cr, CAIRO_FILL_RULE_WINDING);
 
    // Paint the external border in black
    cairo_set_source_rgb(cr, 0., 0., 0.);
    cairo_set_line_width(cr, line_width);
    cairo_stroke(cr);
 
    // Paint the internal border in white
    cairo_set_source_rgb(cr, 1., 1., 1.);
    cairo_rectangle(cr, roi_x, roi_y, roi_w, roi_h);
    cairo_stroke(cr);
  }
  else
  {
    // draw a simple border
    cairo_set_source_rgb(cr, 1., 1., 1.);
    cairo_set_line_width(cr, line_width);
    cairo_rectangle(cr, 0.5, 0.5, wd - 1, ht - 1);
    cairo_stroke(cr);
  }
 
  cairo_restore(cr);
 
  /* Zoom % */
  PangoLayout *layout;
  PangoRectangle logic;
  PangoFontDescription *desc = pango_font_description_copy_static(dt_bauhaus_get_global()->pango_font_desc);
  pango_font_description_set_weight(desc, PANGO_WEIGHT_BOLD);
  layout = pango_cairo_create_layout(cr);
  const float fontsize = DT_PIXEL_APPLY_DPI(14);
  pango_font_description_set_absolute_size(desc, fontsize * PANGO_SCALE);
  pango_layout_set_font_description(layout, desc);
 
  // translate to left bottom corner
  cairo_translate(cr, 0, height);
  cairo_set_source_rgba(cr, 1., 1., 1., 0.5);
  cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND);
 
  gchar *zoomline;
  {
    gchar *fit = NULL;
    if(dt_dev_viewport_scaling(dev) == 1.f)
      fit = g_strdup(_("Fit"));
  
    zoomline = g_strdup_printf("%s %.0f%%", fit ? fit : "", dt_dev_viewport_scaling(dev) * dt_dev_roi_request_natural_scale(dev) * 100);
    if(fit)
    {
      dt_free(fit);
    }
  }
 
  pango_layout_set_text(layout, zoomline, -1);
  dt_free(zoomline);
  pango_layout_get_pixel_extents(layout, NULL, &logic);
  d->zoom_h = logic.height;
  d->zoom_w = logic.width;
  const double h = d->zoom_h;
  const double w = d->zoom_w;
  const int xp = width - w - h - logic.x;
  const int yp = - logic.height;
 
  cairo_move_to(cr, xp, yp);
  cairo_save(cr);
  cairo_set_line_width(cr, DT_PIXEL_APPLY_DPI(1));
 
  GdkRGBA *color;
  gtk_style_context_get(context, gtk_widget_get_state_flags(widget), "background-color", &color, NULL);
 
  gdk_cairo_set_source_rgba(cr, color);
  pango_cairo_layout_path(cr, layout);
  cairo_stroke_preserve(cr);
  cairo_set_source_rgb(cr, 0.8, 0.8, 0.8);
  cairo_fill(cr);
 
  cairo_restore(cr);
 
  gdk_rgba_free(color);
  pango_font_description_free(desc);
  g_object_unref(layout);
 
  const float arrow_h = fontsize;
 
  /* draw the drop-down arrow for zoom menu */
  cairo_move_to(cr, width - 0.95 * arrow_h, -0.9 * arrow_h - 2);
  cairo_line_to(cr, width - 0.05 * arrow_h, -0.9 * arrow_h - 2);
  cairo_line_to(cr, width - 0.5 * arrow_h, -0.1 * arrow_h - 2);
  cairo_fill(cr);
 
 
  cairo_destroy(cr);
  if(!IS_NULL_PTR(d->composed)) cairo_surface_destroy(d->composed);
  d->composed = target;
  d->composed_key = key;
  d->composed_width = width;
  d->composed_height = height;
  return TRUE;
}
 
static gboolean _lib_navigation_draw_callback(GtkWidget *widget, cairo_t *crf, gpointer user_data)
{
  dt_times_t start;
  dt_get_times(&start);
 
  dt_develop_t *dev = dt_dev_get_global();
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  dt_lib_navigation_t *d = (dt_lib_navigation_t *)self->data;
 
  GtkAllocation allocation;
  gtk_widget_get_allocation(widget, &allocation);
  const int width = allocation.width;
  const int height = allocation.height;
 
  const gboolean has_preview_image = dt_dev_pixelpipe_is_backbufer_valid(dev->preview_pipe);
  const uint64_t key = _lib_navigation_picture_key(dev, width, height, has_preview_image);
 
  gboolean composed = FALSE;
  if(IS_NULL_PTR(d->composed) || d->composed_key != key || d->composed_width != width
     || d->composed_height != height)
    composed = _lib_navigation_compose(widget, self, dev, width, height, has_preview_image, key);
 
  if(!IS_NULL_PTR(d->composed))
  {
    cairo_set_source_surface(crf, d->composed, 0, 0);
    cairo_paint(crf);
  }
 
  /* The clip says who asked: the whole widget is a request of this module's own, a strip along
   * an edge is the grip floating over it, hovered. */
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    double x1 = 0.0;
    double y1 = 0.0;
    double x2 = 0.0;
    double y2 = 0.0;
    cairo_clip_extents(crf, &x1, &y1, &x2, &y2);
    dt_show_times_f(&start, "[navigation]", "redraw: %s, clip %.0fx%.0f at %.0f,%.0f of %dx%d",
                    composed ? "composed" : "cached", x2 - x1, y2 - y1, x1, y1, width, height);
  }
 
  return TRUE;
}
 
static void _lib_navigation_set_position(dt_lib_module_t *self, double x, double y, int alloc_wd, int alloc_ht)
{
  dt_develop_t *dev = dt_dev_get_global();
  const dt_lib_navigation_t *d = (const dt_lib_navigation_t *)self->data;
  if(!(dev && d->dragging && dt_dev_viewport_scaling(dev) > 1.f)) return;
 
  // Compute size of navigation ROI in widget coordinates
  int proc_wd, proc_ht;
  dt_dev_get_processed_size(dev, &proc_wd, &proc_ht);
  const float nav_img_scale = fminf(alloc_wd / (float)proc_wd, alloc_ht / (float)proc_ht);
  const int nav_img_w = (int)((float)proc_wd * nav_img_scale);
  const int nav_img_h = (int)((float)proc_ht * nav_img_scale);
  
  // Correct widget coordinates for margins
  float fx = x - (alloc_wd - nav_img_w) * 0.5f;
  float fy = y - (alloc_ht - nav_img_h) * 0.5f;
 
  // Convert widget coordinates to relative coordinates within navigation ROI
  // and commit relative coordinates of the ROI center
  fx /= (float)nav_img_w;
  fy /= (float)nav_img_h;
  dt_dev_check_zoom_pos_bounds(dev, &fx, &fy, NULL, NULL);
 
  dt_dev_viewport_set_center(dev, fx, fy);
 
  /* redraw myself */
  gtk_widget_queue_draw(d->area);
 
  /* redraw pipe */
  dt_dev_pixelpipe_change_zoom_main(dt_dev_get_global());
}
 
static gboolean _lib_navigation_motion_notify_callback(GtkWidget *widget, GdkEventMotion *event,
                                                       gpointer user_data)
{
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  GtkAllocation allocation;
  gtk_widget_get_allocation(widget, &allocation);
  _lib_navigation_set_position(self, event->x, event->y, allocation.width, allocation.height);
  return TRUE;
}
 
static void _zoom_preset_change(dt_lib_zoom_t zoom)
{
  dt_develop_t *dev = dt_dev_get_global();
  if(IS_NULL_PTR(dev)) return;
 
  switch(zoom)
  {
    default:
      dt_dev_viewport_set_scaling(dev, dt_dev_roi_request_natural_scale(dev));
      break;
    case LIB_ZOOM_SMALL:
      dt_dev_viewport_set_scaling(dev, dt_dev_roi_request_natural_scale(dev) * 0.33);
      break;
    case LIB_ZOOM_FIT:
      dt_dev_viewport_set_scaling(dev, dt_dev_roi_request_natural_scale(dev));
      break;
    case LIB_ZOOM_25:
      dt_dev_viewport_set_scaling(dev, 0.25);
      break;
    case LIB_ZOOM_33:
      dt_dev_viewport_set_scaling(dev, 0.33);
      break;
    case LIB_ZOOM_50:
      dt_dev_viewport_set_scaling(dev, 0.50);
      break;
    case LIB_ZOOM_100:
      dt_dev_viewport_set_scaling(dev, 1.);
      break;
    case LIB_ZOOM_200:
      dt_dev_viewport_set_scaling(dev, 2.);
      break;
    case LIB_ZOOM_400:
      dt_dev_viewport_set_scaling(dev, 4.);
      break;
    case LIB_ZOOM_800:
      dt_dev_viewport_set_scaling(dev, 8.);
      break;
    case LIB_ZOOM_1600:
      dt_dev_viewport_set_scaling(dev, 16.);
      break;
  }
 
  // Actual pixelpipe scaling is dt_dev_viewport_scaling(dev) * dt_dev_roi_request_natural_scale(dev),
  // where dt_dev_roi_request_natural_scale(dev) ensures the image fits within the viewport.
  dt_dev_viewport_set_scaling(dev, dt_dev_viewport_scaling(dev) / dt_dev_roi_request_natural_scale(dev));
 
  dt_dev_clamp_viewport_center(dev);
  dt_dev_pixelpipe_change_zoom_main(dev);
}
 
static void _zoom_preset_callback(GtkButton *button, gpointer user_data)
{
  _zoom_preset_change(GPOINTER_TO_INT(user_data));
}
 
static gboolean _lib_navigation_button_press_callback(GtkWidget *widget, GdkEventButton *event,
                                                      gpointer user_data)
{
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  dt_lib_navigation_t *d = (dt_lib_navigation_t *)self->data;
 
  GtkAllocation allocation;
  gtk_widget_get_allocation(widget, &allocation);
  int w = allocation.width;
  int h = allocation.height;
  if(event->x >= w - DT_NAVIGATION_INSET - d->zoom_h - d->zoom_w
     && event->y >= h - DT_NAVIGATION_INSET - d->zoom_h)
  {
    // we show the zoom menu
    GtkMenuShell *menu = GTK_MENU_SHELL(gtk_menu_new());
    GtkWidget *item;
 
    item = gtk_menu_item_new_with_label(_("Small"));
    g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(_zoom_preset_callback), GINT_TO_POINTER(LIB_ZOOM_SMALL));
    gtk_menu_shell_append(menu, item);
 
    item = gtk_menu_item_new_with_label(_("Fit to screen"));
    g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(_zoom_preset_callback), GINT_TO_POINTER(LIB_ZOOM_FIT));
    gtk_menu_shell_append(menu, item);
 
    item = gtk_menu_item_new_with_label(_("25%"));
    g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(_zoom_preset_callback), GINT_TO_POINTER(LIB_ZOOM_25));
    gtk_menu_shell_append(menu, item);
 
    item = gtk_menu_item_new_with_label(_("33%"));
    g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(_zoom_preset_callback), GINT_TO_POINTER(LIB_ZOOM_33));
    gtk_menu_shell_append(menu, item);
 
    item = gtk_menu_item_new_with_label(_("50%"));
    g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(_zoom_preset_callback), GINT_TO_POINTER(LIB_ZOOM_50));
    gtk_menu_shell_append(menu, item);
 
    item = gtk_menu_item_new_with_label(_("100%"));
    g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(_zoom_preset_callback), GINT_TO_POINTER(LIB_ZOOM_100));
    gtk_menu_shell_append(menu, item);
 
    item = gtk_menu_item_new_with_label(_("200%"));
    g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(_zoom_preset_callback), GINT_TO_POINTER(LIB_ZOOM_200));
    gtk_menu_shell_append(menu, item);
 
    item = gtk_menu_item_new_with_label(_("400%"));
    g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(_zoom_preset_callback), GINT_TO_POINTER(LIB_ZOOM_400));
    gtk_menu_shell_append(menu, item);
 
    item = gtk_menu_item_new_with_label(_("800%"));
    g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(_zoom_preset_callback), GINT_TO_POINTER(LIB_ZOOM_800));
    gtk_menu_shell_append(menu, item);
 
    item = gtk_menu_item_new_with_label(_("1600%"));
    g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(_zoom_preset_callback), GINT_TO_POINTER(LIB_ZOOM_1600));
    gtk_menu_shell_append(menu, item);
 
    dt_gui_menu_popup(GTK_MENU(menu), NULL, 0, 0);
 
    return TRUE;
  }
 
  d->dragging = 1;
  _lib_navigation_set_position(self, event->x, event->y, w, h);
  return TRUE;
}
 
static gboolean _lib_navigation_button_release_callback(GtkWidget *widget, GdkEventButton *event,
                                                        gpointer user_data)
{
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  dt_lib_navigation_t *d = (dt_lib_navigation_t *)self->data;
  d->dragging = 0;
 
  return TRUE;
}
 
static gboolean _lib_navigation_leave_notify_callback(GtkWidget *widget, GdkEventCrossing *event,
                                                      gpointer user_data)
{
  return TRUE;
}
 
// 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