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