src/view_dir.c

   1 /*
   2  * Geeqie
   3  * (C) 2008 Vladimir Nadvornik
   4  *
   5  * Author: Laurent Monin
   6  *
   7  * This software is released under the GNU General Public License (GNU GPL).
   8  * Please read the included file COPYING for more information.
   9  * This software comes with no warranty of any kind, use at your own risk!
  10  */
  11
  12 #include "main.h"
  13 #include "view_dir.h"
  14
  15 #include "dnd.h"
  16 #include "dupe.h"
  17 #include "filelist.h"
  18 #include "layout_image.h"
  19 #include "layout_util.h"
  20 #include "ui_bookmark.h"
  21 #include "ui_fileops.h"
  22 #include "ui_tree_edit.h"
  23 #include "ui_menu.h"
  24 #include "utilops.h"
  25 #include "view_dir_list.h"
  26 #include "view_dir_tree.h"
  27
  28 GtkRadioActionEntry menu_view_dir_radio_entries[] = {
  29   { "FolderList",       NULL,           N_("List"),             "<meta>L",      NULL, DIRVIEW_LIST },
  30   { "FolderTree",       NULL,           N_("Tr_ee"),            "<control>T",   NULL, DIRVIEW_TREE },
  31 };
  32
  33 void vd_destroy_cb(GtkWidget *widget, gpointer data)
  34 {
  35         ViewDir *vd = data;
  36
  37         if (vd->popup)
  38                 {
  39                 g_signal_handlers_disconnect_matched(G_OBJECT(vd->popup), G_SIGNAL_MATCH_DATA,
  40                                                      0, 0, 0, NULL, vd);
  41                 gtk_widget_destroy(vd->popup);
  42                 }
  43
  44         if (vd->widget_destroy_cb) vd->widget_destroy_cb(widget, data);
  45
  46         if (vd->pf) folder_icons_free(vd->pf);
  47         if (vd->drop_list) filelist_free(vd->drop_list);
  48
  49         if (vd->path) g_free(vd->path);
  50         if (vd->info) g_free(vd->info);
  51
  52         g_free(vd);
  53 }
  54
  55 ViewDir *vd_new(DirViewType type, const gchar *path)
  56 {
  57         ViewDir *vd = g_new0(ViewDir, 1);
  58
  59         vd->path = NULL;
  60         vd->click_fd = NULL;
  61
  62         vd->drop_fd = NULL;
  63         vd->drop_list = NULL;
  64         vd->drop_scroll_id = -1;
  65         vd->drop_list = NULL;
  66
  67         vd->popup = NULL;
  68
  69         vd->widget = gtk_scrolled_window_new(NULL, NULL);
  70         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(vd->widget), GTK_SHADOW_IN);
  71         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(vd->widget),
  72                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
  73
  74         vd->pf = folder_icons_new();
  75
  76         switch(type)
  77         {
  78         case DIRVIEW_LIST: vd = vdlist_new(vd, path); break;
  79         case DIRVIEW_TREE: vd = vdtree_new(vd, path); break;
  80         }
  81
  82         g_signal_connect(G_OBJECT(vd->widget), "destroy",
  83                          G_CALLBACK(vd_destroy_cb), vd);
  84
  85         return vd;
  86 }
  87
  88 void vd_set_select_func(ViewDir *vd,
  89                         void (*func)(ViewDir *vd, const gchar *path, gpointer data), gpointer data)
  90 {
  91         vd->select_func = func;
  92         vd->select_data = data;
  93 }
  94
  95 void vd_set_layout(ViewDir *vd, LayoutWindow *layout)
  96 {
  97         vd->layout = layout;
  98 }
  99
 100 gint vd_set_path(ViewDir *vd, const gchar *path)
 101 {
 102         gint ret = FALSE;
 103
 104         switch(vd->type)
 105         {
 106         case DIRVIEW_LIST: ret = vdlist_set_path(vd, path); break;
 107         case DIRVIEW_TREE: ret = vdtree_set_path(vd, path); break;
 108         }
 109
 110         return ret;
 111 }
 112
 113 void vd_refresh(ViewDir *vd)
 114 {
 115         switch(vd->type)
 116         {
 117         case DIRVIEW_LIST: return vdlist_refresh(vd);
 118         case DIRVIEW_TREE: return vdtree_refresh(vd);
 119         }
 120 }
 121
 122 const gchar *vd_row_get_path(ViewDir *vd, gint row)
 123 {
 124         const gchar *ret = NULL;
 125
 126         switch(vd->type)
 127         {
 128         case DIRVIEW_LIST: ret = vdlist_row_get_path(vd, row); break;
 129         case DIRVIEW_TREE: ret = vdtree_row_get_path(vd, row); break;
 130         }
 131
 132         return ret;
 133 }
 134
 135 gint vd_find_row(ViewDir *vd, FileData *fd, GtkTreeIter *iter)
 136 {
 137         gint ret = FALSE;
 138
 139         switch(vd->type)
 140         {
 141         case DIRVIEW_LIST: ret = vdlist_find_row(vd, fd, iter); break;
 142         case DIRVIEW_TREE: ret = vdtree_find_row(vd, fd, iter, NULL); break;
 143         }
 144
 145         return ret;
 146 }
 147
 148 static gint vd_rename_cb(TreeEditData *td, const gchar *old, const gchar *new, gpointer data)
 149 {
 150         ViewDir *vd = data;
 151         GtkTreeModel *store;
 152         GtkTreeIter iter;
 153         FileData *fd;
 154         gchar *old_path;
 155         gchar *new_path;
 156         gchar *base;
 157
 158         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 159         if (!gtk_tree_model_get_iter(store, &iter, td->path)) return FALSE;
 160
 161         switch(vd->type)
 162         {
 163         case DIRVIEW_LIST:
 164                 gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &fd, -1);
 165                 break;
 166         case DIRVIEW_TREE:
 167                 {
 168                 NodeData *nd;
 169                 gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &nd, -1);
 170                 if (!nd) return FALSE;
 171                 fd = nd->fd;
 172                 };
 173                 break;
 174         }
 175
 176         if (!fd) return FALSE;
 177
 178         old_path = g_strdup(fd->path);
 179
 180         base = remove_level_from_path(old_path);
 181         new_path = concat_dir_and_file(base, new);
 182         g_free(base);
 183
 184         if (file_util_rename_dir(fd, new_path, vd->view))
 185                 {
 186
 187                 if (vd->type == DIRVIEW_TREE) vdtree_populate_path(vd, new_path, TRUE, TRUE);
 188                 if (vd->layout && strcmp(vd->path, old_path) == 0)
 189                         {
 190                         layout_set_path(vd->layout, new_path);
 191                         }
 192                 else
 193                         {
 194                         if (vd->type == DIRVIEW_LIST) vd_refresh(vd);
 195                         }
 196                 }
 197
 198         g_free(old_path);
 199         g_free(new_path);
 200
 201         return FALSE;
 202 }
 203
 204 static void vd_rename_by_data(ViewDir *vd, FileData *fd)
 205 {
 206         GtkTreeModel *store;
 207         GtkTreePath *tpath;
 208         GtkTreeIter iter;
 209
 210         if (!fd || vd_find_row(vd, fd, &iter) < 0) return;
 211         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 212         tpath = gtk_tree_model_get_path(store, &iter);
 213
 214         tree_edit_by_path(GTK_TREE_VIEW(vd->view), tpath, 0, fd->name,
 215                           vd_rename_cb, vd);
 216         gtk_tree_path_free(tpath);
 217 }
 218
 219
 220 void vd_color_set(ViewDir *vd, FileData *fd, gint color_set)
 221 {
 222         GtkTreeModel *store;
 223         GtkTreeIter iter;
 224
 225         if (vd_find_row(vd, fd, &iter) < 0) return;
 226         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 227
 228         switch(vd->type)
 229         {
 230         case DIRVIEW_LIST:
 231                 gtk_list_store_set(GTK_LIST_STORE(store), &iter, DIR_COLUMN_COLOR, color_set, -1);
 232                 break;
 233         case DIRVIEW_TREE:
 234                 gtk_tree_store_set(GTK_TREE_STORE(store), &iter, DIR_COLUMN_COLOR, color_set, -1);
 235                 break;
 236         }
 237 }
 238
 239 void vd_popup_destroy_cb(GtkWidget *widget, gpointer data)
 240 {
 241         ViewDir *vd = data;
 242
 243         vd_color_set(vd, vd->click_fd, FALSE);
 244         vd->click_fd = NULL;
 245         vd->popup = NULL;
 246
 247         vd_color_set(vd, vd->drop_fd, FALSE);
 248         filelist_free(vd->drop_list);
 249         vd->drop_list = NULL;
 250         vd->drop_fd = NULL;
 251 }
 252
 253 /*
 254  *-----------------------------------------------------------------------------
 255  * drop menu (from dnd)
 256  *-----------------------------------------------------------------------------
 257  */
 258
 259 static void vd_drop_menu_copy_cb(GtkWidget *widget, gpointer data)
 260 {
 261         ViewDir *vd = data;
 262         const gchar *path;
 263         GList *list;
 264
 265         if (!vd->drop_fd) return;
 266
 267         path = vd->drop_fd->path;
 268         list = vd->drop_list;
 269         vd->drop_list = NULL;
 270
 271         file_util_copy_simple(list, path);
 272 }
 273
 274 static void vd_drop_menu_move_cb(GtkWidget *widget, gpointer data)
 275 {
 276         ViewDir *vd = data;
 277         const gchar *path;
 278         GList *list;
 279
 280         if (!vd->drop_fd) return;
 281
 282         path = vd->drop_fd->path;
 283         list = vd->drop_list;
 284
 285         vd->drop_list = NULL;
 286
 287         file_util_move_simple(list, path);
 288 }
 289
 290 GtkWidget *vd_drop_menu(ViewDir *vd, gint active)
 291 {
 292         GtkWidget *menu;
 293
 294         menu = popup_menu_short_lived();
 295         g_signal_connect(G_OBJECT(menu), "destroy",
 296                          G_CALLBACK(vd_popup_destroy_cb), vd);
 297
 298         menu_item_add_stock_sensitive(menu, _("_Copy"), GTK_STOCK_COPY, active,
 299                                       G_CALLBACK(vd_drop_menu_copy_cb), vd);
 300         menu_item_add_sensitive(menu, _("_Move"), active, G_CALLBACK(vd_drop_menu_move_cb), vd);
 301
 302         menu_item_add_divider(menu);
 303         menu_item_add_stock(menu, _("Cancel"), GTK_STOCK_CANCEL, NULL, vd);
 304
 305         return menu;
 306 }
 307
 308 /*
 309  *-----------------------------------------------------------------------------
 310  * pop-up menu
 311  *-----------------------------------------------------------------------------
 312  */
 313
 314 static void vd_pop_menu_up_cb(GtkWidget *widget, gpointer data)
 315 {
 316         ViewDir *vd = data;
 317         gchar *path;
 318
 319         if (!vd->path || strcmp(vd->path, "/") == 0) return;
 320         path = remove_level_from_path(vd->path);
 321
 322         if (vd->select_func)
 323                 {
 324                 vd->select_func(vd, path, vd->select_data);
 325                 }
 326
 327         g_free(path);
 328 }
 329
 330 static void vd_pop_menu_slide_cb(GtkWidget *widget, gpointer data)
 331 {
 332         ViewDir *vd = data;
 333         gchar *path;
 334
 335         if (!vd->layout) return;
 336         if (!vd->click_fd) return;
 337
 338         path = vd->click_fd->path;
 339
 340         layout_set_path(vd->layout, path);
 341         layout_select_none(vd->layout);
 342         layout_image_slideshow_stop(vd->layout);
 343         layout_image_slideshow_start(vd->layout);
 344 }
 345
 346 static void vd_pop_menu_slide_rec_cb(GtkWidget *widget, gpointer data)
 347 {
 348         ViewDir *vd = data;
 349         gchar *path;
 350         GList *list;
 351
 352         if (!vd->layout) return;
 353         if (!vd->click_fd) return;
 354
 355         path = vd->click_fd->path;
 356
 357         list = filelist_recursive(path);
 358
 359         layout_image_slideshow_stop(vd->layout);
 360         layout_image_slideshow_start_from_list(vd->layout, list);
 361 }
 362
 363 static void vd_pop_menu_dupe(ViewDir *vd, gint recursive)
 364 {
 365         DupeWindow *dw;
 366         GList *list = NULL;
 367
 368         if (!vd->click_fd) return;
 369
 370         if (recursive)
 371                 {
 372                 list = g_list_append(list, file_data_ref(vd->click_fd));
 373                 }
 374         else
 375                 {
 376                 filelist_read(vd->click_fd->path, &list, NULL);
 377                 list = filelist_filter(list, FALSE);
 378                 }
 379
 380         dw = dupe_window_new(DUPE_MATCH_NAME);
 381         dupe_window_add_files(dw, list, recursive);
 382
 383         filelist_free(list);
 384 }
 385
 386 static void vd_pop_menu_dupe_cb(GtkWidget *widget, gpointer data)
 387 {
 388         ViewDir *vd = data;
 389         vd_pop_menu_dupe(vd, FALSE);
 390 }
 391
 392 static void vd_pop_menu_dupe_rec_cb(GtkWidget *widget, gpointer data)
 393 {
 394         ViewDir *vd = data;
 395         vd_pop_menu_dupe(vd, TRUE);
 396 }
 397
 398 static void vd_pop_menu_delete_cb(GtkWidget *widget, gpointer data)
 399 {
 400         ViewDir *vd = data;
 401
 402         if (!vd->click_fd) return;
 403         file_util_delete_dir(vd->click_fd, vd->widget);
 404 }
 405
 406 static void vd_pop_menu_dir_view_as_cb(GtkWidget *widget, gpointer data)
 407 {
 408         ViewDir *vd = data;
 409         DirViewType new_type = DIRVIEW_LIST;
 410
 411         if (!vd->layout) return;
 412
 413         switch(vd->type)
 414         {
 415         case DIRVIEW_LIST: new_type = DIRVIEW_TREE; break;
 416         case DIRVIEW_TREE: new_type = DIRVIEW_LIST; break;
 417         }
 418
 419         layout_views_set(vd->layout, new_type, vd->layout->icon_view);
 420 }
 421
 422 static void vd_pop_menu_refresh_cb(GtkWidget *widget, gpointer data)
 423 {
 424         ViewDir *vd = data;
 425
 426         if (vd->layout) layout_refresh(vd->layout);
 427 }
 428
 429 static void vd_toggle_show_hidden_files_cb(GtkWidget *widget, gpointer data)
 430 {
 431         ViewDir *vd = data;
 432
 433         options->file_filter.show_hidden_files = !options->file_filter.show_hidden_files;
 434         if (vd->layout) layout_refresh(vd->layout);
 435 }
 436
 437 static void vd_pop_menu_new_cb(GtkWidget *widget, gpointer data)
 438 {
 439         ViewDir *vd = data;
 440         const gchar *path = NULL;
 441         gchar *new_path;
 442         gchar *buf;
 443
 444         switch(vd->type)
 445                 {
 446                 case DIRVIEW_LIST:
 447                         {
 448                         if (!vd->path) return;
 449                         path = vd->path;
 450                         };
 451                         break;
 452                 case DIRVIEW_TREE:
 453                         {
 454                         if (!vd->click_fd) return;
 455                         path = vd->click_fd->path;
 456                         };
 457                         break;
 458                 }
 459
 460         buf = concat_dir_and_file(path, _("new_folder"));
 461         new_path = unique_filename(buf, NULL, NULL, FALSE);
 462         g_free(buf);
 463         if (!new_path) return;
 464
 465         if (!mkdir_utf8(new_path, 0755))
 466                 {
 467                 gchar *text;
 468
 469                 text = g_strdup_printf(_("Unable to create folder:\n%s"), new_path);
 470                 file_util_warning_dialog(_("Error creating folder"), text, GTK_STOCK_DIALOG_ERROR, vd->view);
 471                 g_free(text);
 472                 }
 473         else
 474                 {
 475                 FileData *fd = NULL;
 476
 477                 switch(vd->type)
 478                         {
 479                         case DIRVIEW_LIST:
 480                                 {
 481                                 vd_refresh(vd);
 482                                 fd = vdlist_row_by_path(vd, new_path, NULL);
 483                                 };
 484                                 break;
 485                         case DIRVIEW_TREE:
 486                                 fd = vdtree_populate_path(vd, new_path, TRUE, TRUE);
 487                                 break;
 488                         }
 489                 vd_rename_by_data(vd, fd);
 490                 }
 491
 492         g_free(new_path);
 493 }
 494
 495 static void vd_pop_menu_rename_cb(GtkWidget *widget, gpointer data)
 496 {
 497         ViewDir *vd = data;
 498
 499         vd_rename_by_data(vd, vd->click_fd);
 500 }
 501
 502 GtkWidget *vd_pop_menu(ViewDir *vd, FileData *fd)
 503 {
 504         GtkWidget *menu;
 505         gint active;
 506         gint rename_delete_active = FALSE;
 507         gint new_folder_active = FALSE;
 508
 509         active = (fd != NULL);
 510         switch(vd->type)
 511                 {
 512                 case DIRVIEW_LIST:
 513                         {
 514                         /* check using . (always row 0) */
 515                         new_folder_active = (vd->path && access_file(vd->path , W_OK | X_OK));
 516
 517                         /* ignore .. and . */
 518                         rename_delete_active = (new_folder_active && fd &&
 519                                 strcmp(fd->name, ".") != 0 &&
 520                                 strcmp(fd->name, "..") != 0 &&
 521                                 access_file(fd->path, W_OK | X_OK));
 522                         };
 523                         break;
 524                 case DIRVIEW_TREE:
 525                         {
 526                         if (fd)
 527                                 {
 528                                 gchar *parent;
 529                                 new_folder_active = (fd && access_file(fd->path, W_OK | X_OK));
 530                                 parent = remove_level_from_path(fd->path);
 531                                 rename_delete_active = access_file(parent, W_OK | X_OK);
 532                                 g_free(parent);
 533                                 };
 534                         }
 535                         break;
 536                 }
 537
 538         menu = popup_menu_short_lived();
 539         g_signal_connect(G_OBJECT(menu), "destroy",
 540                          G_CALLBACK(vd_popup_destroy_cb), vd);
 541
 542         menu_item_add_stock_sensitive(menu, _("_Up to parent"), GTK_STOCK_GO_UP,
 543                                       (vd->path && strcmp(vd->path, "/") != 0),
 544                                       G_CALLBACK(vd_pop_menu_up_cb), vd);
 545
 546         menu_item_add_divider(menu);
 547         menu_item_add_sensitive(menu, _("_Slideshow"), active,
 548                                 G_CALLBACK(vd_pop_menu_slide_cb), vd);
 549         menu_item_add_sensitive(menu, _("Slideshow recursive"), active,
 550                                 G_CALLBACK(vd_pop_menu_slide_rec_cb), vd);
 551
 552         menu_item_add_divider(menu);
 553         menu_item_add_stock_sensitive(menu, _("Find _duplicates..."), GTK_STOCK_FIND, active,
 554                                       G_CALLBACK(vd_pop_menu_dupe_cb), vd);
 555         menu_item_add_stock_sensitive(menu, _("Find duplicates recursive..."), GTK_STOCK_FIND, active,
 556                                       G_CALLBACK(vd_pop_menu_dupe_rec_cb), vd);
 557
 558         menu_item_add_divider(menu);
 559
 560         menu_item_add_sensitive(menu, _("_New folder..."), new_folder_active,
 561                                 G_CALLBACK(vd_pop_menu_new_cb), vd);
 562
 563         menu_item_add_sensitive(menu, _("_Rename..."), rename_delete_active,
 564                                 G_CALLBACK(vd_pop_menu_rename_cb), vd);
 565         menu_item_add_stock_sensitive(menu, _("_Delete..."), GTK_STOCK_DELETE, rename_delete_active,
 566                                       G_CALLBACK(vd_pop_menu_delete_cb), vd);
 567
 568         menu_item_add_divider(menu);
 569         /* FIXME */
 570         menu_item_add_check(menu, _("View as _tree"), vd->type,
 571                             G_CALLBACK(vd_pop_menu_dir_view_as_cb), vd);
 572         menu_item_add_check(menu, _("Show _hidden files"), options->file_filter.show_hidden_files,
 573                             G_CALLBACK(vd_toggle_show_hidden_files_cb), vd);
 574
 575         menu_item_add_stock(menu, _("Re_fresh"), GTK_STOCK_REFRESH,
 576                             G_CALLBACK(vd_pop_menu_refresh_cb), vd);
 577
 578         return menu;
 579 }
 580
 581 /*
 582  *-----------------------------------------------------------------------------
 583  * dnd
 584  *-----------------------------------------------------------------------------
 585  */
 586
 587 static GtkTargetEntry vd_dnd_drop_types[] = {
 588         { "text/uri-list", 0, TARGET_URI_LIST }
 589 };
 590 static gint vd_dnd_drop_types_count = 1;
 591
 592 static void vd_dest_set(ViewDir *vd, gint enable)
 593 {
 594         if (enable)
 595                 {
 596                 gtk_drag_dest_set(vd->view,
 597                                   GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
 598                                   vd_dnd_drop_types, vd_dnd_drop_types_count,
 599                                   GDK_ACTION_MOVE | GDK_ACTION_COPY);
 600                 }
 601         else
 602                 {
 603                 gtk_drag_dest_unset(vd->view);
 604                 }
 605 }
 606
 607 static void vd_dnd_get(GtkWidget *widget, GdkDragContext *context,
 608                            GtkSelectionData *selection_data, guint info,
 609                            guint time, gpointer data)
 610 {
 611         ViewDir *vd = data;
 612         GList *list;
 613         gchar *uritext = NULL;
 614         gint length = 0;
 615
 616         if (!vd->click_fd) return;
 617
 618         switch (info)
 619                 {
 620                 case TARGET_URI_LIST:
 621                 case TARGET_TEXT_PLAIN:
 622                         list = g_list_prepend(NULL, vd->click_fd);
 623                         uritext = uri_text_from_filelist(list, &length, (info == TARGET_TEXT_PLAIN));
 624                         g_list_free(list);
 625                         break;
 626                 }
 627         if (uritext)
 628                 {
 629                 gtk_selection_data_set (selection_data, selection_data->target,
 630                                 8, (guchar *)uritext, length);
 631                 g_free(uritext);
 632                 }
 633 }
 634
 635 static void vd_dnd_begin(GtkWidget *widget, GdkDragContext *context, gpointer data)
 636 {
 637         ViewDir *vd = data;
 638
 639         vd_color_set(vd, vd->click_fd, TRUE);
 640         vd_dest_set(vd, FALSE);
 641 }
 642
 643 static void vd_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
 644 {
 645         ViewDir *vd = data;
 646
 647         vd_color_set(vd, vd->click_fd, FALSE);
 648
 649         if (vd->type == DIRVIEW_LIST && context->action == GDK_ACTION_MOVE)
 650                 {
 651                 vd_refresh(vd);
 652                 }
 653         vd_dest_set(vd, TRUE);
 654 }
 655
 656 static void vd_dnd_drop_receive(GtkWidget *widget,
 657                                     GdkDragContext *context, gint x, gint y,
 658                                     GtkSelectionData *selection_data, guint info,
 659                                     guint time, gpointer data)
 660 {
 661         ViewDir *vd = data;
 662         GtkTreePath *tpath;
 663         GtkTreeIter iter;
 664         FileData *fd = NULL;
 665
 666         vd->click_fd = NULL;
 667
 668         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), x, y,
 669                                           &tpath, NULL, NULL, NULL))
 670                 {
 671                 GtkTreeModel *store;
 672
 673                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
 674                 gtk_tree_model_get_iter(store, &iter, tpath);
 675                 switch (vd->type)
 676                         {
 677                         case DIRVIEW_LIST:
 678                                 gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &fd, -1);
 679                                 break;
 680                         case DIRVIEW_TREE:
 681                                 {
 682                                 NodeData *nd;
 683                                 gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &nd, -1);
 684                                 fd = (nd) ? nd->fd : NULL;
 685                                 };
 686                                 break;
 687                         }
 688                 gtk_tree_path_free(tpath);
 689                 }
 690
 691         if (!fd) return;
 692
 693         if (info == TARGET_URI_LIST)
 694                 {
 695                 GList *list;
 696                 gint active;
 697
 698                 list = uri_filelist_from_text((gchar *)selection_data->data, TRUE);
 699                 if (!list) return;
 700
 701                 active = access_file(fd->path, W_OK | X_OK);
 702
 703                 vd_color_set(vd, fd, TRUE);
 704                 vd->popup = vd_drop_menu(vd, active);
 705                 gtk_menu_popup(GTK_MENU(vd->popup), NULL, NULL, NULL, NULL, 0, time);
 706
 707                 vd->drop_fd = fd;
 708                 vd->drop_list = list;
 709                 }
 710 }
 711
 712 static void vd_drop_update(ViewDir *vd, gint x, gint y)
 713 {
 714         GtkTreePath *tpath;
 715         GtkTreeIter iter;
 716         FileData *fd = NULL;
 717
 718         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vd->view), x, y,
 719                                           &tpath, NULL, NULL, NULL))
 720                 {
 721                 GtkTreeModel *store;
 722
 723                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 724                 gtk_tree_model_get_iter(store, &iter, tpath);
 725                 switch (vd->type)
 726                         {
 727                         case DIRVIEW_LIST:
 728                                 gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &fd, -1);
 729                                 break;
 730                         case DIRVIEW_TREE:
 731                                 {
 732                                 NodeData *nd;
 733                                 gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &nd, -1);
 734                                 fd = (nd) ? nd->fd : NULL;
 735                                 };
 736                                 break;
 737                         }
 738                 gtk_tree_path_free(tpath);
 739                 }
 740
 741         if (fd != vd->drop_fd)
 742                 {
 743                 vd_color_set(vd, vd->drop_fd, FALSE);
 744                 vd_color_set(vd, fd, TRUE);
 745                 if (vd->type == DIRVIEW_TREE && fd) vdtree_dnd_drop_expand(vd);
 746                 }
 747
 748         vd->drop_fd = fd;
 749 }
 750
 751 void vd_dnd_drop_scroll_cancel(ViewDir *vd)
 752 {
 753         if (vd->drop_scroll_id != -1) g_source_remove(vd->drop_scroll_id);
 754         vd->drop_scroll_id = -1;
 755 }
 756
 757 static gint vd_auto_scroll_idle_cb(gpointer data)
 758 {
 759         ViewDir *vd = data;
 760
 761         if (vd->drop_fd)
 762                 {
 763                 GdkWindow *window;
 764                 gint x, y;
 765                 gint w, h;
 766
 767                 window = vd->view->window;
 768                 gdk_window_get_pointer(window, &x, &y, NULL);
 769                 gdk_drawable_get_size(window, &w, &h);
 770                 if (x >= 0 && x < w && y >= 0 && y < h)
 771                         {
 772                         vd_drop_update(vd, x, y);
 773                         }
 774                 }
 775
 776         vd->drop_scroll_id = -1;
 777         return FALSE;
 778 }
 779
 780 static gint vd_auto_scroll_notify_cb(GtkWidget *widget, gint x, gint y, gpointer data)
 781 {
 782         ViewDir *vd = data;
 783
 784         if (!vd->drop_fd || vd->drop_list) return FALSE;
 785
 786         if (vd->drop_scroll_id == -1) vd->drop_scroll_id = g_idle_add(vd_auto_scroll_idle_cb, vd);
 787
 788         return TRUE;
 789 }
 790
 791 static gint vd_dnd_drop_motion(GtkWidget *widget, GdkDragContext *context,
 792                                    gint x, gint y, guint time, gpointer data)
 793 {
 794         ViewDir *vd = data;
 795
 796         vd->click_fd = NULL;
 797
 798         if (gtk_drag_get_source_widget(context) == vd->view)
 799                 {
 800                 /* from same window */
 801                 gdk_drag_status(context, 0, time);
 802                 return TRUE;
 803                 }
 804         else
 805                 {
 806                 gdk_drag_status(context, context->suggested_action, time);
 807                 }
 808
 809         vd_drop_update(vd, x, y);
 810
 811         if (vd->drop_fd)
 812                 {
 813                 GtkAdjustment *adj = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(vd->view));
 814                 widget_auto_scroll_start(vd->view, adj, -1, -1, vd_auto_scroll_notify_cb, vd);
 815                 }
 816
 817         return FALSE;
 818 }
 819
 820 static void vd_dnd_drop_leave(GtkWidget *widget, GdkDragContext *context, guint time, gpointer data)
 821 {
 822         ViewDir *vd = data;
 823
 824         if (vd->drop_fd != vd->click_fd) vd_color_set(vd, vd->drop_fd, FALSE);
 825
 826         vd->drop_fd = NULL;
 827
 828         if (vd->type == DIRVIEW_TREE) vdtree_dnd_drop_expand_cancel(vd);
 829 }
 830
 831 void vd_dnd_init(ViewDir *vd)
 832 {
 833         gtk_drag_source_set(vd->view, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
 834                             dnd_file_drag_types, dnd_file_drag_types_count,
 835                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_ASK);
 836         g_signal_connect(G_OBJECT(vd->view), "drag_data_get",
 837                          G_CALLBACK(vd_dnd_get), vd);
 838         g_signal_connect(G_OBJECT(vd->view), "drag_begin",
 839                          G_CALLBACK(vd_dnd_begin), vd);
 840         g_signal_connect(G_OBJECT(vd->view), "drag_end",
 841                          G_CALLBACK(vd_dnd_end), vd);
 842
 843         vd_dest_set(vd, TRUE);
 844         g_signal_connect(G_OBJECT(vd->view), "drag_data_received",
 845                          G_CALLBACK(vd_dnd_drop_receive), vd);
 846         g_signal_connect(G_OBJECT(vd->view), "drag_motion",
 847                          G_CALLBACK(vd_dnd_drop_motion), vd);
 848         g_signal_connect(G_OBJECT(vd->view), "drag_leave",
 849                          G_CALLBACK(vd_dnd_drop_leave), vd);
 850 }
 851
 852 /*
 853  *----------------------------------------------------------------------------
 854  * callbacks
 855  *----------------------------------------------------------------------------
 856  */
 857
 858 void vd_menu_position_cb(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer data)
 859 {
 860         ViewDir *vd = data;
 861         GtkTreeModel *store;
 862         GtkTreeIter iter;
 863         GtkTreePath *tpath;
 864         gint cw, ch;
 865
 866         if (vd_find_row(vd, vd->click_fd, &iter) < 0) return;
 867         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 868         tpath = gtk_tree_model_get_path(store, &iter);
 869         tree_view_get_cell_clamped(GTK_TREE_VIEW(vd->view), tpath, 0, TRUE, x, y, &cw, &ch);
 870         gtk_tree_path_free(tpath);
 871         *y += ch;
 872         popup_menu_position_clamp(menu, x, y, 0);
 873 }
 874