tagging.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2010-2011, 2013 Henrik Andersson.
    Copyright (C) 2010-2011, 2013-2014 johannes hanika.
    Copyright (C) 2010 Stuart Henderson.
    Copyright (C) 2010-2017 Tobias Ellinghaus.
    Copyright (C) 2011 Antony Dovgal.
    Copyright (C) 2011, 2013 Jérémy Rosen.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2013 José Carlos García Sogo.
    Copyright (C) 2013-2016 Roman Lebedev.
    Copyright (C) 2013 Simon Spannagel.
    Copyright (C) 2014 Pascal de Bruijn.
    Copyright (C) 2017-2018, 2020 parafin.
    Copyright (C) 2018 August Schwerdfeger.
    Copyright (C) 2018, 2023 Maurizio Paglia.
    Copyright (C) 2018 rawfiner.
    Copyright (C) 2019 Alexis Mousset.
    Copyright (C) 2019, 2022-2023, 2025 Aurélien PIERRE.
    Copyright (C) 2019 Edgardo Hoszowski.
    Copyright (C) 2019-2022 Pascal Obry.
    Copyright (C) 2019-2022 Philippe Weyland.
    Copyright (C) 2019 Sam Smith.
    Copyright (C) 2020-2022 Aldric Renaudin.
    Copyright (C) 2020-2022 Diederik Ter Rahe.
    Copyright (C) 2020-2021 Hubert Kowalski.
    Copyright (C) 2020 Marco.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2021 Harald.
    Copyright (C) 2021 luzpaz.
    Copyright (C) 2021 Marco Carrarini.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2022 Nicolas Auffray.
    
    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/collection.h"
#include "common/act_on.h"
#include "widgets/togglebutton.h"
#include "common/selection.h"
#include "system/macros.h"
#include "system/mem_alloc.h"
#include "common/module_versioning.h"
#include "control/signal.h"
#include "common/utility.h"
#include "widgets/gdkkeys.h"
#include "metadata/tags.h"
#include "common/conf.h"
#include "control/control.h"
#include "widgets/bauhaus.h"
#include "widgets/button.h"
#include "widgets/icon_cell_renderer.h"
 
#include "gui/application.h"
#include "widgets/accelerators.h"
#include "gui/drag_and_drop.h"
#include "libs/lib.h"
#include "libs/tagging_completion.h"
#include "libs/lib_api.h"
#ifdef GDK_WINDOWING_QUARTZ
#include "osx/osx.h"
#endif
#include <gdk/gdkkeysyms.h>
#include "widgets/dialog.h"
#include "widgets/label.h"
#include "widgets/scroll_wrap.h"
#include "widgets/widget_settings.h"  // dt_gui_widget_freeze(), dt_gui_widgets_suppressed()
 
#define FLOATING_ENTRY_WIDTH DT_PIXEL_APPLY_DPI(150)
 
DT_MODULE(1)
 
typedef struct dt_lib_tagging_t
{
  char keyword[1024];
  GtkEntry *entry, *dict_entry;
  GtkWidget *manage_window;
  GtkTreeView *attached_view, *dictionary_view;
  GtkWidget *validate_button, *new_button, *import_button, *export_button;
  GtkWidget *toggle_tree_button, *toggle_suggestion_button;
  GtkWidget *attached_view_combo, *sort_combo, *dttags_check;  // sidebar attached-list controls
  GtkListStore *attached_liststore, *dictionary_liststore, *completion_store;
  GtkTreeStore *attached_treestore, *dictionary_treestore;
  GtkTreeModelFilter *dictionary_listfilter, *dictionary_treefilter;
  GHashTable *collection_tags;
  GtkWidget *floating_tag_window;
  GList *floating_tag_imgs;
  gboolean tree_flag, suggestion_flag, sort_count_flag, hide_path_flag, dttags_flag;
  gboolean attached_tree_flag;  // sidebar attached view: TRUE = tree, FALSE = list
  char *collection;
  char *last_tag;
  struct
  {
    gchar *tagname;
    GtkTreePath *path, *lastpath;
    int expand_timeout, scroll_timeout, last_y;
    gboolean root, tag_source;
  } drag;
} dt_lib_tagging_t;
 
typedef struct dt_tag_op_t
{
  gint tagid;
  char *newtagname;
  char *oldtagname;
  gboolean tree_flag;
} dt_tag_op_t;
 
typedef enum dt_lib_tagging_cols_t
{
  DT_LIB_TAGGING_COL_TAG = 0,
  DT_LIB_TAGGING_COL_ID,
  DT_LIB_TAGGING_COL_PATH,
  DT_LIB_TAGGING_COL_SYNONYM,
  DT_LIB_TAGGING_COL_COUNT,
  DT_LIB_TAGGING_COL_SEL,
  DT_LIB_TAGGING_COL_FLAGS,
  DT_LIB_TAGGING_COL_VISIBLE,
  DT_LIB_TAGGING_NUM_COLS
} dt_lib_tagging_cols_t;
 
typedef enum dt_tag_sort_id
{
  DT_TAG_SORT_PATH_ID,
  DT_TAG_SORT_NAME_ID,
  DT_TAG_SORT_COUNT_ID
} dt_tag_sort_id;
 
static void _save_last_tag_used(const char *tags, dt_lib_tagging_t *d);
static void _refresh_collection_tags(dt_lib_module_t *self);
static void _size_recent_tags_list();
static void _entry_clear_suppressed(GtkEntry *entry);
static gboolean _lib_tagging_tag_redo_accel(GtkAccelGroup *accel_group, GObject *accelerable, guint keyval,
                                            GdkModifierType mods, gpointer user_data);
static gboolean _lib_tagging_tag_show_accel(GtkAccelGroup *accel_group, GObject *accelerable, guint keyval,
                                            GdkModifierType mods, gpointer user_data);
 
const char *name(struct dt_lib_module_t *self)
{
  return _("Tags");
}
 
const char **views(dt_lib_module_t *self)
{
  static const char *v[] = {"lighttable", "map", "studio_capture", NULL};
  return v;
}
 
uint32_t container(dt_lib_module_t *self)
{
  return DT_UI_CONTAINER_PANEL_LEFT_CENTER;
}
 
static gboolean _is_user_tag(GtkTreeModel *model, GtkTreeIter *iter)
{
  char *path;
  gtk_tree_model_get(model, iter, DT_LIB_TAGGING_COL_PATH, &path, -1);
  const gboolean user_tag = !g_str_has_prefix(path, "darktable|") || g_str_has_prefix(path, "darktable|style|");
  dt_free(path);
  return user_tag;
}
 
static void _unselect_all_in_view(GtkTreeView *view)
{
  GtkTreeSelection *selection = gtk_tree_view_get_selection(view);
  gtk_tree_selection_unselect_all(selection);
}
 
// MULTIPLE-selection-safe replacement for gtk_tree_selection_get_selected():
// returns the first selected row. gtk_tree_selection_get_selected() asserts
// (Gtk-CRITICAL) on GTK_SELECTION_MULTIPLE views, which both our views now are.
static gboolean _selection_get_first(GtkTreeSelection *selection, GtkTreeModel **model, GtkTreeIter *iter)
{
  GList *rows = gtk_tree_selection_get_selected_rows(selection, model);
  gboolean found = FALSE;
  if(rows)
  {
    found = gtk_tree_model_get_iter(*model, iter, (GtkTreePath *)rows->data);
    g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free);
  }
  return found;
}
 
// kept as a hook for callers that want to refresh after a selection/act-on change;
// the attach/detach buttons it used to drive are gone (tagging is done from the entry,
// detaching from per-row icons or the right-click menu)
static void _update_atdetach_buttons(dt_lib_module_t *self)
{
  dt_lib_cancel_postponed_update(self);
}
 
static void _propagate_sel_to_parents(GtkTreeModel *model, GtkTreeIter *iter)
{
  guint sel;
  GtkTreeIter parent, child = *iter;
  while(gtk_tree_model_iter_parent(model, &parent, &child))
  {
    gtk_tree_model_get(model, &parent, DT_LIB_TAGGING_COL_SEL, &sel, -1);
    if(sel == DT_TS_NO_IMAGE)
      gtk_tree_store_set(GTK_TREE_STORE(model), &parent,
                         DT_LIB_TAGGING_COL_SEL, DT_TS_SOME_IMAGES, -1);
    child = parent;
  }
}
 
static gboolean _set_matching_tag_visibility(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  gboolean visible;
  gchar *tagname = NULL;
  gchar *synonyms = NULL;
  gtk_tree_model_get(model, iter, DT_LIB_TAGGING_COL_PATH, &tagname, DT_LIB_TAGGING_COL_SYNONYM, &synonyms, -1);
  if(!d->keyword[0])
    visible = TRUE;
  else
  {
    if(synonyms && synonyms[0]) tagname = dt_util_dstrcat(tagname, ", %s", synonyms);
    gchar *haystack = g_utf8_strdown(tagname, -1);
    gchar *needle = g_utf8_strdown(d->keyword, -1);
    visible = (g_strrstr(haystack, needle) != NULL);
    dt_free(haystack);
    dt_free(needle);
  }
  if(d->tree_flag)
    gtk_tree_store_set(GTK_TREE_STORE(model), iter, DT_LIB_TAGGING_COL_VISIBLE, visible, -1);
  else
    gtk_list_store_set(GTK_LIST_STORE(model), iter, DT_LIB_TAGGING_COL_VISIBLE, visible, -1);
  dt_free(tagname);
  dt_free(synonyms);
  return FALSE;
}
 
static gboolean _tree_reveal_func(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
{
  gboolean state;
  GtkTreeIter parent, child = *iter;
 
  gtk_tree_model_get(model, iter, DT_LIB_TAGGING_COL_VISIBLE, &state, -1);
  if(!state) return FALSE;
 
  while(gtk_tree_model_iter_parent(model, &parent, &child))
  {
    gtk_tree_model_get(model, &parent, DT_LIB_TAGGING_COL_VISIBLE, &state, -1);
    gtk_tree_store_set(GTK_TREE_STORE(model), &parent, DT_LIB_TAGGING_COL_VISIBLE, TRUE, -1);
    child = parent;
  }
  return FALSE;
}
 
static void _sort_attached_list(dt_lib_module_t *self, gboolean force)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  if(d->attached_tree_flag)
  {
    // tree view: order by full path so the hierarchy lines up
    gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(d->attached_treestore), DT_TAG_SORT_PATH_ID, GTK_SORT_ASCENDING);
    return;
  }
  if(force && d->sort_count_flag)
  {
    // ugly but when sorted by count _tree_tagname_show() is not triggered
    gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(d->attached_liststore), DT_TAG_SORT_NAME_ID, GTK_SORT_ASCENDING);
  }
  const gint sort = d->sort_count_flag ? DT_TAG_SORT_COUNT_ID : DT_TAG_SORT_NAME_ID;
  gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(d->attached_liststore), sort, GTK_SORT_ASCENDING);
}
 
static void _sort_dictionary_list(dt_lib_module_t *self, gboolean force)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  if(!d->tree_flag)
  {
    if(force && d->sort_count_flag)
    {
      // ugly but when sorted by count _tree_tagname_show() is not triggered
      gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(d->dictionary_liststore), DT_TAG_SORT_NAME_ID, GTK_SORT_ASCENDING);
    }
    const gint sort = d->sort_count_flag ? DT_TAG_SORT_COUNT_ID : d->hide_path_flag ? DT_TAG_SORT_NAME_ID : DT_TAG_SORT_PATH_ID;
    gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(d->dictionary_liststore), sort, GTK_SORT_ASCENDING);
  }
  else
    gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(d->dictionary_treestore), DT_TAG_SORT_PATH_ID, GTK_SORT_ASCENDING);
}
 
// find a tag on the tree
static gboolean _find_tag_iter_tagname(GtkTreeModel *model, GtkTreeIter *iter,
                                       const char *tagname, const gboolean needle)
{
  gboolean found = FALSE;
  if(IS_NULL_PTR(tagname)) return found;
  char *path;
  do
  {
    gtk_tree_model_get(model, iter, DT_LIB_TAGGING_COL_PATH, &path, -1);
    if(needle)
    {
      gchar *haystack = g_utf8_strdown(path, -1);
      found = g_strstr_len(haystack, strlen(haystack), tagname) != NULL;
      dt_free(haystack);
    }
    else
      found = !g_strcmp0(tagname, path);
    dt_free(path);
    if(found) return found;
    GtkTreeIter child, parent = *iter;
    if(gtk_tree_model_iter_children(model, &child, &parent))
    {
      found = _find_tag_iter_tagname(model, &child, tagname, needle);
      if(found)
      {
        *iter = child;
        return found;
      }
    }
  } while(gtk_tree_model_iter_next(model, iter));
  return found;
}
 
static void _show_iter_on_view(GtkTreeView *view, GtkTreeIter *iter, const gboolean select)
{
  GtkTreeModel *model = gtk_tree_view_get_model(view);
  GtkTreePath *path = gtk_tree_model_get_path(model, iter);
  gtk_tree_view_expand_to_path(view, path);
  gtk_tree_view_scroll_to_cell(view, path, NULL, TRUE, 0.5, 0.5);
  gtk_tree_path_free(path);
  if(select)
  {
    GtkTreeSelection *selection = gtk_tree_view_get_selection(view);
    gtk_tree_selection_select_iter(selection, iter);
  }
}
 
// make the tag visible on view
static void _show_tag_on_view(GtkTreeView *view, const char *tagname,
                              const gboolean needle, const gboolean select)
{
  if(tagname)
  {
    char *lt = g_strdup(tagname);
    char *t = g_strstrip(lt);
    GtkTreeIter iter;
    GtkTreeModel *model = gtk_tree_view_get_model(view);
    if(gtk_tree_model_get_iter_first(model, &iter))
    {
      if(_find_tag_iter_tagname(model, &iter, t, needle))
        _show_iter_on_view(view, &iter, select);
    }
    dt_free(lt);
  }
}
 
static void _show_keyword_on_view(GtkTreeView *view, const char *keyword, const gboolean select)
{
  gchar *needle = g_utf8_strdown(keyword, -1);
  _show_tag_on_view(view, needle, TRUE, select);
  dt_free(needle);
}
 
static gboolean _select_previous_user_attached_tag(const int index, GtkTreeView *view)
{
  if(index == 0)
    return FALSE;
  GtkTreeIter iter;
  GtkTreeModel *model = gtk_tree_view_get_model(view);
  gboolean valid = gtk_tree_model_get_iter_first(model, &iter);
  int i = 0;
  for(; valid && i < index -1; i++)
    valid = gtk_tree_model_iter_next(model, &iter);
  for(; valid; valid = gtk_tree_model_iter_previous(model, &iter))
  {
    if(_is_user_tag(model, &iter))
    {
      _show_iter_on_view(view, &iter, TRUE);
      return TRUE;
    }
  }
  return FALSE;
}
 
static gboolean _select_next_user_attached_tag(const int index, GtkTreeView *view)
{
  GtkTreeIter iter;
  GtkTreeModel *model = gtk_tree_view_get_model(view);
  gboolean valid = gtk_tree_model_get_iter_first(model, &iter);
  int i = 0;
  for(; valid && i < index; i++)
    valid = gtk_tree_model_iter_next(model, &iter);
  for(; valid; valid = gtk_tree_model_iter_next(model, &iter))
  {
    if(_is_user_tag(model, &iter))
    {
      _show_iter_on_view(view, &iter, TRUE);
      return TRUE;
    }
  }
  if(index)
    return _select_previous_user_attached_tag(index, view);
  return FALSE;
}
 
static void _init_treeview(dt_lib_module_t *self, const int which)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GList *tags = NULL;
  uint32_t count;
  GtkTreeIter iter;
  GtkTreeView *view;
  GtkTreeModel *store;
  GtkTreeModel *model;
  gboolean no_sel = FALSE;
 
  // are we building a hierarchical tree (split on '|') or a flat list?
  const gboolean build_tree = which ? d->tree_flag : d->attached_tree_flag;
 
  if(which == 0) // tags of selected images
  {
    const int imgsel = dt_control_get_mouse_over_id();
    no_sel = imgsel > 0 || dt_selection_get_length(dt_selection_get_global()) == 1;
    count = dt_tag_get_attached(imgsel, &tags, d->dttags_flag ? FALSE : TRUE);
    view = d->attached_view;
    // the attached view shows its store directly (no filter), so model == store
    store = build_tree ? GTK_TREE_MODEL(d->attached_treestore) : GTK_TREE_MODEL(d->attached_liststore);
    model = store;
  }
  else // dictionary_view tags of typed text
  {
    if(!d->tree_flag && d->suggestion_flag)
      count = dt_tag_get_suggestions(&tags);
    else
      count = dt_tag_get_with_usage(&tags);
    view = d->dictionary_view;
    model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
    if(d->tree_flag)
      store = GTK_TREE_MODEL(d->dictionary_treestore);
    else
      store = GTK_TREE_MODEL(d->dictionary_liststore);
  }
  g_object_ref(model);
  gtk_tree_view_set_model(GTK_TREE_VIEW(view), NULL);
 
  gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
  if(build_tree)
  {
    gtk_tree_store_clear(GTK_TREE_STORE(store));
    {
      char **last_tokens = NULL;
      int last_tokens_length = 0;
      GtkTreeIter last_parent = { 0 };
      GList *sorted_tags = dt_sort_tag(tags, 0);  // ordered by full tag name
      tags = sorted_tags;
      for(GList *taglist = tags; taglist; taglist = g_list_next(taglist))
      {
        const gchar *tag = ((dt_tag_t *)taglist->data)->tag;
        if(IS_NULL_PTR(tag)) continue;
        char **tokens;
        tokens = g_strsplit(tag, "|", -1);
        if(tokens)
        {
          // find the number of common parts at the beginning of tokens and last_tokens
          GtkTreeIter parent = last_parent;
          const int tokens_length = g_strv_length(tokens);
          int common_length = 0;
          if(last_tokens)
          {
            while(tokens[common_length] && last_tokens[common_length] &&
                  !g_strcmp0(tokens[common_length], last_tokens[common_length]))
            {
              common_length++;
            }
 
            // point parent iter to where the entries should be added
            for(int i = common_length; i < last_tokens_length; i++)
            {
              gtk_tree_model_iter_parent(GTK_TREE_MODEL(store), &parent, &last_parent);
              last_parent = parent;
            }
          }
 
          // insert everything from tokens past the common part
          char *pth = NULL;
          for(int i = 0; i < common_length; i++)
            pth = dt_util_dstrcat(pth, "%s|", tokens[i]);
 
          for(char **token = &tokens[common_length]; *token; token++)
          {
            pth = dt_util_dstrcat(pth, "%s|", *token);
            gchar *pth2 = g_strdup(pth);
            pth2[strlen(pth2) - 1] = '\0';
            gtk_tree_store_insert(GTK_TREE_STORE(store), &iter, common_length > 0 ? &parent : NULL, -1);
            gtk_tree_store_set(GTK_TREE_STORE(store), &iter,
                              DT_LIB_TAGGING_COL_TAG, *token,
                              DT_LIB_TAGGING_COL_ID, (token == &tokens[tokens_length-1]) ?
                                                     ((dt_tag_t *)taglist->data)->id : 0,
                              DT_LIB_TAGGING_COL_PATH, pth2,
                              DT_LIB_TAGGING_COL_COUNT, (token == &tokens[tokens_length-1]) ?
                                                        ((dt_tag_t *)taglist->data)->count : 0,
                              DT_LIB_TAGGING_COL_SEL, ((dt_tag_t *)taglist->data)->select,
                              DT_LIB_TAGGING_COL_FLAGS, ((dt_tag_t *)taglist->data)->flags,
                              DT_LIB_TAGGING_COL_SYNONYM, ((dt_tag_t *)taglist->data)->synonym,
                              DT_LIB_TAGGING_COL_VISIBLE, TRUE,
                              -1);
            if(((dt_tag_t *)taglist->data)->select)
              _propagate_sel_to_parents(GTK_TREE_MODEL(store), &iter);
            common_length++;
            parent = iter;
            dt_free(pth2);
          }
          dt_free(pth);
 
          // remember things for the next round
          if(last_tokens) g_strfreev(last_tokens);
          last_tokens = tokens;
          last_parent = parent;
          last_tokens_length = tokens_length;
        }
      }
      g_strfreev(last_tokens);
    }
    if(which && d->keyword[0])  // keyword filtering only applies to the dictionary
    {
      gtk_tree_model_foreach(store, (GtkTreeModelForeachFunc)_set_matching_tag_visibility, self);
      gtk_tree_model_foreach(store, (GtkTreeModelForeachFunc)_tree_reveal_func, NULL);
      gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
    }
    else gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
    g_object_unref(model);
  }
  else
  {
    gtk_list_store_clear(GTK_LIST_STORE(store));
    if(count > 0 && tags)
    {
      for (GList *tag = tags; tag; tag = g_list_next(tag))
      {
        const char *subtag = g_strrstr(((dt_tag_t *)tag->data)->tag, "|");
        gtk_list_store_append(GTK_LIST_STORE(store), &iter);
        gtk_list_store_set(GTK_LIST_STORE(store), &iter,
                          DT_LIB_TAGGING_COL_TAG, !subtag ? ((dt_tag_t *)tag->data)->tag : subtag + 1,
                          DT_LIB_TAGGING_COL_ID, ((dt_tag_t *)tag->data)->id,
                          DT_LIB_TAGGING_COL_PATH, ((dt_tag_t *)tag->data)->tag,
                          DT_LIB_TAGGING_COL_COUNT, ((dt_tag_t *)tag->data)->count,
                          DT_LIB_TAGGING_COL_SEL, no_sel ? DT_TS_NO_IMAGE :
                                                  ((dt_tag_t *)tag->data)->select,
                          DT_LIB_TAGGING_COL_FLAGS, ((dt_tag_t *)tag->data)->flags,
                          DT_LIB_TAGGING_COL_SYNONYM, ((dt_tag_t *)tag->data)->synonym,
                          DT_LIB_TAGGING_COL_VISIBLE, TRUE,
                          -1);
      }
    }
    if(which && d->keyword[0])
    {
      gtk_tree_model_foreach(store, (GtkTreeModelForeachFunc)_set_matching_tag_visibility, self);
    }
    gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
    g_object_unref(model);
  }
  if(which)
    _sort_dictionary_list(self, FALSE);
  else
    _sort_attached_list(self, FALSE);
  // the attached tree is meant to display the tags, not to be browsed, so reveal everything
  if(!which && d->attached_tree_flag)
    gtk_tree_view_expand_all(GTK_TREE_VIEW(d->attached_view));
  // Free result...
  dt_tag_free_result(&tags);
}
 
static void _tree_tagname_show(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
                               GtkTreeModel *model, GtkTreeIter *iter,
                               gpointer data, gboolean dictionary_view)
{
  dt_lib_module_t *self = (dt_lib_module_t *)data;
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  guint tagid;
  gchar *name;
  gchar *path;
  guint count;
  gchar *coltext;
  gint flags;
 
  gtk_tree_model_get(model, iter,
                     DT_LIB_TAGGING_COL_ID, &tagid,
                     DT_LIB_TAGGING_COL_TAG, &name,
                     DT_LIB_TAGGING_COL_COUNT, &count,
                     DT_LIB_TAGGING_COL_FLAGS, &flags,
                     DT_LIB_TAGGING_COL_PATH, &path, -1);
  // tree view shows the leaf token only; list view shows the whole "a|b|c" path
  const gboolean hide = dictionary_view ? (d->tree_flag ? TRUE : d->hide_path_flag) : d->attached_tree_flag;
  const gboolean istag = !(flags & DT_TF_CATEGORY) && tagid;
  if((dictionary_view && !count) || (!dictionary_view && count <= 1))
  {
    coltext = g_markup_printf_escaped(istag ? "%s" : "<i>%s</i>", hide ? name : path);
  }
  else
  {
    coltext = g_markup_printf_escaped(istag ? "%s (%d)" : "<i>%s</i> (%d)", hide ? name : path, count);
  }
  g_object_set(renderer, "markup", coltext, NULL);
  dt_free(coltext);
  dt_free(name);
  dt_free(path);
}
 
static void _tree_tagname_show_attached(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
                                        GtkTreeModel *model, GtkTreeIter *iter,
                                        gpointer data)
{
  _tree_tagname_show(col, renderer, model, iter, data, 0);
}
 
static void _tree_tagname_show_dictionary(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
                                          GtkTreeModel *model, GtkTreeIter *iter,
                                          gpointer data)
{
  _tree_tagname_show(col, renderer, model, iter, data, 1);
}
 
 
static void _postponed_update(dt_lib_module_t *self)
{
  _init_treeview(self, 0);
  _update_atdetach_buttons(self);
}
 
static void _lib_tagging_redraw_callback(gpointer instance, dt_lib_module_t *self)
{
  //if(dt_lib_gui_get_expanded(self)) // segfaults internally, for some reason
  dt_lib_queue_postponed_update(self, _postponed_update);
}
 
static void _lib_tagging_tags_changed_callback(gpointer instance, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  _init_treeview(self, 0);
  _init_treeview(self, 1);
  // the set of known tags may have changed (created / deleted / renamed)
  dt_tagging_completion_refresh(d->completion_store);
  _refresh_collection_tags(self);
}
 
static void _collection_updated_callback(gpointer instance, dt_collection_change_t query_change,
                                         dt_collection_properties_t changed_property, gpointer imgs, int next,
                                         dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  d->collection[0] = '\0';
  // the tags suggested on an empty entry follow the current collection
  _refresh_collection_tags(self);
  _update_atdetach_buttons(self);
}
 
static void _raise_signal_tag_changed(dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  // when collection is on tag any attach & detach becomes very slow
  // speeding up when jumping from tag collection to the other
  // the cost is that tag collection doesn't reflect the tag changes real time
  if(!d->collection[0])
  {
    // raises change only for other modules
    dt_control_signal_block_by_func(dt_control_signal_get_global(), G_CALLBACK(_collection_updated_callback), self);
    dt_control_signal_block_by_func(dt_control_signal_get_global(), G_CALLBACK(_lib_tagging_tags_changed_callback), self);
    DT_DEBUG_CONTROL_SIGNAL_RAISE(dt_control_signal_get_global(), DT_SIGNAL_TAG_CHANGED);
    dt_control_signal_unblock_by_func(dt_control_signal_get_global(), G_CALLBACK(_lib_tagging_tags_changed_callback), self);
    dt_control_signal_unblock_by_func(dt_control_signal_get_global(), G_CALLBACK(_collection_updated_callback), self);
  }
}
 
// find a tag on the tree
static gboolean _find_tag_iter_tagid(GtkTreeModel *model, GtkTreeIter *iter, const gint tagid)
{
  gint tag;
  do
  {
    gtk_tree_model_get(model, iter, DT_LIB_TAGGING_COL_ID, &tag, -1);
    if(tag == tagid)
    {
      return TRUE;
    }
    GtkTreeIter child, parent = *iter;
    if(gtk_tree_model_iter_children(model, &child, &parent))
      if(_find_tag_iter_tagid(model, &child, tagid))
      {
        *iter = child;
        return TRUE;
      }
  } while (gtk_tree_model_iter_next(model, iter));
  return FALSE;
}
 
// calculate the indeterminated state (1) where needed on the tree
static void _calculate_sel_on_path(GtkTreeModel *model, GtkTreeIter *iter, const gboolean root)
{
  GtkTreeIter child, parent = *iter;
  do
  {
    gint sel = DT_TS_NO_IMAGE;
    gtk_tree_model_get(model, &parent, DT_LIB_TAGGING_COL_SEL, &sel, -1);
    if(sel == DT_TS_ALL_IMAGES)
    {
      _propagate_sel_to_parents(model, &parent);
    }
    if(gtk_tree_model_iter_children(model, &child, &parent))
      _calculate_sel_on_path(model, &child, FALSE);
  } while (!root && gtk_tree_model_iter_next(model, &parent));
}
 
// reset the indeterminated selection (1) on the tree
static void _reset_sel_on_path(GtkTreeModel *model, GtkTreeIter *iter, const gboolean root)
{
  GtkTreeIter child, parent = *iter;
  do
  {
    if(gtk_tree_model_iter_children(model, &child, &parent))
    {
      gint sel = DT_TS_NO_IMAGE;
      gtk_tree_model_get(model, &parent, DT_LIB_TAGGING_COL_SEL, &sel, -1);
      if(sel == DT_TS_SOME_IMAGES)
      {
        gtk_tree_store_set(GTK_TREE_STORE(model), &parent,
                           DT_LIB_TAGGING_COL_SEL, DT_TS_NO_IMAGE, -1);
      }
      _reset_sel_on_path(model, &child, FALSE);
    }
  } while (!root && gtk_tree_model_iter_next(model, &parent));
}
 
// reset all selection (1 & 2) on the tree
static void _reset_sel_on_path_full(GtkTreeModel *model, GtkTreeIter *iter, const gboolean root)
{
  GtkTreeIter child, parent = *iter;
  do
  {
    if(GTK_IS_TREE_STORE(model))
    {
      gtk_tree_store_set(GTK_TREE_STORE(model), &parent,
                         DT_LIB_TAGGING_COL_SEL, DT_TS_NO_IMAGE, -1);
      if(gtk_tree_model_iter_children(model, &child, &parent))
        _reset_sel_on_path_full(model, &child, FALSE);
    }
    else
    {
      gtk_list_store_set(GTK_LIST_STORE(model), &parent,
                         DT_LIB_TAGGING_COL_SEL, DT_TS_NO_IMAGE, -1);
    }
  } while (!root && gtk_tree_model_iter_next(model, &parent));
}
 
//  try to find a node fully attached (2) which is the root of the update loop. If not the full tree will be used
static void _find_root_iter_iter(GtkTreeModel *model, GtkTreeIter *iter, GtkTreeIter *parent)
{
  guint sel;
  GtkTreeIter child = *iter;
  while (gtk_tree_model_iter_parent(model, parent, &child))
  {
    gtk_tree_model_get(model, parent, DT_LIB_TAGGING_COL_SEL, &sel, -1);
    if(sel == DT_TS_ALL_IMAGES)
    {
      char *path = NULL;
      gtk_tree_model_get(model, parent, DT_LIB_TAGGING_COL_PATH, &path, -1);
      dt_free(path);
      return; // no need to go further
    }
    child = *parent;
  }
  *parent = child;  // last before root
  char *path = NULL;
  gtk_tree_model_get(model, parent, DT_LIB_TAGGING_COL_PATH, &path, -1);
  dt_free(path);
}
 
// with tag detach update the tree selection
static void _calculate_sel_on_tree(GtkTreeModel *model, GtkTreeIter *iter)
{
  GtkTreeIter parent;
  if(iter)
  {
    // only on sub-tree
    _find_root_iter_iter(model, iter, &parent);
    _reset_sel_on_path(model, &parent, TRUE);
    _calculate_sel_on_path(model, &parent, TRUE);
  }
  else
  {
    // on full tree
    if(gtk_tree_model_get_iter_first(model, &parent))
    {
      _reset_sel_on_path(model, &parent, FALSE);
      _calculate_sel_on_path(model, &parent, FALSE);
    }
  }
}
 
// get the new selected images and update the tree selection
static void _update_sel_on_tree(GtkTreeModel *model)
{
  GList *tags = NULL;
  dt_tag_get_attached(-1, &tags, TRUE);
  GtkTreeIter parent;
  if(gtk_tree_model_get_iter_first(model, &parent))
  {
    _reset_sel_on_path_full(model, &parent, FALSE);
    for (GList *tag = tags; tag; tag = g_list_next(tag))
    {
      GtkTreeIter iter = parent;
      if(_find_tag_iter_tagid(model, &iter, ((dt_tag_t *)tag->data)->id))
      {
        if(GTK_IS_TREE_STORE(model))
        {
          gtk_tree_store_set(GTK_TREE_STORE(model), &iter,
                             DT_LIB_TAGGING_COL_SEL, ((dt_tag_t *)tag->data)->select, -1);
          _propagate_sel_to_parents(model, &iter);
        }
        else
        {
          gtk_list_store_set(GTK_LIST_STORE(model), &iter,
                             DT_LIB_TAGGING_COL_SEL, ((dt_tag_t *)tag->data)->select, -1);
        }
      }
    }
  }
  if(tags)
    dt_tag_free_result(&tags);
}
 
// delete a tag in the tree (tree or list)
// delete a branch of the tag tree
static void _delete_tree_path(GtkTreeModel *model, GtkTreeIter *iter, gboolean root, gboolean tree)
{
  if(tree) // the treeview is tree. It handles the hierarchy itself (parent / child)
  {
    GtkTreeIter child, parent = *iter;
    gboolean valid = TRUE;
    do
    {
      if(gtk_tree_model_iter_children(model, &child, &parent))
        _delete_tree_path(model, &child, FALSE, tree);
      GtkTreeIter tobedel = parent;
      valid = gtk_tree_model_iter_next(model, &parent);
      if(root)
      {
        gtk_tree_store_set(GTK_TREE_STORE(model), &tobedel,
                           DT_LIB_TAGGING_COL_SEL, DT_TS_NO_IMAGE,
                           DT_LIB_TAGGING_COL_COUNT, 0, -1);
 
        char *path2 = NULL;
        gtk_tree_model_get(model, &tobedel, DT_LIB_TAGGING_COL_PATH, &path2, -1);
        dt_free(path2);
 
        _calculate_sel_on_tree(model, &tobedel);
      }
      char *path = NULL;
      gtk_tree_model_get(model, &tobedel, DT_LIB_TAGGING_COL_PATH, &path, -1);
      dt_free(path);
      gtk_tree_store_remove(GTK_TREE_STORE(model), &tobedel);
    } while (!root && valid);
  }
  else  // treeview is a list. The hierarchy of tags is found with the root (left part) of tagname
  {
    GtkTreeIter child;
    char *path = NULL;
    gtk_tree_model_get(model, iter, DT_LIB_TAGGING_COL_PATH, &path, -1);
    guint pathlen = strlen(path);
    gboolean valid = gtk_tree_model_get_iter_first(model, &child);
    while(valid)
    {
      char *path2 = NULL;
      gtk_tree_model_get(model, &child, DT_LIB_TAGGING_COL_PATH, &path2, -1);
      GtkTreeIter tobedel = child;
      valid = gtk_tree_model_iter_next (model, &child);
      if(strlen(path2) >= pathlen)
      {
        char letter = path2[pathlen];
        path2[pathlen] = '\0';
        if(g_strcmp0(path, path2) == 0)
        {
          path2[pathlen] = letter;
          gtk_list_store_remove(GTK_LIST_STORE(model), &tobedel);
        }
      }
      dt_free(path2);
    }
    dt_free(path);
  }
}
 
static void _lib_selection_changed_callback(gpointer instance, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  _init_treeview(self, 0);
  if(!d->tree_flag && d->suggestion_flag)
  {
    _init_treeview(self, 1);
  }
  else
    _update_sel_on_tree(d->tree_flag ? GTK_TREE_MODEL(d->dictionary_treestore)
                                    : GTK_TREE_MODEL(d->dictionary_liststore));
 
  _update_atdetach_buttons(self);
}
 
static void _set_keyword(dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  const gchar *beg = g_strrstr(gtk_entry_get_text(d->dict_entry), ",");
 
  if(IS_NULL_PTR(beg))
    beg = gtk_entry_get_text(d->dict_entry);
  else
  {
    if(*beg == ',') beg++;
    if(*beg == ' ') beg++;
  }
  g_strlcpy(d->keyword, beg, sizeof(d->keyword));
}
 
static gboolean _update_tag_name_per_name(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, dt_tag_op_t *to)
{
  char *tagname;
  char *newtagname = to->newtagname;
  char *oldtagname = to->oldtagname;
  gtk_tree_model_get(model, iter, DT_LIB_TAGGING_COL_PATH, &tagname, -1);
  if(g_str_has_prefix(tagname, oldtagname))
  {
    if(strlen(tagname) == strlen(oldtagname))
    {
      // rename the tag itself
      if(to->tree_flag)
      {
        char *subtag = g_strrstr(to->newtagname, "|");
        subtag = (!subtag) ? newtagname : subtag + 1;
        gtk_tree_store_set(GTK_TREE_STORE(model), iter, DT_LIB_TAGGING_COL_PATH,
                           newtagname, DT_LIB_TAGGING_COL_TAG, subtag, -1);
      }
      else
      {
        gtk_list_store_set(GTK_LIST_STORE(model), iter, DT_LIB_TAGGING_COL_PATH,
                           newtagname, DT_LIB_TAGGING_COL_TAG, newtagname, -1);
      }
    }
    else if(strlen(tagname) > strlen(oldtagname) && tagname[strlen(oldtagname)] == '|')
    {
      // rename similar path
      char *newpath = g_strconcat(newtagname, &tagname[strlen(oldtagname)] , NULL);
      if(to->tree_flag)
      {
        gtk_tree_store_set(GTK_TREE_STORE(model), iter, DT_LIB_TAGGING_COL_PATH,
                           newpath, -1);
      }
      else
      {
        gtk_list_store_set(GTK_LIST_STORE(model), iter, DT_LIB_TAGGING_COL_PATH,
                           newpath, DT_LIB_TAGGING_COL_TAG, newpath, -1);
      }
      dt_free(newpath);
    }
  }
  dt_free(tagname);
  return FALSE;
}
 
