2 * Copyright (C) 2004 John Ellis
3 * Copyright (C) 2008 - 2016 The Geeqie Team
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.
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.
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.
22 #include "bar-keywords.h"
28 #include <glib-object.h>
37 #include "main-defines.h"
42 #include "secure-save.h"
44 #include "ui-fileops.h"
47 #include "ui-utildlg.h"
52 GtkListStore *keyword_store = nullptr;
54 void bar_pane_keywords_changed(GtkTextBuffer *buffer, gpointer data);
56 void autocomplete_keywords_list_load(const gchar *path);
57 gboolean autocomplete_keywords_list_save(gchar *path);
58 gboolean autocomplete_activate_cb(GtkWidget *widget, gpointer data);
61 *-------------------------------------------------------------------
62 * keyword / comment utils
63 *-------------------------------------------------------------------
66 GList *keyword_list_pull_selected(GtkWidget *text_widget)
71 text = text_widget_text_pull_selected(text_widget);
72 list = string_to_keywords_list(text);
79 /* the "changed" signal should be blocked before calling this */
80 void keyword_list_push(GtkWidget *textview, GList *list)
82 GtkTextBuffer *buffer;
86 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
87 gtk_text_buffer_get_bounds(buffer, &start, &end);
88 gtk_text_buffer_delete(buffer, &start, &end);
92 auto word = static_cast<const gchar *>(list->data);
95 gtk_text_buffer_get_end_iter(buffer, &iter);
96 if (word) gtk_text_buffer_insert(buffer, &iter, word, -1);
97 gtk_text_buffer_get_end_iter(buffer, &iter);
98 gtk_text_buffer_insert(buffer, &iter, "\n", -1);
106 *-------------------------------------------------------------------
108 *-------------------------------------------------------------------
113 FILTER_KEYWORD_COLUMN_TOGGLE = 0,
114 FILTER_KEYWORD_COLUMN_MARK,
115 FILTER_KEYWORD_COLUMN_NAME,
116 FILTER_KEYWORD_COLUMN_IS_KEYWORD,
117 FILTER_KEYWORD_COLUMN_COUNT
120 GType filter_keyword_column_types[] = {G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN};
122 struct PaneKeywordsData
127 GtkWidget *keyword_view;
128 GtkWidget *keyword_treeview;
130 GtkTreePath *click_tpath;
132 gboolean expand_checked;
133 gboolean collapse_unchecked;
134 gboolean hide_unchecked;
136 guint idle_id; /* event source id */
141 GList *expanded_rows;
143 GtkWidget *autocomplete;
146 struct ConfDialogData
148 PaneKeywordsData *pkd;
149 GtkTreePath *click_tpath;
153 GtkWidget *edit_widget;
156 gboolean edit_existing;
160 void bar_pane_keywords_write(PaneKeywordsData *pkd)
164 if (!pkd->fd) return;
166 list = keyword_list_pull(pkd->keyword_view);
168 metadata_write_list(pkd->fd, KEYWORD_KEY, list);
170 g_list_free_full(list, g_free);
173 gboolean bar_keyword_tree_expand_if_set_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
175 auto pkd = static_cast<PaneKeywordsData *>(data);
178 gtk_tree_model_get(model, iter, FILTER_KEYWORD_COLUMN_TOGGLE, &set, -1);
180 if (set && !gtk_tree_view_row_expanded(GTK_TREE_VIEW(pkd->keyword_treeview), path))
182 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), path);
187 gboolean bar_keyword_tree_collapse_if_unset_cb(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
189 auto pkd = static_cast<PaneKeywordsData *>(data);
192 gtk_tree_model_get(model, iter, FILTER_KEYWORD_COLUMN_TOGGLE, &set, -1);
194 if (!set && gtk_tree_view_row_expanded(GTK_TREE_VIEW(pkd->keyword_treeview), path))
196 gtk_tree_view_collapse_row(GTK_TREE_VIEW(pkd->keyword_treeview), path);
201 void bar_keyword_tree_sync(PaneKeywordsData *pkd)
205 GtkTreeModel *keyword_tree;
208 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
209 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
211 keywords = keyword_list_pull(pkd->keyword_view);
212 keyword_show_set_in(GTK_TREE_STORE(keyword_tree), model, keywords);
213 if (pkd->hide_unchecked) keyword_hide_unset_in(GTK_TREE_STORE(keyword_tree), model, keywords);
214 g_list_free_full(keywords, g_free);
216 gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(model));
218 if (pkd->expand_checked) gtk_tree_model_foreach(model, bar_keyword_tree_expand_if_set_cb, pkd);
219 if (pkd->collapse_unchecked) gtk_tree_model_foreach(model, bar_keyword_tree_collapse_if_unset_cb, pkd);
222 void bar_pane_keywords_update(PaneKeywordsData *pkd)
224 GList *keywords = nullptr;
225 GList *orig_keywords = nullptr;
228 GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
230 keywords = metadata_read_list(pkd->fd, KEYWORD_KEY, METADATA_PLAIN);
231 orig_keywords = keyword_list_pull(pkd->keyword_view);
233 /* compare the lists */
235 work2 = orig_keywords;
237 while (work1 && work2)
239 if (strcmp(static_cast<const gchar *>(work1->data), static_cast<const gchar *>(work2->data)) != 0) break;
244 if (work1 || work2) /* lists differs */
246 g_signal_handlers_block_by_func(keyword_buffer, (gpointer)bar_pane_keywords_changed, pkd);
247 keyword_list_push(pkd->keyword_view, keywords);
248 bar_keyword_tree_sync(pkd);
249 g_signal_handlers_unblock_by_func(keyword_buffer, (gpointer)bar_pane_keywords_changed, pkd);
251 g_list_free_full(keywords, g_free);
252 g_list_free_full(orig_keywords, g_free);
255 void bar_pane_keywords_set_fd(GtkWidget *pane, FileData *fd)
257 PaneKeywordsData *pkd;
259 pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
262 file_data_unref(pkd->fd);
263 pkd->fd = file_data_ref(fd);
265 bar_pane_keywords_update(pkd);
268 void bar_keyword_tree_get_expanded_cb(GtkTreeView *keyword_treeview, GtkTreePath *path, gpointer data)
270 auto expanded = static_cast<GList **>(data);
275 model = gtk_tree_view_get_model(GTK_TREE_VIEW(keyword_treeview));
276 gtk_tree_model_get_iter(model, &iter, path);
278 path_string = gtk_tree_model_get_string_from_iter(model, &iter);
280 *expanded = g_list_append(*expanded, g_strdup(path_string));
284 void bar_pane_keywords_entry_write_config(gchar *entry, GString *outstr, gint indent)
292 WRITE_NL(); WRITE_STRING("<expanded ");
293 WRITE_CHAR(expand, path);
297 void bar_pane_keywords_write_config(GtkWidget *pane, GString *outstr, gint indent)
299 PaneKeywordsData *pkd;
300 GList *path_expanded = nullptr;
304 pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
307 gtk_widget_get_size_request(GTK_WIDGET(pane), &w, &h);
310 WRITE_NL(); WRITE_STRING("<pane_keywords ");
311 write_char_option(outstr, indent, "id", pkd->pane.id);
312 write_char_option(outstr, indent, "title", gtk_label_get_text(GTK_LABEL(pkd->pane.title)));
313 WRITE_BOOL(pkd->pane, expanded);
314 WRITE_CHAR(*pkd, key);
315 WRITE_INT(*pkd, height);
319 gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(pkd->keyword_treeview),
320 (bar_keyword_tree_get_expanded_cb), &path_expanded);
322 GList *work = g_list_first(path_expanded);
325 bar_pane_keywords_entry_write_config(static_cast<gchar *>(work->data), outstr, indent);
328 g_list_free_full(path_expanded, g_free);
332 WRITE_STRING("</pane_keywords>");
335 gint bar_pane_keywords_event(GtkWidget *bar, GdkEvent *event)
337 PaneKeywordsData *pkd;
339 pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(bar), "pane_data"));
340 if (!pkd) return FALSE;
342 if (gtk_widget_has_focus(pkd->keyword_view)) return gtk_widget_event(pkd->keyword_view, event);
344 if (gtk_widget_has_focus(pkd->autocomplete))
346 return gtk_widget_event(pkd->autocomplete, event);
351 void bar_pane_keywords_keyword_toggle(GtkCellRendererToggle *, const gchar *path, gpointer data)
353 auto pkd = static_cast<PaneKeywordsData *>(data);
359 GtkTreeIter child_iter;
360 GtkTreeModel *keyword_tree;
362 GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
364 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
366 tpath = gtk_tree_path_new_from_string(path);
367 gtk_tree_model_get_iter(model, &iter, tpath);
368 gtk_tree_path_free(tpath);
370 gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_TOGGLE, &active, -1);
374 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
375 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
377 list = keyword_list_pull(pkd->keyword_view);
379 keyword_tree_set(keyword_tree, &child_iter, &list);
381 keyword_tree_reset(keyword_tree, &child_iter, &list);
383 g_signal_handlers_block_by_func(keyword_buffer, (gpointer)bar_pane_keywords_changed, pkd);
384 keyword_list_push(pkd->keyword_view, list);
385 g_list_free_full(list, g_free);
386 g_signal_handlers_unblock_by_func(keyword_buffer, (gpointer)bar_pane_keywords_changed, pkd);
388 /* call this just once in the end */
389 bar_pane_keywords_changed(keyword_buffer, pkd);
392 void bar_pane_keywords_filter_modify(GtkTreeModel *model, GtkTreeIter *iter, GValue *value, gint column, gpointer data)
394 auto pkd = static_cast<PaneKeywordsData *>(data);
395 GtkTreeModel *keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
396 GtkTreeIter child_iter;
398 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, iter);
400 memset(value, 0, sizeof (GValue));
404 case FILTER_KEYWORD_COLUMN_TOGGLE:
406 GList *keywords = keyword_list_pull(pkd->keyword_view);
407 gboolean set = keyword_tree_is_set(keyword_tree, &child_iter, keywords);
408 g_list_free_full(keywords, g_free);
410 g_value_init(value, G_TYPE_BOOLEAN);
411 g_value_set_boolean(value, set);
414 case FILTER_KEYWORD_COLUMN_MARK:
415 gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_MARK, value);
417 case FILTER_KEYWORD_COLUMN_NAME:
418 gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_NAME, value);
420 case FILTER_KEYWORD_COLUMN_IS_KEYWORD:
421 gtk_tree_model_get_value(keyword_tree, &child_iter, KEYWORD_COLUMN_IS_KEYWORD, value);
426 gboolean bar_pane_keywords_filter_visible(GtkTreeModel *keyword_tree, GtkTreeIter *iter, gpointer data)
428 auto filter = static_cast<GtkTreeModel *>(data);
430 return !keyword_is_hidden_in(keyword_tree, iter, filter);
433 void bar_pane_keywords_set_selection(PaneKeywordsData *pkd, gboolean append)
435 GList *keywords = nullptr;
436 GList *list = nullptr;
439 keywords = keyword_list_pull_selected(pkd->keyword_view);
441 list = layout_selection_list(pkd->pane.lw);
442 list = file_data_process_groups_in_selection(list, FALSE, nullptr);
447 auto fd = static_cast<FileData *>(work->data);
452 metadata_append_list(fd, KEYWORD_KEY, keywords);
456 metadata_write_list(fd, KEYWORD_KEY, keywords);
461 g_list_free_full(keywords, g_free);
464 void bar_pane_keywords_sel_add_cb(GtkWidget *, gpointer data)
466 auto pkd = static_cast<PaneKeywordsData *>(data);
468 bar_pane_keywords_set_selection(pkd, TRUE);
471 void bar_pane_keywords_sel_replace_cb(GtkWidget *, gpointer data)
473 auto pkd = static_cast<PaneKeywordsData *>(data);
475 bar_pane_keywords_set_selection(pkd, FALSE);
478 void bar_pane_keywords_populate_popup_cb(GtkTextView *, GtkMenu *menu, gpointer data)
480 auto pkd = static_cast<PaneKeywordsData *>(data);
482 menu_item_add_divider(GTK_WIDGET(menu));
483 menu_item_add_icon(GTK_WIDGET(menu), _("Add selected keywords to selected files"), GQ_ICON_ADD, G_CALLBACK(bar_pane_keywords_sel_add_cb), pkd);
484 menu_item_add_icon(GTK_WIDGET(menu), _("Replace existing keywords in selected files with selected keywords"), GQ_ICON_REPLACE, G_CALLBACK(bar_pane_keywords_sel_replace_cb), pkd);
488 void bar_pane_keywords_notify_cb(FileData *fd, NotifyType type, gpointer data)
490 auto pkd = static_cast<PaneKeywordsData *>(data);
491 if ((type & (NOTIFY_REREAD | NOTIFY_CHANGE | NOTIFY_METADATA)) && fd == pkd->fd)
493 DEBUG_1("Notify pane_keywords: %s %04x", fd->path, type);
494 bar_pane_keywords_update(pkd);
498 gboolean bar_pane_keywords_changed_idle_cb(gpointer data)
500 auto pkd = static_cast<PaneKeywordsData *>(data);
502 bar_pane_keywords_write(pkd);
503 bar_keyword_tree_sync(pkd);
505 return G_SOURCE_REMOVE;
508 void bar_pane_keywords_changed(GtkTextBuffer *, gpointer data)
510 auto pkd = static_cast<PaneKeywordsData *>(data);
512 if (pkd->idle_id) return;
513 /* higher prio than redraw */
514 pkd->idle_id = g_idle_add_full(G_PRIORITY_HIGH_IDLE, bar_pane_keywords_changed_idle_cb, pkd, nullptr);
519 *-------------------------------------------------------------------
521 *-------------------------------------------------------------------
524 // @todo Use std::array
525 constexpr GtkTargetEntry bar_pane_keywords_drag_types[] = {
526 { const_cast<gchar *>(TARGET_APP_KEYWORD_PATH_STRING), GTK_TARGET_SAME_WIDGET, TARGET_APP_KEYWORD_PATH },
527 { const_cast<gchar *>("text/plain"), 0, TARGET_TEXT_PLAIN }
529 constexpr gint n_keywords_drag_types = 2;
531 // @todo Use std::array
532 constexpr GtkTargetEntry bar_pane_keywords_drop_types[] = {
533 { const_cast<gchar *>(TARGET_APP_KEYWORD_PATH_STRING), GTK_TARGET_SAME_WIDGET, TARGET_APP_KEYWORD_PATH },
534 { const_cast<gchar *>("text/plain"), 0, TARGET_TEXT_PLAIN }
536 constexpr gint n_keywords_drop_types = 2;
539 void bar_pane_keywords_dnd_get(GtkWidget *tree_view, GdkDragContext *,
540 GtkSelectionData *selection_data, guint info,
545 GtkTreeIter child_iter;
546 GtkTreeModel *keyword_tree;
548 GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
550 if (!gtk_tree_selection_get_selected(sel, &model, &iter)) return;
552 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
553 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
557 case TARGET_APP_KEYWORD_PATH:
559 GList *path = keyword_tree_get_path(keyword_tree, &child_iter);
560 gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
561 8, reinterpret_cast<const guchar *>(&path), sizeof(path));
565 case TARGET_TEXT_PLAIN:
568 gchar *name = keyword_get_name(keyword_tree, &child_iter);
569 gtk_selection_data_set_text(selection_data, name, -1);
576 void bar_pane_keywords_dnd_begin(GtkWidget *tree_view, GdkDragContext *context, gpointer)
580 GtkTreeIter child_iter;
581 GtkTreeModel *keyword_tree;
584 GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
586 if (!gtk_tree_selection_get_selected(sel, &model, &iter)) return;
588 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
589 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
591 name = keyword_get_name(keyword_tree, &child_iter);
593 dnd_set_drag_label(tree_view, context, name);
598 void bar_pane_keywords_dnd_end(GtkWidget *, GdkDragContext *, gpointer)
603 gboolean bar_pane_keywords_dnd_can_move(GtkTreeModel *keyword_tree, GtkTreeIter *src_kw_iter, GtkTreeIter *dest_kw_iter)
608 if (dest_kw_iter && keyword_same_parent(keyword_tree, src_kw_iter, dest_kw_iter))
610 return TRUE; /* reordering of siblings is ok */
612 if (!dest_kw_iter && !gtk_tree_model_iter_parent(keyword_tree, &parent, src_kw_iter))
614 return TRUE; /* reordering of top-level siblings is ok */
617 src_name = keyword_get_name(keyword_tree, src_kw_iter);
618 if (keyword_exists(keyword_tree, nullptr, dest_kw_iter, src_name, FALSE, nullptr))
627 gboolean bar_pane_keywords_dnd_skip_existing(GtkTreeModel *keyword_tree, GtkTreeIter *dest_kw_iter, GList **keywords)
629 /* we have to find at least one keyword that does not already exist as a sibling of dest_kw_iter */
630 GList *work = *keywords;
633 auto keyword = static_cast<gchar *>(work->data);
634 if (keyword_exists(keyword_tree, nullptr, dest_kw_iter, keyword, FALSE, nullptr))
636 GList *next = work->next;
638 *keywords = g_list_delete_link(*keywords, work);
649 void bar_pane_keywords_dnd_receive(GtkWidget *tree_view, GdkDragContext *,
651 GtkSelectionData *selection_data, guint info,
652 guint, gpointer data)
654 auto pkd = static_cast<PaneKeywordsData *>(data);
655 GtkTreePath *tpath = nullptr;
656 GtkTreeViewDropPosition pos;
659 GtkTreeModel *keyword_tree;
660 gboolean src_valid = FALSE;
661 GList *new_keywords = nullptr;
664 /* iterators for keyword_tree */
665 GtkTreeIter src_kw_iter;
666 GtkTreeIter dest_kw_iter;
667 GtkTreeIter new_kw_iter;
669 g_signal_stop_emission_by_name(tree_view, "drag_data_received");
671 model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
672 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
674 gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos);
675 gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), nullptr, pos);
679 case TARGET_APP_KEYWORD_PATH:
681 auto path = static_cast<GList *>(*reinterpret_cast<const gpointer *>(gtk_selection_data_get_data(selection_data)));
682 src_valid = keyword_tree_get_iter(keyword_tree, &src_kw_iter, path);
683 g_list_free_full(path, g_free);
687 new_keywords = string_to_keywords_list(reinterpret_cast<const gchar *>(gtk_selection_data_get_data(selection_data)));
693 GtkTreeIter dest_iter;
694 gtk_tree_model_get_iter(model, &dest_iter, tpath);
695 gtk_tree_path_free(tpath);
696 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &dest_kw_iter, &dest_iter);
698 if (src_valid && gtk_tree_store_is_ancestor(GTK_TREE_STORE(keyword_tree), &src_kw_iter, &dest_kw_iter))
700 /* can't move to it's own child */
704 if (src_valid && keyword_compare(keyword_tree, &src_kw_iter, &dest_kw_iter) == 0)
706 /* can't move to itself */
710 if ((pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE || pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER) &&
711 !gtk_tree_model_iter_has_child(keyword_tree, &dest_kw_iter))
713 /* the node has no children, all keywords can be added */
714 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &dest_kw_iter);
718 if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, &dest_kw_iter))
720 /* the keyword can't be moved if the same name already exist */
723 if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, &dest_kw_iter, &new_keywords))
725 /* the keywords can't be added if the same name already exist */
731 case GTK_TREE_VIEW_DROP_INTO_OR_BEFORE:
732 case GTK_TREE_VIEW_DROP_BEFORE:
733 gtk_tree_store_insert_before(GTK_TREE_STORE(keyword_tree), &new_kw_iter, nullptr, &dest_kw_iter);
735 case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
736 case GTK_TREE_VIEW_DROP_AFTER:
737 gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &new_kw_iter, nullptr, &dest_kw_iter);
745 if (src_valid && !bar_pane_keywords_dnd_can_move(keyword_tree, &src_kw_iter, nullptr))
747 /* the keyword can't be moved if the same name already exist */
750 if (new_keywords && !bar_pane_keywords_dnd_skip_existing(keyword_tree, nullptr, &new_keywords))
752 /* the keywords can't be added if the same name already exist */
755 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &new_kw_iter, nullptr);
761 keyword_move_recursive(GTK_TREE_STORE(keyword_tree), &new_kw_iter, &src_kw_iter);
767 auto keyword = static_cast<gchar *>(work->data);
768 keyword_set(GTK_TREE_STORE(keyword_tree), &new_kw_iter, keyword, TRUE);
774 gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, nullptr, &new_kw_iter);
778 g_list_free_full(new_keywords, g_free);
779 bar_keyword_tree_sync(pkd);
782 gint bar_pane_keywords_dnd_motion(GtkWidget *tree_view, GdkDragContext *context,
783 gint x, gint y, guint time, gpointer)
785 GtkTreePath *tpath = nullptr;
786 GtkTreeViewDropPosition pos;
787 gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(tree_view), x, y, &tpath, &pos);
791 GtkTreeIter dest_iter;
792 model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
793 gtk_tree_model_get_iter(model, &dest_iter, tpath);
794 if (pos == GTK_TREE_VIEW_DROP_INTO_OR_BEFORE && gtk_tree_model_iter_has_child(model, &dest_iter))
795 pos = GTK_TREE_VIEW_DROP_BEFORE;
797 if (pos == GTK_TREE_VIEW_DROP_INTO_OR_AFTER && gtk_tree_model_iter_has_child(model, &dest_iter))
798 pos = GTK_TREE_VIEW_DROP_AFTER;
801 gtk_tree_view_set_drag_dest_row(GTK_TREE_VIEW(tree_view), tpath, pos);
802 gtk_tree_path_free(tpath);
804 if (tree_view == gtk_drag_get_source_widget(context))
805 gdk_drag_status(context, GDK_ACTION_MOVE, time);
807 gdk_drag_status(context, GDK_ACTION_COPY, time);
813 *-------------------------------------------------------------------
815 *-------------------------------------------------------------------
818 void bar_pane_keywords_edit_destroy_cb(GtkWidget *, gpointer data)
820 auto cdd = static_cast<ConfDialogData *>(data);
821 gtk_tree_path_free(cdd->click_tpath);
826 void bar_pane_keywords_edit_cancel_cb(GenericDialog *, gpointer)
831 void bar_pane_keywords_edit_ok_cb(GenericDialog *, gpointer data)
833 auto cdd = static_cast<ConfDialogData *>(data);
834 PaneKeywordsData *pkd = cdd->pkd;
837 GtkTreeModel *keyword_tree;
840 gboolean have_dest = FALSE;
844 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
845 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
847 if (cdd->click_tpath)
850 if (gtk_tree_model_get_iter(model, &iter, cdd->click_tpath))
852 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
857 if (cdd->edit_existing && !have_dest) return;
859 keywords = keyword_list_pull(cdd->edit_widget);
861 if (cdd->edit_existing)
863 if (keywords && keywords->data && /* there should be one keyword */
864 !keyword_exists(keyword_tree, nullptr, &kw_iter, static_cast<const gchar *>(keywords->data), TRUE, nullptr))
866 keyword_set(GTK_TREE_STORE(keyword_tree), &kw_iter, static_cast<const gchar *>(keywords->data), cdd->is_keyword);
871 GList *work = keywords;
872 gboolean append_to = FALSE;
877 if (keyword_exists(keyword_tree, nullptr, (have_dest || append_to) ? &kw_iter : nullptr, static_cast<const gchar *>(work->data), FALSE, nullptr))
884 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, &kw_iter);
888 gtk_tree_store_insert_after(GTK_TREE_STORE(keyword_tree), &add, nullptr, &kw_iter);
892 gtk_tree_store_append(GTK_TREE_STORE(keyword_tree), &add, nullptr);
896 keyword_set(GTK_TREE_STORE(keyword_tree), &add, static_cast<const gchar *>(work->data), cdd->is_keyword);
900 g_list_free_full(keywords, g_free);
903 void bar_pane_keywords_conf_set_helper(GtkWidget *, gpointer data)
905 auto cdd = static_cast<ConfDialogData *>(data);
906 cdd->is_keyword = FALSE;
909 void bar_pane_keywords_conf_set_kw(GtkWidget *, gpointer data)
911 auto cdd = static_cast<ConfDialogData *>(data);
912 cdd->is_keyword = TRUE;
917 void bar_pane_keywords_edit_dialog(PaneKeywordsData *pkd, gboolean edit_existing)
925 gchar *name = nullptr;
926 gboolean is_keyword = TRUE;
929 if (edit_existing && pkd->click_tpath)
933 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
935 if (gtk_tree_model_get_iter(model, &iter, pkd->click_tpath))
937 gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name,
938 FILTER_KEYWORD_COLUMN_IS_KEYWORD, &is_keyword, -1);
946 if (edit_existing && !name) return;
949 cdd = g_new0(ConfDialogData, 1);
951 cdd->click_tpath = pkd->click_tpath;
952 pkd->click_tpath = nullptr;
953 cdd->edit_existing = edit_existing;
955 cdd->gd = gd = generic_dialog_new(name ? _("Edit keyword") : _("New keyword"), "keyword_edit",
957 bar_pane_keywords_edit_cancel_cb, cdd);
958 g_signal_connect(G_OBJECT(gd->dialog), "destroy",
959 G_CALLBACK(bar_pane_keywords_edit_destroy_cb), cdd);
962 generic_dialog_add_message(gd, nullptr, name ? _("Configure keyword") : _("New keyword"), nullptr, FALSE);
964 generic_dialog_add_button(gd, GQ_ICON_OK, "OK",
965 bar_pane_keywords_edit_ok_cb, TRUE);
967 table = pref_table_new(gd->vbox, 3, 1, FALSE, TRUE);
968 pref_table_label(table, 0, 0, _("Keyword:"), GTK_ALIGN_END);
969 cdd->edit_widget = gtk_entry_new();
970 gtk_widget_set_size_request(cdd->edit_widget, 300, -1);
971 if (name) gq_gtk_entry_set_text(GTK_ENTRY(cdd->edit_widget), name);
972 gq_gtk_grid_attach_default(GTK_GRID(table), cdd->edit_widget, 1, 2, 0, 1);
973 /* here could eventually be a text view instead of entry */
974 generic_dialog_attach_default(gd, cdd->edit_widget);
975 gtk_widget_show(cdd->edit_widget);
977 group = pref_group_new(gd->vbox, FALSE, _("Keyword type:"), GTK_ORIENTATION_VERTICAL);
979 button = pref_radiobutton_new(group, nullptr, _("Active keyword"),
981 G_CALLBACK(bar_pane_keywords_conf_set_kw), cdd);
982 button = pref_radiobutton_new(group, button, _("Helper"),
984 G_CALLBACK(bar_pane_keywords_conf_set_helper), cdd);
986 cdd->is_keyword = is_keyword;
990 gtk_widget_grab_focus(cdd->edit_widget);
992 gtk_widget_show(gd->dialog);
997 *-------------------------------------------------------------------
999 *-------------------------------------------------------------------
1002 void bar_pane_keywords_edit_dialog_cb(GtkWidget *, gpointer data)
1004 auto pkd = static_cast<PaneKeywordsData *>(data);
1005 bar_pane_keywords_edit_dialog(pkd, TRUE);
1008 void bar_pane_keywords_add_dialog_cb(GtkWidget *, gpointer data)
1010 auto pkd = static_cast<PaneKeywordsData *>(data);
1011 bar_pane_keywords_edit_dialog(pkd, FALSE);
1014 void bar_pane_keywords_connect_mark_cb(GtkWidget *menu_widget, gpointer data)
1016 auto pkd = static_cast<PaneKeywordsData *>(data);
1018 GtkTreeModel *model;
1021 GtkTreeModel *keyword_tree;
1022 GtkTreeIter kw_iter;
1024 gint mark = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu_widget), "mark")) - 1;
1026 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1027 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1029 if (!pkd->click_tpath) return;
1030 if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1032 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
1034 meta_data_connect_mark_with_keyword(keyword_tree, &kw_iter, mark);
1037 void bar_pane_keywords_disconnect_marks_ok_cb(GenericDialog *, gpointer)
1039 keyword_tree_disconnect_marks();
1042 void dummy_cancel_cb(GenericDialog *, gpointer)
1044 /* no op, only so cancel button appears */
1047 void bar_pane_keywords_disconnect_marks_cb(GtkWidget *menu_widget, gpointer data)
1049 auto pkd = static_cast<PaneKeywordsData *>(data);
1053 gd = generic_dialog_new(_("Marks Keywords"),
1054 "marks_keywords", menu_widget, TRUE, dummy_cancel_cb, pkd);
1055 generic_dialog_add_message(gd, GQ_ICON_DIALOG_WARNING,
1056 _("Disconnect all Marks Keywords connections?"), _("This will disconnect all Marks Keywords connections"), TRUE);
1057 generic_dialog_add_button(gd, GQ_ICON_OK, "OK", bar_pane_keywords_disconnect_marks_ok_cb, TRUE);
1059 gtk_widget_show(gd->dialog);
1062 void bar_pane_keywords_delete_cb(GtkWidget *, gpointer data)
1064 auto pkd = static_cast<PaneKeywordsData *>(data);
1065 GtkTreeModel *model;
1068 GtkTreeModel *keyword_tree;
1069 GtkTreeIter kw_iter;
1071 if (!pkd->click_tpath) return;
1073 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1074 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1076 if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1077 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
1079 keyword_delete(GTK_TREE_STORE(keyword_tree), &kw_iter);
1082 void bar_pane_keywords_hide_cb(GtkWidget *, gpointer data)
1084 auto pkd = static_cast<PaneKeywordsData *>(data);
1085 GtkTreeModel *model;
1088 GtkTreeModel *keyword_tree;
1089 GtkTreeIter kw_iter;
1091 if (!pkd->click_tpath) return;
1093 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1094 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1096 if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1097 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &kw_iter, &iter);
1099 keyword_hide_in(GTK_TREE_STORE(keyword_tree), &kw_iter, model);
1102 void bar_pane_keywords_show_all_cb(GtkWidget *, gpointer data)
1104 auto pkd = static_cast<PaneKeywordsData *>(data);
1105 GtkTreeModel *model;
1107 GtkTreeModel *keyword_tree;
1109 g_list_free_full(pkd->expanded_rows, g_free);
1110 pkd->expanded_rows = nullptr;
1111 gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(pkd->keyword_treeview),
1112 (bar_keyword_tree_get_expanded_cb), &pkd->expanded_rows);
1114 pkd->hide_unchecked = FALSE;
1116 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1117 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1119 keyword_show_all_in(GTK_TREE_STORE(keyword_tree), model);
1121 if (!pkd->collapse_unchecked) gtk_tree_view_expand_all(GTK_TREE_VIEW(pkd->keyword_treeview));
1122 bar_keyword_tree_sync(pkd);
1125 void bar_pane_keywords_revert_cb(GtkWidget *, gpointer data)
1127 auto pkd = static_cast<PaneKeywordsData *>(data);
1129 GtkTreePath *tree_path;
1132 gtk_tree_view_collapse_all(GTK_TREE_VIEW(pkd->keyword_treeview));
1134 work = pkd->expanded_rows;
1137 path = static_cast<gchar *>(work->data);
1138 tree_path = gtk_tree_path_new_from_string(path);
1139 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), tree_path);
1141 gtk_tree_path_free(tree_path);
1144 bar_keyword_tree_sync(pkd);
1147 void bar_pane_keywords_expand_checked_cb(GtkWidget *, gpointer data)
1149 auto pkd = static_cast<PaneKeywordsData *>(data);
1150 GtkTreeModel *model;
1152 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1153 gtk_tree_model_foreach(model, bar_keyword_tree_expand_if_set_cb, pkd);
1156 void bar_pane_keywords_collapse_all_cb(GtkWidget *, gpointer data)
1158 auto pkd = static_cast<PaneKeywordsData *>(data);
1160 g_list_free_full(pkd->expanded_rows, g_free);
1161 pkd->expanded_rows = nullptr;
1162 gtk_tree_view_map_expanded_rows(GTK_TREE_VIEW(pkd->keyword_treeview),
1163 (bar_keyword_tree_get_expanded_cb), &pkd->expanded_rows);
1165 gtk_tree_view_collapse_all(GTK_TREE_VIEW(pkd->keyword_treeview));
1167 bar_keyword_tree_sync(pkd);
1170 void bar_pane_keywords_revert_hidden_cb(GtkWidget *, gpointer data)
1172 auto pkd = static_cast<PaneKeywordsData *>(data);
1173 GtkTreeModel *model;
1174 GtkTreeModel *keyword_tree;
1176 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1177 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1179 keyword_revert_hidden_in(GTK_TREE_STORE(keyword_tree), model);
1181 bar_keyword_tree_sync(pkd);
1184 void bar_pane_keywords_collapse_unchecked_cb(GtkWidget *, gpointer data)
1186 auto pkd = static_cast<PaneKeywordsData *>(data);
1187 GtkTreeModel *model;
1189 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1190 gtk_tree_model_foreach(model, bar_keyword_tree_collapse_if_unset_cb, pkd);
1193 void bar_pane_keywords_hide_unchecked_cb(GtkWidget *, gpointer data)
1195 auto pkd = static_cast<PaneKeywordsData *>(data);
1196 GtkTreeModel *model;
1198 GtkTreeModel *keyword_tree;
1201 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1202 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1204 keywords = keyword_list_pull(pkd->keyword_view);
1205 keyword_hide_unset_in(GTK_TREE_STORE(keyword_tree), model, keywords);
1206 g_list_free_full(keywords, g_free);
1207 bar_keyword_tree_sync(pkd);
1210 void bar_pane_keywords_expand_checked_toggle_cb(GtkWidget *, gpointer data)
1212 auto pkd = static_cast<PaneKeywordsData *>(data);
1213 pkd->expand_checked = !pkd->expand_checked;
1214 bar_keyword_tree_sync(pkd);
1217 void bar_pane_keywords_collapse_unchecked_toggle_cb(GtkWidget *, gpointer data)
1219 auto pkd = static_cast<PaneKeywordsData *>(data);
1220 pkd->collapse_unchecked = !pkd->collapse_unchecked;
1221 bar_keyword_tree_sync(pkd);
1224 void bar_pane_keywords_hide_unchecked_toggle_cb(GtkWidget *, gpointer data)
1226 auto pkd = static_cast<PaneKeywordsData *>(data);
1227 pkd->hide_unchecked = !pkd->hide_unchecked;
1228 bar_keyword_tree_sync(pkd);
1232 * @brief Callback for adding selected keyword to all selected images.
1234 void bar_pane_keywords_add_to_selected_cb(GtkWidget *, gpointer data)
1236 auto pkd = static_cast<PaneKeywordsData *>(data);
1237 GtkTreeIter iter; /* This is the iter which initial holds the current keyword */
1238 GtkTreeIter child_iter;
1239 GtkTreeModel *model;
1240 GtkTreeModel *keyword_tree;
1243 GList *keywords = nullptr;
1245 GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
1247 /* Acquire selected keyword */
1248 if (pkd->click_tpath)
1250 gboolean is_keyword = TRUE;
1252 model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1253 if (!gtk_tree_model_get_iter(model, &iter, pkd->click_tpath)) return;
1254 gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_IS_KEYWORD, &is_keyword, -1);
1255 if (!is_keyword) return;
1260 keyword_tree = gtk_tree_model_filter_get_model(GTK_TREE_MODEL_FILTER(model));
1261 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
1263 list = keyword_list_pull(pkd->keyword_view); /* Get the left keyword view */
1265 /* Now set the current image */
1266 keyword_tree_set(keyword_tree, &child_iter, &list);
1268 keyword_list_push(pkd->keyword_view, list); /* Set the left keyword view */
1269 g_list_free_full(list, g_free);
1271 bar_pane_keywords_changed(keyword_buffer, pkd); /* Get list of all keywords in the hierarchy */
1273 gtk_tree_model_filter_convert_iter_to_child_iter(GTK_TREE_MODEL_FILTER(model), &child_iter, &iter);
1274 keywords = keyword_tree_get(keyword_tree, &child_iter);
1276 list = layout_selection_list(pkd->pane.lw);
1280 auto fd = static_cast<FileData *>(work->data);
1282 metadata_append_list(fd, KEYWORD_KEY, keywords);
1284 filelist_free(list);
1285 g_list_free_full(keywords, g_free);
1288 void bar_pane_keywords_menu_popup(GtkWidget *, PaneKeywordsData *pkd, gint x, gint y)
1293 GtkTreeViewDropPosition pos;
1295 if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);
1296 pkd->click_tpath = nullptr;
1297 gtk_tree_view_get_dest_row_at_pos(GTK_TREE_VIEW(pkd->keyword_treeview), x, y, &pkd->click_tpath, &pos);
1299 menu = popup_menu_short_lived();
1301 menu_item_add_icon(menu, _("New keyword"), GQ_ICON_NEW, G_CALLBACK(bar_pane_keywords_add_dialog_cb), pkd);
1303 menu_item_add_divider(menu);
1305 if (pkd->click_tpath)
1313 GtkTreeModel *model = gtk_tree_view_get_model(GTK_TREE_VIEW(pkd->keyword_treeview));
1316 gtk_tree_model_get_iter(model, &iter, pkd->click_tpath);
1319 gtk_tree_model_get(model, &iter, FILTER_KEYWORD_COLUMN_NAME, &name,
1320 FILTER_KEYWORD_COLUMN_MARK, &mark,
1321 FILTER_KEYWORD_COLUMN_IS_KEYWORD, &keyword, -1);
1325 text = g_strdup_printf(_("Add \"%s\" to all selected images"), name);
1326 menu_item_add_icon(menu, text, GQ_ICON_ADD, G_CALLBACK(bar_pane_keywords_add_to_selected_cb), pkd);
1329 menu_item_add_divider(menu);
1331 text = g_strdup_printf(_("Hide \"%s\""), name);
1332 menu_item_add(menu, text, G_CALLBACK(bar_pane_keywords_hide_cb), pkd);
1335 submenu = gtk_menu_new();
1336 for (i = 0; i < FILEDATA_MARKS_SIZE; i++)
1338 text = g_strdup_printf(_("Mark %d"), 1 + (i < 9 ? i : -1));
1339 item = menu_item_add(submenu, text, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
1340 g_object_set_data(G_OBJECT(item), "mark", GINT_TO_POINTER(i + 1));
1346 text = g_strdup_printf(_("Connect \"%s\" to mark"), name);
1347 item = menu_item_add(menu, text, nullptr, nullptr);
1348 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
1351 menu_item_add_divider(menu);
1353 text = g_strdup_printf(_("Edit \"%s\""), name);
1354 menu_item_add_icon(menu, text, GQ_ICON_EDIT, G_CALLBACK(bar_pane_keywords_edit_dialog_cb), pkd);
1356 text = g_strdup_printf(_("Remove \"%s\""), name);
1357 menu_item_add_icon(menu, text, GQ_ICON_DELETE, G_CALLBACK(bar_pane_keywords_delete_cb), pkd);
1361 if (mark && mark[0])
1363 text = g_strdup_printf(_("Disconnect \"%s\" from mark %s"), name, mark);
1364 menu_item_add_icon(menu, text, GQ_ICON_DELETE, G_CALLBACK(bar_pane_keywords_connect_mark_cb), pkd);
1370 text = g_strdup_printf(_("Disconnect all Mark Keyword connections"));
1371 menu_item_add_icon(menu, text, GQ_ICON_DELETE, G_CALLBACK(bar_pane_keywords_disconnect_marks_cb), pkd);
1374 menu_item_add_divider(menu);
1381 menu_item_add(menu, _("Expand checked"), G_CALLBACK(bar_pane_keywords_expand_checked_cb), pkd);
1382 menu_item_add(menu, _("Collapse unchecked"), G_CALLBACK(bar_pane_keywords_collapse_unchecked_cb), pkd);
1383 menu_item_add(menu, _("Hide unchecked"), G_CALLBACK(bar_pane_keywords_hide_unchecked_cb), pkd);
1384 menu_item_add(menu, _("Revert all hidden"), G_CALLBACK(bar_pane_keywords_revert_hidden_cb), pkd);
1385 menu_item_add_divider(menu);
1386 menu_item_add(menu, _("Show all"), G_CALLBACK(bar_pane_keywords_show_all_cb), pkd);
1387 menu_item_add(menu, _("Collapse all"), G_CALLBACK(bar_pane_keywords_collapse_all_cb), pkd);
1388 menu_item_add(menu, _("Revert"), G_CALLBACK(bar_pane_keywords_revert_cb), pkd);
1389 menu_item_add_divider(menu);
1391 submenu = gtk_menu_new();
1392 item = menu_item_add(menu, _("On any change"), nullptr, nullptr);
1393 gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
1395 menu_item_add_check(submenu, _("Expand checked"), pkd->expand_checked, G_CALLBACK(bar_pane_keywords_expand_checked_toggle_cb), pkd);
1396 menu_item_add_check(submenu, _("Collapse unchecked"), pkd->collapse_unchecked, G_CALLBACK(bar_pane_keywords_collapse_unchecked_toggle_cb), pkd);
1397 menu_item_add_check(submenu, _("Hide unchecked"), pkd->hide_unchecked, G_CALLBACK(bar_pane_keywords_hide_unchecked_toggle_cb), pkd);
1399 gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
1402 gboolean bar_pane_keywords_menu_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1404 auto pkd = static_cast<PaneKeywordsData *>(data);
1405 if (bevent->button == MOUSE_BUTTON_RIGHT)
1407 bar_pane_keywords_menu_popup(widget, pkd, bevent->x, bevent->y);
1414 *-------------------------------------------------------------------
1416 *-------------------------------------------------------------------
1419 void bar_pane_keywords_destroy(GtkWidget *, gpointer data)
1421 auto pkd = static_cast<PaneKeywordsData *>(data);
1424 path = g_build_filename(get_rc_dir(), "keywords", NULL);
1425 autocomplete_keywords_list_save(path);
1427 g_list_free_full(pkd->expanded_rows, g_free);
1428 if (pkd->click_tpath) gtk_tree_path_free(pkd->click_tpath);
1429 if (pkd->idle_id) g_source_remove(pkd->idle_id);
1430 file_data_unregister_notify_func(bar_pane_keywords_notify_cb, pkd);
1432 file_data_unref(pkd->fd);
1439 GtkWidget *bar_pane_keywords_new(const gchar *id, const gchar *title, const gchar *key, gboolean expanded, gint height)
1441 PaneKeywordsData *pkd;
1444 GtkWidget *scrolled;
1445 GtkTextBuffer *buffer;
1446 GtkTreeModel *store;
1447 GtkTreeViewColumn *column;
1448 GtkCellRenderer *renderer;
1450 GtkEntryCompletion *completion;
1453 pkd = g_new0(PaneKeywordsData, 1);
1455 pkd->pane.pane_set_fd = bar_pane_keywords_set_fd;
1456 pkd->pane.pane_event = bar_pane_keywords_event;
1457 pkd->pane.pane_write_config = bar_pane_keywords_write_config;
1458 pkd->pane.title = bar_pane_expander_title(title);
1459 pkd->pane.id = g_strdup(id);
1460 pkd->pane.type = PANE_KEYWORDS;
1462 pkd->pane.expanded = expanded;
1464 pkd->height = height;
1465 pkd->key = g_strdup(key);
1467 pkd->expand_checked = TRUE;
1468 pkd->expanded_rows = nullptr;
1470 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
1471 hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
1472 gq_gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
1475 g_object_set_data(G_OBJECT(pkd->widget), "pane_data", pkd);
1476 g_signal_connect(G_OBJECT(pkd->widget), "destroy",
1477 G_CALLBACK(bar_pane_keywords_destroy), pkd);
1478 gtk_widget_set_size_request(pkd->widget, -1, height);
1479 gtk_widget_show(hbox);
1481 scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
1482 gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
1483 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
1484 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1485 gq_gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
1486 gtk_widget_show(scrolled);
1488 pkd->keyword_view = gtk_text_view_new();
1489 gq_gtk_container_add(GTK_WIDGET(scrolled), pkd->keyword_view);
1490 g_signal_connect(G_OBJECT(pkd->keyword_view), "populate-popup",
1491 G_CALLBACK(bar_pane_keywords_populate_popup_cb), pkd);
1492 gtk_widget_show(pkd->keyword_view);
1494 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
1495 g_signal_connect(G_OBJECT(buffer), "changed",
1496 G_CALLBACK(bar_pane_keywords_changed), pkd);
1498 if (options->show_predefined_keyword_tree)
1500 scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
1501 gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
1502 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
1503 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1504 gq_gtk_box_pack_start(GTK_BOX(hbox), scrolled, TRUE, TRUE, 0);
1505 gtk_widget_show(scrolled);
1508 pkd->autocomplete = gtk_entry_new();
1509 gq_gtk_box_pack_end(GTK_BOX(vbox), pkd->autocomplete, FALSE, FALSE, 0);
1510 gtk_widget_show(pkd->autocomplete);
1511 gtk_widget_show(vbox);
1512 gtk_widget_set_tooltip_text(pkd->autocomplete, _("Keyword autocomplete"));
1514 path = g_build_filename(get_rc_dir(), "keywords", NULL);
1515 autocomplete_keywords_list_load(path);
1517 completion = gtk_entry_completion_new();
1518 gtk_entry_set_completion(GTK_ENTRY(pkd->autocomplete), completion);
1519 gtk_entry_completion_set_inline_completion(completion, TRUE);
1520 gtk_entry_completion_set_inline_selection(completion, TRUE);
1521 g_object_unref(completion);
1523 gtk_entry_completion_set_model(completion, GTK_TREE_MODEL(keyword_store));
1524 gtk_entry_completion_set_text_column(completion, 0);
1526 g_signal_connect(G_OBJECT(pkd->autocomplete), "activate",
1527 G_CALLBACK(autocomplete_activate_cb), pkd);
1529 if (!keyword_tree || !gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_tree), &iter))
1531 /* keyword tree does not exist or is empty - fill with defaults */
1532 keyword_tree_new_default();
1535 store = gtk_tree_model_filter_new(GTK_TREE_MODEL(keyword_tree), nullptr);
1537 gtk_tree_model_filter_set_modify_func(GTK_TREE_MODEL_FILTER(store),
1538 FILTER_KEYWORD_COLUMN_COUNT,
1539 filter_keyword_column_types,
1540 bar_pane_keywords_filter_modify,
1543 gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(store),
1544 bar_pane_keywords_filter_visible,
1548 pkd->keyword_treeview = gtk_tree_view_new_with_model(store);
1549 g_object_unref(store);
1551 gtk_widget_set_size_request(pkd->keyword_treeview, -1, 400);
1553 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(pkd->keyword_treeview), FALSE);
1555 column = gtk_tree_view_column_new();
1556 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1558 renderer = gtk_cell_renderer_text_new();
1559 gtk_tree_view_column_pack_start(column, renderer, TRUE);
1561 gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_MARK);
1563 gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
1565 column = gtk_tree_view_column_new();
1566 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
1567 renderer = gtk_cell_renderer_toggle_new();
1568 gtk_tree_view_column_pack_start(column, renderer, FALSE);
1569 gtk_tree_view_column_add_attribute(column, renderer, "active", FILTER_KEYWORD_COLUMN_TOGGLE);
1570 gtk_tree_view_column_add_attribute(column, renderer, "visible", FILTER_KEYWORD_COLUMN_IS_KEYWORD);
1571 g_signal_connect(G_OBJECT(renderer), "toggled",
1572 G_CALLBACK(bar_pane_keywords_keyword_toggle), pkd);
1574 renderer = gtk_cell_renderer_text_new();
1575 gtk_tree_view_column_pack_start(column, renderer, TRUE);
1576 gtk_tree_view_column_add_attribute(column, renderer, "text", FILTER_KEYWORD_COLUMN_NAME);
1578 gtk_tree_view_append_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
1579 gtk_tree_view_set_expander_column(GTK_TREE_VIEW(pkd->keyword_treeview), column);
1581 gtk_drag_source_set(pkd->keyword_treeview,
1582 static_cast<GdkModifierType>(GDK_BUTTON1_MASK | GDK_BUTTON2_MASK),
1583 bar_pane_keywords_drag_types, n_keywords_drag_types,
1584 static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK));
1586 g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_get",
1587 G_CALLBACK(bar_pane_keywords_dnd_get), pkd);
1589 g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_begin",
1590 G_CALLBACK(bar_pane_keywords_dnd_begin), pkd);
1591 g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_end",
1592 G_CALLBACK(bar_pane_keywords_dnd_end), pkd);
1594 gtk_drag_dest_set(pkd->keyword_treeview,
1595 static_cast<GtkDestDefaults>(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP),
1596 bar_pane_keywords_drop_types, n_keywords_drop_types,
1597 static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE));
1599 g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_data_received",
1600 G_CALLBACK(bar_pane_keywords_dnd_receive), pkd);
1602 g_signal_connect(G_OBJECT(pkd->keyword_treeview), "drag_motion",
1603 G_CALLBACK(bar_pane_keywords_dnd_motion), pkd);
1605 g_signal_connect(G_OBJECT(pkd->keyword_treeview), "button_release_event",
1606 G_CALLBACK(bar_pane_keywords_menu_cb), pkd);
1608 if (options->show_predefined_keyword_tree)
1610 gq_gtk_container_add(GTK_WIDGET(scrolled), pkd->keyword_treeview);
1611 gtk_widget_show(pkd->keyword_treeview);
1614 file_data_register_notify_func(bar_pane_keywords_notify_cb, pkd, NOTIFY_PRIORITY_LOW);
1620 *-----------------------------------------------------------------------------
1621 * Autocomplete keywords
1622 *-----------------------------------------------------------------------------
1625 gboolean autocomplete_activate_cb(GtkWidget *, gpointer data)
1627 auto pkd = static_cast<PaneKeywordsData *>(data);
1629 GtkTextBuffer *buffer;
1635 gboolean found = FALSE;
1638 entry_text = g_strdup(gq_gtk_entry_get_text(GTK_ENTRY(pkd->autocomplete)));
1639 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view));
1641 kw_split = strtok(entry_text, ",");
1642 while (kw_split != nullptr)
1644 kw_cr = g_strconcat(kw_split, "\n", NULL);
1646 gtk_text_buffer_get_end_iter(buffer, &iter);
1647 gtk_text_buffer_insert(buffer, &iter, kw_cr, -1);
1649 kw_split = strtok(nullptr, ",");
1654 entry_text = g_strdup(gq_gtk_entry_get_text(GTK_ENTRY(pkd->autocomplete)));
1656 gq_gtk_entry_set_text(GTK_ENTRY(pkd->autocomplete), "");
1658 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_store), &iter_t);
1661 gtk_tree_model_get (GTK_TREE_MODEL(keyword_store), &iter_t, 0, &string, -1);
1662 if (g_strcmp0(entry_text, string) == 0)
1667 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(keyword_store), &iter_t);
1672 gtk_list_store_append (keyword_store, &iter_t);
1673 gtk_list_store_set(keyword_store, &iter_t, 0, entry_text, -1);
1680 gint autocomplete_sort_iter_compare_func (GtkTreeModel *model,
1689 gtk_tree_model_get(model, a, 0, &name1, -1);
1690 gtk_tree_model_get(model, b, 0, &name2, -1);
1692 if (name1 == nullptr || name2 == nullptr)
1694 if (name1 == nullptr && name2 == nullptr)
1700 ret = (name1 == nullptr) ? -1 : 1;
1705 ret = g_utf8_collate(name1,name2);
1714 void autocomplete_keywords_list_load(const gchar *path)
1721 GtkTreeSortable *sortable;
1723 if (keyword_store) return;
1724 keyword_store = gtk_list_store_new(1, G_TYPE_STRING);
1726 sortable = GTK_TREE_SORTABLE(keyword_store);
1727 gtk_tree_sortable_set_sort_func(sortable, 0, autocomplete_sort_iter_compare_func,
1728 GINT_TO_POINTER(0), nullptr);
1730 gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_ASCENDING);
1732 pathl = path_from_utf8(path);
1733 f = fopen(pathl, "r");
1737 log_printf("Warning: keywords file %s not loaded", pathl);
1742 /* first line must start with Keywords comment */
1743 if (!fgets(s_buf, sizeof(s_buf), f) ||
1744 strncmp(s_buf, "#Keywords", 9) != 0)
1747 log_printf("Warning: keywords file %s not loaded", pathl);
1754 while (fgets(s_buf, sizeof(s_buf), f))
1756 if (s_buf[0]=='#') continue;
1758 len = strlen(s_buf);
1759 if( s_buf[len-1] == '\n' )
1763 gtk_list_store_append (keyword_store, &iter);
1764 gtk_list_store_set(keyword_store, &iter, 0, g_strdup(s_buf), -1);
1770 gboolean autocomplete_keywords_list_save(gchar *path)
1772 SecureSaveInfo *ssi;
1779 pathl = path_from_utf8(path);
1780 ssi = secure_open(pathl);
1785 log_printf(_("Error: Unable to write keywords list to: %s\n"), path);
1789 secure_fprintf(ssi, "#Keywords list\n");
1791 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_store), &iter);
1795 gtk_tree_model_get (GTK_TREE_MODEL(keyword_store), &iter, 0, &string, -1);
1796 string_nl = g_strconcat(string, "\n", NULL);
1797 secure_fprintf(ssi, "%s", string_nl);
1799 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(keyword_store), &iter);
1804 secure_fprintf(ssi, "#end\n");
1805 return (secure_close(ssi) == 0);
1811 *-------------------------------------------------------------------
1813 *-------------------------------------------------------------------
1816 #pragma GCC diagnostic push
1817 #pragma GCC diagnostic ignored "-Wunused-function"
1818 void bar_pane_keywords_close_unused(GtkWidget *bar)
1820 PaneKeywordsData *pkd;
1822 pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(bar), "pane_data"));
1825 g_free(pkd->pane.id);
1826 g_object_unref(pkd->widget);
1828 #pragma GCC diagnostic pop
1830 GtkWidget *bar_pane_keywords_new_from_config(const gchar **attribute_names, const gchar **attribute_values)
1832 gchar *id = g_strdup("keywords");
1833 gchar *title = nullptr;
1834 gchar *key = g_strdup(COMMENT_KEY);
1835 gboolean expanded = TRUE;
1839 while (*attribute_names)
1841 const gchar *option = *attribute_names++;
1842 const gchar *value = *attribute_values++;
1844 if (READ_CHAR_FULL("id", id)) continue;
1845 if (READ_CHAR_FULL("title", title)) continue;
1846 if (READ_CHAR_FULL("key", key)) continue;
1847 if (READ_BOOL_FULL("expanded", expanded)) continue;
1848 if (READ_INT_FULL("height", height)) continue;
1851 log_printf("unknown attribute %s = %s\n", option, value);
1854 options->info_keywords.height = height;
1855 bar_pane_translate_title(PANE_KEYWORDS, id, &title);
1856 ret = bar_pane_keywords_new(id, title, key, expanded, height);
1863 void bar_pane_keywords_update_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
1865 PaneKeywordsData *pkd;
1867 pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
1870 gchar *title = nullptr;
1872 while (*attribute_names)
1874 const gchar *option = *attribute_names++;
1875 const gchar *value = *attribute_values++;
1877 if (READ_CHAR_FULL("title", title)) continue;
1878 if (READ_CHAR_FULL("key", pkd->key)) continue;
1879 if (READ_BOOL_FULL("expanded", pkd->pane.expanded)) continue;
1880 if (READ_CHAR_FULL("id", pkd->pane.id)) continue;
1883 log_printf("unknown attribute %s = %s\n", option, value);
1888 bar_pane_translate_title(PANE_KEYWORDS, pkd->pane.id, &title);
1889 gtk_label_set_text(GTK_LABEL(pkd->pane.title), title);
1893 bar_update_expander(pane);
1894 bar_pane_keywords_update(pkd);
1898 void bar_pane_keywords_entry_add_from_config(GtkWidget *pane, const gchar **attribute_names, const gchar **attribute_values)
1900 PaneKeywordsData *pkd;
1901 gchar *path = nullptr;
1902 GtkTreePath *tree_path;
1904 pkd = static_cast<PaneKeywordsData *>(g_object_get_data(G_OBJECT(pane), "pane_data"));
1907 while (*attribute_names)
1909 const gchar *option = *attribute_names++;
1910 const gchar *value = *attribute_values++;
1912 if (READ_CHAR_FULL("path", path))
1914 tree_path = gtk_tree_path_new_from_string(path);
1915 gtk_tree_view_expand_to_path(GTK_TREE_VIEW(pkd->keyword_treeview), tree_path);
1916 gtk_tree_path_free(tree_path);
1917 pkd->expanded_rows = g_list_append(pkd->expanded_rows, g_strdup(path));
1920 log_printf("unknown attribute %s = %s\n", option, value);
1925 *-------------------------------------------------------------------
1926 * keyword / comment utils
1927 *-------------------------------------------------------------------
1930 GList *keyword_list_pull(GtkWidget *text_widget)
1935 text = text_widget_text_pull(text_widget);
1936 list = string_to_keywords_list(text);
1943 GList *keyword_list_get()
1945 GList *ret_list = nullptr;
1953 valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(keyword_store), &iter);
1957 gtk_tree_model_get (GTK_TREE_MODEL(keyword_store), &iter, 0, &string, -1);
1958 string_nl = g_strconcat(string, "\n", NULL);
1959 ret_list = g_list_append(ret_list, string);
1960 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(keyword_store), &iter);
1969 void keyword_list_set(GList *keyword_list)
1973 if (!keyword_list) return;
1977 gtk_list_store_clear(keyword_store);
1981 keyword_store = gtk_list_store_new(1, G_TYPE_STRING);
1984 while (keyword_list)
1986 gtk_list_store_append (keyword_store, &iter);
1987 gtk_list_store_set(keyword_store, &iter, 0, keyword_list->data, -1);
1989 keyword_list = keyword_list->next;
1993 gboolean bar_keywords_autocomplete_focus(LayoutWindow *lw)
1996 GtkWidget *current_focus;
2000 current_focus = gtk_window_get_focus(GTK_WINDOW(lw->window));
2001 pane = bar_find_pane_by_id(lw->bar, PANE_KEYWORDS, "keywords");
2003 children = gtk_container_get_children(GTK_CONTAINER(pane));
2004 children = g_list_last(children);
2006 if (current_focus == children->data)
2012 gtk_widget_grab_focus(GTK_WIDGET(children->data));
2016 g_list_free(children);
2020 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */