src/bar-keywords.cc

   1 /*
   2  * Copyright (C) 2004 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * Author: John Ellis
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "bar-keywords.h"
  23
  24 #include <config.h>
  25
  26 #include "bar.h"
  27 #include "compat.h"
  28 #include "debug.h"
  29 #include "dnd.h"
  30 #include "filedata.h"
  31 #include "intl.h"
  32 #include "layout.h"
  33 #include "main-defines.h"
  34 #include "metadata.h"
  35 #include "misc.h"
  36 #include "rcfile.h"
  37 #include "secure-save.h"
  38 #include "ui-fileops.h"
  39 #include "ui-menu.h"
  40 #include "ui-misc.h"
  41 #include "ui-utildlg.h"
  42
  43 static void bar_pane_keywords_changed(GtkTextBuffer *buffer, gpointer data);
  44
  45 static void autocomplete_keywords_list_load(const gchar *path);
  46 static GtkListStore *keyword_store = nullptr;
  47 static gboolean autocomplete_keywords_list_save(gchar *path);
  48 static gboolean autocomplete_activate_cb(GtkWidget *widget, gpointer data);
  49
  50 /*
  51  *-------------------------------------------------------------------
  52  * keyword / comment utils
  53  *-------------------------------------------------------------------
  54  */
  55
  56
  57 GList *keyword_list_pull(GtkWidget *text_widget)
  58 {
  59         GList *list;
  60         gchar *text;
  61
  62         text = text_widget_text_pull(text_widget);
  63         list = string_to_keywords_list(text);
  64
  65         g_free(text);
  66
  67         return list;
  68 }
  69
  70 static GList *keyword_list_pull_selected(GtkWidget *text_widget)
  71 {
  72         GList *list;
  73         gchar *text;
  74
  75         text = text_widget_text_pull_selected(text_widget);
  76         list = string_to_keywords_list(text);
  77
  78         g_free(text);
  79
  80         return list;
  81 }
  82
  83 /* the "changed" signal should be blocked before calling this */
  84 static void keyword_list_push(GtkWidget *textview, GList *list)
  85 {
  86         GtkTextBuffer *buffer;
  87         GtkTextIter start;
  88         GtkTextIter end;
  89
  90         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
  91         gtk_text_buffer_get_bounds(buffer, &start, &end);
  92         gtk_text_buffer_delete(buffer, &start, &end);
  93
  94         while (list)
  95                 {
  96                 auto word = static_cast<const gchar *>(list->data);
  97                 GtkTextIter iter;
  98
  99                 gtk_text_buffer_get_end_iter(buffer, &iter);
 100                 if (word) gtk_text_buffer_insert(buffer, &iter, word, -1);
 101                 gtk_text_buffer_get_end_iter(buffer, &iter);
 102                 gtk_text_buffer_insert(buffer, &iter, "\n", -1);
 103
 104                 list = list->next;
 105                 }
 106 }
 107
 108
 109 /*
 110  *-------------------------------------------------------------------
 111  * info bar
 112  *-------------------------------------------------------------------
 113  */
 114
 115
 116 enum {
 117         FILTER_KEYWORD_COLUMN_TOGGLE = 0,
 118         FILTER_KEYWORD_COLUMN_MARK,
 119         FILTER_KEYWORD_COLUMN_NAME,
 120         FILTER_KEYWORD_COLUMN_IS_KEYWORD,
 121         FILTER_KEYWORD_COLUMN_COUNT
 122 };
 123
 124 static GType filter_keyword_column_types[] = {G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN};
 125
 126 struct PaneKeywordsData
 127 {
 128         PaneData pane;
 129         GtkWidget *widget;
 130
 131         GtkWidget *keyword_view;
 132         GtkWidget *keyword_treeview;
 133
 134         GtkTreePath *click_tpath;
 135
 136         gboolean expand_checked;
 137         gboolean collapse_unchecked;
 138         gboolean hide_unchecked;
 139
 140         guint idle_id; /* event source id */
 141         FileData *fd;
 142         gchar *key;
 143         gint height;
 144
 145         GList *expanded_rows;
 146
 147         GtkWidget *autocomplete;
 148 };
 149
 150 struct ConfDialogData
 151 {
 152         PaneKeywordsData *pkd;
 153         GtkTreePath *click_tpath;
 154
 155         /* dialog parts */
 156         GenericDialog *gd;
 157         GtkWidget *edit_widget;
 158         gboolean is_keyword;
 159
 160         gboolean edit_existing;
 161 };
 162
 163
 164 static void bar_pane_keywords_write(PaneKeywordsData *pkd)
 165 {
 166         GList *list;
 167
 168         if (!pkd->fd) return;
 169
 170         list = keyword_list_pull(pkd->keyword_view);
 171
 172         metadata_write_list(pkd->fd, KEYWORD_KEY, list);
 173
 174         g_list_free_full(list, g_free);
 175 }
 176
 177 static gboolean bar_keyword_tree_expand_if_set_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
 178 {
 179         auto pkd = static_cast<PaneKeywordsData *>(data);
 180         gboolean set;
 181
 182         gtk_tree_model_get(model, iter, FILTER_KEYWORD_COLUMN_TOGGLE, &set, -1);
 183
 184         if (set && !gtk_tree_view_row_expanded(GTK_TREE_VIEW(pkd->keyword_treeview), path))
 185                 {
 186                 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), path);
 187                 }
 188         return FALSE;
 189 }
 190
 191 static gboolean bar_keyword_tree_collapse_if_unset_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
 192 {
 193         auto pkd = static_cast<PaneKeywordsData *>(data);
 194         gboolean set;
 195
 196         gtk_tree_model_get(model, iter, FILTER_KEYWORD_COLUMN_TOGGLE, &set, -1);
 197
 198         if (!set && gtk_tree_view_row_expanded(GTK_TREE_VIEW(pkd->keyword_treeview), path))
 199                 {
 200                 gtk_tree_view_collapse_row(GTK_TREE_VIEW(pkd->keyword_treeview), path);
 201                 }
 202         return FALSE;
 203 }
 204
 205 static void bar_keyword_tree_sync(PaneKeywordsData *pkd)
 206 {
 207         GtkTreeModel *model;
 208
 209         GtkTreeModel *keyword_tree;
 210         GList *keywords;
 211
 212         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 213         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 214
 215         keywords = keyword_list_pull(pkd->keyword_view);
 216         keyword_show_set_in(GTK_TREE_STORE(keyword_tree), model, keywords);
 217         if (pkd->hide_unchecked) keyword_hide_unset_in(GTK_TREE_STORE(keyword_tree), model, keywords);
 218         g_list_free_full(keywords, g_free);
 219
 220         gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(model));
 221
 222         if (pkd->expand_checked) gtk_tree_model_foreach(model, bar_keyword_tree_expand_if_set_cb, pkd);
 223         if (pkd->collapse_unchecked) gtk_tree_model_foreach(model, bar_keyword_tree_collapse_if_unset_cb, pkd);
 224 }
 225
 226 static void bar_pane_keywords_update(PaneKeywordsData *pkd)
 227 {
 228         GList *keywords = nullptr;
 229         GList *orig_keywords = nullptr;
 230         GList *work1;
 231         GList *work2;
 232         GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
 233
 234         keywords = metadata_read_list(pkd->fd, KEYWORD_KEY, METADATA_PLAIN);
 235         orig_keywords = keyword_list_pull(pkd->keyword_view);
 236
 237         /* compare the lists */
 238         work1 = keywords;
 239         work2 = orig_keywords;
 240
 241         while (work1 && work2)
 242                 {
 243                 if (strcmp(static_cast<const gchar *>(work1->data), static_cast<const gchar *>(work2->data)) != 0) break;
 244                 work1 = work1->next;
 245                 work2 = work2->next;
 246                 }
 247
 248         if (work1 || work2) /* lists differs */
 249                 {
 250                 g_signal_handlers_block_by_func(keyword_buffer, (gpointer)bar_pane_keywords_changed, pkd);
 251                 keyword_list_push(pkd->keyword_view, keywords);
 252                 bar_keyword_tree_sync(pkd);
 253                 g_signal_handlers_unblock_by_func(keyword_buffer, (gpointer)bar_pane_keywords_changed, pkd);
 254                 }
 255         g_list_free_full(keywords, g_free);
 256         g_list_free_full(orig_keywords, g_free);
 257 }
 258
 259 static void bar_pane_keywords_set_fd(GtkWidget *pane, FileData *fd)
 260 {
 261         PaneKeywordsData *pkd;
 262
 263         pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
 264         if (!pkd) return;
 265
 266         file_data_unref(pkd->fd);
 267         pkd->fd = file_data_ref(fd);
 268
 269         bar_pane_keywords_update(pkd);
 270 }
 271
 272 static void bar_keyword_tree_get_expanded_cb(GtkTreeView *keyword_treeview, GtkTreePath *path,  gpointer data)
 273 {
 274         auto expanded = static_cast<GList **>(data);
 275         GtkTreeModel *model;
 276         GtkTreeIter iter;
 277         gchar *path_string;
 278
 279         model = gtk_tree_view_get_model(GTK_TREE_VIEW(keyword_treeview));
 280         gtk_tree_model_get_iter(model, &iter, path);
 281
 282         path_string = gtk_tree_model_get_string_from_iter(model, &iter);
 283
 284         *expanded = g_list_append(*expanded, g_strdup(path_string));
 285         g_free(path_string);
 286 }
 287
 288 static void bar_pane_keywords_entry_write_config(gchar *entry, GString *outstr, gint indent)
 289 {
 290         struct {
 291                 gchar *path;
 292         } expand;
 293
 294         expand.path = entry;
 295
 296         WRITE_NL(); WRITE_STRING("<expanded ");
 297         WRITE_CHAR(expand, path);
 298         WRITE_STRING("/>");
 299 }
 300
 301 static void bar_pane_keywords_write_config(GtkWidget *pane, GString *outstr, gint indent)
 302 {
 303         PaneKeywordsData *pkd;
 304         GList *path_expanded = nullptr;
 305         gint w;
 306         gint h;
 307
 308         pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
 309         if (!pkd) return;
 310
 311         gtk_widget_get_size_request(GTK_WIDGET(pane), &w, &h);
 312         pkd->height = h;
 313
 314         WRITE_NL(); WRITE_STRING("<pane_keywords ");
 315         write_char_option(outstr, indent, "id", pkd->pane.id);
 316         write_char_option(outstr, indent, "title", gtk_label_get_text(GTK_LABEL(pkd->pane.title)));
 317         WRITE_BOOL(pkd->pane, expanded);
 318         WRITE_CHAR(*pkd, key);
 319         WRITE_INT(*pkd, height);
 320         WRITE_STRING(">");
 321         indent++;
 322
 323         gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(pkd->keyword_treeview),
 324                                                                 (bar_keyword_tree_get_expanded_cb), &path_expanded);
 325
 326         GList *work = g_list_first(path_expanded);
 327         while (work)
 328                 {
 329                 bar_pane_keywords_entry_write_config(static_cast<gchar *>(work->data), outstr, indent);
 330                 work = work->next;
 331                 }
 332         g_list_free_full(path_expanded, g_free);
 333
 334         indent--;
 335         WRITE_NL();
 336         WRITE_STRING("</pane_keywords>");
 337 }
 338
 339 static gint bar_pane_keywords_event(GtkWidget *bar, GdkEvent *event)
 340 {
 341         PaneKeywordsData *pkd;
 342
 343         pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(bar), "pane_data"));
 344         if (!pkd) return FALSE;
 345
 346         if (gtk_widget_has_focus(pkd->keyword_view)) return gtk_widget_event(pkd->keyword_view, event);
 347
 348         if (gtk_widget_has_focus(pkd->autocomplete))
 349                 {
 350                 return gtk_widget_event(pkd->autocomplete, event);
 351                 }
 352         return FALSE;
 353 }
 354
 355 static void bar_pane_keywords_keyword_toggle(GtkCellRendererToggle *, const gchar *path, gpointer data)
 356 {
 357         auto pkd = static_cast<PaneKeywordsData *>(data);
 358         GtkTreeModel *model;
 359         GtkTreeIter iter;
 360         GtkTreePath *tpath;
 361         gboolean active;
 362         GList *list;
 363         GtkTreeIter child_iter;
 364         GtkTreeModel *keyword_tree;
 365
 366         GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
 367
 368         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 369
 370         tpath = gtk_tree_path_new_from_string(path);
 371         gtk_tree_model_get_iter(model, &iter, tpath);
 372         gtk_tree_path_free(tpath);
 373
 374         gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_TOGGLE, &active, -1);
 375         active = (!active);
 376
 377
 378         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 379         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
 380
 381         list = keyword_list_pull(pkd->keyword_view);
 382         if (active)
 383                 keyword_tree_set(keyword_tree, &child_iter, &list);
 384         else
 385                 keyword_tree_reset(keyword_tree, &child_iter, &list);
 386
 387         g_signal_handlers_block_by_func(keyword_buffer, (gpointer)bar_pane_keywords_changed, pkd);
 388         keyword_list_push(pkd->keyword_view, list);
 389         g_list_free_full(list, g_free);
 390         g_signal_handlers_unblock_by_func(keyword_buffer, (gpointer)bar_pane_keywords_changed, pkd);
 391
 392         /* call this just once in the end */
 393         bar_pane_keywords_changed(keyword_buffer, pkd);
 394 }
 395
 396 static void bar_pane_keywords_filter_modify(GtkTreeModel *model, GtkTreeIter *iter, GValue *value, gint column, gpointer data)
 397 {
 398         auto pkd = static_cast<PaneKeywordsData *>(data);
 399         GtkTreeModel *keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 400         GtkTreeIter child_iter;
 401
 402         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, iter);
 403
 404         memset(value, 0, sizeof (GValue));
 405
 406         switch (column)
 407                 {
 408                 case FILTER_KEYWORD_COLUMN_TOGGLE:
 409                         {
 410                         GList *keywords = keyword_list_pull(pkd->keyword_view);
 411                         gboolean set = keyword_tree_is_set(keyword_tree, &child_iter, keywords);
 412                         g_list_free_full(keywords, g_free);
 413
 414                         g_value_init(value, G_TYPE_BOOLEAN);
 415                         g_value_set_boolean(value, set);
 416                         break;
 417                         }
 418                 case FILTER_KEYWORD_COLUMN_MARK:
 419                         gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_MARK, value);
 420                         break;
 421                 case FILTER_KEYWORD_COLUMN_NAME:
 422                         gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_NAME, value);
 423                         break;
 424                 case FILTER_KEYWORD_COLUMN_IS_KEYWORD:
 425                         gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_IS_KEYWORD, value);
 426                         break;
 427                 }
 428 }
 429
 430 static gboolean bar_pane_keywords_filter_visible(GtkTreeModel *keyword_tree, GtkTreeIter *iter, gpointer data)
 431 {
 432         auto filter = static_cast<GtkTreeModel *>(data);
 433
 434         return !keyword_is_hidden_in(keyword_tree, iter, filter);
 435 }
 436
 437 static void bar_pane_keywords_set_selection(PaneKeywordsData *pkd, gboolean append)
 438 {
 439         GList *keywords = nullptr;
 440         GList *list = nullptr;
 441         GList *work;
 442
 443         keywords = keyword_list_pull_selected(pkd->keyword_view);
 444
 445         list = layout_selection_list(pkd->pane.lw);
 446         list = file_data_process_groups_in_selection(list, FALSE, nullptr);
 447
 448         work = list;
 449         while (work)
 450                 {
 451                 auto fd = static_cast<FileData *>(work->data);
 452                 work = work->next;
 453
 454                 if (append)
 455                         {
 456                         metadata_append_list(fd, KEYWORD_KEY, keywords);
 457                         }
 458                 else
 459                         {
 460                         metadata_write_list(fd, KEYWORD_KEY, keywords);
 461                         }
 462                 }
 463
 464         filelist_free(list);
 465         g_list_free_full(keywords, g_free);
 466 }
 467
 468 static void bar_pane_keywords_sel_add_cb(GtkWidget *, gpointer data)
 469 {
 470         auto pkd = static_cast<PaneKeywordsData *>(data);
 471
 472         bar_pane_keywords_set_selection(pkd, TRUE);
 473 }
 474
 475 static void bar_pane_keywords_sel_replace_cb(GtkWidget *, gpointer data)
 476 {
 477         auto pkd = static_cast<PaneKeywordsData *>(data);
 478
 479         bar_pane_keywords_set_selection(pkd, FALSE);
 480 }
 481
 482 static void bar_pane_keywords_populate_popup_cb(GtkTextView *, GtkMenu *menu, gpointer data)
 483 {
 484         auto pkd = static_cast<PaneKeywordsData *>(data);
 485
 486         menu_item_add_divider(GTK_WIDGET(menu));
 487         menu_item_add_icon(GTK_WIDGET(menu), _("Add selected keywords to selected files"), GQ_ICON_ADD, G_CALLBACK(bar_pane_keywords_sel_add_cb), pkd);
 488         menu_item_add_icon(GTK_WIDGET(menu), _("Replace existing keywords in selected files with selected keywords"), GQ_ICON_REPLACE, G_CALLBACK(bar_pane_keywords_sel_replace_cb), pkd);
 489 }
 490
 491
 492 static void bar_pane_keywords_notify_cb(FileData *fd, NotifyType type, gpointer data)
 493 {
 494         auto pkd = static_cast<PaneKeywordsData *>(data);
 495         if ((type & (NOTIFY_REREAD | NOTIFY_CHANGE | NOTIFY_METADATA)) && fd == pkd->fd)
 496                 {
 497                 DEBUG_1("Notify pane_keywords: %s %04x", fd->path, type);
 498                 bar_pane_keywords_update(pkd);
 499                 }
 500 }
 501
 502 static gboolean bar_pane_keywords_changed_idle_cb(gpointer data)
 503 {
 504         auto pkd = static_cast<PaneKeywordsData *>(data);
 505
 506         bar_pane_keywords_write(pkd);
 507         bar_keyword_tree_sync(pkd);
 508         pkd->idle_id = 0;
 509         return G_SOURCE_REMOVE;
 510 }
 511
 512 static void bar_pane_keywords_changed(GtkTextBuffer *, gpointer data)
 513 {
 514         auto pkd = static_cast<PaneKeywordsData *>(data);
 515
 516         if (pkd->idle_id) return;
 517         /* higher prio than redraw */
 518         pkd->idle_id = g_idle_add_full(G_PRIORITY_HIGH_IDLE, bar_pane_keywords_changed_idle_cb, pkd, nullptr);
 519 }
 520
 521
 522 /*
 523  *-------------------------------------------------------------------
 524  * dnd
 525  *-------------------------------------------------------------------
 526  */
 527
 528
 529 static GtkTargetEntry bar_pane_keywords_drag_types[] = {
 530         { const_cast<gchar *>(TARGET_APP_KEYWORD_PATH_STRING), GTK_TARGET_SAME_WIDGET, TARGET_APP_KEYWORD_PATH },
 531         { const_cast<gchar *>("text/plain"), 0, TARGET_TEXT_PLAIN }
 532 };
 533 static gint n_keywords_drag_types = 2;
 534
 535
 536 static GtkTargetEntry bar_pane_keywords_drop_types[] = {
 537         { const_cast<gchar *>(TARGET_APP_KEYWORD_PATH_STRING), GTK_TARGET_SAME_WIDGET, TARGET_APP_KEYWORD_PATH },
 538         { const_cast<gchar *>("text/plain"), 0, TARGET_TEXT_PLAIN }
 539 };
 540 static gint n_keywords_drop_types = 2;
 541
 542
 543 static void bar_pane_keywords_dnd_get(GtkWidget *tree_view, GdkDragContext *,
 544                                      GtkSelectionData *selection_data, guint info,
 545                                      guint, gpointer)
 546 {
 547         GtkTreeIter iter;
 548         GtkTreeModel *model;
 549         GtkTreeIter child_iter;
 550         GtkTreeModel *keyword_tree;
 551
 552         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
 553
 554         if (!gtk_tree_selection_get_selected(sel, &model, &iter)) return;
 555
 556         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 557         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
 558
 559         switch (info)
 560                 {
 561                 case TARGET_APP_KEYWORD_PATH:
 562                         {
 563                         GList *path = keyword_tree_get_path(keyword_tree, &child_iter);
 564                         gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
 565                                                8, reinterpret_cast<const guchar *>(&path), sizeof(path));
 566                         break;
 567                         }
 568
 569                 case TARGET_TEXT_PLAIN:
 570                 default:
 571                         {
 572                         gchar *name = keyword_get_name(keyword_tree, &child_iter);
 573                         gtk_selection_data_set_text(selection_data, name, -1);
 574                         g_free(name);
 575                         }
 576                         break;
 577                 }
 578 }
 579
 580 static void bar_pane_keywords_dnd_begin(GtkWidget *tree_view, GdkDragContext *context, gpointer)
 581 {
 582         GtkTreeIter iter;
 583         GtkTreeModel *model;
 584         GtkTreeIter child_iter;
 585         GtkTreeModel *keyword_tree;
 586         gchar *name;
 587
 588         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
 589
 590         if (!gtk_tree_selection_get_selected(sel, &model, &iter)) return;
 591
 592         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 593         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
 594
 595         name = keyword_get_name(keyword_tree, &child_iter);
 596
 597         dnd_set_drag_label(tree_view, context, name);
 598         g_free(name);
 599
 600 }
 601
 602 static void bar_pane_keywords_dnd_end(GtkWidget *, GdkDragContext *, gpointer)
 603 {
 604 }
 605
 606
 607 static gboolean bar_pane_keywords_dnd_can_move(GtkTreeModel *keyword_tree, GtkTreeIter *src_kw_iter, GtkTreeIter *dest_kw_iter)
 608 {
 609         gchar *src_name;
 610         GtkTreeIter parent;
 611
 612         if (dest_kw_iter && keyword_same_parent(keyword_tree, src_kw_iter, dest_kw_iter))
 613                 {
 614                 return TRUE; /* reordering of siblings is ok */
 615                 }
 616         if (!dest_kw_iter && !gtk_tree_model_iter_parent(keyword_tree, &parent, src_kw_iter))
 617                 {
 618                 return TRUE; /* reordering of top-level siblings is ok */
 619                 }
 620
 621         src_name = keyword_get_name(keyword_tree, src_kw_iter);
 622         if (keyword_exists(keyword_tree, nullptr, dest_kw_iter, src_name, FALSE, nullptr))
 623                 {
 624                 g_free(src_name);
 625                 return FALSE;
 626         }
 627         g_free(src_name);
 628         return TRUE;
 629 }
 630
 631 static gboolean bar_pane_keywords_dnd_skip_existing(GtkTreeModel *keyword_tree, GtkTreeIter *dest_kw_iter, GList **keywords)
 632 {
 633         /* we have to find at least one keyword that does not already exist as a sibling of dest_kw_iter */
 634         GList *work = *keywords;
 635         while (work)
 636                 {
 637                 auto keyword = static_cast<gchar *>(work->data);
 638                 if (keyword_exists(keyword_tree, nullptr, dest_kw_iter, keyword, FALSE, nullptr))
 639                         {
 640                         GList *next = work->next;
 641                         g_free(keyword);
 642                         *keywords = g_list_delete_link(*keywords, work);
 643                         work = next;
 644                         }
 645                 else
 646                         {
 647                         work = work->next;
 648                         }
 649                 }
 650         return !!*keywords;
 651 }
 652
 653 static void bar_pane_keywords_dnd_receive(GtkWidget *tree_view, GdkDragContext *,
 654                                           gint x, gint y,
 655                                           GtkSelectionData *selection_data, guint info,
 656                                           guint, gpointer data)
 657 {
 658         auto pkd = static_cast<PaneKeywordsData *>(data);
 659         GtkTreePath *tpath = nullptr;
 660         GtkTreeViewDropPosition pos;
 661         GtkTreeModel *model;
 662
 663         GtkTreeModel *keyword_tree;
 664         gboolean src_valid = FALSE;
 665         GList *new_keywords = nullptr;
 666         GList *work;
 667
 668         /* iterators for keyword_tree */
 669         GtkTreeIter src_kw_iter;
 670         GtkTreeIter dest_kw_iter;
 671         GtkTreeIter new_kw_iter;
 672
 673         g_signal_stop_emission_by_name(tree_view, "drag_data_received");
 674
 675         model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
 676         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 677
 678         gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos);
 679         gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), nullptr, pos);
 680
 681         switch (info)
 682                 {
 683                 case TARGET_APP_KEYWORD_PATH:
 684                         {
 685                         auto path = static_cast<GList *>(*reinterpret_cast<const gpointer *>(gtk_selection_data_get_data(selection_data)));
 686                         src_valid = keyword_tree_get_iter(keyword_tree, &src_kw_iter, path);
 687                         g_list_free_full(path, g_free);
 688                         break;
 689                         }
 690                 default:
 691                         new_keywords = string_to_keywords_list(reinterpret_cast<const gchar *>(gtk_selection_data_get_data(selection_data)));
 692                         break;
 693                 }
 694
 695         if (tpath)
 696                 {
 697                 GtkTreeIter dest_iter;
 698                 gtk_tree_model_get_iter(model, &dest_iter, tpath);
 699                 gtk_tree_path_free(tpath);
 700                 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &dest_kw_iter, &dest_iter);
 701
 702                 if (src_valid && gtk_tree_store_is_ancestor(GTK_TREE_STORE(keyword_tree), &src_kw_iter, &dest_kw_iter))
 703                         {
 704                         /* can't move to it's own child */
 705                         return;
 706                         }
 707
 708                 if (src_valid && keyword_compare(keyword_tree, &src_kw_iter, &dest_kw_iter) == 0)
 709                         {
 710                         /* can't move to itself */
 711                         return;
 712                         }
 713
 714                 if ((pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE || pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER) &&
 715                     !gtk_tree_model_iter_has_child(keyword_tree, &dest_kw_iter))
 716                         {
 717                         /* the node has no children, all keywords can be added */
 718                         gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &dest_kw_iter);
 719                         }
 720                 else
 721                         {
 722                         if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, &dest_kw_iter))
 723                                 {
 724                                 /* the keyword can't be moved if the same name already exist */
 725                                 return;
 726                                 }
 727                         if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, &dest_kw_iter, &new_keywords))
 728                                 {
 729                                 /* the keywords can't be added if the same name already exist */
 730                                 return;
 731                                 }
 732
 733                         switch (pos)
 734                                 {
 735                                 case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
 736                                 case GTK_TREE_VIEW_DROP_BEFORE:
 737                                         gtk_tree_store_insert_before(GTK_TREE_STORE(keyword_tree), &new_kw_iter, nullptr, &dest_kw_iter);
 738                                         break;
 739                                 case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
 740                                 case GTK_TREE_VIEW_DROP_AFTER:
 741                                         gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &new_kw_iter, nullptr, &dest_kw_iter);
 742                                         break;
 743                                 }
 744                         }
 745
 746                 }
 747         else
 748                 {
 749                 if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, nullptr))
 750                         {
 751                         /* the keyword can't be moved if the same name already exist */
 752                         return;
 753                         }
 754                 if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, nullptr, &new_keywords))
 755                         {
 756                         /* the keywords can't be added if the same name already exist */
 757                         return;
 758                         }
 759                 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, nullptr);
 760                 }
 761
 762
 763         if (src_valid)
 764                 {
 765                 keyword_move_recursive(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &src_kw_iter);
 766                 }
 767
 768         work = new_keywords;
 769         while (work)
 770                 {
 771                 auto keyword = static_cast<gchar *>(work->data);
 772                 keyword_set(GTK_TREE_STORE(keyword_tree), &new_kw_iter, keyword, TRUE);
 773                 work = work->next;
 774
 775                 if (work)
 776                         {
 777                         GtkTreeIter add;
 778                         gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, nullptr, &new_kw_iter);
 779                         new_kw_iter = add;
 780                         }
 781                 }
 782         g_list_free_full(new_keywords, g_free);
 783         bar_keyword_tree_sync(pkd);
 784 }
 785
 786 static gint bar_pane_keywords_dnd_motion(GtkWidget *tree_view, GdkDragContext *context,
 787                                         gint x, gint y, guint time, gpointer)
 788 {
 789         GtkTreePath *tpath = nullptr;
 790         GtkTreeViewDropPosition pos;
 791         gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos);
 792         if (tpath)
 793                 {
 794                 GtkTreeModel *model;
 795                 GtkTreeIter dest_iter;
 796                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
 797                 gtk_tree_model_get_iter(model, &dest_iter, tpath);
 798                 if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE && gtk_tree_model_iter_has_child(model, &dest_iter))
 799                         pos = GTK_TREE_VIEW_DROP_BEFORE;
 800
 801                 if (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER && gtk_tree_model_iter_has_child(model, &dest_iter))
 802                         pos = GTK_TREE_VIEW_DROP_AFTER;
 803                 }
 804
 805         gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), tpath, pos);
 806         gtk_tree_path_free(tpath);
 807
 808         if (tree_view == gtk_drag_get_source_widget(context))
 809                 gdk_drag_status(context, GDK_ACTION_MOVE, time);
 810         else
 811                 gdk_drag_status(context, GDK_ACTION_COPY, time);
 812
 813         return TRUE;
 814 }
 815
 816 /*
 817  *-------------------------------------------------------------------
 818  * edit dialog
 819  *-------------------------------------------------------------------
 820  */
 821
 822 static void bar_pane_keywords_edit_destroy_cb(GtkWidget *, gpointer data)
 823 {
 824         auto cdd = static_cast<ConfDialogData *>(data);
 825         gtk_tree_path_free(cdd->click_tpath);
 826         g_free(cdd);
 827 }
 828
 829
 830 static void bar_pane_keywords_edit_cancel_cb(GenericDialog *, gpointer)
 831 {
 832 }
 833
 834
 835 static void bar_pane_keywords_edit_ok_cb(GenericDialog *, gpointer data)
 836 {
 837         auto cdd = static_cast<ConfDialogData *>(data);
 838         PaneKeywordsData *pkd = cdd->pkd;
 839         GtkTreeModel *model;
 840
 841         GtkTreeModel *keyword_tree;
 842         GtkTreeIter kw_iter;
 843
 844         gboolean have_dest = FALSE;
 845
 846         GList *keywords;
 847
 848         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 849         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 850
 851         if (cdd->click_tpath)
 852                 {
 853                 GtkTreeIter iter;
 854                 if (gtk_tree_model_get_iter(model, &iter, cdd->click_tpath))
 855                         {
 856                         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
 857                         have_dest = TRUE;
 858                         }
 859                 }
 860
 861         if (cdd->edit_existing && !have_dest) return;
 862
 863         keywords = keyword_list_pull(cdd->edit_widget);
 864
 865         if (cdd->edit_existing)
 866                 {
 867                 if (keywords && keywords->data && /* there should be one keyword */
 868                     !keyword_exists(keyword_tree, nullptr, &kw_iter, static_cast<const gchar *>(keywords->data), TRUE, nullptr))
 869                         {
 870                         keyword_set(GTK_TREE_STORE(keyword_tree), &kw_iter, static_cast<const gchar *>(keywords->data), cdd->is_keyword);
 871                         }
 872                 }
 873         else
 874                 {
 875                 GList *work = keywords;
 876                 gboolean append_to = FALSE;
 877
 878                 while (work)
 879                         {
 880                         GtkTreeIter add;
 881                         if (keyword_exists(keyword_tree, nullptr, (have_dest || append_to) ? &kw_iter : nullptr, static_cast<const gchar *>(work->data), FALSE, nullptr))
 882                                 {
 883                                 work = work->next;
 884                                 continue;
 885                                 }
 886                         if (have_dest)
 887                                 {
 888                                 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, &kw_iter);
 889                                 }
 890                         else if (append_to)
 891                                 {
 892                                 gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, nullptr, &kw_iter);
 893                                 }
 894                         else
 895                                 {
 896                                 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, nullptr);
 897                                 append_to = TRUE;
 898                                 kw_iter = add;
 899                                 }
 900                         keyword_set(GTK_TREE_STORE(keyword_tree), &add, static_cast<const gchar *>(work->data), cdd->is_keyword);
 901                         work = work->next;
 902                         }
 903                 }
 904         g_list_free_full(keywords, g_free);
 905 }
 906
 907 static void bar_pane_keywords_conf_set_helper(GtkWidget *, gpointer data)
 908 {
 909         auto cdd = static_cast<ConfDialogData *>(data);
 910         cdd->is_keyword = FALSE;
 911 }
 912
 913 static void bar_pane_keywords_conf_set_kw(GtkWidget *, gpointer data)
 914 {
 915         auto cdd = static_cast<ConfDialogData *>(data);
 916         cdd->is_keyword = TRUE;
 917 }
 918
 919
 920
 921 static void bar_pane_keywords_edit_dialog(PaneKeywordsData *pkd, gboolean edit_existing)
 922 {
 923         ConfDialogData *cdd;
 924         GenericDialog *gd;
 925         GtkWidget *table;
 926         GtkWidget *group;
 927         GtkWidget *button;
 928
 929         gchar *name = nullptr;
 930         gboolean is_keyword = TRUE;
 931
 932
 933         if (edit_existing && pkd->click_tpath)
 934                 {
 935                 GtkTreeModel *model;
 936                 GtkTreeIter iter;
 937                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 938
 939                 if (gtk_tree_model_get_iter(model, &iter, pkd->click_tpath))
 940                         {
 941                         gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name,
 942                                                          FILTER_KEYWORD_COLUMN_IS_KEYWORD, &is_keyword, -1);
 943                         }
 944                 else
 945                         {
 946                         return;
 947                         }
 948                 }
 949
 950         if (edit_existing && !name) return;
 951
 952
 953         cdd = g_new0(ConfDialogData, 1);
 954         cdd->pkd =pkd;
 955         cdd->click_tpath = pkd->click_tpath;
 956         pkd->click_tpath = nullptr;
 957         cdd->edit_existing = edit_existing;
 958
 959         cdd->gd = gd = generic_dialog_new(name ? _("Edit keyword") : _("New keyword"), "keyword_edit",
 960                                 pkd->widget, TRUE,
 961                                 bar_pane_keywords_edit_cancel_cb, cdd);
 962         g_signal_connect(G_OBJECT(gd->dialog), "destroy",
 963                          G_CALLBACK(bar_pane_keywords_edit_destroy_cb), cdd);
 964
 965
 966         generic_dialog_add_message(gd, nullptr, name ? _("Configure keyword") : _("New keyword"), nullptr, FALSE);
 967
 968         generic_dialog_add_button(gd, GQ_ICON_OK, "OK",
 969                                   bar_pane_keywords_edit_ok_cb, TRUE);
 970
 971         table = pref_table_new(gd->vbox, 3, 1, FALSE, TRUE);
 972         pref_table_label(table, 0, 0, _("Keyword:"), GTK_ALIGN_END);
 973         cdd->edit_widget = gtk_entry_new();
 974         gtk_widget_set_size_request(cdd->edit_widget, 300, -1);
 975         if (name) gq_gtk_entry_set_text(GTK_ENTRY(cdd->edit_widget), name);
 976         gq_gtk_grid_attach_default(GTK_GRID(table), cdd->edit_widget, 1, 2, 0, 1);
 977         /* here could eventually be a text view instead of entry */
 978         generic_dialog_attach_default(gd, cdd->edit_widget);
 979         gtk_widget_show(cdd->edit_widget);
 980
 981         group = pref_group_new(gd->vbox, FALSE, _("Keyword type:"), GTK_ORIENTATION_VERTICAL);
 982
 983         button = pref_radiobutton_new(group, nullptr, _("Active keyword"),
 984                                       (is_keyword),
 985                                       G_CALLBACK(bar_pane_keywords_conf_set_kw), cdd);
 986         button = pref_radiobutton_new(group, button, _("Helper"),
 987                                       (!is_keyword),
 988                                       G_CALLBACK(bar_pane_keywords_conf_set_helper), cdd);
 989
 990         cdd->is_keyword = is_keyword;
 991
 992         g_free(name);
 993
 994         gtk_widget_grab_focus(cdd->edit_widget);
 995
 996         gtk_widget_show(gd->dialog);
 997 }
 998
 999
1000
1001
1002 /*
1003  *-------------------------------------------------------------------
1004  * popup menu
1005  *-------------------------------------------------------------------
1006  */
1007
1008 static void bar_pane_keywords_edit_dialog_cb(GtkWidget *, gpointer data)
1009 {
1010         auto pkd = static_cast<PaneKeywordsData *>(data);
1011         bar_pane_keywords_edit_dialog(pkd, TRUE);
1012 }
1013
1014 static void bar_pane_keywords_add_dialog_cb(GtkWidget *, gpointer data)
1015 {
1016         auto pkd = static_cast<PaneKeywordsData *>(data);
1017         bar_pane_keywords_edit_dialog(pkd, FALSE);
1018 }
1019
1020 static void bar_pane_keywords_connect_mark_cb(GtkWidget *menu_widget, gpointer data)
1021 {
1022         auto pkd = static_cast<PaneKeywordsData *>(data);
1023
1024         GtkTreeModel *model;
1025         GtkTreeIter iter;
1026
1027         GtkTreeModel *keyword_tree;
1028         GtkTreeIter kw_iter;
1029
1030         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu_widget), "mark")) - 1;
1031
1032         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1033         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1034
1035         if (!pkd->click_tpath) return;
1036         if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1037
1038         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
1039
1040         meta_data_connect_mark_with_keyword(keyword_tree, &kw_iter, mark);
1041 }
1042
1043 static void bar_pane_keywords_disconnect_marks_ok_cb(GenericDialog *, gpointer)
1044 {
1045         keyword_tree_disconnect_marks();
1046 }
1047
1048 static void dummy_cancel_cb(GenericDialog *, gpointer)
1049 {
1050         /* no op, only so cancel button appears */
1051 }
1052
1053 static void bar_pane_keywords_disconnect_marks_cb(GtkWidget *menu_widget, gpointer data)
1054 {
1055         auto pkd = static_cast<PaneKeywordsData *>(data);
1056
1057         GenericDialog *gd;
1058
1059         gd = generic_dialog_new(_("Marks Keywords"),
1060                                 "marks_keywords", menu_widget, TRUE, dummy_cancel_cb, pkd);
1061         generic_dialog_add_message(gd, GQ_ICON_DIALOG_WARNING,
1062                                 "Disconnect all Marks Keywords connections?", _("This will disconnect all Marks Keywords connections"), TRUE);
1063         generic_dialog_add_button(gd, GQ_ICON_OK, "OK", bar_pane_keywords_disconnect_marks_ok_cb, TRUE);
1064
1065         gtk_widget_show(gd->dialog);
1066 }
1067
1068 static void bar_pane_keywords_delete_cb(GtkWidget *, gpointer data)
1069 {
1070         auto pkd = static_cast<PaneKeywordsData *>(data);
1071         GtkTreeModel *model;
1072         GtkTreeIter iter;
1073
1074         GtkTreeModel *keyword_tree;
1075         GtkTreeIter kw_iter;
1076
1077         if (!pkd->click_tpath) return;
1078
1079         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1080         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1081
1082         if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1083         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
1084
1085         keyword_delete(GTK_TREE_STORE(keyword_tree), &kw_iter);
1086 }
1087
1088 static void bar_pane_keywords_hide_cb(GtkWidget *, gpointer data)
1089 {
1090         auto pkd = static_cast<PaneKeywordsData *>(data);
1091         GtkTreeModel *model;
1092         GtkTreeIter iter;
1093
1094         GtkTreeModel *keyword_tree;
1095         GtkTreeIter kw_iter;
1096
1097         if (!pkd->click_tpath) return;
1098
1099         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1100         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1101
1102         if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1103         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
1104
1105         keyword_hide_in(GTK_TREE_STORE(keyword_tree), &kw_iter, model);
1106 }
1107
1108 static void bar_pane_keywords_show_all_cb(GtkWidget *, gpointer data)
1109 {
1110         auto pkd = static_cast<PaneKeywordsData *>(data);
1111         GtkTreeModel *model;
1112
1113         GtkTreeModel *keyword_tree;
1114
1115         g_list_free_full(pkd->expanded_rows, g_free);
1116         pkd->expanded_rows = nullptr;
1117         gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(pkd->keyword_treeview),
1118                                                                 (bar_keyword_tree_get_expanded_cb), &pkd->expanded_rows);
1119
1120         pkd->hide_unchecked = FALSE;
1121
1122         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1123         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1124
1125         keyword_show_all_in(GTK_TREE_STORE(keyword_tree), model);
1126
1127         if (!pkd->collapse_unchecked) gtk_tree_view_expand_all(GTK_TREE_VIEW(pkd->keyword_treeview));
1128         bar_keyword_tree_sync(pkd);
1129 }
1130
1131 static void bar_pane_keywords_revert_cb(GtkWidget *, gpointer data)
1132 {
1133         auto pkd = static_cast<PaneKeywordsData *>(data);
1134         GList *work;
1135         GtkTreePath *tree_path;
1136         gchar *path;
1137
1138         gtk_tree_view_collapse_all(GTK_TREE_VIEW(pkd->keyword_treeview));
1139
1140         work = pkd->expanded_rows;
1141         while (work)
1142                 {
1143                 path = static_cast<gchar *>(work->data);
1144                 tree_path = gtk_tree_path_new_from_string(path);
1145                 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), tree_path);
1146                 work = work->next;
1147                 gtk_tree_path_free(tree_path);
1148                 }
1149
1150         bar_keyword_tree_sync(pkd);
1151 }
1152
1153 static void bar_pane_keywords_expand_checked_cb(GtkWidget *, gpointer data)
1154 {
1155         auto pkd = static_cast<PaneKeywordsData *>(data);
1156         GtkTreeModel *model;
1157
1158         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1159         gtk_tree_model_foreach(model, bar_keyword_tree_expand_if_set_cb, pkd);
1160 }
1161
1162 static void bar_pane_keywords_collapse_all_cb(GtkWidget *, gpointer data)
1163 {
1164         auto pkd = static_cast<PaneKeywordsData *>(data);
1165
1166         g_list_free_full(pkd->expanded_rows, g_free);
1167         pkd->expanded_rows = nullptr;
1168         gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(pkd->keyword_treeview),
1169                                                                 (bar_keyword_tree_get_expanded_cb), &pkd->expanded_rows);
1170
1171         gtk_tree_view_collapse_all(GTK_TREE_VIEW(pkd->keyword_treeview));
1172
1173         bar_keyword_tree_sync(pkd);
1174 }
1175
1176 static void bar_pane_keywords_revert_hidden_cb(GtkWidget *, gpointer data)
1177 {
1178         auto pkd = static_cast<PaneKeywordsData *>(data);
1179         GtkTreeModel *model;
1180         GtkTreeModel *keyword_tree;
1181
1182         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1183         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1184
1185         keyword_revert_hidden_in(GTK_TREE_STORE(keyword_tree), model);
1186
1187         bar_keyword_tree_sync(pkd);
1188 }
1189
1190 static void bar_pane_keywords_collapse_unchecked_cb(GtkWidget *, gpointer data)
1191 {
1192         auto pkd = static_cast<PaneKeywordsData *>(data);
1193         GtkTreeModel *model;
1194
1195         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1196         gtk_tree_model_foreach(model, bar_keyword_tree_collapse_if_unset_cb, pkd);
1197 }
1198
1199 static void bar_pane_keywords_hide_unchecked_cb(GtkWidget *, gpointer data)
1200 {
1201         auto pkd = static_cast<PaneKeywordsData *>(data);
1202         GtkTreeModel *model;
1203
1204         GtkTreeModel *keyword_tree;
1205         GList *keywords;
1206
1207         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1208         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1209
1210         keywords = keyword_list_pull(pkd->keyword_view);
1211         keyword_hide_unset_in(GTK_TREE_STORE(keyword_tree), model, keywords);
1212         g_list_free_full(keywords, g_free);
1213         bar_keyword_tree_sync(pkd);
1214 }
1215
1216 static void bar_pane_keywords_expand_checked_toggle_cb(GtkWidget *, gpointer data)
1217 {
1218         auto pkd = static_cast<PaneKeywordsData *>(data);
1219         pkd->expand_checked = !pkd->expand_checked;
1220         bar_keyword_tree_sync(pkd);
1221 }
1222
1223 static void bar_pane_keywords_collapse_unchecked_toggle_cb(GtkWidget *, gpointer data)
1224 {
1225         auto pkd = static_cast<PaneKeywordsData *>(data);
1226         pkd->collapse_unchecked = !pkd->collapse_unchecked;
1227         bar_keyword_tree_sync(pkd);
1228 }
1229
1230 static void bar_pane_keywords_hide_unchecked_toggle_cb(GtkWidget *, gpointer data)
1231 {
1232         auto pkd = static_cast<PaneKeywordsData *>(data);
1233         pkd->hide_unchecked = !pkd->hide_unchecked;
1234         bar_keyword_tree_sync(pkd);
1235 }
1236
1237 /**
1238  * @brief Callback for adding selected keyword to all selected images.
1239  */
1240 static void bar_pane_keywords_add_to_selected_cb(GtkWidget *, gpointer data)
1241 {
1242         auto pkd = static_cast<PaneKeywordsData *>(data);
1243         GtkTreeIter iter; /* This is the iter which initial holds the current keyword */
1244         GtkTreeIter child_iter;
1245         GtkTreeModel *model;
1246         GtkTreeModel *keyword_tree;
1247         GList *list;
1248         GList *work;
1249         GList *keywords = nullptr;
1250
1251         GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
1252
1253         /* Acquire selected keyword */
1254         if (pkd->click_tpath)
1255                 {
1256                 gboolean is_keyword = TRUE;
1257
1258                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1259                 if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1260                 gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_IS_KEYWORD, &is_keyword, -1);
1261                 if (!is_keyword) return;
1262                 }
1263         else
1264                 return;
1265
1266         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1267         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
1268
1269         list = keyword_list_pull(pkd->keyword_view); /* Get the left keyword view */
1270
1271         /* Now set the current image */
1272         keyword_tree_set(keyword_tree, &child_iter, &list);
1273
1274         keyword_list_push(pkd->keyword_view, list); /* Set the left keyword view */
1275         g_list_free_full(list, g_free);
1276
1277         bar_pane_keywords_changed(keyword_buffer, pkd); /* Get list of all keywords in the hierarchy */
1278
1279         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
1280         keywords = keyword_tree_get(keyword_tree, &child_iter);
1281
1282         list = layout_selection_list(pkd->pane.lw);
1283         work = list;
1284         while (work)
1285                 {
1286                 auto fd = static_cast<FileData *>(work->data);
1287                 work = work->next;
1288                 metadata_append_list(fd, KEYWORD_KEY, keywords);
1289                 }
1290         filelist_free(list);
1291         g_list_free_full(keywords, g_free);
1292 }
1293
1294 static void bar_pane_keywords_menu_popup(GtkWidget *, PaneKeywordsData *pkd, gint x, gint y)
1295 {
1296         GtkWidget *menu;
1297         GtkWidget *item;
1298         GtkWidget *submenu;
1299         GtkTreeViewDropPosition pos;
1300
1301         if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);
1302         pkd->click_tpath = nullptr;
1303         gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(pkd->keyword_treeview), x, y, &pkd->click_tpath, &pos);
1304
1305         menu = popup_menu_short_lived();
1306
1307         menu_item_add_icon(menu, _("New keyword"), GQ_ICON_NEW, G_CALLBACK(bar_pane_keywords_add_dialog_cb), pkd);
1308
1309         menu_item_add_divider(menu);
1310
1311         if (pkd->click_tpath)
1312                 {
1313                 /* for the entry */
1314                 gchar *text;
1315                 gchar *mark;
1316                 gint i;
1317                 gboolean keyword;
1318
1319                 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1320
1321                 GtkTreeIter iter;
1322                 gtk_tree_model_get_iter(model, &iter, pkd->click_tpath);
1323                 gchar *name;
1324
1325                 gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name,
1326                                                 FILTER_KEYWORD_COLUMN_MARK, &mark,
1327                                                 FILTER_KEYWORD_COLUMN_IS_KEYWORD, &keyword, -1);
1328
1329                 if (keyword)
1330                         {
1331                         text = g_strdup_printf(_("Add \"%s\" to all selected images"), name);
1332                         menu_item_add_icon(menu, text, GQ_ICON_ADD, G_CALLBACK(bar_pane_keywords_add_to_selected_cb), pkd);
1333                         g_free(text);
1334                         }
1335                 menu_item_add_divider(menu);
1336
1337                 text = g_strdup_printf(_("Hide \"%s\""), name);
1338                 menu_item_add(menu, text, G_CALLBACK(bar_pane_keywords_hide_cb), pkd);
1339                 g_free(text);
1340
1341                 submenu = gtk_menu_new();
1342                 for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
1343                         {
1344                         text = g_strdup_printf(_("Mark %d"), 1 + (i < 9 ? i : -1));
1345                         item = menu_item_add(submenu, text, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
1346                         g_object_set_data(G_OBJECT(item), "mark", GINT_TO_POINTER(i + 1));
1347                         g_free(text);
1348                         }
1349
1350                 if (keyword)
1351                         {
1352                         text = g_strdup_printf(_("Connect \"%s\" to mark"), name);
1353                         item = menu_item_add(menu, text, nullptr, nullptr);
1354                         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
1355                         g_free(text);
1356                         }
1357                 menu_item_add_divider(menu);
1358
1359                 text = g_strdup_printf(_("Edit \"%s\""), name);
1360                 menu_item_add_icon(menu, text, GQ_ICON_EDIT, G_CALLBACK(bar_pane_keywords_edit_dialog_cb), pkd);
1361                 g_free(text);
1362                 text = g_strdup_printf(_("Remove \"%s\""), name);
1363                 menu_item_add_icon(menu, text, GQ_ICON_DELETE, G_CALLBACK(bar_pane_keywords_delete_cb), pkd);
1364                 g_free(text);
1365
1366
1367                 if (mark && mark[0])
1368                         {
1369                         text = g_strdup_printf(_("Disconnect \"%s\" from mark %s"), name, mark);
1370                         menu_item_add_icon(menu, text, GQ_ICON_DELETE, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
1371                         g_free(text);
1372                         }
1373
1374                 if (keyword)
1375                         {
1376                         text = g_strdup_printf(_("Disconnect all Mark Keyword connections"));
1377                         menu_item_add_icon(menu, text, GQ_ICON_DELETE, G_CALLBACK(bar_pane_keywords_disconnect_marks_cb), pkd);
1378                         g_free(text);
1379                         }
1380                 menu_item_add_divider(menu);
1381                 g_free(mark);
1382                 g_free(name);
1383                 }
1384         /* for the pane */
1385
1386
1387         menu_item_add(menu, _("Expand checked"), G_CALLBACK(bar_pane_keywords_expand_checked_cb), pkd);
1388         menu_item_add(menu, _("Collapse unchecked"), G_CALLBACK(bar_pane_keywords_collapse_unchecked_cb), pkd);
1389         menu_item_add(menu, _("Hide unchecked"), G_CALLBACK(bar_pane_keywords_hide_unchecked_cb), pkd);
1390         menu_item_add(menu, _("Revert all hidden"), G_CALLBACK(bar_pane_keywords_revert_hidden_cb), pkd);
1391         menu_item_add_divider(menu);
1392         menu_item_add(menu, _("Show all"), G_CALLBACK(bar_pane_keywords_show_all_cb), pkd);
1393         menu_item_add(menu, _("Collapse all"), G_CALLBACK(bar_pane_keywords_collapse_all_cb), pkd);
1394         menu_item_add(menu, _("Revert"), G_CALLBACK(bar_pane_keywords_revert_cb), pkd);
1395         menu_item_add_divider(menu);
1396
1397         submenu = gtk_menu_new();
1398         item = menu_item_add(menu, _("On any change"), nullptr, nullptr);
1399         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
1400
1401         menu_item_add_check(submenu, _("Expand checked"), pkd->expand_checked, G_CALLBACK(bar_pane_keywords_expand_checked_toggle_cb), pkd);
1402         menu_item_add_check(submenu, _("Collapse unchecked"), pkd->collapse_unchecked, G_CALLBACK(bar_pane_keywords_collapse_unchecked_toggle_cb), pkd);
1403         menu_item_add_check(submenu, _("Hide unchecked"), pkd->hide_unchecked, G_CALLBACK(bar_pane_keywords_hide_unchecked_toggle_cb), pkd);
1404
1405         gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
1406 }
1407
1408
1409 static gboolean bar_pane_keywords_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1410 {
1411         auto pkd = static_cast<PaneKeywordsData *>(data);
1412         if (bevent->button == MOUSE_BUTTON_RIGHT)
1413                 {
1414                 bar_pane_keywords_menu_popup(widget, pkd, bevent->x, bevent->y);
1415                 return TRUE;
1416                 }
1417         return FALSE;
1418 }
1419
1420 /*
1421  *-------------------------------------------------------------------
1422  * init
1423  *-------------------------------------------------------------------
1424  */
1425
1426 #pragma GCC diagnostic push
1427 #pragma GCC diagnostic ignored "-Wunused-function"
1428 void bar_pane_keywords_close_unused(GtkWidget *bar)
1429 {
1430         PaneKeywordsData *pkd;
1431
1432         pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(bar), "pane_data"));
1433         if (!pkd) return;
1434
1435         g_free(pkd->pane.id);
1436         g_object_unref(pkd->widget);
1437 }
1438 #pragma GCC diagnostic pop
1439
1440 static void bar_pane_keywords_destroy(GtkWidget *, gpointer data)
1441 {
1442         auto pkd = static_cast<PaneKeywordsData *>(data);
1443         gchar *path;
1444
1445         path = g_build_filename(get_rc_dir(), "keywords", NULL);
1446         autocomplete_keywords_list_save(path);
1447
1448         g_list_free_full(pkd->expanded_rows, g_free);
1449         if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);
1450         if (pkd->idle_id) g_source_remove(pkd->idle_id);
1451         file_data_unregister_notify_func(bar_pane_keywords_notify_cb, pkd);
1452
1453         file_data_unref(pkd->fd);
1454         g_free(pkd->key);
1455
1456         g_free(pkd);
1457 }
1458
1459
1460 static GtkWidget *bar_pane_keywords_new(const gchar *id, const gchar *title, const gchar *key, gboolean expanded, gint height)
1461 {
1462         PaneKeywordsData *pkd;
1463         GtkWidget *hbox;
1464         GtkWidget *vbox;
1465         GtkWidget *scrolled;
1466         GtkTextBuffer *buffer;
1467         GtkTreeModel *store;
1468         GtkTreeViewColumn *column;
1469         GtkCellRenderer *renderer;
1470         GtkTreeIter iter;
1471         GtkEntryCompletion *completion;
1472         gchar *path;
1473
1474         pkd = g_new0(PaneKeywordsData, 1);
1475
1476         pkd->pane.pane_set_fd = bar_pane_keywords_set_fd;
1477         pkd->pane.pane_event = bar_pane_keywords_event;
1478         pkd->pane.pane_write_config = bar_pane_keywords_write_config;
1479         pkd->pane.title = bar_pane_expander_title(title);
1480         pkd->pane.id = g_strdup(id);
1481         pkd->pane.type = PANE_KEYWORDS;
1482
1483         pkd->pane.expanded = expanded;
1484
1485         pkd->height = height;
1486         pkd->key = g_strdup(key);
1487
1488         pkd->expand_checked = TRUE;
1489         pkd->expanded_rows = nullptr;
1490
1491         vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
1492         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
1493         gq_gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
1494
1495         pkd->widget = vbox;
1496         g_object_set_data(G_OBJECT(pkd->widget), "pane_data", pkd);
1497         g_signal_connect(G_OBJECT(pkd->widget), "destroy",
1498                          G_CALLBACK(bar_pane_keywords_destroy), pkd);
1499         gtk_widget_set_size_request(pkd->widget, -1, height);
1500         gtk_widget_show(hbox);
1501
1502         scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
1503         gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
1504         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
1505                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1506         gq_gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
1507         gtk_widget_show(scrolled);
1508
1509         pkd->keyword_view = gtk_text_view_new();
1510         gq_gtk_container_add(GTK_WIDGET(scrolled), pkd->keyword_view);
1511         g_signal_connect(G_OBJECT(pkd->keyword_view), "populate-popup",
1512                          G_CALLBACK(bar_pane_keywords_populate_popup_cb), pkd);
1513         gtk_widget_show(pkd->keyword_view);
1514
1515         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
1516         g_signal_connect(G_OBJECT(buffer), "changed",
1517                          G_CALLBACK(bar_pane_keywords_changed), pkd);
1518
1519         if (options->show_predefined_keyword_tree)
1520                 {
1521                 scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
1522                 gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
1523                 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
1524                                                 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1525                 gq_gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
1526                 gtk_widget_show(scrolled);
1527                 }
1528
1529         pkd->autocomplete = gtk_entry_new();
1530         gq_gtk_box_pack_end(GTK_BOX(vbox), pkd->autocomplete, FALSE, FALSE, 0);
1531         gtk_widget_show(pkd->autocomplete);
1532         gtk_widget_show(vbox);
1533         gtk_widget_set_tooltip_text(pkd->autocomplete, "Keyword autocomplete");
1534
1535         path = g_build_filename(get_rc_dir(), "keywords", NULL);
1536         autocomplete_keywords_list_load(path);
1537
1538         completion = gtk_entry_completion_new();
1539         gtk_entry_set_completion(GTK_ENTRY(pkd->autocomplete), completion);
1540         gtk_entry_completion_set_inline_completion(completion, TRUE);
1541         gtk_entry_completion_set_inline_selection(completion, TRUE);
1542         g_object_unref(completion);
1543
1544         gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(keyword_store));
1545         gtk_entry_completion_set_text_column(completion, 0);
1546
1547         g_signal_connect(G_OBJECT(pkd->autocomplete), "activate",
1548                          G_CALLBACK(autocomplete_activate_cb), pkd);
1549
1550         if (!keyword_tree || !gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_tree), &iter))
1551                 {
1552                 /* keyword tree does not exist or is empty - fill with defaults */
1553                 keyword_tree_new_default();
1554                 }
1555
1556         store = gtk_tree_model_filter_new(GTK_TREE_MODEL(keyword_tree), nullptr);
1557
1558         gtk_tree_model_filter_set_modify_func(GTK_TREE_MODEL_FILTER(store),
1559                                               FILTER_KEYWORD_COLUMN_COUNT,
1560                                               filter_keyword_column_types,
1561                                               bar_pane_keywords_filter_modify,
1562                                               pkd,
1563                                               nullptr);
1564         gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(store),
1565                                                bar_pane_keywords_filter_visible,
1566                                                store,
1567                                                nullptr);
1568
1569         pkd->keyword_treeview = gtk_tree_view_new_with_model(store);
1570         g_object_unref(store);
1571
1572         gtk_widget_set_size_request(pkd->keyword_treeview, -1, 400);
1573
1574         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(pkd->keyword_treeview), FALSE);
1575
1576         column = gtk_tree_view_column_new();
1577         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1578
1579         renderer = gtk_cell_renderer_text_new();
1580         gtk_tree_view_column_pack_start(column, renderer, TRUE);
1581
1582         gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_MARK);
1583
1584         gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
1585
1586         column = gtk_tree_view_column_new();
1587         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
1588         renderer = gtk_cell_renderer_toggle_new();
1589         gtk_tree_view_column_pack_start(column, renderer, FALSE);
1590         gtk_tree_view_column_add_attribute(column, renderer, "active", FILTER_KEYWORD_COLUMN_TOGGLE);
1591         gtk_tree_view_column_add_attribute(column, renderer, "visible", FILTER_KEYWORD_COLUMN_IS_KEYWORD);
1592         g_signal_connect(G_OBJECT(renderer), "toggled",
1593                          G_CALLBACK(bar_pane_keywords_keyword_toggle), pkd);
1594
1595         renderer = gtk_cell_renderer_text_new();
1596         gtk_tree_view_column_pack_start(column, renderer, TRUE);
1597         gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_NAME);
1598
1599         gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
1600         gtk_tree_view_set_expander_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
1601
1602         gtk_drag_source_set(pkd->keyword_treeview,
1603                             static_cast<GdkModifierType>(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK),
1604                             bar_pane_keywords_drag_types, n_keywords_drag_types,
1605                             static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK));
1606
1607         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_get",
1608                          G_CALLBACK(bar_pane_keywords_dnd_get), pkd);
1609
1610         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_begin",
1611                          G_CALLBACK(bar_pane_keywords_dnd_begin), pkd);
1612         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_end",
1613                          G_CALLBACK(bar_pane_keywords_dnd_end), pkd);
1614
1615         gtk_drag_dest_set(pkd->keyword_treeview,
1616                           static_cast<GtkDestDefaults>(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP),
1617                           bar_pane_keywords_drop_types, n_keywords_drop_types,
1618                           static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE));
1619
1620         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_received",
1621                          G_CALLBACK(bar_pane_keywords_dnd_receive), pkd);
1622
1623         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_motion",
1624                          G_CALLBACK(bar_pane_keywords_dnd_motion), pkd);
1625
1626         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "button_release_event",
1627                          G_CALLBACK(bar_pane_keywords_menu_cb), pkd);
1628
1629         if (options->show_predefined_keyword_tree)
1630                 {
1631                 gq_gtk_container_add(GTK_WIDGET(scrolled), pkd->keyword_treeview);
1632                 gtk_widget_show(pkd->keyword_treeview);
1633                 }
1634
1635         file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW);
1636
1637         return pkd->widget;
1638 }
1639
1640 GtkWidget *bar_pane_keywords_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
1641 {
1642         gchar *id = g_strdup("keywords");
1643         gchar *title = nullptr;
1644         gchar *key = g_strdup(COMMENT_KEY);
1645         gboolean expanded = TRUE;
1646         gint height = 200;
1647         GtkWidget *ret;
1648
1649         while (*attribute_names)
1650                 {
1651                 const gchar *option = *attribute_names++;
1652                 const gchar *value = *attribute_values++;
1653
1654                 if (READ_CHAR_FULL("id", id)) continue;
1655                 if (READ_CHAR_FULL("title", title)) continue;
1656                 if (READ_CHAR_FULL("key", key)) continue;
1657                 if (READ_BOOL_FULL("expanded", expanded)) continue;
1658                 if (READ_INT_FULL("height", height)) continue;
1659
1660
1661                 log_printf("unknown attribute %s = %s\n", option, value);
1662                 }
1663
1664         options->info_keywords.height = height;
1665         bar_pane_translate_title(PANE_KEYWORDS, id, &title);
1666         ret = bar_pane_keywords_new(id, title, key, expanded, height);
1667         g_free(id);
1668         g_free(title);
1669         g_free(key);
1670         return ret;
1671 }
1672
1673 void bar_pane_keywords_update_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
1674 {
1675         PaneKeywordsData *pkd;
1676
1677         pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
1678         if (!pkd) return;
1679
1680         gchar *title = nullptr;
1681
1682         while (*attribute_names)
1683                 {
1684                 const gchar *option = *attribute_names++;
1685                 const gchar *value = *attribute_values++;
1686
1687                 if (READ_CHAR_FULL("title", title)) continue;
1688                 if (READ_CHAR_FULL("key", pkd->key)) continue;
1689                 if (READ_BOOL_FULL("expanded", pkd->pane.expanded)) continue;
1690                 if (READ_CHAR_FULL("id", pkd->pane.id)) continue;
1691
1692
1693                 log_printf("unknown attribute %s = %s\n", option, value);
1694                 }
1695
1696         if (title)
1697                 {
1698                 bar_pane_translate_title(PANE_KEYWORDS, pkd->pane.id, &title);
1699                 gtk_label_set_text(GTK_LABEL(pkd->pane.title), title);
1700                 g_free(title);
1701                 }
1702
1703         bar_update_expander(pane);
1704         bar_pane_keywords_update(pkd);
1705 }
1706
1707
1708 void bar_pane_keywords_entry_add_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
1709 {
1710         PaneKeywordsData *pkd;
1711         gchar *path = nullptr;
1712         GtkTreePath *tree_path;
1713
1714         pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
1715         if (!pkd) return;
1716
1717         while (*attribute_names)
1718                 {
1719                 const gchar *option = *attribute_names++;
1720                 const gchar *value = *attribute_values++;
1721
1722                 if (READ_CHAR_FULL("path", path))
1723                         {
1724                         tree_path = gtk_tree_path_new_from_string(path);
1725                         gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), tree_path);
1726                         gtk_tree_path_free(tree_path);
1727                         pkd->expanded_rows = g_list_append(pkd->expanded_rows, g_strdup(path));
1728                         continue;
1729                         }
1730                 log_printf("unknown attribute %s = %s\n", option, value);
1731                 }
1732 }
1733
1734 /*
1735  *-----------------------------------------------------------------------------
1736  * Autocomplete keywords
1737  *-----------------------------------------------------------------------------
1738  */
1739
1740 static gboolean autocomplete_activate_cb(GtkWidget *, gpointer data)
1741 {
1742         auto pkd = static_cast<PaneKeywordsData *>(data);
1743         gchar *entry_text;
1744         GtkTextBuffer *buffer;
1745         GtkTextIter iter;
1746         GtkTreeIter iter_t;
1747         gchar *kw_cr;
1748         gchar *kw_split;
1749         gboolean valid;
1750         gboolean found = FALSE;
1751         gchar *string;
1752
1753         entry_text = g_strdup(gq_gtk_entry_get_text(GTK_ENTRY(pkd->autocomplete)));
1754         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
1755
1756         kw_split = strtok(entry_text, ",");
1757         while (kw_split != nullptr)
1758                 {
1759                 kw_cr = g_strconcat(kw_split, "\n", NULL);
1760                 g_strchug(kw_cr);
1761                 gtk_text_buffer_get_end_iter(buffer, &iter);
1762                 gtk_text_buffer_insert(buffer, &iter, kw_cr, -1);
1763
1764                 kw_split = strtok(nullptr, ",");
1765                 g_free(kw_cr);
1766                 }
1767
1768         g_free(entry_text);
1769         entry_text = g_strdup(gq_gtk_entry_get_text(GTK_ENTRY(pkd->autocomplete)));
1770
1771         gq_gtk_entry_set_text(GTK_ENTRY(pkd->autocomplete), "");
1772
1773         valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_store), &iter_t);
1774         while (valid)
1775                 {
1776                 gtk_tree_model_get (GTK_TREE_MODEL(keyword_store), &iter_t, 0, &string, -1);
1777                 if (g_strcmp0(entry_text, string) == 0)
1778                         {
1779                         found = TRUE;
1780                         break;
1781                         }
1782                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(keyword_store), &iter_t);
1783                 }
1784
1785         if (!found)
1786                 {
1787                 gtk_list_store_append (keyword_store, &iter_t);
1788                 gtk_list_store_set(keyword_store, &iter_t, 0, entry_text, -1);
1789                 }
1790
1791         g_free(entry_text);
1792         return FALSE;
1793 }
1794
1795 static gint autocomplete_sort_iter_compare_func (GtkTreeModel *model,
1796                                                                         GtkTreeIter *a,
1797                                                                         GtkTreeIter *b,
1798                                                                         gpointer)
1799 {
1800         gint ret = 0;
1801         gchar *name1;
1802         gchar *name2;
1803
1804         gtk_tree_model_get(model, a, 0, &name1, -1);
1805         gtk_tree_model_get(model, b, 0, &name2, -1);
1806
1807         if (name1 == nullptr || name2 == nullptr)
1808                 {
1809                 if (name1 == nullptr && name2 == nullptr)
1810                         {
1811                         ret = 0;
1812                         }
1813                 else
1814                         {
1815                         ret = (name1 == nullptr) ? -1 : 1;
1816                         }
1817                 }
1818         else
1819                 {
1820                 ret = g_utf8_collate(name1,name2);
1821                 }
1822
1823         g_free(name1);
1824         g_free(name2);
1825
1826         return ret;
1827 }
1828
1829 static void autocomplete_keywords_list_load(const gchar *path)
1830 {
1831         FILE *f;
1832         gchar s_buf[1024];
1833         gchar *pathl;
1834         gint len;
1835         GtkTreeIter iter;
1836         GtkTreeSortable *sortable;
1837
1838         if (keyword_store) return;
1839         keyword_store = gtk_list_store_new(1, G_TYPE_STRING);
1840
1841         sortable = GTK_TREE_SORTABLE(keyword_store);
1842         gtk_tree_sortable_set_sort_func(sortable, 0, autocomplete_sort_iter_compare_func,
1843                                                                                                 GINT_TO_POINTER(0), nullptr);
1844
1845         gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_ASCENDING);
1846
1847         pathl = path_from_utf8(path);
1848         f = fopen(pathl, "r");
1849
1850         if (!f)
1851                 {
1852                 log_printf("Warning: keywords file %s not loaded", pathl);
1853                 g_free(pathl);
1854                 return;
1855                 }
1856
1857         /* first line must start with Keywords comment */
1858         if (!fgets(s_buf, sizeof(s_buf), f) ||
1859                                         strncmp(s_buf, "#Keywords", 9) != 0)
1860                 {
1861                 fclose(f);
1862                 log_printf("Warning: keywords file %s not loaded", pathl);
1863                 g_free(pathl);
1864                 return;
1865                 }
1866
1867         g_free(pathl);
1868
1869         while (fgets(s_buf, sizeof(s_buf), f))
1870                 {
1871                 if (s_buf[0]=='#') continue;
1872
1873                 len = strlen(s_buf);
1874                 if( s_buf[len-1] == '\n' )
1875                         {
1876                         s_buf[len-1] = 0;
1877                         }
1878                 gtk_list_store_append (keyword_store, &iter);
1879                 gtk_list_store_set(keyword_store, &iter, 0, g_strdup(s_buf), -1);
1880                 }
1881
1882         fclose(f);
1883 }
1884
1885 static gboolean autocomplete_keywords_list_save(gchar *path)
1886 {
1887         SecureSaveInfo *ssi;
1888         gchar *pathl;
1889         gchar *string;
1890         gchar *string_nl;
1891         GtkTreeIter  iter;
1892         gboolean     valid;
1893
1894         pathl = path_from_utf8(path);
1895         ssi = secure_open(pathl);
1896         g_free(pathl);
1897
1898         if (!ssi)
1899                 {
1900                 log_printf(_("Error: Unable to write keywords list to: %s\n"), path);
1901                 return FALSE;
1902                 }
1903
1904         secure_fprintf(ssi, "#Keywords list\n");
1905
1906         valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_store), &iter);
1907
1908         while (valid)
1909                 {
1910                 gtk_tree_model_get (GTK_TREE_MODEL(keyword_store), &iter, 0, &string, -1);
1911                 string_nl = g_strconcat(string, "\n", NULL);
1912                 secure_fprintf(ssi, "%s", string_nl);
1913
1914                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(keyword_store), &iter);
1915
1916                 g_free(string_nl);
1917                 }
1918
1919         secure_fprintf(ssi, "#end\n");
1920         return (secure_close(ssi) == 0);
1921 }
1922
1923 GList *keyword_list_get()
1924 {
1925         GList *ret_list = nullptr;
1926         gchar *string;
1927         gchar *string_nl;
1928         GtkTreeIter iter;
1929         gboolean valid;
1930
1931         if (keyword_store)
1932                 {
1933                 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_store), &iter);
1934
1935                 while (valid)
1936                         {
1937                         gtk_tree_model_get (GTK_TREE_MODEL(keyword_store), &iter, 0, &string, -1);
1938                         string_nl = g_strconcat(string, "\n", NULL);
1939                         ret_list = g_list_append(ret_list, string);
1940                         valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(keyword_store), &iter);
1941
1942                         g_free(string_nl);
1943                         }
1944                 }
1945
1946         return ret_list;
1947 }
1948
1949 void keyword_list_set(GList *keyword_list)
1950 {
1951         GtkTreeIter  iter;
1952
1953         if (!keyword_list) return;
1954
1955         if (keyword_store)
1956                 {
1957                 gtk_list_store_clear(keyword_store);
1958                 }
1959         else
1960                 {
1961                 keyword_store = gtk_list_store_new(1, G_TYPE_STRING);
1962                 }
1963
1964         while (keyword_list)
1965                 {
1966                 gtk_list_store_append (keyword_store, &iter);
1967                 gtk_list_store_set(keyword_store, &iter, 0, keyword_list->data, -1);
1968
1969                 keyword_list = keyword_list->next;
1970                 }
1971 }
1972
1973 gboolean bar_keywords_autocomplete_focus(LayoutWindow *lw)
1974 {
1975         GtkWidget *pane;
1976         GtkWidget *current_focus;
1977         GList *children;
1978         gboolean ret;
1979
1980         current_focus = gtk_window_get_focus(GTK_WINDOW(lw->window));
1981         pane = bar_find_pane_by_id(lw->bar, PANE_KEYWORDS, "keywords");
1982
1983         children = gtk_container_get_children(GTK_CONTAINER(pane));
1984         children = g_list_last(children);
1985
1986         if (current_focus == children->data)
1987                 {
1988                 ret = TRUE;
1989                 }
1990         else
1991                 {
1992                 gtk_widget_grab_focus(GTK_WIDGET(children->data));
1993                 ret = FALSE;
1994                 }
1995
1996         g_list_free(children);
1997
1998         return ret;
1999 }
2000 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */