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