static void _update_attached_count(const int tagid, GtkTreeView *view, const gboolean tree_flag)
{
  const guint count = dt_tag_images_count(tagid);
  GtkTreeModel *model = gtk_tree_view_get_model(view);
  GtkTreeModel *store = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
  GtkTreeIter iter;
  if(gtk_tree_model_get_iter_first(store, &iter))
  {
    if(_find_tag_iter_tagid(store, &iter, tagid))
    {
      if(tree_flag)
      {
        gtk_tree_store_set(GTK_TREE_STORE(store), &iter,
                           DT_LIB_TAGGING_COL_COUNT, count,
                           DT_LIB_TAGGING_COL_SEL, DT_TS_ALL_IMAGES, -1);
        _calculate_sel_on_tree(GTK_TREE_MODEL(store), &iter);
      }
      else
      {
        gtk_list_store_set(GTK_LIST_STORE(store), &iter,
                           DT_LIB_TAGGING_COL_COUNT, count,
                           DT_LIB_TAGGING_COL_SEL, DT_TS_ALL_IMAGES, -1);
      }
    }
  }
}
 
void init_presets(dt_lib_module_t *self)
{
 
}
 
void *get_params(dt_lib_module_t *self, int *size)
{
  char *params = NULL;
  *size = 0;
  GList *tags = NULL;
  const guint count = dt_tag_get_attached(-1, &tags, TRUE);
 
  if(count)
  {
    for(GList *taglist = tags; taglist; taglist = g_list_next(taglist))
    {
      params = dt_util_dstrcat(params, "%d,", ((dt_tag_t *)taglist->data)->id);
    }
    dt_tag_free_result(&tags);
    if(IS_NULL_PTR(params))
      return NULL;
    *size = strlen(params);
    params[*size-1]='\0';
  }
  return params;
}
 
int set_params(dt_lib_module_t *self, const void *params, int size)
{
  if(IS_NULL_PTR(params) || !size) return 1;
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
 
  const char *buf = (char *)params;
  if(buf && buf[0])
  {
    gchar **tokens = g_strsplit(buf, ",", 0);
    if(tokens)
    {
      GList *tags = NULL;
      gchar **entry = tokens;
      while(*entry)
      {
        const guint tagid = strtoul(*entry, NULL, 0);
        tags = g_list_prepend(tags, GINT_TO_POINTER(tagid));
        entry++;
      }
      g_strfreev(tokens);
      GList *imgs = dt_act_on_get_images();
      dt_tag_set_tags(tags, imgs, TRUE, FALSE, TRUE);
      g_list_free(imgs);
      imgs = NULL;
      gboolean change = FALSE;
      for(GList *tag = tags; tag; tag = g_list_next(tag))
      {
        _update_attached_count(GPOINTER_TO_INT(tag->data), d->dictionary_view, d->tree_flag);
        change = TRUE;
      }
 
      if(change)
      {
        _init_treeview(self, 0);
        _raise_signal_tag_changed(self);
        dt_image_synch_xmp(-1);
      }
      g_list_free(tags);
      tags = NULL;
    }
  }
  return 0;
}
 
// collect the tag ids of all currently selected rows of view (skips non-tag nodes)
static GList *_selected_tagids(GtkTreeView *view)
{
  GList *ids = NULL;
  GtkTreeModel *model = NULL;
  GList *rows = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(view), &model);
  for(GList *r = rows; r; r = g_list_next(r))
  {
    GtkTreeIter iter;
    if(gtk_tree_model_get_iter(model, &iter, (GtkTreePath *)r->data))
    {
      guint tagid = 0;
      gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_ID, &tagid, -1);
      if(tagid > 0) ids = g_list_prepend(ids, GUINT_TO_POINTER(tagid));
    }
  }
  g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free);
  return ids;
}
 
// detach the given tag ids from the images to act on, then refresh the views
static void _detach_tagids(GList *tagids, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  if(IS_NULL_PTR(tagids)) return;
  GList *imgs = dt_act_on_get_images();
  if(IS_NULL_PTR(imgs)) return;
 
  gboolean changed = FALSE;
  for(GList *t = tagids; t; t = g_list_next(t))
  {
    const guint tagid = GPOINTER_TO_UINT(t->data);
    if(tagid <= 0) continue;
    GList *affected = dt_tag_get_images_from_list(imgs, tagid);
    if(affected)
    {
      if(dt_tag_detach_images(tagid, affected, TRUE)) changed = TRUE;
      dt_image_synch_xmps(affected);
      g_list_free(affected);
    }
  }
  g_list_free(imgs);
 
  _init_treeview(self, 0);
  _init_treeview(self, 1);
  dt_tagging_completion_refresh(d->completion_store);
  _refresh_collection_tags(self);
  if(changed) _raise_signal_tag_changed(self);
}
 
static void _pop_menu_attached_attach_to_all(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GtkTreeIter iter;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->attached_view));
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(d->attached_view));
  if(!_selection_get_first(selection, &model, &iter))
    return;
  guint tagid;
  gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_ID, &tagid, -1);
  if(tagid <= 0) return;
 
  // attach tag on images to act on
  const gboolean res = dt_tag_attach(tagid, -1, TRUE, TRUE);
 
  _save_last_tag_used(dt_tag_get_name(tagid), d);
 
  _init_treeview(self, 0);
 
  const uint32_t count = dt_tag_images_count(tagid);
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->dictionary_view));
  if(gtk_tree_model_get_iter_first(model, &iter))
  {
    if(_find_tag_iter_tagid(model, &iter, tagid))
    {
      GtkTreeIter store_iter;
      GtkTreeModel *store = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
      gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model),
                                &store_iter, &iter);
      if(d->tree_flag)
      {
        gtk_tree_store_set(GTK_TREE_STORE(store), &store_iter, DT_LIB_TAGGING_COL_COUNT, count, -1);
      }
      else
      {
        gtk_list_store_set(GTK_LIST_STORE(store), &store_iter, DT_LIB_TAGGING_COL_COUNT, count, -1);
      }
    }
  }
 
  if(res)
  {
    _raise_signal_tag_changed(self);
    dt_image_synch_xmp(-1);
  }
}
 
static void _pop_menu_attached_detach(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GList *tagids = _selected_tagids(d->attached_view);
  _detach_tagids(tagids, self);
  g_list_free(tagids);
}
 
// detach every (user) tag currently listed in the attached view
static void _pop_menu_attached_detach_all(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->attached_view));
  GtkTreeIter iter;
  GList *tagids = NULL;
  if(gtk_tree_model_get_iter_first(model, &iter))
  {
    do
    {
      if(!_is_user_tag(model, &iter)) continue;  // never touch Ansel internal tags
      guint tagid = 0;
      gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_ID, &tagid, -1);
      if(tagid > 0) tagids = g_list_prepend(tagids, GUINT_TO_POINTER(tagid));
    } while(gtk_tree_model_iter_next(model, &iter));
  }
  _detach_tagids(tagids, self);
  g_list_free(tagids);
}
 
static void _pop_menu_attached(GtkWidget *treeview, GdkEventButton *event, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GtkWidget *menu, *menuitem;
  menu = gtk_menu_new();
 
  GtkTreeIter iter;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->attached_view));
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(d->attached_view));
  const gint sel_cnt = gtk_tree_selection_count_selected_rows(selection);
 
  // "attach to all" only makes sense for a single partially-attached tag
  if(sel_cnt == 1 && _selection_get_first(selection, &model, &iter))
  {
    guint sel;
    gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_SEL, &sel, -1);
    if(sel == DT_TS_SOME_IMAGES)
    {
      menuitem = gtk_menu_item_new_with_label(_("attach tag to all"));
      g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_attached_attach_to_all, self);
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
      menuitem = gtk_separator_menu_item_new();
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    }
  }
 
  if(sel_cnt > 0)
  {
    menuitem = gtk_menu_item_new_with_label(sel_cnt > 1 ? _("detach tags") : _("detach tag"));
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_attached_detach, self);
  }
 
  menuitem = gtk_menu_item_new_with_label(_("detach all tags"));
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
  g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_attached_detach_all, self);
 
  gtk_widget_show_all(GTK_WIDGET(menu));
 
  gtk_menu_popup_at_pointer(GTK_MENU(menu), (GdkEvent *)event);
}
 
// detach the single tag of the row whose per-row "delete" icon was clicked
static gboolean _attached_delete_icon_activated(GtkCellRenderer *cell, GdkEvent *event, GtkWidget *treeview,
                                                const gchar *path_str, GdkRectangle *background,
                                                GdkRectangle *cell_area, GtkCellRendererState flags,
                                                gpointer user_data)
{
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
  GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
  GtkTreeIter iter;
  if(path && gtk_tree_model_get_iter(model, &iter, path))
  {
    guint tagid = 0;
    gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_ID, &tagid, -1);
    if(tagid > 0)
    {
      GList *one = g_list_prepend(NULL, GUINT_TO_POINTER(tagid));
      _detach_tagids(one, self);
      g_list_free(one);
    }
  }
  if(path) gtk_tree_path_free(path);
  return TRUE;
}
 
// only real user tags get a per-row delete icon (not Ansel internal tags,
// nor the free/parent nodes that appear in tree view, which have no tag id)
static void _attached_delete_icon_show(GtkTreeViewColumn *col, GtkCellRenderer *renderer,
                                       GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
{
  guint tagid = 0;
  gtk_tree_model_get(model, iter, DT_LIB_TAGGING_COL_ID, &tagid, -1);
  g_object_set(renderer, "icon-name", "edit-delete-symbolic",
               "visible", (tagid > 0) && _is_user_tag(model, iter), NULL);
}
 
static gboolean _click_on_view_attached(GtkWidget *view, GdkEventButton *event, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  _unselect_all_in_view(d->dictionary_view);
 
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->attached_view));
  GtkTreePath *path = NULL;
  const gboolean on_row =
    gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(view), (gint)event->x, (gint)event->y, &path, NULL, NULL, NULL);
 
  gboolean valid_tag = FALSE;
  GtkTreeIter iter;
  if(on_row && gtk_tree_model_get_iter(model, &iter, path))
    valid_tag = _is_user_tag(model, &iter);  // not an Ansel internal tag
 
  // right-click: always offer the menu, even on empty space (so "detach all tags" is reachable)
  if(event->type == GDK_BUTTON_PRESS && event->button == 3)
  {
    if(valid_tag)
    {
      // keep an existing multi-selection so the menu can act on it in bulk
      if(!gtk_tree_selection_path_is_selected(selection, path))
      {
        gtk_tree_selection_unselect_all(selection);
        gtk_tree_selection_select_path(selection, path);
      }
    }
    else
      gtk_tree_selection_unselect_all(selection);  // clicked empty space / an Ansel tag
    _pop_menu_attached(view, event, self);
    if(path) gtk_tree_path_free(path);
    return TRUE;
  }
 
  // double-click on a user tag: detach that single tag
  if(event->type == GDK_2BUTTON_PRESS && event->button == 1 && valid_tag)
  {
    guint tagid = 0;
    gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_ID, &tagid, -1);
    if(tagid > 0)
    {
      GList *one = g_list_prepend(NULL, GUINT_TO_POINTER(tagid));
      _detach_tagids(one, self);
      g_list_free(one);
    }
    if(path) gtk_tree_path_free(path);
    return TRUE;
  }
 
  // single click on an Ansel internal tag: prevent selecting it
  if(event->type == GDK_BUTTON_PRESS && event->button == 1 && on_row && !valid_tag)
  {
    gtk_tree_path_free(path);
    return TRUE;
  }
 
  if(path) gtk_tree_path_free(path);
  return FALSE;
}
 
static gboolean _attached_key_pressed(GtkWidget *view, GdkEventKey *event, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  _unselect_all_in_view(d->dictionary_view);
 
  guint key = dt_keys_mainpad_alternatives(event->keyval);
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  if(key == GDK_KEY_Delete && gtk_tree_selection_count_selected_rows(selection) > 0)
  {
    GList *tagids = _selected_tagids(GTK_TREE_VIEW(view));
    _detach_tagids(tagids, self);
    g_list_free(tagids);
    return TRUE;
  }
  if(key == GDK_KEY_Tab)
  {
    gtk_tree_selection_unselect_all(selection);
    gtk_widget_grab_focus(GTK_WIDGET(d->entry));
    return TRUE;
  }
  else if(key == GDK_KEY_ISO_Left_Tab)
  {
    gtk_tree_selection_unselect_all(selection);
    return TRUE;
  }
  return FALSE;
}
 
// create the tag typed in src and attach it to the current selection
static void _create_tag_from_entry(dt_lib_module_t *self, GtkEntry *src)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  const gchar *tag = gtk_entry_get_text(src);
  if(IS_NULL_PTR(tag) || tag[0] == '\0') return;
 
  GList *imgs = dt_selection_get_list(dt_selection_get_global());
  const gboolean res = dt_tag_attach_string_list(tag, imgs, TRUE);
  if(res) dt_image_synch_xmps(imgs);
  g_list_free(imgs);
  imgs = NULL;
 
  _save_last_tag_used(tag, d);
 
  _entry_clear_suppressed(src);
 
  _init_treeview(self, 0);
  _init_treeview(self, 1);
  // _raise_signal_tag_changed() may block the tags-changed callback, so refresh
  // the autocompletion explicitly to pick up the freshly created tag
  dt_tagging_completion_refresh(d->completion_store);
  _refresh_collection_tags(self);
  char *tagname = strrchr(d->last_tag, ',');
  if(res) _raise_signal_tag_changed(self);
  _show_tag_on_view(GTK_TREE_VIEW(d->dictionary_view),
                    tagname ? tagname + 1 : d->last_tag, FALSE, TRUE);
}
 
// "new" button in the management popup: create from its search entry
static void _new_button_clicked(GtkButton *button, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  _create_tag_from_entry(self, d->dict_entry);
}
 
/* Clear a tag entry without its own key handler taking the programmatic change for user input.
 *
 * dt_gui_widget_freeze() (widgets/widget_settings.h) is the application-wide way to say that, and
 * the one this file already uses everywhere else: it raises the suppression depth for the rest of
 * the enclosing scope and drops it on every exit path, while each widget callback opens by asking
 * dt_gui_widgets_suppressed(). Disconnecting the handler by id and reconnecting it around the
 * clear expressed the same intent, but had to be spelled out identically at four call sites, and
 * left the entry with NO key handler at all if anything between the two ever returned early. */
static void _entry_clear_suppressed(GtkEntry *entry)
{
  dt_gui_widget_freeze();
  dt_tagging_entry_clear(entry);
}
 
static gboolean _enter_key_pressed(GtkWidget *entry, GdkEventKey *event, dt_lib_module_t *self)
{
  // A programmatic clear of the entry is not the user pressing a key. FALSE, not TRUE: a
  // suppressed callback declines the event rather than swallowing it.
  if(dt_gui_widgets_suppressed()) return FALSE;
 
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  guint key = dt_keys_mainpad_alternatives(event->keyval);
  switch(key)
  {
    case GDK_KEY_Return:
      _create_tag_from_entry(self, d->entry);
      break;
    case GDK_KEY_Escape:
      gtk_window_set_focus(GTK_WINDOW(dt_gui_main_window()), NULL);
      break;
    case GDK_KEY_ISO_Left_Tab:
    {
      if(_select_next_user_attached_tag(0, d->attached_view))
      {
        _entry_clear_suppressed(d->entry);
        gtk_widget_grab_focus(GTK_WIDGET(d->attached_view));
      }
      return TRUE;
    }
    default:
      break;
  }
  return FALSE;
}
 
static void _entry_clear_icon(GtkEntry *entry, const GtkEntryIconPosition position,
                              GdkEvent *event, dt_lib_module_t *self)
{
  if(position != GTK_ENTRY_ICON_SECONDARY) return;
 
  _entry_clear_suppressed(entry);
  gtk_widget_grab_focus(GTK_WIDGET(entry));
}
 
 
static void _tag_name_changed(GtkEntry *entry, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  _set_keyword(self);
  GtkTreeModel *model = gtk_tree_view_get_model(d->dictionary_view);
  GtkTreeModel *store = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
  gtk_tree_model_foreach(store, (GtkTreeModelForeachFunc)_set_matching_tag_visibility, self);
  if(d->tree_flag && d->keyword[0])
  {
    gtk_tree_model_foreach(store, (GtkTreeModelForeachFunc)_tree_reveal_func, NULL);
    _show_keyword_on_view(d->dictionary_view, d->keyword, FALSE);
  }
}
 
static void _pop_menu_dictionary_delete_node(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
 
  int res = GTK_RESPONSE_YES;
 
  char *tagname;
  gint tagid;
  gchar *text;
  GtkWidget *label;
  GtkTreeIter iter;
  GtkTreeModel *model = NULL;
  GtkTreeView *view = d->dictionary_view;
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  if(!_selection_get_first(selection, &model, &iter)) return;
 
  gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_PATH, &tagname,
          DT_LIB_TAGGING_COL_ID, &tagid, -1);
 
  gint tag_count = 0;
  gint img_count = 0;
  dt_tag_count_tags_images(tagname, &tag_count, &img_count);
  if(tag_count == 0) return;
 
  GtkWidget *win = dt_gui_main_window();
  GtkWidget *dialog = gtk_dialog_new_with_buttons( _("delete node?"), GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT,
                                _("cancel"), GTK_RESPONSE_NONE, _("delete"), GTK_RESPONSE_YES, NULL);
  gtk_window_set_default_size(GTK_WINDOW(dialog), 300, -1);
  GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
  GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
  gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
  gtk_container_add(GTK_CONTAINER(area), vbox);
  text = g_strdup_printf(_("selected: %s"), tagname);
  label = gtk_label_new(text);
  gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0);
  dt_free(text);
 
  GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, TRUE, 0);
  text = g_strdup_printf(ngettext("<u>%d</u> tag will be deleted", "<u>%d</u> tags will be deleted", tag_count), tag_count);
  label = gtk_label_new(NULL);
  gtk_label_set_markup(GTK_LABEL(label), text);
  gtk_box_pack_start(GTK_BOX(box), label, FALSE, TRUE, 0);
  dt_free(text);
  text = g_strdup_printf(ngettext("<u>%d</u> image will be updated", "<u>%d</u> images will be updated", img_count), img_count);
  label = gtk_label_new(NULL);
  gtk_label_set_markup(GTK_LABEL(label), text);
  gtk_box_pack_start(GTK_BOX(box), label, FALSE, TRUE, 0);
  dt_free(text);
 
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(dialog);
#endif
  gtk_widget_show_all(dialog);
 
  res = gtk_dialog_run(GTK_DIALOG(dialog));
  GtkWindow *dialog_parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
  gtk_widget_destroy(dialog);
  dt_gui_refocus_parent(dialog_parent);
  if(res != GTK_RESPONSE_YES)
  {
    dt_free(tagname);
    return;
  }
 
  GList *tag_family = NULL;
  GList *tagged_images = NULL;
  dt_tag_get_tags_images(tagname, &tag_family, &tagged_images);
 
  dt_control_signal_block_by_func(dt_control_signal_get_global(), G_CALLBACK(_lib_tagging_tags_changed_callback), self);
  tag_count = dt_tag_remove_list(tag_family);
  dt_control_signal_unblock_by_func(dt_control_signal_get_global(), G_CALLBACK(_lib_tagging_tags_changed_callback), self);
  dt_control_log(_("%d tags removed"), tag_count);
 
  GtkTreeIter store_iter;
  GtkTreeModel *store = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
  gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model),
                            &store_iter, &iter);
  _delete_tree_path(GTK_TREE_MODEL(store), &store_iter, TRUE, d->tree_flag);
  _init_treeview(self, 0);
 
  dt_tag_free_result(&tag_family);
  dt_image_synch_xmps(tagged_images);
  g_list_free(tagged_images);
  tagged_images = NULL;
  dt_tagging_completion_refresh(d->completion_store);
  _refresh_collection_tags(self);
  _raise_signal_tag_changed(self);
  dt_free(tagname);
}
 
// create tag allows the user to create a single tag, which can be an element of the hierarchy or not
static void _pop_menu_dictionary_create_tag(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
 
  char *tagname;
  char *path;
  gint tagid;
  gchar *text;
  GtkWidget *label;
  GtkTreeIter iter;
  GtkTreeModel *model = NULL;
  GtkTreeView *view = d->dictionary_view;
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  if(!_selection_get_first(selection, &model, &iter)) return;
 
  gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_TAG, &tagname,
        DT_LIB_TAGGING_COL_PATH, &path, DT_LIB_TAGGING_COL_ID, &tagid, -1);
 
  GtkWidget *win = dt_gui_main_window();
  GtkWidget *dialog = gtk_dialog_new_with_buttons(_("create tag"), GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT,
                                       _("cancel"), GTK_RESPONSE_NONE, _("save"), GTK_RESPONSE_YES, NULL);
  gtk_window_set_default_size(GTK_WINDOW(dialog), 300, -1);
  GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
  GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
  gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
  gtk_container_add(GTK_CONTAINER(area), vbox);
 
  GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, TRUE, 0);
  label = gtk_label_new(_("name: "));
  gtk_box_pack_start(GTK_BOX(box), label, FALSE, TRUE, 0);
  GtkWidget *entry = gtk_entry_new();
  dt_accels_disconnect_on_text_input(entry);
  gtk_box_pack_end(GTK_BOX(box), entry, TRUE, TRUE, 0);
 
  GtkWidget *category;
  GtkWidget *private;
  GtkWidget *parent;
  GtkTextBuffer *buffer = NULL;
  GtkWidget *vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, TRUE, 0);
 
  text = g_strdup_printf(_("add to: \"%s\" "), path);
  parent = gtk_check_button_new_with_label(text);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(parent), TRUE);
  gtk_box_pack_end(GTK_BOX(vbox2), parent, FALSE, TRUE, 0);
  dt_free(text);
 
  category = gtk_check_button_new_with_label(_("category"));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(category), FALSE);
  gtk_box_pack_end(GTK_BOX(vbox2), category, FALSE, TRUE, 0);
  private = gtk_check_button_new_with_label(_("private"));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(private), FALSE);
  gtk_box_pack_end(GTK_BOX(vbox2), private, FALSE, TRUE, 0);
 
  box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_end(GTK_BOX(vbox), box, TRUE, TRUE, 0);
  label = gtk_label_new(_("synonyms: "));
  gtk_box_pack_start(GTK_BOX(box), label, FALSE, TRUE, 0);
  GtkWidget *synonyms = gtk_text_view_new();
  dt_accels_disconnect_on_text_input(synonyms);
  dt_gui_textview_set_padding(GTK_TEXT_VIEW(synonyms));
  gtk_box_pack_end(GTK_BOX(box), synonyms, TRUE, TRUE, 0);
  gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(synonyms), GTK_WRAP_WORD);
  buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(synonyms));
 
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(dialog);
#endif
  gtk_widget_show_all(dialog);
 
  if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES)
  {
    const char *newtag = gtk_entry_get_text(GTK_ENTRY(entry));
    char *message = NULL;
    if(!newtag[0])
      message = _("empty tag is not allowed, aborting");
    char *new_tagname = NULL;
    const gboolean root = !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(parent));
    if(!root)
    {
      new_tagname = g_strdup(path);
      new_tagname = dt_util_dstrcat(new_tagname, "|%s", newtag);
    }
    else new_tagname = g_strdup(newtag);
 
    if(dt_tag_exists(new_tagname, NULL))
      message = _("tag name already exists. aborting.");
    if(message)
    {
      GtkWidget *warning_dialog = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL,
                      GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "%s", message);
      gtk_dialog_run(GTK_DIALOG(warning_dialog));
      gtk_widget_destroy(warning_dialog);
      GtkWindow *dialog_parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
      gtk_widget_destroy(dialog);
      dt_gui_refocus_parent(dialog_parent);
      dt_free(tagname);
      return;
    }
    guint new_tagid = 0;
    if(dt_tag_new(new_tagname, &new_tagid))
    {
      const gint new_flags = ((gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(category)) ? DT_TF_CATEGORY : 0) |
                      (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(private)) ? DT_TF_PRIVATE : 0));
      if(new_tagid) dt_tag_set_flags(new_tagid, new_flags);
      GtkTextIter start, end;
      gtk_text_buffer_get_start_iter(buffer, &start);
      gtk_text_buffer_get_end_iter(buffer, &end);
      gchar *new_synonyms_list = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
      if(new_tagid && new_synonyms_list && new_synonyms_list[0])
        dt_tag_set_synonyms(new_tagid, new_synonyms_list);
      dt_free(new_synonyms_list);
      _init_treeview(self, 1);
      dt_tagging_completion_refresh(d->completion_store);
      _raise_signal_tag_changed(self);
      _show_tag_on_view(view, new_tagname, FALSE, TRUE);
    }
    dt_free(new_tagname);
  }
  _init_treeview(self, 0);
  GtkWindow *dialog_parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
  gtk_widget_destroy(dialog);
  dt_gui_refocus_parent(dialog_parent);
  dt_free(tagname);
}
 
// edit tag allows the user to rename a single tag, which can be an element of the hierarchy and change other parameters
static void _pop_menu_dictionary_edit_tag(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
 
  char *tagname;
  char *synonyms_list;
  gint tagid;
  gchar *text;
  GtkWidget *label;
  GtkTreeIter iter;
  GtkTreeModel *model = NULL;
  GtkTreeView *view = d->dictionary_view;
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  if(!_selection_get_first(selection, &model, &iter)) return;
 
  gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_PATH, &tagname,
          DT_LIB_TAGGING_COL_SYNONYM, &synonyms_list, DT_LIB_TAGGING_COL_ID, &tagid, -1);
  char *subtag = g_strrstr(tagname, "|");
  if(subtag) subtag = subtag + 1;
  gint tag_count;
  gint img_count;
  dt_tag_count_tags_images(tagname, &tag_count, &img_count);
  if(tag_count == 0)
  {
    dt_free(tagname);
    dt_free(synonyms_list);
    return;
  }
 
  GtkWidget *win = dt_gui_main_window();
  GtkWidget *dialog = gtk_dialog_new_with_buttons(_("edit"), GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT,
                                       _("cancel"), GTK_RESPONSE_NONE, _("save"), GTK_RESPONSE_YES, NULL);
  gtk_window_set_default_size(GTK_WINDOW(dialog), 300, -1);
  GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
  GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
  gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
  gtk_container_add(GTK_CONTAINER(area), vbox);
  text = g_strdup_printf(_("selected: %s"), tagname);
  label = gtk_label_new(text);
  gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0);
  dt_free(text);
 
  GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, TRUE, 0);
  text = g_strdup_printf(ngettext("<u>%d</u> tag will be updated", "<u>%d</u> tags will be updated", tag_count), tag_count);
  label = gtk_label_new(NULL);
  gtk_label_set_markup(GTK_LABEL(label), text);
  gtk_box_pack_start(GTK_BOX(box), label, FALSE, TRUE, 0);
  dt_free(text);
  text = g_strdup_printf(ngettext("<u>%d</u> image will be updated", "<u>%d</u> images will be updated", img_count), img_count);
  label = gtk_label_new(NULL);
  gtk_label_set_markup(GTK_LABEL(label), text);
  gtk_box_pack_start(GTK_BOX(box), label, FALSE, TRUE, 0);
  dt_free(text);
 
  box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, TRUE, 0);
  label = gtk_label_new(_("name: "));
  gtk_box_pack_start(GTK_BOX(box), label, FALSE, TRUE, 0);
  GtkWidget *entry = gtk_entry_new();
  dt_accels_disconnect_on_text_input(entry);
  gtk_entry_set_text(GTK_ENTRY(entry), subtag ? subtag : tagname);
  gtk_box_pack_end(GTK_BOX(box), entry, TRUE, TRUE, 0);
 
  gint flags = 0;
  GtkWidget *category = NULL;
  GtkWidget *private = gtk_check_button_new_with_label(_("private"));
  GtkTextBuffer *buffer = NULL;
 
  if(tagid)
  {
    GtkWidget *vbox2 = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
    gtk_box_pack_start(GTK_BOX(vbox), vbox2, FALSE, TRUE, 0);
    flags = dt_tag_get_flags(tagid);
    category = gtk_check_button_new_with_label(_("category"));
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(category), flags & DT_TF_CATEGORY);
    gtk_box_pack_end(GTK_BOX(vbox2), category, FALSE, TRUE, 0);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(private), flags & DT_TF_PRIVATE);
    gtk_box_pack_end(GTK_BOX(vbox2), private, FALSE, TRUE, 0);
 
    box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
    gtk_box_pack_end(GTK_BOX(vbox), box, TRUE, TRUE, 0);
    label = gtk_label_new(_("synonyms: "));
    gtk_box_pack_start(GTK_BOX(box), label, FALSE, TRUE, 0);
    GtkWidget *synonyms = gtk_text_view_new();
    dt_accels_disconnect_on_text_input(synonyms);
    dt_gui_textview_set_padding(GTK_TEXT_VIEW(synonyms));
    gtk_box_pack_end(GTK_BOX(box), synonyms, TRUE, TRUE, 0);
    gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(synonyms), GTK_WRAP_WORD);
    buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(synonyms));
    if(synonyms_list) gtk_text_buffer_set_text(buffer, synonyms_list, -1);
  }
 
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(dialog);
#endif
  gtk_widget_show_all(dialog);
 
  if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES)
  {
    const char *newtag = gtk_entry_get_text(GTK_ENTRY(entry));
    if(g_strcmp0(newtag, subtag ? subtag : tagname) != 0)
    {
      // tag name has changed
      char *message = NULL;
      if(!newtag[0])
        message = _("empty tag is not allowed, aborting");
      if(strchr(newtag, '|') != 0)
        message = _("'|' character is not allowed for renaming tag.\nto modify the hierarchy use rename path instead. Aborting.");
      if(message)
      {
        GtkWidget *warning_dialog = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL,
                        GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "%s", message);
        gtk_dialog_run(GTK_DIALOG(warning_dialog));
        gtk_widget_destroy(warning_dialog);
        GtkWindow *dialog_parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
        gtk_widget_destroy(dialog);
        dt_gui_refocus_parent(dialog_parent);
        dt_free(tagname);
        return;
      }
 
      GList *tag_family = NULL;
      GList *tagged_images = NULL;
      dt_tag_get_tags_images(tagname, &tag_family, &tagged_images);
 
      const int tagname_len = strlen(tagname);
      char *new_prefix_tag;
      if(subtag)
      {
        const int subtag_len = strlen(subtag);
        const char letter = tagname[tagname_len - subtag_len];
        tagname[tagname_len - subtag_len] = '\0';
        new_prefix_tag = g_strconcat(tagname, newtag, NULL);
        tagname[tagname_len - subtag_len] = letter;
      }
      else
        new_prefix_tag = (char *)newtag;
 
      // check if one of the new tagnames already exists.
      gboolean tagname_exists = FALSE;
      for (GList *taglist = tag_family; taglist && !tagname_exists; taglist = g_list_next(taglist))
      {
        char *new_tagname = g_strconcat(new_prefix_tag, &((dt_tag_t *)taglist->data)->tag[tagname_len], NULL);
        tagname_exists = dt_tag_exists(new_tagname, NULL);
        if(tagname_exists)
        {
          GtkWidget *warning_dialog = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL,
                          GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
                          _("at least one new tag name (%s) already exists, aborting"), new_tagname);
          gtk_dialog_run(GTK_DIALOG(warning_dialog));
          gtk_widget_destroy(warning_dialog);
          dt_free(new_tagname);
          if(subtag)
          {
            dt_free(new_prefix_tag);
          }
          GtkWindow *dialog_parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
          gtk_widget_destroy(dialog);
          dt_gui_refocus_parent(dialog_parent);
          dt_free(tagname);
          return;
        };
        dt_free(new_tagname);
      }
 
      // rename related tags
      for (GList *taglist = tag_family; taglist; taglist = g_list_next(taglist))
      {
        char *new_tagname = g_strconcat(new_prefix_tag, &((dt_tag_t *)taglist->data)->tag[tagname_len], NULL);
        dt_tag_rename(((dt_tag_t *)taglist->data)->id, new_tagname);
        dt_free(new_tagname);
      }
 
      // update the store
      GtkTreeModel *store = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
      dt_tag_op_t *to = g_malloc(sizeof(dt_tag_op_t));
      to->tree_flag = d->tree_flag;
      to->oldtagname = tagname;
      to->newtagname = new_prefix_tag;
      gint sort_column;
      GtkSortType sort_order;
      gtk_tree_sortable_get_sort_column_id(GTK_TREE_SORTABLE(store), &sort_column, &sort_order);
      gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
      gtk_tree_model_foreach(store, (GtkTreeModelForeachFunc)_update_tag_name_per_name, to);
      gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), sort_column, sort_order);
      dt_free(to);
      if(subtag)
      {
        dt_free(new_prefix_tag);
      }
 
      dt_tagging_completion_refresh(d->completion_store);
      _refresh_collection_tags(self);
      _raise_signal_tag_changed(self);
      dt_tag_free_result(&tag_family);
      dt_image_synch_xmps(tagged_images);
      g_list_free(tagged_images);
      tagged_images = NULL;
    }
 
    if(tagid)
    {
      gint new_flags = ((gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(category)) ? DT_TF_CATEGORY : 0) |
                      (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(private)) ? DT_TF_PRIVATE : 0));
      GtkTextIter start, end;
      gtk_text_buffer_get_start_iter(buffer, &start);
      gtk_text_buffer_get_end_iter(buffer, &end);
      gchar *new_synonyms_list = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
      // refresh iter
      _selection_get_first(selection, &model, &iter);
      GtkTreeIter store_iter;
      GtkTreeModel *store = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
      gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model),
                                                       &store_iter, &iter);
      if(new_flags != (flags & (DT_TF_CATEGORY | DT_TF_PRIVATE)))
      {
        new_flags = (flags & ~(DT_TF_CATEGORY | DT_TF_PRIVATE)) | new_flags;
        dt_tag_set_flags(tagid, new_flags);
        if(!d->tree_flag)
          gtk_list_store_set(GTK_LIST_STORE(store), &store_iter, DT_LIB_TAGGING_COL_FLAGS, new_flags, -1);
        else
          gtk_tree_store_set(GTK_TREE_STORE(store), &store_iter, DT_LIB_TAGGING_COL_FLAGS, new_flags, -1);
      }
      if(new_synonyms_list && g_strcmp0(synonyms_list, new_synonyms_list) != 0)
      {
        dt_tag_set_synonyms(tagid, new_synonyms_list);
        if(!d->tree_flag)
          gtk_list_store_set(GTK_LIST_STORE(store), &store_iter, DT_LIB_TAGGING_COL_SYNONYM, new_synonyms_list, -1);
        else
          gtk_tree_store_set(GTK_TREE_STORE(store), &store_iter, DT_LIB_TAGGING_COL_SYNONYM, new_synonyms_list, -1);
      }
      dt_free(new_synonyms_list);
    }
  }
  _init_treeview(self, 0);
  GtkWindow *dialog_parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
  gtk_widget_destroy(dialog);
  dt_gui_refocus_parent(dialog_parent);
  dt_free(synonyms_list);
  dt_free(tagname);
}
 
static gboolean _apply_rename_path(GtkWidget *dialog, const char *tagname,
                                    const char *newtag, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
 
  gboolean success = FALSE;
  GList *tag_family = NULL;
  GList *tagged_images = NULL;
  dt_tag_get_tags_images(tagname, &tag_family, &tagged_images);
 
  // check if one of the new tagnames already exists.
  const int tagname_len = strlen(tagname);
  gboolean tagname_exists = FALSE;
  for(GList *taglist = tag_family; taglist && !tagname_exists; taglist = g_list_next(taglist))
  {
    char *new_tagname = g_strconcat(newtag, &((dt_tag_t *)taglist->data)->tag[tagname_len], NULL);
    tagname_exists = dt_tag_exists(new_tagname, NULL);
    if(tagname_exists)
    {
      GtkWidget *win;
      if(IS_NULL_PTR(dialog))
        win = dt_gui_main_window();
      else
        win = dialog;
 
      GtkWidget *warning_dialog = gtk_message_dialog_new(GTK_WINDOW(win), GTK_DIALOG_MODAL,
                      GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
                      _("at least one new tagname (%s) already exists, aborting."), new_tagname);
      gtk_dialog_run(GTK_DIALOG(warning_dialog));
      gtk_widget_destroy(warning_dialog);
    }
    dt_free(new_tagname);
  }
 
  if(!tagname_exists)
  {
    for (GList *taglist = tag_family; taglist; taglist = g_list_next(taglist))
    {
      char *new_tagname = g_strconcat(newtag, &((dt_tag_t *)taglist->data)->tag[tagname_len], NULL);
      dt_tag_rename(((dt_tag_t *)taglist->data)->id, new_tagname);
      dt_free(new_tagname);
    }
    _init_treeview(self, 0);
    _init_treeview(self, 1);
    dt_tagging_completion_refresh(d->completion_store);
    _refresh_collection_tags(self);
    dt_image_synch_xmps(tagged_images);
    _raise_signal_tag_changed(self);
    _show_tag_on_view(d->dictionary_view, newtag, FALSE, TRUE);
    success = TRUE;
  }
  dt_tag_free_result(&tag_family);
  g_list_free(tagged_images);
  tagged_images = NULL;
 
  return success;
}
 
// rename path allows the user to redefine a hierarchy
static void _pop_menu_dictionary_change_path(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
 
  char *tagname;
  gint tagid;
  gchar *text;
  GtkWidget *label;
  GtkTreeIter iter;
  GtkTreeModel *model = NULL;
  GtkTreeView *view = d->dictionary_view;
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  if(!_selection_get_first(selection, &model, &iter)) return;
 
  gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_PATH, &tagname,
          DT_LIB_TAGGING_COL_ID, &tagid, -1);
 
  gint tag_count = 0;
  gint img_count = 0;
  dt_tag_count_tags_images(tagname, &tag_count, &img_count);
  if(tag_count == 0) return;
 
  GtkWidget *win = dt_gui_main_window();
  GtkWidget *dialog = gtk_dialog_new_with_buttons(_("change path"), GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT,
                                       _("cancel"), GTK_RESPONSE_NONE, _("save"), GTK_RESPONSE_YES, NULL);
  gtk_window_set_default_size(GTK_WINDOW(dialog), 300, -1);
  GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
  GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
  gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
  gtk_container_add(GTK_CONTAINER(area), vbox);
  text = g_strdup_printf(_("selected: %s"), tagname);
  label = gtk_label_new(text);
  gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0);
  dt_free(text);
 
  GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, TRUE, 0);
  text = g_strdup_printf(ngettext("<u>%d</u> tag will be updated", "<u>%d</u> tags will be updated", tag_count), tag_count);
  label = gtk_label_new(NULL);
  gtk_label_set_markup(GTK_LABEL(label), text);
  gtk_box_pack_start(GTK_BOX(box), label, FALSE, TRUE, 0);
  dt_free(text);
  text = g_strdup_printf(ngettext("<u>%d</u> image will be updated", "<u>%d</u> images will be updated", img_count), img_count);
  label = gtk_label_new(NULL);
  gtk_label_set_markup(GTK_LABEL(label), text);
  gtk_box_pack_start(GTK_BOX(box), label, FALSE, TRUE, 0);
  dt_free(text);
 
  GtkWidget *entry = gtk_entry_new();
  dt_accels_disconnect_on_text_input(entry);
  gtk_entry_set_text(GTK_ENTRY(entry), tagname);
  gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, TRUE, 0);
 
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(dialog);
#endif
  gtk_widget_show_all(dialog);
 
  if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES)
  {
    const char *newtag = gtk_entry_get_text(GTK_ENTRY(entry));
    if(g_strcmp0(newtag, tagname) == 0)
      return;  // no change
    char *message = NULL;
    if(!newtag[0])
      message = _("empty tag is not allowed, aborting");
    if(strchr(newtag, '|') == &newtag[0] || strchr(newtag, '|') == &newtag[strlen(newtag)-1] || strstr(newtag, "||"))
      message = _("'|' misplaced, empty tag is not allowed, aborting");
    if(message)
    {
      GtkWidget *warning_dialog = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL,
                      GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, "%s", message);
      gtk_dialog_run(GTK_DIALOG(warning_dialog));
      gtk_widget_destroy(warning_dialog);
      GtkWindow *dialog_parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
      gtk_widget_destroy(dialog);
      dt_gui_refocus_parent(dialog_parent);
      dt_free(tagname);
      return;
    }
    _apply_rename_path(dialog, tagname, newtag, self);
  }
  GtkWindow *dialog_parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
  gtk_widget_destroy(dialog);
  dt_gui_refocus_parent(dialog_parent);
  dt_free(tagname);
}
 
static void _pop_menu_dictionary_goto_tag_collection(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GtkTreeIter iter;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->dictionary_view));
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(d->dictionary_view));
  if(_selection_get_first(selection, &model, &iter))
  {
    char *path;
    guint count;
    gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_PATH, &path, DT_LIB_TAGGING_COL_COUNT, &count, -1);
    if(count)
    {
      if(!d->collection[0]) dt_collection_serialize(d->collection, 4096);
      gchar *tag_collection = g_strdup_printf("1:0:%d:%s$", DT_COLLECTION_PROP_TAG, path);
      dt_control_signal_block_by_func(dt_control_signal_get_global(), G_CALLBACK(_collection_updated_callback), self);
      dt_collection_deserialize(tag_collection);
      dt_control_signal_unblock_by_func(dt_control_signal_get_global(), G_CALLBACK(_collection_updated_callback), self);
      dt_free(tag_collection);
    }
    dt_free(path);
  }
}
 
static void _pop_menu_dictionary_goto_collection_back(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  if(d->collection[0])
  {
    dt_control_signal_block_by_func(dt_control_signal_get_global(), G_CALLBACK(_collection_updated_callback), self);
    dt_collection_deserialize(d->collection);
    dt_control_signal_unblock_by_func(dt_control_signal_get_global(), G_CALLBACK(_collection_updated_callback), self);
    d->collection[0] = '\0';
  }
}
 
static void _pop_menu_dictionary_copy_tag(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GtkTreeIter iter;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->dictionary_view));
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(d->dictionary_view));
  if(_selection_get_first(selection, &model, &iter))
  {
    char *tag;
    gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_PATH, &tag, -1);
    gtk_entry_set_text(d->dict_entry, tag);
    dt_free(tag);
    gtk_entry_grab_focus_without_selecting(d->dict_entry);
  }
}
 
// delete the given tag ids from the database (after a single confirmation), then refresh
static void _delete_tagids(GList *tagids, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  if(IS_NULL_PTR(tagids)) return;
  const guint nb = g_list_length(tagids);
 
  // dry-run removal (FALSE) to count how many images would lose a tag
  guint img_count = 0;
  for(GList *t = tagids; t; t = g_list_next(t))
    img_count += dt_tag_remove(GPOINTER_TO_UINT(t->data), FALSE);
 
  if(img_count > 0 || dt_conf_get_bool("plugins/lighttable/tagging/ask_before_delete_tag"))
  {
    GtkWidget *win = dt_gui_main_window();
    GtkWidget *dialog = gtk_dialog_new_with_buttons(_("delete tag?"), GTK_WINDOW(win), GTK_DIALOG_DESTROY_WITH_PARENT,
                                  _("cancel"), GTK_RESPONSE_NONE, _("delete"), GTK_RESPONSE_YES, NULL);
    gtk_window_set_default_size(GTK_WINDOW(dialog), 300, -1);
    GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
    gchar *text = g_strdup_printf(ngettext("do you really want to delete %d tag?\n%d image is assigned these tags!",
                                           "do you really want to delete %d tags?\n%d images are assigned these tags!",
                                           img_count), nb, img_count);
    GtkWidget *label = gtk_label_new(text);
    gtk_container_set_border_width(GTK_CONTAINER(area), 8);
    gtk_container_add(GTK_CONTAINER(area), label);
    dt_free(text);
#ifdef GDK_WINDOWING_QUARTZ
    dt_osx_disallow_fullscreen(dialog);
#endif
    gtk_widget_show_all(dialog);
    const int res = gtk_dialog_run(GTK_DIALOG(dialog));
    GtkWindow *dialog_parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
    gtk_widget_destroy(dialog);
    dt_gui_refocus_parent(dialog_parent);
    if(res != GTK_RESPONSE_YES) return;
  }
 
  GList *affected = NULL;
  for(GList *t = tagids; t; t = g_list_next(t))
  {
    const guint tagid = GPOINTER_TO_UINT(t->data);
    affected = g_list_concat(affected, dt_tag_get_images(tagid));
    gchar *name = dt_tag_get_name(tagid);
    dt_tag_remove(tagid, TRUE);
    if(name)
    {
      dt_control_log(_("tag %s removed"), name);
      dt_free(name);
    }
  }
 
  _init_treeview(self, 0);
  _init_treeview(self, 1);
  dt_tagging_completion_refresh(d->completion_store);
  _refresh_collection_tags(self);
  dt_image_synch_xmps(affected);
  g_list_free(affected);
  _raise_signal_tag_changed(self);
}
 
static void _pop_menu_dictionary_delete_selected(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GList *tagids = _selected_tagids(d->dictionary_view);
  _delete_tagids(tagids, self);
  g_list_free(tagids);
}
 
static void _pop_menu_dictionary_set_as_tag(GtkWidget *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  char *tagname;
  guint new_tagid;
 
  GtkTreeIter iter;
  GtkTreeModel *model = NULL;
  GtkTreeView *view = d->dictionary_view;
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  if(!_selection_get_first(selection, &model, &iter)) return;
 
  gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_PATH, &tagname, -1);
 
  dt_tag_new(tagname, &new_tagid);
  dt_control_log(_("tag %s created"), tagname);
 
  _init_treeview(self, 1);
  dt_tagging_completion_refresh(d->completion_store);
  _raise_signal_tag_changed(self);
  _show_tag_on_view(d->dictionary_view, tagname, FALSE, TRUE);
  dt_free(tagname);
 
}
 
static void _pop_menu_dictionary(GtkWidget *treeview, GdkEventButton *event, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GtkTreeIter iter, child;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->dictionary_view));
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(d->dictionary_view));
  const gint sel_cnt = gtk_tree_selection_count_selected_rows(selection);
  if(sel_cnt == 0) return;
 
  GtkWidget *menu = gtk_menu_new();
  GtkWidget *menuitem;
 
  // with several tags selected, only bulk CRUD makes sense
  if(sel_cnt > 1)
  {
    menuitem = gtk_menu_item_new_with_label(_("delete tags"));
    g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_dictionary_delete_selected, self);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    gtk_widget_show_all(GTK_WIDGET(menu));
    gtk_menu_popup_at_pointer(GTK_MENU(menu), (GdkEvent *)event);
    return;
  }
 
  if(_selection_get_first(selection, &model, &iter))
  {
    guint tagid, count;
    gtk_tree_model_get(model, &iter,
                       DT_LIB_TAGGING_COL_ID, &tagid,
                       DT_LIB_TAGGING_COL_COUNT, &count, -1);
 
    if(d->tree_flag || !d->suggestion_flag)
    {
      menuitem = gtk_menu_item_new_with_label(_("create tag..."));
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
      g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_dictionary_create_tag, self);
 
      if(tagid)
      {
        menuitem = gtk_menu_item_new_with_label(_("delete tag"));
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
        g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_dictionary_delete_selected, self);
      }
 
      if(gtk_tree_model_iter_children(model, &child, &iter))
      {
        menuitem = gtk_menu_item_new_with_label(_("delete node"));
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
        g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_dictionary_delete_node, self);
      }
 
      menuitem = gtk_menu_item_new_with_label(_("edit..."));
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
      g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_dictionary_edit_tag, self);
 
    }
 
    if(d->tree_flag)
    {
      menuitem = gtk_menu_item_new_with_label(_("change path..."));
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
      g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_dictionary_change_path, self);
    }
 
    if(d->tree_flag && !tagid)
    {
      menuitem = gtk_separator_menu_item_new();
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 
      menuitem = gtk_menu_item_new_with_label(_("set as a tag"));
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
      g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_dictionary_set_as_tag, self);
    }
 
    if(!d->suggestion_flag)
    {
      menuitem = gtk_separator_menu_item_new();
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
    }
 
    menuitem = gtk_menu_item_new_with_label(_("copy to entry"));
    g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_dictionary_copy_tag, self);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
 
    if(d->collection[0])
    {
      char *collection = g_malloc(4096);
      dt_collection_serialize(collection, 4096);
      if(g_strcmp0(d->collection, collection) == 0) d->collection[0] = '\0';
      dt_free(collection);
    }
    if(count || d->collection[0])
    {
      menuitem = gtk_separator_menu_item_new();
      gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
      if(count)
      {
        menuitem = gtk_menu_item_new_with_label(_("go to tag collection"));
        g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_dictionary_goto_tag_collection, self);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
      }
      if(d->collection[0])
      {
        menuitem = gtk_menu_item_new_with_label(_("go back to work"));
        g_signal_connect(menuitem, "activate", (GCallback)_pop_menu_dictionary_goto_collection_back, self);
        gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
      }
    }
    gtk_widget_show_all(GTK_WIDGET(menu));
 
    gtk_menu_popup_at_pointer(GTK_MENU(menu), (GdkEvent *)event);
  }
}
 
static gboolean _click_on_view_dictionary(GtkWidget *view, GdkEventButton *event, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  _unselect_all_in_view(d->attached_view);
 
  const int button_pressed = (event->type == GDK_BUTTON_PRESS) ? event->button : 0;
  const gboolean shift_pressed = dt_modifier_is(event->state, GDK_SHIFT_MASK);
  if((button_pressed == 3)                       // contextual menu
     || (d->tree_flag && button_pressed == 1))   // expand & drag
  {
    GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
    GtkTreePath *path = NULL;
    // Get tree path for row that was clicked
    if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(view), (gint)event->x, (gint)event->y, &path, NULL, NULL, NULL))
    {
      if(d->tree_flag && button_pressed == 1 && !shift_pressed)
      {
        GtkTreeModel *model = gtk_tree_view_get_model(d->dictionary_view);
        GtkTreeIter iter;
        gtk_tree_model_get_iter(model, &iter, path);
        char *tagname;
        gtk_tree_model_get(model, &iter,
                           DT_LIB_TAGGING_COL_PATH, &tagname, -1);
        if(d->drag.tagname)
        {
          dt_free(d->drag.tagname);
        }
        d->drag.tagname = tagname;
        if(d->drag.path) gtk_tree_path_free(d->drag.path);
        d->drag.path = path;
        if(d->drag.lastpath) gtk_tree_path_free(d->drag.lastpath);
        d->drag.lastpath = NULL;
        return FALSE;
      }
      else if(button_pressed == 3)
      {
        // keep an existing multi-selection so the menu can act on it in bulk
        if(!gtk_tree_selection_path_is_selected(selection, path))
        {
          gtk_tree_selection_unselect_all(selection);
          gtk_tree_selection_select_path(selection, path);
        }
        _pop_menu_dictionary(view, event, self);
        gtk_tree_path_free(path);
        return TRUE;
      }
      else if(d->tree_flag && button_pressed == 1 && shift_pressed)
      {
        gtk_tree_selection_select_path(selection, path);
        gtk_tree_view_expand_row(GTK_TREE_VIEW(view), path, TRUE);
        gtk_tree_path_free(path);
        return TRUE;
      }
    }
    gtk_tree_path_free(path);
  }
  return FALSE;
}
 
static gboolean _dictionary_key_pressed(GtkWidget *view, GdkEventKey *event, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  _unselect_all_in_view(d->attached_view);
  GtkTreeIter iter;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->dictionary_view));
  GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  gboolean res = FALSE;
  guint key = dt_keys_mainpad_alternatives(event->keyval);
 
  if(_selection_get_first(selection, &model, &iter))
  {
    GtkTreePath *path = gtk_tree_model_get_path(model, &iter);
    switch(key)
    {
      case GDK_KEY_Left:
        if(path)
        {
          if(dt_modifier_is(event->state, GDK_SHIFT_MASK))
            gtk_tree_view_collapse_all(GTK_TREE_VIEW(view));
          else
            gtk_tree_view_collapse_row(GTK_TREE_VIEW(view), path);
          res = TRUE;
        }
        break;
      case GDK_KEY_Right:
        if(path)
        {
          gtk_tree_view_expand_row(GTK_TREE_VIEW(view), path,
                                   dt_modifier_is(event->state, GDK_SHIFT_MASK));
          res = TRUE;
        }
        break;
      default:
        break;
    }
    gtk_tree_path_free(path);
  }
  if(event->keyval == GDK_KEY_Tab)
  {
    gtk_tree_selection_unselect_all(selection);
    res = TRUE;
  }
  else if(event->keyval == GDK_KEY_ISO_Left_Tab)
  {
    gtk_tree_selection_unselect_all(selection);
    gtk_widget_grab_focus(GTK_WIDGET(d->dict_entry));
    res = TRUE;
  }
  return res;
}
 
static gboolean _row_tooltip_setup(GtkWidget *treeview, gint x, gint y, gboolean kb_mode,
      GtkTooltip* tooltip, dt_lib_module_t *self)
{
  gboolean res = FALSE;
  GtkTreePath *path = NULL;
  // Get tree path mouse position
  if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), x, y, &path, NULL, NULL, NULL))
  {
    GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
    GtkTreeIter iter;
    if(gtk_tree_model_get_iter(model, &iter, path))
    {
      char *tagname;
      guint tagid;
      guint flags;
      char *synonyms = NULL;
      gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_ID, &tagid, DT_LIB_TAGGING_COL_TAG, &tagname,
              DT_LIB_TAGGING_COL_FLAGS, &flags, DT_LIB_TAGGING_COL_SYNONYM, &synonyms, -1);
      if(tagid)
      {
        if((flags & DT_TF_PRIVATE) || (synonyms && synonyms[0]))
        {
          gchar *text = g_strdup_printf(_("%s"), tagname);
          text = dt_util_dstrcat(text, " %s\n", (flags & DT_TF_PRIVATE) ? _("(private)") : "");
          text = dt_util_dstrcat(text, "synonyms: %s", (synonyms && synonyms[0]) ? synonyms : " - ");
          gtk_tooltip_set_text(tooltip, text);
          dt_free(text);
          res = TRUE;
        }
      }
      dt_free(synonyms);
      dt_free(tagname);
    }
  }
  gtk_tree_path_free(path);
 
  return res;
}
 
