/*
    This file is part of darktable,
    Copyright (C) 2012-2026 darktable developers.

    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/gdk_event_utils.h"

#include "common/debug.h"
#include "common/file_location.h"
#include "common/image_cache.h"
#include "common/collection.h"
#include "common/selection.h"
#include "common/gpx.h"
#include "common/geo.h"
#include "common/datetime.h"
#include "control/conf.h"
#include "dtgtk/button.h"
#include "control/jobs.h"
#include "gui/accelerators.h"
#include "gui/gtk.h"
#include "libs/lib_api.h"

#ifdef HAVE_MAP
#include "views/view.h"
#endif

#ifdef GDK_WINDOWING_QUARTZ
#include "osx/osx.h"
#endif

#include <gdk/gdkkeysyms.h>

DT_MODULE(1)

typedef struct tz_tuple_t
{
  char *name, *display;
} tz_tuple_t;

#define DT_GEOTAG_PARTS_NB 7

typedef struct dt_lib_datetime_t
{
  GtkWidget *widget[DT_GEOTAG_PARTS_NB];
  GtkWidget *sign;
} dt_lib_datetime_t;

#ifdef HAVE_MAP
typedef struct dt_lib_tracks_data_t
{
  GObject *track;
  dt_map_box_t map_box;
} dt_lib_tracks_data_t;

typedef struct dt_lib_tracks_t
{
  dt_lib_tracks_data_t td[1];
} dt_lib_tracks_t;

typedef enum dt_tracks_cols_t
{
  DT_GEO_TRACKS_ACTIVE = 0,       // active / deactivated track
  DT_GEO_TRACKS_DATETIME,         // displayed start datetime
  DT_GEO_TRACKS_POINTS,           // nb points
  DT_GEO_TRACKS_IMAGES,           // nb images
  DT_GEO_TRACKS_SEGID,            // id track segment
  DT_GEO_TRACKS_TOOLTIP,          // datetime details
  DT_GEO_TRACKS_NUM_COLS
} dt_tracks_cols_t;

#endif

typedef struct dt_lib_geotagging_t
{
  dt_lib_datetime_t dt;
  dt_lib_datetime_t dt0;
  dt_lib_datetime_t of;
  GDateTime *datetime;
  GDateTime *datetime0;
  GTimeSpan offset;
  gboolean editing;
  dt_imgid_t imgid;
  GList* imgs;
  int nb_imgs;
  GtkWidget *apply_offset;
  GtkWidget *lock_offset;
  GtkWidget *apply_datetime;
  GtkWidget *timezone;
  GList *timezones;
  GtkWidget *timezone_changed;
  GtkWidget *gpx_button;
  GTimeZone *tz_camera;
#ifdef HAVE_MAP
  struct
  {
    gboolean view;
    GtkWidget *gpx_button, *gpx_file, *gpx_view;
    struct dt_gpx_t *gpx;
    dt_lib_tracks_t *tracks;
    dt_map_box_t map_box;
    int nb_tracks, nb_imgs;
    GtkWidget *gpx_section, *preview_button, *apply_gpx_button,
              *select_button, *nb_imgs_label;
    GtkTreeViewColumn *sel_tracks;
  } map;
#endif
} dt_lib_geotagging_t;

typedef struct dt_sel_img_t
{
  dt_imgid_t imgid;
  uint32_t segid;
  gchar dt[DT_DATETIME_LENGTH];
  gboolean counted;
  dt_image_geoloc_t gl;
  GObject *image;
} dt_sel_img_t;

static void _datetime_entry_changed(GtkWidget *entry, dt_lib_module_t *self);
static void _setup_selected_images_list(dt_lib_module_t *self);

static void free_tz_tuple(gpointer data)
{
  tz_tuple_t *tz_tuple = (tz_tuple_t *)data;
  g_free(tz_tuple->display);
#ifdef _WIN32
  g_free(tz_tuple->name); // on non-Windows both point to the same string
#endif
  free(tz_tuple);
}

const char *name(dt_lib_module_t *self)
{
  return _("geotagging");
}

const char *description(dt_lib_module_t *self)
{
  return _("set geolocation information for\n"
           "the currently selected images");
}

dt_view_type_flags_t views(dt_lib_module_t *self)
{
#ifdef HAVE_MAP
  return DT_VIEW_LIGHTTABLE | DT_VIEW_MAP;
#else
  return DT_VIEW_LIGHTTABLE;
#endif
}

uint32_t container(dt_lib_module_t *self)
{
  return DT_UI_CONTAINER_PANEL_RIGHT_CENTER;
}

int position(const dt_lib_module_t *self)
{
  return 450;
}

// modify the datetime_taken field in the db/cache of selected images
static void _apply_offset_callback(GtkWidget *widget, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  if(d->offset)
    dt_control_datetime(d->offset, NULL, NULL);
}

// modify the datetime_taken field in the db/cache of selected images
static void _apply_datetime_callback(GtkWidget *widget, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  if(d->datetime)
  {
    char dt[DT_DATETIME_LENGTH];
    dt_datetime_gdatetime_to_exif(dt, sizeof(dt), d->datetime);
    dt_control_datetime(0, dt, NULL);
  }
}

static gboolean _lib_geotagging_filter_gpx(const GtkFileFilterInfo *filter_info, gpointer data)
{
  if(!g_ascii_strcasecmp(filter_info->mime_type, "application/gpx+xml")) return TRUE;

  const gchar *filename = filter_info->filename;
  const char *cc = filename + strlen(filename);
  for(; *cc != '.' && cc > filename; cc--)
    ;

  if(!g_ascii_strcasecmp(cc, ".gpx")) return TRUE;

  return FALSE;
}

static GtkWidget *_set_up_label(const char *name, const int align, GtkWidget *grid,
                                const int col, const int line, const int ellipsize)
{
  GtkWidget *label = gtk_label_new(name);
  gtk_label_set_ellipsize(GTK_LABEL(label), ellipsize);
  if(ellipsize != PANGO_ELLIPSIZE_NONE)
    gtk_widget_set_visible(label, TRUE);
  gtk_widget_set_halign(label, align);
  gtk_widget_set_hexpand(label, TRUE);
  gtk_grid_attach(GTK_GRID(grid), label, col, line, 1, 1);
  return label;
}

static gchar *_utc_timeval_to_localtime_text(GDateTime *utc_dt, GTimeZone *tz_camera,
                                             const gboolean full)
{
  GDateTime *local_dt  = g_date_time_to_timezone(utc_dt, tz_camera);
  gchar *dts = g_date_time_format(local_dt, full ? "%Y:%m:%d %H:%M:%S" : "%H:%M:%S");
  g_date_time_unref(local_dt);
  return dts;
}

static GDateTime *_localtime_text_to_utc_timeval(const char *date_time,
                                                 GTimeZone *tz_camera, GTimeZone *tz_utc,
                                                 GTimeSpan offset)
{
  GDateTime *exif_time = dt_datetime_exif_to_gdatetime(date_time, tz_camera);
  GDateTime *dt_offset = g_date_time_add(exif_time, offset);
  GDateTime *utc_time = g_date_time_to_timezone(dt_offset, tz_utc);

  g_date_time_unref(exif_time);
  g_date_time_unref(dt_offset);
  return utc_time;
}

static int _count_images_per_track(dt_gpx_track_segment_t *t, dt_gpx_track_segment_t *n,
                                   dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;

  int nb_imgs = 0;
  for(GList *i = d->imgs; i; i = g_list_next(i))
  {
    dt_sel_img_t *im = i->data;
    if(im->segid == -1)
    {
      GDateTime *dt = _localtime_text_to_utc_timeval(im->dt, d->tz_camera, darktable.utc_tz, d->offset);
      if((g_date_time_compare(dt, t->start_dt) >= 0
          && g_date_time_compare(dt, t->end_dt) <= 0)
         || (n && g_date_time_compare(dt, t->end_dt) >= 0
             && g_date_time_compare(dt, n->start_dt) <= 0))
      {
        nb_imgs++;
        im->segid = t->id;
      }
      g_date_time_unref(dt);
    }
  }
  return nb_imgs;
}

#ifdef HAVE_MAP
static gchar *_utc_timeval_to_utc_text(GDateTime *utc_dt, const gboolean full)
{
  gchar *dts = g_date_time_format(utc_dt, full ? "%Y:%m:%d %H:%M:%S" : "%H:%M:%S");
  return dts;
}

static gchar *_datetime_tooltip(GDateTime *start, GDateTime *end, GTimeZone *tz)
{
  gchar *dtsl = _utc_timeval_to_localtime_text(start, tz, FALSE);
  gchar *dtel = _utc_timeval_to_localtime_text(end, tz, FALSE);
  gchar *dtsu = _utc_timeval_to_utc_text(start, FALSE);
  gchar *dteu = _utc_timeval_to_utc_text(end, FALSE);
  gchar *res = g_strdup_printf("%s -> %s LT\n%s -> %s UTC", dtsl, dtel, dtsu, dteu);
  g_free(dtsl);
  g_free(dtel);
  g_free(dtsu);
  g_free(dteu);
  return res;
}

static void _remove_images_from_map(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  for(GList *i = d->imgs; i; i = g_list_next(i))
  {
    dt_sel_img_t *im = i->data;
    if(im->image)
    {
      dt_view_map_remove_marker(darktable.view_manager, MAP_DISPLAY_THUMB, im->image);
      im->image = NULL;
    }
  }
}

static void _refresh_images_displayed_on_track(const int segid, const gboolean active, dt_lib_module_t *self)
{
  dt_gui_cursor_set_busy();
  dt_lib_geotagging_t *d = self->data;
  for(GList *i = d->imgs; i; i = g_list_next(i))
  {
    dt_sel_img_t *im = i->data;
    if(im->segid == segid && active)
    {
      GDateTime *dt = _localtime_text_to_utc_timeval(im->dt, d->tz_camera, darktable.utc_tz, d->offset);
      if(!dt_gpx_get_location(d->map.gpx, dt, &im->gl))
        im->gl.latitude = NAN;
      g_date_time_unref(dt);
    }
    else if(im->segid == segid && !active && im->image)
    {
      dt_view_map_remove_marker(darktable.view_manager, MAP_DISPLAY_THUMB, im->image);
      im->image = NULL;
      im->gl.latitude = NAN;
    }
  }
  int count = 0;
  for(GList *i = d->imgs; active && i; i = g_list_next(i))
  {
    dt_sel_img_t *im = i->data;
    if(im->segid == segid && im->gl.latitude != NAN)
    {
      count++;
      dt_sel_img_t *next = i->next ? (dt_sel_img_t *)i->next->data
                                   : NULL;
      if(!im->image && (!next
                        || !((next->gl.latitude == im->gl.latitude)
                             && (next->gl.longitude == im->gl.longitude))))
      {
        struct {dt_imgid_t imgid; float latitude; float longitude; int count;} p;
        p.imgid = im->imgid;
        p.latitude = im->gl.latitude;
        p.longitude = im->gl.longitude;
        p.count = count == 1 ? 0 : count;
        GList *img = g_list_prepend(NULL, &p);
        im->image = dt_view_map_add_marker(darktable.view_manager, MAP_DISPLAY_THUMB, img);
        g_list_free(img);
        count = 0;
      }
    }
  }
  dt_gui_cursor_clear_busy();
}

static void _update_nb_images(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->map.gpx_view));
  GtkTreeIter iter;
  gboolean valid = gtk_tree_model_get_iter_first(model, &iter);
  int nb_imgs = 0;
  for(int segid = 0; valid && segid < d->map.nb_tracks; segid++)
  {
    gboolean active;
    int nb;
    gtk_tree_model_get(model, &iter, DT_GEO_TRACKS_ACTIVE, &active,
                                     DT_GEO_TRACKS_IMAGES, &nb, -1);
    if(active)
      nb_imgs += nb;
    valid = gtk_tree_model_iter_next(model, &iter);
  }
  d->map.nb_imgs = nb_imgs;
  gchar *nb = g_strdup_printf("%d/%d", nb_imgs, d->nb_imgs);
  gtk_label_set_text(GTK_LABEL(d->map.nb_imgs_label), nb);
  g_free(nb);
}

static void _update_buttons(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  gtk_widget_set_sensitive(d->map.preview_button, d->map.nb_tracks);
  GtkWidget *label = gtk_bin_get_child(GTK_BIN(d->map.apply_gpx_button));
  gtk_label_set_text(GTK_LABEL(label), d->offset ? _("apply offset and geo-location")
                                                 : _("apply geo-location"));
  gtk_widget_set_tooltip_text(d->map.apply_gpx_button,
                              d->offset ? _("apply offset and geo-location to matching images"
                                            "\ndouble operation: two ctrl+z to undo")
                                        : _("apply geo-location to matching images"));
  gtk_widget_set_sensitive(d->map.apply_gpx_button, d->map.nb_imgs);
  gtk_widget_set_sensitive(d->map.select_button,
                           d->map.nb_imgs && d->map.nb_imgs != d->nb_imgs);
}

static GList *_get_images_on_active_tracks(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;

  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->map.gpx_view));
  GtkTreeIter iter;
  int segid = 0;
  GList *imgs = NULL;
  gboolean valid = gtk_tree_model_get_iter_first(model, &iter);
  while(valid)
  {
    gboolean active;
    gtk_tree_model_get(model, &iter, DT_GEO_TRACKS_ACTIVE, &active, -1);
    if(active)
    {
      for(GList *i = d->imgs; i; i = g_list_next(i))
      {
        dt_sel_img_t *im = i->data;
        if(im->segid == segid)
          imgs = g_list_prepend(imgs, GINT_TO_POINTER(im->imgid));
      }
    }
    valid = gtk_tree_model_iter_next(model, &iter);
    segid++;
  }
  return imgs;
}

static void _refresh_displayed_images(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->map.gpx_view));
  GtkTreeIter iter;
  const gboolean preview = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(d->map.preview_button));
  gboolean valid = gtk_tree_model_get_iter_first(model, &iter);
  for(int segid = 0; valid && segid < d->map.nb_tracks; segid++)
  {
    gboolean active;
    gtk_tree_model_get(model, &iter, DT_GEO_TRACKS_ACTIVE, &active, -1);
    _refresh_images_displayed_on_track(segid, active && preview, self);
    valid = gtk_tree_model_iter_next(model, &iter);
  }
}

static gboolean _update_map_box(const guint segid, GList *pts, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  // box for this track
  if(pts)
  {
    d->map.tracks->td[segid].map_box.lon1 = 180.0;
    d->map.tracks->td[segid].map_box.lon2 = -180.0;
    d->map.tracks->td[segid].map_box.lat1 = -90.0;
    d->map.tracks->td[segid].map_box.lat2 = 90.0;
    for(GList *pt = pts; pt; pt = g_list_next(pt))
    {
      dt_geo_map_display_point_t *p = pt->data;
      if(p->lon < d->map.tracks->td[segid].map_box.lon1)
        d->map.tracks->td[segid].map_box.lon1 = MAX(-180.0, p->lon);
      if(p->lon > d->map.tracks->td[segid].map_box.lon2)
        d->map.tracks->td[segid].map_box.lon2 = MIN(180.0, p->lon);
      if(p->lat > d->map.tracks->td[segid].map_box.lat1)
        d->map.tracks->td[segid].map_box.lat1 = MIN(90.0, p->lat);
      if(p->lat < d->map.tracks->td[segid].map_box.lat2)
        d->map.tracks->td[segid].map_box.lat2 = MAX(-90.0, p->lat);
    }
  }

  // box for all tracks
  float lon1 = 180.0;
  float lon2 = -180.0;
  float lat1 = -90.0;
  float lat2 = 90.0;
  for(int i = 0; i < d->map.nb_tracks; i++)
  {
    if(d->map.tracks->td[i].track)
    {
      if(d->map.tracks->td[i].map_box.lon1 < lon1)
        lon1 = d->map.tracks->td[i].map_box.lon1;
      if(d->map.tracks->td[i].map_box.lon2 > lon2)
        lon2 = d->map.tracks->td[i].map_box.lon2;
      if(d->map.tracks->td[i].map_box.lat1 > lat1)
        lat1 = d->map.tracks->td[i].map_box.lat1;
      if(d->map.tracks->td[i].map_box.lat2 < lat2)
        lat2 = d->map.tracks->td[i].map_box.lat2;
    }
  }
  const gboolean grow = lon1 < d->map.map_box.lon1 || lon2 > d->map.map_box.lon1 ||
                        lat1 > d->map.map_box.lat1 || lat2 < d->map.map_box.lat2;
  d->map.map_box.lon1 = lon1;
  d->map.map_box.lon2 = lon2;
  d->map.map_box.lat1 = lat1;
  d->map.map_box.lat2 = lat2;

  return grow;
}

static void _remove_tracks_from_map(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  if(d->map.tracks)
  {
    for(int i = 0; i < d->map.nb_tracks; i++)
    {
      if(d->map.tracks->td[i].track)
      {
        dt_view_map_remove_marker(darktable.view_manager, MAP_DISPLAY_TRACK,
                                  d->map.tracks->td[i].track);
        d->map.tracks->td[i].track = NULL;
      }
    }
    g_free(d->map.tracks);
    d->map.tracks = NULL;
  }
  if(d->map.gpx)
  {
    dt_gpx_destroy(d->map.gpx);
    d->map.gpx = NULL;
  }
}

GdkRGBA color[] = {(GdkRGBA){.red = 1.0, .green = 0.0, .blue = 0.0, .alpha = 0.5 },
                   (GdkRGBA){.red = 0.0, .green = 1.0, .blue = 1.0, .alpha = 0.5 },
                   (GdkRGBA){.red = 0.0, .green = 0.0, .blue = 1.0, .alpha = 0.5 },
                   (GdkRGBA){.red = 1.0, .green = 1.0, .blue = 0.0, .alpha = 0.5 },
                   (GdkRGBA){.red = 0.0, .green = 1.0, .blue = 0.0, .alpha = 0.5 },
                   (GdkRGBA){.red = 1.0, .green = 0.0, .blue = 1.0, .alpha = 0.5 }};

static gboolean _refresh_display_track(const gboolean active, const int segid, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  gboolean grow = FALSE;
  if(active)
  {
    GList *pts = dt_gpx_get_trkpts(d->map.gpx, segid);
    if(!d->map.tracks->td[segid].track)
      d->map.tracks->td[segid].track = dt_view_map_add_marker(darktable.view_manager,
                                                              MAP_DISPLAY_TRACK, pts);
    osm_gps_map_track_set_color((OsmGpsMapTrack *)d->map.tracks->td[segid].track, &color[segid % 6]);
    grow = _update_map_box(segid, pts, self);
    g_list_free_full(pts, g_free);
  }
  else
  {
    if(d->map.tracks->td[segid].track !=  NULL)
      dt_view_map_remove_marker(darktable.view_manager, MAP_DISPLAY_TRACK,
                                d->map.tracks->td[segid].track);
    d->map.tracks->td[segid].track =  NULL;
    _update_map_box(segid, NULL, self);
  }
  return grow;
}

static void _refresh_display_all_tracks(GtkWidget *widget, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->map.gpx_view));
  GtkTreeIter iter;
  gboolean valid = gtk_tree_model_get_iter_first(model, &iter);
  gboolean grow = FALSE;
  for(int segid = 0; valid && segid < d->map.nb_tracks; segid++)
  {
    gboolean active;
    gtk_tree_model_get(model, &iter, DT_GEO_TRACKS_ACTIVE, &active, -1);
    grow = _refresh_display_track(active, segid, self) ? TRUE : grow;
    valid = gtk_tree_model_iter_next(model, &iter);
  }

  if(grow)
  {
    dt_view_map_center_on_bbox(darktable.view_manager, d->map.map_box.lon1, d->map.map_box.lat1,
                                                       d->map.map_box.lon2, d->map.map_box.lat2);
  }
  _refresh_displayed_images(self);
}

static void _click_for_entire_track_pressed(GtkGestureSingle *gesture,
                                             int n_press,
                                             double x,
                                             double y,
                                             dt_lib_module_t *self)
{
  if(n_press == 2)
  {
    _refresh_display_all_tracks(NULL, self);
  }
}

static void _track_seg_toggled(GtkCellRendererToggle *cell_renderer, gchar *path_str, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->map.gpx_view));
  GtkTreeIter iter;
  GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
  gboolean active;
  uint32_t segid;

  gtk_tree_model_get_iter(model, &iter, path);
  gtk_tree_model_get(model, &iter, DT_GEO_TRACKS_ACTIVE, &active,
                                   DT_GEO_TRACKS_SEGID, &segid, -1);
  gtk_list_store_set(GTK_LIST_STORE(model), &iter, DT_GEO_TRACKS_ACTIVE, !active, -1);
  gtk_tree_path_free(path);

  active = !active;
  if(_refresh_display_track(active, segid, self))
  {
    dt_view_map_center_on_bbox(darktable.view_manager, d->map.map_box.lon1, d->map.map_box.lat1,
                                                       d->map.map_box.lon2, d->map.map_box.lat2);
  }

  const gboolean preview = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(d->map.preview_button));
  _refresh_images_displayed_on_track(segid, active && preview, self);
  _update_nb_images(self);
  _update_buttons(self);
}

static void _all_tracks_toggled(GtkTreeViewColumn *column, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  GtkWidget *toggle = gtk_tree_view_column_get_widget(column);
  gboolean active = !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), active);

  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->map.gpx_view));
  GtkTreeIter iter;
  gboolean valid = gtk_tree_model_get_iter_first(model, &iter);
  gboolean grow = FALSE;
  for(int segid = 0; valid && segid < d->map.nb_tracks; segid++)
  {
    gtk_list_store_set(GTK_LIST_STORE(model), &iter,
                       DT_GEO_TRACKS_ACTIVE, active,-1);
    grow = _refresh_display_track(active, segid, self) ? TRUE : grow;
    valid = gtk_tree_model_iter_next(model, &iter);
  }
  if(active && grow)
  {
    dt_view_map_center_on_bbox(darktable.view_manager, d->map.map_box.lon1, d->map.map_box.lat1,
                                                       d->map.map_box.lon2, d->map.map_box.lat2);
  }
  _refresh_displayed_images(self);
  _update_nb_images(self);
  _update_buttons(self);
}

static void _select_images(GtkWidget *widget, dt_lib_module_t *self)
{
  GList *imgs = _get_images_on_active_tracks(self);
  dt_selection_clear(darktable.selection);
  dt_selection_select_list(darktable.selection, imgs);
  g_list_free(imgs);
}

static void _images_preview_toggled(GtkToggleButton *button, dt_lib_module_t *self)
{
  _refresh_displayed_images(self);
}

static void _refresh_track_list(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  if(!d->map.gpx) return;

  GList *trkseg = dt_gpx_get_trkseg(d->map.gpx);
  _remove_images_from_map(self);
  for(GList *i = d->imgs; i; i = g_list_next(i))
    ((dt_sel_img_t *)i->data)->segid = -1;

  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->map.gpx_view));
  GtkTreeIter iter;
  gboolean valid = gtk_tree_model_get_iter_first(model, &iter);
  for(GList *ts = trkseg; ts && valid; ts = g_list_next(ts))
  {
    dt_gpx_track_segment_t *t = ts->data;
    gchar *dts = _utc_timeval_to_localtime_text(t->start_dt, d->tz_camera, TRUE);
    const int nb_imgs = _count_images_per_track(t, ts->next ? ts->next->data : NULL, self);
    gboolean active;
    gtk_tree_model_get(model, &iter, DT_GEO_TRACKS_ACTIVE, &active, -1);
    gchar *tooltip = _datetime_tooltip(t->start_dt, t->end_dt, d->tz_camera);
    gtk_list_store_set(GTK_LIST_STORE(model), &iter,
                       DT_GEO_TRACKS_DATETIME, dts,
                       DT_GEO_TRACKS_POINTS, t->nb_trkpt,
                       DT_GEO_TRACKS_IMAGES, nb_imgs,
                       DT_GEO_TRACKS_TOOLTIP, tooltip,
                       -1);
    g_free(dts);
    g_free(tooltip);
    valid = gtk_tree_model_iter_next(model, &iter);
  }
  _update_nb_images(self);
  _refresh_displayed_images(self);
  _update_buttons(self);
}

static void _show_gpx_tracks(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  _remove_tracks_from_map(self);
  d->map.gpx = dt_gpx_new(gtk_label_get_text(GTK_LABEL(d->map.gpx_file)));
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->map.gpx_view));
  g_object_ref(model);
  gtk_tree_view_set_model(GTK_TREE_VIEW(d->map.gpx_view), NULL);
  gtk_list_store_clear(GTK_LIST_STORE(model));

  GList *trkseg = dt_gpx_get_trkseg(d->map.gpx);
  d->map.nb_tracks = g_list_length(trkseg);
  d->map.tracks = g_try_malloc0(sizeof(dt_lib_tracks_data_t) * d->map.nb_tracks);
  if(!d->map.tracks)
  {
    d->map.nb_tracks = 0;
    dt_print(DT_DEBUG_ALWAYS, "[geotagging] unable to allocate storage for tracks");
  }

  _remove_images_from_map(self);
  for(GList *i = d->imgs; i; i = g_list_next(i))
    ((dt_sel_img_t *)i->data)->segid = -1;

  int segid = 0;
  const gboolean active = gtk_toggle_button_get_active(
                          GTK_TOGGLE_BUTTON(gtk_tree_view_column_get_widget(d->map.sel_tracks)));
  for(GList *ts = trkseg; ts; ts = g_list_next(ts))
  {
    dt_gpx_track_segment_t *t = ts->data;
    gchar *dts = _utc_timeval_to_localtime_text(t->start_dt, d->tz_camera, TRUE);
    gchar *tooltip = _datetime_tooltip(t->start_dt, t->end_dt, d->tz_camera);
    const int nb_imgs = _count_images_per_track(t, ts->next ? ts->next->data : NULL, self);
    gtk_list_store_insert_with_values(GTK_LIST_STORE(model), NULL, -1,
                       DT_GEO_TRACKS_ACTIVE, active,
                       DT_GEO_TRACKS_DATETIME, dts,
                       DT_GEO_TRACKS_POINTS, t->nb_trkpt,
                       DT_GEO_TRACKS_IMAGES, nb_imgs,
                       DT_GEO_TRACKS_SEGID, segid,
                       DT_GEO_TRACKS_TOOLTIP, tooltip,
                       -1);
    segid++;
    g_free(dts);
    g_free(tooltip);
  }
  gtk_tree_view_set_model(GTK_TREE_VIEW(d->map.gpx_view), model);
  g_object_unref(model);

  gtk_tree_view_column_set_clickable(d->map.sel_tracks, TRUE);
  _update_nb_images(self);
  _update_buttons(self);
  _refresh_display_all_tracks(NULL, self);
}

static void _apply_gpx(GtkWidget *widget, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  gchar *tz = dt_conf_get_string("plugins/lighttable/geotagging/tz");
  GList *imgs = _get_images_on_active_tracks(self);
  if(imgs)
  {
    if(d->offset)
    {
      GList *imgs2 = g_list_copy(imgs);
      dt_control_datetime(d->offset, NULL, imgs2);
    }
    dt_control_gpx_apply(gtk_label_get_text(GTK_LABEL(d->map.gpx_file)), -1, tz, imgs);
  }
  g_free(tz);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->map.preview_button), FALSE);
}

static void _update_layout(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  gtk_widget_set_visible(d->gpx_button, !d->map.view);
  gtk_widget_set_visible(d->map.gpx_section, d->map.view);
}

static void _view_changed(gpointer instance, dt_view_t *old_view,
                          dt_view_t *new_view, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  if(old_view != new_view)
  {
    d->map.view = !g_strcmp0(new_view->module_name, "map");
    if(d->map.view)
    {
      _setup_selected_images_list(self);
      _refresh_track_list(self);
    }
    _update_layout(self);
  }
}

static void _geotag_changed(gpointer instance, GList *imgs, const int locid, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  if(d->map.view && !locid)
  {
    _refresh_displayed_images(self);
    _update_nb_images(self);
    _update_buttons(self);
  }
}

static void _refresh_selected_images_datetime(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  for(GList *i = d->imgs; i; i = g_list_next(i))
  {
    dt_sel_img_t *img = i->data;
    const dt_image_t *cimg = dt_image_cache_get(img->imgid, 'r');
    if(!cimg) continue;
    dt_datetime_img_to_exif(img->dt, sizeof(img->dt), cimg);
    dt_image_cache_read_release(cimg);
  }
}

static gboolean _row_tooltip_setup(GtkWidget *view, gint x, gint y, gboolean kb_mode,
                                   GtkTooltip* tooltip, dt_lib_module_t *self)
{
  gboolean res = FALSE;
  GtkTreePath *path = NULL;
  GtkTreeViewColumn *column = NULL;
  // Get view path mouse position
  gint tx, ty;
  gtk_tree_view_convert_widget_to_bin_window_coords(GTK_TREE_VIEW(view), x, y, &tx, &ty);
  if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(view), tx, ty, &path, &column, NULL, NULL))
  {
    GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
    GtkTreeIter iter;
    if(gtk_tree_model_get_iter(model, &iter, path))
    {
      char *text = NULL;
      gtk_tree_model_get(model, &iter, DT_GEO_TRACKS_TOOLTIP, &text, -1);
      if(text && text[0] != '\0')
      {
        gtk_tooltip_set_text(tooltip, text);
        res = TRUE;
      }
      g_free(text);
    }
  }
  gtk_tree_path_free(path);
  return res;
}
#endif // HAVE_MAP

static void _preview_gpx_file(GtkWidget *widget, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
  GtkWidget *dialog = gtk_dialog_new_with_buttons(_("GPX file track segments"), GTK_WINDOW(win),
                                                  GTK_DIALOG_DESTROY_WITH_PARENT,
                                                  _("_done"), GTK_RESPONSE_CANCEL, NULL);
  gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CANCEL);

  gchar *filedir = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget));
  struct dt_gpx_t *gpx = dt_gpx_new(filedir);
  g_free(filedir);

  GtkWidget *grid = gtk_grid_new();
  gtk_grid_set_column_spacing(GTK_GRID(grid), DT_PIXEL_APPLY_DPI(10));
  int line = 0;

  GList *trkseg = dt_gpx_get_trkseg(gpx);

  _set_up_label(_("name"), GTK_ALIGN_START, grid, 0, line, PANGO_ELLIPSIZE_NONE);
  _set_up_label(_("start time"), GTK_ALIGN_START, grid, 1, line, PANGO_ELLIPSIZE_NONE);
  _set_up_label(_("end time"), GTK_ALIGN_START, grid, 2, line, PANGO_ELLIPSIZE_NONE);
  _set_up_label(_("points"), GTK_ALIGN_CENTER, grid, 3, line, PANGO_ELLIPSIZE_NONE);
  _set_up_label(_("images"), GTK_ALIGN_CENTER, grid, 4, line, PANGO_ELLIPSIZE_NONE);

  for(GList *i = d->imgs; i; i = g_list_next(i))
    ((dt_sel_img_t *)i->data)->segid = -1;
  int total_imgs = 0;
  int total_pts = 0;
  line++;
  for(GList *ts = trkseg; ts; ts = g_list_next(ts))
  {
    dt_gpx_track_segment_t *t = ts->data;
    gchar *dts = _utc_timeval_to_localtime_text(t->start_dt, d->tz_camera, TRUE);
    gchar *dte = _utc_timeval_to_localtime_text(t->end_dt, d->tz_camera, TRUE);

    const int nb_imgs = _count_images_per_track(t, ts->next ? ts->next->data : NULL,self);
    total_imgs += nb_imgs;

    _set_up_label(t->name, GTK_ALIGN_START, grid, 0, line, PANGO_ELLIPSIZE_NONE);
    _set_up_label(dts, GTK_ALIGN_START, grid, 1, line, PANGO_ELLIPSIZE_NONE);
    _set_up_label(dte, GTK_ALIGN_START, grid, 2, line, PANGO_ELLIPSIZE_NONE);
    char *nb = g_strdup_printf("%u", t->nb_trkpt);
    _set_up_label(nb, GTK_ALIGN_CENTER, grid, 3, line, PANGO_ELLIPSIZE_NONE);
    g_free(nb);
    nb = g_strdup_printf("%d", nb_imgs);
    _set_up_label(nb, GTK_ALIGN_CENTER, grid, 4, line, PANGO_ELLIPSIZE_NONE);
    g_free(nb);
    line++;
    total_pts += t->nb_trkpt;
    g_free(dts);
    g_free(dte);
  }

  char *nb = g_strdup_printf("%d", total_pts);
  _set_up_label(nb, GTK_ALIGN_CENTER, grid, 3, line, PANGO_ELLIPSIZE_NONE);
  g_free(nb);
  nb = g_strdup_printf("%d / %d", total_imgs, d->nb_imgs);
  _set_up_label(nb, GTK_ALIGN_CENTER, grid, 4, line, PANGO_ELLIPSIZE_NONE);
  g_free(nb);

  if(gpx)
  {
    dt_gpx_destroy(gpx);
    gpx = NULL;
  }

  GtkWidget *w = dt_gui_scroll_wrap(grid);
  gtk_widget_set_size_request(w, -1, DT_PIXEL_APPLY_DPI(100));
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
  dt_gui_dialog_add(GTK_DIALOG(dialog), w);

#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(dialog);
#endif
  gtk_widget_show_all(dialog);
  gtk_dialog_run(GTK_DIALOG(dialog));

  gtk_widget_destroy(dialog);
}

static void _setup_selected_images_list(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  if(d->imgs)
  {
#ifdef HAVE_MAP
    _remove_images_from_map(self);
#endif
    g_list_free_full(d->imgs, g_free);
  }
  d->imgs = NULL;
  d->nb_imgs = 0;

  sqlite3_stmt *stmt;
  DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
                              "SELECT imgid FROM main.selected_images",
                              -1, &stmt, NULL);
  while(sqlite3_step(stmt) == SQLITE_ROW)
  {
    const dt_imgid_t imgid = sqlite3_column_int(stmt, 0);
    const dt_image_t *cimg = dt_image_cache_get(imgid, 'r');
    char dt[DT_DATETIME_LENGTH];
    if(!cimg) continue;
    dt_datetime_img_to_exif(dt, sizeof(dt), cimg);
    dt_image_cache_read_release(cimg);

    dt_sel_img_t *img = g_try_malloc0(sizeof(dt_sel_img_t));
    if(!img) continue;
    memcpy(img->dt, dt, DT_DATETIME_LENGTH);
    img->imgid = imgid;
    d->imgs = g_list_prepend(d->imgs, img);
    d->nb_imgs++;
  }
  sqlite3_finalize(stmt);
}

static void _choose_gpx_callback(GtkWidget *widget, dt_lib_module_t *self)
{
  // bring a filechooser to select the gpx file to apply to selection
  dt_lib_geotagging_t *d = self->data;
  GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
  GtkWidget *filechooser = gtk_file_chooser_dialog_new(
            _("open GPX file"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN,
            _("preview"), GTK_RESPONSE_ACCEPT,
            _("_cancel"), GTK_RESPONSE_CANCEL,
            _("_open"), GTK_RESPONSE_OK, (char *)NULL);
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(filechooser);
#endif

  dt_conf_get_folder_to_file_chooser("ui_last/gpx_last_directory", GTK_FILE_CHOOSER(filechooser));

  GtkFileFilter *filter;
  filter = GTK_FILE_FILTER(gtk_file_filter_new());
  gtk_file_filter_add_custom(filter, GTK_FILE_FILTER_FILENAME | GTK_FILE_FILTER_MIME_TYPE,
                             _lib_geotagging_filter_gpx, NULL, NULL);
  gtk_file_filter_set_name(filter, _("GPS data exchange format"));
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);

  filter = GTK_FILE_FILTER(gtk_file_filter_new());
  gtk_file_filter_add_pattern(filter, "*");
  gtk_file_filter_set_name(filter, _("all files"));
  gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(filechooser), filter);

  if(!d->imgs)
    _setup_selected_images_list(self);

  int res = gtk_dialog_run(GTK_DIALOG(filechooser));
  while(res == GTK_RESPONSE_ACCEPT)
  {
    _preview_gpx_file(filechooser, self);
    res = gtk_dialog_run(GTK_DIALOG(filechooser));
  }
  if(res == GTK_RESPONSE_OK)
  {
    dt_conf_set_folder_from_file_chooser("ui_last/gpx_last_directory", GTK_FILE_CHOOSER(filechooser));

    gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));

#ifdef HAVE_MAP
    if(d->map.view)
    {
      gtk_label_set_text(GTK_LABEL(d->map.gpx_file), filename);
      _show_gpx_tracks(self);
      gtk_widget_set_visible(d->map.gpx_view, d->map.view);
    }
    else
#endif
    {
      gchar *tz = dt_conf_get_string("plugins/lighttable/geotagging/tz");
      dt_control_gpx_apply(filename, -1, tz, NULL);
      g_free(tz);
      g_list_free_full(d->imgs, g_free);
      d->imgs = NULL;
      d->nb_imgs = 0;
    }
    g_free(filename);
  }

  gtk_widget_destroy(filechooser);
  //   dt_control_queue_redraw_center();
}

static int _sort_timezones(gconstpointer a, gconstpointer b)
{
  const tz_tuple_t *tz_a = (tz_tuple_t *)a;
  const tz_tuple_t *tz_b = (tz_tuple_t *)b;

#ifdef _WIN32
  gboolean utc_neg_a = g_str_has_prefix(tz_a->display, "(UTC-");
  gboolean utc_neg_b = g_str_has_prefix(tz_b->display, "(UTC-");

  gboolean utc_pos_a = g_str_has_prefix(tz_a->display, "(UTC+");
  gboolean utc_pos_b = g_str_has_prefix(tz_b->display, "(UTC+");

  if(utc_neg_a && utc_neg_b)
  {
    char *iter_a = tz_a->display + strlen("(UTC-");
    char *iter_b = tz_b->display + strlen("(UTC-");

    while(((*iter_a >= '0' && *iter_a <= '9') || *iter_a == ':') &&
          ((*iter_b >= '0' && *iter_b <= '9') || *iter_b == ':'))
    {
      if(*iter_a != *iter_b) return *iter_b - *iter_a;
      iter_a++;
      iter_b++;
    }
  }
  else if(utc_neg_a && utc_pos_b) return -1;
  else if(utc_pos_a && utc_neg_b) return 1;
#endif

  return g_strcmp0(tz_a->display, tz_b->display);
}

// create a list of possible time zones
static GList *_lib_geotagging_get_timezones(void)
{
  GList *timezones = NULL;

#ifndef _WIN32
  // possible locations for zone.tab:
  // - /usr/share/zoneinfo
  // - /usr/lib/zoneinfo
  // - getenv("TZDIR")
  // - apparently on solaris there is no zones.tab. we need to collect the information ourselves like this:
  //   /bin/grep -h ^Zone /usr/share/lib/zoneinfo/src/* | /bin/awk '{print "??\t+9999+99999\t" $2}'
#define MAX_LINE_LENGTH 256
  FILE *fp;
  char line[MAX_LINE_LENGTH];

  // find the file using known possible locations
  gchar *zone_tab = g_strdup("/usr/share/zoneinfo/zone.tab");
  if(!g_file_test(zone_tab, G_FILE_TEST_IS_REGULAR))
  {
    g_free(zone_tab);
    zone_tab = g_strdup("/usr/lib/zoneinfo/zone.tab");
    if(!g_file_test(zone_tab, G_FILE_TEST_IS_REGULAR))
    {
      g_free(zone_tab);
      zone_tab = g_build_filename(g_getenv("TZDIR"), "zone.tab", NULL);
      if(!g_file_test(zone_tab, G_FILE_TEST_IS_REGULAR))
      {
        g_free(zone_tab);
        char datadir[PATH_MAX] = { 0 };
        dt_loc_get_datadir(datadir, sizeof(datadir));
        zone_tab = g_build_filename(datadir, "zone.tab", NULL);
        if(!g_file_test(zone_tab, G_FILE_TEST_IS_REGULAR))
        {
          g_free(zone_tab);
          // TODO: Solaris test
          return NULL;
        }
      }
    }
  }

  // parse zone.tab and put all time zone descriptions into timezones
  fp = g_fopen(zone_tab, "r");
  g_free(zone_tab);

  if(!fp) return NULL;

  while(fgets(line, MAX_LINE_LENGTH, fp))
  {
    if(line[0] == '#' || line[0] == '\0') continue;
    gchar **tokens = g_strsplit_set(line, " \t\n", 0);
    // sometimes files are not separated by single tabs but multiple spaces, resulting in empty strings in tokens
    // so we have to look for the 3rd non-empty entry
    int n_found = -1, i;
    for(i = 0; tokens[i] && n_found < 2; i++) if(*tokens[i]) n_found++;
    if(n_found != 2)
    {
      g_strfreev(tokens);
      continue;
    }
    gchar *name = g_strdup(tokens[i - 1]);
    g_strfreev(tokens);
    if(name[0] == '\0')
    {
      g_free(name);
      continue;
    }
    size_t last_char = strlen(name) - 1;
    if(name[last_char] == '\n') name[last_char] = '\0';
    tz_tuple_t *tz_tuple = malloc(sizeof(tz_tuple_t));
    if(tz_tuple)
    {
      tz_tuple->display = name;
      tz_tuple->name = name;
      timezones = g_list_prepend(timezones, tz_tuple);
    }
  }

  fclose(fp);

  // sort timezones
  timezones = g_list_sort(timezones, _sort_timezones);

  tz_tuple_t *utc = malloc(sizeof(tz_tuple_t));
  if(utc)
  {
    utc->display = g_strdup("UTC");
    utc->name = utc->display;
    timezones = g_list_prepend(timezones, utc);
  }

#undef MAX_LINE_LENGTH

#else // !_WIN32
  // on Windows we have to grab the time zones from the registry
  char *keypath = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\";
  HKEY hKey;

  if(RegOpenKeyExA(HKEY_LOCAL_MACHINE,
                   keypath,
                   0,
                   KEY_READ,
                   &hKey) == ERROR_SUCCESS)
  {
    DWORD n_subkeys, max_subkey_len;

    if(RegQueryInfoKey(hKey,
                       NULL,
                       NULL,
                       NULL,
                       &n_subkeys,
                       &max_subkey_len,
                       NULL,
                       NULL,
                       NULL,
                       NULL,
                       NULL,
                       NULL) == ERROR_SUCCESS)
    {
      wchar_t *subkeyname = malloc(sizeof(wchar_t) * (max_subkey_len + 1));

      for(DWORD i = 1; i < n_subkeys; i++)
      {
        DWORD subkeyname_length = max_subkey_len + 1;
        if(RegEnumKeyExW(hKey,
                         i,
                         subkeyname,
                         &subkeyname_length,
                         NULL,
                         NULL,
                         NULL,
                         NULL) == ERROR_SUCCESS)
        {
          DWORD buffer_size;
          char *subkeyname_utf8 = g_utf16_to_utf8(subkeyname, -1, NULL, NULL, NULL);
          char *subkeypath_utf8 = g_strconcat(keypath, "\\", subkeyname_utf8, NULL);
          wchar_t *subkeypath = g_utf8_to_utf16(subkeypath_utf8, -1, NULL, NULL, NULL);
          if(RegGetValueW(HKEY_LOCAL_MACHINE,
                          subkeypath,
                          L"Display",
                          RRF_RT_ANY,
                          NULL,
                          NULL,
                          &buffer_size) == ERROR_SUCCESS)
          {
            wchar_t *display_name = malloc(buffer_size);
            if(RegGetValueW(HKEY_LOCAL_MACHINE,
                            subkeypath,
                            L"Display",
                            RRF_RT_ANY,
                            NULL,
                            display_name,
                            &buffer_size) == ERROR_SUCCESS)
            {
              tz_tuple_t *tz = malloc(sizeof(tz_tuple_t));
              if(tz)
              {
                tz->name = subkeyname_utf8;
                tz->display = g_utf16_to_utf8(display_name, -1, NULL, NULL, NULL);
                timezones = g_list_prepend(timezones, tz);
              }
              subkeyname_utf8 = NULL; // to not free it later
            }
            free(display_name);
          }
          g_free(subkeyname_utf8);
          g_free(subkeypath_utf8);
          g_free(subkeypath);
        }
      }

      free(subkeyname);
    }
  }

  RegCloseKey(hKey);

  timezones = g_list_sort(timezones, _sort_timezones);
#endif // !_WIN32

  return timezones;
}

static void _display_offset(const GTimeSpan offset_int, const gboolean valid, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  GTimeSpan off2 = 0;
  if(valid)
  {
    const gboolean neg = offset_int < 0;
    gtk_label_set_text(GTK_LABEL(d->of.sign), neg ? "- " : "");
    char text[5];
    GTimeSpan off = neg ? -offset_int : offset_int;
    off2 = off / 1000;  // skip microseconds
    off = off2;
    off2 = off / 1000;
    snprintf(text, sizeof(text), "%03d", (int)(off - off2 * 1000));
    gtk_entry_set_text(GTK_ENTRY(d->of.widget[6]), text);
    off = off2;
    off2 = off / 60;
    snprintf(text, sizeof(text), "%02d", (int)(off - off2 * 60));
    gtk_entry_set_text(GTK_ENTRY(d->of.widget[5]), text);
    off = off2;
    off2 = off / 60;
    snprintf(text, sizeof(text), "%02d", (int)(off - off2 * 60));
    gtk_entry_set_text(GTK_ENTRY(d->of.widget[4]), text);
    off = off2;
    off2 = off / 24;
    snprintf(text, sizeof(text), "%02d", (int)(off - off2 * 24));
    gtk_entry_set_text(GTK_ENTRY(d->of.widget[3]), text);
    off = off2;
    off2 = off / 10000;
    snprintf(text, sizeof(text), "%04d", (int)(off - off2 * 10000));
    gtk_entry_set_text(GTK_ENTRY(d->of.widget[2]), text);
  }
  if(!valid || off2)
  {
    gtk_label_set_text(GTK_LABEL(d->of.sign), "");
    for(int i = 2; i < DT_GEOTAG_PARTS_NB; i++)
      gtk_entry_set_text(GTK_ENTRY(d->of.widget[i]), "-");
  }
  const gboolean locked = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(d->lock_offset));
  gtk_widget_set_sensitive(d->apply_offset, d->imgid && valid && !off2 && offset_int);
  gtk_widget_set_sensitive(d->lock_offset, locked || (d->imgid && valid && !off2 && offset_int));
  gtk_widget_set_sensitive(d->apply_datetime, d->imgid && !locked);
#ifdef HAVE_MAP
  _update_buttons(self);
#endif
}

static void _display_datetime(dt_lib_datetime_t *dtw, GDateTime *datetime,
                              const gboolean lock, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  for(int i = 0; lock && i < DT_GEOTAG_PARTS_NB; i++)
    g_signal_handlers_block_by_func(d->dt.widget[i], _datetime_entry_changed, self);
  if(datetime)
  {
    char value[8] = {0};
    snprintf(value, sizeof(value), "%04d", g_date_time_get_year(datetime));
    gtk_entry_set_text(GTK_ENTRY(dtw->widget[0]), value);
    snprintf(value, sizeof(value), "%02d", g_date_time_get_month(datetime));
    gtk_entry_set_text(GTK_ENTRY(dtw->widget[1]), value);
    snprintf(value, sizeof(value), "%02d", g_date_time_get_day_of_month(datetime));
    gtk_entry_set_text(GTK_ENTRY(dtw->widget[2]), value);
    snprintf(value, sizeof(value), "%02d", g_date_time_get_hour(datetime));
    gtk_entry_set_text(GTK_ENTRY(dtw->widget[3]), value);
    snprintf(value, sizeof(value), "%02d", g_date_time_get_minute(datetime));
    gtk_entry_set_text(GTK_ENTRY(dtw->widget[4]),value);
    snprintf(value, sizeof(value), "%02d", g_date_time_get_second(datetime));
    gtk_entry_set_text(GTK_ENTRY(dtw->widget[5]), value);
    snprintf(value, sizeof(value), "%03d", (int)(g_date_time_get_microsecond(datetime) * 0.001));
    gtk_entry_set_text(GTK_ENTRY(dtw->widget[6]), value);
  }
  else
  {
    for(int i = 0; i < DT_GEOTAG_PARTS_NB; i++)
      gtk_entry_set_text(GTK_ENTRY(dtw->widget[i]), "-");
  }
  for(int i = 0; lock && i < DT_GEOTAG_PARTS_NB; i++)
    g_signal_handlers_unblock_by_func(d->dt.widget[i], _datetime_entry_changed, self);
}

// read the current date/time and make correction (field under/overflow)
static GDateTime *_read_datetime_entry(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;

  const int year = atoi(gtk_entry_get_text(GTK_ENTRY(d->dt.widget[0])));
  const int month = atoi(gtk_entry_get_text(GTK_ENTRY(d->dt.widget[1])));
  const int day = atoi(gtk_entry_get_text(GTK_ENTRY(d->dt.widget[2])));
  const int hour = atoi(gtk_entry_get_text(GTK_ENTRY(d->dt.widget[3])));
  const int minute = atoi(gtk_entry_get_text(GTK_ENTRY(d->dt.widget[4])));
  const int second = atoi(gtk_entry_get_text(GTK_ENTRY(d->dt.widget[5])));
  const int millisecond = atoi(gtk_entry_get_text(GTK_ENTRY(d->dt.widget[6])));
  const gdouble second2 = (gdouble)second + (gdouble)millisecond * 0.001;

  return g_date_time_new(darktable.utc_tz, year, month, day, hour, minute, second2);
}

static void _new_datetime(GDateTime *datetime, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  if(datetime)
  {
    _display_datetime(&d->dt, datetime, TRUE, self);

    if(d->datetime)
      g_date_time_unref(d->datetime);
    d->datetime = datetime;
    d->offset = g_date_time_difference(d->datetime, d->datetime0);
    _display_offset(d->offset, d->datetime != NULL, self);
#ifdef HAVE_MAP
    if(d->map.view)
      _refresh_track_list(self);
#endif
  }
}

static void _datetime_entry_changed(GtkWidget *entry, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  if(!d->editing)
  {
    GDateTime *datetime = _read_datetime_entry(self);
    _new_datetime(datetime, self);
  }
}

static GDateTime *_get_image_datetime(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  GList *selected = dt_collection_get_selected(darktable.collection, 1);
  const int selid = selected ? GPOINTER_TO_INT(selected->data) : 0;
  const dt_imgid_t imgid = dt_act_on_get_main_image();
  GDateTime *datetime = NULL;
  if((selid != 0) || ((selid == 0) && (dt_is_valid_imgid(imgid))))
  {
    // consider act on only if no selected
    char datetime_s[DT_DATETIME_LENGTH];
    dt_image_get_datetime(selid ? selid : imgid, datetime_s);
    if(datetime_s[0] != '\0')
      datetime = dt_datetime_exif_to_gdatetime(datetime_s, darktable.utc_tz);
    else
      datetime = NULL;
  }
  d->imgid = selid;
  return datetime;
}

static void _refresh_image_datetime(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  const gboolean locked = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(d->lock_offset));
  GDateTime *datetime = _get_image_datetime(self);
  if(d->datetime0)
    g_date_time_unref(d->datetime0);
  d->datetime0 = datetime;
  _display_datetime(&d->dt0, datetime, FALSE, self);
  if(locked)
  {
    if(datetime)
    {
      GDateTime *datetime2 = g_date_time_add(datetime, d->offset);
      _new_datetime(datetime2, self);
    }
  }
  else
  {
    _display_offset(d->offset = 0, datetime != NULL, self);
    if(datetime)
    {
      g_date_time_ref(datetime);
      _new_datetime(datetime, self);
    }
  }
}

static void _image_info_changed(gpointer instance, gpointer imgs, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  for(GList *i = imgs; i; i = g_list_next(i))
  {
    if(GPOINTER_TO_INT(i->data) == d->imgid)
    {
      _refresh_image_datetime(self);
      break;
    }
  }
#ifdef HAVE_MAP
  if(d->map.view)
  {
    _refresh_selected_images_datetime(self);
    _refresh_track_list(self);
  }
#endif
}

static void _mouse_over_image_callback(gpointer instance, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  if(!d->imgid)
    _refresh_image_datetime(self);
}

static void _selection_changed_callback(gpointer instance, dt_lib_module_t *self)
{
  _refresh_image_datetime(self);
#ifdef HAVE_MAP
  dt_lib_geotagging_t *d = self->data;
  if(d->map.view)
  {
    _setup_selected_images_list(self);
    _refresh_track_list(self);
  }
#endif
}

static void _datetime_scroll_over(GtkEventControllerScroll *controller,
                                  double dx, double dy,
                                  dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  if(!d->editing)
  {
    GtkWidget* w = dt_gui_get_widget(controller);
    int i = 0;
    for(i = 0; i < DT_GEOTAG_PARTS_NB; i++)
      if(w == d->dt.widget[i]) break;

    int increment = CLAMPF(-dy, -1, 1);
    if(dt_modifier_eq(controller, GDK_SHIFT_MASK))
      increment *= 10;

    GDateTime *datetime;
    switch(i)
    {
      case 0:
        datetime = g_date_time_add_years(d->datetime, increment);
        break;
      case 1:
        datetime = g_date_time_add_months(d->datetime, increment);
        break;
      case 2:
        datetime = g_date_time_add_days(d->datetime, increment);
        break;
      case 3:
        datetime = g_date_time_add_hours(d->datetime, increment);
        break;
      case 4:
        datetime = g_date_time_add_minutes(d->datetime, increment);
        break;
      case 5:
        datetime = g_date_time_add_seconds(d->datetime, increment);
        break;
      case 6:
        datetime = g_date_time_add(d->datetime, increment * 1000);
        break;
      default:
        datetime = NULL;
    }

    _new_datetime(datetime, self);
  }
}

// type 0 date/time, 1 original date/time, 2 offset
static GtkWidget *_gui_init_datetime(gchar *text,
                                     dt_lib_datetime_t *dt,
                                     const int type,
                                     dt_lib_module_t *self,
                                     GtkSizeGroup *group,
                                     GtkWidget *button,
                                     gchar *tip)
{
  GtkWidget *flow = gtk_flow_box_new();
  gtk_flow_box_set_max_children_per_line(GTK_FLOW_BOX(flow), 2);

  GtkWidget *t = dt_ui_label_new(text);
  gtk_size_group_add_widget(group, t);
  gtk_container_add(GTK_CONTAINER(flow), t);
  gtk_widget_set_tooltip_text(flow, tip);

  GtkWidget *flow2 = gtk_flow_box_new();
  gtk_flow_box_set_homogeneous(GTK_FLOW_BOX(flow2), TRUE); // otherwise weird behavior
  gtk_flow_box_set_max_children_per_line(GTK_FLOW_BOX(flow2), 2);
  gtk_container_add(GTK_CONTAINER(flow), flow2);

  GtkBox *box = NULL;
  for(int i = 0; i < DT_GEOTAG_PARTS_NB; i++)
  {
    if(!box) box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));

    if(i == 0 && type == 2)
    {
      gtk_box_set_homogeneous(box, TRUE); // creates some spacing
      gtk_box_pack_start(box, button, TRUE, TRUE, 0);
      dt->sign = gtk_label_new("");
      gtk_box_pack_start(box, dt->sign, FALSE, FALSE, 0);
    }
    if(i >= 2 || type != 2)
    {
      // 1st field of dates (offset line is excluded by "if" above) is year, so 4 digits
      dt->widget[i] = dt_ui_entry_new(i == 0 ? 4
      // 7th field (optional, may be hidden) is msec, so 3 digits
                                             : i == 6 ? 3
      // 2nd widget of offset line should accommodate offsets up to 9999 days, so 4 digits
      // all other fields for 2 digit numbers
                                                      : ((type == 2) && (i == 2)) ? 4 : 2);
      gtk_entry_set_alignment(GTK_ENTRY(dt->widget[i]), 0.5);
      gtk_box_pack_start(box, dt->widget[i], FALSE, FALSE, 0);
      if(type == 0)
      {
        dt_action_define(DT_ACTION(self), NULL, i <= 2 ? N_("date") : N_("time"), dt->widget[i], &dt_action_def_entry);
        gtk_widget_add_events(dt->widget[i], darktable.gui->scroll_mask);
      }
      else
      {
        gtk_widget_set_sensitive(dt->widget[i], FALSE);
      }
    }

    if(i == 2 || i == 6)
    {
      gtk_widget_set_halign(GTK_WIDGET(box), GTK_ALIGN_END);
      gtk_widget_set_hexpand(GTK_WIDGET(box), TRUE);
      gtk_container_add(GTK_CONTAINER(flow2), GTK_WIDGET(box));
      box = NULL;
    }
    else if(i > 2 || type != 2)
    {
      GtkWidget *label = gtk_label_new(i < 2 ? "-" : i == 5 ? "." :":");
      if(i == 5)
        g_object_set_data(G_OBJECT(dt->widget[i]), "msec_label", label);
      gtk_box_pack_start(box, label, FALSE, FALSE, 0);
    }
  }

  gtk_container_foreach(GTK_CONTAINER(flow2), (GtkCallback)gtk_widget_set_can_focus, GINT_TO_POINTER(FALSE));

  return flow;
}

static gboolean _datetime_key_pressed(GtkEventControllerKey *controller,
                                      guint keyval,
                                      guint keycode,
                                      GdkModifierType state,
                                      dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  switch(keyval)
  {
    case GDK_KEY_Escape:
    {
      // reset
      _refresh_image_datetime(self);
#ifdef HAVE_MAP
      if(d->map.view)
        _refresh_track_list(self);
#endif
      gtk_window_set_focus(GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)), NULL);
      d->editing = FALSE;
      return FALSE;
    }
    // allow  0 .. 9, left/right/home/end movement using arrow keys and del/backspace
    case GDK_KEY_0:
    case GDK_KEY_KP_0:
    case GDK_KEY_1:
    case GDK_KEY_KP_1:
    case GDK_KEY_2:
    case GDK_KEY_KP_2:
    case GDK_KEY_3:
    case GDK_KEY_KP_3:
    case GDK_KEY_4:
    case GDK_KEY_KP_4:
    case GDK_KEY_5:
    case GDK_KEY_KP_5:
    case GDK_KEY_6:
    case GDK_KEY_KP_6:
    case GDK_KEY_7:
    case GDK_KEY_KP_7:
    case GDK_KEY_8:
    case GDK_KEY_KP_8:
    case GDK_KEY_9:
    case GDK_KEY_KP_9:
    case GDK_KEY_Delete:
    case GDK_KEY_KP_Delete:
    case GDK_KEY_BackSpace:
    case GDK_KEY_Left:
    case GDK_KEY_Right:
    case GDK_KEY_Home:
    case GDK_KEY_KP_Home:
    case GDK_KEY_End:
    case GDK_KEY_KP_End:
      d->editing = TRUE;
      return FALSE;

    case GDK_KEY_Tab:
    case GDK_KEY_KP_Tab:
    case GDK_KEY_ISO_Left_Tab:
    case GDK_KEY_Return:
    case GDK_KEY_KP_Enter:
      d->editing = FALSE;
      g_signal_emit_by_name(d->dt.widget[0], "changed");
      return FALSE;

    default:
      return TRUE;
  }
}

static void _timezone_save(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  const gchar *tz = gtk_entry_get_text(GTK_ENTRY(d->timezone));

  gchar *name = NULL;
  for(GList *iter = d->timezones; iter; iter = g_list_next(iter))
  {
    tz_tuple_t *tz_tuple = (tz_tuple_t *)iter->data;
    if(!strcmp(tz_tuple->display, tz))
      name = tz_tuple->name;
  }
  if(d->tz_camera) g_time_zone_unref(d->tz_camera);
  d->tz_camera = !name ? g_time_zone_new_utc() : g_time_zone_new(name);
  dt_conf_set_string("plugins/lighttable/geotagging/tz", name ? name : "UTC");
  gtk_entry_set_text(GTK_ENTRY(d->timezone), name ? name : "UTC");
  gtk_label_set_text(GTK_LABEL (d->timezone_changed), "");

  gtk_window_set_focus(GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)), NULL);
#ifdef HAVE_MAP
  if(d->map.view)
    _refresh_track_list(self);
#endif
}

static gboolean _timezone_key_pressed(GtkEventControllerKey *controller,
                                       guint keyval,
                                       guint keycode,
                                       GdkModifierType state,
                                       dt_lib_module_t *self)
{
  switch(keyval)
  {
    case GDK_KEY_Return:
    case GDK_KEY_KP_Enter:
    case GDK_KEY_Tab:
      _timezone_save(self);
      return TRUE;
    case GDK_KEY_Escape:
      gtk_window_set_focus(GTK_WINDOW(dt_ui_main_window(darktable.gui->ui)), NULL);
      return TRUE;
    default: ;
      dt_lib_geotagging_t *d = self->data;
      gtk_label_set_text(GTK_LABEL (d->timezone_changed), " *");
      break;
  }
  return FALSE;
}

static void _timezone_focus_out(GtkEventController *controller, dt_lib_module_t *self)
{
  _timezone_save(self);
}

static gboolean _completion_match_func(GtkEntryCompletion *completion, const gchar *key, GtkTreeIter *iter,
                                       gpointer user_data)
{
  gboolean res = FALSE;

  GtkEditable *e = (GtkEditable *)gtk_entry_completion_get_entry(completion);
  if(!GTK_IS_EDITABLE(e))
    return FALSE;

  GtkTreeModel *model = gtk_entry_completion_get_model(completion);
  const int column = gtk_entry_completion_get_text_column(completion);

  if(gtk_tree_model_get_column_type(model, column) != G_TYPE_STRING)
    return FALSE;

  char *tag = NULL;
  gtk_tree_model_get(model, iter, column, &tag, -1);
  if(tag)
  {
    char *normalized = g_utf8_normalize(tag, -1, G_NORMALIZE_ALL);
    if(normalized)
    {
      char *casefold = g_utf8_casefold(normalized, -1);
      if(casefold)
      {
        res = g_strstr_len(casefold, -1, key) != NULL;
      }
      g_free(casefold);
    }
    g_free(normalized);
    g_free(tag);
  }

  return res;
}

static void _toggle_lock_button_callback(GtkToggleButton *button, dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  const gboolean locked = gtk_toggle_button_get_active(button);
  for(int i = 0; i < DT_GEOTAG_PARTS_NB; i++)
  {
    gtk_widget_set_sensitive(d->dt.widget[i], !locked);
  }
  gtk_widget_set_sensitive(d->apply_datetime, d->imgid && !locked);
}

GtkTreeViewColumn *_new_tree_text_column(const char *name, const gboolean expand,
                                         const float xalign, const int m_col,
                                         const int ellipsize)
{
  GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
  GtkTreeViewColumn *column = gtk_tree_view_column_new();
  gtk_tree_view_column_pack_start(column, renderer, TRUE);
  gtk_tree_view_column_set_attributes(column, renderer, "text", m_col, NULL);
  gtk_tree_view_column_set_expand(column, expand);
  GtkWidget *label = gtk_label_new(name);
  gtk_widget_show(label);
  gtk_tree_view_column_set_widget(column, label);
  gtk_label_set_ellipsize(GTK_LABEL(label), expand ? PANGO_ELLIPSIZE_MIDDLE : PANGO_ELLIPSIZE_NONE);
  g_object_set(renderer, "xalign", xalign, "ellipsize", ellipsize, NULL);
  return column;
}

static void _show_milliseconds(dt_lib_geotagging_t *d)
{
  const gboolean milliseconds = dt_conf_get_bool("lighttable/ui/milliseconds");
  gtk_widget_set_visible(d->dt.widget[6], milliseconds);
  gtk_widget_set_visible(d->dt0.widget[6], milliseconds);
  gtk_widget_set_visible(d->of.widget[6], milliseconds);
  gtk_widget_set_visible(g_object_get_data(G_OBJECT(d->dt.widget[5]), "msec_label"), milliseconds);
  gtk_widget_set_visible(g_object_get_data(G_OBJECT(d->dt0.widget[5]), "msec_label"), milliseconds);
  gtk_widget_set_visible(g_object_get_data(G_OBJECT(d->of.widget[5]), "msec_label"), milliseconds);
}

static void _dt_pref_change_callback(gpointer instance, dt_lib_module_t *self)
{
  _show_milliseconds(self->data);
}

void gui_reset(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->lock_offset), FALSE);
  _refresh_image_datetime(self);

#ifdef HAVE_MAP
  if(d->map.view)
  {
    gtk_label_set_text(GTK_LABEL(d->map.gpx_file), "");
    _remove_tracks_from_map(self);
    gtk_widget_set_visible(d->map.gpx_view, FALSE);
  }
#endif
}

void gui_init(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = g_malloc0(sizeof(dt_lib_geotagging_t));
  self->data = (void *)d;
  d->timezones = _lib_geotagging_get_timezones();
  self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);

  GtkGrid *grid = GTK_GRID(gtk_grid_new());
  gtk_grid_set_column_spacing(grid, DT_PIXEL_APPLY_DPI(5));
  int line = 0;

  GtkSizeGroup *group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
  GtkWidget *box = _gui_init_datetime(_("date/time"), &d->dt, 0, self, group, NULL,
                                      _("enter the new date/time (YYYY:MM:DD hh:mm:ss[.sss])"
                                        "\nkey in the new numbers or scroll over the cell"));
  gtk_grid_attach(grid, box, 0, line++, 4, 1);

  box = _gui_init_datetime(_("original date/time"), &d->dt0, 1, self, group, NULL, NULL);
  gtk_grid_attach(grid, box, 0, line++, 4, 1);

  d->lock_offset = dtgtk_togglebutton_new_full(dtgtk_cairo_paint_lock, 0, NULL,
      &(dtgtk_button_config_t){
        .tooltip = _("lock date/time offset value to apply it onto another selection"),
        .clicked_cb = G_CALLBACK(_toggle_lock_button_callback),
        .clicked_data = (gpointer)self,
      });
  gtk_widget_set_halign(d->lock_offset, GTK_ALIGN_START);

  box = _gui_init_datetime(_("date/time offset"), &d->of, 2, self, group, d->lock_offset,
                           _("offset or difference ([-]dd hh:mm:ss[.sss])"));
  gtk_grid_attach(grid, box, 0, line++, 4, 1);

  // apply
  d->apply_offset = dt_action_button_new(self, N_("apply offset"), _apply_offset_callback, self,
                                         _("apply offset to selected images"), 0, 0);
  gtk_grid_attach(grid, d->apply_offset , 0, line, 2, 1);

  d->apply_datetime = dt_action_button_new(self, N_("apply date/time"), _apply_datetime_callback, self,
                                           _("apply the same date/time to selected images"), 0, 0);
  gtk_grid_attach(grid, d->apply_datetime , 2, line++, 2, 1);

  // time zone entry
  GtkWidget *label = dt_ui_label_new(_(dt_confgen_get_label("plugins/lighttable/geotagging/tz")));
  gtk_widget_set_tooltip_markup(label, _(dt_confgen_get_tooltip("plugins/lighttable/geotagging/tz")));

  gtk_grid_attach(grid, label, 0, line, 2, 1);

  d->timezone = dt_ui_entry_new(0);
  gtk_widget_set_tooltip_text(d->timezone,
                              _("start typing to show a list of permitted values and select your timezone.\n"
                                "press enter to confirm, so that the asterisk * disappears"));
  d->timezone_changed = dt_ui_label_new("");

  GtkWidget *timezone_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
  gtk_box_pack_start(GTK_BOX(timezone_box), d->timezone, TRUE, TRUE, 0);
  gtk_box_pack_end(GTK_BOX(timezone_box), d->timezone_changed, FALSE, FALSE, 0);

  gtk_grid_attach(grid, timezone_box, 2, line++, 2, 1);

  GtkCellRenderer *renderer;
  GtkListStore *model = gtk_list_store_new(2, G_TYPE_STRING /*display*/, G_TYPE_STRING /*name*/);
  GtkWidget *tz_selection = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
  renderer = gtk_cell_renderer_text_new();
  gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(tz_selection), renderer, FALSE);
  gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(tz_selection), renderer, "text", 0, NULL);

  gchar *tz = dt_conf_get_string("plugins/lighttable/geotagging/tz");
  d->tz_camera = (tz == NULL) ? g_time_zone_new_utc() : g_time_zone_new(tz);
  for(GList *iter = d->timezones; iter; iter = g_list_next(iter))
  {
    tz_tuple_t *tz_tuple = (tz_tuple_t *)iter->data;
    gtk_list_store_insert_with_values(model, NULL, -1, 0, tz_tuple->display, 1, tz_tuple->name, -1);
    if(!strcmp(tz_tuple->name, tz))
      gtk_entry_set_text(GTK_ENTRY(d->timezone), tz_tuple->display);
  }
  g_free(tz);

  // add entry completion
  GtkEntryCompletion *completion = gtk_entry_completion_new();
  gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(model));
  gtk_entry_completion_set_text_column(completion, 0);
  gtk_entry_completion_set_inline_completion(completion, TRUE);
  gtk_entry_completion_set_popup_set_width(completion, FALSE);
  gtk_entry_completion_set_match_func(completion, _completion_match_func, NULL, NULL);
  gtk_entry_completion_set_minimum_key_length(completion, 0);
  gtk_entry_set_completion(GTK_ENTRY(d->timezone), completion);
  dt_gui_connect_key(d->timezone, _timezone_key_pressed, self);
  dt_gui_connect_focus(d->timezone, NULL, _timezone_focus_out, self);

  // gpx
  d->gpx_button = dt_action_button_new(self, N_("apply GPX track file..."), _choose_gpx_callback, self,
                                       _("parses a GPX file and updates location of selected images"), 0, 0);
  gtk_grid_attach(grid, d->gpx_button, 0, line++, 4, 1);
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(grid), TRUE, TRUE, 0);
#ifdef HAVE_MAP
  grid = GTK_GRID(gtk_grid_new());
  gtk_grid_set_column_spacing(grid, DT_PIXEL_APPLY_DPI(5));
  line = 0;

  d->map.gpx_section = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->map.gpx_section), TRUE, TRUE, 0);

  label = dt_ui_section_label_new(C_("section", "GPX file"));
  gtk_grid_attach(grid, label, 0, line++, 4, 1);

  d->map.gpx_button = dtgtk_button_new_full(dtgtk_cairo_paint_directory, CPF_NONE, NULL,
      &(dtgtk_button_config_t){
        .tooltip = _("select a GPX track file..."),
        .clicked_cb = G_CALLBACK(_choose_gpx_callback),
        .clicked_data = self,
      });
  gtk_widget_set_hexpand(d->map.gpx_button, FALSE);
  gtk_widget_set_halign(d->map.gpx_button, GTK_ALIGN_START);
  gtk_widget_set_name(d->map.gpx_button, "non-flat");
  gtk_grid_attach(grid, d->map.gpx_button, 0, line, 1, 1);

  d->map.gpx_file = dt_ui_label_new("");
  gtk_label_set_ellipsize(GTK_LABEL(d->map.gpx_file ), PANGO_ELLIPSIZE_MIDDLE);
  gtk_widget_set_hexpand(d->map.gpx_file, TRUE);
  gtk_grid_attach(grid, d->map.gpx_file, 1, line++, 3, 1);
  gtk_box_pack_start(GTK_BOX(d->map.gpx_section), GTK_WIDGET(grid), TRUE, TRUE, 0);

  model = gtk_list_store_new(DT_GEO_TRACKS_NUM_COLS, G_TYPE_BOOLEAN, G_TYPE_STRING,
                             G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING);

  d->map.gpx_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
  g_object_unref(model);
  gtk_widget_set_name(d->map.gpx_view, "gpx_list");
  gtk_widget_set_tooltip_text(GTK_WIDGET(d->map.gpx_view),
                              _("list of track segments in the GPX file, for each segment:"
                                "\n- the start date/time in local time (LT)"
                                "\n- the number of track points"
                                "\n- the number of matching images"
                                " based on images date/time, offset and time zone"
                                "\n- more detailed time information hovering the row"));
  renderer = gtk_cell_renderer_toggle_new();
  g_signal_connect(renderer, "toggled", G_CALLBACK(_track_seg_toggled), self);
  GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes("", renderer, "active", DT_GEO_TRACKS_ACTIVE, NULL);
  gtk_tree_view_append_column(GTK_TREE_VIEW(d->map.gpx_view), column);
  d->map.sel_tracks = column;
  GtkWidget *button = gtk_check_button_new();
  gtk_widget_show(button);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE);
  gtk_tree_view_column_set_widget(column, button);
  gtk_tree_view_column_set_alignment(column, 0.5);
  g_signal_connect(column, "clicked", G_CALLBACK(_all_tracks_toggled), self);

  column = _new_tree_text_column(_("start time"), TRUE, 0.0, DT_GEO_TRACKS_DATETIME, PANGO_ELLIPSIZE_START);
  gtk_tree_view_append_column(GTK_TREE_VIEW(d->map.gpx_view), column);
  column = _new_tree_text_column(_("points"), FALSE, 1.0, DT_GEO_TRACKS_POINTS, PANGO_ELLIPSIZE_NONE);
  gtk_tree_view_append_column(GTK_TREE_VIEW(d->map.gpx_view), column);
  column = _new_tree_text_column(_("images"), FALSE, 1.0, DT_GEO_TRACKS_IMAGES, PANGO_ELLIPSIZE_NONE);
  gtk_tree_view_append_column(GTK_TREE_VIEW(d->map.gpx_view), column);

  g_object_set(G_OBJECT(d->map.gpx_view), "has-tooltip", TRUE, NULL);
  g_signal_connect(G_OBJECT(d->map.gpx_view), "query-tooltip", G_CALLBACK(_row_tooltip_setup), self);
  dt_gui_connect_click(d->map.gpx_view, _click_for_entire_track_pressed, NULL, self);

  // avoid ugly console pixman messages due to headers
  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(d->map.gpx_view), FALSE);
  GtkWidget *w = dt_ui_resize_wrap(GTK_WIDGET(d->map.gpx_view), 100, "plugins/lighttable/geotagging/heighttracklist");
  gtk_widget_set_size_request(w, -1, 100);
  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(d->map.gpx_view), TRUE);

  // the gpx_view_button is invisible and the label and tooltip of cannot be displayed on GUI.
  // but label is use in "shortcuts" dialog.
  GtkWidget *gpx_view_button = dt_action_button_new(self, N_("view entire track"), _refresh_display_all_tracks, self,
                                        _("refresh map to view entire selected track segments"), 0, 0);
  gtk_widget_set_opacity(gpx_view_button, 0);
  gtk_widget_set_valign(gpx_view_button, GTK_ALIGN_START);
  gtk_widget_set_margin_start(gpx_view_button, DT_PIXEL_APPLY_DPI(25));
  gtk_widget_set_size_request(gpx_view_button, -1, DT_PIXEL_APPLY_DPI(25));
  GtkWidget *overlay = gtk_overlay_new();
  gtk_container_add(GTK_CONTAINER(overlay), w);
  gtk_overlay_add_overlay(GTK_OVERLAY(overlay), GTK_WIDGET(gpx_view_button));
  gtk_box_pack_start(GTK_BOX(d->map.gpx_section), overlay, TRUE, TRUE, 0);

  grid = GTK_GRID(gtk_grid_new());
  gtk_grid_set_column_spacing(grid, DT_PIXEL_APPLY_DPI(5));
  line = 0;

  d->map.preview_button = gtk_check_button_new_with_label(_("preview images"));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->map.preview_button), TRUE);
  gtk_widget_set_sensitive(d->map.preview_button, FALSE);
  gtk_label_set_ellipsize(GTK_LABEL(gtk_bin_get_child(GTK_BIN(d->map.preview_button))), PANGO_ELLIPSIZE_END);
  gtk_grid_attach(grid, d->map.preview_button, 0, line, 1, 1);
  gtk_widget_set_tooltip_text(d->map.preview_button, _("show on map matching images"));
  g_signal_connect(GTK_TOGGLE_BUTTON(d->map.preview_button), "toggled", G_CALLBACK(_images_preview_toggled), self);

  d->map.select_button = dt_action_button_new(self, N_("select images"), _select_images, self,
                                              _("select matching images"), 0, 0);
  gtk_widget_set_hexpand(d->map.select_button, TRUE);
  gtk_widget_set_sensitive(d->map.select_button, FALSE);
  gtk_grid_attach(grid, d->map.select_button, 1, line, 1, 1);

  d->map.nb_imgs_label = dt_ui_label_new("0/0");
  gtk_widget_set_halign(d->map.nb_imgs_label, GTK_ALIGN_END);
  gtk_widget_set_tooltip_text(GTK_WIDGET(d->map.nb_imgs_label),
                              _("number of matching images versus selected images"));
  gtk_grid_attach(grid, d->map.nb_imgs_label, 2, line++, 1, 1);

  d->map.apply_gpx_button = dt_action_button_new(self, N_("apply geo-location"), _apply_gpx, self,
                                                 _("apply geo-location to matching images"), 0, 0);
  gtk_widget_set_hexpand(d->map.apply_gpx_button, TRUE);
  gtk_widget_set_sensitive(d->map.apply_gpx_button, FALSE);
  gtk_grid_attach(grid, d->map.apply_gpx_button, 0, line++, 3, 1);

  gtk_box_pack_start(GTK_BOX(d->map.gpx_section), GTK_WIDGET(grid), TRUE, TRUE, 0);

  d->map.view = FALSE;
  gtk_widget_show_all(self->widget);
  gtk_widget_set_no_show_all(self->widget, TRUE);
  _update_layout(self);
#endif
  d->imgid = NO_IMGID;
  d->datetime = d->datetime0 = _get_image_datetime(self);
  if(d->datetime)
    g_date_time_ref(d->datetime);
  _display_datetime(&d->dt0, d->datetime0, FALSE, self);
  _display_datetime(&d->dt, d->datetime, TRUE, self);
  d->offset = 0;
  _display_offset(d->offset, TRUE, self);

  for(int i = 0; i < DT_GEOTAG_PARTS_NB; i++)
  {
    g_signal_connect(d->dt.widget[i], "changed", G_CALLBACK(_datetime_entry_changed), self);
    dt_gui_connect_key(d->dt.widget[i], _datetime_key_pressed, self);
    dt_gui_connect_scroll(d->dt.widget[i],
                          GTK_EVENT_CONTROLLER_SCROLL_VERTICAL
                          | GTK_EVENT_CONTROLLER_SCROLL_DISCRETE,
                          _datetime_scroll_over,
                          self);
  }
  DT_CONTROL_SIGNAL_HANDLE(DT_SIGNAL_SELECTION_CHANGED, _selection_changed_callback);
  DT_CONTROL_SIGNAL_HANDLE(DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE, _mouse_over_image_callback);
  DT_CONTROL_SIGNAL_HANDLE(DT_SIGNAL_IMAGE_INFO_CHANGED, _image_info_changed);
  DT_CONTROL_SIGNAL_HANDLE(DT_SIGNAL_PREFERENCES_CHANGE, _dt_pref_change_callback);
#ifdef HAVE_MAP
  DT_CONTROL_SIGNAL_HANDLE(DT_SIGNAL_VIEWMANAGER_VIEW_CHANGED, _view_changed);
  DT_CONTROL_SIGNAL_HANDLE(DT_SIGNAL_GEOTAG_CHANGED, _geotag_changed);
#endif

  _show_milliseconds(d);
  gtk_widget_show_all(self->widget);
  gtk_widget_set_no_show_all(self->widget, TRUE);
}

void gui_cleanup(dt_lib_module_t *self)
{
  dt_lib_geotagging_t *d = self->data;
  g_list_free_full(d->timezones, free_tz_tuple);
  d->timezones = NULL;
  g_time_zone_unref(d->tz_camera);
  if(d->datetime)
    g_date_time_unref(d->datetime);
  if(d->datetime0)
    g_date_time_unref(d->datetime0);
  if(d->imgs)
  {
#ifdef HAVE_MAP
    _remove_images_from_map(self);
#endif
    g_list_free_full(d->imgs, g_free);
  }
  d->imgs = NULL;
  d->imgs = 0;
#ifdef HAVE_MAP
  _remove_tracks_from_map(self);
#endif
  free(self->data);
  self->data = NULL;
}

// 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