thumbtable.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2020-2022 Aldric Renaudin.
    Copyright (C) 2020 Bill Ferguson.
    Copyright (C) 2020 Chris Elston.
    Copyright (C) 2020-2022 Diederik Ter Rahe.
    Copyright (C) 2020, 2022 Hanno Schwalm.
    Copyright (C) 2020 Heiko Bauke.
    Copyright (C) 2020 Hubert Kowalski.
    Copyright (C) 2020-2021 Pascal Obry.
    Copyright (C) 2020, 2022 Philippe Weyland.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2021 Dan Torop.
    Copyright (C) 2021 domosbg.
    Copyright (C) 2021 Erkan Ozgur Yilmaz.
    Copyright (C) 2021 Fabio Heer.
    Copyright (C) 2021 luzpaz.
    Copyright (C) 2022-2023, 2025-2026 Aurélien PIERRE.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2022 Miloš Komarčević.
    Copyright (C) 2022 Nicolas Auffray.
    Copyright (C) 2022 solarer.
    Copyright (C) 2022 Victor Forsiuk.
    Copyright (C) 2023 Luca Zulberti.
    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 "common/image_extensions.h"
#include "common/paths.h"   // DT_PATH_MAX
#include "database/collection_query.h"
#include "common/act_on.h"
#include "control/settings.h"
#include "common/conf.h"
#include "control/jobs/control_jobs.h"
#include "widgets/gdkkeys.h"
#include "gui/dtgtk/thumbtable.h"
#include "gui/dtgtk/thumbtable_internal.h"
#include "gui/dtgtk/thumbnail.h"
#include "gui/dtgtk/thumbtable_info.h"
#include "common/collection.h"
#include "history/history.h"
#include "caches/image_cache.h"
#include "database/image_repository.h"
#include "common/hash.h"
#include "common/selection.h"
#include "common/times.h"
#include "common/usermanual_url.h"
#include "common/utility.h"
#include "control/control.h"
#include "control/jobs/import_jobs.h"
 
#include "widgets/accelerators.h"
#include "widgets/widget_settings.h"
#include "gui/drag_and_drop.h"
#include "views/view.h"
#include "widgets/bauhaus.h"
#include "gui/import.h"
 
#ifdef GDK_WINDOWING_QUARTZ
#include "osx/osx.h"
#endif
 
#include <glib-object.h>
#include <math.h>
#include <glib.h>
#include "gui/application.h"
#include "widgets/widget_style.h"
#include "common/glib_utils.h"
 
 
static gboolean _thumbtable_clone_lut(dt_thumbtable_t *dst)
{
  if(IS_NULL_PTR(dst) || IS_NULL_PTR(dt_gui_get_global()) || IS_NULL_PTR(dt_gui_get_ui())) return FALSE;
 
  dt_thumbtable_t *src = NULL;
  if(dt_gui_get_ui()->thumbtable_lighttable == dst)
    src = dt_gui_get_ui()->thumbtable_filmstrip;
  else if(dt_gui_get_ui()->thumbtable_filmstrip == dst)
    src = dt_gui_get_ui()->thumbtable_lighttable;
 
  if(IS_NULL_PTR(src) || src == dst) return FALSE;
 
  dt_pthread_mutex_lock(&src->lock);
  const gboolean can_clone = (src->lut
                              && src->collection_inited
                              && src->collection_hash == dst->collection_hash
                              && src->collapse_groups == dst->collapse_groups
                              && src->collection_count > 0);
  if(!can_clone)
  {
    dt_pthread_mutex_unlock(&src->lock);
    return FALSE;
  }
 
  const uint32_t count = src->collection_count;
  dt_thumbtable_cache_t *cloned_lut = malloc(count * sizeof(dt_thumbtable_cache_t));
  if(IS_NULL_PTR(cloned_lut))
  {
    dt_pthread_mutex_unlock(&src->lock);
    return FALSE;
  }
 
  memcpy(cloned_lut, src->lut, count * sizeof(dt_thumbtable_cache_t));
  dt_pthread_mutex_unlock(&src->lock);
 
  for(uint32_t i = 0; i < count; i++)
    cloned_lut[i].thumb = NULL;
 
  dt_thumbtable_cache_t *old_lut = NULL;
  dt_pthread_mutex_lock(&dst->lock);
  old_lut = dst->lut;
  dst->lut = cloned_lut;
  dst->collection_count = count;
  dst->collection_inited = TRUE;
  dt_pthread_mutex_unlock(&dst->lock);
 
  dt_free(old_lut);
  return TRUE;
}
 
void _dt_thumbtable_empty_list(dt_thumbtable_t *table);
 
static gboolean _thumbtable_idle_update(gpointer user_data);
static void _thumbtable_schedule_update(dt_thumbtable_t *table);
static void _scrollbar_value_changed(GtkAdjustment *adjustment, gpointer user_data);
static void _scrollbar_page_size_notify(GObject *object, GParamSpec *pspec, gpointer user_data);
static void _parent_overlay_size_allocate(GtkWidget *widget, GtkAllocation *allocation, gpointer user_data);
static void _scrollbar_widget_size_allocate(GtkWidget *widget, GtkAllocation *allocation, gpointer user_data);
 
static gint _thumb_compare_rowid_desc(gconstpointer a, gconstpointer b)
{
  const dt_thumbnail_t *thumb_a = (const dt_thumbnail_t *)a;
  const dt_thumbnail_t *thumb_b = (const dt_thumbnail_t *)b;
 
  if(thumb_a->rowid < thumb_b->rowid) return 1;
  if(thumb_a->rowid > thumb_b->rowid) return -1;
  return 0;
}
 
static int _grab_focus(dt_thumbtable_t *table)
{
  if(IS_NULL_PTR(table)) return 0;
  table->focus_idle_id = 0;
 
  if(table->ops->grab_focus) table->ops->grab_focus(table);
  dt_thumbtable_scroll_to_selection(table);
  return 0;
}
 
void dt_thumbtable_schedule_focus_real(dt_thumbtable_t *table, const gint priority)
{
  if(IS_NULL_PTR(table) || table->focus_idle_id) return;
  dt_print(DT_DEBUG_LIGHTTABLE, "[thumbtable] schedule_focus queued (priority=%d)\n", priority);
  table->focus_idle_id = g_idle_add_full(priority, (GSourceFunc)_grab_focus, table, NULL);
}
 
static gboolean _thumbtable_idle_update(gpointer user_data)
{
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  if(IS_NULL_PTR(table)) return G_SOURCE_REMOVE;
 
  table->idle_update_id = 0;
  dt_thumbtable_configure(table);
  dt_thumbtable_update(table);
  if(table->thumb_nb == 0) gtk_widget_queue_draw(table->grid);
  return G_SOURCE_REMOVE;
}
 
static void _thumbtable_schedule_update(dt_thumbtable_t *table)
{
  if(IS_NULL_PTR(table)) return;
  if(table->scroll_window && !gtk_widget_is_visible(table->scroll_window)) return;
  if(table->idle_update_id) return;
  table->idle_update_id = g_idle_add_full(G_PRIORITY_LOW, (GSourceFunc)_thumbtable_idle_update, table, NULL);
}
 
void dt_thumbtable_queue_update(dt_thumbtable_t *table)
{
  _thumbtable_schedule_update(table);
}
 
static void _scrollbar_value_changed(GtkAdjustment *adjustment, gpointer user_data)
{
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  if(IS_NULL_PTR(table)) return;
 
  // Only react to the adjustment that is meaningful in the current mode.
  if(!table->ops->wants_scroll_value(table, adjustment)) return;
 
  _thumbtable_schedule_update(table);
}
 
static void _scrollbar_page_size_notify(GObject *object, GParamSpec *pspec, gpointer user_data)
{
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  if(IS_NULL_PTR(table)) return;
 
  // Page size is only used to size the filemanager/grid (filmstrip uses its parent allocation), and
  // only the scroll-axis (vertical) adjustment matters. Reacting to the cross-axis adjustment would
  // re-enter configure (whose grid-width write drives that page size) and can spin in a resize loop.
  if(!table->ops->wants_page_size_notify(table, object)) return;
 
  _thumbtable_schedule_update(table);
}
 
static void _parent_overlay_size_allocate(GtkWidget *widget, GtkAllocation *allocation, gpointer user_data)
{
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  if(IS_NULL_PTR(table) || IS_NULL_PTR(allocation)) return;
 
  if(allocation->width == table->last_parent_width && allocation->height == table->last_parent_height)
    return;
 
  table->last_parent_width = allocation->width;
  table->last_parent_height = allocation->height;
  _thumbtable_schedule_update(table);
}
 
static void _scrollbar_widget_size_allocate(GtkWidget *widget, GtkAllocation *allocation, gpointer user_data)
{
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  if(IS_NULL_PTR(table) || IS_NULL_PTR(allocation) || IS_NULL_PTR(table->scroll_window)) return;
 
  // The frontend decides which scrollbar's geometry drives its thumbnail sizing (filmstrip: the
  // horizontal scrollbar height; filemanager: the vertical scrollbar width) and records it.
  if(table->ops->relevant_scrollbar_changed(table, widget, allocation))
    _thumbtable_schedule_update(table);
}
 
// We can't trust the mouse enter/leave events on thumnbails to properly
// update active thumbnail styling, so we need to catch the signal here and update the whole list.
void _mouse_over_image_callback(gpointer instance, gpointer user_data)
{
  if(IS_NULL_PTR(user_data)) return;
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  if(IS_NULL_PTR(table->lut) || table->collection_count == 0) return;
 
  const int32_t imgid = dt_control_get_mouse_over_id();
 
  dt_pthread_mutex_lock(&table->lock);
 
  int32_t group_id = UNKNOWN_IMAGE;
 
  // We iterate and update only over the visible range of thumbs + 2 rows as a safety margin
  int32_t row_start = CLAMP(table->min_row_id - 2 * table->thumbs_per_row, 0, table->collection_count - 1);
  int32_t row_end = CLAMP(table->max_row_id + 2 * table->thumbs_per_row, 0, table->collection_count - 1);
  for(int rowid = row_start; rowid <= row_end; rowid++)
  {
    dt_thumbnail_t *thumb = table->lut[rowid].thumb;
    if(IS_NULL_PTR(thumb)) continue; // thumb object not inited
 
    const gboolean mouse_over = thumb->mouse_over;
    dt_thumbnail_set_mouseover(thumb, thumb->info.id == imgid);
 
    if(thumb->info.id == imgid && dt_thumbtable_info_is_grouped(table->lut[rowid].thumb->info))
      group_id = thumb->info.group_id;
 
    if(thumb->mouse_over != mouse_over)
      gtk_widget_queue_draw(thumb->widget);
  }
 
  // Now, we update all the thumbs of the same image group
  if(table->draw_group_borders)
  {
    for(int rowid = row_start; rowid <= row_end; rowid++)
    {
      dt_thumbnail_t *thumb = table->lut[rowid].thumb;
      if(IS_NULL_PTR(thumb)) continue; // thumb object not inited
 
      // In CSS:
      // images borders from non-grouped images are transparent (default),
      // images borders from non-hovered groups, when there is none, are dark orange (base border classes)
      // images borders from the hovered group, when there is one, are bright orange (overwrite base border classes)
      // images borders from non-hovered groups, when there is one, are transparent (overwrite base border classes width default)
      // Here we dispatch the additional CSS classes alloying to overwrite
      // the base border classes.
      if(thumb->info.group_id == group_id)
      {
        dt_gui_add_class(thumb->widget, "hovered-group");
        dt_gui_remove_class(thumb->widget, "non-hovered-group");
      }
      else if(group_id == UNKNOWN_IMAGE)
      {
        dt_gui_remove_class(thumb->widget, "hovered-group");
        dt_gui_remove_class(thumb->widget, "non-hovered-group");
      }
      else
      {
        dt_gui_remove_class(thumb->widget, "hovered-group");
        dt_gui_add_class(thumb->widget, "non-hovered-group");
      }
    }
  }
 
  dt_pthread_mutex_unlock(&table->lock);
}
 
 
static void _rowid_to_position(dt_thumbtable_t *table, int rowid, int *x, int *y)
{
  if(table->thumbs_per_row < 1) return;
  table->ops->rowid_to_position(table, rowid, x, y);
}
 
// Needs updated table->x_position and table->y_position
static int _position_to_rowid(dt_thumbtable_t *table, const double x, const double y)
{
  return table->ops->position_to_rowid(table, x, y);
}
 
// Find the x, y coordinates of any given thumbnail
// Return TRUE if a position could be computed
// thumb->rowid and table->thumbs_per_row need to have been inited before calling this
static gboolean _set_thumb_position(dt_thumbtable_t *table, dt_thumbnail_t *thumb)
{
  if(table->thumbs_per_row < 1) return FALSE;
  _rowid_to_position(table, thumb->rowid, &thumb->x, &thumb->y);
  return TRUE;
}
 
// Updates table->x_position and table->y_position
void dt_thumbtable_get_scroll_position(dt_thumbtable_t *table, double *x, double *y)
{
  *y = gtk_adjustment_get_value(table->v_scrollbar);
  *x = gtk_adjustment_get_value(table->h_scrollbar);
}
 
void dt_thumbtable_set_active_rowid(dt_thumbtable_t *table)
{
  double x = 0.;
  double y = 0.;
  dt_thumbtable_get_scroll_position(table, &x, &y);
  table->rowid = _position_to_rowid(table, x, y);
}
 
static int dt_thumbtable_scroll_to_position(dt_thumbtable_t *table, const double x, const double y)
{
  gtk_adjustment_set_value(table->v_scrollbar, y);
  gtk_adjustment_set_value(table->h_scrollbar, x);
  return 0;
}
 
static void dt_thumbtable_scroll_to_rowid(dt_thumbtable_t *table, int rowid)
{
  // Find (x, y) of the current thumbnail (north-west corner)
  int x = 0, y = 0;
  _rowid_to_position(table, rowid, &x, &y);
 
  // Put the image always in the center of the view, if possible,
  // aka move from north-west corner to center of the thumb
  x += table->thumb_width / 2;
  y += table->thumb_height / 2;
 
  // Scroll viewport there
  const double x_scroll = (double)x - (double)table->view_width / 2.;
  const double y_scroll = (double)y - (double)table->view_height / 2.;
  dt_thumbtable_scroll_to_position(table, x_scroll, y_scroll);
}
 
int dt_thumbtable_find_rowid_from_imgid(dt_thumbtable_t *table, const int32_t imgid)
{
  if(IS_NULL_PTR(table) || IS_NULL_PTR(table->lut) || table->collection_count <= 0) return UNKNOWN_IMAGE;
 
  for(int i = 0; i < table->collection_count; i++)
    if(table->lut[i].imgid == imgid)
      return i;
 
  return UNKNOWN_IMAGE;
}
 
int dt_thumbtable_scroll_to_imgid(dt_thumbtable_t *table, int32_t imgid)
{
  if(IS_NULL_PTR(table) || !table->collection_inited || IS_NULL_PTR(table->lut) || table->collection_count <= 0)
    return 1;
 
  int rowid = UNKNOWN_IMAGE;
  if(imgid > UNKNOWN_IMAGE)
  {
    dt_pthread_mutex_lock(&table->lock);
    rowid = dt_thumbtable_find_rowid_from_imgid(table, imgid);
    dt_pthread_mutex_unlock(&table->lock);
  }
  else
    rowid = table->rowid;
 
  if(rowid == UNKNOWN_IMAGE) return 1;
 
  dt_thumbtable_scroll_to_rowid(table, rowid);
 
  return 0;
}
 
 
int dt_thumbtable_scroll_to_active_rowid(dt_thumbtable_t *table)
{
  if(table->rowid > UNKNOWN_IMAGE)
    dt_thumbtable_scroll_to_rowid(table, table->rowid);
  else
    dt_thumbtable_scroll_to_selection(table);
  return 0;
}
 
 
int dt_thumbtable_scroll_to_selection(dt_thumbtable_t *table)
{
  int id = dt_selection_get_first_id(dt_selection_get_global());
  if(id < 0) id = dt_control_get_keyboard_over_id();
  if(id < 0) id = dt_control_get_mouse_over_id();
  dt_print(DT_DEBUG_LIGHTTABLE, "[thumbtable] scroll_to_selection: id=%d\n", id);
  dt_thumbtable_scroll_to_imgid(table, id);
  return 0;
}
 
// Find the row ids (as in SQLite indices) of the images contained within viewport at current scrolling stage
static gboolean _get_row_ids(dt_thumbtable_t *table, int *rowid_min, int *rowid_max)
{
  if(!table->configured || IS_NULL_PTR(table->v_scrollbar) || IS_NULL_PTR(table->h_scrollbar)) return FALSE;
  table->ops->get_row_ids(table, rowid_min, rowid_max);
  return TRUE;
}
 
// Find out if a given row id is visible at current scroll step
gboolean _is_rowid_visible(dt_thumbtable_t *table, int rowid)
{
  if(!table->configured || IS_NULL_PTR(table->v_scrollbar) || IS_NULL_PTR(table->h_scrollbar)) return FALSE;
  return table->ops->is_rowid_visible(table, rowid);
}
 
// Returns TRUE if visible row ids have changed since last check
gboolean _update_row_ids(dt_thumbtable_t *table)
{
  int rowid_min = 0;
  int rowid_max = 0;
  if(!_get_row_ids(table, &rowid_min, &rowid_max)) return FALSE;
  if(rowid_min != table->min_row_id || rowid_max != table->max_row_id)
  {
    table->min_row_id = rowid_min;
    table->max_row_id = rowid_max;
    table->thumbs_inited = FALSE;
    return TRUE;
  }
  return FALSE;
}
 
void _update_grid_area(dt_thumbtable_t *table)
{
  if(!table->configured || !table->collection_inited) return;
  table->ops->update_content_size(table);
}
 
 
// Store the geometry computed by dt_thumbtable_configure. It must NOT re-derive thumb_width/height:
// configure already applies the cell-decoration budget when computing them, so re-deriving here
// (e.g. floor(width/cols), ignoring deco) would disagree by a pixel and make thumbs_changed forever
// true - an infinite configure/redraw loop.
void _grid_configure(dt_thumbtable_t *table, int width, int height, int per_row, int thumb_width, int thumb_height)
{
  if(width < 32 || height < 32) return;
 
  table->thumbs_per_row = per_row;
  table->view_width = width;
  table->view_height = height;
  table->thumb_width = thumb_width;
  table->thumb_height = thumb_height;
 
  table->configured = TRUE;
 
  dt_print(DT_DEBUG_LIGHTTABLE, "Configuring thumbtable w=%i h=%i thumbs/row=%i thumb_width=%i\n",
           table->view_width, table->view_height, table->thumbs_per_row, table->thumb_width);
}
 
// Extra extent one thumb cell adds beyond the layout stride (thumb_width/height).
//
// The cells (.thumb-cell) carry a transparent border plus a negative margin, used to overlap and merge
// the borders of adjacent cells. As a result a cell's margin box is larger than the stride by
// (border + margin); inner cells overlap their neighbours so it cancels out, but the last row/column
// has no neighbour to overlap into, so the GtkFixed grid ends up exactly that much larger than
// cols*thumb_width (GtkFixed sizes itself as max(child->x + child_preferred), and the child's
// preferred size includes its margins). Budgeting for it - read from the theme rather than hardcoded -
// keeps the grid within its viewport under the NEVER scroll policy instead of forcing the scrolled
// window (and its scrollbar) past the parent overlay. The cell is square, so H and V surplus are equal.
int dt_thumbtable_thumb_cell_decoration(void)
{
  GtkWidgetPath *path = gtk_widget_path_new();
  gtk_widget_path_append_type(path, GTK_TYPE_EVENT_BOX);
  gtk_widget_path_iter_add_class(path, -1, "thumb-cell");
 
  GtkStyleContext *ctx = gtk_style_context_new();
  gtk_style_context_set_path(ctx, path);
 
  GtkBorder margin, border;
  gtk_style_context_get_margin(ctx, GTK_STATE_FLAG_NORMAL, &margin);
  gtk_style_context_get_border(ctx, GTK_STATE_FLAG_NORMAL, &border);
 
  g_object_unref(ctx);
  gtk_widget_path_unref(path);
 
  return MAX(0, (border.left + border.right) + (margin.left + margin.right));
}
 
// Track size changes of the container or number of thumbs per row
// and recomputed the size of individual thumbnails accordingly
void dt_thumbtable_configure(dt_thumbtable_t *table)
{
  if(!gtk_widget_is_visible(table->scroll_window)) return;
 
  int new_width = 0;
  int new_height = 0;
  int new_thumbs_per_row = 0;
  int new_thumb_width = 0;
  int new_thumb_height = 0;
 
  // The frontend reads the parent allocation and derives the viewport size, per-row count and
  // individual thumbnail size (including the scrollbar gutter and per-cell decoration budget).
  table->ops->configure_dims(table, &new_width, &new_height, &new_thumbs_per_row,
                             &new_thumb_width, &new_thumb_height);
 
  // Parent is not allocated or something went wrong:
  // ensure to reset everything so no further code will run.
  if(new_width < 32 || new_height < 32)
  {
    table->thumbs_inited = FALSE;
    table->configured = FALSE;
    table->thumbs_per_row = 0;
    table->thumb_height = 0;
    table->thumb_width = 0;
    return;
  }
 
  const gboolean thumbs_changed = (!table->configured
                                  || new_thumbs_per_row != table->thumbs_per_row
                                  || new_thumb_width != table->thumb_width
                                  || new_thumb_height != table->thumb_height);
 
  // Always keep view sizes in sync: they are used for navigation and scroll centering.
  table->view_width = new_width;
  table->view_height = new_height;
 
  if(thumbs_changed)
  {
    table->thumbs_inited = FALSE;
    _grid_configure(table, new_width, new_height, new_thumbs_per_row, new_thumb_width, new_thumb_height);
    _update_grid_area(table);
  }
}
 
dt_thumbnail_t *_find_thumb_by_imgid(dt_thumbtable_t *table, const int32_t imgid)
{
  if(IS_NULL_PTR(table) || imgid <= 0) return NULL;
  return (dt_thumbnail_t *)g_hash_table_lookup(table->list, GINT_TO_POINTER(imgid));
}
 
gboolean dt_thumbtable_get_thumbnail_info(dt_thumbtable_t *table, int32_t imgid, dt_image_t *out)
{
  if(IS_NULL_PTR(table) || IS_NULL_PTR(out) || imgid <= 0) return FALSE;
 
  // Prefer LUT-backed metadata to avoid touching the image cache for read-only UI needs.
  gboolean found = FALSE;
  dt_pthread_mutex_lock(&table->lock);
  if(table->lut)
  {
    for(int rowid = 0; rowid < table->collection_count; rowid++)
    {
      if(table->lut[rowid].imgid == imgid && table->lut[rowid].thumb)
      {
        dt_thumbnail_t *thumb = table->lut[rowid].thumb;
        if(g_hash_table_lookup(table->list, GINT_TO_POINTER(imgid)) == thumb)
        {
          *out = thumb->info;
          found = TRUE;
          break;
        }
        table->lut[rowid].thumb = NULL;
      }
    }
  }
  dt_pthread_mutex_unlock(&table->lock);
 
  return found;
}
 
#define CLAMP_ROW(rowid) CLAMP(rowid, 0, table->collection_count - 1)
#define IS_COLLECTION_EDGE(rowid) (rowid < 0 || rowid >= table->collection_count)
 
void _add_thumbnail_group_borders(dt_thumbtable_t *table, dt_thumbnail_t *thumb)
{
  // Reset all CSS classes
  dt_thumbnail_border_t borders = 0;
  dt_thumbnail_set_group_border(thumb, borders);
 
  const int32_t rowid = thumb->rowid;
 
  // Ungrouped image: abort
  if(!dt_thumbtable_info_is_grouped(table->lut[rowid].thumb->info) || !table->draw_group_borders) return;
 
  // The frontend adds the mode-specific border flags (grid closes on all four neighbours; the
  // filmstrip always closes top+bottom and checks only its horizontal neighbours).
  table->ops->group_borders(table, thumb, &borders);
 
  dt_thumbnail_set_group_border(thumb, borders);
}
 
void _add_thumbnail_at_rowid(dt_thumbtable_t *table, const size_t rowid, const int32_t mouse_over)
{
  const int32_t imgid = table->lut[rowid].imgid;
  dt_image_t info;
  dt_image_t *img = dt_image_cache_get(imgid, 'r');
  if(IS_NULL_PTR(img)) return;
 
  // Take a private copy
  info = *img;
  dt_image_cache_read_release(img);
 
  dt_thumbnail_t *thumb = NULL;
  gboolean new_item = TRUE;
  gboolean new_position = TRUE;
 
  // Do we already have a thumbnail at the correct postion for the correct imgid ?
  if(table->lut[rowid].thumb && table->lut[rowid].imgid == imgid)
  {
    // Reuse the LUT entry only if it still matches the live thumbnail registry.
    dt_thumbnail_t *mapped_thumb = _find_thumb_by_imgid(table, imgid);
    if(mapped_thumb == table->lut[rowid].thumb)
    {
      thumb = mapped_thumb;
      new_position = FALSE;
    }
    else
    {
      table->lut[rowid].thumb = NULL;
    }
  }
  else
  {
    // NO : Try to find an existing thumbnail widget by imgid in table->list
    // That will be faster if we only changed the sorting order but are still in the same collection.
    // NOTE: the thumb widget position in grid will be wrong
    thumb = _find_thumb_by_imgid(table, imgid);
  }
 
  if(thumb)
  {
    // Ensure everything is up-to-date
    thumb->rowid = rowid;
    dt_thumbnail_resync_info(thumb, &info);
    new_item = FALSE;
  }
  else
  {
    thumb = dt_thumbnail_new(rowid, table->overlays, table, &info);
    if(IS_NULL_PTR(thumb)) return;
    g_hash_table_insert(table->list, GINT_TO_POINTER(thumb->info.id), thumb);
    table->thumb_nb += 1;
  }
 
  table->lut[rowid].thumb = thumb;
 
  // Resize
  gboolean size_changed = (table->thumb_height != thumb->height || table->thumb_width != thumb->width);
  if(new_item || size_changed || table->overlays != thumb->over)
  {
    dt_thumbnail_set_overlay(thumb, table->overlays);
    dt_thumbnail_resize(thumb, table->thumb_width, table->thumb_height);
  }
 
  // Actually moving the widgets in the grid is more expensive, do it only if necessary
  if(new_item)
  {
    _set_thumb_position(table, thumb);
    table->ops->place_child(table, thumb);
    //fprintf(stdout, "adding new thumb at #%lu: %i, %i\n", rowid, thumb->x, thumb->y);
  }
  else if(new_position || size_changed)
  {
    _set_thumb_position(table, thumb);
    table->ops->move_child(table, thumb);
    //fprintf(stdout, "moving new thumb at #%lu: %i, %i\n", rowid, thumb->x, thumb->y);
  }
 
  // Update visual states and flags. Mouse over is not connected to a signal and cheap to update
  dt_thumbnail_set_mouseover(thumb, (mouse_over == thumb->info.id));
  dt_thumbnail_alternative_mode(thumb, table->alternate_mode);
 
  // Per-mode selection/action state (filmstrip tracks active images and disables actions).
  table->ops->on_thumbnail_added(table, thumb);
 
  _add_thumbnail_group_borders(table, thumb);
  gtk_widget_show(thumb->widget);
}
 
 
// Add and/or resize thumbnails within visible viewort at current scroll level
void _populate_thumbnails(dt_thumbtable_t *table)
{
  const int32_t mouse_over = dt_control_get_mouse_over_id();
 
  // for(size_t rowid = 0; rowid < table->collection_count; rowid++)
  for(size_t rowid = MAX(table->min_row_id, 0); rowid < MIN(table->max_row_id, table->collection_count); rowid++)
    _add_thumbnail_at_rowid(table, rowid, mouse_over);
}
 
// Resize the thumbnails that are still existing but outside of visible viewport at current scroll level
void _resize_thumbnails(dt_thumbtable_t *table)
{
  if(!table->configured) return;
 
  GHashTableIter iter;
  gpointer value = NULL;
  g_hash_table_iter_init(&iter, table->list);
  while(g_hash_table_iter_next(&iter, NULL, &value))
  {
    dt_thumbnail_t *thumb = (dt_thumbnail_t *)value;
    gboolean size_changed = (table->thumb_height != thumb->height || table->thumb_width != thumb->width);
 
    if(size_changed || table->overlays != thumb->over)
    {
      // Overlay modes may change the height of the image
      // to accommodate buttons. We need to resize on overlay changes.
      dt_thumbnail_set_overlay(thumb, table->overlays);
      dt_thumbnail_resize(thumb, table->thumb_width, table->thumb_height);
      if(size_changed)
      {
        _set_thumb_position(table, thumb);
        table->ops->move_child(table, thumb);
      }
      dt_thumbnail_alternative_mode(thumb, table->alternate_mode);
    }
 
    dt_thumbnail_update_gui(thumb);
    _add_thumbnail_group_borders(table, thumb);
    gtk_widget_queue_draw(thumb->widget);
  }
}
 
// Destroy the thumbnails whose rowid lies outside [keep_min, keep_max). Each is a child of
// table->grid, and GTK restyles an appended child by recursing through all its previous siblings:
// unbounded, paging through a large collection overflows the main-thread stack (1 MiB on Windows).
static void _evict_thumbnails(dt_thumbtable_t *table, const int keep_min, const int keep_max)
{
  if(keep_max <= keep_min) return; // no visible range: nothing tells what to keep
 
  const double start = dt_get_wtime();
  GList *evicted = NULL;
 
  dt_pthread_mutex_lock(&table->lock);
  GHashTableIter iter;
  gpointer value = NULL;
  g_hash_table_iter_init(&iter, table->list);
  while(g_hash_table_iter_next(&iter, NULL, &value))
  {
    dt_thumbnail_t *thumb = (dt_thumbnail_t *)value;
    if(thumb->rowid >= keep_min && thumb->rowid < keep_max) continue;
    g_hash_table_iter_remove(&iter);
    evicted = g_list_prepend(evicted, thumb);
    table->thumb_nb--;
  }
  dt_pthread_mutex_unlock(&table->lock);
 
  // dt_thumbnail_destroy() takes table->lock, and clears the LUT slots still pointing to the thumbnail
  const guint count = g_list_length(evicted);
  for(GList *l = evicted; l; l = g_list_next(l))
  {
    dt_thumbnail_t *thumb = (dt_thumbnail_t *)l->data;
    gtk_widget_hide(thumb->widget);
    dt_thumbnail_destroy(thumb);
  }
  g_list_free(evicted);
 
  dt_print(DT_DEBUG_LIGHTTABLE, "Evicted %u thumbs outside of %i and %i in %0.04f sec\n", count, keep_min,
           keep_max, dt_get_wtime() - start);
}
 
static gboolean _evict_idle(gpointer user_data)
{
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  table->evict_idle_id = 0;
 
  const int span = table->max_row_id - table->min_row_id;
  _evict_thumbnails(table, table->min_row_id - span, table->max_row_id + span);
  return G_SOURCE_REMOVE;
}
 
 
void dt_thumbtable_update(dt_thumbtable_t *table)
{
  _update_row_ids(table);
 
  if(!gtk_widget_is_visible(table->scroll_window) || IS_NULL_PTR(table->lut) || !table->configured || !table->collection_inited
     || table->thumbs_inited || table->collection_count == 0)
    return;
 
  if(table->reset_collection)
  {
    _dt_thumbtable_empty_list(table);
    table->reset_collection = FALSE;
  }
 
  const double start = dt_get_wtime();
 
  dt_pthread_mutex_lock(&table->lock);
 
  gboolean empty_list = (table->thumb_nb == 0);
 
  _populate_thumbnails(table);
 
  if(!empty_list)
    _resize_thumbnails(table);
 
  table->thumbs_inited = TRUE;
 
  dt_pthread_mutex_unlock(&table->lock);
 
  // Destroying a thumbnail costs half of creating one, so it waits until this page is drawn. The idle
  // starves while Page Down is held: past 4 visible ranges, evict now to keep the stack bounded.
  const int span = table->max_row_id - table->min_row_id;
  if((int)table->thumb_nb > 4 * span)
    _evict_thumbnails(table, table->min_row_id - span, table->max_row_id + span);
  else if(!table->evict_idle_id)
    table->evict_idle_id = g_idle_add_full(G_PRIORITY_LOW + 10, _evict_idle, table, NULL);
 
  const char *const name = gtk_widget_get_name(table->grid);
  dt_print(DT_DEBUG_LIGHTTABLE, "[%s] Populated %d thumbs between %i and %i in %0.04f sec \n",
           name ? name : "thumbtable", table->thumb_nb, table->min_row_id, table->max_row_id,
           dt_get_wtime() - start);
}
 
 
static void _dt_profile_change_callback(gpointer instance, int type, gpointer user_data)
{
  if(IS_NULL_PTR(user_data)) return;
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  dt_thumbtable_refresh_thumbnail(table, UNKNOWN_IMAGE, TRUE);
}
 
// Repaint every materialised thumbnail's "highlighted" state from the mode's source of truth
// (grid: the selection; filmstrip: the active/developed image - see is_thumb_highlighted). Called
// on both selection and active-image changes so the mode tracks whichever one it cares about and
// is not clobbered by the other. Issue #954: the darkroom clears the selection AND sets a new
// active image when the developed picture changes; the filmstrip must follow the active image.
static void _refresh_highlights(dt_thumbtable_t *table)
{
  if(IS_NULL_PTR(table)) return;
  // Hidden tables re-evaluate highlights on view re-entry (populate calls on_thumbnail_added), so
  // there is no point (and, for huge collections, real cost) in scanning them here.
  if(!gtk_widget_is_visible(table->scroll_window)) return;
 
  gboolean first = TRUE;
 
  dt_pthread_mutex_lock(&table->lock);
  if(IS_NULL_PTR(table->lut) || !table->collection_inited || table->collection_count == 0)
  {
    dt_pthread_mutex_unlock(&table->lock);
    return;
  }
 
  for(int rowid = 0; rowid < table->collection_count; rowid++)
  {
    dt_thumbnail_t *thumb = table->lut[rowid].thumb;
    if(IS_NULL_PTR(thumb)) continue;
 
    if(g_hash_table_lookup(table->list, GINT_TO_POINTER(table->lut[rowid].imgid)) != thumb)
    {
      table->lut[rowid].thumb = NULL;
      continue;
    }
 
    const gboolean was_highlighted = thumb->selected;
    dt_thumbnail_update_selection(thumb, table->ops->is_thumb_highlighted(table, thumb->info.id));
 
    if(thumb->selected && first)
    {
      dt_view_image_info_update(thumb->info.id);
 
      // Sync the table active row id with the first highlighted thumb
      table->rowid = thumb->rowid;
      first = FALSE;
    }
 
    if(thumb->selected != was_highlighted)
      gtk_widget_queue_draw(thumb->widget);
  }
  dt_pthread_mutex_unlock(&table->lock);
}
 
static void _dt_selection_changed_callback(gpointer instance, gpointer user_data)
{
  if(IS_NULL_PTR(user_data)) return;
  _refresh_highlights((dt_thumbtable_t *)user_data);
}
 
// The filmstrip highlights the active/developed image; refresh when it changes (e.g. navigating to
// another picture in darkroom). The grid's highlight source is the selection, so this is a no-op
// there.
static void _dt_active_images_changed_callback(gpointer instance, gpointer user_data)
{
  if(IS_NULL_PTR(user_data)) return;
  _refresh_highlights((dt_thumbtable_t *)user_data);
}
 
void dt_thumbtable_set_focus_regions(dt_thumbtable_t *table, gboolean enable)
{
  table->focus_regions = enable;
  dt_thumbtable_refresh_thumbnail(table, UNKNOWN_IMAGE, TRUE);
}
 
gboolean dt_thumbtable_get_focus_regions(dt_thumbtable_t *table)
{
  return table->focus_regions;
}
 
void dt_thumbtable_set_focus_peaking(dt_thumbtable_t *table, gboolean enable)
{
  table->focus_peaking = enable;
  dt_thumbtable_refresh_thumbnail(table, UNKNOWN_IMAGE, TRUE);
}
 
gboolean dt_thumbtable_get_focus_peaking(dt_thumbtable_t *table)
{
  return table->focus_peaking;
}
 
