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