static void _import_button_clicked(GtkButton *button, dt_lib_module_t *self)
{
  const char *last_dirname = dt_conf_get_string_const("plugins/lighttable/tagging/last_import_export_location");
  if(IS_NULL_PTR(last_dirname) || !*last_dirname)
  {
    last_dirname = g_get_home_dir();
  }
 
  GtkWidget *win = dt_gui_main_window();
  GtkFileChooserNative *filechooser = gtk_file_chooser_native_new(
        _("select a keyword file"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_OPEN,
        _("_import"), _("_cancel"));
 
  gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_dirname);
  gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), FALSE);
 
  if(gtk_native_dialog_run(GTK_NATIVE_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
  {
    char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
    char *dirname = g_path_get_dirname(filename);
    dt_conf_set_string("plugins/lighttable/tagging/last_import_export_location", dirname);
    uint32_t count = dt_tag_import(filename);
    dt_control_log(_("%u tags imported"), count);
    dt_free(filename);
    dt_free(dirname);
  }
 
  g_object_unref(filechooser);
  _init_treeview(self, 1);
}
 
static void _export_button_clicked(GtkButton *button, dt_lib_module_t *self)
{
  GDateTime *now = g_date_time_new_now_local();
  char *export_filename = g_date_time_format(now, "darktable_tags_%F_%H-%M.txt");
  const char *last_dirname = dt_conf_get_string_const("plugins/lighttable/tagging/last_import_export_location");
  if(IS_NULL_PTR(last_dirname) || !*last_dirname)
  {
    last_dirname = g_get_home_dir();
  }
 
  GtkWidget *win = dt_gui_main_window();
  GtkFileChooserNative *filechooser = gtk_file_chooser_native_new(
        _("select file to export to"), GTK_WINDOW(win), GTK_FILE_CHOOSER_ACTION_SAVE,
        _("_export"), _("_cancel"));
 
  gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(filechooser), TRUE);
  gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(filechooser), last_dirname);
  gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(filechooser), export_filename);
 
  if(gtk_native_dialog_run(GTK_NATIVE_DIALOG(filechooser)) == GTK_RESPONSE_ACCEPT)
  {
    char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(filechooser));
    char *dirname = g_path_get_dirname(filename);
    dt_conf_set_string("plugins/lighttable/tagging/last_import_export_location", dirname);
    const uint32_t count = dt_tag_export(filename);
    dt_control_log(_("%u tags exported"), count);
    dt_free(filename);
    dt_free(dirname);
  }
 
  g_date_time_unref(now);
  dt_free(export_filename);
  g_object_unref(filechooser);
}
 
static void _update_layout(dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(d->dictionary_view));
 
  dt_gui_freeze_begin();
 
  d->suggestion_flag = dt_conf_get_bool("plugins/lighttable/tagging/nosuggestion");
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->toggle_suggestion_button), d->suggestion_flag);
  d->tree_flag = dt_conf_get_bool("plugins/lighttable/tagging/treeview");
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->toggle_tree_button), d->tree_flag);
 
  if(d->tree_flag)
  {
    if(model == GTK_TREE_MODEL(d->dictionary_listfilter))
    {
      g_object_ref(model);
      gtk_tree_view_set_model(GTK_TREE_VIEW(d->dictionary_view), NULL);
      GtkTreeModel *store = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
      gtk_list_store_clear(GTK_LIST_STORE(store));
      gtk_tree_view_set_model(GTK_TREE_VIEW(d->dictionary_view), GTK_TREE_MODEL(d->dictionary_treefilter));
      g_object_unref(d->dictionary_treefilter);
    }
    gtk_widget_set_sensitive(GTK_WIDGET(d->toggle_suggestion_button), FALSE);
  }
  else
  {
    if(model == GTK_TREE_MODEL(d->dictionary_treefilter))
    {
      g_object_ref(model);
      gtk_tree_view_set_model(GTK_TREE_VIEW(d->dictionary_view), NULL);
      GtkTreeModel *store = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
      gtk_tree_store_clear(GTK_TREE_STORE(store));
      gtk_tree_view_set_model(GTK_TREE_VIEW(d->dictionary_view), GTK_TREE_MODEL(d->dictionary_listfilter));
      g_object_unref(d->dictionary_listfilter);
    }
    gtk_widget_set_sensitive(GTK_WIDGET(d->toggle_suggestion_button), TRUE);
  }
 
  // drag & drop
  if(d->tree_flag)
    gtk_drag_source_set(GTK_WIDGET(d->dictionary_view), GDK_BUTTON1_MASK,
                        target_list_tags, n_targets_tags, GDK_ACTION_MOVE);
  else
    gtk_drag_source_unset(GTK_WIDGET(d->dictionary_view));
 
  d->sort_count_flag = dt_conf_get_bool("plugins/lighttable/tagging/listsortedbycount");
  dt_bauhaus_combobox_set(d->sort_combo, d->sort_count_flag ? 1 : 0);
 
  // controls the dictionary list rendering (leaf vs full path); the sidebar attached
  // view has its own tree/list "view" combobox below
  d->hide_path_flag = dt_conf_get_bool("plugins/lighttable/tagging/hidehierarchy");
 
  d->attached_tree_flag = dt_conf_get_bool("plugins/lighttable/tagging/attached_treeview");
  dt_bauhaus_combobox_set(d->attached_view_combo, d->attached_tree_flag ? 1 : 0);
 
  d->dttags_flag = dt_conf_get_bool("plugins/lighttable/tagging/dttags");
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->dttags_check), d->dttags_flag);
 
  dt_gui_freeze_end();
}
 
static void _toggle_suggestion_button_callback(GtkToggleButton *source, dt_lib_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
  const gboolean new_state = !dt_conf_get_bool("plugins/lighttable/tagging/nosuggestion");
  dt_conf_set_bool("plugins/lighttable/tagging/nosuggestion", new_state);
  _update_layout(self);
  _init_treeview(self, 1);
}
 
static void _toggle_tree_button_callback(GtkToggleButton *source, dt_lib_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
  const gboolean new_state = !dt_conf_get_bool("plugins/lighttable/tagging/treeview");
  dt_conf_set_bool("plugins/lighttable/tagging/treeview", new_state);
  _update_layout(self);
  _init_treeview(self, 1);
}
 
static gint _sort_tree_count_func(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, dt_lib_module_t *self)
{
  guint count_a = 0;
  guint count_b = 0;
  gtk_tree_model_get(model, a, DT_LIB_TAGGING_COL_COUNT, &count_a, -1);
  gtk_tree_model_get(model, b, DT_LIB_TAGGING_COL_COUNT, &count_b, -1);
  return (count_b - count_a);
}
 
static gint _sort_tree_tag_func(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, dt_lib_module_t *self)
{
  char *tag_a = NULL;
  char *tag_b = NULL;
  gtk_tree_model_get(model, a, DT_LIB_TAGGING_COL_TAG, &tag_a, -1);
  gtk_tree_model_get(model, b, DT_LIB_TAGGING_COL_TAG, &tag_b, -1);
  if(IS_NULL_PTR(tag_a)) tag_a = g_strdup("");
  if(IS_NULL_PTR(tag_b)) tag_b = g_strdup("");
  const gboolean sort = g_strcmp0(tag_a, tag_b);
  dt_free(tag_a);
  dt_free(tag_b);
  return sort;
}
 
static gint _sort_tree_path_func(GtkTreeModel *model, GtkTreeIter *a, GtkTreeIter *b, dt_lib_module_t *self)
{
  char *tag_a = NULL;
  char *tag_b = NULL;
  gtk_tree_model_get(model, a, DT_LIB_TAGGING_COL_PATH, &tag_a, -1);
  gtk_tree_model_get(model, b, DT_LIB_TAGGING_COL_PATH, &tag_b, -1);
  if(tag_a)
  {
    for(char *letter = tag_a; *letter; letter++)
      if(*letter == '|') *letter = '\1';
  }
  else
    tag_a = g_strdup("");
 
  if(tag_b)
  {
    for(char *letter = tag_b; *letter; letter++)
      if(*letter == '|') *letter = '\1';
  }
  else
    tag_b = g_strdup("");
 
  const gboolean sort = g_strcmp0(tag_a, tag_b);
  dt_free(tag_a);
  dt_free(tag_b);
  return sort;
}
 
// "sort" combobox in the sidebar: by name (0) or by count (1)
static void _sort_combo_changed(GtkWidget *combo, dt_lib_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
  dt_conf_set_bool("plugins/lighttable/tagging/listsortedbycount", dt_bauhaus_combobox_get(combo) == 1);
  _update_layout(self);
  _sort_attached_list(self, FALSE);
  _sort_dictionary_list(self, FALSE);
}
 
// "view" combobox in the sidebar: attached list (0) or attached tree (1)
static void _attached_view_combo_changed(GtkWidget *combo, dt_lib_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
  dt_conf_set_bool("plugins/lighttable/tagging/attached_treeview", dt_bauhaus_combobox_get(combo) == 1);
  _update_layout(self);
  _init_treeview(self, 0);
}
 
// "show system tags" checkbox in the sidebar
static void _dttags_check_toggled(GtkToggleButton *source, dt_lib_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  d->dttags_flag = gtk_toggle_button_get_active(source);
  dt_conf_set_bool("plugins/lighttable/tagging/dttags", d->dttags_flag);
  _init_treeview(self, 0);
}
 
void gui_reset(dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  // clear entry boxes and query
  _entry_clear_suppressed(d->entry);
  _entry_clear_suppressed(d->dict_entry);
  _set_keyword(self);
  _init_treeview(self, 1);
  _update_atdetach_buttons(self);
}
 
int position()
{
  return 3;
}
 
// Single-column model feeding the tag entry autocompletion (full tag path).
enum { DT_COMPL_COL_PATH = 0, DT_COMPL_NUM_COLS };
 
// (Re)build the set of tags used by the current collection. Used to seed the
// entry autocompletion when nothing has been typed yet.
static void _refresh_collection_tags(dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  if(!d->collection_tags) return;
  g_hash_table_remove_all(d->collection_tags);
  GList *tags = NULL;
  dt_tag_get_collection_tags(&tags);
  for(GList *t = tags; t; t = g_list_next(t))
  {
    const dt_tag_t *tag = (const dt_tag_t *)t->data;
    if(IS_NULL_PTR(tag->tag)) continue;
    g_hash_table_add(d->collection_tags, g_strdup(tag->tag));
  }
  dt_tag_free_result(&tags);
}
 
static gboolean _completion_match_func(GtkEntryCompletion *completion, const gchar *key, GtkTreeIter *iter,
                                       gpointer user_data)
{
  gboolean res = FALSE;
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  dt_lib_tagging_t *d = self ? (dt_lib_tagging_t *)self->data : NULL;
 
  GtkEditable *e = (GtkEditable *)gtk_entry_completion_get_entry(completion);
 
  if(!GTK_IS_EDITABLE(e))
  {
    return FALSE;
  }
 
  const gint cur_pos = gtk_editable_get_position(e);
  const gboolean onLastTag = (g_strstr_len(&key[cur_pos], -1, ",") == NULL);
  if(!onLastTag)
  {
    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;
  }
 
  const gchar *lastTag = g_strrstr(key, ",");
  if(!IS_NULL_PTR(lastTag))
  {
    lastTag++;
  }
  else
  {
    lastTag = key;
  }
 
  char *tag = NULL;
  gtk_tree_model_get(model, iter, column, &tag, -1);
 
  // nothing typed yet on the active tag token: default the suggestions to the
  // tags used by the current collection opened in lighttable
  if(lastTag[0] == '\0')
  {
    res = (d && d->collection_tags && tag) ? g_hash_table_contains(d->collection_tags, tag) : FALSE;
    dt_free(tag);
    return res;
  }
 
  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, lastTag) != NULL;
      }
      dt_free(casefold);
    }
    dt_free(normalized);
    dt_free(tag);
  }
 
  return res;
}
 
static void _tree_selection_changed(GtkTreeSelection *treeselection, gpointer data)
{
  _update_atdetach_buttons((dt_lib_module_t *)data);
}
 
static void _dnd_clear_root(dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  if(!d->drag.root) return;
  GtkTreeModel *model = GTK_TREE_MODEL(d->dictionary_treestore);
  GtkTreeIter iter;
  gtk_tree_model_get_iter_first(model, &iter);
  char *name;
  gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_PATH, &name, -1);
  if(name && name[0] == '\0')
    gtk_tree_store_remove(d->dictionary_treestore, &iter);
  dt_free(name);
  d->drag.root = FALSE;
}
 
static void _event_dnd_begin(GtkWidget *widget, GdkDragContext *context, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GtkTreeView *tree = GTK_TREE_VIEW(widget);
 
  if(d->drag.path)
  {
    cairo_surface_t *row_pix = gtk_tree_view_create_row_drag_icon(tree, d->drag.path);
    // FIXME: try to put the anchor point on left bottom corner as for images
//    cairo_surface_set_device_offset(row_pix,
//                                    // the + 1 is for the black border in the icon
//                                     - (double)(cairo_image_surface_get_width(row_pix) + 1),
//                                     - (double)(cairo_image_surface_get_height(row_pix)+ 1));
    gtk_drag_set_icon_surface(context, row_pix);
    cairo_surface_destroy(row_pix);
    gtk_tree_path_free(d->drag.path);
    d->drag.path = NULL;
    d->drag.tag_source = TRUE;
  }
}
 
static void _event_dnd_get(GtkWidget *widget, GdkDragContext *context, GtkSelectionData *selection_data,
                           const guint target_type, const guint time, dt_lib_module_t *self)
{
  if(target_type == DND_TARGET_TAG)
    gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
                           _DWORD, NULL, 0);
}
 
static void _event_dnd_received(GtkWidget *widget, GdkDragContext *context, gint x, gint y,
                                GtkSelectionData *selection_data, guint target_type, guint time,
                                dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GtkTreeView *tree = GTK_TREE_VIEW(widget);
  // disable the default handler
  g_signal_stop_emission_by_name(tree, "drag-data-received");
  gboolean success = FALSE;
 
  if(target_type == DND_TARGET_TAG)
  {
    GtkTreePath *path = NULL;
    if(gtk_tree_view_get_path_at_pos(tree, x, y, &path, NULL, NULL, NULL))
    {
      char *name;
      GtkTreeModel *model = gtk_tree_view_get_model(tree);
      GtkTreeIter iter;
 
      gtk_tree_model_get_iter(model, &iter, path);
      gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_PATH, &name, -1);
      _dnd_clear_root(self);
      const gboolean root = (name && name[0] == '\0');
      char *leave = g_strrstr(d->drag.tagname, "|");
      if(leave) leave++;
      name = dt_util_dstrcat(name, "%s%s", root ? "" : "|", leave ? leave : d->drag.tagname);
      _apply_rename_path(NULL, d->drag.tagname, name, self);
 
      dt_free(name);
      dt_free(d->drag.tagname);
      gtk_tree_path_free(path); // release result of gtk_tree_view_get_path_at_pos above
      success = TRUE;
    }
  }
  else if((target_type == DND_TARGET_IMGID) && (!IS_NULL_PTR(selection_data)))
  {
    GtkTreePath *path = NULL;
    const int imgs_nb = gtk_selection_data_get_length(selection_data) / sizeof(uint32_t);
    if(imgs_nb && gtk_tree_view_get_path_at_pos(tree, x, y, &path, NULL, NULL, NULL))
    {
      const uint32_t *imgt = (uint32_t *)gtk_selection_data_get_data(selection_data);
      GList *imgs = NULL;
      for(int i = 0; i < imgs_nb; i++)
      {
        imgs = g_list_prepend(imgs, GINT_TO_POINTER(imgt[i]));
      }
      GtkTreeModel *model = gtk_tree_view_get_model(tree);
      GtkTreeIter iter;
      gtk_tree_model_get_iter(model, &iter, path);
      gint tagid;
      gtk_tree_model_get(model, &iter, DT_LIB_TAGGING_COL_ID, &tagid, -1);
      if(tagid)
        dt_tag_attach_images(tagid, imgs, TRUE);
      g_list_free(imgs);
      imgs = NULL;
      _update_attached_count(tagid, d->dictionary_view, d->tree_flag);
      _init_treeview(self, 0);
      _raise_signal_tag_changed(self);
      dt_image_synch_xmp(-1);
      gtk_tree_path_free(path); // release result of gtk_tree_view_get_path_at_pos above
      success = TRUE;
    }
  }
  gtk_drag_finish(context, success, FALSE, time);
}
 
static gboolean _dnd_expand_timeout(dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  if(d->drag.lastpath)
  {
    gtk_tree_view_expand_row(d->dictionary_view, d->drag.lastpath, FALSE);
  }
  return FALSE;
}
 
static gboolean _dnd_scroll_timeout(dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  if(d->drag.scroll_timeout)
  {
    GdkRectangle visible;
    gtk_tree_view_get_visible_rect(d->dictionary_view, &visible);
    gint top_ty;
    gtk_tree_view_convert_bin_window_to_tree_coords(d->dictionary_view,
                                                    0, 0, NULL, &top_ty);
 
    // temporary drop root
    if(d->drag.tag_source && !d->drag.root && d->drag.last_y < 5 && top_ty < 1)
    {
      GtkTreeIter iter;
      gtk_tree_store_prepend(d->dictionary_treestore, &iter, NULL);
      gtk_tree_store_set(d->dictionary_treestore, &iter,
                        DT_LIB_TAGGING_COL_TAG, _("drop to root"),
                        DT_LIB_TAGGING_COL_ID, 0,
                        DT_LIB_TAGGING_COL_PATH, "",
                        DT_LIB_TAGGING_COL_COUNT, 0,
                        DT_LIB_TAGGING_COL_SEL, 0,
                        DT_LIB_TAGGING_COL_FLAGS, 0,
                        DT_LIB_TAGGING_COL_VISIBLE, TRUE,
                        -1);
      d->drag.root = TRUE;
    }
    else if(d->drag.root && d->drag.last_y >= 20)
      _dnd_clear_root(self);
 
    if(d->drag.last_y < 5)
    {
      // scroll up
      gtk_tree_view_scroll_to_point(d->dictionary_view, 0, top_ty - 25 < 0 ? 0 : top_ty - 25);
    }
    else if(d->drag.last_y > visible.height - 5)
      // scroll down
      gtk_tree_view_scroll_to_point(d->dictionary_view, 0, top_ty + 25);
    return TRUE;
  }
  return FALSE;
}
 
static gboolean _event_dnd_motion(GtkWidget *widget, GdkDragContext *context,
                                  gint x, gint y, guint time, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  GtkTreeView *tree = GTK_TREE_VIEW(widget);
  GtkTreePath *path = NULL;
 
  if(gtk_tree_view_get_path_at_pos(tree, x, y, &path, NULL, NULL, NULL))
  {
    if(IS_NULL_PTR(d->drag.lastpath) || ((d->drag.lastpath) && gtk_tree_path_compare(d->drag.lastpath, path) != 0))
    {
      GtkTreeViewColumn *col = gtk_tree_view_get_column(d->dictionary_view, 0);
      const int sel_width = gtk_tree_view_column_get_width(col);
      if(x >= sel_width)
      {
        if(!gtk_tree_view_row_expanded(tree, path))
          d->drag.expand_timeout = g_timeout_add(200, (GSourceFunc)_dnd_expand_timeout, self);
      }
    }
 
    GtkTreeSelection *selection = gtk_tree_view_get_selection(d->dictionary_view);
    gtk_tree_selection_select_path(selection, path);
    d->drag.last_y = y;
    if(d->drag.scroll_timeout == 0)
    {
      d->drag.scroll_timeout = g_timeout_add(100, (GSourceFunc)_dnd_scroll_timeout, self);
    }
  }
 
  // FIXME - no row highlihted... workartound with selection above
//  gtk_tree_view_set_drag_dest_row(tree, path, GTK_TREE_VIEW_DROP_INTO_OR_BEFORE);
 
  if(d->drag.lastpath)
    gtk_tree_path_free(d->drag.lastpath);
  d->drag.lastpath = path;
 
  return TRUE;
}
 
static void _event_dnd_end(GtkWidget *widget, GdkDragContext *context, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  // FIXME (see gtk_tree_view_set_drag_dest_row above)
//  gtk_tree_view_set_drag_dest_row(d->dictionary_view, NULL, GTK_TREE_VIEW_DROP_BEFORE);
  GtkTreeSelection *selection = gtk_tree_view_get_selection(d->dictionary_view);
  gtk_tree_selection_unselect_all(selection);
  if(d->drag.scroll_timeout)
    g_source_remove(d->drag.scroll_timeout);
  d->drag.scroll_timeout = 0;
  d->drag.tag_source = FALSE;
  _dnd_clear_root(self);
}
 
// open the tag management window (from the module's gear menu)
static void _show_manage_window(GtkMenuItem *menuitem, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  gtk_widget_show_all(d->manage_window);
  gtk_window_present(GTK_WINDOW(d->manage_window));
}
 
// after a suggestion setting changed, rebuild the dictionary if it shows suggestions
static void _refresh_suggestions(dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  if(!d->tree_flag && d->suggestion_flag)
    _init_treeview(self, 1);
}
 
static void _confidence_changed(GtkSpinButton *spin, dt_lib_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
  dt_conf_set_int("plugins/lighttable/tagging/confidence", gtk_spin_button_get_value_as_int(spin));
  _refresh_suggestions(self);
}
 
static void _recent_tags_changed(GtkSpinButton *spin, dt_lib_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
  dt_conf_set_int("plugins/lighttable/tagging/nb_recent_tags", gtk_spin_button_get_value_as_int(spin));
  _size_recent_tags_list();
  _refresh_suggestions(self);
}
 
// validate button next to the entry: attach the typed/picked tag (same as pressing Enter)
static void _validate_button_clicked(GtkButton *button, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  _create_tag_from_entry(self, d->entry);
}
 
void gui_init(dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)calloc(sizeof(dt_lib_tagging_t),1);
  self->data = (void *)d;
  d->last_tag = NULL;
  self->timeout_handle = 0;
 
  self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
 
  GtkBox *box, *hbox;
  GtkWidget *button;
  GtkWidget *w;
  GtkTreeView *view;
  GtkTreeModel *model;
  GtkListStore *liststore;
  GtkTreeStore *treestore;
  GtkTreeViewColumn *col;
  GtkCellRenderer *renderer;
 
  // ── line 1: "view" (list/tree) and "sort" (name/count) comboboxes ──
  hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING));
 
  // "view" combobox: render the attached list above as a flat list, or as a hierarchical tree
  d->attached_view_combo = dt_bauhaus_combobox_new(dt_bauhaus_get_global(), DT_GUI_MODULE(NULL));
  dt_bauhaus_widget_set_label(d->attached_view_combo, _("view"));
  dt_bauhaus_combobox_add(d->attached_view_combo, _("list"));
  dt_bauhaus_combobox_add(d->attached_view_combo, _("tree"));
  dt_bauhaus_combobox_set_selected_text_align(d->attached_view_combo, DT_BAUHAUS_COMBOBOX_ALIGN_RIGHT);
  gtk_widget_set_valign(d->attached_view_combo, GTK_ALIGN_CENTER);
  gtk_widget_set_tooltip_text(d->attached_view_combo,
                              _("show the attached tags as a flat list or as a hierarchical tree"));
  g_signal_connect(G_OBJECT(d->attached_view_combo), "value-changed", G_CALLBACK(_attached_view_combo_changed), self);
  gtk_box_pack_start(hbox, d->attached_view_combo, TRUE, TRUE, 0);
 
  // "sort" combobox: by name or by image count
  d->sort_combo = dt_bauhaus_combobox_new(dt_bauhaus_get_global(), DT_GUI_MODULE(NULL));
  dt_bauhaus_widget_set_label(d->sort_combo, _("Sort by"));
  dt_bauhaus_combobox_add(d->sort_combo, _("name"));
  dt_bauhaus_combobox_add(d->sort_combo, _("count"));
  dt_bauhaus_combobox_set_selected_text_align(d->sort_combo, DT_BAUHAUS_COMBOBOX_ALIGN_RIGHT);
  gtk_widget_set_valign(d->sort_combo, GTK_ALIGN_CENTER);
  gtk_widget_set_tooltip_text(d->sort_combo, _("sort the tags by name or by image count"));
  g_signal_connect(G_OBJECT(d->sort_combo), "value-changed", G_CALLBACK(_sort_combo_changed), self);
  gtk_box_pack_start(hbox, d->sort_combo, TRUE, TRUE, 0);
 
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), FALSE, TRUE, 0);
 
  // ── line 3: scrolled list / tree of attached tags ──
  // (packed here in code, but reordered below to sit under the entry — see the reorder call)
  box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING));
 
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0);
  view = GTK_TREE_VIEW(gtk_tree_view_new());
  // Static: the attached-tags list tracks the hovered/selected images, so keep a fixed height.
  w = dt_ui_scroll_wrap(GTK_WIDGET(view), 200, "plugins/lighttable/tagging/heightattachedwindow",
                        DT_UI_RESIZE_STATIC);
  gtk_box_pack_start(box, w, TRUE, TRUE, 0);
  d->attached_view = view;
  gtk_tree_view_set_enable_search(view, FALSE);
  gtk_tree_view_set_headers_visible(view, FALSE);
  liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING,
                                G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN);
  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(liststore), DT_TAG_SORT_PATH_ID,
                  (GtkTreeIterCompareFunc)_sort_tree_path_func, self, NULL);
  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(liststore), DT_TAG_SORT_NAME_ID,
                  (GtkTreeIterCompareFunc)_sort_tree_tag_func, self, NULL);
  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(liststore), DT_TAG_SORT_COUNT_ID,
                  (GtkTreeIterCompareFunc)_sort_tree_count_func, self, NULL);
  d->attached_liststore = liststore;  // kept alive by d's ref (the view alternates between the two stores)
  // tree variant of the attached view, used when the "view" combobox is set to "tree"
  treestore = gtk_tree_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING,
                                G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN);
  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(treestore), DT_TAG_SORT_PATH_ID,
                  (GtkTreeIterCompareFunc)_sort_tree_path_func, self, NULL);
  d->attached_treestore = treestore;
  g_object_set(G_OBJECT(view), "has-tooltip", TRUE, NULL);
  g_signal_connect(G_OBJECT(view), "query-tooltip", G_CALLBACK(_row_tooltip_setup), (gpointer)self);
 
  col = gtk_tree_view_column_new();
  gtk_tree_view_append_column(view, col);
  renderer = gtk_cell_renderer_text_new();
  g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_MIDDLE, (gchar *)0);
  gtk_tree_view_column_pack_start(col, renderer, TRUE);
  gtk_tree_view_column_set_cell_data_func(col, renderer, _tree_tagname_show_attached, (gpointer)self, NULL);
  gtk_tree_view_column_set_expand(col, TRUE);
  gtk_tree_view_set_expander_column(view, col);
 
  // per-row "delete" icon to detach a single tag in one click
  col = gtk_tree_view_column_new();
  gtk_tree_view_append_column(view, col);
  renderer = dtgtk_cell_renderer_button_new();
  g_object_set(renderer, "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
  gtk_tree_view_column_pack_end(col, renderer, FALSE);
  gtk_tree_view_column_set_cell_data_func(col, renderer, _attached_delete_icon_show, NULL, NULL);
  g_signal_connect(renderer, "activate", G_CALLBACK(_attached_delete_icon_activated), (gpointer)self);
 
  gtk_tree_selection_set_mode(gtk_tree_view_get_selection(view), GTK_SELECTION_MULTIPLE);
  gtk_tree_view_set_model(view, GTK_TREE_MODEL(liststore));
  // NB: liststore and treestore are not unref'd here — d keeps a ref on each so they
  // both survive while the view switches between list and tree mode (freed in gui_cleanup)
  gtk_widget_set_tooltip_text(GTK_WIDGET(view), _("attached tags,"
                                                  "\nclick the trash icon, press Delete or double-click to detach"
                                                  "\nselect several tags and right-click to detach them in bulk,"
                                                  "\npress Tab to give the focus to entry,"
                                                  "\nctrl-wheel scroll to resize the window"));
  g_signal_connect(G_OBJECT(view), "button-press-event", G_CALLBACK(_click_on_view_attached), (gpointer)self);
  g_signal_connect(G_OBJECT(view), "key-press-event", G_CALLBACK(_attached_key_pressed), (gpointer)self);
  g_signal_connect(gtk_tree_view_get_selection(view), "changed", G_CALLBACK(_tree_selection_changed), self);
 
#define NEW_TOGGLE_BUTTON(paint, callback, tooltip, action)                  \
  button = dtgtk_togglebutton_new(paint, 0, NULL);                           \
  gtk_widget_set_tooltip_text(button, tooltip);                              \
  gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, TRUE, 0);                   \
  g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(callback), self); \
 
  // ── line 2: tag input entry (with autocompletion) ──
  box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING));
  gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), FALSE, TRUE, 0);
  // the attached-tags list is built before this entry, so move the entry up to index 1
  // (just under the combos at index 0): final order is combos, entry, attached list, checkbox
  gtk_box_reorder_child(GTK_BOX(self->widget), GTK_WIDGET(box), 1);
 
  hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING));
 
  w = gtk_entry_new();
  dt_accels_disconnect_on_text_input(w);
  gtk_entry_set_text(GTK_ENTRY(w), "");
  gtk_entry_set_width_chars(GTK_ENTRY(w), 0);
  // no widget tooltip here: it would pop up over the autocompletion list and hide it
  gtk_entry_set_placeholder_text(GTK_ENTRY(w), _("enter or pick a tag, Enter to attach"));
  gtk_entry_set_icon_from_icon_name(GTK_ENTRY(w), GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");
  gtk_entry_set_icon_tooltip_text(GTK_ENTRY(w), GTK_ENTRY_ICON_SECONDARY, _("clear entry"));
  g_signal_connect(G_OBJECT(w), "icon-release", G_CALLBACK(_entry_clear_icon), self);
  gtk_box_pack_start(hbox, w, TRUE, TRUE, 0);
  gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK);
  d->entry = GTK_ENTRY(w);
 
  // validate button: attach the typed/picked tag without having to hit Enter
  d->validate_button = dtgtk_button_new(dtgtk_cairo_paint_check_mark, 0, NULL);
  gtk_widget_set_tooltip_text(d->validate_button, _("attach this tag to the selected images"));
  gtk_box_pack_end(GTK_BOX(hbox), d->validate_button, FALSE, TRUE, 0);
  g_signal_connect(G_OBJECT(d->validate_button), "clicked", G_CALLBACK(_validate_button_clicked), (gpointer)self);
  gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0);
 
  // autocompletion: every known tag feeds the model, suggestions default to the
  // current collection's tags when the entry holds a single token (see _completion_match_func).
  // minimum key length 1: an empty entry shows no popup, so the list does not hover over the
  // attached-tags view (e.g. right after a tag was attached and the entry cleared).
  d->completion_store = gtk_list_store_new(DT_COMPL_NUM_COLS, G_TYPE_STRING);
  {
    GtkEntryCompletion *completion = gtk_entry_completion_new();
    gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(d->completion_store));
    gtk_entry_completion_set_text_column(completion, DT_COMPL_COL_PATH);
    gtk_entry_completion_set_inline_completion(completion, TRUE);
    gtk_entry_completion_set_popup_completion(completion, TRUE);
    gtk_entry_completion_set_popup_set_width(completion, FALSE);
    gtk_entry_completion_set_minimum_key_length(completion, 1);
    g_signal_connect(G_OBJECT(completion), "match-selected",
                     G_CALLBACK(dt_tagging_completion_match_selected), self);
    gtk_entry_completion_set_match_func(completion, _completion_match_func, self, NULL);
    gtk_entry_set_completion(d->entry, completion);
    g_object_unref(completion);
  }
  g_object_unref(d->completion_store);  // kept alive by the completion above
  // connected after gtk_entry_set_completion() so GtkEntryCompletion's own Return-key
  // handling (accepting a keyboard-highlighted popup match into the entry text) runs
  // before ours: otherwise a tag gets created from the raw typed prefix instead of the
  // selected suggestion (#905)
  g_signal_connect(G_OBJECT(d->entry), "key-press-event", G_CALLBACK(_enter_key_pressed), self);
 
  // ── tag management popup window (persistent, hidden until requested) ────
  d->manage_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(d->manage_window);
