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