src/ui-pathsel.cc

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