src/bar_keywords.c

   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 <glib/gprintf.h>
  23
  24 #include "main.h"
  25 #include "bar_keywords.h"
  26
  27 #include "filedata.h"
  28 #include "history_list.h"
  29 #include "metadata.h"
  30 #include "misc.h"
  31 #include "ui_fileops.h"
  32 #include "ui_misc.h"
  33 #include "ui_utildlg.h"
  34 #include "utilops.h"
  35 #include "bar.h"
  36 #include "ui_menu.h"
  37 #include "rcfile.h"
  38 #include "layout.h"
  39 #include "dnd.h"
  40
  41
  42 //static void bar_pane_keywords_keyword_update_all(void);
  43 static void bar_pane_keywords_changed(GtkTextBuffer *buffer, gpointer data);
  44
  45 /*
  46  *-------------------------------------------------------------------
  47  * keyword / comment utils
  48  *-------------------------------------------------------------------
  49  */
  50
  51
  52 GList *keyword_list_pull(GtkWidget *text_widget)
  53 {
  54         GList *list;
  55         gchar *text;
  56
  57         text = text_widget_text_pull(text_widget);
  58         list = string_to_keywords_list(text);
  59
  60         g_free(text);
  61
  62         return list;
  63 }
  64
  65 /* the "changed" signal should be blocked before calling this */
  66 static void keyword_list_push(GtkWidget *textview, GList *list)
  67 {
  68         GtkTextBuffer *buffer;
  69         GtkTextIter start, end;
  70
  71         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
  72         gtk_text_buffer_get_bounds(buffer, &start, &end);
  73         gtk_text_buffer_delete(buffer, &start, &end);
  74
  75         while (list)
  76                 {
  77                 const gchar *word = list->data;
  78                 GtkTextIter iter;
  79
  80                 gtk_text_buffer_get_end_iter(buffer, &iter);
  81                 if (word) gtk_text_buffer_insert(buffer, &iter, word, -1);
  82                 gtk_text_buffer_get_end_iter(buffer, &iter);
  83                 gtk_text_buffer_insert(buffer, &iter, "\n", -1);
  84
  85                 list = list->next;
  86                 }
  87 }
  88
  89
  90 /*
  91  *-------------------------------------------------------------------
  92  * info bar
  93  *-------------------------------------------------------------------
  94  */
  95
  96
  97 enum {
  98         FILTER_KEYWORD_COLUMN_TOGGLE = 0,
  99         FILTER_KEYWORD_COLUMN_MARK,
 100         FILTER_KEYWORD_COLUMN_NAME,
 101         FILTER_KEYWORD_COLUMN_IS_KEYWORD,
 102         FILTER_KEYWORD_COLUMN_COUNT
 103 };
 104
 105 static GType filter_keyword_column_types[] = {G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN};
 106
 107 typedef struct _PaneKeywordsData PaneKeywordsData;
 108 struct _PaneKeywordsData
 109 {
 110         PaneData pane;
 111         GtkWidget *widget;
 112
 113         GtkWidget *keyword_view;
 114         GtkWidget *keyword_treeview;
 115
 116         GtkTreePath *click_tpath;
 117
 118         gboolean expand_checked;
 119         gboolean collapse_unchecked;
 120         gboolean hide_unchecked;
 121
 122         guint idle_id; /* event source id */
 123         FileData *fd;
 124         gchar *key;
 125         gint height;
 126 };
 127
 128 typedef struct _ConfDialogData ConfDialogData;
 129 struct _ConfDialogData
 130 {
 131         PaneKeywordsData *pkd;
 132         GtkTreePath *click_tpath;
 133
 134         /* dialog parts */
 135         GenericDialog *gd;
 136         GtkWidget *edit_widget;
 137         gboolean is_keyword;
 138
 139         gboolean edit_existing;
 140 };
 141
 142
 143 static void bar_pane_keywords_write(PaneKeywordsData *pkd)
 144 {
 145         GList *list;
 146
 147         if (!pkd->fd) return;
 148
 149         list = keyword_list_pull(pkd->keyword_view);
 150
 151         metadata_write_list(pkd->fd, KEYWORD_KEY, list);
 152
 153         string_list_free(list);
 154 }
 155
 156 gboolean bar_keyword_tree_expand_if_set_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
 157 {
 158         PaneKeywordsData *pkd = data;
 159         gboolean set;
 160
 161         gtk_tree_model_get(model, iter, FILTER_KEYWORD_COLUMN_TOGGLE, &set, -1);
 162
 163         if (set && !gtk_tree_view_row_expanded(GTK_TREE_VIEW(pkd->keyword_treeview), path))
 164                 {
 165                 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), path);
 166                 }
 167         return FALSE;
 168 }
 169
 170 gboolean bar_keyword_tree_collapse_if_unset_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
 171 {
 172         PaneKeywordsData *pkd = data;
 173         gboolean set;
 174
 175         gtk_tree_model_get(model, iter, FILTER_KEYWORD_COLUMN_TOGGLE, &set, -1);
 176
 177         if (!set && gtk_tree_view_row_expanded(GTK_TREE_VIEW(pkd->keyword_treeview), path))
 178                 {
 179                 gtk_tree_view_collapse_row(GTK_TREE_VIEW(pkd->keyword_treeview), path);
 180                 }
 181         return FALSE;
 182 }
 183
 184 static void bar_keyword_tree_sync(PaneKeywordsData *pkd)
 185 {
 186         GtkTreeModel *model;
 187
 188         GtkTreeModel *keyword_tree;
 189         GList *keywords;
 190
 191         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 192         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 193
 194         keywords = keyword_list_pull(pkd->keyword_view);
 195         keyword_show_set_in(GTK_TREE_STORE(keyword_tree), model, keywords);
 196         if (pkd->hide_unchecked) keyword_hide_unset_in(GTK_TREE_STORE(keyword_tree), model, keywords);
 197         string_list_free(keywords);
 198
 199         gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(model));
 200
 201         if (pkd->expand_checked) gtk_tree_model_foreach(model, bar_keyword_tree_expand_if_set_cb, pkd);
 202         if (pkd->collapse_unchecked) gtk_tree_model_foreach(model, bar_keyword_tree_collapse_if_unset_cb, pkd);
 203 }
 204
 205 static void bar_pane_keywords_update(PaneKeywordsData *pkd)
 206 {
 207         GList *keywords = NULL;
 208         GList *orig_keywords = NULL;
 209         GList *work1, *work2;
 210         GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
 211
 212         keywords = metadata_read_list(pkd->fd, KEYWORD_KEY, METADATA_PLAIN);
 213         orig_keywords = keyword_list_pull(pkd->keyword_view);
 214
 215         /* compare the lists */
 216         work1 = keywords;
 217         work2 = orig_keywords;
 218
 219         while (work1 && work2)
 220                 {
 221                 if (strcmp(work1->data, work2->data) != 0) break;
 222                 work1 = work1->next;
 223                 work2 = work2->next;
 224                 }
 225
 226         if (work1 || work2) /* lists differs */
 227                 {
 228                 g_signal_handlers_block_by_func(keyword_buffer, bar_pane_keywords_changed, pkd);
 229                 keyword_list_push(pkd->keyword_view, keywords);
 230                 bar_keyword_tree_sync(pkd);
 231                 g_signal_handlers_unblock_by_func(keyword_buffer, bar_pane_keywords_changed, pkd);
 232                 }
 233         string_list_free(keywords);
 234         string_list_free(orig_keywords);
 235 }
 236
 237 void bar_pane_keywords_set_fd(GtkWidget *pane, FileData *fd)
 238 {
 239         PaneKeywordsData *pkd;
 240
 241         pkd = g_object_get_data(G_OBJECT(pane), "pane_data");
 242         if (!pkd) return;
 243
 244         file_data_unref(pkd->fd);
 245         pkd->fd = file_data_ref(fd);
 246
 247         bar_pane_keywords_update(pkd);
 248 }
 249
 250 static void bar_pane_keywords_write_config(GtkWidget *pane, GString *outstr, gint indent)
 251 {
 252         PaneKeywordsData *pkd;
 253
 254         pkd = g_object_get_data(G_OBJECT(pane), "pane_data");
 255         if (!pkd) return;
 256
 257         pkd->height = options->info_keywords.height;
 258
 259         WRITE_NL(); WRITE_STRING("<pane_keywords ");
 260         write_char_option(outstr, indent, "id", pkd->pane.id);
 261         write_char_option(outstr, indent, "title", gtk_label_get_text(GTK_LABEL(pkd->pane.title)));
 262         WRITE_BOOL(pkd->pane, expanded);
 263         WRITE_CHAR(*pkd, key);
 264         WRITE_INT(*pkd, height);
 265         WRITE_STRING("/>");
 266 }
 267
 268 gint bar_pane_keywords_event(GtkWidget *bar, GdkEvent *event)
 269 {
 270         PaneKeywordsData *pkd;
 271
 272         pkd = g_object_get_data(G_OBJECT(bar), "pane_data");
 273         if (!pkd) return FALSE;
 274
 275         if (gtk_widget_has_focus(pkd->keyword_view)) return gtk_widget_event(pkd->keyword_view, event);
 276
 277         return FALSE;
 278 }
 279
 280 static void bar_pane_keywords_keyword_toggle(GtkCellRendererToggle *toggle, const gchar *path, gpointer data)
 281 {
 282         PaneKeywordsData *pkd = data;
 283         GtkTreeModel *model;
 284         GtkTreeIter iter;
 285         GtkTreePath *tpath;
 286         gboolean active;
 287         GList *list;
 288         GtkTreeIter child_iter;
 289         GtkTreeModel *keyword_tree;
 290
 291         GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
 292
 293         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 294
 295         tpath = gtk_tree_path_new_from_string(path);
 296         gtk_tree_model_get_iter(model, &iter, tpath);
 297         gtk_tree_path_free(tpath);
 298
 299         gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_TOGGLE, &active, -1);
 300         active = (!active);
 301
 302
 303         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 304         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
 305
 306         list = keyword_list_pull(pkd->keyword_view);
 307         if (active)
 308                 keyword_tree_set(keyword_tree, &child_iter, &list);
 309         else
 310                 keyword_tree_reset(keyword_tree, &child_iter, &list);
 311
 312         g_signal_handlers_block_by_func(keyword_buffer, bar_pane_keywords_changed, pkd);
 313         keyword_list_push(pkd->keyword_view, list);
 314         string_list_free(list);
 315         g_signal_handlers_unblock_by_func(keyword_buffer, bar_pane_keywords_changed, pkd);
 316
 317         /* call this just once in the end */
 318         bar_pane_keywords_changed(keyword_buffer, pkd);
 319 }
 320
 321 void bar_pane_keywords_filter_modify(GtkTreeModel *model, GtkTreeIter *iter, GValue *value, gint column, gpointer data)
 322 {
 323         PaneKeywordsData *pkd = data;
 324         GtkTreeModel *keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 325         GtkTreeIter child_iter;
 326
 327         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, iter);
 328
 329         memset(value, 0, sizeof (GValue));
 330
 331         switch (column)
 332                 {
 333                 case FILTER_KEYWORD_COLUMN_TOGGLE:
 334                         {
 335                         GList *keywords = keyword_list_pull(pkd->keyword_view);
 336                         gboolean set = keyword_tree_is_set(keyword_tree, &child_iter, keywords);
 337                         string_list_free(keywords);
 338
 339                         g_value_init(value, G_TYPE_BOOLEAN);
 340                         g_value_set_boolean(value, set);
 341                         break;
 342                         }
 343                 case FILTER_KEYWORD_COLUMN_MARK:
 344                         gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_MARK, value);
 345                         break;
 346                 case FILTER_KEYWORD_COLUMN_NAME:
 347                         gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_NAME, value);
 348                         break;
 349                 case FILTER_KEYWORD_COLUMN_IS_KEYWORD:
 350                         gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_IS_KEYWORD, value);
 351                         break;
 352                 }
 353         return;
 354
 355 }
 356
 357 gboolean bar_pane_keywords_filter_visible(GtkTreeModel *keyword_tree, GtkTreeIter *iter, gpointer data)
 358 {
 359         GtkTreeModel *filter = data;
 360
 361         return !keyword_is_hidden_in(keyword_tree, iter, filter);
 362 }
 363
 364 static void bar_pane_keywords_set_selection(PaneKeywordsData *pkd, gboolean append)
 365 {
 366         GList *keywords = NULL;
 367         GList *list = NULL;
 368         GList *work;
 369
 370         keywords = keyword_list_pull(pkd->keyword_view);
 371
 372         list = layout_selection_list(pkd->pane.lw);
 373         list = file_data_process_groups_in_selection(list, FALSE, NULL);
 374
 375         work = list;
 376         while (work)
 377                 {
 378                 FileData *fd = work->data;
 379                 work = work->next;
 380
 381                 if (append)
 382                         {
 383                         metadata_append_list(fd, KEYWORD_KEY, keywords);
 384                         }
 385                 else
 386                         {
 387                         metadata_write_list(fd, KEYWORD_KEY, keywords);
 388                         }
 389                 }
 390
 391         filelist_free(list);
 392         string_list_free(keywords);
 393 }
 394
 395 static void bar_pane_keywords_sel_add_cb(GtkWidget *button, gpointer data)
 396 {
 397         PaneKeywordsData *pkd = data;
 398
 399         bar_pane_keywords_set_selection(pkd, TRUE);
 400 }
 401
 402 static void bar_pane_keywords_sel_replace_cb(GtkWidget *button, gpointer data)
 403 {
 404         PaneKeywordsData *pkd = data;
 405
 406         bar_pane_keywords_set_selection(pkd, FALSE);
 407 }
 408
 409 static void bar_pane_keywords_populate_popup_cb(GtkTextView *textview, GtkMenu *menu, gpointer data)
 410 {
 411         PaneKeywordsData *pkd = data;
 412
 413         menu_item_add_divider(GTK_WIDGET(menu));
 414         menu_item_add_stock(GTK_WIDGET(menu), _("Add keywords to selected files"), GTK_STOCK_ADD, G_CALLBACK(bar_pane_keywords_sel_add_cb), pkd);
 415         menu_item_add_stock(GTK_WIDGET(menu), _("Replace existing keywords in selected files"), GTK_STOCK_CONVERT, G_CALLBACK(bar_pane_keywords_sel_replace_cb), pkd);
 416 }
 417
 418
 419 static void bar_pane_keywords_notify_cb(FileData *fd, NotifyType type, gpointer data)
 420 {
 421         PaneKeywordsData *pkd = data;
 422         if ((type & (NOTIFY_REREAD | NOTIFY_CHANGE | NOTIFY_METADATA)) && fd == pkd->fd)
 423                 {
 424                 DEBUG_1("Notify pane_keywords: %s %04x", fd->path, type);
 425                 bar_pane_keywords_update(pkd);
 426                 }
 427 }
 428
 429 static gboolean bar_pane_keywords_changed_idle_cb(gpointer data)
 430 {
 431         PaneKeywordsData *pkd = data;
 432
 433         bar_pane_keywords_write(pkd);
 434         bar_keyword_tree_sync(pkd);
 435         pkd->idle_id = 0;
 436         return FALSE;
 437 }
 438
 439 static void bar_pane_keywords_changed(GtkTextBuffer *buffer, gpointer data)
 440 {
 441         PaneKeywordsData *pkd = data;
 442
 443         if (pkd->idle_id) return;
 444         /* higher prio than redraw */
 445         pkd->idle_id = g_idle_add_full(G_PRIORITY_HIGH_IDLE, bar_pane_keywords_changed_idle_cb, pkd, NULL);
 446 }
 447
 448
 449 /*
 450  *-------------------------------------------------------------------
 451  * dnd
 452  *-------------------------------------------------------------------
 453  */
 454
 455
 456 static GtkTargetEntry bar_pane_keywords_drag_types[] = {
 457         { TARGET_APP_KEYWORD_PATH_STRING, GTK_TARGET_SAME_WIDGET, TARGET_APP_KEYWORD_PATH },
 458         { "text/plain", 0, TARGET_TEXT_PLAIN }
 459 };
 460 static gint n_keywords_drag_types = 2;
 461
 462
 463 static GtkTargetEntry bar_pane_keywords_drop_types[] = {
 464         { TARGET_APP_KEYWORD_PATH_STRING, GTK_TARGET_SAME_WIDGET, TARGET_APP_KEYWORD_PATH },
 465         { "text/plain", 0, TARGET_TEXT_PLAIN }
 466 };
 467 static gint n_keywords_drop_types = 2;
 468
 469
 470 static void bar_pane_keywords_dnd_get(GtkWidget *tree_view, GdkDragContext *context,
 471                                      GtkSelectionData *selection_data, guint info,
 472                                      guint time, gpointer data)
 473 {
 474         GtkTreeIter iter;
 475         GtkTreeModel *model;
 476         GtkTreeIter child_iter;
 477         GtkTreeModel *keyword_tree;
 478
 479         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
 480
 481         if (!gtk_tree_selection_get_selected(sel, &model, &iter)) return;
 482
 483         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 484         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
 485
 486         switch (info)
 487                 {
 488                 case TARGET_APP_KEYWORD_PATH:
 489                         {
 490                         GList *path = keyword_tree_get_path(keyword_tree, &child_iter);
 491                         gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
 492                                                8, (gpointer) &path, sizeof(path));
 493                         break;
 494                         }
 495
 496                 case TARGET_TEXT_PLAIN:
 497                 default:
 498                         {
 499                         gchar *name = keyword_get_name(keyword_tree, &child_iter);
 500                         gtk_selection_data_set_text(selection_data, name, -1);
 501                         g_free(name);
 502                         }
 503                         break;
 504                 }
 505 }
 506
 507 static void bar_pane_keywords_dnd_begin(GtkWidget *tree_view, GdkDragContext *context, gpointer data)
 508 {
 509         GtkTreeIter iter;
 510         GtkTreeModel *model;
 511         GtkTreeIter child_iter;
 512         GtkTreeModel *keyword_tree;
 513         gchar *name;
 514
 515         GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
 516
 517         if (!gtk_tree_selection_get_selected(sel, &model, &iter)) return;
 518
 519         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 520         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
 521
 522         name = keyword_get_name(keyword_tree, &child_iter);
 523
 524         dnd_set_drag_label(tree_view, context, name);
 525         g_free(name);
 526
 527 }
 528
 529 static void bar_pane_keywords_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
 530 {
 531 }
 532
 533
 534 static gboolean bar_pane_keywords_dnd_can_move(GtkTreeModel *keyword_tree, GtkTreeIter *src_kw_iter, GtkTreeIter *dest_kw_iter)
 535 {
 536         gchar *src_name;
 537         GtkTreeIter parent;
 538
 539         if (dest_kw_iter && keyword_same_parent(keyword_tree, src_kw_iter, dest_kw_iter))
 540                 {
 541                 return TRUE; /* reordering of siblings is ok */
 542                 }
 543         if (!dest_kw_iter && !gtk_tree_model_iter_parent(keyword_tree, &parent, src_kw_iter))
 544                 {
 545                 return TRUE; /* reordering of top-level siblings is ok */
 546                 }
 547
 548         src_name = keyword_get_name(keyword_tree, src_kw_iter);
 549         if (keyword_exists(keyword_tree, NULL, dest_kw_iter, src_name, FALSE, NULL))
 550                 {
 551                 g_free(src_name);
 552                 return FALSE;
 553         }
 554         g_free(src_name);
 555         return TRUE;
 556 }
 557
 558 static gboolean bar_pane_keywords_dnd_skip_existing(GtkTreeModel *keyword_tree, GtkTreeIter *dest_kw_iter, GList **keywords)
 559 {
 560         /* we have to find at least one keyword that does not already exist as a sibling of dest_kw_iter */
 561         GList *work = *keywords;
 562         while (work)
 563                 {
 564                 gchar *keyword = work->data;
 565                 if (keyword_exists(keyword_tree, NULL, dest_kw_iter, keyword, FALSE, NULL))
 566                         {
 567                         GList *next = work->next;
 568                         g_free(keyword);
 569                         *keywords = g_list_delete_link(*keywords, work);
 570                         work = next;
 571                         }
 572                 else
 573                         {
 574                         work = work->next;
 575                         }
 576                 }
 577         return !!*keywords;
 578 }
 579
 580 static void bar_pane_keywords_dnd_receive(GtkWidget *tree_view, GdkDragContext *context,
 581                                           gint x, gint y,
 582                                           GtkSelectionData *selection_data, guint info,
 583                                           guint time, gpointer data)
 584 {
 585         PaneKeywordsData *pkd = data;
 586         GtkTreePath *tpath = NULL;
 587         GtkTreeViewDropPosition pos;
 588         GtkTreeModel *model;
 589
 590         GtkTreeModel *keyword_tree;
 591         gboolean src_valid = FALSE;
 592         GList *new_keywords = NULL;
 593         GList *work;
 594
 595         /* iterators for keyword_tree */
 596         GtkTreeIter src_kw_iter;
 597         GtkTreeIter dest_kw_iter;
 598         GtkTreeIter new_kw_iter;
 599
 600         g_signal_stop_emission_by_name(tree_view, "drag_data_received");
 601
 602         model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
 603         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 604
 605         gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos);
 606         gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), NULL, pos);
 607
 608         switch (info)
 609                 {
 610                 case TARGET_APP_KEYWORD_PATH:
 611                         {
 612                         GList *path = *(gpointer *)gtk_selection_data_get_data(selection_data);
 613                         src_valid = keyword_tree_get_iter(keyword_tree, &src_kw_iter, path);
 614                         string_list_free(path);
 615                         break;
 616                         }
 617                 default:
 618                         new_keywords = string_to_keywords_list((gchar *)gtk_selection_data_get_data(selection_data));
 619                         break;
 620                 }
 621
 622         if (tpath)
 623                 {
 624                 GtkTreeIter dest_iter;
 625                 gtk_tree_model_get_iter(model, &dest_iter, tpath);
 626                 gtk_tree_path_free(tpath);
 627                 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &dest_kw_iter, &dest_iter);
 628
 629                 if (src_valid && gtk_tree_store_is_ancestor(GTK_TREE_STORE(keyword_tree), &src_kw_iter, &dest_kw_iter))
 630                         {
 631                         /* can't move to it's own child */
 632                         return;
 633                         }
 634
 635                 if (src_valid && keyword_compare(keyword_tree, &src_kw_iter, &dest_kw_iter) == 0)
 636                         {
 637                         /* can't move to itself */
 638                         return;
 639                         }
 640
 641                 if ((pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE || pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER) &&
 642                     !gtk_tree_model_iter_has_child(keyword_tree, &dest_kw_iter))
 643                         {
 644                         /* the node has no children, all keywords can be added */
 645                         gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &dest_kw_iter);
 646                         }
 647                 else
 648                         {
 649                         if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, &dest_kw_iter))
 650                                 {
 651                                 /* the keyword can't be moved if the same name already exist */
 652                                 return;
 653                                 }
 654                         if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, &dest_kw_iter, &new_keywords))
 655                                 {
 656                                 /* the keywords can't be added if the same name already exist */
 657                                 return;
 658                                 }
 659
 660                         switch (pos)
 661                                 {
 662                                 case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
 663                                 case GTK_TREE_VIEW_DROP_BEFORE:
 664                                         gtk_tree_store_insert_before(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL, &dest_kw_iter);
 665                                         break;
 666                                 case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
 667                                 case GTK_TREE_VIEW_DROP_AFTER:
 668                                         gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL, &dest_kw_iter);
 669                                         break;
 670                                 }
 671                         }
 672
 673                 }
 674         else
 675                 {
 676                 if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, NULL))
 677                         {
 678                         /* the keyword can't be moved if the same name already exist */
 679                         return;
 680                         }
 681                 if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, NULL, &new_keywords))
 682                         {
 683                         /* the keywords can't be added if the same name already exist */
 684                         return;
 685                         }
 686                 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, NULL);
 687                 }
 688
 689
 690         if (src_valid)
 691                 {
 692                 keyword_move_recursive(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &src_kw_iter);
 693                 }
 694
 695         work = new_keywords;
 696         while (work)
 697                 {
 698                 gchar *keyword = work->data;
 699                 keyword_set(GTK_TREE_STORE(keyword_tree), &new_kw_iter, keyword, TRUE);
 700                 work = work->next;
 701
 702                 if (work)
 703                         {
 704                         GtkTreeIter add;
 705                         gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, NULL, &new_kw_iter);
 706                         new_kw_iter = add;
 707                         }
 708                 }
 709         string_list_free(new_keywords);
 710         bar_keyword_tree_sync(pkd);
 711 }
 712
 713 static gint bar_pane_keywords_dnd_motion(GtkWidget *tree_view, GdkDragContext *context,
 714                                         gint x, gint y, guint time, gpointer data)
 715 {
 716         GtkTreePath *tpath = NULL;
 717         GtkTreeViewDropPosition pos;
 718         gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos);
 719         if (tpath)
 720                 {
 721                 GtkTreeModel *model;
 722                 GtkTreeIter dest_iter;
 723                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
 724                 gtk_tree_model_get_iter(model, &dest_iter, tpath);
 725                 if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE && gtk_tree_model_iter_has_child(model, &dest_iter))
 726                         pos = GTK_TREE_VIEW_DROP_BEFORE;
 727
 728                 if (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER && gtk_tree_model_iter_has_child(model, &dest_iter))
 729                         pos = GTK_TREE_VIEW_DROP_AFTER;
 730                 }
 731
 732         gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), tpath, pos);
 733         gtk_tree_path_free(tpath);
 734
 735         if (tree_view == gtk_drag_get_source_widget(context))
 736                 gdk_drag_status(context, GDK_ACTION_MOVE, time);
 737         else
 738                 gdk_drag_status(context, GDK_ACTION_COPY, time);
 739
 740         return TRUE;
 741 }
 742
 743 /*
 744  *-------------------------------------------------------------------
 745  * edit dialog
 746  *-------------------------------------------------------------------
 747  */
 748
 749 static void bar_pane_keywords_edit_destroy_cb(GtkWidget *widget, gpointer data)
 750 {
 751         ConfDialogData *cdd = data;
 752         gtk_tree_path_free(cdd->click_tpath);
 753         g_free(cdd);
 754 }
 755
 756
 757 static void bar_pane_keywords_edit_cancel_cb(GenericDialog *gd, gpointer data)
 758 {
 759 }
 760
 761
 762 static void bar_pane_keywords_edit_ok_cb(GenericDialog *gd, gpointer data)
 763 {
 764         ConfDialogData *cdd = data;
 765         PaneKeywordsData *pkd = cdd->pkd;
 766         GtkTreeModel *model;
 767
 768         GtkTreeModel *keyword_tree;
 769         GtkTreeIter kw_iter;
 770
 771         gboolean have_dest = FALSE;
 772
 773         GList *keywords;
 774
 775         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 776         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 777
 778         if (cdd->click_tpath)
 779                 {
 780                 GtkTreeIter iter;
 781                 if (gtk_tree_model_get_iter(model, &iter, cdd->click_tpath))
 782                         {
 783                         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
 784                         have_dest = TRUE;
 785                         }
 786                 }
 787
 788         if (cdd->edit_existing && !have_dest) return;
 789
 790         keywords = keyword_list_pull(cdd->edit_widget);
 791
 792         if (cdd->edit_existing)
 793                 {
 794                 if (keywords && keywords->data && /* there should be one keyword */
 795                     !keyword_exists(keyword_tree, NULL, &kw_iter, keywords->data, TRUE, NULL))
 796                         {
 797                         keyword_set(GTK_TREE_STORE(keyword_tree), &kw_iter, keywords->data, cdd->is_keyword);
 798                         }
 799                 }
 800         else
 801                 {
 802                 GList *work = keywords;
 803                 gboolean append_to = FALSE;
 804
 805                 while (work)
 806                         {
 807                         GtkTreeIter add;
 808                         if (keyword_exists(keyword_tree, NULL, (have_dest || append_to) ? &kw_iter : NULL, work->data, FALSE, NULL))
 809                                 {
 810                                 work = work->next;
 811                                 continue;
 812                                 }
 813                         if (have_dest)
 814                                 {
 815                                 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, &kw_iter);
 816                                 }
 817                         else if (append_to)
 818                                 {
 819                                 gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, NULL, &kw_iter);
 820                                 }
 821                         else
 822                                 {
 823                                 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, NULL);
 824                                 append_to = TRUE;
 825                                 kw_iter = add;
 826                                 }
 827                         keyword_set(GTK_TREE_STORE(keyword_tree), &add, work->data, cdd->is_keyword);
 828                         work = work->next;
 829                         }
 830                 }
 831         string_list_free(keywords);
 832 }
 833
 834 static void bar_pane_keywords_conf_set_helper(GtkWidget *widget, gpointer data)
 835 {
 836         ConfDialogData *cdd = data;
 837         cdd->is_keyword = FALSE;
 838 }
 839
 840 static void bar_pane_keywords_conf_set_kw(GtkWidget *widget, gpointer data)
 841 {
 842         ConfDialogData *cdd = data;
 843         cdd->is_keyword = TRUE;
 844 }
 845
 846
 847
 848 static void bar_pane_keywords_edit_dialog(PaneKeywordsData *pkd, gboolean edit_existing)
 849 {
 850         ConfDialogData *cdd;
 851         GenericDialog *gd;
 852         GtkWidget *table;
 853         GtkWidget *group;
 854         GtkWidget *button;
 855
 856         gchar *name = NULL;
 857         gboolean is_keyword = TRUE;
 858
 859
 860         if (edit_existing && pkd->click_tpath)
 861                 {
 862                 GtkTreeModel *model;
 863                 GtkTreeIter iter;
 864                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 865
 866                 if (gtk_tree_model_get_iter(model, &iter, pkd->click_tpath))
 867                         {
 868                         gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name,
 869                                                          FILTER_KEYWORD_COLUMN_IS_KEYWORD, &is_keyword, -1);
 870                         }
 871                 else
 872                         {
 873                         return;
 874                         }
 875                 }
 876
 877         if (edit_existing && !name) return;
 878
 879
 880         cdd = g_new0(ConfDialogData, 1);
 881         cdd->pkd =pkd;
 882         cdd->click_tpath = pkd->click_tpath;
 883         pkd->click_tpath = NULL;
 884         cdd->edit_existing = edit_existing;
 885
 886         cdd->gd = gd = generic_dialog_new(name ? _("Edit keyword") : _("New keyword"), "keyword_edit",
 887                                 pkd->widget, TRUE,
 888                                 bar_pane_keywords_edit_cancel_cb, cdd);
 889         g_signal_connect(G_OBJECT(gd->dialog), "destroy",
 890                          G_CALLBACK(bar_pane_keywords_edit_destroy_cb), cdd);
 891
 892
 893         generic_dialog_add_message(gd, NULL, name ? _("Configure keyword") : _("New keyword"), NULL);
 894
 895         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
 896                                   bar_pane_keywords_edit_ok_cb, TRUE);
 897
 898         table = pref_table_new(gd->vbox, 3, 1, FALSE, TRUE);
 899         pref_table_label(table, 0, 0, _("Keyword:"), 1.0);
 900         cdd->edit_widget = gtk_entry_new();
 901         gtk_widget_set_size_request(cdd->edit_widget, 300, -1);
 902         if (name) gtk_entry_set_text(GTK_ENTRY(cdd->edit_widget), name);
 903         gtk_table_attach_defaults(GTK_TABLE(table), cdd->edit_widget, 1, 2, 0, 1);
 904         /* here could eventually be a text view instead of entry */
 905         generic_dialog_attach_default(gd, cdd->edit_widget);
 906         gtk_widget_show(cdd->edit_widget);
 907
 908         group = pref_group_new(gd->vbox, FALSE, _("Keyword type:"), GTK_ORIENTATION_VERTICAL);
 909
 910         button = pref_radiobutton_new(group, NULL, _("Active keyword"),
 911                                       (is_keyword),
 912                                       G_CALLBACK(bar_pane_keywords_conf_set_kw), cdd);
 913         button = pref_radiobutton_new(group, button, _("Helper"),
 914                                       (!is_keyword),
 915                                       G_CALLBACK(bar_pane_keywords_conf_set_helper), cdd);
 916
 917         cdd->is_keyword = is_keyword;
 918
 919         g_free(name);
 920
 921         gtk_widget_grab_focus(cdd->edit_widget);
 922
 923         gtk_widget_show(gd->dialog);
 924 }
 925
 926
 927
 928
 929 /*
 930  *-------------------------------------------------------------------
 931  * popup menu
 932  *-------------------------------------------------------------------
 933  */
 934
 935 static void bar_pane_keywords_edit_dialog_cb(GtkWidget *menu_widget, gpointer data)
 936 {
 937         PaneKeywordsData *pkd = data;
 938         bar_pane_keywords_edit_dialog(pkd, TRUE);
 939 }
 940
 941 static void bar_pane_keywords_add_dialog_cb(GtkWidget *menu_widget, gpointer data)
 942 {
 943         PaneKeywordsData *pkd = data;
 944         bar_pane_keywords_edit_dialog(pkd, FALSE);
 945 }
 946
 947 static void bar_pane_keywords_connect_mark_cb(GtkWidget *menu_widget, gpointer data)
 948 {
 949         PaneKeywordsData *pkd = data;
 950
 951         GtkTreeModel *model;
 952         GtkTreeIter iter;
 953
 954         GtkTreeModel *keyword_tree;
 955         GtkTreeIter kw_iter;
 956
 957         gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu_widget), "mark")) - 1;
 958
 959         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 960         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 961
 962         if (!pkd->click_tpath) return;
 963         if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
 964
 965         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
 966
 967         meta_data_connect_mark_with_keyword(keyword_tree, &kw_iter, mark);
 968 }
 969
 970
 971 static void bar_pane_keywords_delete_cb(GtkWidget *menu_widget, gpointer data)
 972 {
 973         PaneKeywordsData *pkd = data;
 974         GtkTreeModel *model;
 975         GtkTreeIter iter;
 976
 977         GtkTreeModel *keyword_tree;
 978         GtkTreeIter kw_iter;
 979
 980         if (!pkd->click_tpath) return;
 981
 982         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 983         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 984
 985         if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
 986         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
 987
 988         keyword_delete(GTK_TREE_STORE(keyword_tree), &kw_iter);
 989 }
 990
 991 static void bar_pane_keywords_hide_cb(GtkWidget *menu_widget, gpointer data)
 992 {
 993         PaneKeywordsData *pkd = data;
 994         GtkTreeModel *model;
 995         GtkTreeIter iter;
 996
 997         GtkTreeModel *keyword_tree;
 998         GtkTreeIter kw_iter;
 999
1000         if (!pkd->click_tpath) return;
1001
1002         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1003         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1004
1005         if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1006         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
1007
1008         keyword_hide_in(GTK_TREE_STORE(keyword_tree), &kw_iter, model);
1009 }
1010
1011 static void bar_pane_keywords_show_all_cb(GtkWidget *menu_widget, gpointer data)
1012 {
1013         PaneKeywordsData *pkd = data;
1014         GtkTreeModel *model;
1015
1016         GtkTreeModel *keyword_tree;
1017
1018         pkd->hide_unchecked = FALSE;
1019
1020         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1021         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1022
1023         keyword_show_all_in(GTK_TREE_STORE(keyword_tree), model);
1024
1025         if (!pkd->collapse_unchecked) gtk_tree_view_expand_all(GTK_TREE_VIEW(pkd->keyword_treeview));
1026         bar_keyword_tree_sync(pkd);
1027 }
1028
1029 static void bar_pane_keywords_expand_checked_cb(GtkWidget *menu_widget, gpointer data)
1030 {
1031         PaneKeywordsData *pkd = data;
1032         GtkTreeModel *model;
1033
1034         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1035         gtk_tree_model_foreach(model, bar_keyword_tree_expand_if_set_cb, pkd);
1036 }
1037
1038 static void bar_pane_keywords_collapse_unchecked_cb(GtkWidget *menu_widget, gpointer data)
1039 {
1040         PaneKeywordsData *pkd = data;
1041         GtkTreeModel *model;
1042
1043         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1044         gtk_tree_model_foreach(model, bar_keyword_tree_collapse_if_unset_cb, pkd);
1045 }
1046
1047 static void bar_pane_keywords_hide_unchecked_cb(GtkWidget *menu_widget, gpointer data)
1048 {
1049         PaneKeywordsData *pkd = data;
1050         GtkTreeModel *model;
1051
1052         GtkTreeModel *keyword_tree;
1053         GList *keywords;
1054
1055         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1056         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1057
1058         keywords = keyword_list_pull(pkd->keyword_view);
1059         keyword_hide_unset_in(GTK_TREE_STORE(keyword_tree), model, keywords);
1060         string_list_free(keywords);
1061         bar_keyword_tree_sync(pkd);
1062 }
1063
1064 static void bar_pane_keywords_expand_checked_toggle_cb(GtkWidget *menu_widget, gpointer data)
1065 {
1066         PaneKeywordsData *pkd = data;
1067         pkd->expand_checked = !pkd->expand_checked;
1068         bar_keyword_tree_sync(pkd);
1069 }
1070
1071 static void bar_pane_keywords_collapse_unchecked_toggle_cb(GtkWidget *menu_widget, gpointer data)
1072 {
1073         PaneKeywordsData *pkd = data;
1074         pkd->collapse_unchecked = !pkd->collapse_unchecked;
1075         bar_keyword_tree_sync(pkd);
1076 }
1077
1078 static void bar_pane_keywords_hide_unchecked_toggle_cb(GtkWidget *menu_widget, gpointer data)
1079 {
1080         PaneKeywordsData *pkd = data;
1081         pkd->hide_unchecked = !pkd->hide_unchecked;
1082         bar_keyword_tree_sync(pkd);
1083 }
1084
1085 /**
1086  * \brief Callback for adding selected keyword to all selected images.
1087  */
1088 static void bar_pane_keywords_add_to_selected_cb(GtkWidget *menu_widget, gpointer data)
1089 {
1090         PaneKeywordsData *pkd = data;
1091         GtkTreeIter iter; /* This is the iter which initial holds the current keyword */
1092         GtkTreeIter child_iter;
1093         GtkTreeModel *model;
1094         GtkTreeModel *keyword_tree;
1095         GList *list, *work;
1096         GList *keywords = NULL;
1097
1098         GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
1099
1100         /* Aquire selected keyword */
1101         if (pkd->click_tpath)
1102                 {
1103                 gboolean is_keyword = TRUE;
1104
1105                 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1106                 if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1107                 gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_IS_KEYWORD, &is_keyword, -1);
1108                 if (!is_keyword) return;
1109                 }
1110         else
1111                 return;
1112
1113         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1114         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
1115
1116         list = keyword_list_pull(pkd->keyword_view); /* Get the left keyword view */
1117
1118         /* Now set the current image */
1119         keyword_tree_set(keyword_tree, &child_iter, &list);
1120
1121         keyword_list_push(pkd->keyword_view, list); /* Set the left keyword view */
1122         string_list_free(list);
1123
1124         bar_pane_keywords_changed(keyword_buffer, pkd); /* Get list of all keywords in the hierarchy */
1125
1126         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
1127         keywords = keyword_tree_get(keyword_tree, &child_iter);
1128
1129         list = layout_selection_list(pkd->pane.lw);
1130         work = list;
1131         while (work)
1132                 {
1133                 FileData *fd = work->data;
1134                 work = work->next;
1135                 metadata_append_list(fd, KEYWORD_KEY, keywords);
1136                 }
1137         filelist_free(list);
1138         string_list_free(keywords);
1139 }
1140
1141 static void bar_pane_keywords_menu_popup(GtkWidget *widget, PaneKeywordsData *pkd, gint x, gint y)
1142 {
1143         GtkWidget *menu;
1144         GtkWidget *item;
1145         GtkWidget *submenu;
1146         GtkTreeViewDropPosition pos;
1147
1148         if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);
1149         pkd->click_tpath = NULL;
1150         gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(pkd->keyword_treeview), x, y, &pkd->click_tpath, &pos);
1151
1152         menu = popup_menu_short_lived();
1153
1154         menu_item_add_stock(menu, _("New keyword"), GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_add_dialog_cb), pkd);
1155
1156         menu_item_add_divider(menu);
1157
1158         menu_item_add(menu, _("Add keyword to all selected images"), G_CALLBACK(bar_pane_keywords_add_to_selected_cb), pkd);
1159
1160         menu_item_add_divider(menu);
1161
1162         if (pkd->click_tpath)
1163                 {
1164                 /* for the entry */
1165                 gchar *text;
1166                 gchar *mark;
1167                 gint i;
1168
1169                 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1170
1171                 GtkTreeIter iter;
1172                 gtk_tree_model_get_iter(model, &iter, pkd->click_tpath);
1173                 gchar *name;
1174
1175                 gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name,
1176                                                  FILTER_KEYWORD_COLUMN_MARK, &mark, -1);
1177
1178                 text = g_strdup_printf(_("Hide \"%s\""), name);
1179                 menu_item_add_stock(menu, text, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_hide_cb), pkd);
1180                 g_free(text);
1181
1182                 submenu = gtk_menu_new();
1183                 for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
1184                         {
1185                         text = g_strdup_printf(_("Mark %d"), i + 1);
1186                         item = menu_item_add(submenu, text, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
1187                         g_object_set_data(G_OBJECT(item), "mark", GINT_TO_POINTER(i + 1));
1188                         g_free(text);
1189                         }
1190                 text = g_strdup_printf(_("Connect \"%s\" to mark"), name);
1191                 item = menu_item_add(menu, text, NULL, NULL);
1192                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
1193                 g_free(text);
1194
1195                 menu_item_add_divider(menu);
1196
1197                 text = g_strdup_printf(_("Edit \"%s\""), name);
1198                 menu_item_add_stock(menu, text, GTK_STOCK_EDIT, G_CALLBACK(bar_pane_keywords_edit_dialog_cb), pkd);
1199                 g_free(text);
1200                 text = g_strdup_printf(_("Remove \"%s\""), name);
1201                 menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_delete_cb), pkd);
1202                 g_free(text);
1203
1204
1205                 if (mark && mark[0])
1206                         {
1207                         text = g_strdup_printf(_("Disconnect \"%s\" from mark %s"), name, mark);
1208                         menu_item_add_stock(menu, text, GTK_STOCK_DELETE, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
1209                         g_free(text);
1210                         }
1211
1212                 menu_item_add_divider(menu);
1213                 g_free(mark);
1214                 g_free(name);
1215                 }
1216         /* for the pane */
1217
1218
1219         menu_item_add(menu, _("Expand checked"), G_CALLBACK(bar_pane_keywords_expand_checked_cb), pkd);
1220         menu_item_add(menu, _("Collapse unchecked"), G_CALLBACK(bar_pane_keywords_collapse_unchecked_cb), pkd);
1221         menu_item_add(menu, _("Hide unchecked"), G_CALLBACK(bar_pane_keywords_hide_unchecked_cb), pkd);
1222         menu_item_add(menu, _("Show all"), G_CALLBACK(bar_pane_keywords_show_all_cb), pkd);
1223
1224         submenu = gtk_menu_new();
1225         item = menu_item_add(menu, _("On any change"), NULL, NULL);
1226         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
1227
1228         menu_item_add_check(submenu, _("Expand checked"), pkd->expand_checked, G_CALLBACK(bar_pane_keywords_expand_checked_toggle_cb), pkd);
1229         menu_item_add_check(submenu, _("Collapse unchecked"), pkd->collapse_unchecked, G_CALLBACK(bar_pane_keywords_collapse_unchecked_toggle_cb), pkd);
1230         menu_item_add_check(submenu, _("Hide unchecked"), pkd->hide_unchecked, G_CALLBACK(bar_pane_keywords_hide_unchecked_toggle_cb), pkd);
1231
1232         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
1233 }
1234
1235
1236 static gboolean bar_pane_keywords_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1237 {
1238         PaneKeywordsData *pkd = data;
1239         if (bevent->button == MOUSE_BUTTON_RIGHT)
1240                 {
1241                 bar_pane_keywords_menu_popup(widget, pkd, bevent->x, bevent->y);
1242                 return TRUE;
1243                 }
1244         return FALSE;
1245 }
1246
1247 /*
1248  *-------------------------------------------------------------------
1249  * init
1250  *-------------------------------------------------------------------
1251  */
1252
1253 void bar_pane_keywords_close(GtkWidget *bar)
1254 {
1255         PaneKeywordsData *pkd;
1256
1257         pkd = g_object_get_data(G_OBJECT(bar), "pane_data");
1258         if (!pkd) return;
1259
1260         g_free(pkd->pane.id);
1261         gtk_widget_destroy(pkd->widget);
1262 }
1263
1264 static void bar_pane_keywords_destroy(GtkWidget *widget, gpointer data)
1265 {
1266         PaneKeywordsData *pkd = data;
1267
1268         if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);
1269         if (pkd->idle_id) g_source_remove(pkd->idle_id);
1270         file_data_unregister_notify_func(bar_pane_keywords_notify_cb, pkd);
1271
1272         file_data_unref(pkd->fd);
1273         g_free(pkd->key);
1274
1275         g_free(pkd);
1276 }
1277
1278
1279 static GtkWidget *bar_pane_keywords_new(const gchar *id, const gchar *title, const gchar *key, gboolean expanded, gint height)
1280 {
1281         PaneKeywordsData *pkd;
1282         GtkWidget *hbox;
1283         GtkWidget *scrolled;
1284         GtkTextBuffer *buffer;
1285         GtkTreeModel *store;
1286         GtkTreeViewColumn *column;
1287         GtkCellRenderer *renderer;
1288         GtkTreeIter iter;
1289
1290         pkd = g_new0(PaneKeywordsData, 1);
1291
1292         pkd->pane.pane_set_fd = bar_pane_keywords_set_fd;
1293         pkd->pane.pane_event = bar_pane_keywords_event;
1294         pkd->pane.pane_write_config = bar_pane_keywords_write_config;
1295         pkd->pane.title = bar_pane_expander_title(title);
1296         pkd->pane.id = g_strdup(id);
1297         pkd->pane.type = PANE_KEYWORDS;
1298
1299         pkd->pane.expanded = expanded;
1300
1301         pkd->height = height;
1302         pkd->key = g_strdup(key);
1303
1304         pkd->expand_checked = TRUE;
1305
1306         hbox = gtk_hbox_new(FALSE, PREF_PAD_GAP);
1307
1308         pkd->widget = hbox;
1309         g_object_set_data(G_OBJECT(pkd->widget), "pane_data", pkd);
1310         g_signal_connect(G_OBJECT(pkd->widget), "destroy",
1311                          G_CALLBACK(bar_pane_keywords_destroy), pkd);
1312         gtk_widget_set_size_request(pkd->widget, -1, height);
1313         gtk_widget_show(hbox);
1314
1315         scrolled = gtk_scrolled_window_new(NULL, NULL);
1316         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
1317         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
1318                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1319         gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
1320         gtk_widget_show(scrolled);
1321
1322         pkd->keyword_view = gtk_text_view_new();
1323         gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_view);
1324         g_signal_connect(G_OBJECT(pkd->keyword_view), "populate-popup",
1325                          G_CALLBACK(bar_pane_keywords_populate_popup_cb), pkd);
1326         gtk_widget_show(pkd->keyword_view);
1327
1328         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
1329         g_signal_connect(G_OBJECT(buffer), "changed",
1330                          G_CALLBACK(bar_pane_keywords_changed), pkd);
1331
1332         scrolled = gtk_scrolled_window_new(NULL, NULL);
1333         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
1334         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
1335                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1336         gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
1337         gtk_widget_show(scrolled);
1338
1339
1340         if (!keyword_tree || !gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_tree), &iter))
1341                 {
1342                 /* keyword tree does not exist or is empty - fill with defaults */
1343                 keyword_tree_new_default();
1344                 }
1345
1346         store = gtk_tree_model_filter_new(GTK_TREE_MODEL(keyword_tree), NULL);
1347
1348         gtk_tree_model_filter_set_modify_func(GTK_TREE_MODEL_FILTER(store),
1349                                               FILTER_KEYWORD_COLUMN_COUNT,
1350                                               filter_keyword_column_types,
1351                                               bar_pane_keywords_filter_modify,
1352                                               pkd,
1353                                               NULL);
1354         gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(store),
1355                                                bar_pane_keywords_filter_visible,
1356                                                store,
1357                                                NULL);
1358
1359         pkd->keyword_treeview = gtk_tree_view_new_with_model(store);
1360         g_object_unref(store);
1361
1362         gtk_widget_set_size_request(pkd->keyword_treeview, -1, 400);
1363
1364         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(pkd->keyword_treeview), FALSE);
1365
1366 //      gtk_tree_view_set_search_column(GTK_TREE_VIEW(pkd->keyword_treeview), FILTER_KEYWORD_COLUMN_);
1367
1368         column = gtk_tree_view_column_new();
1369         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1370
1371         renderer = gtk_cell_renderer_text_new();
1372         gtk_tree_view_column_pack_start(column, renderer, TRUE);
1373
1374         gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_MARK);
1375
1376         gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
1377
1378         column = gtk_tree_view_column_new();
1379         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
1380         renderer = gtk_cell_renderer_toggle_new();
1381         gtk_tree_view_column_pack_start(column, renderer, FALSE);
1382         gtk_tree_view_column_add_attribute(column, renderer, "active", FILTER_KEYWORD_COLUMN_TOGGLE);
1383         gtk_tree_view_column_add_attribute(column, renderer, "visible", FILTER_KEYWORD_COLUMN_IS_KEYWORD);
1384         g_signal_connect(G_OBJECT(renderer), "toggled",
1385                          G_CALLBACK(bar_pane_keywords_keyword_toggle), pkd);
1386
1387         renderer = gtk_cell_renderer_text_new();
1388         gtk_tree_view_column_pack_start(column, renderer, TRUE);
1389         gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_NAME);
1390
1391         gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
1392         gtk_tree_view_set_expander_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
1393
1394         gtk_drag_source_set(pkd->keyword_treeview,
1395                             GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
1396                             bar_pane_keywords_drag_types, n_keywords_drag_types,
1397                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
1398
1399         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_get",
1400                          G_CALLBACK(bar_pane_keywords_dnd_get), pkd);
1401
1402         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_begin",
1403                          G_CALLBACK(bar_pane_keywords_dnd_begin), pkd);
1404         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_end",
1405                          G_CALLBACK(bar_pane_keywords_dnd_end), pkd);
1406
1407         gtk_drag_dest_set(pkd->keyword_treeview,
1408                           GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP,
1409                           bar_pane_keywords_drop_types, n_keywords_drop_types,
1410                           GDK_ACTION_COPY | GDK_ACTION_MOVE);
1411
1412         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_received",
1413                          G_CALLBACK(bar_pane_keywords_dnd_receive), pkd);
1414
1415         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_motion",
1416                          G_CALLBACK(bar_pane_keywords_dnd_motion), pkd);
1417
1418         g_signal_connect(G_OBJECT(pkd->keyword_treeview), "button_release_event",
1419                          G_CALLBACK(bar_pane_keywords_menu_cb), pkd);
1420
1421         gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_treeview);
1422         gtk_widget_show(pkd->keyword_treeview);
1423
1424         file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW);
1425
1426         return pkd->widget;
1427 }
1428
1429 GtkWidget *bar_pane_keywords_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
1430 {
1431         gchar *id = g_strdup("keywords");
1432         gchar *title = NULL;
1433         gchar *key = g_strdup(COMMENT_KEY);
1434         gboolean expanded = TRUE;
1435         gint height = 200;
1436         GtkWidget *ret;
1437
1438         while (*attribute_names)
1439                 {
1440                 const gchar *option = *attribute_names++;
1441                 const gchar *value = *attribute_values++;
1442
1443                 if (READ_CHAR_FULL("id", id)) continue;
1444                 if (READ_CHAR_FULL("title", title)) continue;
1445                 if (READ_CHAR_FULL("key", key)) continue;
1446                 if (READ_BOOL_FULL("expanded", expanded)) continue;
1447                 if (READ_INT_FULL("height", height)) continue;
1448
1449
1450                 log_printf("unknown attribute %s = %s\n", option, value);
1451                 }
1452
1453         options->info_keywords.height = height;
1454         bar_pane_translate_title(PANE_KEYWORDS, id, &title);
1455         ret = bar_pane_keywords_new(id, title, key, expanded, height);
1456         g_free(id);
1457         g_free(title);
1458         g_free(key);
1459         return ret;
1460 }
1461
1462 void bar_pane_keywords_update_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
1463 {
1464         PaneKeywordsData *pkd;
1465
1466         pkd = g_object_get_data(G_OBJECT(pane), "pane_data");
1467         if (!pkd) return;
1468
1469         gchar *title = NULL;
1470
1471         while (*attribute_names)
1472                 {
1473                 const gchar *option = *attribute_names++;
1474                 const gchar *value = *attribute_values++;
1475
1476                 if (READ_CHAR_FULL("title", title)) continue;
1477                 if (READ_CHAR_FULL("key", pkd->key)) continue;
1478                 if (READ_BOOL_FULL("expanded", pkd->pane.expanded)) continue;
1479                 if (READ_CHAR_FULL("id", pkd->pane.id)) continue;
1480
1481
1482                 log_printf("unknown attribute %s = %s\n", option, value);
1483                 }
1484
1485         if (title)
1486                 {
1487                 bar_pane_translate_title(PANE_KEYWORDS, pkd->pane.id, &title);
1488                 gtk_label_set_text(GTK_LABEL(pkd->pane.title), title);
1489                 g_free(title);
1490                 }
1491
1492         bar_update_expander(pane);
1493         bar_pane_keywords_update(pkd);
1494 }
1495
1496
1497 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */