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 "main.h"
  23 #include "bar-keywords.h"
  24
  25 #include "filedata.h"
  26 #include "metadata.h"
  27 #include "ui-fileops.h"
  28 #include "ui-misc.h"
  29 #include "ui-utildlg.h"
  30 #include "bar.h"
  31 #include "ui-menu.h"
  32 #include "rcfile.h"
  33 #include "layout.h"
  34 #include "dnd.h"
  35 #include "secure-save.h"
  36
  37
  38 //static void bar_pane_keywords_keyword_update_all(void);
  39 static void bar_pane_keywords_changed(GtkTextBuffer *buffer, gpointer data);
  40
  41 static void autocomplete_keywords_list_load(const gchar *path);
  42 static GtkListStore *keyword_store = NULL;
  43 static gboolean autocomplete_keywords_list_save(gchar *path);
  44 static gboolean autocomplete_activate_cb(GtkWidget *widget, gpointer data);
  45
  46 /*
  47  *-------------------------------------------------------------------
  48  * keyword / comment utils
  49  *-------------------------------------------------------------------
  50  */
  51
  52
  53 GList *keyword_list_pull(GtkWidget *text_widget)
  54 {
  55         GList *list;
  56         gchar *text;
  57
  58         text = text_widget_text_pull(text_widget);
  59         list = string_to_keywords_list(text);
  60
  61         g_free(text);
  62
  63         return list;
  64 }
  65
  66 static 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 static void keyword_list_push(GtkWidget *textview, GList *list)
  81 {
  82         GtkTextBuffer *buffer;
  83         GtkTextIter start, end;
  84
  85         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
  86         gtk_text_buffer_get_bounds(buffer, &start, &end);
  87         gtk_text_buffer_delete(buffer, &start, &end);
  88
  89         while (list)
  90                 {
  91                 const gchar *word = static_cast<const gchar *>(list->data);
  92                 GtkTextIter iter;
  93
  94                 gtk_text_buffer_get_end_iter(buffer, &iter);
  95                 if (word) gtk_text_buffer_insert(buffer, &iter, word, -1);
  96                 gtk_text_buffer_get_end_iter(buffer, &iter);
  97                 gtk_text_buffer_insert(buffer, &iter, "\n", -1);
  98
  99                 list = list->next;
 100                 }
 101 }
 102
 103
 104 /*
 105  *-------------------------------------------------------------------
 106  * info bar
 107  *-------------------------------------------------------------------
 108  */
 109
 110
 111 enum {
 112         FILTER_KEYWORD_COLUMN_TOGGLE = 0,
 113         FILTER_KEYWORD_COLUMN_MARK,
 114         FILTER_KEYWORD_COLUMN_NAME,
 115         FILTER_KEYWORD_COLUMN_IS_KEYWORD,
 116         FILTER_KEYWORD_COLUMN_COUNT
 117 };
 118
 119 static GType filter_keyword_column_types[] = {G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN};
 120
 121 typedef struct _PaneKeywordsData PaneKeywordsData;
 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 typedef struct _ConfDialogData ConfDialogData;
 147 struct _ConfDialogData
 148 {
 149         PaneKeywordsData *pkd;
 150         GtkTreePath *click_tpath;
 151
 152         /* dialog parts */
 153         GenericDialog *gd;
 154         GtkWidget *edit_widget;
 155         gboolean is_keyword;
 156
 157         gboolean edit_existing;
 158 };
 159
 160
 161 static void bar_pane_keywords_write(PaneKeywordsData *pkd)
 162 {
 163         GList *list;
 164
 165         if (!pkd->fd) return;
 166
 167         list = keyword_list_pull(pkd->keyword_view);
 168
 169         metadata_write_list(pkd->fd, KEYWORD_KEY, list);
 170
 171         string_list_free(list);
 172 }
 173
 174 gboolean bar_keyword_tree_expand_if_set_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
 175 {
 176         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
 177         gboolean set;
 178
 179         gtk_tree_model_get(model, iter, FILTER_KEYWORD_COLUMN_TOGGLE, &set, -1);
 180
 181         if (set && !gtk_tree_view_row_expanded(GTK_TREE_VIEW(pkd->keyword_treeview), path))
 182                 {
 183                 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), path);
 184                 }
 185         return FALSE;
 186 }
 187
 188 gboolean bar_keyword_tree_collapse_if_unset_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
 189 {
 190         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
 191         gboolean set;
 192
 193         gtk_tree_model_get(model, iter, FILTER_KEYWORD_COLUMN_TOGGLE, &set, -1);
 194
 195         if (!set && gtk_tree_view_row_expanded(GTK_TREE_VIEW(pkd->keyword_treeview), path))
 196                 {
 197                 gtk_tree_view_collapse_row(GTK_TREE_VIEW(pkd->keyword_treeview), path);
 198                 }
 199         return FALSE;
 200 }
 201
 202 static void bar_keyword_tree_sync(PaneKeywordsData *pkd)
 203 {
 204         GtkTreeModel *model;
 205
 206         GtkTreeModel *keyword_tree;
 207         GList *keywords;
 208
 209         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 210         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 211
 212         keywords = keyword_list_pull(pkd->keyword_view);
 213         keyword_show_set_in(GTK_TREE_STORE(keyword_tree), model, keywords);
 214         if (pkd->hide_unchecked) keyword_hide_unset_in(GTK_TREE_STORE(keyword_tree), model, keywords);
 215         string_list_free(keywords);
 216
 217         gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(model));
 218
 219         if (pkd->expand_checked) gtk_tree_model_foreach(model, bar_keyword_tree_expand_if_set_cb, pkd);
 220         if (pkd->collapse_unchecked) gtk_tree_model_foreach(model, bar_keyword_tree_collapse_if_unset_cb, pkd);
 221 }
 222
 223 static void bar_pane_keywords_update(PaneKeywordsData *pkd)
 224 {
 225         GList *keywords = NULL;
 226         GList *orig_keywords = NULL;
 227         GList *work1, *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         string_list_free(keywords);
 252         string_list_free(orig_keywords);
 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         GList **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 static 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 static void bar_pane_keywords_write_config(GtkWidget *pane, GString *outstr, gint indent)
 298 {
 299         PaneKeywordsData *pkd;
 300         GList *path_expanded = NULL;
 301         gint w, h;
 302
 303         pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
 304         if (!pkd) return;
 305
 306         gtk_widget_get_size_request(GTK_WIDGET(pane), &w, &h);
 307         pkd->height = h;
 308
 309         WRITE_NL(); WRITE_STRING("<pane_keywords ");
 310         write_char_option(outstr, indent, "id", pkd->pane.id);
 311         write_char_option(outstr, indent, "title", gtk_label_get_text(GTK_LABEL(pkd->pane.title)));
 312         WRITE_BOOL(pkd->pane, expanded);
 313         WRITE_CHAR(*pkd, key);
 314         WRITE_INT(*pkd, height);
 315         WRITE_STRING(">");
 316         indent++;
 317
 318         gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(pkd->keyword_treeview),
 319                                                                 (bar_keyword_tree_get_expanded_cb), &path_expanded);
 320
 321         g_list_first(path_expanded);
 322         while (path_expanded)
 323                 {
 324                 bar_pane_keywords_entry_write_config(static_cast<gchar *>(path_expanded->data), outstr, indent);
 325                 g_free(path_expanded->data);
 326                 path_expanded = path_expanded->next;
 327                 }
 328         g_list_free(path_expanded);
 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 static void bar_pane_keywords_keyword_toggle(GtkCellRendererToggle *UNUSED(toggle), const gchar *path, gpointer data)
 352 {
 353         PaneKeywordsData *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         string_list_free(list);
 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         PaneKeywordsData *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                         string_list_free(keywords);
 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         return;
 425
 426 }
 427
 428 gboolean bar_pane_keywords_filter_visible(GtkTreeModel *keyword_tree, GtkTreeIter *iter, gpointer data)
 429 {
 430         GtkTreeModel *filter = static_cast<GtkTreeModel *>(data);
 431
 432         return !keyword_is_hidden_in(keyword_tree, iter, filter);
 433 }
 434
 435 static void bar_pane_keywords_set_selection(PaneKeywordsData *pkd, gboolean append)
 436 {
 437         GList *keywords = NULL;
 438         GList *list = NULL;
 439         GList *work;
 440
 441         keywords = keyword_list_pull_selected(pkd->keyword_view);
 442
 443         list = layout_selection_list(pkd->pane.lw);
 444         list = file_data_process_groups_in_selection(list, FALSE, NULL);
 445
 446         work = list;
 447         while (work)
 448                 {
 449                 FileData *fd = static_cast<FileData *>(work->data);
 450                 work = work->next;
 451
 452                 if (append)
 453                         {
 454                         metadata_append_list(fd, KEYWORD_KEY, keywords);
 455                         }
 456                 else
 457                         {
 458                         metadata_write_list(fd, KEYWORD_KEY, keywords);
 459                         }
 460                 }
 461
 462         filelist_free(list);
 463         string_list_free(keywords);
 464 }
 465
 466 static void bar_pane_keywords_sel_add_cb(GtkWidget *UNUSED(button), gpointer data)
 467 {
 468         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
 469
 470         bar_pane_keywords_set_selection(pkd, TRUE);
 471 }
 472
 473 static void bar_pane_keywords_sel_replace_cb(GtkWidget *UNUSED(button), gpointer data)
 474 {
 475         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
 476
 477         bar_pane_keywords_set_selection(pkd, FALSE);
 478 }
 479
 480 static void bar_pane_keywords_populate_popup_cb(GtkTextView *UNUSED(textview), GtkMenu *menu, gpointer data)
 481 {
 482         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
 483
 484         menu_item_add_divider(GTK_WIDGET(menu));
 485         menu_item_add_stock(GTK_WIDGET(menu), _("Add selected keywords to selected files"), GTK_STOCK_ADD, G_CALLBACK(bar_pane_keywords_sel_add_cb), pkd);
 486         menu_item_add_stock(GTK_WIDGET(menu), _("Replace existing keywords in selected files with selected keywords"), GTK_STOCK_CONVERT, G_CALLBACK(bar_pane_keywords_sel_replace_cb), pkd);
 487 }
 488
 489
 490 static void bar_pane_keywords_notify_cb(FileData *fd, NotifyType type, gpointer data)
 491 {
 492         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
 493         if ((type & (NOTIFY_REREAD | NOTIFY_CHANGE | NOTIFY_METADATA)) && fd == pkd->fd)
 494                 {
 495                 DEBUG_1("Notify pane_keywords: %s %04x", fd->path, type);
 496                 bar_pane_keywords_update(pkd);
 497                 }
 498 }
 499
 500 static gboolean bar_pane_keywords_changed_idle_cb(gpointer data)
 501 {
 502         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
 503
 504         bar_pane_keywords_write(pkd);
 505         bar_keyword_tree_sync(pkd);
 506         pkd->idle_id = 0;
 507         return G_SOURCE_REMOVE;
 508 }
 509
 510 static void bar_pane_keywords_changed(GtkTextBuffer *UNUSED(buffer), gpointer data)
 511 {
 512         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
 513
 514         if (pkd->idle_id) return;
 515         /* higher prio than redraw */
 516         pkd->idle_id = g_idle_add_full(G_PRIORITY_HIGH_IDLE, bar_pane_keywords_changed_idle_cb, pkd, NULL);
 517 }
 518
 519
 520 /*
 521  *-------------------------------------------------------------------
 522  * dnd
 523  *-------------------------------------------------------------------
 524  */
 525
 526
 527 static GtkTargetEntry bar_pane_keywords_drag_types[] = {
 528         { const_cast<gchar *>(TARGET_APP_KEYWORD_PATH_STRING), GTK_TARGET_SAME_WIDGET, TARGET_APP_KEYWORD_PATH },
 529         { const_cast<gchar *>("text/plain"), 0, TARGET_TEXT_PLAIN }
 530 };
 531 static gint n_keywords_drag_types = 2;
 532
 533
 534 static GtkTargetEntry bar_pane_keywords_drop_types[] = {
 535         { const_cast<gchar *>(TARGET_APP_KEYWORD_PATH_STRING), GTK_TARGET_SAME_WIDGET, TARGET_APP_KEYWORD_PATH },
 536         { const_cast<gchar *>("text/plain"), 0, TARGET_TEXT_PLAIN }
 537 };
 538 static gint n_keywords_drop_types = 2;
 539
 540
 541 static void bar_pane_keywords_dnd_get(GtkWidget *tree_view, GdkDragContext *UNUSED(context),
 542                                      GtkSelectionData *selection_data, guint info,
 543                                      guint UNUSED(time), gpointer UNUSED(data))
 544 {
 545         GtkTreeIter iter;
 546         GtkTreeModel *model;
 547         GtkTreeIter child_iter;
 548         GtkTreeModel *keyword_tree;
 549
 550         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
 551
 552         if (!gtk_tree_selection_get_selected(sel, &model, &iter)) return;
 553
 554         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 555         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
 556
 557         switch (info)
 558                 {
 559                 case TARGET_APP_KEYWORD_PATH:
 560                         {
 561                         GList *path = keyword_tree_get_path(keyword_tree, &child_iter);
 562                         gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
 563                                                8, reinterpret_cast<const guchar *>(&path), sizeof(path));
 564                         break;
 565                         }
 566
 567                 case TARGET_TEXT_PLAIN:
 568                 default:
 569                         {
 570                         gchar *name = keyword_get_name(keyword_tree, &child_iter);
 571                         gtk_selection_data_set_text(selection_data, name, -1);
 572                         g_free(name);
 573                         }
 574                         break;
 575                 }
 576 }
 577
 578 static void bar_pane_keywords_dnd_begin(GtkWidget *tree_view, GdkDragContext *context, gpointer UNUSED(data))
 579 {
 580         GtkTreeIter iter;
 581         GtkTreeModel *model;
 582         GtkTreeIter child_iter;
 583         GtkTreeModel *keyword_tree;
 584         gchar *name;
 585
 586         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
 587
 588         if (!gtk_tree_selection_get_selected(sel, &model, &iter)) return;
 589
 590         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 591         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
 592
 593         name = keyword_get_name(keyword_tree, &child_iter);
 594
 595         dnd_set_drag_label(tree_view, context, name);
 596         g_free(name);
 597
 598 }
 599
 600 static void bar_pane_keywords_dnd_end(GtkWidget *UNUSED(widget), GdkDragContext *UNUSED(context), gpointer UNUSED(data))
 601 {
 602 }
 603
 604
 605 static gboolean bar_pane_keywords_dnd_can_move(GtkTreeModel *keyword_tree, GtkTreeIter *src_kw_iter, GtkTreeIter *dest_kw_iter)
 606 {
 607         gchar *src_name;
 608         GtkTreeIter parent;
 609
 610         if (dest_kw_iter && keyword_same_parent(keyword_tree, src_kw_iter, dest_kw_iter))
 611                 {
 612                 return TRUE; /* reordering of siblings is ok */
 613                 }
 614         if (!dest_kw_iter && !gtk_tree_model_iter_parent(keyword_tree, &parent, src_kw_iter))
 615                 {
 616                 return TRUE; /* reordering of top-level siblings is ok */
 617                 }
 618
 619         src_name = keyword_get_name(keyword_tree, src_kw_iter);
 620         if (keyword_exists(keyword_tree, NULL, dest_kw_iter, src_name, FALSE, NULL))
 621                 {
 622                 g_free(src_name);
 623                 return FALSE;
 624         }
 625         g_free(src_name);
 626         return TRUE;
 627 }
 628
 629 static gboolean bar_pane_keywords_dnd_skip_existing(GtkTreeModel *keyword_tree, GtkTreeIter *dest_kw_iter, GList **keywords)
 630 {
 631         /* we have to find at least one keyword that does not already exist as a sibling of dest_kw_iter */
 632         GList *work = *keywords;
 633         while (work)
 634                 {
 635                 gchar *keyword = static_cast<gchar *>(work->data);
 636                 if (keyword_exists(keyword_tree, NULL, dest_kw_iter, keyword, FALSE, NULL))
 637                         {
 638                         GList *next = work->next;
 639                         g_free(keyword);
 640                         *keywords = g_list_delete_link(*keywords, work);
 641                         work = next;
 642                         }
 643                 else
 644                         {
 645                         work = work->next;
 646                         }
 647                 }
 648         return !!*keywords;
 649 }
 650
 651 static void bar_pane_keywords_dnd_receive(GtkWidget *tree_view, GdkDragContext *UNUSED(context),
 652                                           gint x, gint y,
 653                                           GtkSelectionData *selection_data, guint info,
 654                                           guint UNUSED(time), gpointer data)
 655 {
 656         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
 657         GtkTreePath *tpath = NULL;
 658         GtkTreeViewDropPosition pos;
 659         GtkTreeModel *model;
 660
 661         GtkTreeModel *keyword_tree;
 662         gboolean src_valid = FALSE;
 663         GList *new_keywords = NULL;
 664         GList *work;
 665
 666         /* iterators for keyword_tree */
 667         GtkTreeIter src_kw_iter;
 668         GtkTreeIter dest_kw_iter;
 669         GtkTreeIter new_kw_iter;
 670
 671         g_signal_stop_emission_by_name(tree_view, "drag_data_received");
 672
 673         model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
 674         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 675
 676         gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos);
 677         gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), NULL, pos);
 678
 679         switch (info)
 680                 {
 681                 case TARGET_APP_KEYWORD_PATH:
 682                         {
 683                         GList *path = static_cast<GList *>(*(gpointer *)(gtk_selection_data_get_data(selection_data)));
 684                         src_valid = keyword_tree_get_iter(keyword_tree, &src_kw_iter, path);
 685                         string_list_free(path);
 686                         break;
 687                         }
 688                 default:
 689                         new_keywords = string_to_keywords_list((gchar *)gtk_selection_data_get_data(selection_data));
 690                         break;
 691                 }
 692
 693         if (tpath)
 694                 {
 695                 GtkTreeIter dest_iter;
 696                 gtk_tree_model_get_iter(model, &dest_iter, tpath);
 697                 gtk_tree_path_free(tpath);
 698                 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &dest_kw_iter, &dest_iter);
 699
 700                 if (src_valid && gtk_tree_store_is_ancestor(GTK_TREE_STORE(keyword_tree), &src_kw_iter, &dest_kw_iter))
 701                         {
 702                         /* can't move to it's own child */
 703                         return;
 704                         }
 705
 706                 if (src_valid && keyword_compare(keyword_tree, &src_kw_iter, &dest_kw_iter) == 0)
 707                         {
 708                         /* can't move to itself */
 709                         return;
 710                         }
 711
 712                 if ((pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE || pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER) &&
 713                     !gtk_tree_model_iter_has_child(keyword_tree, &dest_kw_iter))
 714                         {
 715                         /* the node has no children, all keywords can be added */
 716                         gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &dest_kw_iter);
 717                         }
 718                 else
 719                         {
 720                         if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, &dest_kw_iter))
 721                                 {
 722                                 /* the keyword can't be moved if the same name already exist */
 723                                 return;
 724                                 }
 725                         if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, &dest_kw_iter, &new_keywords))
 726                                 {
 727                                 /* the keywords can't be added if the same name already exist */
 728                                 return;
 729                                 }
 730
 731                         switch (pos)
 732                                 {
 733                                 case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
 734                                 case GTK_TREE_VIEW_DROP_BEFORE:
 735                                         gtk_tree_store_insert_before(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL, &dest_kw_iter);
 736                                         break;
 737                                 case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
 738                                 case GTK_TREE_VIEW_DROP_AFTER:
 739                                         gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL, &dest_kw_iter);
 740                                         break;
 741                                 }
 742                         }
 743
 744                 }
 745         else
 746                 {
 747                 if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, NULL))
 748                         {
 749                         /* the keyword can't be moved if the same name already exist */
 750                         return;
 751                         }
 752                 if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, NULL, &new_keywords))
 753                         {
 754                         /* the keywords can't be added if the same name already exist */
 755                         return;
 756                         }
 757                 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL);
 758                 }
 759
 760
 761         if (src_valid)
 762                 {
 763                 keyword_move_recursive(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &src_kw_iter);
 764                 }
 765
 766         work = new_keywords;
 767         while (work)
 768                 {
 769                 gchar *keyword = static_cast<gchar *>(work->data);
 770                 keyword_set(GTK_TREE_STORE(keyword_tree), &new_kw_iter, keyword, TRUE);
 771                 work = work->next;
 772
 773                 if (work)
 774                         {
 775                         GtkTreeIter add;
 776                         gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, NULL, &new_kw_iter);
 777                         new_kw_iter = add;
 778                         }
 779                 }
 780         string_list_free(new_keywords);
 781         bar_keyword_tree_sync(pkd);
 782 }
 783
 784 static gint bar_pane_keywords_dnd_motion(GtkWidget *tree_view, GdkDragContext *context,
 785                                         gint x, gint y, guint time, gpointer UNUSED(data))
 786 {
 787         GtkTreePath *tpath = NULL;
 788         GtkTreeViewDropPosition pos;
 789         gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos);
 790         if (tpath)
 791                 {
 792                 GtkTreeModel *model;
 793                 GtkTreeIter dest_iter;
 794                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
 795                 gtk_tree_model_get_iter(model, &dest_iter, tpath);
 796                 if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE && gtk_tree_model_iter_has_child(model, &dest_iter))
 797                         pos = GTK_TREE_VIEW_DROP_BEFORE;
 798
 799                 if (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER && gtk_tree_model_iter_has_child(model, &dest_iter))
 800                         pos = GTK_TREE_VIEW_DROP_AFTER;
 801                 }
 802
 803         gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), tpath, pos);
 804         gtk_tree_path_free(tpath);
 805
 806         if (tree_view == gtk_drag_get_source_widget(context))
 807                 gdk_drag_status(context, GDK_ACTION_MOVE, time);
 808         else
 809                 gdk_drag_status(context, GDK_ACTION_COPY, time);
 810
 811         return TRUE;
 812 }
 813
 814 /*
 815  *-------------------------------------------------------------------
 816  * edit dialog
 817  *-------------------------------------------------------------------
 818  */
 819
 820 static void bar_pane_keywords_edit_destroy_cb(GtkWidget *UNUSED(widget), gpointer data)
 821 {
 822         ConfDialogData *cdd = static_cast<ConfDialogData *>(data);
 823         gtk_tree_path_free(cdd->click_tpath);
 824         g_free(cdd);
 825 }
 826
 827
 828 static void bar_pane_keywords_edit_cancel_cb(GenericDialog *UNUSED(gd), gpointer UNUSED(data))
 829 {
 830 }
 831
 832
 833 static void bar_pane_keywords_edit_ok_cb(GenericDialog *UNUSED(gd), gpointer data)
 834 {
 835         ConfDialogData *cdd = static_cast<ConfDialogData *>(data);
 836         PaneKeywordsData *pkd = cdd->pkd;
 837         GtkTreeModel *model;
 838
 839         GtkTreeModel *keyword_tree;
 840         GtkTreeIter kw_iter;
 841
 842         gboolean have_dest = FALSE;
 843
 844         GList *keywords;
 845
 846         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 847         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 848
 849         if (cdd->click_tpath)
 850                 {
 851                 GtkTreeIter iter;
 852                 if (gtk_tree_model_get_iter(model, &iter, cdd->click_tpath))
 853                         {
 854                         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
 855                         have_dest = TRUE;
 856                         }
 857                 }
 858
 859         if (cdd->edit_existing && !have_dest) return;
 860
 861         keywords = keyword_list_pull(cdd->edit_widget);
 862
 863         if (cdd->edit_existing)
 864                 {
 865                 if (keywords && keywords->data && /* there should be one keyword */
 866                     !keyword_exists(keyword_tree, NULL, &kw_iter, static_cast<const gchar *>(keywords->data), TRUE, NULL))
 867                         {
 868                         keyword_set(GTK_TREE_STORE(keyword_tree), &kw_iter, static_cast<const gchar *>(keywords->data), cdd->is_keyword);
 869                         }
 870                 }
 871         else
 872                 {
 873                 GList *work = keywords;
 874                 gboolean append_to = FALSE;
 875
 876                 while (work)
 877                         {
 878                         GtkTreeIter add;
 879                         if (keyword_exists(keyword_tree, NULL, (have_dest || append_to) ? &kw_iter : NULL, static_cast<const gchar *>(work->data), FALSE, NULL))
 880                                 {
 881                                 work = work->next;
 882                                 continue;
 883                                 }
 884                         if (have_dest)
 885                                 {
 886                                 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, &kw_iter);
 887                                 }
 888                         else if (append_to)
 889                                 {
 890                                 gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, NULL, &kw_iter);
 891                                 }
 892                         else
 893                                 {
 894                                 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, NULL);
 895                                 append_to = TRUE;
 896                                 kw_iter = add;
 897                                 }
 898                         keyword_set(GTK_TREE_STORE(keyword_tree), &add, static_cast<const gchar *>(work->data), cdd->is_keyword);
 899                         work = work->next;
 900                         }
 901                 }
 902         string_list_free(keywords);
 903 }
 904
 905 static void bar_pane_keywords_conf_set_helper(GtkWidget *UNUSED(widget), gpointer data)
 906 {
 907         ConfDialogData *cdd = static_cast<ConfDialogData *>(data);
 908         cdd->is_keyword = FALSE;
 909 }
 910
 911 static void bar_pane_keywords_conf_set_kw(GtkWidget *UNUSED(widget), gpointer data)
 912 {
 913         ConfDialogData *cdd = static_cast<ConfDialogData *>(data);
 914         cdd->is_keyword = TRUE;
 915 }
 916
 917
 918
 919 static void bar_pane_keywords_edit_dialog(PaneKeywordsData *pkd, gboolean edit_existing)
 920 {
 921         ConfDialogData *cdd;
 922         GenericDialog *gd;
 923         GtkWidget *table;
 924         GtkWidget *group;
 925         GtkWidget *button;
 926
 927         gchar *name = NULL;
 928         gboolean is_keyword = TRUE;
 929
 930
 931         if (edit_existing && pkd->click_tpath)
 932                 {
 933                 GtkTreeModel *model;
 934                 GtkTreeIter iter;
 935                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 936
 937                 if (gtk_tree_model_get_iter(model, &iter, pkd->click_tpath))
 938                         {
 939                         gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name,
 940                                                          FILTER_KEYWORD_COLUMN_IS_KEYWORD, &is_keyword, -1);
 941                         }
 942                 else
 943                         {
 944                         return;
 945                         }
 946                 }
 947
 948         if (edit_existing && !name) return;
 949
 950
 951         cdd = g_new0(ConfDialogData, 1);
 952         cdd->pkd =pkd;
 953         cdd->click_tpath = pkd->click_tpath;
 954         pkd->click_tpath = NULL;
 955         cdd->edit_existing = edit_existing;
 956
 957         cdd->gd = gd = generic_dialog_new(name ? _("Edit keyword") : _("New keyword"), "keyword_edit",
 958                                 pkd->widget, TRUE,
 959                                 bar_pane_keywords_edit_cancel_cb, cdd);
 960         g_signal_connect(G_OBJECT(gd->dialog), "destroy",
 961                          G_CALLBACK(bar_pane_keywords_edit_destroy_cb), cdd);
 962
 963
 964         generic_dialog_add_message(gd, NULL, name ? _("Configure keyword") : _("New keyword"), NULL, FALSE);
 965
 966         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
 967                                   bar_pane_keywords_edit_ok_cb, TRUE);
 968
 969         table = pref_table_new(gd->vbox, 3, 1, FALSE, TRUE);
 970         pref_table_label(table, 0, 0, _("Keyword:"), 1.0);
 971         cdd->edit_widget = gtk_entry_new();
 972         gtk_widget_set_size_request(cdd->edit_widget, 300, -1);
 973         if (name) gtk_entry_set_text(GTK_ENTRY(cdd->edit_widget), name);
 974         gtk_table_attach_defaults(GTK_TABLE(table), cdd->edit_widget, 1, 2, 0, 1);
 975         /* here could eventually be a text view instead of entry */
 976         generic_dialog_attach_default(gd, cdd->edit_widget);
 977         gtk_widget_show(cdd->edit_widget);
 978
 979         group = pref_group_new(gd->vbox, FALSE, _("Keyword type:"), GTK_ORIENTATION_VERTICAL);
 980
 981         button = pref_radiobutton_new(group, NULL, _("Active keyword"),
 982                                       (is_keyword),
 983                                       G_CALLBACK(bar_pane_keywords_conf_set_kw), cdd);
 984         button = pref_radiobutton_new(group, button, _("Helper"),
 985                                       (!is_keyword),
 986                                       G_CALLBACK(bar_pane_keywords_conf_set_helper), cdd);
 987
 988         cdd->is_keyword = is_keyword;
 989
 990         g_free(name);
 991
 992         gtk_widget_grab_focus(cdd->edit_widget);
 993
 994         gtk_widget_show(gd->dialog);
 995 }
 996
 997
 998
 999
