src/bar_keywords.c

   1 /*
   2  * Geeqie
   3  * (C) 2004 John Ellis
   4  * Copyright (C) 2008 - 2009 The Geeqie Team
   5  *
   6  * Author: John Ellis
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13 #include <glib/gprintf.h>
  14
  15 #include "main.h"
  16 #include "bar_keywords.h"
  17
  18 #include "filedata.h"
  19 #include "history_list.h"
  20 #include "metadata.h"
  21 #include "misc.h"
  22 #include "ui_fileops.h"
  23 #include "ui_misc.h"
  24 #include "ui_utildlg.h"
  25 #include "utilops.h"
  26 #include "bar.h"
  27 #include "ui_menu.h"
  28
  29 static const gchar *keyword_favorite_defaults[] = {
  30         N_("Favorite"),
  31         N_("Todo"),
  32         N_("People"),
  33         N_("Places"),
  34         N_("Art"),
  35         N_("Nature"),
  36         N_("Possessions"),
  37         NULL
  38 };
  39
  40
  41 static void bar_pane_keywords_keyword_update_all(void);
  42 static void bar_pane_keywords_changed(GtkTextBuffer *buffer, gpointer data);
  43
  44 /*
  45  *-------------------------------------------------------------------
  46  * keyword / comment utils
  47  *-------------------------------------------------------------------
  48  */
  49
  50
  51 GList *keyword_list_pull(GtkWidget *text_widget)
  52 {
  53         GList *list;
  54         gchar *text;
  55
  56         text = text_widget_text_pull(text_widget);
  57         list = string_to_keywords_list(text);
  58
  59         g_free(text);
  60
  61         return list;
  62 }
  63
  64 static void keyword_list_push(GtkWidget *textview, GList *list)
  65 {
  66         GtkTextBuffer *buffer;
  67         GtkTextIter start, end;
  68
  69         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
  70         gtk_text_buffer_get_bounds(buffer, &start, &end);
  71         gtk_text_buffer_delete(buffer, &start, &end);
  72
  73         while (list)
  74                 {
  75                 const gchar *word = list->data;
  76                 GtkTextIter iter;
  77
  78                 gtk_text_buffer_get_end_iter(buffer, &iter);
  79                 if (word) gtk_text_buffer_insert(buffer, &iter, word, -1);
  80                 gtk_text_buffer_get_end_iter(buffer, &iter);
  81                 gtk_text_buffer_insert(buffer, &iter, "\n", -1);
  82
  83                 list = list->next;
  84                 }
  85 }
  86
  87
  88 /*
  89  *-------------------------------------------------------------------
  90  * keyword list dialog
  91  *-------------------------------------------------------------------
  92  */
  93
  94 #define KEYWORD_DIALOG_WIDTH  200
  95 #define KEYWORD_DIALOG_HEIGHT 250
  96
  97 typedef struct _KeywordDlg KeywordDlg;
  98 struct _KeywordDlg
  99 {
 100         GenericDialog *gd;
 101         GtkWidget *treeview;
 102 };
 103
 104 static KeywordDlg *keyword_dialog = NULL;
 105
 106
 107 static void keyword_dialog_cancel_cb(GenericDialog *gd, gpointer data)
 108 {
 109         g_free(keyword_dialog);
 110         keyword_dialog = NULL;
 111 }
 112
 113 static void keyword_dialog_ok_cb(GenericDialog *gd, gpointer data)
 114 {
 115         KeywordDlg *kd = data;
 116         GtkTreeModel *store;
 117         GtkTreeIter iter;
 118         gint valid;
 119
 120         history_list_free_key("keywords");
 121
 122         store = gtk_tree_view_get_model(GTK_TREE_VIEW(kd->treeview));
 123         valid = gtk_tree_model_get_iter_first(store, &iter);
 124         while (valid)
 125                 {
 126                 gchar *key;
 127
 128                 gtk_tree_model_get(store, &iter, 0, &key, -1);
 129                 valid = gtk_tree_model_iter_next(store, &iter);
 130
 131                 history_list_add_to_key("keywords", key, 0);
 132                 }
 133
 134         keyword_dialog_cancel_cb(gd, data);
 135
 136         bar_pane_keywords_keyword_update_all();
 137 }
 138
 139 static void keyword_dialog_add_cb(GtkWidget *button, gpointer data)
 140 {
 141         KeywordDlg *kd = data;
 142         GtkTreeSelection *selection;
 143         GtkTreeModel *store;
 144         GtkTreeIter sibling;
 145         GtkTreeIter iter;
 146         GtkTreePath *tpath;
 147
 148         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(kd->treeview));
 149         if (gtk_tree_selection_get_selected(selection, &store, &sibling))
 150                 {
 151                 gtk_list_store_insert_before(GTK_LIST_STORE(store), &iter, &sibling);
 152                 }
 153         else
 154                 {
 155                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(kd->treeview));
 156                 gtk_list_store_append(GTK_LIST_STORE(store), &iter);
 157                 }
 158
 159         gtk_list_store_set(GTK_LIST_STORE(store), &iter, 1, TRUE, -1);
 160
 161         tpath = gtk_tree_model_get_path(store, &iter);
 162         gtk_tree_view_set_cursor(GTK_TREE_VIEW(kd->treeview), tpath,
 163                                  gtk_tree_view_get_column(GTK_TREE_VIEW(kd->treeview), 0), TRUE);
 164         gtk_tree_path_free(tpath);
 165 }
 166
 167 static void keyword_dialog_remove_cb(GtkWidget *button, gpointer data)
 168 {
 169         KeywordDlg *kd = data;
 170         GtkTreeSelection *selection;
 171         GtkTreeModel *store;
 172         GtkTreeIter iter;
 173         GtkTreeIter next;
 174         GtkTreePath *tpath;
 175
 176         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(kd->treeview));
 177         if (!gtk_tree_selection_get_selected(selection, &store, &iter)) return;
 178
 179         tpath = NULL;
 180         next = iter;
 181         if (gtk_tree_model_iter_next(store, &next))
 182                 {
 183                 tpath = gtk_tree_model_get_path(store, &next);
 184                 }
 185         else
 186                 {
 187                 tpath = gtk_tree_model_get_path(store, &iter);
 188                 if (!gtk_tree_path_prev(tpath))
 189                         {
 190                         gtk_tree_path_free(tpath);
 191                         tpath = NULL;
 192                         }
 193                 }
 194         if (tpath)
 195                 {
 196                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(kd->treeview), tpath,
 197                                          gtk_tree_view_get_column(GTK_TREE_VIEW(kd->treeview), 0), FALSE);
 198                 gtk_tree_path_free(tpath);
 199                 }
 200
 201         gtk_list_store_remove(GTK_LIST_STORE(store), &iter);
 202 }
 203
 204 static void keyword_dialog_edit_cb(GtkCellRendererText *renderer, const gchar *path,
 205                                    const gchar *new_text, gpointer data)
 206 {
 207         KeywordDlg *kd = data;
 208         GtkTreeModel *store;
 209         GtkTreeIter iter;
 210         GtkTreePath *tpath;
 211
 212         if (!new_text || strlen(new_text) == 0) return;
 213
 214         store = gtk_tree_view_get_model(GTK_TREE_VIEW(kd->treeview));
 215
 216         tpath = gtk_tree_path_new_from_string(path);
 217         gtk_tree_model_get_iter(store, &iter, tpath);
 218         gtk_tree_path_free(tpath);
 219
 220         gtk_list_store_set(GTK_LIST_STORE(store), &iter, 0, new_text, -1);
 221 }
 222
 223 static void keyword_dialog_populate(KeywordDlg *kd)
 224 {
 225         GtkListStore *store;
 226         GList *list;
 227
 228         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(kd->treeview)));
 229         gtk_list_store_clear(store);
 230
 231         list = history_list_get_by_key("keywords");
 232         list = g_list_last(list);
 233         while (list)
 234                 {
 235                 GtkTreeIter iter;
 236
 237                 gtk_list_store_append(store, &iter);
 238                 gtk_list_store_set(store, &iter, 0, list->data,
 239                                                  1, TRUE, -1);
 240
 241                 list = list->prev;
 242                 }
 243 }
 244
 245 static void keyword_dialog_show(void)
 246 {
 247         GtkWidget *scrolled;
 248         GtkListStore *store;
 249         GtkTreeViewColumn *column;
 250         GtkCellRenderer *renderer;
 251         GtkWidget *hbox;
 252         GtkWidget *button;
 253
 254         if (keyword_dialog)
 255                 {
 256                 gtk_window_present(GTK_WINDOW(keyword_dialog->gd->dialog));
 257                 return;
 258                 }
 259
 260         keyword_dialog = g_new0(KeywordDlg, 1);
 261
 262         keyword_dialog->gd = generic_dialog_new(_("Keyword Presets"),
 263                                                 "keyword_presets", NULL, TRUE,
 264                                                 keyword_dialog_cancel_cb, keyword_dialog);
 265         generic_dialog_add_message(keyword_dialog->gd, NULL, _("Favorite keywords list"), NULL);
 266
 267         generic_dialog_add_button(keyword_dialog->gd, GTK_STOCK_OK, NULL,
 268                                  keyword_dialog_ok_cb, TRUE);
 269
 270         scrolled = gtk_scrolled_window_new(NULL, NULL);
 271         gtk_widget_set_size_request(scrolled, KEYWORD_DIALOG_WIDTH, KEYWORD_DIALOG_HEIGHT);
 272         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
 273         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
 274                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 275         gtk_box_pack_start(GTK_BOX(keyword_dialog->gd->vbox), scrolled, TRUE, TRUE, 5);
 276         gtk_widget_show(scrolled);
 277
 278         store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_BOOLEAN);
 279         keyword_dialog->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 280         g_object_unref(store);
 281
 282         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(keyword_dialog->treeview), FALSE);
 283         gtk_tree_view_set_search_column(GTK_TREE_VIEW(keyword_dialog->treeview), 0);
 284         gtk_tree_view_set_reorderable(GTK_TREE_VIEW(keyword_dialog->treeview), TRUE);
 285
 286         column = gtk_tree_view_column_new();
 287         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 288         renderer = gtk_cell_renderer_text_new();
 289         g_signal_connect(G_OBJECT(renderer), "edited",
 290                          G_CALLBACK(keyword_dialog_edit_cb), keyword_dialog);
 291         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 292         gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
 293         gtk_tree_view_column_add_attribute(column, renderer, "editable", 1);
 294         gtk_tree_view_append_column(GTK_TREE_VIEW(keyword_dialog->treeview), column);
 295
 296         gtk_container_add(GTK_CONTAINER(scrolled), keyword_dialog->treeview);
 297         gtk_widget_show(keyword_dialog->treeview);
 298
 299         hbox = gtk_hbox_new(FALSE, 5);
 300         gtk_box_pack_start(GTK_BOX(keyword_dialog->gd->vbox), hbox, FALSE, FALSE, 0);
 301         gtk_widget_show(hbox);
 302
 303         button = gtk_button_new_from_stock(GTK_STOCK_ADD);
 304         g_signal_connect(G_OBJECT(button), "clicked",
 305                          G_CALLBACK(keyword_dialog_add_cb), keyword_dialog);
 306         gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
 307         gtk_widget_show(button);
 308
 309         button = gtk_button_new_from_stock(GTK_STOCK_REMOVE);
 310         g_signal_connect(G_OBJECT(button), "clicked",
 311                          G_CALLBACK(keyword_dialog_remove_cb), keyword_dialog);
 312         gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
 313         gtk_widget_show(button);
 314
 315         keyword_dialog_populate(keyword_dialog);
 316
 317         gtk_widget_show(keyword_dialog->gd->dialog);
 318 }
 319
 320
 321 static void bar_keyword_edit_cb(GtkWidget *button, gpointer data)
 322 {
 323         keyword_dialog_show();
 324 }
 325
 326
 327 /*
 328  *-------------------------------------------------------------------
 329  * info bar
 330  *-------------------------------------------------------------------
 331  */
 332
 333 enum {
 334         KEYWORD_COLUMN_TOGGLE = 0,
 335         KEYWORD_COLUMN_TEXT,
 336         KEYWORD_COLUMN_MARK
 337 };
 338
 339 typedef struct _PaneKeywordsData PaneKeywordsData;
 340 struct _PaneKeywordsData
 341 {
 342         PaneData pane;
 343         GtkWidget *widget;
 344
 345         GtkWidget *keyword_view;
 346         GtkWidget *keyword_treeview;
 347
 348         FileData *fd;
 349         gchar *key;
 350 };
 351
 352
 353 static GList *bar_list = NULL;
 354
 355
 356 static void bar_pane_keywords_write(PaneKeywordsData *pkd)
 357 {
 358         GList *list;
 359
 360         if (!pkd->fd) return;
 361
 362         list = keyword_list_pull(pkd->keyword_view);
 363
 364         metadata_write_list(pkd->fd, KEYWORD_KEY, list);
 365
 366         string_list_free(list);
 367 }
 368
 369 static gchar *bar_pane_keywords_get_mark_text(const gchar *key)
 370 {
 371         gint i;
 372         static gchar buf[10];
 373
 374         for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
 375                 {
 376                 FileDataGetMarkFunc get_mark_func;
 377                 FileDataSetMarkFunc set_mark_func;
 378                 gpointer data;
 379                 file_data_get_registered_mark_func(i, &get_mark_func, &set_mark_func, &data);
 380                 if (get_mark_func == meta_data_get_keyword_mark && strcmp(data, key) == 0)
 381                         {
 382                         g_sprintf(buf, " %d ", i + 1);
 383                         return buf;
 384                         }
 385                 }
 386         return " ... ";
 387 }
 388
 389 static void bar_keyword_list_sync(PaneKeywordsData *pkd, GList *keywords)
 390 {
 391         GList *list;
 392         GtkListStore *store;
 393         GtkTreeIter iter;
 394
 395         list = history_list_get_by_key("keywords");
 396         if (!list)
 397                 {
 398                 /* blank? set up a few example defaults */
 399
 400                 gint i = 0;
 401
 402                 while (keyword_favorite_defaults[i] != NULL)
 403                         {
 404                         history_list_add_to_key("keywords", _(keyword_favorite_defaults[i]), 0);
 405                         i++;
 406                         }
 407
 408                 list = history_list_get_by_key("keywords");
 409                 }
 410
 411         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview)));
 412
 413         gtk_list_store_clear(store);
 414
 415         list = g_list_last(list);
 416         while (list)
 417                 {
 418                 gchar *key = list->data;
 419
 420                 gtk_list_store_append(store, &iter);
 421                 gtk_list_store_set(store, &iter, KEYWORD_COLUMN_TOGGLE, find_string_in_list(keywords, key),
 422                                                  KEYWORD_COLUMN_TEXT, key,
 423                                                  KEYWORD_COLUMN_MARK, bar_pane_keywords_get_mark_text(key), -1);
 424
 425                 list = list->prev;
 426                 }
 427 }
 428
 429 static void bar_pane_keywords_keyword_update_all(void)
 430 {
 431         GList *work;
 432
 433         work = bar_list;
 434         while (work)
 435                 {
 436                 PaneKeywordsData *pkd;
 437                 GList *keywords;
 438
 439                 pkd = work->data;
 440                 work = work->next;
 441
 442                 keywords = keyword_list_pull(pkd->keyword_view);
 443                 bar_keyword_list_sync(pkd, keywords);
 444                 string_list_free(keywords);
 445                 }
 446 }
 447
 448 static void bar_pane_keywords_update(PaneKeywordsData *pkd)
 449 {
 450         GList *keywords = NULL;
 451         GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
 452
 453         g_signal_handlers_block_by_func(keyword_buffer, bar_pane_keywords_changed, pkd);
 454
 455         keywords = metadata_read_list(pkd->fd, KEYWORD_KEY, METADATA_PLAIN);
 456         keyword_list_push(pkd->keyword_view, keywords);
 457         bar_keyword_list_sync(pkd, keywords);
 458         string_list_free(keywords);
 459
 460         g_signal_handlers_unblock_by_func(keyword_buffer, bar_pane_keywords_changed, pkd);
 461
 462 }
 463
 464 void bar_pane_keywords_set_fd(GtkWidget *pane, FileData *fd)
 465 {
 466         PaneKeywordsData *pkd;
 467
 468         pkd = g_object_get_data(G_OBJECT(pane), "pane_data");
 469         if (!pkd) return;
 470
 471         file_data_unref(pkd->fd);
 472         pkd->fd = file_data_ref(fd);
 473
 474         bar_pane_keywords_update(pkd);
 475 }
 476
 477 gint bar_pane_keywords_event(GtkWidget *bar, GdkEvent *event)
 478 {
 479         PaneKeywordsData *pkd;
 480
 481         pkd = g_object_get_data(G_OBJECT(bar), "pane_data");
 482         if (!pkd) return FALSE;
 483
 484         if (GTK_WIDGET_HAS_FOCUS(pkd->keyword_view)) return gtk_widget_event(pkd->keyword_view, event);
 485
 486         return FALSE;
 487 }
 488
 489 static void bar_pane_keywords_keyword_set(PaneKeywordsData *pkd, const gchar *keyword, gint active)
 490 {
 491         GList *list;
 492         gint found;
 493
 494         if (!keyword) return;
 495
 496         list = keyword_list_pull(pkd->keyword_view);
 497         found = find_string_in_list(list, keyword);
 498
 499         if (active != found)
 500                 {
 501                 if (found)
 502                         {
 503                         GList *work = list;
 504
 505                         while (work)
 506                                 {
 507                                 gchar *key = work->data;
 508                                 work = work->next;
 509
 510                                 if (key && keyword && strcmp(key, keyword) == 0)
 511                                         {
 512                                         list = g_list_remove(list, key);
 513                                         g_free(key);
 514                                         }
 515                                 }
 516                         }
 517                 else
 518                         {
 519                         list = g_list_append(list, g_strdup(keyword));
 520                         }
 521
 522                 keyword_list_push(pkd->keyword_view, list);
 523                 }
 524
 525         string_list_free(list);
 526 }
 527
 528 static void bar_pane_keywords_keyword_toggle(GtkCellRendererToggle *toggle, const gchar *path, gpointer data)
 529 {
 530         PaneKeywordsData *pkd = data;
 531         GtkTreeModel *store;
 532         GtkTreeIter iter;
 533         GtkTreePath *tpath;
 534         gchar *key = NULL;
 535         gboolean active;
 536
 537         store = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 538
 539         tpath = gtk_tree_path_new_from_string(path);
 540         gtk_tree_model_get_iter(store, &iter, tpath);
 541         gtk_tree_path_free(tpath);
 542
 543         gtk_tree_model_get(store, &iter, KEYWORD_COLUMN_TOGGLE, &active,
 544                                          KEYWORD_COLUMN_TEXT, &key, -1);
 545         active = (!active);
 546         gtk_list_store_set(GTK_LIST_STORE(store), &iter, KEYWORD_COLUMN_TOGGLE, active, -1);
 547
 548         bar_pane_keywords_keyword_set(pkd, key, active);
 549         g_free(key);
 550 }
 551
 552 static void bar_pane_keywords_set_selection(PaneKeywordsData *pkd, gboolean append)
 553 {
 554         GList *keywords = NULL;
 555         GList *list = NULL;
 556         GList *work;
 557
 558         if (!pkd->pane.list_func) return;
 559
 560         keywords = keyword_list_pull(pkd->keyword_view);
 561
 562         list = pkd->pane.list_func(pkd->pane.list_data);
 563         work = list;
 564         while (work)
 565                 {
 566                 FileData *fd = work->data;
 567                 work = work->next;
 568
 569                 if (append)
 570                         {
 571                         metadata_append_list(fd, KEYWORD_KEY, keywords);
 572                         }
 573                 else
 574                         {
 575                         metadata_write_list(fd, KEYWORD_KEY, keywords);
 576                         }
 577                 }
 578
 579         filelist_free(list);
 580         string_list_free(keywords);
 581 }
 582
 583 static void bar_pane_keywords_sel_add_cb(GtkWidget *button, gpointer data)
 584 {
 585         PaneKeywordsData *pkd = data;
 586
 587         bar_pane_keywords_set_selection(pkd, TRUE);
 588 }
 589
 590 static void bar_pane_keywords_sel_replace_cb(GtkWidget *button, gpointer data)
 591 {
 592         PaneKeywordsData *pkd = data;
 593
 594         bar_pane_keywords_set_selection(pkd, FALSE);
 595 }
 596
 597 static void bar_pane_keywords_populate_popup_cb(GtkTextView *textview, GtkMenu *menu, gpointer data)
 598 {
 599         PaneKeywordsData *pkd = data;
 600
 601         menu_item_add_divider(GTK_WIDGET(menu));
 602         menu_item_add_stock(GTK_WIDGET(menu), _("Add keywords to selected files"), GTK_STOCK_ADD, G_CALLBACK(bar_pane_keywords_sel_add_cb), pkd);
 603         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);
 604 }
 605
 606
 607 static void bar_pane_keywords_notify_cb(FileData *fd, NotifyType type, gpointer data)
 608 {
 609         PaneKeywordsData *pkd = data;
 610         if (fd == pkd->fd) bar_pane_keywords_update(pkd);
 611 }
 612
 613 static void bar_pane_keywords_changed(GtkTextBuffer *buffer, gpointer data)
 614 {
 615         PaneKeywordsData *pkd = data;
 616
 617         file_data_unregister_notify_func(bar_pane_keywords_notify_cb, pkd);
 618         bar_pane_keywords_write(pkd);
 619         file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW);
 620 }
 621
 622 static void bar_pane_keywords_mark_edited (GtkCellRendererText *cell, const gchar *path, const gchar *text, gpointer data)
 623 {
 624         PaneKeywordsData *pkd = data;
 625         GtkTreeModel *store;
 626         GtkTreeIter iter;
 627         GtkTreePath *tpath;
 628         gchar *key = NULL;
 629         gint i;
 630         FileDataGetMarkFunc get_mark_func;
 631         FileDataSetMarkFunc set_mark_func;
 632         gpointer mark_func_data;
 633
 634         file_data_unregister_notify_func(bar_pane_keywords_notify_cb, pkd);
 635
 636         store = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 637
 638         tpath = gtk_tree_path_new_from_string(path);
 639         gtk_tree_model_get_iter(store, &iter, tpath);
 640         gtk_tree_path_free(tpath);
 641
 642         gtk_tree_model_get(store, &iter, KEYWORD_COLUMN_TEXT, &key, -1);
 643
 644         for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
 645                 {
 646                 file_data_get_registered_mark_func(i, &get_mark_func, &set_mark_func, &mark_func_data);
 647                 if (get_mark_func == meta_data_get_keyword_mark && strcmp(mark_func_data, key) == 0)
 648                         {
 649                         g_free(mark_func_data);
 650                         file_data_register_mark_func(i, NULL, NULL, NULL);
 651                         }
 652                 }
 653
 654         if (sscanf(text, " %d ", &i) &&i >=1 && i <= FILEDATA_MARKS_SIZE)
 655                 {
 656                 i--;
 657                 file_data_get_registered_mark_func(i, &get_mark_func, &set_mark_func, &mark_func_data);
 658                 if (get_mark_func == meta_data_get_keyword_mark && mark_func_data) g_free(mark_func_data);
 659                 file_data_register_mark_func(i, meta_data_get_keyword_mark, meta_data_set_keyword_mark, g_strdup(key));
 660                 }
 661
 662         g_free(key);
 663
 664         file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW);
 665         bar_pane_keywords_update(pkd);
 666 }
 667
 668 void bar_pane_keywords_close(GtkWidget *bar)
 669 {
 670         PaneKeywordsData *pkd;
 671
 672         pkd = g_object_get_data(G_OBJECT(bar), "pane_data");
 673         if (!pkd) return;
 674
 675         gtk_widget_destroy(pkd->widget);
 676 }
 677
 678 static void bar_pane_keywords_destroy(GtkWidget *widget, gpointer data)
 679 {
 680         PaneKeywordsData *pkd = data;
 681
 682         file_data_unregister_notify_func(bar_pane_keywords_notify_cb, pkd);
 683
 684         file_data_unref(pkd->fd);
 685         g_free(pkd->key);
 686
 687         g_free(pkd);
 688 }
 689
 690 static GtkTreeModel *create_marks_list(void)
 691 {
 692         GtkListStore *model;
 693         GtkTreeIter iter;
 694         gint i;
 695
 696         /* create list store */
 697         model = gtk_list_store_new(1, G_TYPE_STRING);
 698         for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
 699                 {
 700                 gchar str[10];
 701                 g_sprintf(str, " %d ", i + 1);
 702                 gtk_list_store_append (model, &iter);
 703                 gtk_list_store_set(model, &iter, 0, str, -1);
 704                 }
 705         gtk_list_store_append (model, &iter);
 706         gtk_list_store_set(model, &iter, 0, " ... ", -1);
 707         return GTK_TREE_MODEL(model);
 708 }
 709
 710 GtkWidget *bar_pane_keywords_new(const gchar *title, const gchar *key)
 711 {
 712         PaneKeywordsData *pkd;
 713         GtkWidget *hbox;
 714         GtkWidget *scrolled;
 715         GtkTextBuffer *buffer;
 716         GtkListStore *store;
 717         GtkTreeViewColumn *column;
 718         GtkCellRenderer *renderer;
 719
 720         pkd = g_new0(PaneKeywordsData, 1);
 721
 722         pkd->pane.pane_set_fd = bar_pane_keywords_set_fd;
 723         pkd->pane.pane_event = bar_pane_keywords_event;
 724         pkd->pane.title = g_strdup(title);
 725
 726         pkd->key = g_strdup(key);
 727
 728
 729         hbox = gtk_hbox_new(FALSE, PREF_PAD_GAP);
 730
 731         pkd->widget = hbox;
 732         g_object_set_data(G_OBJECT(pkd->widget), "pane_data", pkd);
 733         g_signal_connect(G_OBJECT(pkd->widget), "destroy",
 734                          G_CALLBACK(bar_pane_keywords_destroy), pkd);
 735         gtk_widget_show(hbox);
 736
 737         scrolled = gtk_scrolled_window_new(NULL, NULL);
 738         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
 739         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
 740                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 741         gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
 742         gtk_widget_show(scrolled);
 743
 744         pkd->keyword_view = gtk_text_view_new();
 745         gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_view);
 746         g_signal_connect(G_OBJECT(pkd->keyword_view), "populate-popup",
 747                          G_CALLBACK(bar_pane_keywords_populate_popup_cb), pkd);
 748         gtk_widget_show(pkd->keyword_view);
 749
 750         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
 751         g_signal_connect(G_OBJECT(buffer), "changed",
 752                          G_CALLBACK(bar_pane_keywords_changed), pkd);
 753
 754         scrolled = gtk_scrolled_window_new(NULL, NULL);
 755         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
 756         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
 757                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 758         gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
 759         gtk_widget_show(scrolled);
 760
 761         store = gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING);
 762         pkd->keyword_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
 763         g_object_unref(store);
 764
 765         gtk_widget_set_size_request(pkd->keyword_treeview, -1, 400);
 766
 767         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(pkd->keyword_treeview), FALSE);
 768
 769         gtk_tree_view_set_search_column(GTK_TREE_VIEW(pkd->keyword_treeview), KEYWORD_COLUMN_TEXT);
 770
 771         column = gtk_tree_view_column_new();
 772         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 773
 774         renderer = gtk_cell_renderer_toggle_new();
 775         gtk_tree_view_column_pack_start(column, renderer, FALSE);
 776         gtk_tree_view_column_add_attribute(column, renderer, "active", KEYWORD_COLUMN_TOGGLE);
 777         g_signal_connect(G_OBJECT(renderer), "toggled",
 778                          G_CALLBACK(bar_pane_keywords_keyword_toggle), pkd);
 779
 780         renderer = gtk_cell_renderer_text_new();
 781         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 782         gtk_tree_view_column_add_attribute(column, renderer, "text", KEYWORD_COLUMN_TEXT);
 783
 784         gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
 785
 786         column = gtk_tree_view_column_new();
 787         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
 788
 789         renderer = gtk_cell_renderer_combo_new();
 790         g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE,
 791                                          "model", create_marks_list(),
 792                                          "text-column", 0,
 793                                          "has-entry", FALSE,
 794                                          NULL);
 795
 796         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 797         gtk_tree_view_column_add_attribute(column, renderer, "text", KEYWORD_COLUMN_MARK);
 798         g_signal_connect (renderer, "edited",
 799                           G_CALLBACK (bar_pane_keywords_mark_edited), pkd);
 800         gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
 801
 802
 803         gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_treeview);
 804         gtk_widget_show(pkd->keyword_treeview);
 805
 806         file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW);
 807
 808         return pkd->widget;
 809 }
 810 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */