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 #include "rcfile.h"
  29 #include "layout.h"
  30
  31 static const gchar *keyword_favorite_defaults[] = {
  32         N_("Favorite"),
  33         N_("Todo"),
  34         N_("People"),
  35         N_("Places"),
  36         N_("Art"),
  37         N_("Nature"),
  38         N_("Possessions"),
  39         NULL
  40 };
  41
  42
  43 static void bar_pane_keywords_keyword_update_all(void);
  44 static void bar_pane_keywords_changed(GtkTextBuffer *buffer, gpointer data);
  45
  46 /*
  47  *-------------------------------------------------------------------
  48  * keyword / comment utils
  49  *-------------------------------------------------------------------
  50  */
  51
  52
  53 GList *keyword_list_pull(GtkWidget *text_widget)
  54 {
  55         GList *list;
  56         gchar *text;
  57
  58         text = text_widget_text_pull(text_widget);
  59         list = string_to_keywords_list(text);
  60
  61         g_free(text);
  62
  63         return list;
  64 }
  65
  66 static 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         FileData *fd;
 117         gchar *key;
 118 };
 119
 120
 121 static GList *bar_list = NULL;
 122
 123
 124 static void bar_pane_keywords_write(PaneKeywordsData *pkd)
 125 {
 126         GList *list;
 127
 128         if (!pkd->fd) return;
 129
 130         list = keyword_list_pull(pkd->keyword_view);
 131
 132         metadata_write_list(pkd->fd, KEYWORD_KEY, list);
 133
 134         string_list_free(list);
 135 }
 136
 137 static gchar *bar_pane_keywords_get_mark_text(const gchar *key)
 138 {
 139         gint i;
 140         static gchar buf[10];
 141
 142         for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
 143                 {
 144                 FileDataGetMarkFunc get_mark_func;
 145                 FileDataSetMarkFunc set_mark_func;
 146                 gpointer data;
 147                 file_data_get_registered_mark_func(i, &get_mark_func, &set_mark_func, &data);
 148                 if (get_mark_func == meta_data_get_keyword_mark && strcmp(data, key) == 0)
 149                         {
 150                         g_sprintf(buf, " %d ", i + 1);
 151                         return buf;
 152                         }
 153                 }
 154         return " ... ";
 155 }
 156
 157 gboolean bar_keyword_tree_expand_if_set(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
 158 {
 159         PaneKeywordsData *pkd = data;
 160         gboolean set;
 161
 162         gtk_tree_model_get(model, iter, FILTER_KEYWORD_COLUMN_TOGGLE, &set, -1);
 163
 164         if (set && !gtk_tree_view_row_expanded(GTK_TREE_VIEW(pkd->keyword_treeview), path))
 165                 {
 166                 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), path);
 167                 }
 168         return FALSE;
 169 }
 170
 171 static void bar_keyword_tree_sync(PaneKeywordsData *pkd)
 172 {
 173         GtkTreeModelFilter *store;
 174
 175         store = GTK_TREE_MODEL_FILTER(gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview)));
 176
 177         gtk_tree_model_filter_refilter(store);
 178         gtk_tree_model_foreach(GTK_TREE_MODEL(store), bar_keyword_tree_expand_if_set, pkd);
 179
 180 }
 181
 182 static void bar_pane_keywords_keyword_update_all(void)
 183 {
 184         GList *work;
 185
 186         work = bar_list;
 187         while (work)
 188                 {
 189                 PaneKeywordsData *pkd;
 190 //              GList *keywords;
 191
 192                 pkd = work->data;
 193                 work = work->next;
 194
 195                 bar_keyword_tree_sync(pkd);
 196                 }
 197 }
 198
 199 static void bar_pane_keywords_update(PaneKeywordsData *pkd)
 200 {
 201         GList *keywords = NULL;
 202         GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
 203
 204         g_signal_handlers_block_by_func(keyword_buffer, bar_pane_keywords_changed, pkd);
 205
 206         keywords = metadata_read_list(pkd->fd, KEYWORD_KEY, METADATA_PLAIN);
 207         keyword_list_push(pkd->keyword_view, keywords);
 208         bar_keyword_tree_sync(pkd);
 209         string_list_free(keywords);
 210
 211         g_signal_handlers_unblock_by_func(keyword_buffer, bar_pane_keywords_changed, pkd);
 212
 213 }
 214
 215 void bar_pane_keywords_set_fd(GtkWidget *pane, FileData *fd)
 216 {
 217         PaneKeywordsData *pkd;
 218
 219         pkd = g_object_get_data(G_OBJECT(pane), "pane_data");
 220         if (!pkd) return;
 221
 222         file_data_unref(pkd->fd);
 223         pkd->fd = file_data_ref(fd);
 224
 225         bar_pane_keywords_update(pkd);
 226 }
 227
 228 static void bar_pane_keywords_write_config(GtkWidget *pane, GString *outstr, gint indent)
 229 {
 230         PaneKeywordsData *pkd;
 231
 232         pkd = g_object_get_data(G_OBJECT(pane), "pane_data");
 233         if (!pkd) return;
 234
 235         WRITE_STRING("<pane_keywords\n");
 236         indent++;
 237         write_char_option(outstr, indent, "pane.title", gtk_label_get_text(GTK_LABEL(pkd->pane.title)));
 238         WRITE_BOOL(*pkd, pane.expanded);
 239         WRITE_CHAR(*pkd, key);
 240         indent--;
 241         WRITE_STRING("/>\n");
 242 }
 243
 244 gint bar_pane_keywords_event(GtkWidget *bar, GdkEvent *event)
 245 {
 246         PaneKeywordsData *pkd;
 247
 248         pkd = g_object_get_data(G_OBJECT(bar), "pane_data");
 249         if (!pkd) return FALSE;
 250
 251         if (GTK_WIDGET_HAS_FOCUS(pkd->keyword_view)) return gtk_widget_event(pkd->keyword_view, event);
 252
 253         return FALSE;
 254 }
 255
 256 static void bar_pane_keywords_keyword_toggle(GtkCellRendererToggle *toggle, const gchar *path, gpointer data)
 257 {
 258         PaneKeywordsData *pkd = data;
 259         GtkTreeModel *model;
 260         GtkTreeIter iter;
 261         GtkTreePath *tpath;
 262         gboolean active;
 263         GList *list;
 264         GtkTreeIter child_iter;
 265         GtkTreeModel *keyword_tree;
 266
 267         model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 268
 269         tpath = gtk_tree_path_new_from_string(path);
 270         gtk_tree_model_get_iter(model, &iter, tpath);
 271         gtk_tree_path_free(tpath);
 272
 273         gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_TOGGLE, &active, -1);
 274         active = (!active);
 275
 276
 277         keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 278         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
 279
 280         list = keyword_list_pull(pkd->keyword_view);
 281         if (active)
 282                 keyword_tree_set(keyword_tree, &child_iter, &list);
 283         else
 284                 keyword_tree_reset(keyword_tree, &child_iter, &list);
 285
 286         keyword_list_push(pkd->keyword_view, list);
 287         string_list_free(list);
 288         bar_keyword_tree_sync(pkd);
 289 }
 290
 291 void bar_pane_keywords_filter_modify(GtkTreeModel *model, GtkTreeIter *iter, GValue *value, gint column, gpointer data)
 292 {
 293         PaneKeywordsData *pkd = data;
 294         GtkTreeModel *keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
 295         GtkTreeIter child_iter;
 296
 297         gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, iter);
 298
 299         memset(value, 0, sizeof (GValue));
 300
 301         switch (column)
 302                 {
 303                 case FILTER_KEYWORD_COLUMN_TOGGLE:
 304                         {
 305                         GList *keywords = keyword_list_pull(pkd->keyword_view);
 306                         gboolean set = keyword_tree_is_set(keyword_tree, &child_iter, keywords);
 307                         string_list_free(keywords);
 308
 309                         g_value_init(value, G_TYPE_BOOLEAN);
 310                         g_value_set_boolean(value, set);
 311                         break;
 312                         }
 313                 case FILTER_KEYWORD_COLUMN_MARK:
 314                         gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_MARK, value);
 315                         break;
 316                 case FILTER_KEYWORD_COLUMN_NAME:
 317                         gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_NAME, value);
 318                         break;
 319                 case FILTER_KEYWORD_COLUMN_IS_KEYWORD:
 320                         gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_IS_KEYWORD, value);
 321                         break;
 322                 }
 323         return;
 324
 325 }
 326
 327 static void bar_pane_keywords_set_selection(PaneKeywordsData *pkd, gboolean append)
 328 {
 329         GList *keywords = NULL;
 330         GList *list = NULL;
 331         GList *work;
 332
 333         keywords = keyword_list_pull(pkd->keyword_view);
 334
 335         list = layout_selection_list(pkd->pane.lw);
 336         work = list;
 337         while (work)
 338                 {
 339                 FileData *fd = work->data;
 340                 work = work->next;
 341
 342                 if (append)
 343                         {
 344                         metadata_append_list(fd, KEYWORD_KEY, keywords);
 345                         }
 346                 else
 347                         {
 348                         metadata_write_list(fd, KEYWORD_KEY, keywords);
 349                         }
 350                 }
 351
 352         filelist_free(list);
 353         string_list_free(keywords);
 354 }
 355
 356 static void bar_pane_keywords_sel_add_cb(GtkWidget *button, gpointer data)
 357 {
 358         PaneKeywordsData *pkd = data;
 359
 360         bar_pane_keywords_set_selection(pkd, TRUE);
 361 }
 362
 363 static void bar_pane_keywords_sel_replace_cb(GtkWidget *button, gpointer data)
 364 {
 365         PaneKeywordsData *pkd = data;
 366
 367         bar_pane_keywords_set_selection(pkd, FALSE);
 368 }
 369
 370 static void bar_pane_keywords_populate_popup_cb(GtkTextView *textview, GtkMenu *menu, gpointer data)
 371 {
 372         PaneKeywordsData *pkd = data;
 373
 374         menu_item_add_divider(GTK_WIDGET(menu));
 375         menu_item_add_stock(GTK_WIDGET(menu), _("Add keywords to selected files"), GTK_STOCK_ADD, G_CALLBACK(bar_pane_keywords_sel_add_cb), pkd);
 376         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);
 377 }
 378
 379
 380 static void bar_pane_keywords_notify_cb(FileData *fd, NotifyType type, gpointer data)
 381 {
 382         PaneKeywordsData *pkd = data;
 383         if (fd == pkd->fd) bar_pane_keywords_update(pkd);
 384 }
 385
 386 static void bar_pane_keywords_changed(GtkTextBuffer *buffer, gpointer data)
 387 {
 388         PaneKeywordsData *pkd = data;
 389
 390         file_data_unregister_notify_func(bar_pane_keywords_notify_cb, pkd);
 391         bar_pane_keywords_write(pkd);
 392         bar_keyword_tree_sync(pkd);
 393         file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW);
 394 }
 395
 396 static void bar_pane_keywords_mark_edited(GtkCellRendererText *cell, const gchar *path, const gchar *text, gpointer data)
 397 {
 398 /*      PaneKeywordsData *pkd = data;
 399         GtkTreeModel *store;
 400         GtkTreeIter iter;
 401         GtkTreePath *tpath;
 402         gchar *key = NULL;
 403         gint i;
 404         FileDataGetMarkFunc get_mark_func;
 405         FileDataSetMarkFunc set_mark_func;
 406         gpointer mark_func_data;
 407
 408         file_data_unregister_notify_func(bar_pane_keywords_notify_cb, pkd);
 409
 410         store = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
 411
 412         tpath = gtk_tree_path_new_from_string(path);
 413         gtk_tree_model_get_iter(store, &iter, tpath);
 414         gtk_tree_path_free(tpath);
 415
 416         gtk_tree_model_get(store, &iter, FILTER_KEYWORD_COLUMN_TEXT, &key, -1);
 417
 418         for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
 419                 {
 420                 file_data_get_registered_mark_func(i, &get_mark_func, &set_mark_func, &mark_func_data);
 421                 if (get_mark_func == meta_data_get_keyword_mark && strcmp(mark_func_data, key) == 0)
 422                         {
 423                         g_free(mark_func_data);
 424                         file_data_register_mark_func(i, NULL, NULL, NULL);
 425                         }
 426                 }
 427
 428         if (sscanf(text, " %d ", &i) &&i >=1 && i <= FILEDATA_MARKS_SIZE)
 429                 {
 430                 i--;
 431                 file_data_get_registered_mark_func(i, &get_mark_func, &set_mark_func, &mark_func_data);
 432                 if (get_mark_func == meta_data_get_keyword_mark && mark_func_data) g_free(mark_func_data);
 433                 file_data_register_mark_func(i, meta_data_get_keyword_mark, meta_data_set_keyword_mark, g_strdup(key));
 434                 }
 435
 436         g_free(key);
 437
 438         file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW);
 439         bar_pane_keywords_update(pkd);
 440 */
 441 }
 442
 443 void bar_pane_keywords_close(GtkWidget *bar)
 444 {
 445         PaneKeywordsData *pkd;
 446
 447         pkd = g_object_get_data(G_OBJECT(bar), "pane_data");
 448         if (!pkd) return;
 449
 450         gtk_widget_destroy(pkd->widget);
 451 }
 452
 453 static void bar_pane_keywords_destroy(GtkWidget *widget, gpointer data)
 454 {
 455         PaneKeywordsData *pkd = data;
 456
 457         file_data_unregister_notify_func(bar_pane_keywords_notify_cb, pkd);
 458
 459         file_data_unref(pkd->fd);
 460         g_free(pkd->key);
 461
 462         g_free(pkd);
 463 }
 464
 465 static GtkTreeModel *create_marks_list(void)
 466 {
 467         GtkListStore *model;
 468         GtkTreeIter iter;
 469         gint i;
 470
 471         /* create list store */
 472         model = gtk_list_store_new(1, G_TYPE_STRING);
 473         for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
 474                 {
 475                 gchar str[10];
 476                 g_sprintf(str, " %d ", i + 1);
 477                 gtk_list_store_append(model, &iter);
 478                 gtk_list_store_set(model, &iter, 0, str, -1);
 479                 }
 480         gtk_list_store_append(model, &iter);
 481         gtk_list_store_set(model, &iter, 0, " ... ", -1);
 482         return GTK_TREE_MODEL(model);
 483 }
 484
 485
 486 GtkWidget *bar_pane_keywords_new(const gchar *title, const gchar *key, gboolean expanded)
 487 {
 488         PaneKeywordsData *pkd;
 489         GtkWidget *hbox;
 490         GtkWidget *scrolled;
 491         GtkTextBuffer *buffer;
 492         GtkTreeModel *store;
 493         GtkTreeViewColumn *column;
 494         GtkCellRenderer *renderer;
 495
 496         pkd = g_new0(PaneKeywordsData, 1);
 497
 498         pkd->pane.pane_set_fd = bar_pane_keywords_set_fd;
 499         pkd->pane.pane_event = bar_pane_keywords_event;
 500         pkd->pane.pane_write_config = bar_pane_keywords_write_config;
 501         pkd->pane.title = bar_pane_expander_title(title);
 502
 503         pkd->pane.expanded = expanded;
 504
 505         pkd->key = g_strdup(key);
 506
 507
 508         hbox = gtk_hbox_new(FALSE, PREF_PAD_GAP);
 509
 510         pkd->widget = hbox;
 511         g_object_set_data(G_OBJECT(pkd->widget), "pane_data", pkd);
 512         g_signal_connect(G_OBJECT(pkd->widget), "destroy",
 513                          G_CALLBACK(bar_pane_keywords_destroy), pkd);
 514         gtk_widget_show(hbox);
 515
 516         scrolled = gtk_scrolled_window_new(NULL, NULL);
 517         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
 518         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
 519                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 520         gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
 521         gtk_widget_show(scrolled);
 522
 523         pkd->keyword_view = gtk_text_view_new();
 524         gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_view);
 525         g_signal_connect(G_OBJECT(pkd->keyword_view), "populate-popup",
 526                          G_CALLBACK(bar_pane_keywords_populate_popup_cb), pkd);
 527         gtk_widget_show(pkd->keyword_view);
 528
 529         buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
 530         g_signal_connect(G_OBJECT(buffer), "changed",
 531                          G_CALLBACK(bar_pane_keywords_changed), pkd);
 532
 533         scrolled = gtk_scrolled_window_new(NULL, NULL);
 534         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
 535         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
 536                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 537         gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
 538         gtk_widget_show(scrolled);
 539
 540
 541         if (!keyword_tree) keyword_tree_new_default();
 542
 543         store = gtk_tree_model_filter_new(GTK_TREE_MODEL(keyword_tree), NULL);
 544
 545         gtk_tree_model_filter_set_modify_func(GTK_TREE_MODEL_FILTER(store),
 546                                               FILTER_KEYWORD_COLUMN_COUNT,
 547                                               filter_keyword_column_types,
 548                                               bar_pane_keywords_filter_modify,
 549                                               pkd,
 550                                               NULL);
 551
 552         pkd->keyword_treeview = gtk_tree_view_new_with_model(store);
 553         g_object_unref(store);
 554
 555         gtk_widget_set_size_request(pkd->keyword_treeview, -1, 400);
 556
 557         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(pkd->keyword_treeview), FALSE);
 558
 559 //      gtk_tree_view_set_search_column(GTK_TREE_VIEW(pkd->keyword_treeview), FILTER_KEYWORD_COLUMN_);
 560
 561         column = gtk_tree_view_column_new();
 562         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
 563
 564         renderer = gtk_cell_renderer_combo_new();
 565         g_object_set(G_OBJECT(renderer), "editable", (gboolean)TRUE,
 566                                          "model", create_marks_list(),
 567                                          "text-column", 0,
 568                                          "has-entry", FALSE,
 569                                          NULL);
 570
 571         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 572         gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_MARK);
 573         g_signal_connect(renderer, "edited",
 574                           G_CALLBACK (bar_pane_keywords_mark_edited), pkd);
 575         gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
 576
 577
 578         column = gtk_tree_view_column_new();
 579         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 580         renderer = gtk_cell_renderer_toggle_new();
 581         gtk_tree_view_column_pack_start(column, renderer, FALSE);
 582         gtk_tree_view_column_add_attribute(column, renderer, "active", FILTER_KEYWORD_COLUMN_TOGGLE);
 583         gtk_tree_view_column_add_attribute(column, renderer, "visible", FILTER_KEYWORD_COLUMN_IS_KEYWORD);
 584         g_signal_connect(G_OBJECT(renderer), "toggled",
 585                          G_CALLBACK(bar_pane_keywords_keyword_toggle), pkd);
 586
 587         renderer = gtk_cell_renderer_text_new();
 588         gtk_tree_view_column_pack_start(column, renderer, TRUE);
 589         gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_NAME);
 590
 591         gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
 592         gtk_tree_view_set_expander_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
 593
 594         gtk_container_add(GTK_CONTAINER(scrolled), pkd->keyword_treeview);
 595         gtk_widget_show(pkd->keyword_treeview);
 596
 597         file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW);
 598
 599         return pkd->widget;
 600 }
 601
 602 GtkWidget *bar_pane_keywords_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
 603 {
 604         gchar *title = g_strdup(_("NoName"));
 605         gchar *key = g_strdup(COMMENT_KEY);
 606         gboolean expanded = TRUE;
 607
 608         while (*attribute_names)
 609                 {
 610                 const gchar *option = *attribute_names++;
 611                 const gchar *value = *attribute_values++;
 612
 613                 if (READ_CHAR_FULL("pane.title", title)) continue;
 614                 if (READ_CHAR_FULL("key", key)) continue;
 615                 if (READ_BOOL_FULL("pane.expanded", expanded)) continue;
 616
 617
 618                 DEBUG_1("unknown attribute %s = %s", option, value);
 619                 }
 620
 621         return bar_pane_keywords_new(title, key, expanded);
 622 }
 623
 624 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */