src/ui_pathsel.c

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