#endif
  gtk_window_set_title(GTK_WINDOW(d->manage_window), _("manage tags"));
  gtk_window_set_transient_for(GTK_WINDOW(d->manage_window), GTK_WINDOW(dt_gui_main_window()));
  gtk_window_set_default_size(GTK_WINDOW(d->manage_window), DT_PIXEL_APPLY_DPI(400), DT_PIXEL_APPLY_DPI(600));
  // hide instead of destroy so the dictionary widgets/state persist across openings
  g_signal_connect(G_OBJECT(d->manage_window), "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), NULL);
 
  box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING));
  gtk_container_set_border_width(GTK_CONTAINER(box), DT_PIXEL_APPLY_DPI(8));
  gtk_container_add(GTK_CONTAINER(d->manage_window), GTK_WIDGET(box));
 
  // search entry to filter the dictionary
  w = gtk_entry_new();
  dt_accels_disconnect_on_text_input(w);
  gtk_entry_set_text(GTK_ENTRY(w), "");
  gtk_entry_set_width_chars(GTK_ENTRY(w), 0);
  gtk_entry_set_placeholder_text(GTK_ENTRY(w), _("type to filter the tag dictionary below"));
  gtk_entry_set_icon_from_icon_name(GTK_ENTRY(w), GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");
  gtk_entry_set_icon_tooltip_text(GTK_ENTRY(w), GTK_ENTRY_ICON_SECONDARY, _("clear entry"));
  g_signal_connect(G_OBJECT(w), "icon-release", G_CALLBACK(_entry_clear_icon), self);
  gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK);
  g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(_tag_name_changed), (gpointer)self);
  d->dict_entry = GTK_ENTRY(w);
  gtk_box_pack_start(box, w, FALSE, TRUE, 0);
 
  // dictionary_view tree view
  view = GTK_TREE_VIEW(gtk_tree_view_new());
  // Static: keep a fixed height for stability alongside the attached-tags list above.
  w = dt_ui_scroll_wrap(GTK_WIDGET(view), 200, "plugins/lighttable/tagging/heightdictionarywindow",
                        DT_UI_RESIZE_STATIC);
  gtk_box_pack_start(box, w, TRUE, TRUE, 0);
  d->dictionary_view = view;
  gtk_tree_view_set_enable_search(view, FALSE);
  gtk_tree_view_set_headers_visible(view, FALSE);
  liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING,
                                G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN);
  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(liststore), DT_TAG_SORT_PATH_ID,
                  (GtkTreeIterCompareFunc)_sort_tree_path_func, self, NULL);
  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(liststore), DT_TAG_SORT_NAME_ID,
                  (GtkTreeIterCompareFunc)_sort_tree_tag_func, self, NULL);
  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(liststore), DT_TAG_SORT_COUNT_ID,
                  (GtkTreeIterCompareFunc)_sort_tree_count_func, self, NULL);
  d->dictionary_liststore = liststore;
  model = gtk_tree_model_filter_new(GTK_TREE_MODEL(liststore), NULL);
  gtk_tree_model_filter_set_visible_column(GTK_TREE_MODEL_FILTER(model), DT_LIB_TAGGING_COL_VISIBLE);
  d->dictionary_listfilter = GTK_TREE_MODEL_FILTER(model);
  treestore = gtk_tree_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING,
                                G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_BOOLEAN);
  gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(treestore), DT_TAG_SORT_PATH_ID,
                  (GtkTreeIterCompareFunc)_sort_tree_path_func, self, NULL);
  d->dictionary_treestore = treestore;
  model = gtk_tree_model_filter_new(GTK_TREE_MODEL(treestore), NULL);
  gtk_tree_model_filter_set_visible_column(GTK_TREE_MODEL_FILTER(model), DT_LIB_TAGGING_COL_VISIBLE);
  d->dictionary_treefilter = GTK_TREE_MODEL_FILTER(model);
 
  col = gtk_tree_view_column_new();
  gtk_tree_view_append_column(view, col);
  renderer = gtk_cell_renderer_text_new();
  g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_MIDDLE, (gchar *)0);
  gtk_tree_view_column_pack_start(col, renderer, TRUE);
  gtk_tree_view_column_set_cell_data_func(col, renderer, _tree_tagname_show_dictionary, (gpointer)self, NULL);
  gtk_tree_view_set_expander_column(view, col);
 
  gtk_tree_selection_set_mode(gtk_tree_view_get_selection(view), GTK_SELECTION_MULTIPLE);
  gtk_widget_set_tooltip_text(GTK_WIDGET(view), _("tag dictionary,"
                                                  "\nright-click to create, edit, delete tags,"
                                                  "\nselect several tags and right-click to delete them in bulk,"
                                                  "\nshift+click to fully expand the selected tag,"
                                                  "\nctrl-scroll to resize the window"));
 
  g_signal_connect(G_OBJECT(view), "button-press-event", G_CALLBACK(_click_on_view_dictionary), (gpointer)self);
  g_signal_connect(G_OBJECT(view), "key-press-event", G_CALLBACK(_dictionary_key_pressed), (gpointer)self);
  gtk_tree_view_set_model(view, GTK_TREE_MODEL(d->dictionary_listfilter));
  g_object_unref(d->dictionary_listfilter);
  g_object_set(G_OBJECT(view), "has-tooltip", TRUE, NULL);
  g_signal_connect(G_OBJECT(view), "query-tooltip", G_CALLBACK(_row_tooltip_setup), (gpointer)self);
  g_signal_connect(gtk_tree_view_get_selection(view), "changed", G_CALLBACK(_tree_selection_changed), self);
 
  // drag & drop
  {
    d->drag.path = NULL;
    d->drag.tagname = NULL;
    d->drag.scroll_timeout = 0;
    d->drag.expand_timeout = 0;
    d->drag.root = FALSE;
    d->drag.tag_source = FALSE;
    gtk_drag_dest_set(GTK_WIDGET(d->dictionary_view), GTK_DEST_DEFAULT_ALL,
                      target_list_tags_dest, n_targets_tags_dest, GDK_ACTION_MOVE);
    g_signal_connect(d->dictionary_view, "drag-data-get", G_CALLBACK(_event_dnd_get), self);
    g_signal_connect(d->dictionary_view, "drag-data-received", G_CALLBACK(_event_dnd_received), self);
    g_signal_connect_after(d->dictionary_view, "drag-begin", G_CALLBACK(_event_dnd_begin), self);
    g_signal_connect_after(d->dictionary_view, "drag-end", G_CALLBACK(_event_dnd_end), self);
    g_signal_connect(d->dictionary_view, "drag-motion", G_CALLBACK(_event_dnd_motion), self);
  }
 
  // buttons
  hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING));
 
  d->new_button = dt_action_button_new(self, N_("new"), _new_button_clicked, self, _("create a new tag with the\nname you entered"), 0, 0);
  gtk_box_pack_start(hbox, d->new_button, TRUE, TRUE, 0);
 
  d->import_button = dt_action_button_new(self, N_("import..."), _import_button_clicked, self, _("import tags from a Lightroom keyword file"), 0, 0);
  gtk_box_pack_start(hbox, d->import_button, TRUE, TRUE, 0);
 
  d->export_button = dt_action_button_new(self, N_("export..."), _export_button_clicked, self, _("export all tags to a Lightroom keyword file"), 0, 0);
  gtk_box_pack_start(hbox, d->export_button, TRUE, TRUE, 0);
 
  d->toggle_tree_button = NEW_TOGGLE_BUTTON(dtgtk_cairo_paint_treelist, _toggle_tree_button_callback,
                                            _("toggle list / tree view"), N_("tree"));
  d->toggle_suggestion_button = NEW_TOGGLE_BUTTON(dtgtk_cairo_paint_plus_simple, _toggle_suggestion_button_callback,
                                                  _("toggle list with / without suggestion"), N_("suggestion"));
 
  gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0);
 
  // ── tag-suggestion settings (formerly the module "preferences" dialog), applied live ──
  gtk_box_pack_start(box, gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, DT_PIXEL_APPLY_DPI(4));
  {
    GtkWidget *grid = gtk_grid_new();
    gtk_grid_set_row_spacing(GTK_GRID(grid), DT_GUI_BOX_SPACING);
    gtk_grid_set_column_spacing(GTK_GRID(grid), DT_GUI_BOX_SPACING);
 
    GtkWidget *lbl = gtk_label_new(_("suggested tags level of confidence"));
    gtk_widget_set_halign(lbl, GTK_ALIGN_START);
    gtk_widget_set_hexpand(lbl, TRUE);
    GtkWidget *spin = gtk_spin_button_new_with_range(0, 100, 1);
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), dt_conf_get_int("plugins/lighttable/tagging/confidence"));
    gtk_widget_set_tooltip_text(spin, _("level of confidence to include a tag in the suggestions list:"
                                        "\n0: all associated tags, 99: 99% matching tags,"
                                        "\n100: only the recently-used tags (faster)"));
    g_signal_connect(G_OBJECT(spin), "value-changed", G_CALLBACK(_confidence_changed), self);
    gtk_grid_attach(GTK_GRID(grid), lbl, 0, 0, 1, 1);
    gtk_grid_attach(GTK_GRID(grid), spin, 1, 0, 1, 1);
 
    GtkWidget *lbl2 = gtk_label_new(_("number of recently attached tags"));
    gtk_widget_set_halign(lbl2, GTK_ALIGN_START);
    gtk_widget_set_hexpand(lbl2, TRUE);
    GtkWidget *spin2 = gtk_spin_button_new_with_range(-1, 1000, 1);
    gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin2), dt_conf_get_int("plugins/lighttable/tagging/nb_recent_tags"));
    gtk_widget_set_tooltip_text(spin2, _("number of recently attached tags shown in the suggestions list"
                                         "\n(-1 disables the recent-tags list)"));
    g_signal_connect(G_OBJECT(spin2), "value-changed", G_CALLBACK(_recent_tags_changed), self);
    gtk_grid_attach(GTK_GRID(grid), lbl2, 0, 1, 1, 1);
    gtk_grid_attach(GTK_GRID(grid), spin2, 1, 1, 1, 1);
 
    gtk_box_pack_start(box, grid, FALSE, FALSE, 0);
  }
 
  // "show system tags" checkbox: reveal the tags Ansel manages automatically (Ansel|…)
  d->dttags_check = gtk_check_button_new_with_label(_("Show system tags"));
  gtk_widget_set_tooltip_text(d->dttags_check, _("show the tags automatically attached by Ansel (names starting with “Ansel|”)"));
  d->dttags_flag = FALSE;
  g_signal_connect(G_OBJECT(d->dttags_check), "toggled", G_CALLBACK(_dttags_check_toggled), self);
  gtk_box_pack_start(GTK_BOX(self->widget), d->dttags_check, FALSE, TRUE, 0);
 
#undef NEW_TOGGLE_BUTTON
 
  /* connect to mouse over id */
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE,
                            G_CALLBACK(_lib_tagging_redraw_callback), self);
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_TAG_CHANGED,
                            G_CALLBACK(_lib_tagging_tags_changed_callback), self);
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_SELECTION_CHANGED,
                            G_CALLBACK(_lib_selection_changed_callback), self);
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_COLLECTION_CHANGED,
                            G_CALLBACK(_collection_updated_callback), self);
 
  d->collection = g_malloc(4096);
  d->collection_tags = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
  _update_layout(self);
  _init_treeview(self, 0);
  _set_keyword(self);
  _init_treeview(self, 1);
  _update_atdetach_buttons(self);
  dt_tagging_completion_refresh(d->completion_store);
  _refresh_collection_tags(self);
 
  dt_accels_new_action_shortcut(dt_gui_get_accels(), _lib_tagging_tag_show_accel, self, NULL,
                                dt_gui_get_accels()->lighttable_accels, N_("Lighttable/Tags"),
                                N_("Tag"), GDK_KEY_t, DT_PRIMARY_MASK, FALSE,
                                _("Opens the quick tagging entry"));
  dt_accels_new_action_shortcut(dt_gui_get_accels(), _lib_tagging_tag_redo_accel, self, NULL,
                                dt_gui_get_accels()->lighttable_accels, N_("Lighttable/Tags"),
                                N_("Redo last tag"), GDK_KEY_t, GDK_MOD1_MASK, FALSE,
                                _("Re-applies the last used tag"));
  dt_accels_new_action_shortcut(dt_gui_get_accels(), _lib_tagging_tag_show_accel, self, NULL,
                                dt_gui_get_accels()->map_accels, N_("Map/Tags"),
                                N_("Tag"), GDK_KEY_t, DT_PRIMARY_MASK, FALSE,
                                _("Opens the quick tagging entry"));
  dt_accels_new_action_shortcut(dt_gui_get_accels(), _lib_tagging_tag_redo_accel, self, NULL,
                                dt_gui_get_accels()->map_accels, N_("Map/Tags"),
                                N_("Redo last tag"), GDK_KEY_t, GDK_MOD1_MASK, FALSE,
                                _("Re-applies the last used tag"));
}
 
void gui_cleanup(dt_lib_module_t *self)
{
  if(IS_NULL_PTR(self->data)) return;
  dt_lib_cancel_postponed_update(self);
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
 
  gchar *path = dt_accels_build_path(N_("Lighttable/Tags"), N_("Tag"));
  dt_accels_remove_accel(dt_gui_get_accels(), path, self);
  dt_free(path);
  path = dt_accels_build_path(N_("Lighttable/Tags"), N_("Redo last tag"));
  dt_accels_remove_accel(dt_gui_get_accels(), path, self);
  dt_free(path);
  path = dt_accels_build_path(N_("Map/Tags"), N_("Tag"));
  dt_accels_remove_accel(dt_gui_get_accels(), path, self);
  dt_free(path);
  path = dt_accels_build_path(N_("Map/Tags"), N_("Redo last tag"));
  dt_accels_remove_accel(dt_gui_get_accels(), path, self);
  dt_free(path);
 
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_lib_tagging_redraw_callback), self);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_lib_tagging_tags_changed_callback), self);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_lib_selection_changed_callback), self);
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(_collection_updated_callback), self);
  if(d->manage_window) gtk_widget_destroy(d->manage_window);
  if(d->collection_tags) g_hash_table_destroy(d->collection_tags);
  // d kept its own ref on both attached stores so the view could switch between them
  if(d->attached_liststore) g_object_unref(d->attached_liststore);
  if(d->attached_treestore) g_object_unref(d->attached_treestore);
  dt_free(d->collection);
  if(d->drag.tagname)
  {
    dt_free(d->drag.tagname);
  }
  if(d->drag.path) gtk_tree_path_free(d->drag.path);
  dt_free(self->data);
}
 
// http://stackoverflow.com/questions/4631388/transparent-floating-gtkentry
static gboolean _lib_tagging_tag_key_press(GtkWidget *entry, GdkEventKey *event, dt_lib_module_t *self)
{
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  guint key = dt_keys_mainpad_alternatives(event->keyval);
 
  switch(key)
  {
    case GDK_KEY_Escape:
      g_list_free(d->floating_tag_imgs);
      d->floating_tag_imgs = NULL;
      gtk_widget_destroy(d->floating_tag_window);
      gtk_window_present(GTK_WINDOW(dt_gui_main_window()));
      return TRUE;
    case GDK_KEY_Tab:
      return TRUE;
    case GDK_KEY_Return:
    {
      const gchar *tag = gtk_entry_get_text(GTK_ENTRY(entry));
      const gboolean res = dt_tag_attach_string_list(tag, d->floating_tag_imgs, TRUE);
      if(res) dt_image_synch_xmps(d->floating_tag_imgs);
      g_list_free(d->floating_tag_imgs);
      d->floating_tag_imgs = NULL;
 
      _save_last_tag_used(tag, d);
 
      _init_treeview(self, 0);
      _init_treeview(self, 1);
      dt_tagging_completion_refresh(d->completion_store);
      _refresh_collection_tags(self);
      gtk_widget_destroy(d->floating_tag_window);
      gtk_window_present(GTK_WINDOW(dt_gui_main_window()));
      if(res) _raise_signal_tag_changed(self);
 
      return TRUE;
    }
  }
  return FALSE; /* event not handled */
}
 
static gboolean _lib_tagging_tag_destroy(GtkWidget *widget, GdkEvent *event, gpointer user_data)
{
  gtk_widget_destroy(GTK_WIDGET(user_data));
  return FALSE;
}
 
 
static gboolean _lib_tagging_tag_redo_accel(GtkAccelGroup *accel_group, GObject *accelerable, guint keyval,
                                            GdkModifierType mods, gpointer user_data)
{
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
 
  if(d->last_tag)
  {
    GList *imgs = dt_act_on_get_images();
    const gboolean res = dt_tag_attach_string_list(d->last_tag, imgs, TRUE);
    if(res) dt_image_synch_xmps(imgs);
    g_list_free(imgs);
    imgs = NULL;
    _init_treeview(self, 0);
    _init_treeview(self, 1);
    dt_tagging_completion_refresh(d->completion_store);
    _refresh_collection_tags(self);
    if(res) _raise_signal_tag_changed(self);
  }
 
  return TRUE;
}
 
static gboolean _lib_tagging_tag_show_accel(GtkAccelGroup *accel_group, GObject *accelerable, guint keyval,
                                            GdkModifierType mods, gpointer user_data)
{
  dt_lib_module_t *self = (dt_lib_module_t *)user_data;
  dt_lib_tagging_t *d = (dt_lib_tagging_t *)self->data;
  if(d->tree_flag)
  {
    dt_control_log(_("tag shortcut is not active with tag tree view. please switch to list view"));
    return TRUE;  // doesn't work properly with tree treeview
  }
 
  d->floating_tag_imgs = dt_act_on_get_images();
  gint x, y;
  gint px, py, w, h;
  GtkWidget *window = dt_gui_main_window();
  GtkWidget *center = dt_gui_center_widget();
  gdk_window_get_origin(gtk_widget_get_window(center), &px, &py);
 
  w = gdk_window_get_width(gtk_widget_get_window(center));
  h = gdk_window_get_height(gtk_widget_get_window(center));
 
  x = px + 0.5 * (w - FLOATING_ENTRY_WIDTH);
  y = py + h - 50;
 
  /* put the floating box at the mouse pointer */
  //   gint pointerx, pointery;
  //   GdkDevice *device =
  //   gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(widget)));
  //   gdk_window_get_device_position (gtk_widget_get_window (widget), device, &pointerx, &pointery, NULL);
  //   x = px + pointerx + 1;
  //   y = py + pointery + 1;
 
  d->floating_tag_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#ifdef GDK_WINDOWING_QUARTZ
  dt_osx_disallow_fullscreen(d->floating_tag_window);
#endif
  /* stackoverflow.com/questions/1925568/how-to-give-keyboard-focus-to-a-pop-up-gtk-window */
  gtk_widget_set_can_focus(d->floating_tag_window, TRUE);
  gtk_window_set_decorated(GTK_WINDOW(d->floating_tag_window), FALSE);
  gtk_window_set_type_hint(GTK_WINDOW(d->floating_tag_window), GDK_WINDOW_TYPE_HINT_POPUP_MENU);
  gtk_window_set_transient_for(GTK_WINDOW(d->floating_tag_window), GTK_WINDOW(window));
  gtk_widget_set_opacity(d->floating_tag_window, 0.8);
  gtk_window_move(GTK_WINDOW(d->floating_tag_window), x, y);
 
  GtkWidget *entry = gtk_entry_new();
  dt_accels_disconnect_on_text_input(entry);
  gtk_widget_set_size_request(entry, FLOATING_ENTRY_WIDTH, -1);
  gtk_widget_add_events(entry, GDK_FOCUS_CHANGE_MASK);
 
  GtkEntryCompletion *completion = gtk_entry_completion_new();
  gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(d->completion_store));
  gtk_entry_completion_set_text_column(completion, DT_COMPL_COL_PATH);
  gtk_entry_completion_set_inline_completion(completion, TRUE);
  gtk_entry_completion_set_popup_set_width(completion, FALSE);
  gtk_entry_completion_set_minimum_key_length(completion, 0);
  g_signal_connect(G_OBJECT(completion), "match-selected",
                   G_CALLBACK(dt_tagging_completion_match_selected), self);
  gtk_entry_completion_set_match_func(completion, _completion_match_func, self, NULL);
  gtk_entry_set_completion(GTK_ENTRY(entry), completion);
 
  gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
  gtk_container_add(GTK_CONTAINER(d->floating_tag_window), entry);
  g_signal_connect(entry, "focus-out-event", G_CALLBACK(_lib_tagging_tag_destroy), d->floating_tag_window);
  g_signal_connect(entry, "key-press-event", G_CALLBACK(_lib_tagging_tag_key_press), self);
 
  gtk_widget_show_all(d->floating_tag_window);
  gtk_widget_grab_focus(entry);
  gtk_window_present(GTK_WINDOW(d->floating_tag_window));
 
  return TRUE;
}
 
static int _get_recent_tags_list_length()
{
  const int length = dt_conf_get_int("plugins/lighttable/tagging/nb_recent_tags");
  if(length == -1) return length;
  else if(length >= 10/2) return length * 2;
  else return 10;
}
 
static void _size_recent_tags_list()
{
  const char *list = dt_conf_get_string_const("plugins/lighttable/tagging/recent_tags");
  if(!list[0])
    return;
  const int length = _get_recent_tags_list_length();
  if(length == -1)
  {
    dt_conf_set_string("plugins/lighttable/tagging/recent_tags", "");
    return;
  }
 
  char *p = (char *)list;
  int nb = 1;
  for(;*p != '\0'; p++)
  {
    if(*p == ',') nb++;
  }
 
  if(nb > length)
  {
    nb -= length;
    char *list2 = g_strdup(list);
    for(; nb > 0; nb--)
    {
      p = g_strrstr(list2, "','");
      if(p) *p = '\0';
    }
    dt_conf_set_string("plugins/lighttable/tagging/recent_tags", list2);
    dt_free(list2);
  }
}
 
// the module's gear menu opens the tag management window, which now also hosts the
// tag-suggestion settings that used to live in a separate "preferences" dialog
void set_preferences(void *menu, dt_lib_module_t *self)
{
  GtkWidget *mi = gtk_menu_item_new_with_label(_("manage tags..."));
  g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(_show_manage_window), self);
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi);
}
 
static void _save_last_tag_used(const char *tagnames, dt_lib_tagging_t *d)
{
  dt_free(d->last_tag);
  d->last_tag = g_strdup(tagnames);
 
  const int nb_recent = _get_recent_tags_list_length();
 
  if(nb_recent != -1)
  {
    GList *ntags = dt_util_str_to_glist(",", tagnames);
    if(ntags)
    {
      const char *sl = dt_conf_get_string_const("plugins/lighttable/tagging/recent_tags");
      // use "','" instead of "," to use the list as is in the query (dt_tag_get_suggestions)
      GList *tags = dt_util_str_to_glist("','", sl);
      for(GList *tag = ntags; tag; tag = g_list_next(tag))
      {
        char *escaped = sqlite3_mprintf("%q", (char *)tag->data);
        GList *found = g_list_find_custom(tags, escaped, (GCompareFunc)g_strcmp0);
        if(found)
        {
          tags = g_list_remove_link(tags, found);
          dt_free(found->data);
          g_list_free(found);
          found = NULL;
        }
        tags = g_list_prepend(tags, g_strdup(escaped));
        sqlite3_free(escaped);
      }
      g_list_free_full(ntags, dt_free_gpointer);
      ntags = NULL;
 
      char *nsl = dt_util_glist_to_str("','", tags);
      dt_conf_set_string("plugins/lighttable/tagging/recent_tags", nsl);
      dt_free(nsl);
      if(g_list_length(tags) > nb_recent)
        _size_recent_tags_list();
      g_list_free_full(tags, dt_free_gpointer);
      tags = 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