void dt_thumbtable_set_draw_group_borders(dt_thumbtable_t *table, gboolean enable)
{
  table->draw_group_borders = enable;
  dt_pthread_mutex_lock(&table->lock);
  _resize_thumbnails(table);
  dt_pthread_mutex_unlock(&table->lock);
}
 
gboolean dt_thumbtable_get_draw_group_borders(dt_thumbtable_t *table)
{
  return table->draw_group_borders;
}
 
// can be called with imgid = -1, in that case we reload all mipmaps
// reinit = FALSE should be called when the mipmap is ready to redraw,
// reinit = TRUE should be called when a refreshed mipmap has been requested but we have nothing yet to draw
void dt_thumbtable_refresh_thumbnail_real(dt_thumbtable_t *table, int32_t imgid, gboolean reinit)
{
  dt_pthread_mutex_lock(&table->lock);
  if(imgid != UNKNOWN_IMAGE)
  {
    dt_thumbnail_t *thumb = (dt_thumbnail_t *)g_hash_table_lookup(table->list, GINT_TO_POINTER(imgid));
    if(thumb)
      dt_thumbnail_image_refresh(thumb);
  }
  else
  {
    GHashTableIter iter;
    gpointer value = NULL;
    g_hash_table_iter_init(&iter, table->list);
    while(g_hash_table_iter_next(&iter, NULL, &value))
    {
      dt_thumbnail_t *thumb = (dt_thumbnail_t *)value;
      dt_thumbnail_image_refresh(thumb);
    }
  }
  dt_pthread_mutex_unlock(&table->lock);
}
 
 
// this is called each time the images info change
// NOTE: remember we populate the table->lut with the current collection
// but we init actual thumbnail objects and add their widgets to the grid
// only when they appear in viewport. 
// So, we have to account for the fact that we may not have actual
// thumbnails to refresh yet, and the table->list doesn't contain
// uninited thumbs.
// So we always use table->lut to find imgid, update the cached info
// and try to update widgets only if we have some.
// Otherwise, fresh info will be read when initing new thumbnails objects.
static void _dt_image_info_changed_callback(gpointer instance, gpointer imgs, gpointer user_data)
{
  if(!user_data || IS_NULL_PTR(imgs)) return;
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  if(IS_NULL_PTR(table->lut)) return;
 
  dt_pthread_mutex_lock(&table->lock);
 
  for(GList *l = g_list_first(imgs); l; l = g_list_next(l))
  {
    const int32_t imgid = GPOINTER_TO_INT(l->data);
    if(imgid <= 0) continue;
 
    const int rowid = dt_thumbtable_find_rowid_from_imgid(table, imgid);
    if(rowid == UNKNOWN_IMAGE) continue;
 
    dt_thumbnail_t *thumb = table->lut[rowid].thumb;
    if(thumb)
    {
      // Refresh the cached LUT info from the image cache for write-driven updates
      // (ratings, color labels, etc.) while still keeping read paths cache-free.
      const dt_image_t *img = dt_image_cache_testget(imgid, 'r');
      if(img)
      {
        dt_thumbnail_resync_info(thumb, img);
        dt_image_cache_read_release(img);
        dt_thumbnail_update_gui(thumb);
        _add_thumbnail_group_borders(table, thumb);
        gtk_widget_queue_draw(thumb->widget);
      }
    }
 
    if(dt_view_manager_get_global()->image_info_id == imgid)
      dt_view_image_info_update(imgid);
  }
 
  dt_pthread_mutex_unlock(&table->lock);
}
 
/* One collected image, as the repository read it. Context for _dt_collection_lut() below. */
typedef struct _collection_lut_ctx_t
{
  dt_thumbtable_t *table;
  GArray *collection;
} _collection_lut_ctx_t;
 
static void _collection_lut_row(void *user_data, const dt_image_t *row)
{
  _collection_lut_ctx_t *ctx = (_collection_lut_ctx_t *)user_data;
  const int32_t imgid = row->id;
  const int32_t groupid = row->group_id;
 
  if(ctx->table->collapse_groups && imgid != groupid)
  {
    // if user requested to collapse image groups in GUI,
    // only the group leader is shown. But we need to make sure
    // there is no dangling selection pointing to hidden group members
    // because it's unexpected that unvisible items might be selected,
    // and selection sanitization only deals with imgids outside of current collection,
    // but group members are always within the collection.
    dt_selection_deselect(dt_selection_get_global(), imgid);
    return;
  }
 
  dt_thumbtable_cache_t entry = { .thumb = NULL, .imgid = imgid, .groupid = groupid };
  g_array_append_val(ctx->collection, entry);
 
  // Populate the image cache. We don't keep a copy here because it wouldn't
  // be memory-managed
  dt_image_t info = *row;
  dt_image_derive_fields(&info);
 
#ifndef NDEBUG
  dt_thumbtable_info_debug_assert_matches_cache(&info);
#endif
 
  // Seed the cache and be done
  dt_thumbtable_info_seed_image_cache(&info);
}
 
static void _dt_collection_lut(dt_thumbtable_t *table)
{
  // NOTE: non-grouped images have group_id equal to their own id
  // grouped images have group_id equal to the id of the "group leader".
  // In old database versions, it's possible that group_id may have been set to -1 for non-grouped images.
  // That would actually make group detection much easier...
 
  // Convert SQL imgids into C objects we can work with. In-memory collected images don't store
  // group_id, so the repository reads the whole row again from the images table.
  GArray *collection = g_array_new(FALSE, FALSE, sizeof(dt_thumbtable_cache_t));
  _collection_lut_ctx_t ctx = { .table = table, .collection = collection };
  dt_image_repository_foreach_collected(_collection_lut_row, &ctx);
 
  if(IS_NULL_PTR(collection) || collection->len == 0)
  {
    dt_thumbtable_cache_t *old_lut = NULL;
    dt_pthread_mutex_lock(&table->lock);
    old_lut = table->lut;
    table->lut = NULL;
    table->collection_count = 0;
    table->collection_inited = FALSE;
    dt_pthread_mutex_unlock(&table->lock);
 
    dt_free(old_lut);
    if(collection) g_array_free(collection, TRUE);
    return;
  }
 
  // Build the collection LUT, aka a fixed-sized array of image objects
  // where the position of an image in the collection is directly the index in the LUT/array.
  // This makes for very efficient position -> imgid/thumbnail accesses directly in C,
  // especially from GUI code. The downside is we need to fully clear and recreate the LUT
  // everytime a collection changes (meaning filters OR sorting changed).
  dt_thumbtable_cache_t *new_lut = malloc(collection->len * sizeof(dt_thumbtable_cache_t));
 
  if(IS_NULL_PTR(new_lut))
  {
    g_array_free(collection, TRUE);
    return;
  }
 
  memcpy(new_lut, collection->data, collection->len * sizeof(dt_thumbtable_cache_t));
 
  dt_thumbtable_cache_t *old_lut = NULL;
  dt_pthread_mutex_lock(&table->lock);
  old_lut = table->lut;
  table->lut = new_lut;
  table->collection_count = collection->len;
  table->collection_inited = TRUE;
  dt_pthread_mutex_unlock(&table->lock);
 
  dt_free(old_lut);
  g_array_free(collection, TRUE);
}
 
static gboolean _dt_collection_get_hash(dt_thumbtable_t *table)
{
  // The collection query's generation stands in for the query text, which no longer leaves the
  // database module. It advances on every recomposition, so it changes exactly when the text
  // would have.
  const uint64_t generation = dt_collection_query_get_generation();
  uint64_t hash = dt_hash(5384, (char *)&generation, sizeof(uint64_t));
 
  // Factor in the number of images in the collection result
  uint32_t num_pics = dt_collection_get_count(dt_collection_get_global());
  hash = dt_hash(hash, (char *)&num_pics, sizeof(uint32_t));
 
  if(hash != table->collection_hash || table->reset_collection)
  {
    // Collection changed: reset everything
    table->collection_hash = hash;
    table->collection_inited = FALSE;
    return TRUE;
  }
  return FALSE;
}
 
 
// this is called each time collected images change
static void _dt_collection_changed_callback(gpointer instance, dt_collection_change_t query_change,
                                            dt_collection_properties_t changed_property, gpointer imgs,
                                            const int next, gpointer user_data)
{
  if(IS_NULL_PTR(user_data)) return;
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
 
  gboolean collapse_groups = dt_conf_get_bool("ui_last/grouping");
  gboolean collapsing_changed = (table->collapse_groups != collapse_groups);
 
  // Remember where the scrolling is at to possibly get the same visible images
  // despite collection changes (provided they are still there).
  dt_thumbtable_set_active_rowid(table);
 
  // See if the collection changed
  gboolean grouping_changed = changed_property == DT_COLLECTION_PROP_GROUPING;
  gboolean hash_changed = _dt_collection_get_hash(table);
  gboolean changed = hash_changed || collapsing_changed || grouping_changed;
  dt_print(DT_DEBUG_LIGHTTABLE,
          "[thumbtable] collection_changed_callback: query_change=%d changed_property=%d hash_changed=%d "
          "collapsing_changed=%d grouping_changed=%d -> changed=%d\n",
          query_change, changed_property, hash_changed, collapsing_changed, grouping_changed, changed);
  if(changed)
  {
    // If groups are collapsed, we add only the group leader image to the collection
    // It needs to be set before running _dt_collection_lut()
    table->collapse_groups = collapse_groups;
    if(!_thumbtable_clone_lut(table))
      _dt_collection_lut(table);
 
    table->thumbs_inited = FALSE;
    _dt_thumbtable_empty_list(table);
 
    if(table->collection_count == 0)
    {
      dt_control_log(_(
          "The current filtered collection contains no image. Relax your filters or fetch a non-empty collection"));
    }
 
    // Ensure we have something to scroll
    dt_thumbtable_configure(table);
 
    // Number of images may have changed, size of grid too:
    _update_grid_area(table);
 
    // Coalesce multiple layout/resize signals that can happen during collection loads.
    dt_thumbtable_queue_update(table);
 
    // DT_COLLECTION_CHANGE_BACKGROUND_SYNC marks a passive background sync (see
    // dt_collection_notify_imported()): the grid content above must still refresh -- it's driven
    // by the hash, which is what actually detected new/removed images -- but a background import
    // dropping images into the browsed folder must not also hijack the user's scroll position
    // every time it does. A real navigational change (folder switch, filter edit...) always
    // carries a different query_change and keeps re-centering on the selection as before.
    if(query_change != DT_COLLECTION_CHANGE_BACKGROUND_SYNC)
      dt_thumbtable_schedule_focus(table, G_PRIORITY_DEFAULT_IDLE);
  }
}
 
// get the class name associated with the overlays mode
static gchar *_thumbs_get_overlays_class(dt_thumbnail_overlay_t over)
{
  switch(over)
  {
    case DT_THUMBNAIL_OVERLAYS_NONE:
      return g_strdup("dt_overlays_none");
    case DT_THUMBNAIL_OVERLAYS_ALWAYS_NORMAL:
      return g_strdup("dt_overlays_always");
    case DT_THUMBNAIL_OVERLAYS_HOVER_NORMAL:
    default:
      return g_strdup("dt_overlays_hover");
  }
}
 
// update thumbtable class and overlays mode, depending on size category
static void _thumbs_update_overlays_mode(dt_thumbtable_t *table)
{
  // we change the overlay mode
  gchar *txt = g_strdup("plugins/lighttable/overlays/global");
  dt_thumbnail_overlay_t over = sanitize_overlays(dt_conf_get_int(txt));
  dt_free(txt);
 
  dt_thumbtable_set_overlays_mode(table, over);
}
 
// change the type of overlays that should be shown
void dt_thumbtable_set_overlays_mode(dt_thumbtable_t *table, dt_thumbnail_overlay_t over)
{
  if(IS_NULL_PTR(table)) return;
  if(over == table->overlays) return;
 
  // Cleanup old Darktable stupid modes
  dt_conf_set_int("plugins/lighttable/overlays/global", sanitize_overlays(over));
 
  gchar *cl0 = _thumbs_get_overlays_class(table->overlays);
  gchar *cl1 = _thumbs_get_overlays_class(over);
  dt_gui_remove_class(table->grid, cl0);
  dt_gui_add_class(table->grid, cl1);
  dt_free(cl0);
  dt_free(cl1);
 
  table->thumbs_inited = FALSE;
  table->overlays = over;
 
  dt_pthread_mutex_lock(&table->lock);
  _resize_thumbnails(table);
  dt_pthread_mutex_unlock(&table->lock);
}
 
