src/ui-pathsel.cc

   1 /*
   2  * Copyright (C) 2006 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * Author: John Ellis
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "ui-pathsel.h"
  23
  24 #include <cstring>
  25
  26 #include <dirent.h>
  27 #include <sys/stat.h>
  28
  29 #include <gdk/gdk.h>
  30 #include <glib-object.h>
  31
  32 #include "compat.h"
  33 #include "debug.h"
  34 #include "intl.h"
  35 #include "main-defines.h"
  36 #include "misc.h"
  37 #include "options.h"
  38 #include "typedefs.h"
  39 #include "ui-bookmark.h"
  40 #include "ui-fileops.h"
  41 #include "ui-menu.h"
  42 #include "ui-misc.h"
  43 #include "ui-tabcomp.h"
  44 #include "ui-tree-edit.h"
  45 #include "ui-utildlg.h"
  46 #include "uri-utils.h"
  47 #include "utilops.h"
  48
  49
  50 enum {
  51         DEST_WIDTH = 250,
  52         DEST_HEIGHT = 210
  53 };
  54
  55 enum {
  56         RENAME_PRESS_DELAY = 333        /* 1/3 second, to allow double clicks */
  57 };
  58
  59 #define PATH_SEL_USE_HEADINGS FALSE
  60
  61 enum {
  62         FILTER_COLUMN_NAME = 0,
  63         FILTER_COLUMN_FILTER
  64 };
  65
  66 struct Dest_Data
  67 {
  68         GtkWidget *d_view;
  69         GtkWidget *f_view;
  70         GtkWidget *entry;
  71         gchar *filter;
  72         gchar *path;
  73
  74         GList *filter_list;
  75         GList *filter_text_list;
  76         GtkWidget *filter_combo;
  77
  78         gboolean show_hidden;
  79         GtkWidget *hidden_button;
  80
  81         GtkWidget *bookmark_list;
  82
  83         GtkTreePath *right_click_path;
  84
  85         void (*select_func)(const gchar *path, gpointer data);
  86         gpointer select_data;
  87
  88         GenericDialog *gd;      /* any open confirm dialogs ? */
  89 };
  90
  91 struct DestDel_Data
  92 {
  93         Dest_Data *dd;
  94         gchar *path;
  95 };
  96
  97
  98 static void dest_view_delete_dlg_cancel(GenericDialog *gd, gpointer data);
  99
 100
 101 /*
 102  *-----------------------------------------------------------------------------
 103  * (private)
 104  *-----------------------------------------------------------------------------
 105  */
 106
 107 static void dest_free_data(GtkWidget *, gpointer data)
 108 {
 109         auto dd = static_cast<Dest_Data *>(data);
 110
 111         if (dd->gd)
 112                 {
 113                 GenericDialog *gd = dd->gd;
 114                 dest_view_delete_dlg_cancel(dd->gd, dd->gd->data);
 115                 generic_dialog_close(gd);
 116                 }
 117         if (dd->right_click_path) gtk_tree_path_free(dd->right_click_path);
 118
 119         g_free(dd->filter);
 120         g_free(dd->path);
 121         g_free(dd);
 122 }
 123
 124 static gboolean dest_check_filter(const gchar *filter, const gchar *file)
 125 {
 126         const gchar *f_ptr = filter;
 127         const gchar *strt_ptr;
 128         gint i;
 129         gint l;
 130
 131         l = strlen(file);
 132
 133         if (filter[0] == '*') return TRUE;
 134         while (f_ptr < filter + strlen(filter))
 135                 {
 136                 strt_ptr = f_ptr;
 137                 i=0;
 138                 while (*f_ptr != ';' && *f_ptr != '\0')
 139                         {
 140                         f_ptr++;
 141                         i++;
 142                         }
 143                 if (*f_ptr != '\0' && f_ptr[1] == ' ') f_ptr++; /* skip space immediately after separator */
 144                 f_ptr++;
 145                 /**
 146                  * @FIXME utf8 */
 147                 if (l >= i && g_ascii_strncasecmp(file + l - i, strt_ptr, i) == 0) return TRUE;
 148                 }
 149         return FALSE;
 150 }
 151
 152 #ifndef CASE_SORT
 153 #define CASE_SORT strcmp
 154 #endif
 155
 156 static gint dest_sort_cb(gpointer a, gpointer b)
 157 {
 158         return CASE_SORT((gchar *)a, (gchar *)b);
 159 }
 160
 161 static gboolean is_hidden(const gchar *name)
 162 {
 163         if (name[0] != '.') return FALSE;
 164         if (name[1] == '\0') return FALSE;
 165         if (name[1] == '.' && name[2] == '\0') return FALSE;
 166         return TRUE;
 167 }
 168
 169 static void dest_populate(Dest_Data *dd, const gchar *path)
 170 {
 171         DIR *dp;
 172         struct dirent *dir;
 173         struct stat ent_sbuf;
 174         GList *path_list = nullptr;
 175         GList *file_list = nullptr;
 176         GList *list;
 177         GtkListStore *store;
 178         gchar *pathl;
 179
 180         if (!path) return;
 181
 182         pathl = path_from_utf8(path);
 183         dp = opendir(pathl);
 184         if (!dp)
 185                 {
 186                 /* dir not found */
 187                 g_free(pathl);
 188                 return;
 189                 }
 190         while ((dir = readdir(dp)) != nullptr)
 191                 {
 192                 if (!options->file_filter.show_dot_directory
 193                     && dir->d_name[0] == '.' && dir->d_name[1] == '\0')
 194                         continue;
 195                 if (dir->d_name[0] == '.' && dir->d_name[1] == '.' && dir->d_name[2] == '\0'
 196                     && pathl[0] == G_DIR_SEPARATOR && pathl[1] == '\0')
 197                         continue; /* no .. for root directory */
 198                 if (dd->show_hidden || !is_hidden(dir->d_name))
 199                         {
 200                         gchar *name = dir->d_name;
 201                         gchar *filepath = g_build_filename(pathl, name, NULL);
 202                         if (stat(filepath, &ent_sbuf) >= 0 && S_ISDIR(ent_sbuf.st_mode))
 203                                 {
 204                                 path_list = g_list_prepend(path_list, path_to_utf8(name));
 205                                 }
 206                         else if (dd->f_view)
 207                                 {
 208                                 if (!dd->filter || (dd->filter && dest_check_filter(dd->filter, name)))
 209                                         file_list = g_list_prepend(file_list, path_to_utf8(name));
 210                                 }
 211                         g_free(filepath);
 212                         }
 213                 }
 214         closedir(dp);
 215         g_free(pathl);
 216
 217         path_list = g_list_sort(path_list, reinterpret_cast<GCompareFunc>(dest_sort_cb));
 218         file_list = g_list_sort(file_list, reinterpret_cast<GCompareFunc>(dest_sort_cb));
 219
 220         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dd->d_view)));
 221         gtk_list_store_clear(store);
 222
 223         list = path_list;
 224         while (list)
 225                 {
 226                 GtkTreeIter iter;
 227                 gchar *filepath;
 228
 229                 if (strcmp(static_cast<const gchar *>(list->data), ".") == 0)
 230                         {
 231                         filepath = g_strdup(path);
 232                         }
 233                 else if (strcmp(static_cast<const gchar *>(list->data), "..") == 0)
 234                         {
 235                         gchar *p;
 236                         filepath = g_strdup(path);
 237                         p = const_cast<gchar *>(filename_from_path(filepath));
 238                         if (p - 1 != filepath) p--;
 239                         p[0] = '\0';
 240                         }
 241                 else
 242                         {
 243                         filepath = g_build_filename(path, list->data, NULL);
 244                         }
 245
 246                 gtk_list_store_append(store, &iter);
 247                 gtk_list_store_set(store, &iter, 0, list->data, 1, filepath, -1);
 248
 249                 g_free(filepath);
 250                 list = list->next;
 251                 }
 252
 253         g_list_free_full(path_list, g_free);
 254
 255
 256         if (dd->f_view)
 257                 {
 258                 store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dd->f_view)));
 259                 gtk_list_store_clear(store);
 260
 261                 list = file_list;
 262                 while (list)
 263                         {
 264                         GtkTreeIter iter;
 265                         gchar *filepath;
 266                         auto name = static_cast<const gchar *>(list->data);
 267
 268                         filepath = g_build_filename(path, name, NULL);
 269
 270                         gtk_list_store_append(store, &iter);
 271                         gtk_list_store_set(store, &iter, 0, name, 1, filepath, -1);
 272
 273                         g_free(filepath);
 274                         list = list->next;
 275                         }
 276
 277                 g_list_free_full(file_list, g_free);
 278                 }
 279
 280         g_free(dd->path);
 281         dd->path = g_strdup(path);
 282 }
 283
 284 static void dest_change_dir(Dest_Data *dd, const gchar *path, gboolean retain_name)
 285 {
 286         const gchar *old_name = nullptr;
 287         gchar *full_path;
 288         gchar *new_directory;
 289
 290         if (retain_name)
 291                 {
 292                 const gchar *buf = gq_gtk_entry_get_text(GTK_ENTRY(dd->entry));
 293
 294                 if (!isdir(buf)) old_name = filename_from_path(buf);
 295                 }
 296
 297         full_path = g_build_filename(path, old_name, NULL);
 298         if (old_name)
 299                 new_directory = g_path_get_dirname(full_path);
 300         else
 301                 new_directory = g_strdup(full_path);
 302
 303         gq_gtk_entry_set_text(GTK_ENTRY(dd->entry), full_path);
 304
 305         dest_populate(dd, new_directory);
 306         g_free(new_directory);
 307
 308         if (old_name)
 309                 {
 310                 gchar *basename = g_path_get_basename(full_path);
 311
 312                 gtk_editable_select_region(GTK_EDITABLE(dd->entry), strlen(full_path) - strlen(basename), strlen(full_path));
 313                 g_free(basename);
 314                 }
 315
 316         g_free(full_path);
 317 }
 318
 319 /*
 320  *-----------------------------------------------------------------------------
 321  * drag and drop
 322  *-----------------------------------------------------------------------------
 323  */
 324
 325 enum {
 326         TARGET_URI_LIST,
 327         TARGET_TEXT_PLAIN
 328 };
 329
 330 static GtkTargetEntry dest_drag_types[] = {
 331         { const_cast<gchar *>("text/uri-list"), 0, TARGET_URI_LIST },
 332         { const_cast<gchar *>("text/plain"),    0, TARGET_TEXT_PLAIN }
 333 };
 334 enum {
 335         dest_drag_types_n = 2
 336 };
 337
 338
 339 static void dest_dnd_set_data(GtkWidget *view, GdkDragContext *,
 340                                   GtkSelectionData *selection_data,
 341                                   guint, guint, gpointer)
 342 {
 343         gchar *path = nullptr;
 344         GList *list = nullptr;
 345         GtkTreeModel *model;
 346         GtkTreeSelection *selection;
 347         GtkTreeIter iter;
 348
 349         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
 350         if (!gtk_tree_selection_get_selected(selection, &model, &iter)) return;
 351
 352         gtk_tree_model_get(model, &iter, 1, &path, -1);
 353         if (!path) return;
 354
 355         list = g_list_append(list, path);
 356
 357         gchar **uris = uris_from_pathlist(list);
 358         gboolean ret = gtk_selection_data_set_uris(selection_data, uris);
 359         if (!ret)
 360                 {
 361                 char *str = g_strjoinv("\r\n", uris);
 362                 ret = gtk_selection_data_set_text(selection_data, str, -1);
 363                 g_free(str);
 364                 }
 365
 366         g_list_free_full(list, g_free);
 367 }
 368
 369 static void dest_dnd_init(Dest_Data *dd)
 370 {
 371         gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(dd->d_view), GDK_BUTTON1_MASK,
 372                                                dest_drag_types, dest_drag_types_n,
 373                                                static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK));
 374         g_signal_connect(G_OBJECT(dd->d_view), "drag_data_get",
 375                          G_CALLBACK(dest_dnd_set_data), dd);
 376
 377         if (dd->f_view)
 378                 {
 379                 gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(dd->f_view), GDK_BUTTON1_MASK,
 380                                                        dest_drag_types, dest_drag_types_n,
 381                                                        static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK));
 382                 g_signal_connect(G_OBJECT(dd->f_view), "drag_data_get",
 383                                  G_CALLBACK(dest_dnd_set_data), dd);
 384                 }
 385 }
 386
 387
 388 /*
 389  *-----------------------------------------------------------------------------
 390  * destination widget file management utils
 391  *-----------------------------------------------------------------------------
 392  */
 393
 394 static void dest_view_store_selection(Dest_Data *dd, GtkTreeView *view)
 395 {
 396         GtkTreeModel *model;
 397         GtkTreeSelection *selection;
 398         GtkTreeIter iter;
 399
 400         if (dd->right_click_path) gtk_tree_path_free(dd->right_click_path);
 401         dd->right_click_path = nullptr;
 402
 403         selection = gtk_tree_view_get_selection(view);
 404         if (!gtk_tree_selection_get_selected(selection, &model, &iter))
 405                 {
 406                 return;
 407                 }
 408
 409         dd->right_click_path = gtk_tree_model_get_path(model, &iter);
 410 }
 411
 412 static gint dest_view_rename_cb(TreeEditData *ted, const gchar *old_name, const gchar *new_name, gpointer data)
 413 {
 414         auto dd = static_cast<Dest_Data *>(data);
 415         GtkTreeModel *model;
 416         GtkTreeIter iter;
 417         gchar *buf;
 418         gchar *old_path;
 419         gchar *new_path;
 420
 421         model = gtk_tree_view_get_model(GTK_TREE_VIEW(ted->tree));
 422         gtk_tree_model_get_iter(model, &iter, dd->right_click_path);
 423
 424         gtk_tree_model_get(model, &iter, 1, &old_path, -1);
 425         if (!old_path) return FALSE;
 426
 427         buf = remove_level_from_path(old_path);
 428         new_path = g_build_filename(buf, new_name, NULL);
 429         g_free(buf);
 430
 431         if (isname(new_path))
 432                 {
 433                 buf = g_strdup_printf(_("A file with name %s already exists."), new_name);
 434                 warning_dialog(_("Rename failed"), buf, GQ_ICON_DIALOG_INFO, dd->entry);
 435                 g_free(buf);
 436                 }
 437         else if (!rename_file(old_path, new_path))
 438                 {
 439                 buf = g_strdup_printf(_("Failed to rename %s to %s."), old_name, new_name);
 440                 warning_dialog(_("Rename failed"), buf, GQ_ICON_DIALOG_ERROR, dd->entry);
 441                 g_free(buf);
 442                 }
 443         else
 444                 {
 445                 const gchar *text;
 446
 447                 gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, new_name, 1, new_path, -1);
 448
 449                 text = gq_gtk_entry_get_text(GTK_ENTRY(dd->entry));
 450                 if (text && old_path && strcmp(text, old_path) == 0)
 451                         {
 452                         gq_gtk_entry_set_text(GTK_ENTRY(dd->entry), new_path);
 453                         }
 454                 }
 455
 456         g_free(old_path);
 457         g_free(new_path);
 458
 459         return TRUE;
 460 }
 461
 462 static void dest_view_rename(Dest_Data *dd, GtkTreeView *view)
 463 {
 464         GtkTreeModel *model;
 465         GtkTreeIter iter;
 466         gchar *text;
 467
 468         if (!dd->right_click_path) return;
 469
 470         model = gtk_tree_view_get_model(view);
 471         gtk_tree_model_get_iter(model, &iter, dd->right_click_path);
 472         gtk_tree_model_get(model, &iter, 0, &text, -1);
 473
 474         tree_edit_by_path(view, dd->right_click_path, 0, text,
 475                           dest_view_rename_cb, dd);
 476
 477         g_free(text);
 478 }
 479
 480 static void dest_view_delete_dlg_cancel(GenericDialog *, gpointer data)
 481 {
 482         auto dl = static_cast<DestDel_Data *>(data);
 483
 484         dl->dd->gd = nullptr;
 485         g_free(dl->path);
 486         g_free(dl);
 487 }
 488
 489 static void dest_view_delete_dlg_ok_cb(GenericDialog *gd, gpointer data)
 490 {
 491         auto dl = static_cast<DestDel_Data *>(data);
 492
 493         if (!unlink_file(dl->path))
 494                 {
 495                 gchar *text = g_strdup_printf(_("Unable to delete file:\n%s"), dl->path);
 496                 warning_dialog(_("File deletion failed"), text, GQ_ICON_DIALOG_WARNING, dl->dd->entry);
 497                 g_free(text);
 498                 }
 499         else if (dl->dd->path)
 500                 {
 501                 /* refresh list */
 502                 gchar *path = g_strdup(dl->dd->path);
 503                 dest_populate(dl->dd, path);
 504                 g_free(path);
 505                 }
 506
 507         dest_view_delete_dlg_cancel(gd, data);
 508 }
 509
 510 static void dest_view_delete(Dest_Data *dd, GtkTreeView *view)
 511 {
 512         gchar *path;
 513         gchar *text;
 514         DestDel_Data *dl;
 515         GtkTreeModel *model;
 516         GtkTreeIter iter;
 517
 518         if (view != GTK_TREE_VIEW(dd->f_view)) return;
 519         if (!dd->right_click_path) return;
 520
 521         model = gtk_tree_view_get_model(view);
 522         gtk_tree_model_get_iter(model, &iter, dd->right_click_path);
 523         gtk_tree_model_get(model, &iter, 1, &path, -1);
 524
 525         if (!path) return;
 526
 527         dl = g_new(DestDel_Data, 1);
 528         dl->dd = dd;
 529         dl->path = path;
 530
 531         if (dd->gd)
 532                 {
 533                 GenericDialog *gd = dd->gd;
 534                 dest_view_delete_dlg_cancel(dd->gd, dd->gd->data);
 535                 generic_dialog_close(gd);
 536                 }
 537
 538         dd->gd = generic_dialog_new(_("Delete file"), "dlg_confirm",
 539                                     dd->entry, TRUE,
 540                                     dest_view_delete_dlg_cancel, dl);
 541
 542         generic_dialog_add_button(dd->gd, GQ_ICON_DELETE, _("Delete"), dest_view_delete_dlg_ok_cb, TRUE);
 543
 544         text = g_strdup_printf(_("About to delete the file:\n %s"), path);
 545         generic_dialog_add_message(dd->gd, GQ_ICON_DIALOG_QUESTION,
 546                                    _("Delete file"), text, TRUE);
 547         g_free(text);
 548
 549         gtk_widget_show(dd->gd->dialog);
 550 }
 551
 552 static void dest_view_bookmark(Dest_Data *dd, GtkTreeView *view)
 553 {
 554         GtkTreeModel *model;
 555         GtkTreeIter iter;
 556         gchar *path;
 557
 558         if (!dd->right_click_path) return;
 559
 560         model = gtk_tree_view_get_model(view);
 561         gtk_tree_model_get_iter(model, &iter, dd->right_click_path);
 562         gtk_tree_model_get(model, &iter, 1, &path, -1);
 563
 564         bookmark_list_add(dd->bookmark_list, filename_from_path(path), path);
 565         g_free(path);
 566 }
 567
 568 static void dest_popup_dir_rename_cb(GtkWidget *, gpointer data)
 569 {
 570         auto dd = static_cast<Dest_Data *>(data);
 571         dest_view_rename(dd, GTK_TREE_VIEW(dd->d_view));
 572 }
 573
 574 static void dest_popup_dir_bookmark_cb(GtkWidget *, gpointer data)
 575 {
 576         auto dd = static_cast<Dest_Data *>(data);
 577         dest_view_bookmark(dd, GTK_TREE_VIEW(dd->d_view));
 578 }
 579
 580 static void dest_popup_file_rename_cb(GtkWidget *, gpointer data)
 581 {
 582         auto dd = static_cast<Dest_Data *>(data);
 583         dest_view_rename(dd, GTK_TREE_VIEW(dd->f_view));
 584 }
 585
 586 static void dest_popup_file_delete_cb(GtkWidget *, gpointer data)
 587 {
 588         auto dd = static_cast<Dest_Data *>(data);
 589         dest_view_delete(dd, GTK_TREE_VIEW(dd->f_view));
 590 }
 591
 592 static void dest_popup_file_bookmark_cb(GtkWidget *, gpointer data)
 593 {
 594         auto dd = static_cast<Dest_Data *>(data);
 595         dest_view_bookmark(dd, GTK_TREE_VIEW(dd->f_view));
 596 }
 597
 598 static gboolean dest_popup_menu(Dest_Data *dd, GtkTreeView *view, guint, guint32, gboolean local)
 599 {
 600         GtkWidget *menu;
 601
 602         if (!dd->right_click_path) return FALSE;
 603
 604         if (view == GTK_TREE_VIEW(dd->d_view))
 605                 {
 606                 GtkTreeModel *model;
 607                 GtkTreeIter iter;
 608                 gchar *text;
 609                 gboolean normal_dir;
 610
 611                 model = gtk_tree_view_get_model(view);
 612                 gtk_tree_model_get_iter(model, &iter, dd->right_click_path);
 613                 gtk_tree_model_get(model, &iter, 0, &text, -1);
 614
 615                 if (!text) return FALSE;
 616
 617                 normal_dir = (strcmp(text, ".") == 0 || strcmp(text, "..") == 0);
 618
 619                 menu = popup_menu_short_lived();
 620                 menu_item_add_sensitive(menu, _("_Rename"), !normal_dir,
 621                               G_CALLBACK(dest_popup_dir_rename_cb), dd);
 622                 menu_item_add_icon(menu, _("Add _Bookmark"), GQ_ICON_GO_JUMP,
 623                               G_CALLBACK(dest_popup_dir_bookmark_cb), dd);
 624                 }
 625         else
 626                 {
 627                 menu = popup_menu_short_lived();
 628                 menu_item_add(menu, _("_Rename"),
 629                                 G_CALLBACK(dest_popup_file_rename_cb), dd);
 630                 menu_item_add_icon(menu, _("_Delete"), GQ_ICON_DELETE,
 631                                 G_CALLBACK(dest_popup_file_delete_cb), dd);
 632                 menu_item_add_icon(menu, _("Add _Bookmark"), GQ_ICON_GO_JUMP,
 633                                 G_CALLBACK(dest_popup_file_bookmark_cb), dd);
 634                 }
 635
 636         if (local)
 637                 {
 638                 g_object_set_data(G_OBJECT(menu), "active_view", view);
 639                 gtk_menu_popup_at_widget(GTK_MENU(menu), GTK_WIDGET(view), GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER, nullptr);
 640                 }
 641         else
 642                 {
 643                 gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
 644
 645                 }
 646
 647         return TRUE;
 648 }
 649
 650 static gboolean dest_press_cb(GtkWidget *view, GdkEventButton *event, gpointer data)
 651 {
 652         auto dd = static_cast<Dest_Data *>(data);
 653         GtkTreePath *tpath;
 654         GtkTreeViewColumn *column;
 655         gint cell_x;
 656         gint cell_y;
 657         GtkTreeModel *model;
 658         GtkTreeIter iter;
 659         GtkTreeSelection *selection;
 660
 661         if (event->button != MOUSE_BUTTON_RIGHT ||
 662             !gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(view), event->x, event->y,
 663                                            &tpath, &column, &cell_x, &cell_y))
 664                 {
 665                 return FALSE;
 666                 }
 667
 668         model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
 669         gtk_tree_model_get_iter(model, &iter, tpath);
 670
 671         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
 672         gtk_tree_selection_select_iter(selection, &iter);
 673
 674         if (dd->right_click_path) gtk_tree_path_free(dd->right_click_path);
 675         dd->right_click_path = tpath;
 676
 677         return dest_popup_menu(dd, GTK_TREE_VIEW(view), 0, event->time, FALSE);
 678 }
 679
 680 static gboolean dest_keypress_cb(GtkWidget *view, GdkEventKey *event, gpointer data)
 681 {
 682         auto dd = static_cast<Dest_Data *>(data);
 683
 684         switch (event->keyval)
 685                 {
 686                 case GDK_KEY_F10:
 687                         if (!(event->state & GDK_CONTROL_MASK)) return FALSE;
 688                         /* fall through */
 689                 case GDK_KEY_Menu:
 690                         dest_view_store_selection(dd, GTK_TREE_VIEW(view));
 691                         dest_popup_menu(dd, GTK_TREE_VIEW(view), 0, event->time, TRUE);
 692                         return TRUE;
 693                         break;
 694                 case 'R': case 'r':
 695                         if (event->state & GDK_CONTROL_MASK)
 696                                 {
 697                                 dest_view_store_selection(dd, GTK_TREE_VIEW(view));
 698                                 dest_view_rename(dd, GTK_TREE_VIEW(view));
 699                                 return TRUE;
 700                                 }
 701                         break;
 702                 case GDK_KEY_Delete:
 703                         dest_view_store_selection(dd, GTK_TREE_VIEW(view));
 704                         dest_view_delete(dd, GTK_TREE_VIEW(view));
 705                         return TRUE;
 706                         break;
 707                 case 'B' : case 'b':
 708                         if (event->state & GDK_CONTROL_MASK)
 709                                 {
 710                                 dest_view_store_selection(dd, GTK_TREE_VIEW(view));
 711                                 dest_view_bookmark(dd, GTK_TREE_VIEW(view));
 712                                 return TRUE;
 713                                 }
 714                         break;
 715                 }
 716
 717         return FALSE;
 718 }
 719
 720 static void file_util_create_dir_cb(gboolean success, const gchar *new_path, gpointer data)
 721 {
 722         auto dd = static_cast<Dest_Data *>(data);
 723         const gchar *text;
 724         GtkListStore *store;
 725         GtkTreeIter iter;
 726
 727         if (!success)
 728                 {
 729                 return;
 730                 }
 731
 732         if (new_path == nullptr)
 733                 {
 734                 return;
 735                 }
 736
 737         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(dd->d_view)));
 738
 739         text = filename_from_path(new_path);
 740
 741         gtk_list_store_append(store, &iter);
 742         gtk_list_store_set(store, &iter, 0, text, 1, new_path, -1);
 743
 744         if (dd->right_click_path)
 745                 {
 746                 gtk_tree_path_free(dd->right_click_path);
 747                 }
 748         dd->right_click_path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter);
 749
 750         gq_gtk_entry_set_text(GTK_ENTRY(dd->entry), new_path);
 751
 752         gtk_widget_grab_focus(GTK_WIDGET(dd->entry));
 753 }
 754
 755 static void dest_new_dir_cb(GtkWidget *widget, gpointer data)
 756 {
 757         auto dd = static_cast<Dest_Data *>(data);
 758
 759 /**
 760  * @FIXME on exit from the "new folder" modal dialog, focus returns to the main Geeqie
 761  * window rather than the file dialog window. gtk_window_present() does not seem to
 762  * function unless the window was previously minimized.
 763  */
 764         file_util_create_dir(gq_gtk_entry_get_text(GTK_ENTRY(dd->entry)), widget, file_util_create_dir_cb, data);
 765 }
 766
 767 /*
 768  *-----------------------------------------------------------------------------
 769  * destination widget file selection, traversal, view options
 770  *-----------------------------------------------------------------------------
 771  */
 772
 773 static void dest_select_cb(GtkTreeSelection *selection, gpointer data)
 774 {
 775         auto dd = static_cast<Dest_Data *>(data);
 776         GtkTreeView *view;
 777         GtkTreeModel *store;
 778         GtkTreeIter iter;
 779         gchar *path;
 780
 781         if (!gtk_tree_selection_get_selected(selection, nullptr, &iter)) return;
 782
 783         view = gtk_tree_selection_get_tree_view(selection);
 784         store = gtk_tree_view_get_model(view);
 785         gtk_tree_model_get(store, &iter, 1, &path, -1);
 786
 787         if (view == GTK_TREE_VIEW(dd->d_view))
 788                 {
 789                 dest_change_dir(dd, path, (dd->f_view != nullptr));
 790                 }
 791         else
 792                 {
 793                 gq_gtk_entry_set_text(GTK_ENTRY(dd->entry), path);
 794                 }
 795
 796         g_free(path);
 797 }
 798
 799 static void dest_activate_cb(GtkWidget *view, GtkTreePath *tpath, GtkTreeViewColumn *, gpointer data)
 800 {
 801         auto dd = static_cast<Dest_Data *>(data);
 802         GtkTreeModel *store;
 803         GtkTreeIter iter;
 804         gchar *path;
 805
 806         store = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
 807         gtk_tree_model_get_iter(store, &iter, tpath);
 808         gtk_tree_model_get(store, &iter, 1, &path, -1);
 809
 810         if (view == dd->d_view)
 811                 {
 812                 dest_change_dir(dd, path, (dd->f_view != nullptr));
 813                 }
 814         else
 815                 {
 816                 if (dd->select_func)
 817                         {
 818                         dd->select_func(path, dd->select_data);
 819                         }
 820                 }
 821
 822         g_free(path);
 823 }
 824
 825 static void dest_home_cb(GtkWidget *, gpointer data)
 826 {
 827         auto dd = static_cast<Dest_Data *>(data);
 828
 829         dest_change_dir(dd, homedir(), (dd->f_view != nullptr));
 830 }
 831
 832 static void dest_show_hidden_cb(GtkWidget *, gpointer data)
 833 {
 834         auto dd = static_cast<Dest_Data *>(data);
 835         gchar *buf;
 836
 837         dd->show_hidden = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(dd->hidden_button));
 838
 839         buf = g_strdup(dd->path);
 840         dest_populate(dd, buf);
 841         g_free(buf);
 842 }
 843
 844 static void dest_entry_changed_cb(GtkEditable *, gpointer data)
 845 {
 846         auto dd = static_cast<Dest_Data *>(data);
 847         const gchar *path;
 848         gchar *buf;
 849
 850         path = gq_gtk_entry_get_text(GTK_ENTRY(dd->entry));
 851         if (dd->path && strcmp(path, dd->path) == 0) return;
 852
 853         buf = remove_level_from_path(path);
 854
 855         if (buf && (!dd->path || strcmp(buf, dd->path) != 0))
 856                 {
 857                 gchar *tmp = remove_trailing_slash(path);
 858                 if (isdir(tmp))
 859                         {
 860                         dest_populate(dd, tmp);
 861                         }
 862                 else if (isdir(buf))
 863                         {
 864                         dest_populate(dd, buf);
 865                         }
 866                 g_free(tmp);
 867                 }
 868         g_free(buf);
 869 }
 870
 871 static void dest_filter_list_sync(Dest_Data *dd)
 872 {
 873         GtkWidget *entry;
 874         GtkListStore *store;
 875         gchar *old_text;
 876         GList *fwork;
 877         GList *twork;
 878
 879         if (!dd->filter_list || !dd->filter_combo) return;
 880
 881         entry = gtk_bin_get_child(GTK_BIN(dd->filter_combo));
 882         old_text = g_strdup(gq_gtk_entry_get_text(GTK_ENTRY(entry)));
 883
 884         store = GTK_LIST_STORE(gtk_combo_box_get_model(GTK_COMBO_BOX(dd->filter_combo)));
 885         gtk_list_store_clear(store);
 886
 887         fwork = dd->filter_list;
 888         twork = dd->filter_text_list;
 889         while (fwork && twork)
 890                 {
 891                 GtkTreeIter iter;
 892                 gchar *name;
 893                 gchar *filter;
 894
 895                 name = static_cast<gchar *>(twork->data);
 896                 filter = static_cast<gchar *>(fwork->data);
 897
 898                 gtk_list_store_append(store, &iter);
 899                 gtk_list_store_set(store, &iter, FILTER_COLUMN_NAME, name,
 900                                                  FILTER_COLUMN_FILTER, filter, -1);
 901
 902                 if (strcmp(old_text, filter) == 0)
 903                         {
 904                         gtk_combo_box_set_active_iter(GTK_COMBO_BOX(dd->filter_combo), &iter);
 905                         }
 906
 907                 fwork = fwork->next;
 908                 twork = twork->next;
 909                 }
 910
 911         g_free(old_text);
 912 }
 913
 914 static void dest_filter_add(Dest_Data *dd, const gchar *filter, const gchar *description, gboolean set)
 915 {
 916         GList *work;
 917         gchar *buf;
 918         gint c = 0;
 919
 920         if (!filter) return;
 921
 922         work = dd->filter_list;
 923         while (work)
 924                 {
 925                 auto f = static_cast<gchar *>(work->data);
 926
 927                 if (strcmp(f, filter) == 0)
 928                         {
 929                         if (set) gtk_combo_box_set_active(GTK_COMBO_BOX(dd->filter_combo), c);
 930                         return;
 931                         }
 932                 work = work->next;
 933                 c++;
 934                 }
 935
 936         dd->filter_list = uig_list_insert_link(dd->filter_list, g_list_last(dd->filter_list), g_strdup(filter));
 937
 938         if (description)
 939                 {
 940                 buf = g_strdup_printf("%s  ( %s )", description, filter);
 941                 }
 942         else
 943                 {
 944                 buf = g_strdup_printf("( %s )", filter);
 945                 }
 946         dd->filter_text_list = uig_list_insert_link(dd->filter_text_list, g_list_last(dd->filter_text_list), buf);
 947
 948         if (set) gq_gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(dd->filter_combo))), filter);
 949         dest_filter_list_sync(dd);
 950 }
 951
 952 static void dest_filter_clear(Dest_Data *dd)
 953 {
 954         g_list_free_full(dd->filter_list, g_free);
 955         dd->filter_list = nullptr;
 956
 957         g_list_free_full(dd->filter_text_list, g_free);
 958         dd->filter_text_list = nullptr;
 959
 960         dest_filter_add(dd, "*", _("All Files"), TRUE);
 961 }
 962
 963 static void dest_filter_changed_cb(GtkEditable *, gpointer data)
 964 {
 965         auto dd = static_cast<Dest_Data *>(data);
 966         GtkWidget *entry;
 967         const gchar *buf;
 968         gchar *path;
 969
 970         entry = gtk_bin_get_child(GTK_BIN(dd->filter_combo));
 971         buf = gq_gtk_entry_get_text(GTK_ENTRY(entry));
 972
 973         g_free(dd->filter);
 974         dd->filter = nullptr;
 975         if (strlen(buf) > 0) dd->filter = g_strdup(buf);
 976
 977         path = g_strdup(dd->path);
 978         dest_populate(dd, path);
 979         g_free(path);
 980 }
 981
 982 static void dest_bookmark_select_cb(const gchar *path, gpointer data)
 983 {
 984         auto dd = static_cast<Dest_Data *>(data);
 985
 986         if (isdir(path))
 987                 {
 988                 dest_change_dir(dd, path, (dd->f_view != nullptr));
 989                 }
 990         else if (isfile(path) && dd->f_view)
 991                 {
 992                 gq_gtk_entry_set_text(GTK_ENTRY(dd->entry), path);
 993                 }
 994 }
 995
 996 /*
 997  *-----------------------------------------------------------------------------
 998  * destination widget setup routines (public)
 999  *-----------------------------------------------------------------------------
1000  */
1001
1002 GtkWidget *path_selection_new_with_files(GtkWidget *entry, const gchar *path,
1003                                          const gchar *filter, const gchar *filter_desc)
1004 {
1005         Dest_Data *dd;
1006         GtkCellRenderer *renderer;
1007         GtkListStore *store;
1008         GtkTreeSelection *selection;
1009         GtkTreeViewColumn *column;
1010         GtkWidget *hbox1; // home, new folder, hidden, filter
1011         GtkWidget *hbox2; // files paned
1012         GtkWidget *hbox3; // filter
1013         GtkWidget *paned;
1014         GtkWidget *scrolled;
1015         GtkWidget *table; // main box
1016
1017         dd = g_new0(Dest_Data, 1);
1018
1019         table = gtk_box_new(GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
1020
1021         dd->entry = entry;
1022         g_object_set_data(G_OBJECT(dd->entry), "destination_data", dd);
1023
1024         hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
1025         gtk_box_set_spacing(GTK_BOX(hbox1), PREF_PAD_BUTTON_GAP);
1026         pref_button_new(hbox1, nullptr, _("Home"),
1027                         G_CALLBACK(dest_home_cb), dd);
1028         pref_button_new(hbox1, nullptr, _("New folder"),
1029                         G_CALLBACK(dest_new_dir_cb), dd);
1030
1031         dd->hidden_button = gtk_check_button_new_with_label(_("Show hidden"));
1032         g_signal_connect(G_OBJECT(dd->hidden_button), "clicked",
1033                          G_CALLBACK(dest_show_hidden_cb), dd);
1034         gq_gtk_box_pack_end(GTK_BOX(hbox1), dd->hidden_button, FALSE, FALSE, 0);
1035         gtk_widget_show(dd->hidden_button);
1036
1037         gq_gtk_box_pack_start(GTK_BOX(table), hbox1, FALSE, FALSE, 0);
1038         gtk_widget_show_all(hbox1);
1039
1040         hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_GAP);
1041         if (filter)
1042                 {
1043                 paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
1044                 DEBUG_NAME(paned);
1045                 gq_gtk_box_pack_end(GTK_BOX(table), paned, TRUE , TRUE, 0);
1046                 gtk_widget_show(paned);
1047                 gtk_paned_add1(GTK_PANED(paned), hbox2);
1048                 }
1049         else
1050                 {
1051                 paned = nullptr;
1052                 gq_gtk_box_pack_end(GTK_BOX(table), hbox2, TRUE, TRUE, 0);
1053                 }
1054         gtk_widget_show(hbox2);
1055
1056         /* bookmarks */
1057         scrolled = bookmark_list_new(nullptr, dest_bookmark_select_cb, dd);
1058         gq_gtk_box_pack_start(GTK_BOX(hbox2), scrolled, FALSE, FALSE, 0);
1059         gtk_widget_show(scrolled);
1060
1061         dd->bookmark_list = scrolled;
1062
1063         scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
1064         gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
1065         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
1066                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
1067         gq_gtk_box_pack_start(GTK_BOX(hbox2), scrolled, TRUE, TRUE, 0);
1068         gtk_widget_show(scrolled);
1069
1070         store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
1071         dd->d_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
1072         g_object_unref(store);
1073
1074         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(dd->d_view), PATH_SEL_USE_HEADINGS);
1075
1076         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dd->d_view));
1077         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
1078
1079         column = gtk_tree_view_column_new();
1080         gtk_tree_view_column_set_title(column, _("Folders"));
1081         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
1082
1083         renderer = gtk_cell_renderer_text_new();
1084         gtk_tree_view_column_pack_start(column, renderer, TRUE);
1085         gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
1086
1087         gtk_tree_view_append_column(GTK_TREE_VIEW(dd->d_view), column);
1088
1089 #if 0
1090         /* only for debugging */
1091         column = gtk_tree_view_column_new();
1092         gtk_tree_view_column_set_title(column, _("Path"));
1093         renderer = gtk_cell_renderer_text_new();
1094         gtk_tree_view_column_pack_start(column, renderer, TRUE);
1095         gtk_tree_view_column_add_attribute(column, renderer, "text", 1);
1096         gtk_tree_view_append_column(GTK_TREE_VIEW(dd->d_view), column);
1097 #endif
1098
1099         gtk_widget_set_size_request(dd->d_view, DEST_WIDTH, DEST_HEIGHT);
1100         gq_gtk_container_add(GTK_WIDGET(scrolled), dd->d_view);
1101         gtk_widget_show(dd->d_view);
1102
1103         g_signal_connect(G_OBJECT(dd->d_view), "button_press_event",
1104                          G_CALLBACK(dest_press_cb), dd);
1105         g_signal_connect(G_OBJECT(dd->d_view), "key_press_event",
1106                          G_CALLBACK(dest_keypress_cb), dd);
1107         g_signal_connect(G_OBJECT(dd->d_view), "row_activated",
1108                          G_CALLBACK(dest_activate_cb), dd);
1109         g_signal_connect(G_OBJECT(dd->d_view), "destroy",
1110                          G_CALLBACK(dest_free_data), dd);
1111
1112         if (filter)
1113                 {
1114                 GtkListStore *store;
1115
1116                 hbox3 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
1117                 pref_label_new(hbox3, _("Filter:"));
1118
1119                 store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
1120
1121                 dd->filter_combo = gtk_combo_box_new_with_model_and_entry(GTK_TREE_MODEL(store));
1122                 gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(dd->filter_combo),
1123                                                                                                                 FILTER_COLUMN_FILTER);
1124                 gtk_widget_set_tooltip_text(dd->filter_combo, _("File extension.\nAll files: *\nOr, e.g. png;jpg\nOr, e.g. png; jpg"));
1125
1126                 g_object_unref(store);
1127                 gtk_cell_layout_clear(GTK_CELL_LAYOUT(dd->filter_combo));
1128                 renderer = gtk_cell_renderer_text_new();
1129                 gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(dd->filter_combo), renderer, TRUE);
1130                 gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(dd->filter_combo), renderer, "text", FILTER_COLUMN_NAME, NULL);
1131                 gq_gtk_box_pack_start(GTK_BOX(hbox3), dd->filter_combo, TRUE, TRUE, 0);
1132                 gtk_widget_show(dd->filter_combo);
1133
1134                 gq_gtk_box_pack_end(GTK_BOX(hbox1), hbox3, FALSE, FALSE, 0);
1135                 gtk_widget_show(hbox3);
1136
1137                 scrolled = gq_gtk_scrolled_window_new(nullptr, nullptr);
1138                 gq_gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
1139                 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
1140                                                GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
1141                 if (paned)
1142                         {
1143                         gtk_paned_add2(GTK_PANED(paned), scrolled);
1144                         }
1145                 else
1146                         {
1147                         gq_gtk_box_pack_end(GTK_BOX(table), paned, FALSE, FALSE, 0);
1148                         }
1149                 gtk_widget_show(scrolled);
1150
1151                 store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
1152                 dd->f_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
1153                 g_object_unref(store);
1154
1155                 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(dd->f_view), PATH_SEL_USE_HEADINGS);
1156
1157                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dd->f_view));
1158                 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_SINGLE);
1159
1160                 column = gtk_tree_view_column_new();
1161                 gtk_tree_view_column_set_title(column, _("Files"));
1162                 gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
1163
1164                 renderer = gtk_cell_renderer_text_new();
1165                 gtk_tree_view_column_pack_start(column, renderer, TRUE);
1166                 gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
1167
1168                 gtk_tree_view_append_column(GTK_TREE_VIEW(dd->f_view), column);
1169
1170                 gtk_widget_set_size_request(dd->f_view, DEST_WIDTH, DEST_HEIGHT);
1171                 gq_gtk_container_add(GTK_WIDGET(scrolled), dd->f_view);
1172                 gtk_widget_show(dd->f_view);
1173
1174                 g_signal_connect(G_OBJECT(dd->f_view), "button_press_event",
1175                                  G_CALLBACK(dest_press_cb), dd);
1176                 g_signal_connect(G_OBJECT(dd->f_view), "key_press_event",
1177                                  G_CALLBACK(dest_keypress_cb), dd);
1178                 g_signal_connect(G_OBJECT(dd->f_view), "row_activated",
1179                                  G_CALLBACK(dest_activate_cb), dd);
1180                 g_signal_connect(selection, "changed",
1181                                  G_CALLBACK(dest_select_cb), dd);
1182
1183                 dest_filter_clear(dd);
1184                 dest_filter_add(dd, filter, filter_desc, TRUE);
1185
1186                 dd->filter = g_strdup(gq_gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(dd->filter_combo)))));
1187                 }
1188
1189         if (path && path[0] == G_DIR_SEPARATOR && isdir(path))
1190                 {
1191                 dest_populate(dd, path);
1192                 }
1193         else
1194                 {
1195                 gchar *buf = remove_level_from_path(path);
1196                 if (buf && buf[0] == G_DIR_SEPARATOR && isdir(buf))
1197                         {
1198                         dest_populate(dd, buf);
1199                         }
1200                 else
1201                         {
1202                         gint pos = -1;
1203
1204                         dest_populate(dd, const_cast<gchar *>(homedir()));
1205                         if (path) gtk_editable_insert_text(GTK_EDITABLE(dd->entry), G_DIR_SEPARATOR_S, -1, &pos);
1206                         if (path) gtk_editable_insert_text(GTK_EDITABLE(dd->entry), path, -1, &pos);
1207                         }
1208                 g_free(buf);
1209                 }
1210
1211         if (dd->filter_combo)
1212                 {
1213                 g_signal_connect(G_OBJECT(gtk_bin_get_child(GTK_BIN(dd->filter_combo))), "changed",
1214                                  G_CALLBACK(dest_filter_changed_cb), dd);
1215                 }
1216         g_signal_connect(G_OBJECT(dd->entry), "changed",
1217                          G_CALLBACK(dest_entry_changed_cb), dd);
1218
1219         dest_dnd_init(dd);
1220
1221         return table;
1222 }
1223
1224 #pragma GCC diagnostic push
1225 #pragma GCC diagnostic ignored "-Wunused-function"
1226 GtkWidget *path_selection_new_unused(const gchar *path, GtkWidget *entry)
1227 {
1228         return path_selection_new_with_files(entry, path, nullptr, nullptr);
1229 }
1230
1231 void path_selection_sync_to_entry_unused(GtkWidget *entry)
1232 {
1233         auto *dd = static_cast<Dest_Data *>(g_object_get_data(G_OBJECT(entry), "destination_data"));
1234         const gchar *path;
1235
1236         if (!dd) return;
1237
1238         path = gq_gtk_entry_get_text(GTK_ENTRY(entry));
1239
1240         if (isdir(path) && (!dd->path || strcmp(path, dd->path) != 0))
1241                 {
1242                 dest_populate(dd, path);
1243                 }
1244         else
1245                 {
1246                 gchar *buf = remove_level_from_path(path);
1247                 if (isdir(buf) && (!dd->path || strcmp(buf, dd->path) != 0))
1248                         {
1249                         dest_populate(dd, buf);
1250                         }
1251                 g_free(buf);
1252                 }
1253 }
1254 #pragma GCC diagnostic pop
1255
1256 void path_selection_add_select_func(GtkWidget *entry,
1257                                     void (*func)(const gchar *, gpointer), gpointer data)
1258 {
1259         auto dd = static_cast<Dest_Data *>(g_object_get_data(G_OBJECT(entry), "destination_data"));
1260
1261         if (!dd) return;
1262
1263         dd->select_func = func;
1264         dd->select_data = data;
1265 }
1266
1267 void path_selection_add_filter(GtkWidget *entry, const gchar *filter, const gchar *description, gboolean set)
1268 {
1269         auto dd = static_cast<Dest_Data *>(g_object_get_data(G_OBJECT(entry), "destination_data"));
1270
1271         if (!dd) return;
1272         if (!filter) return;
1273
1274         dest_filter_add(dd, filter, description, set);
1275 }
1276
1277 void path_selection_clear_filter(GtkWidget *entry)
1278 {
1279         auto dd = static_cast<Dest_Data *>(g_object_get_data(G_OBJECT(entry), "destination_data"));
1280
1281         if (!dd) return;
1282
1283         dest_filter_clear(dd);
1284 }
1285 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */