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