static void _event_dnd_get(GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data,
                           const guint target_type, const guint time, gpointer user_data)
{
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  g_assert(!IS_NULL_PTR(selection_data));
 
  switch(target_type)
  {
    case DND_TARGET_IMGID:
    {
      const int imgs_nb = g_list_length(table->drag_list);
      if(imgs_nb)
      {
        uint32_t *imgs = malloc(sizeof(uint32_t) * imgs_nb);
        GList *l = table->drag_list;
        for(int i = 0; i < imgs_nb; i++)
        {
          imgs[i] = GPOINTER_TO_INT(l->data);
          l = g_list_next(l);
        }
        gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
                               _DWORD, (guchar *)imgs, imgs_nb * sizeof(uint32_t));
        dt_free(imgs);
      }
      break;
    }
    default: // return the location of the file as a last resort
    case DND_TARGET_URI:
    {
      GList *l = table->drag_list;
      if(g_list_is_singleton(l))
      {
        gchar pathname[DT_PATH_MAX] = { 0 };
        gboolean from_cache = TRUE;
        const int id = GPOINTER_TO_INT(l->data);
        dt_image_full_path(id,  pathname,  sizeof(pathname),  &from_cache, __FUNCTION__);
        gchar *uri = g_strdup_printf("file://%s", pathname); // TODO: should we add the host?
        gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
                               _BYTE, (guchar *)uri, strlen(uri));
        dt_free(uri);
      }
      else
      {
        GList *images = NULL;
        for(; l; l = g_list_next(l))
        {
          const int id = GPOINTER_TO_INT(l->data);
          gchar pathname[DT_PATH_MAX] = { 0 };
          gboolean from_cache = TRUE;
          dt_image_full_path(id,  pathname,  sizeof(pathname),  &from_cache, __FUNCTION__);
          gchar *uri = g_strdup_printf("file://%s", pathname); // TODO: should we add the host?
          images = g_list_prepend(images, uri);
        }
        images = g_list_reverse(images); // list was built in reverse order, so un-reverse it
        gchar *uri_list = dt_util_glist_to_str("\r\n", images);
        g_list_free_full(images, dt_free_gpointer);
        images = NULL;
        gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data), _BYTE,
                               (guchar *)uri_list, strlen(uri_list));
        dt_free(uri_list);
      }
      break;
    }
  }
}
 
static void _thumbtable_drag_set_icon(dt_thumbtable_t *table, GdkDragContext *context)
{
  if(IS_NULL_PTR(table) || !table->drag_list) return;
 
  const int32_t imgid = dt_control_get_mouse_over_id();
  dt_thumbnail_t *thumb = _find_thumb_by_imgid(table, imgid);
  if(IS_NULL_PTR(thumb)) return;
 
  cairo_surface_t *surface = NULL;
  int hotspot_x = 0;
  int hotspot_y = 0;
  int width = 0;
  int height = 0;
 
  dt_pthread_mutex_lock(&thumb->lock);
  if(thumb->img_surf && cairo_surface_get_reference_count(thumb->img_surf) > 0)
  {
    surface = cairo_surface_reference(thumb->img_surf);
    width = thumb->img_width;
    height = thumb->img_height;
    hotspot_x = width / 2;
    hotspot_y = height / 2;
  }
  dt_pthread_mutex_unlock(&thumb->lock);
 
  if(IS_NULL_PTR(surface)) return;
 
  GtkWidget *image = gtk_image_new_from_surface(surface);
  cairo_surface_destroy(surface);
  // thumb->img_width/img_height are already in logical (CSS) pixels, but GtkImage sizes itself
  // from the surface's raw physical pixel count, ignoring its device scale: on HiDPI screens
  // (PPD > 1) that makes the drag icon balloon to PPD× the intended size. Pin the widget to the
  // correct logical size explicitly; the surface still paints crisply since cairo itself honors
  // the device scale when compositing.
  gtk_widget_set_size_request(image, width, height);
 
  gtk_widget_show(image);
  gtk_drag_set_icon_widget(context, image, hotspot_x, hotspot_y);
}
 
static void _event_dnd_begin(GtkWidget *widget, GdkDragContext *context, gpointer user_data)
{
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  const int32_t imgid = dt_control_get_mouse_over_id();
 
  // Commit the hovered image before dt_act_on_get_images() snapshots the payload: the filmstrip
  // raises a view signal, the grid extends the selection.
  table->ops->on_drag_begin(table, imgid);
 
  table->drag_list = dt_act_on_get_images();
  _thumbtable_drag_set_icon(table, context);
}
 
// Regular files are collected into `files` directly (unfiltered by type, same as always).
// Folders are collected into `*folders` instead of being rejected: the caller asks the user
// which file type(s) to pull out of them, then scans them on a background job (see
// _thumbtable_dnd_scan_folders_and_import()).
GList *_thumbtable_dnd_import_check(GList *files, const char *pathname, int *elements, GList **folders)
{
  if (IS_NULL_PTR(pathname) || IS_NULL_PTR(pathname))
  {
    fprintf(stdout,"DND check: no pathname.\n");
    return files;
  }
  fprintf(stdout,"DND check pathname: %s\n", pathname);
 
  if(g_file_test(pathname, G_FILE_TEST_IS_REGULAR))
  {
    if (dt_supported_image(pathname))
    {
      files = g_list_prepend(files, g_strdup(pathname));
      (*elements)++;
    }
    else
      fprintf(stderr, "`%s`: Unkonwn format.", pathname);
  }
  else if(g_file_test(pathname, G_FILE_TEST_IS_DIR))
  {
    *folders = g_list_prepend(*folders, g_strdup(pathname));
  }
  else
  {
    fprintf(stderr, "DND check: `%s` not a file or folder.\n", pathname);
  }
 
  return files;
}
 
// Response codes for the file-type dialog below, same shape as control_jobs.c's
// _dt_delete_dialog_choice (a GtkResponseType-typed gtk_dialog_run() return value doesn't fit a
// 3-way custom choice, so this stands in for it exactly like that one does).
enum _dt_dnd_import_choice
{
  _DT_DND_IMPORT_CHOICE_ALL = 1,
  _DT_DND_IMPORT_CHOICE_RAW = 2,
  _DT_DND_IMPORT_CHOICE_RASTER = 3
};
 
// State for the background job that recursively scans dropped folders (drag-and-drop) and
// merges the result with any directly-dropped files before handing everything to
// dt_control_import(). Mirrors the Import dialog's own recursive scan
// (_recurse_folder()/_filter_document() in gui/import.c) but without that dialog's
// generation/cancellation bookkeeping: a drop happens once, atomically, there is no live
// file-chooser selection that could invalidate a scan already in flight.
typedef struct dt_dnd_folder_import_t
{
  GList *folders;              // owned: char* paths of the dropped folders to recurse into
  GList *files;                 // owned: char* paths already known (directly-dropped regular files)
  dt_import_filter_type_t filter_type;
} dt_dnd_folder_import_t;
 
static void _dnd_recurse_folder(const char *folder_path, dt_import_filter_type_t filter_type, GList **files,
                                guint *scan_errors)
{
  GFile *folder = g_file_new_for_path(folder_path);
  GError *error = NULL;
  GFileEnumerator *children = g_file_enumerate_children(
      folder, G_FILE_ATTRIBUTE_STANDARD_NAME "," G_FILE_ATTRIBUTE_STANDARD_TYPE, G_FILE_QUERY_INFO_NONE, NULL, &error);
  if(IS_NULL_PTR(children))
  {
    // e.g. permission denied, or the folder vanished mid-scan.
    if(error)
    {
      dt_print(DT_DEBUG_IMPORT, "[import] could not fully scan folder `%s': %s\n", folder_path, error->message);
      g_error_free(error);
      (*scan_errors)++;
    }
    g_object_unref(folder);
    return;
  }
 
  GFile *child = NULL;
  GError *iter_error = NULL;
  while(g_file_enumerator_iterate(children, NULL, &child, NULL, &iter_error))
  {
    // g_file_enumerator_iterate returns FALSE only on errors, not on end of enumeration; an ugly
    // break is needed here, else infinite loop.
    if(IS_NULL_PTR(child)) break;
 
    gchar *pathname = g_file_get_path(child);
    if(pathname && g_file_test(pathname, G_FILE_TEST_IS_REGULAR) && dt_import_passes_filter(filter_type, pathname))
    {
      *files = g_list_prepend(*files, pathname);
      pathname = NULL;
    }
    else if(pathname && g_file_test(pathname, G_FILE_TEST_IS_DIR))
    {
      _dnd_recurse_folder(pathname, filter_type, files, scan_errors);
    }
    dt_free(pathname);
    // g_file_enumerator_iterate() returns transfer-none children owned by the enumerator; unref
    // happens when the enumerator advances or is destroyed.
    child = NULL;
  }
 
  // A FALSE return above without a set error just means "iteration finished normally" -- only
  // report when GLib actually set one.
  if(iter_error)
  {
    dt_print(DT_DEBUG_IMPORT, "[import] could not fully scan folder `%s': %s\n", folder_path, iter_error->message);
    g_error_free(iter_error);
    (*scan_errors)++;
  }
 
  g_object_unref(children);
  g_object_unref(folder);
}
 
static int32_t _dnd_folder_import_job_run(dt_job_t *job)
{
  dt_dnd_folder_import_t *data = (dt_dnd_folder_import_t *)dt_control_job_get_params(job);
 
  // Take over the already-collected files; the scan below prepends the matches found in the
  // dropped folder(s) onto the same list.
  GList *files = data->files;
  data->files = NULL;
 
  guint scan_errors = 0;
  for(GList *l = data->folders; l; l = g_list_next(l))
    _dnd_recurse_folder((const char *)l->data, data->filter_type, &files, &scan_errors);
 
  const int elements = g_list_length(files);
  if(elements > 0)
  {
    dt_control_import_t import_data = {.imgs = files, // ownership transferred to the import job
                                       .datetime = g_date_time_new_now_local(),
                                       .copy = FALSE, // we only import in place, like plain-file DnD.
                                       .jobcode = dt_conf_get_string("ui_last/import_jobcode"),
                                       .base_folder = dt_conf_get_string("session/base_directory_pattern"),
                                       .target_subfolder_pattern = dt_conf_get_string("session/sub_directory_pattern"),
                                       .target_file_pattern = dt_conf_get_string("session/filename_pattern"),
                                       .target_dir = NULL,
                                       .elements = elements,
                                       .discarded = NULL};
    if(dt_control_import(import_data))
      dt_control_log(_("Could not start the import job."));
  }
  else
  {
    g_list_free(files);
    dt_control_log(_("No matching file found in the dropped folder(s)."));
  }
 
  if(scan_errors > 0)
    dt_control_log(ngettext("%u folder could not be scanned (permission denied?)",
                           "%u folders could not be scanned (permission denied?)", scan_errors),
                   scan_errors);
 
  return elements > 0 ? 0 : 1;
}
 
static void _dnd_folder_import_job_cleanup(void *p)
{
  dt_dnd_folder_import_t *data = (dt_dnd_folder_import_t *)p;
  g_list_free_full(data->folders, dt_free_gpointer);
  // data->files is only non-NULL here if _dnd_folder_import_job_run() never ran (job disposed
  // before execution): the success path hands the list to dt_control_import(), and the
  // no-match path frees it itself.
  if(data->files) g_list_free_full(data->files, dt_free_gpointer);
  dt_free(data);
}
 
// Ask which file type(s) to pull out of the dropped folder(s) (mirrors the Import dialog's
// All/Raw/Raster filter), then recursively scan them on a background job -- scanning can be slow
// for a large/deep folder, and this runs from the GUI thread's drag-and-drop handler. The result
// is merged with `files` (already-known, directly-dropped regular files -- always imported
// regardless of the chosen filter: the question is about what to pull out of folders, not about
// re-filtering files the user explicitly picked) before everything is handed to
// dt_control_import(). Takes ownership of both `folders` and `files`.
static void _thumbtable_dnd_scan_folders_and_import(GList *folders, GList *files)
{
  GtkWidget *dialog = gtk_message_dialog_new(
      GTK_WINDOW(dt_gui_get_ui()->main_window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_QUESTION,
      GTK_BUTTONS_NONE, "%s",
      _("The dropped folder(s) will be scanned recursively.\nWhich files should be imported?"));
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(dialog);
#endif
 
  gtk_dialog_add_button(GTK_DIALOG(dialog), _("All image files"), _DT_DND_IMPORT_CHOICE_ALL);
  gtk_dialog_add_button(GTK_DIALOG(dialog), _("Raw image files"), _DT_DND_IMPORT_CHOICE_RAW);
  gtk_dialog_add_button(GTK_DIALOG(dialog), _("Raster image files"), _DT_DND_IMPORT_CHOICE_RASTER);
 
  gtk_window_set_title(GTK_WINDOW(dialog), _("Import folder"));
  const gint choice = gtk_dialog_run(GTK_DIALOG(dialog));
  gtk_widget_destroy(dialog);
 
  if(choice != _DT_DND_IMPORT_CHOICE_ALL && choice != _DT_DND_IMPORT_CHOICE_RAW
     && choice != _DT_DND_IMPORT_CHOICE_RASTER)
  {
    // Dialog closed without a choice: treat the whole drop as cancelled, directly-dropped files
    // included, rather than second-guessing whether the user still wants those imported alone.
    g_list_free_full(folders, dt_free_gpointer);
    g_list_free_full(files, dt_free_gpointer);
    return;
  }
 
  dt_job_t *job = dt_control_job_create(&_dnd_folder_import_job_run, "scan dropped folder(s) for import");
  if(IS_NULL_PTR(job))
  {
    g_list_free_full(folders, dt_free_gpointer);
    g_list_free_full(files, dt_free_gpointer);
    return;
  }
 
  dt_dnd_folder_import_t *data = g_malloc0(sizeof(dt_dnd_folder_import_t));
  data->folders = folders;
  data->files = files;
  data->filter_type = choice == _DT_DND_IMPORT_CHOICE_RAW
                           ? DT_IMPORT_FILTER_RAW
                           : choice == _DT_DND_IMPORT_CHOICE_RASTER ? DT_IMPORT_FILTER_RASTER : DT_IMPORT_FILTER_ALL;
 
  dt_control_job_set_params(job, data, _dnd_folder_import_job_cleanup);
  dt_control_add_job(dt_control_get_global(), DT_JOB_QUEUE_USER_BG, job);
}
 
static gboolean _thumbtable_dnd_import(GtkSelectionData *selection_data)
{
  gchar **uris = gtk_selection_data_get_uris(selection_data);
  int elements = 0;
  GList *files = NULL;
  GList *folders = NULL;
 
  if(uris)
  {
    GVfs *vfs = g_vfs_get_default();
    for (int i = 0; !IS_NULL_PTR(uris[i]); i++)
    {
      GFile *filepath = g_vfs_get_file_for_uri(vfs, uris[i]);
      const gchar *pathname = g_strdup(g_file_get_path(filepath));
      files = _thumbtable_dnd_import_check(files, pathname, &elements, &folders);
      g_object_unref(filepath);
    }
 
    if(folders)
    {
      // At least one dropped item is a folder: ask which file type(s) to pull out of it/them,
      // then scan (background job) and import everything -- folders and any directly-dropped
      // files together -- once done. Ownership of both lists passes to that flow.
      _thumbtable_dnd_scan_folders_and_import(folders, files);
      files = NULL;
    }
    else if(elements > 0)
    {
      // WARNING: we copy a Glist of pathes as char*
      // The references to the char* still belong to the original.
      // We will free them in the import job.
      dt_control_import_t data = {.imgs = g_list_copy(files),
                                  .datetime = g_date_time_new_now_local(),
                                  .copy = FALSE, // we only import in place.
                                  .jobcode = dt_conf_get_string("ui_last/import_jobcode"),
                                  .base_folder = dt_conf_get_string("session/base_directory_pattern"),
                                  .target_subfolder_pattern = dt_conf_get_string("session/sub_directory_pattern"),
                                  .target_file_pattern = dt_conf_get_string("session/filename_pattern"),
                                  .target_dir = NULL,
                                  .elements = elements,
                                  .discarded = NULL
                                  };
 
      if(dt_control_import(data))
        dt_control_log(_("Could not start the import job."));
    }
    else fprintf(stderr,"No files to import. Check your selection or use 'File > Import'.");
  }
 
  g_strfreev(uris);
  g_list_free(files);
  files = NULL;
  return elements >= 0 ? TRUE : FALSE;
}
 
void dt_thumbtable_event_dnd_received(GtkWidget *widget, GdkDragContext *context, gint x, gint y,
                                GtkSelectionData *selection_data, guint target_type, guint time,
                                gpointer user_data)
{
  gboolean success = FALSE;
 
  if((target_type == DND_TARGET_URI) && (!IS_NULL_PTR(selection_data))
     && (gtk_selection_data_get_length(selection_data) >= 0))
  {
    success = _thumbtable_dnd_import(selection_data);
  }
 
  gtk_drag_finish(context, success, FALSE, time);
}
 
static void _event_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer user_data)
{
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  if(table->drag_list)
  {
    g_list_free(table->drag_list);
    table->drag_list = NULL;
  }
  // in any case, with reset the reordering class if any
  dt_gui_remove_class(table->grid, "dt_thumbtable_reorder");
}
 
int _imgid_to_rowid(dt_thumbtable_t *table, int32_t imgid)
{
  if(IS_NULL_PTR(table->lut)) return UNKNOWN_IMAGE;
 
  int rowid = UNKNOWN_IMAGE;
 
  dt_pthread_mutex_lock(&table->lock);
  for(int i = 0; i < table->collection_count; i++)
  {
    if(table->lut[i].imgid == imgid)
    {
      rowid = i;
      break;
    }
  }
  dt_pthread_mutex_unlock(&table->lock);
 
  return rowid;
}
 
void dt_thumbtable_move_in_grid(dt_thumbtable_t *table, GdkEventKey *event, dt_thumbtable_direction_t direction, int origin_imgid)
{
  if(IS_NULL_PTR(table->lut)) return;
  if(!gtk_widget_is_visible(table->scroll_window)) return;
 
  int current_rowid = _imgid_to_rowid(table, origin_imgid);
  int offset = 0;
 
  switch(direction)
  {
    case DT_TT_MOVE_UP:
      offset = - table->thumbs_per_row;
      break;
    case DT_TT_MOVE_DOWN:
      offset = + table->thumbs_per_row;
      break;
    case DT_TT_MOVE_LEFT:
      offset = - 1;
      break;
    case DT_TT_MOVE_RIGHT:
      offset = + 1;
      break;
    case DT_TT_MOVE_PREVIOUS_PAGE:
      offset = - table->view_height / table->thumb_height * table->thumbs_per_row;
      break;
    case DT_TT_MOVE_NEXT_PAGE:
      offset = + table->view_height / table->thumb_height * table->thumbs_per_row;
      break;
    case DT_TT_MOVE_START:
      offset = - origin_imgid;
      break;
    case DT_TT_MOVE_END:
      offset = +table->collection_count; // will be clamped below, don't care
      break;
  }
 
  int new_rowid = CLAMP(current_rowid + offset, 0, table->collection_count - 1);
 
  dt_pthread_mutex_lock(&table->lock);
  int new_imgid = table->lut[new_rowid].imgid;
  dt_pthread_mutex_unlock(&table->lock);
 
  dt_thumbtable_dispatch_over(table, event->type, new_imgid);
 
  if(!_is_rowid_visible(table, new_rowid))
  {
    // GUI update will be handled through the value-changed event of the GtkAdjustment
    dt_thumbtable_scroll_to_imgid(table, new_imgid);
  }
  else
  {
    // We still need to update all visible thumbs to keep mouse_over states in sync
    table->thumbs_inited = FALSE;
    dt_thumbtable_update(table);
  }
}
 
void _alternative_mode(dt_thumbtable_t *table, gboolean enable)
{
  if(table->alternate_mode == enable) return;
  table->alternate_mode = enable;
 
  dt_pthread_mutex_lock(&table->lock);
  GHashTableIter iter;
  gpointer value = NULL;
  g_hash_table_iter_init(&iter, table->list);
  while(g_hash_table_iter_next(&iter, NULL, &value))
  {
    dt_thumbnail_t *thumb = (dt_thumbnail_t *)value;
    dt_thumbnail_alternative_mode(thumb, enable);
  }
  dt_pthread_mutex_unlock(&table->lock);
}
 
 
gboolean dt_thumbtable_key_pressed_grid(GtkWidget *self, GdkEventKey *event, gpointer user_data)
{
  if(!gtk_window_is_active(GTK_WINDOW(dt_gui_get_ui()->main_window))) return FALSE;
  if(IS_NULL_PTR(user_data)) return FALSE;
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
  if(IS_NULL_PTR(table->lut)) return FALSE;
 
  // Find out the current image
  // NOTE: when moving into the grid from key arrow events,
  // if the cursor is still overlaying the grid when scrolling, it can collide
  // with key event and set the mouse_over focus elsewhere.
  // For this reason, we use our own private keyboard_over event,
  // and use the mouse_over as a fall-back only.
  // Key events are "knobby", therefore more reliale than "hover",
  // so they always take precedence.
  int32_t imgid = dt_control_get_keyboard_over_id();
  if(imgid < 0) imgid = dt_control_get_mouse_over_id();
  if(imgid < 0) imgid = dt_selection_get_first_id(dt_selection_get_global());
  if(imgid < 0 && table->lut)
  {
    dt_pthread_mutex_lock(&table->lock);
    imgid = table->lut[0].imgid;
    dt_pthread_mutex_unlock(&table->lock);
  }
 
  //fprintf(stdout, "%s\n", gtk_accelerator_name(event->keyval, event->state));
 
  // Exit alternative mode on any keystroke other than alt
  if(event->keyval != GDK_KEY_Alt_L && event->keyval != GDK_KEY_Alt_R)
    _alternative_mode(table, FALSE);
 
  guint key = dt_keys_mainpad_alternatives(event->keyval);
 
  // Mode-specific navigation/selection keys first: the grid consumes Up/Down (row navigation) and
  // space/nobreakspace (selection); the filmstrip has none and lets them fall through.
  if(table->ops->handle_key && table->ops->handle_key(table, event, key, imgid))
    return TRUE;
 
  // Keys handled identically in both modes.
  switch(key)
  {
    case GDK_KEY_Left:
    {
      dt_thumbtable_move_in_grid(table, event, DT_TT_MOVE_LEFT, imgid);
      return TRUE;
    }
    case GDK_KEY_Right:
    {
      dt_thumbtable_move_in_grid(table, event, DT_TT_MOVE_RIGHT, imgid);
      return TRUE;
    }
    case GDK_KEY_Page_Up:
    {
      dt_thumbtable_move_in_grid(table, event, DT_TT_MOVE_PREVIOUS_PAGE, imgid);
      return TRUE;
    }
    case GDK_KEY_Page_Down:
    {
      dt_thumbtable_move_in_grid(table, event, DT_TT_MOVE_NEXT_PAGE, imgid);
      return TRUE;
    }
    case GDK_KEY_Home:
    {
      dt_thumbtable_move_in_grid(table, event, DT_TT_MOVE_START, imgid);
      return TRUE;
    }
    case GDK_KEY_End:
    {
      dt_thumbtable_move_in_grid(table, event, DT_TT_MOVE_END, imgid);
      return TRUE;
    }
    case GDK_KEY_Return:
    {
      // This is only to be consistent with mouse events:
      // opening to darkroom happens with double click (aka ACTIVATE event),
      // but the first click always select the clicked thumbnail before.
      // So we do the same here, even though it's not required and actually slightly annoying.
      // (grid selects the thumbnail first; the filmstrip just activates.)
      if(table->ops->pre_activate) table->ops->pre_activate(table, imgid);
 
      DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_VIEWMANAGER_THUMBTABLE_ACTIVATE, imgid);
      return TRUE;
    }
    case GDK_KEY_Alt_L:
    case GDK_KEY_Alt_R:
    {
      _alternative_mode(table, TRUE);
      return TRUE;
    }
    case GDK_KEY_Delete:
    {
      // This is the "Remove image from library" shortcut, declared on Delete alone. A Delete
      // with a modifier that the dispatcher let through (Shift+Delete read as auto-repeat) is
      // not it, and must not remove anything.
      if(!dt_modifier_is(event->state, 0)) return FALSE;
      dt_control_remove_images();
      return TRUE;
    }
  }
  return FALSE;
}
 
gboolean dt_thumbtable_key_released_grid(GtkWidget *self, GdkEventKey *event, gpointer user_data)
{
  if(!gtk_window_is_active(GTK_WINDOW(dt_gui_get_ui()->main_window))) return FALSE;
 
  if(IS_NULL_PTR(user_data)) return FALSE;
  dt_thumbtable_t *table = (dt_thumbtable_t *)user_data;
 
  //fprintf(stdout, "%s\n", gtk_accelerator_name(event->keyval, event->state));
  _alternative_mode(table, FALSE);
  return FALSE;
}
 
 
static gboolean _draw_callback(GtkWidget *widget, cairo_t *cr, gpointer user_data)
{
  if(IS_NULL_PTR(user_data)) return TRUE;
 
  // Ensure the background color is painted
  GtkStyleContext *context = gtk_widget_get_style_context(widget);
  GtkAllocation allocation;
  gtk_widget_get_allocation(widget, &allocation);
  gtk_render_background(context, cr, 0, 0, allocation.width, allocation.height);
  gtk_render_frame(context, cr, 0, 0, allocation.width, allocation.height);
 
  return FALSE;
}
 
void dt_thumbtable_reset_collection(dt_thumbtable_t *table)
{
  table->reset_collection = TRUE;
}
 
gboolean _event_main_leave(GtkWidget *widget, GdkEventCrossing *event, gpointer user_data)
{
  if(IS_NULL_PTR(user_data)) return TRUE;
  dt_control_set_mouse_over_id(UNKNOWN_IMAGE);
  return TRUE;
}
 
 
// Single dispatch point mapping a mode to its layout strategy. Every former if(mode==...) branch
// now routes through the returned vtable (see thumbtable_internal.h and the two frontends).
static const dt_thumbtable_layout_ops_t *_ops_for_mode(dt_thumbtable_mode_t mode)
{
  switch(mode)
  {
    case DT_THUMBTABLE_MODE_FILMSTRIP:
      return dt_thumbtable_filmstrip_ops();
    case DT_THUMBTABLE_MODE_FILEMANAGER:
    default:
      return dt_thumbtable_grid_ops();
  }
}
 
dt_thumbtable_t *dt_thumbtable_new(dt_thumbtable_mode_t mode)
{
  dt_thumbtable_t *table = (dt_thumbtable_t *)calloc(1, sizeof(dt_thumbtable_t));
 
  // Bind the layout strategy before building the content widget: the frontend decides whether the
  // content is a GtkFixed (grid) or a GtkLayout (filmstrip).
  table->mode = mode;
  table->ops = _ops_for_mode(mode);
 
  table->scroll_window = gtk_scrolled_window_new(NULL, NULL);
  // Named so the theme can zero its "scrollbar-spacing" style property (see dt_thumbtable_configure).
  gtk_widget_set_name(table->scroll_window, "thumbtable-scroll");
  gtk_scrolled_window_set_overlay_scrolling(GTK_SCROLLED_WINDOW(table->scroll_window), FALSE);
  // No frame: the image grid is full-bleed content and needs no recessed border.
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(table->scroll_window), GTK_SHADOW_NONE);
 
  table->v_scrollbar = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(table->scroll_window));
  table->h_scrollbar = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(table->scroll_window));
  g_signal_connect(G_OBJECT(table->v_scrollbar), "value-changed", G_CALLBACK(_scrollbar_value_changed), table);
  g_signal_connect(G_OBJECT(table->h_scrollbar), "value-changed", G_CALLBACK(_scrollbar_value_changed), table);
  g_signal_connect(G_OBJECT(table->v_scrollbar), "notify::page-size", G_CALLBACK(_scrollbar_page_size_notify), table);
  g_signal_connect(G_OBJECT(table->h_scrollbar), "notify::page-size", G_CALLBACK(_scrollbar_page_size_notify), table);
 
  // Track actual scrollbar widget allocations: filmstrip sizing depends on the horizontal scrollbar height,
  // and filemanager fallback sizing depends on the vertical scrollbar width.
  GtkWidget *h_scroll = gtk_scrolled_window_get_hscrollbar(GTK_SCROLLED_WINDOW(table->scroll_window));
  GtkWidget *v_scroll = gtk_scrolled_window_get_vscrollbar(GTK_SCROLLED_WINDOW(table->scroll_window));
  if(h_scroll)
    g_signal_connect(G_OBJECT(h_scroll), "size-allocate", G_CALLBACK(_scrollbar_widget_size_allocate), table);
  if(v_scroll)
    g_signal_connect(G_OBJECT(v_scroll), "size-allocate", G_CALLBACK(_scrollbar_widget_size_allocate), table);
 
  // Content widget: GtkFixed for the grid, GtkLayout for the filmstrip (the latter is a
  // GtkScrollable, avoiding the implicit GtkViewport that collapsed the strip - issue #877).
  table->grid = table->ops->create_content_widget();
  dt_gui_add_class(table->grid, "dt_thumbtable");
  gtk_container_add(GTK_CONTAINER(table->scroll_window), table->grid);
 
  // A non-scrollable content widget (GtkFixed) gets wrapped in an implicit GtkViewport whose
  // default shadow is GTK_SHADOW_IN (a .frame border). Drop it so it doesn't add to the scrolled
  // window's size. A GtkScrollable (GtkLayout) is added directly, with no viewport to adjust.
  GtkWidget *viewport = gtk_bin_get_child(GTK_BIN(table->scroll_window));
  if(GTK_IS_VIEWPORT(viewport))
    gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
 
  g_object_set_data(G_OBJECT(table->grid), DT_ACCELS_WIDGET_TOOLTIP_DISABLED_KEY, GINT_TO_POINTER(1));
  gtk_widget_set_has_tooltip(table->grid, FALSE);
  // The filmstrip must never hold keyboard focus (see its ops' grab_focus comment): clicking one
  // of its thumbnails would otherwise steal focus away from the current view's own center widget,
  // and Return then gets swallowed here (raising a plain ACTIVATE/preview) instead of reaching the
  // view's own key_pressed (e.g. Studio Capture's "open in darkroom").
  const gboolean can_focus = (table->mode != DT_THUMBTABLE_MODE_FILMSTRIP);
  gtk_widget_set_can_focus(table->grid, can_focus);
  gtk_widget_set_focus_on_click(table->grid, can_focus);
  gtk_widget_add_events(table->grid, GDK_LEAVE_NOTIFY_MASK);
  gtk_widget_set_app_paintable(table->grid, TRUE);
  g_signal_connect(G_OBJECT(table->grid), "leave-notify-event", G_CALLBACK(_event_main_leave), table);
 
  // Disable auto re-scrolling to beginning when a child of scrolled window gets the focus
  // Doesn't seem to work...
  // https://stackoverflow.com/questions/26693042/gtkscrolledwindow-disable-scroll-to-focused-child
  GtkAdjustment *dummy = gtk_adjustment_new(0., 0., 1., 1., 1., 1.);
  gtk_container_set_focus_hadjustment(GTK_CONTAINER(table->scroll_window), dummy);
  gtk_container_set_focus_vadjustment(GTK_CONTAINER(table->scroll_window), dummy);
  gtk_container_set_focus_hadjustment(GTK_CONTAINER(table->grid), dummy);
  gtk_container_set_focus_vadjustment(GTK_CONTAINER(table->grid), dummy);
  g_object_unref(dummy);
 
  // drag and drop : used for reordering, interactions with maps, exporting uri to external apps, importing images
  // in filmroll...
  gtk_drag_source_set(table->grid, GDK_BUTTON1_MASK, target_list_all, n_targets_all, GDK_ACTION_MOVE);
  gtk_drag_dest_set(table->grid, GTK_DEST_DEFAULT_ALL, target_list_all, n_targets_all, GDK_ACTION_MOVE);
  g_signal_connect_after(table->grid, "drag-begin", G_CALLBACK(_event_dnd_begin), table);
  g_signal_connect_after(table->grid, "drag-end", G_CALLBACK(_event_dnd_end), table);
  g_signal_connect(table->grid, "drag-data-get", G_CALLBACK(_event_dnd_get), table);
  g_signal_connect(table->grid, "drag-data-received", G_CALLBACK(dt_thumbtable_event_dnd_received), table);
 
  gtk_widget_add_events(table->grid, GDK_STRUCTURE_MASK | GDK_EXPOSURE_MASK | GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK);
  g_signal_connect(table->grid, "draw", G_CALLBACK(_draw_callback), table);
  g_signal_connect(table->grid, "key-press-event", G_CALLBACK(dt_thumbtable_key_pressed_grid), table);
  g_signal_connect(table->grid, "key-release-event", G_CALLBACK(dt_thumbtable_key_released_grid), table);
  gtk_widget_show(table->grid);
 
  table->thumb_nb = 0;
  table->grid_cols = 0;
  table->collection_inited = FALSE;
  table->configured = FALSE;
  table->thumbs_inited = FALSE;
  table->collection_hash = -1;
  table->list = g_hash_table_new(g_direct_hash, g_direct_equal);
  table->collection_count = 0;
  table->min_row_id = 0;
  table->max_row_id = 0;
  table->lut = NULL;
  table->reset_collection = FALSE;
  table->x_position = 0.;
  table->y_position = 0.;
  table->alternate_mode = FALSE;
  table->rowid = -1;
  table->collapse_groups = dt_conf_get_bool("ui_last/grouping");
  table->draw_group_borders = dt_conf_get_bool("plugins/lighttable/group_borders");
  table->idle_update_id = 0;
  table->focus_idle_id = 0;
  table->evict_idle_id = 0;
  table->last_parent_width = 0;
  table->last_parent_height = 0;
  table->last_h_scrollbar_height = -1;
  table->last_v_scrollbar_width = -1;
 
  dt_pthread_mutex_init(&table->lock, NULL);
 
  dt_gui_add_help_link(table->grid, dt_get_help_url("lighttable_filemanager"));
 
  // set css name and class
  gtk_widget_set_name(table->grid, "thumbtable-filemanager");
 
  // overlays mode
  _thumbs_update_overlays_mode(table);
 
  // we register globals signals
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_COLLECTION_CHANGED,
                            G_CALLBACK(_dt_collection_changed_callback), table);
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_SELECTION_CHANGED,
                            G_CALLBACK(_dt_selection_changed_callback), table);
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_ACTIVE_IMAGES_CHANGE,
                            G_CALLBACK(_dt_active_images_changed_callback), table);
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_CONTROL_PROFILE_USER_CHANGED,
                            G_CALLBACK(_dt_profile_change_callback), table);
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_IMAGE_INFO_CHANGED,
                            G_CALLBACK(_dt_image_info_changed_callback), table);
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE,
                            G_CALLBACK(_mouse_over_image_callback), table);
 
  dt_thumbtable_set_parent(table, mode);
 
  // The file manager belongs only to lighttable, while the filmstrip widget is
  // shared by darkroom, print and map. Each owner view needs its own accel
  // paths so shortcut search, menus and dispatch stay in sync with the
  // currently active accel group.
  GtkAccelGroup *accel_groups[] = {
    dt_gui_get_accels()->lighttable_accels,
    dt_gui_get_accels()->darkroom_accels,
    dt_gui_get_accels()->print_accels,
    dt_gui_get_accels()->map_accels
  };
  const char *path_bases[] = {
    _("Lighttable/Thumbtable"),
    _("Darkroom/Filmstrip"),
    _("Print/Filmstrip"),
    _("Map/Filmstrip")
  };
  // The filemanager owns only the lighttable accel group (index 0); the shared filmstrip owns
  // the darkroom/print/map groups (indices 1-3).
  int first_group = 1, last_group = 4;
  switch(mode)
  {
    case DT_THUMBTABLE_MODE_FILEMANAGER:
      first_group = 0;
      last_group = 1;
      break;
    default:
      break;
  }
 
  gchar *path = NULL;
  for(int group_index = first_group; group_index < last_group; group_index++)
  {
    GtkAccelGroup *accel_group = accel_groups[group_index];
    const char *path_base = path_bases[group_index];
 
    path = dt_accels_build_path(path_base, _("Move up"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_Up, 0);
    dt_free(path);
    path = dt_accels_build_path(path_base, _("Move down"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_Down, 0);
    dt_free(path);
    path = dt_accels_build_path(path_base, _("Move left"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_Left, 0);
    dt_free(path);
    path = dt_accels_build_path(path_base, _("Move right"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_Right, 0);
    dt_free(path);
    path = dt_accels_build_path(path_base, _("Go to previous page"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_Page_Up, 0);
    dt_free(path);
    path = dt_accels_build_path(path_base, _("Go to next page"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_Page_Down, 0);
    dt_free(path);
    path = dt_accels_build_path(path_base, _("Go to the start"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_Home, 0);
    dt_free(path);
    path = dt_accels_build_path(path_base, _("Go to the end"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_End, 0);
    dt_free(path);
    path = dt_accels_build_path(path_base, _("Select the current thumbnail"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_space, 0);
    dt_free(path);
    // Kept as the literal Ctrl key (not DT_PRIMARY_MASK): Cmd+Space is reserved
    // system-wide by macOS to open Spotlight.
    path = dt_accels_build_path(path_base, _("Toogle the current thumbnail from selection"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_space, GDK_CONTROL_MASK);
    dt_free(path);
    path = dt_accels_build_path(path_base, _("Expand the current selection up to the hovered thumbnail"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_space, GDK_SHIFT_MASK);
    dt_free(path);
    path = dt_accels_build_path(path_base, _("Open the current thumbnail in darkroom"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_Return, 0);
    dt_free(path);
    path = dt_accels_build_path(path_base, _("Enable thumbnail transient alternative view"));
    dt_accels_new_virtual_shortcut(dt_gui_get_accels(), accel_group,
                                   path, table->grid, GDK_KEY_Alt_L, 0);
    dt_free(path);
  }
 
  path = dt_accels_build_path(_("Global/Menu/File"), _("Remove image from library"));
  dt_accels_new_virtual_shortcut(dt_gui_get_accels(), dt_gui_get_accels()->global_accels,
                                 path, table->grid, GDK_KEY_Delete, 0);
  dt_free(path);
  return table;
}
 
 
void _dt_thumbtable_empty_list(dt_thumbtable_t *table)
{
  // Cleanup existing stuff
  const double start = dt_get_wtime();
 
  dt_pthread_mutex_lock(&table->lock);
  if(table->lut)
    for(int rowid = 0; rowid < table->collection_count; rowid++)
      table->lut[rowid].thumb = NULL;
 
  // WARNING: we need to detach children from parent starting from the last
  // otherwise, Gtk updates the index of all the next children in sequence
  // and that takes forever when thumb_nb > 1000
  GList *thumbs = g_hash_table_get_values(table->list);
  thumbs = g_list_sort(thumbs, _thumb_compare_rowid_desc);
  g_hash_table_remove_all(table->list);
  dt_pthread_mutex_unlock(&table->lock);
 
  for(GList *l = thumbs; l; l = g_list_next(l))
  {
    dt_thumbnail_t *thumb = (dt_thumbnail_t *)l->data;
    gtk_widget_hide(thumb->widget);
    dt_thumbnail_destroy(thumb);
  }
  g_list_free(thumbs);
  thumbs = NULL;
 
  dt_print(DT_DEBUG_LIGHTTABLE, "Cleaning the list of %i elements in %0.04f sec\n", table->thumb_nb,
           dt_get_wtime() - start);
 
  table->thumb_nb = 0;
  table->thumbs_inited = FALSE;
}
 
 
void dt_thumbtable_cleanup(dt_thumbtable_t *table)
{
  if(table->idle_update_id)
  {
    g_source_remove(table->idle_update_id);
    table->idle_update_id = 0;
  }
  if(table->focus_idle_id)
  {
    g_source_remove(table->focus_idle_id);
    table->focus_idle_id = 0;
  }
  if(table->evict_idle_id)
  {
    g_source_remove(table->evict_idle_id);
    table->evict_idle_id = 0;
  }
 
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_dt_collection_changed_callback), table);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_dt_selection_changed_callback), table);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_dt_active_images_changed_callback), table);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_dt_profile_change_callback), table);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_dt_image_info_changed_callback), table);
 
  _dt_thumbtable_empty_list(table);
 
  dt_pthread_mutex_destroy(&table->lock);
 
  g_hash_table_destroy(table->list);
  if(table->lut)
  {
    dt_free(table->lut);
  }
 
  dt_free(table);
}
 
void dt_thumbtable_stop(dt_thumbtable_t *table)
{
  if(IS_NULL_PTR(table)) return;
 
  if(table->idle_update_id)
  {
    g_source_remove(table->idle_update_id);
    table->idle_update_id = 0;
  }
  if(table->focus_idle_id)
  {
    g_source_remove(table->focus_idle_id);
    table->focus_idle_id = 0;
  }
  if(table->evict_idle_id)
  {
    g_source_remove(table->evict_idle_id);
    table->evict_idle_id = 0;
  }
 
  table->reset_collection = TRUE;
 
  dt_pthread_mutex_lock(&table->lock);
  if(table->lut)
    for(int rowid = 0; rowid < table->collection_count; rowid++)
      table->lut[rowid].thumb = NULL;
 
  GList *thumbs = g_hash_table_get_values(table->list);
  thumbs = g_list_sort(thumbs, _thumb_compare_rowid_desc);
  g_hash_table_remove_all(table->list);
  dt_pthread_mutex_unlock(&table->lock);
 
  for(GList *l = thumbs; l; l = g_list_next(l))
  {
    dt_thumbnail_t *thumb = (dt_thumbnail_t *)l->data;
    gtk_widget_hide(thumb->widget);
    dt_thumbnail_destroy(thumb);
  }
  g_list_free(thumbs);
 
  table->thumb_nb = 0;
  table->thumbs_inited = FALSE;
}
 
void dt_thumbtable_update_parent(dt_thumbtable_t *table)
{
  dt_thumbtable_schedule_focus(table, G_PRIORITY_DEFAULT_IDLE);
}
 
void dt_thumbtable_set_parent(dt_thumbtable_t *table, dt_thumbtable_mode_t mode)
{
  table->mode = mode;
  table->ops = _ops_for_mode(mode);
 
  table->parent_overlay = gtk_overlay_new();
  g_signal_connect(G_OBJECT(table->parent_overlay), "size-allocate", G_CALLBACK(_parent_overlay_size_allocate), table);
 
  // The frontend builds its own scroll stack (overlay child vs. main child), widget name, help link
  // and scroll policy.
  table->ops->setup_parent(table);
}
 
void dt_thumbtable_select_all(dt_thumbtable_t *table)
{
  if(!table->collection_inited || table->collection_count == 0) return;
 
  if(table->collapse_groups)
    dt_control_log(_("Image groups are collapsed in view.\n"
                     "Selecting all images will only target visible members of image groups.\n"
                     "Uncollapse groups to select all their members"));
 
  GList *img = NULL;
 
  dt_pthread_mutex_lock(&table->lock);
  for(size_t i = 0; i < table->collection_count; i++)
    img = g_list_prepend(img, GINT_TO_POINTER(table->lut[i].imgid));
  dt_pthread_mutex_unlock(&table->lock);
 
  if(img)
  {
    dt_selection_select_list(dt_selection_get_global(), img);
    g_list_free(img);
    img = NULL;
  }
}
 
void dt_thumbtable_select_range(dt_thumbtable_t *table, const int rowid)
{
  if(!table->collection_inited || table->collection_count == 0) return;
  if(rowid < 0 || rowid > table->collection_count - 1) return;
 
  if(table->collapse_groups)
    dt_control_log(_("Image groups are collapsed in view.\n"
                     "Selecting a range of images will only target visible members of image groups.\n"
                     "Uncollapse groups to select all their members"));
 
  dt_pthread_mutex_lock(&table->lock);
 
  // Find the bounds of the current selection
  size_t rowid_end = 0;
  size_t rowid_start = table->collection_count - 1;
  GList *selected = dt_selection_get_list(dt_selection_get_global());
 
  if(selected)
  {
    for(GList *s = g_list_first(selected); s; s = g_list_next(s))
    {
      int32_t imgid = GPOINTER_TO_INT(s->data);
      int row = dt_thumbtable_find_rowid_from_imgid(table, imgid);
      if(row < 0) continue; // not found - should not happen
      if(row < rowid_start) rowid_start = row;
      if(row > rowid_end) rowid_end = row;
    }
    g_list_free(selected);
    selected = NULL;
  }
  else
  {
    // range selection always has to start from a previous selection
    dt_pthread_mutex_unlock(&table->lock);
    return;
  }
 
  if(rowid_start > rowid_end)
  {
     // the start is strictly after the end, we have a deep problem
     dt_pthread_mutex_unlock(&table->lock);
    return;
  }
 
  // Find the extra imgids to select
  GList *img = NULL;
  if(rowid > rowid_end && rowid_end < table->collection_count - 1)
  {
    // select after
    for(int i = rowid_end + 1; i <= rowid; i++)
      img = g_list_prepend(img, GINT_TO_POINTER(table->lut[i].imgid));
  }
  else if(rowid < rowid_start && rowid_start > 0)
  {
    // select before
    for(int i = rowid_start - 1; i >= rowid; i--)
      img = g_list_prepend(img, GINT_TO_POINTER(table->lut[i].imgid));
  }
  // else: select within. What should that yield ??? Deselect ?
 
  dt_pthread_mutex_unlock(&table->lock);
 
  if(img)
  {
    dt_selection_select_list(dt_selection_get_global(), img);
    g_list_free(img);
    img = NULL;
  }
}
 
void dt_thumbtable_invert_selection(dt_thumbtable_t *table)
{
  if(!table->collection_inited || table->collection_count == 0) return;
 
  // Record initial selection, select all, then deselect initial selection
  GList *to_deselect = dt_selection_get_list(dt_selection_get_global());
  if(to_deselect)
  {
    dt_thumbtable_select_all(table);
    dt_selection_deselect_list(dt_selection_get_global(), to_deselect);
    g_list_free(to_deselect);
    to_deselect = NULL;
  }
}
 
static gint64 next_over_time = 0;
 
void dt_thumbtable_dispatch_over(dt_thumbtable_t *table, GdkEventType type, int32_t imgid)
{
  if(!gtk_widget_is_visible(table->scroll_window)) return;
 
  gint64 current_time = g_get_real_time(); // microseconds
  if(type == GDK_KEY_PRESS || type == GDK_KEY_RELEASE)
  {
    // allow the mouse to capture the next hover events
    // in more than 100 ms:
    next_over_time = current_time + 100000;
 
    dt_control_set_mouse_over_id(imgid);
    dt_control_set_keyboard_over_id(imgid);
  }
  else if(type == GDK_ENTER_NOTIFY || type == GDK_LEAVE_NOTIFY)
  {
    // When navigating the grid with arrow keys, the view will get scrolled.
    // If the mouse pointer is over the grid, it will enter a new thumbnail
    // which will trigger leave/enter events.
    // But we don't want that when interacting from the keyboard, so disallow
    // recording enter/leave events in the next 100 ms after keyboard interaction.
    if(current_time > next_over_time)
      dt_control_set_mouse_over_id(imgid);
    else
      return;
  }
  else if(type == GDK_MOTION_NOTIFY || type == GDK_BUTTON_PRESS || type == GDK_2BUTTON_PRESS)
  {
    // Active mouse pointer interactions: accept unconditionnaly
    dt_control_set_mouse_over_id(imgid);
  }
  else
  {
    fprintf(stderr, "[dt_thumbtable_dispatch_over] unsupported event type: %i\n", type);
    return;
  }
 
  dt_pthread_mutex_lock(&table->lock);
  table->rowid = dt_thumbtable_find_rowid_from_imgid(table, imgid);
  dt_pthread_mutex_unlock(&table->lock);
 
  // Attempt to re-grab focus on every interaction to restore keyboard navigation,
  // for example after a combobox grabbed it on click.
  if(!gtk_widget_has_focus(table->grid))
  {
    // But giving focus to the grid scrolls it back to top, so we have to re-scroll it after
    double x = 0.;
    double y = 0.;
    dt_thumbtable_get_scroll_position(table, &x, &y);
    gtk_widget_grab_focus(table->grid);
    dt_thumbtable_scroll_to_position(table, x, y);
  }
}
 
// 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