1000 /*
1001  *-------------------------------------------------------------------
1002  * popup menu
1003  *-------------------------------------------------------------------
1004  */
1005
1006 static void bar_pane_keywords_edit_dialog_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1007 {
1008         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1009         bar_pane_keywords_edit_dialog(pkd, TRUE);
1010 }
1011
1012 static void bar_pane_keywords_add_dialog_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1013 {
1014         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1015         bar_pane_keywords_edit_dialog(pkd, FALSE);
1016 }
1017
1018 static void bar_pane_keywords_connect_mark_cb(GtkWidget *menu_widget, gpointer data)
1019 {
1020         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1021
1022         GtkTreeModel *model;
1023         GtkTreeIter iter;
1024
1025         GtkTreeModel *keyword_tree;
1026         GtkTreeIter kw_iter;
1027
1028         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu_widget), "mark")) - 1;
1029
1030         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1031         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1032
1033         if (!pkd->click_tpath) return;
1034         if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1035
1036         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
1037
1038         meta_data_connect_mark_with_keyword(keyword_tree, &kw_iter, mark);
1039 }
1040
1041 static void bar_pane_keywords_disconnect_marks_ok_cb(GenericDialog *UNUSED(gd), gpointer UNUSED(data))
1042 {
1043         keyword_tree_disconnect_marks();
1044 }
1045
1046 static void dummy_cancel_cb(GenericDialog *UNUSED(gd), gpointer UNUSED(data))
1047 {
1048         /* no op, only so cancel button appears */
1049 }
1050
1051 static void bar_pane_keywords_disconnect_marks_cb(GtkWidget *menu_widget, gpointer data)
1052 {
1053         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1054
1055         GenericDialog *gd;
1056         GString *message = g_string_new("");
1057
1058         message = g_string_append(message, _("This will disconnect all Marks Keywords connections"));
1059
1060         gd = generic_dialog_new(_("Marks Keywords"),
1061                                 "marks_keywords", menu_widget, TRUE, dummy_cancel_cb, pkd);
1062         generic_dialog_add_message(gd, GTK_STOCK_DIALOG_WARNING,
1063                                 "Disconnect all Marks Keywords connections?", message->str, TRUE);
1064         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL, bar_pane_keywords_disconnect_marks_ok_cb, TRUE);
1065
1066         gtk_widget_show(gd->dialog);
1067
1068         g_string_free(message, TRUE);
1069 }
1070
1071 static void bar_pane_keywords_delete_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1072 {
1073         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1074         GtkTreeModel *model;
1075         GtkTreeIter iter;
1076
1077         GtkTreeModel *keyword_tree;
1078         GtkTreeIter kw_iter;
1079
1080         if (!pkd->click_tpath) return;
1081
1082         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1083         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1084
1085         if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1086         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
1087
1088         keyword_delete(GTK_TREE_STORE(keyword_tree), &kw_iter);
1089 }
1090
1091 static void bar_pane_keywords_hide_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1092 {
1093         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1094         GtkTreeModel *model;
1095         GtkTreeIter iter;
1096
1097         GtkTreeModel *keyword_tree;
1098         GtkTreeIter kw_iter;
1099
1100         if (!pkd->click_tpath) return;
1101
1102         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1103         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1104
1105         if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1106         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
1107
1108         keyword_hide_in(GTK_TREE_STORE(keyword_tree), &kw_iter, model);
1109 }
1110
1111 static void bar_pane_keywords_show_all_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1112 {
1113         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1114         GtkTreeModel *model;
1115
1116         GtkTreeModel *keyword_tree;
1117
1118         string_list_free(pkd->expanded_rows);
1119         pkd->expanded_rows = NULL;
1120         gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(pkd->keyword_treeview),
1121                                                                 (bar_keyword_tree_get_expanded_cb), &pkd->expanded_rows);
1122
1123         pkd->hide_unchecked = FALSE;
1124
1125         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1126         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1127
1128         keyword_show_all_in(GTK_TREE_STORE(keyword_tree), model);
1129
1130         if (!pkd->collapse_unchecked) gtk_tree_view_expand_all(GTK_TREE_VIEW(pkd->keyword_treeview));
1131         bar_keyword_tree_sync(pkd);
1132 }
1133
1134 static void bar_pane_keywords_revert_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1135 {
1136         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1137         GList *work;
1138         GtkTreePath *tree_path;
1139         gchar *path;
1140
1141         gtk_tree_view_collapse_all(GTK_TREE_VIEW(pkd->keyword_treeview));
1142
1143         work = pkd->expanded_rows;
1144         while (work)
1145                 {
1146                 path = static_cast<gchar *>(work->data);
1147                 tree_path = gtk_tree_path_new_from_string(path);
1148                 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), tree_path);
1149                 work = work->next;
1150                 gtk_tree_path_free(tree_path);
1151                 }
1152
1153         bar_keyword_tree_sync(pkd);
1154 }
1155
1156 static void bar_pane_keywords_expand_checked_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1157 {
1158         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1159         GtkTreeModel *model;
1160
1161         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1162         gtk_tree_model_foreach(model, bar_keyword_tree_expand_if_set_cb, pkd);
1163 }
1164
1165 static void bar_pane_keywords_collapse_all_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1166 {
1167         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1168
1169         string_list_free(pkd->expanded_rows);
1170         pkd->expanded_rows = NULL;
1171         gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(pkd->keyword_treeview),
1172                                                                 (bar_keyword_tree_get_expanded_cb), &pkd->expanded_rows);
1173
1174         gtk_tree_view_collapse_all(GTK_TREE_VIEW(pkd->keyword_treeview));
1175
1176         bar_keyword_tree_sync(pkd);
1177 }
1178
1179 static void bar_pane_keywords_revert_hidden_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1180 {
1181         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1182         GtkTreeModel *model;
1183         GtkTreeModel *keyword_tree;
1184
1185         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1186         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1187
1188         keyword_revert_hidden_in(GTK_TREE_STORE(keyword_tree), model);
1189
1190         bar_keyword_tree_sync(pkd);
1191 }
1192
1193 static void bar_pane_keywords_collapse_unchecked_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1194 {
1195         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1196         GtkTreeModel *model;
1197
1198         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1199         gtk_tree_model_foreach(model, bar_keyword_tree_collapse_if_unset_cb, pkd);
1200 }
1201
1202 static void bar_pane_keywords_hide_unchecked_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1203 {
1204         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1205         GtkTreeModel *model;
1206
1207         GtkTreeModel *keyword_tree;
1208         GList *keywords;
1209
1210         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1211         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1212
1213         keywords = keyword_list_pull(pkd->keyword_view);
1214         keyword_hide_unset_in(GTK_TREE_STORE(keyword_tree), model, keywords);
1215         string_list_free(keywords);
1216         bar_keyword_tree_sync(pkd);
1217 }
1218
1219 static void bar_pane_keywords_expand_checked_toggle_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1220 {
1221         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1222         pkd->expand_checked = !pkd->expand_checked;
1223         bar_keyword_tree_sync(pkd);
1224 }
1225
1226 static void bar_pane_keywords_collapse_unchecked_toggle_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1227 {
1228         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1229         pkd->collapse_unchecked = !pkd->collapse_unchecked;
1230         bar_keyword_tree_sync(pkd);
1231 }
1232
1233 static void bar_pane_keywords_hide_unchecked_toggle_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1234 {
1235         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1236         pkd->hide_unchecked = !pkd->hide_unchecked;
1237         bar_keyword_tree_sync(pkd);
1238 }
1239
1240 /**
1241  * @brief Callback for adding selected keyword to all selected images.
1242  */
1243 static void bar_pane_keywords_add_to_selected_cb(GtkWidget *UNUSED(menu_widget), gpointer data)
1244 {
1245         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1246         GtkTreeIter iter; /* This is the iter which initial holds the current keyword */
1247         GtkTreeIter child_iter;
1248         GtkTreeModel *model;
1249         GtkTreeModel *keyword_tree;
1250         GList *list, *work;
1251         GList *keywords = NULL;
1252
1253         GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
1254
1255         /* Acquire selected keyword */
1256         if (pkd->click_tpath)
1257                 {
1258                 gboolean is_keyword = TRUE;
1259
1260                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1261                 if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1262                 gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_IS_KEYWORD, &is_keyword, -1);
1263                 if (!is_keyword) return;
1264                 }
1265         else
1266                 return;
1267
1268         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1269         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
1270
1271         list = keyword_list_pull(pkd->keyword_view); /* Get the left keyword view */
1272
1273         /* Now set the current image */
1274         keyword_tree_set(keyword_tree, &child_iter, &list);
1275
1276         keyword_list_push(pkd->keyword_view, list); /* Set the left keyword view */
1277         string_list_free(list);
1278
1279         bar_pane_keywords_changed(keyword_buffer, pkd); /* Get list of all keywords in the hierarchy */
1280
1281         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
1282         keywords = keyword_tree_get(keyword_tree, &child_iter);
1283
1284         list = layout_selection_list(pkd->pane.lw);
1285         work = list;
1286         while (work)
1287                 {
1288                 FileData *fd = static_cast<FileData *>(work->data);
1289                 work = work->next;
1290                 metadata_append_list(fd, KEYWORD_KEY, keywords);
1291                 }
1292         filelist_free(list);
1293         string_list_free(keywords);
1294 }
1295
1296 static void bar_pane_keywords_menu_popup(GtkWidget *UNUSED(widget), PaneKeywordsData *pkd, gint x, gint y)
1297 {
1298         GtkWidget *menu;
1299         GtkWidget *item;
1300         GtkWidget *submenu;
1301         GtkTreeViewDropPosition pos;
1302
1303         if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);
1304         pkd->click_tpath = NULL;
1305         gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(pkd->keyword_treeview), x, y, &pkd->click_tpath, &pos);
1306
1307         menu = popup_menu_short_lived();
1308
1309         menu_item_add_stock(menu, _("New keyword"), GTK_STOCK_NEW, G_CALLBACK(bar_pane_keywords_add_dialog_cb), pkd);
1310
1311         menu_item_add_divider(menu);
1312
1313         if (pkd->click_tpath)
1314                 {
1315                 /* for the entry */
1316                 gchar *text;
1317                 gchar *mark;
1318                 gint i;
1319                 gboolean keyword;
1320
1321                 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1322
1323                 GtkTreeIter iter;
1324                 gtk_tree_model_get_iter(model, &iter, pkd->click_tpath);
1325                 gchar *name;
1326
1327                 gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name,
1328                                                 FILTER_KEYWORD_COLUMN_MARK, &mark,
1329                                                 FILTER_KEYWORD_COLUMN_IS_KEYWORD, &keyword, -1);
1330
1331                 if (keyword)
1332                         {
1333                         text = g_strdup_printf(_("Add \"%s\" to all selected images"), name);
1334                         menu_item_add_stock(menu, text, GTK_STOCK_ADD, G_CALLBACK(bar_pane_keywords_add_to_selected_cb), pkd);
1335                         g_free(text);
1336                         }
1337                 menu_item_add_divider(menu);
1338
1339                 text = g_strdup_printf(_("Hide \"%s\""), name);
1340                 menu_item_add(menu, text, G_CALLBACK(bar_pane_keywords_hide_cb), pkd);
1341                 g_free(text);
1342
1343                 submenu = gtk_menu_new();
1344                 for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
1345                         {
1346                         text = g_strdup_printf(_("Mark %d"), 1 + (i < 9 ? i : -1));
1347                         item = menu_item_add(submenu, text, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
1348                         g_object_set_data(G_OBJECT(item), "mark", GINT_TO_POINTER(i + 1));
1349                         g_free(text);
1350                         }
1351
1352                 if (keyword)
1353                         {
1354                         text = g_strdup_printf(_("Connect \"%s\" to mark"), name);
1355                         item = menu_item_add(menu, text, NULL, NULL);
1356                         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
1357                         g_free(text);
1358                         }
1359                 menu_item_add_divider(menu);
1360
1361                 text = g_strdup_printf(_("Edit \"%s\""), name);
1362                 menu_item_add_stock(menu, text, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_edit_dialog_cb), pkd);
1363                 g_free(text);
1364                 text = g_strdup_printf(_("Remove \"%s\""), name);
1365                 menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_delete_cb), pkd);
1366                 g_free(text);
1367
1368
1369                 if (mark && mark[0])
1370                         {
1371                         text = g_strdup_printf(_("Disconnect \"%s\" from mark %s"), name, mark);
1372                         menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
1373                         g_free(text);
1374                         }
1375
1376                 if (keyword)
1377                         {
1378                         text = g_strdup_printf(_("Disconnect all Mark Keyword connections"));
1379                         menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_disconnect_marks_cb), pkd);
1380                         g_free(text);
1381                         }
1382                 menu_item_add_divider(menu);
1383                 g_free(mark);
1384                 g_free(name);
1385                 }
1386         /* for the pane */
1387
1388
1389         menu_item_add(menu, _("Expand checked"), G_CALLBACK(bar_pane_keywords_expand_checked_cb), pkd);
1390         menu_item_add(menu, _("Collapse unchecked"), G_CALLBACK(bar_pane_keywords_collapse_unchecked_cb), pkd);
1391         menu_item_add(menu, _("Hide unchecked"), G_CALLBACK(bar_pane_keywords_hide_unchecked_cb), pkd);
1392         menu_item_add(menu, _("Revert all hidden"), G_CALLBACK(bar_pane_keywords_revert_hidden_cb), pkd);
1393         menu_item_add_divider(menu);
1394         menu_item_add(menu, _("Show all"), G_CALLBACK(bar_pane_keywords_show_all_cb), pkd);
1395         menu_item_add(menu, _("Collapse all"), G_CALLBACK(bar_pane_keywords_collapse_all_cb), pkd);
1396         menu_item_add(menu, _("Revert"), G_CALLBACK(bar_pane_keywords_revert_cb), pkd);
1397         menu_item_add_divider(menu);
1398
1399         submenu = gtk_menu_new();
1400         item = menu_item_add(menu, _("On any change"), NULL, NULL);
1401         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
1402
1403         menu_item_add_check(submenu, _("Expand checked"), pkd->expand_checked, G_CALLBACK(bar_pane_keywords_expand_checked_toggle_cb), pkd);
1404         menu_item_add_check(submenu, _("Collapse unchecked"), pkd->collapse_unchecked, G_CALLBACK(bar_pane_keywords_collapse_unchecked_toggle_cb), pkd);
1405         menu_item_add_check(submenu, _("Hide unchecked"), pkd->hide_unchecked, G_CALLBACK(bar_pane_keywords_hide_unchecked_toggle_cb), pkd);
1406
1407         gtk_menu_popup_at_pointer(GTK_MENU(menu), NULL);
1408 }
1409
1410
1411 static gboolean bar_pane_keywords_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1412 {
1413         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1414         if (bevent->button == MOUSE_BUTTON_RIGHT)
1415                 {
1416                 bar_pane_keywords_menu_popup(widget, pkd, bevent->x, bevent->y);
1417                 return TRUE;
1418                 }
1419         return FALSE;
1420 }
1421
1422 /*
1423  *-------------------------------------------------------------------
1424  * init
1425  *-------------------------------------------------------------------
1426  */
1427
1428 //void bar_pane_keywords_close(GtkWidget *bar)
1429 //{
1430         //PaneKeywordsData *pkd;
1431
1432         //pkd = g_object_get_data(G_OBJECT(bar), "pane_data");
1433         //if (!pkd) return;
1434
1435         //g_free(pkd->pane.id);
1436         //gtk_widget_destroy(pkd->widget);
1437 //}
1438
1439 static void bar_pane_keywords_destroy(GtkWidget *UNUSED(widget), gpointer data)
1440 {
1441         PaneKeywordsData *pkd = static_cast<PaneKeywordsData *>(data);
1442         gchar *path;
1443
1444         path = g_build_filename(get_rc_dir(), "keywords", NULL);
1445         autocomplete_keywords_list_save(path);
1446
1447         string_list_free(pkd->expanded_rows);
1448         if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);
1449         if (pkd->idle_id) g_source_remove(pkd->idle_id);
1450         file_data_unregister_notify_func(bar_pane_keywords_notify_cb, pkd);
1451
1452         file_data_unref(pkd->fd);
1453         g_free(pkd->key);
1454
1455         g_free(pkd);
1456 }
1457
1458
1459 static GtkWidget *bar_pane_keywords_new(const gchar *id, const gchar *title, const gchar *key, gboolean expanded, gint height)
1460 {
1461         PaneKeywordsData *pkd;
1462         GtkWidget *hbox, *vbox;
1463         GtkWidget *scrolled;
1464         GtkTextBuffer *buffer;
1465         GtkTreeModel *store;
1466         GtkTreeViewColumn *column;
1467         GtkCellRenderer *renderer;
1468         GtkTreeIter iter;
1469         GtkEntryCompletion *completion;
1470         gchar *path;
1471
1472         pkd = g_new0(PaneKeywordsData, 1);
1473
1474         pkd->pane.pane_set_fd = bar_pane_keywords_set_fd;
1475         pkd->pane.pane_event = bar_pane_keywords_event;
1476         pkd->pane.pane_write_config = bar_pane_keywords_write_config;
1477         pkd->pane.title = bar_pane_expander_title(title);
1478         pkd->pane.id = g_strdup(id);
1479         pkd->pane.type = PANE_KEYWORDS;
1480
1481         pkd->pane.expanded = expanded;
1482
1483         pkd->height = height;
1484         pkd->key = g_strdup(key);
1485
1486         pkd->expand_checked = TRUE;
1487         pkd->expanded_rows = NULL;
1488
1489         vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
1490         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
1491         gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
1492
1493         pkd->widget = vbox;
1494         g_object_set_data(G_OBJECT(pkd->widget), "pane_data", pkd);
1495         g_signal_connect(G_OBJECT(pkd->widget), "destroy",
1496                          G_CALLBACK(bar_pane_keywords_destroy), pkd);
1497         gtk_widget_set_size_request(pkd->widget, -1, height);
1498         gtk_widget_show(hbox);
1499
1500         scrolled = gtk_scrolled_window_new(NULL, NULL);
1501         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         gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
1505         gtk_widget_show(scrolled);
1506
1507         pkd->keyword_view = gtk_text_view_new();
1508         gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_view);
1509         g_signal_connect(G_OBJECT(pkd->keyword_view), "populate-popup",
1510                          G_CALLBACK(bar_pane_keywords_populate_popup_cb), pkd);
1511         gtk_widget_show(pkd->keyword_view);
1512
1513         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
1514         g_signal_connect(G_OBJECT(buffer), "changed",
1515                          G_CALLBACK(bar_pane_keywords_changed), pkd);
1516
1517         if (options->show_predefined_keyword_tree)
1518                 {
1519                 scrolled = gtk_scrolled_window_new(NULL, NULL);
1520                 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
1521                 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
1522                                                 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1523                 gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
1524                 gtk_widget_show(scrolled);
1525                 }
1526
1527         pkd->autocomplete = gtk_entry_new();
1528         gtk_box_pack_end(GTK_BOX(vbox), pkd->autocomplete, FALSE, FALSE, 0);
1529         gtk_widget_show(pkd->autocomplete);
1530         gtk_widget_show(vbox);
1531         gtk_widget_set_tooltip_text(pkd->autocomplete, "Keyword autocomplete");
1532
1533         path = g_build_filename(get_rc_dir(), "keywords", NULL);
1534         autocomplete_keywords_list_load(path);
1535
1536         completion = gtk_entry_completion_new();
1537         gtk_entry_set_completion(GTK_ENTRY(pkd->autocomplete), completion);
1538         gtk_entry_completion_set_inline_completion(completion, TRUE);
1539         gtk_entry_completion_set_inline_selection(completion, TRUE);
1540         g_object_unref(completion);
1541
1542         gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(keyword_store));
1543         gtk_entry_completion_set_text_column(completion, 0);
1544
1545         g_signal_connect(G_OBJECT(pkd->autocomplete), "activate",
1546                          G_CALLBACK(autocomplete_activate_cb), pkd);
1547
1548         if (!keyword_tree || !gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_tree), &iter))
1549                 {
1550                 /* keyword tree does not exist or is empty - fill with defaults */
1551                 keyword_tree_new_default();
1552                 }
1553
1554         store = gtk_tree_model_filter_new(GTK_TREE_MODEL(keyword_tree), NULL);
1555
1556         gtk_tree_model_filter_set_modify_func(GTK_TREE_MODEL_FILTER(store),
1557                                               FILTER_KEYWORD_COLUMN_COUNT,
1558                                               filter_keyword_column_types,
1559                                               bar_pane_keywords_filter_modify,
1560                                               pkd,
1561                                               NULL);
1562         gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(store),
1563                                                bar_pane_keywords_filter_visible,
1564                                                store,
1565                                                NULL);
1566
1567         pkd->keyword_treeview = gtk_tree_view_new_with_model(store);
1568         g_object_unref(store);
1569
1570         gtk_widget_set_size_request(pkd->keyword_treeview, -1, 400);
1571
1572         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(pkd->keyword_treeview), FALSE);
1573
1574 //      gtk_tree_view_set_search_column(GTK_TREE_VIEW(pkd->keyword_treeview), FILTER_KEYWORD_COLUMN_);
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                 gtk_container_add(GTK_CONTAINER(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 = NULL;
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 = NULL;
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 = NULL;
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 *UNUSED(widget), gpointer data)
1741 {
1742         PaneKeywordsData *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(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 != NULL)
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(NULL, ",");
1765                 g_free(kw_cr);
1766                 }
1767
1768         g_free(entry_text);
1769         entry_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(pkd->autocomplete)));
1770
1771         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 gint autocomplete_sort_iter_compare_func (GtkTreeModel *model,
1796                                                                         GtkTreeIter *a,
1797                                                                         GtkTreeIter *b,
1798                                                                         gpointer UNUSED(userdata))
1799 {
1800         gint ret = 0;
1801         gchar *name1, *name2;
1802
1803         gtk_tree_model_get(model, a, 0, &name1, -1);
1804         gtk_tree_model_get(model, b, 0, &name2, -1);
1805
1806         if (name1 == NULL || name2 == NULL)
1807                 {
1808                 if (name1 == NULL && name2 == NULL)
1809                         {
1810                         ret = 0;
1811                         }
1812                 else
1813                         {
1814                         ret = (name1 == NULL) ? -1 : 1;
1815                         }
1816                 }
1817         else
1818                 {
1819                 ret = g_utf8_collate(name1,name2);
1820                 }
1821
1822         g_free(name1);
1823         g_free(name2);
1824
1825         return ret;
1826 }
1827
1828 static void autocomplete_keywords_list_load(const gchar *path)
1829 {
1830         FILE *f;
1831         gchar s_buf[1024];
1832         gchar *pathl;
1833         gint len;
1834         GtkTreeIter iter;
1835         GtkTreeSortable *sortable;
1836
1837         if (keyword_store) return;
1838         keyword_store = gtk_list_store_new(1, G_TYPE_STRING);
1839
1840         sortable = GTK_TREE_SORTABLE(keyword_store);
1841         gtk_tree_sortable_set_sort_func(sortable, 0, autocomplete_sort_iter_compare_func,
1842                                                                                                 GINT_TO_POINTER(0), NULL);
1843
1844         gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_ASCENDING);
1845
1846         pathl = path_from_utf8(path);
1847         f = fopen(pathl, "r");
1848         g_free(pathl);
1849
1850         if (!f)
1851                 {
1852                 log_printf("Warning: keywords file %s not loaded", pathl);
1853                 return;
1854                 }
1855
1856         /* first line must start with Keywords comment */
1857         if (!fgets(s_buf, sizeof(s_buf), f) ||
1858                                         strncmp(s_buf, "#Keywords", 9) != 0)
1859                 {
1860                 fclose(f);
1861                 log_printf("Warning: keywords file %s not loaded", pathl);
1862                 return;
1863                 }
1864
1865         while (fgets(s_buf, sizeof(s_buf), f))
1866                 {
1867                 if (s_buf[0]=='#') continue;
1868
1869                 len = strlen(s_buf);
1870                 if( s_buf[len-1] == '\n' )
1871                         {
1872                         s_buf[len-1] = 0;
1873                         }
1874                 gtk_list_store_append (keyword_store, &iter);
1875                 gtk_list_store_set(keyword_store, &iter, 0, g_strdup(s_buf), -1);
1876                 }
1877
1878         fclose(f);
1879 }
1880
1881 static gboolean autocomplete_keywords_list_save(gchar *path)
1882 {
1883         SecureSaveInfo *ssi;
1884         gchar *pathl;
1885         gchar *string;
1886         gchar *string_nl;
1887         GtkTreeIter  iter;
1888         gboolean     valid;
1889
1890         pathl = path_from_utf8(path);
1891         ssi = secure_open(pathl);
1892         g_free(pathl);
1893
1894         if (!ssi)
1895                 {
1896                 log_printf(_("Error: Unable to write keywords list to: %s\n"), path);
1897                 return FALSE;
1898                 }
1899
1900         secure_fprintf(ssi, "#Keywords list\n");
1901
1902         valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_store), &iter);
1903
1904         while (valid)
1905                 {
1906                 gtk_tree_model_get (GTK_TREE_MODEL(keyword_store), &iter, 0, &string, -1);
1907                 string_nl = g_strconcat(string, "\n", NULL);
1908                 secure_fprintf(ssi, "%s", string_nl);
1909
1910                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(keyword_store), &iter);
1911
1912                 g_free(string_nl);
1913                 }
1914
1915         secure_fprintf(ssi, "#end\n");
1916         return (secure_close(ssi) == 0);
1917 }
1918
1919 GList *keyword_list_get()
1920 {
1921         GList *ret_list = NULL;
1922         gchar *string;
1923         gchar *string_nl;
1924         GtkTreeIter iter;
1925         gboolean valid;
1926
1927         if (keyword_store)
1928                 {
1929                 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_store), &iter);
1930
1931                 while (valid)
1932                         {
1933                         gtk_tree_model_get (GTK_TREE_MODEL(keyword_store), &iter, 0, &string, -1);
1934                         string_nl = g_strconcat(string, "\n", NULL);
1935                         ret_list = g_list_append(ret_list, string);
1936                         valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(keyword_store), &iter);
1937
1938                         g_free(string_nl);
1939                         }
1940                 }
1941
1942         return ret_list;
1943 }
1944
1945 void keyword_list_set(GList *keyword_list)
1946 {
1947         GtkTreeIter  iter;
1948
1949         if (!keyword_list) return;
1950
1951         if (keyword_store)
1952                 {
1953                 gtk_list_store_clear(keyword_store);
1954                 }
1955         else
1956                 {
1957                 keyword_store = gtk_list_store_new(1, G_TYPE_STRING);
1958                 }
1959
1960         while (keyword_list)
1961                 {
1962                 gtk_list_store_append (keyword_store, &iter);
1963                 gtk_list_store_set(keyword_store, &iter, 0, keyword_list->data, -1);
1964
1965                 keyword_list = keyword_list->next;
1966                 }
1967 }
1968
1969 gboolean bar_keywords_autocomplete_focus(LayoutWindow *lw)
1970 {
1971         GtkWidget *pane;
1972         GtkWidget *current_focus;
1973         GList *children;
1974         gboolean ret;
1975
1976         current_focus = gtk_window_get_focus(GTK_WINDOW(lw->window));
1977         pane = bar_find_pane_by_id(lw->bar, PANE_KEYWORDS, "keywords");
1978
1979         children = gtk_container_get_children(GTK_CONTAINER(pane));
1980         children = g_list_last(children);
1981
1982         if (current_focus == children->data)
1983                 {
1984                 ret = TRUE;
1985                 }
1986         else
1987                 {
1988                 gtk_widget_grab_focus(GTK_WIDGET(children->data));
1989                 ret = FALSE;
1990                 }
1991
1992         g_list_free(children);
1993
1994         return ret;
1995 }
1996 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */