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