src/view_dir.c

   1 /*
   2  * Geeqie
   3  * Copyright (C) 2008 - 2009 The Geeqie Team
   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 "editors.h"
  18 #include "filedata.h"
  19 #include "layout_image.h"
  20 #include "layout_util.h"
  21 #include "pixbuf_util.h"
  22 #include "ui_fileops.h"
  23 #include "ui_tree_edit.h"
  24 #include "ui_menu.h"
  25 #include "utilops.h"
  26 #include "uri_utils.h"
  27 #include "view_dir_list.h"
  28 #include "view_dir_tree.h"
  29
  30 /* Folders icons to be used in tree or list directory view */
  31 static PixmapFolders *folder_icons_new(GtkWidget *widget)
  32 {
  33         PixmapFolders *pf = g_new0(PixmapFolders, 1);
  34
  35 #if 1
  36         GtkIconSize size = GTK_ICON_SIZE_MENU;
  37
  38         /* Attempt to use stock gtk icons */
  39         pf->close  = gtk_widget_render_icon(widget, GTK_STOCK_DIRECTORY, size, NULL);
  40         pf->open   = gtk_widget_render_icon(widget, GTK_STOCK_OPEN, size, NULL);
  41         pf->deny   = gtk_widget_render_icon(widget, GTK_STOCK_STOP, size, NULL);
  42         pf->parent = gtk_widget_render_icon(widget, GTK_STOCK_GO_UP, size, NULL);
  43 #else
  44         /* GQView legacy icons */
  45         pf->close  = pixbuf_inline(PIXBUF_INLINE_FOLDER_CLOSED);
  46         pf->open   = pixbuf_inline(PIXBUF_INLINE_FOLDER_OPEN);
  47         pf->deny   = pixbuf_inline(PIXBUF_INLINE_FOLDER_LOCKED);
  48         pf->parent = pixbuf_inline(PIXBUF_INLINE_FOLDER_UP);
  49 #endif
  50         return pf;
  51 }
  52
  53 static void folder_icons_free(PixmapFolders *pf)
  54 {
  55         if (!pf) return;
  56
  57         g_object_unref(pf->close);
  58         g_object_unref(pf->open);
  59         g_object_unref(pf->deny);
  60         g_object_unref(pf->parent);
  61
  62         g_free(pf);
  63 }
  64
  65
  66
  67 static void vd_notify_cb(FileData *fd, NotifyType type, gpointer data);
  68
  69 GtkRadioActionEntry menu_view_dir_radio_entries[] = {
  70   { "FolderList",       NULL,           N_("_List"),            "<meta>L",      NULL, DIRVIEW_LIST },
  71   { "FolderTree",       NULL,           N_("_Tree"),            "<control>T",   NULL, DIRVIEW_TREE },
  72 };
  73
  74 static void vd_destroy_cb(GtkWidget *widget, gpointer data)
  75 {
  76         ViewDir *vd = data;
  77
  78         file_data_unregister_notify_func(vd_notify_cb, vd);
  79
  80         if (vd->popup)
  81                 {
  82                 g_signal_handlers_disconnect_matched(G_OBJECT(vd->popup), G_SIGNAL_MATCH_DATA,
  83                                                      0, 0, 0, NULL, vd);
  84                 gtk_widget_destroy(vd->popup);
  85                 }
  86
  87         switch (vd->type)
  88         {
  89         case DIRVIEW_LIST: vdlist_destroy_cb(widget, data); break;
  90         case DIRVIEW_TREE: vdtree_destroy_cb(widget, data); break;
  91         }
  92
  93         if (vd->pf) folder_icons_free(vd->pf);
  94         if (vd->drop_list) filelist_free(vd->drop_list);
  95
  96         if (vd->dir_fd) file_data_unref(vd->dir_fd);
  97         if (vd->info) g_free(vd->info);
  98
  99         g_free(vd);
 100 }
 101
 102 ViewDir *vd_new(DirViewType type, FileData *dir_fd)
 103 {
 104         g_assert(VIEW_DIR_TYPES_COUNT <= G_N_ELEMENTS(menu_view_dir_radio_entries));
 105
 106         ViewDir *vd = g_new0(ViewDir, 1);
 107
 108         vd->widget = gtk_scrolled_window_new(NULL, NULL);
 109         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(vd->widget), GTK_SHADOW_IN);
 110         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(vd->widget),
 111                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
 112
 113         vd->pf = folder_icons_new(vd->widget);
 114
 115         switch (type)
 116         {
 117         case DIRVIEW_LIST: vd = vdlist_new(vd, dir_fd); break;
 118         case DIRVIEW_TREE: vd = vdtree_new(vd, dir_fd); break;
 119         }
 120
 121         gtk_container_add(GTK_CONTAINER(vd->widget), vd->view);
 122
 123         vd_dnd_init(vd);
 124
 125         g_signal_connect(G_OBJECT(vd->view), "row_activated",
 126                          G_CALLBACK(vd_activate_cb), vd);
 127         g_signal_connect(G_OBJECT(vd->widget), "destroy",
 128                          G_CALLBACK(vd_destroy_cb), vd);
 129         g_signal_connect(G_OBJECT(vd->view), "key_press_event",
 130                          G_CALLBACK(vd_press_key_cb), vd);
 131         g_signal_connect(G_OBJECT(vd->view), "button_press_event",
 132                          G_CALLBACK(vd_press_cb), vd);
 133         g_signal_connect(G_OBJECT(vd->view), "button_release_event",
 134                          G_CALLBACK(vd_release_cb), vd);
 135
 136         if (dir_fd) vd_set_fd(vd, dir_fd);
 137
 138         file_data_register_notify_func(vd_notify_cb, vd, NOTIFY_PRIORITY_HIGH);
 139
 140         gtk_widget_show(vd->view);
 141
 142         return vd;
 143 }
 144
 145 void vd_set_select_func(ViewDir *vd,
 146                         void (*func)(ViewDir *vd, FileData *fd, gpointer data), gpointer data)
 147 {
 148         vd->select_func = func;
 149         vd->select_data = data;
 150 }
 151
 152 void vd_set_layout(ViewDir *vd, LayoutWindow *layout)
 153 {
 154         vd->layout = layout;
 155 }
 156
 157 gboolean vd_set_fd(ViewDir *vd, FileData *dir_fd)
 158 {
 159         gboolean ret = FALSE;
 160
 161         file_data_unregister_notify_func(vd_notify_cb, vd);
 162
 163         switch (vd->type)
 164         {
 165         case DIRVIEW_LIST: ret = vdlist_set_fd(vd, dir_fd); break;
 166         case DIRVIEW_TREE: ret = vdtree_set_fd(vd, dir_fd); break;
 167         }
 168
 169         file_data_register_notify_func(vd_notify_cb, vd, NOTIFY_PRIORITY_HIGH);
 170
 171         return ret;
 172 }
 173
 174 void vd_refresh(ViewDir *vd)
 175 {
 176         switch (vd->type)
 177         {
 178         case DIRVIEW_LIST: vdlist_refresh(vd); break;
 179         case DIRVIEW_TREE: vdtree_refresh(vd); break;
 180         }
 181 }
 182
 183 const gchar *vd_row_get_path(ViewDir *vd, gint row)
 184 {
 185         const gchar *ret = NULL;
 186
 187         switch (vd->type)
 188         {
 189         case DIRVIEW_LIST: ret = vdlist_row_get_path(vd, row); break;
 190         case DIRVIEW_TREE: ret = vdtree_row_get_path(vd, row); break;
 191         }
 192
 193         return ret;
 194 }
 195
 196 /* the calling stack is this:
 197    vd_select_row -> select_func -> layout_set_fd -> vd_set_fd
 198 */
 199 void vd_select_row(ViewDir *vd, FileData *fd)
 200 {
 201         if (fd && vd->select_func)
 202                 {
 203                 vd->select_func(vd, fd, vd->select_data);
 204                 }
 205 }
 206
 207 gboolean vd_find_row(ViewDir *vd, FileData *fd, GtkTreeIter *iter)
 208 {
 209         gboolean ret = FALSE;
 210
 211         switch (vd->type)
 212         {
 213         case DIRVIEW_LIST: ret = vdlist_find_row(vd, fd, iter); break;
 214         case DIRVIEW_TREE: ret = vdtree_find_row(vd, fd, iter, NULL); break;
 215         }
 216
 217         return ret;
 218 }
 219
 220 FileData *vd_get_fd_from_tree_path(ViewDir *vd, GtkTreeView *tview, GtkTreePath *tpath)
 221 {
 222         GtkTreeIter iter;
 223         FileData *fd = NULL;
 224         GtkTreeModel *store;
 225
 226         store = gtk_tree_view_get_model(tview);
 227         gtk_tree_model_get_iter(store, &iter, tpath);
 228         switch (vd->type)
 229                 {
 230                 case DIRVIEW_LIST:
 231                         gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &fd, -1);
 232                         break;
 233                 case DIRVIEW_TREE:
 234                         {
 235                         NodeData *nd;
 236                         gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &nd, -1);
 237                         fd = (nd) ? nd->fd : NULL;
 238                         };
 239                         break;
 240                 }
 241
 242         return fd;
 243 }
 244
 245 static gboolean vd_rename_cb(TreeEditData *td, const gchar *old, const gchar *new, gpointer data)
 246 {
 247         ViewDir *vd = data;
 248         FileData *fd;
 249         gchar *new_path;
 250         gchar *base;
 251
 252         fd = vd_get_fd_from_tree_path(vd, GTK_TREE_VIEW(vd->view), td->path);
 253         if (!fd) return FALSE;
 254
 255         base = remove_level_from_path(fd->path);
 256         new_path = g_build_filename(base, new, NULL);
 257         g_free(base);
 258
 259         file_util_rename_dir(fd, new_path, vd->view);
 260
 261         g_free(new_path);
 262
 263         return FALSE;
 264 }
 265
 266 static void vd_rename_by_data(ViewDir *vd, FileData *fd)
 267 {
 268         GtkTreeModel *store;
 269         GtkTreePath *tpath;
 270         GtkTreeIter iter;
 271
 272         if (!fd || !vd_find_row(vd, fd, &iter)) return;
 273         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 274         tpath = gtk_tree_model_get_path(store, &iter);
 275
 276         tree_edit_by_path(GTK_TREE_VIEW(vd->view), tpath, 0, fd->name,
 277                           vd_rename_cb, vd);
 278         gtk_tree_path_free(tpath);
 279 }
 280
 281
 282 void vd_color_set(ViewDir *vd, FileData *fd, gint color_set)
 283 {
 284         GtkTreeModel *store;
 285         GtkTreeIter iter;
 286
 287         if (!vd_find_row(vd, fd, &iter)) return;
 288         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 289
 290         switch (vd->type)
 291         {
 292         case DIRVIEW_LIST:
 293                 gtk_list_store_set(GTK_LIST_STORE(store), &iter, DIR_COLUMN_COLOR, color_set, -1);
 294                 break;
 295         case DIRVIEW_TREE:
 296                 gtk_tree_store_set(GTK_TREE_STORE(store), &iter, DIR_COLUMN_COLOR, color_set, -1);
 297                 break;
 298         }
 299 }
 300
 301 void vd_popup_destroy_cb(GtkWidget *widget, gpointer data)
 302 {
 303         ViewDir *vd = data;
 304
 305         vd_color_set(vd, vd->click_fd, FALSE);
 306         vd->click_fd = NULL;
 307         vd->popup = NULL;
 308
 309         vd_color_set(vd, vd->drop_fd, FALSE);
 310         filelist_free(vd->drop_list);
 311         vd->drop_list = NULL;
 312         vd->drop_fd = NULL;
 313 }
 314
 315 /*
 316  *-----------------------------------------------------------------------------
 317  * drop menu (from dnd)
 318  *-----------------------------------------------------------------------------
 319  */
 320
 321 static void vd_drop_menu_copy_cb(GtkWidget *widget, gpointer data)
 322 {
 323         ViewDir *vd = data;
 324         const gchar *path;
 325         GList *list;
 326
 327         if (!vd->drop_fd) return;
 328
 329         path = vd->drop_fd->path;
 330         list = vd->drop_list;
 331         vd->drop_list = NULL;
 332
 333         file_util_copy_simple(list, path, vd->widget);
 334 }
 335
 336 static void vd_drop_menu_move_cb(GtkWidget *widget, gpointer data)
 337 {
 338         ViewDir *vd = data;
 339         const gchar *path;
 340         GList *list;
 341
 342         if (!vd->drop_fd) return;
 343
 344         path = vd->drop_fd->path;
 345         list = vd->drop_list;
 346
 347         vd->drop_list = NULL;
 348
 349         file_util_move_simple(list, path, vd->widget);
 350 }
 351
 352 static void vd_drop_menu_filter_cb(GtkWidget *widget, gpointer data)
 353 {
 354         ViewDir *vd = data;
 355         const gchar *path;
 356         GList *list;
 357         const gchar *key;
 358
 359         if (!vd->drop_fd) return;
 360
 361         key = g_object_get_data(G_OBJECT(widget), "filter_key");
 362
 363         path = vd->drop_fd->path;
 364         list = vd->drop_list;
 365
 366         vd->drop_list = NULL;
 367
 368         file_util_start_filter_from_filelist(key, list, path, vd->widget);
 369 }
 370
 371 static void vd_drop_menu_edit_item_free(gpointer data)
 372 {
 373         g_free(data);
 374 }
 375
 376 GtkWidget *vd_drop_menu(ViewDir *vd, gint active)
 377 {
 378         GtkWidget *menu;
 379         GList *editors_list = editor_list_get();
 380         GList *work = editors_list;
 381
 382         menu = popup_menu_short_lived();
 383         g_signal_connect(G_OBJECT(menu), "destroy",
 384                          G_CALLBACK(vd_popup_destroy_cb), vd);
 385
 386         menu_item_add_stock_sensitive(menu, _("_Copy"), GTK_STOCK_COPY, active,
 387                                       G_CALLBACK(vd_drop_menu_copy_cb), vd);
 388         menu_item_add_sensitive(menu, _("_Move"), active, G_CALLBACK(vd_drop_menu_move_cb), vd);
 389
 390         while (work)
 391                 {
 392                 GtkWidget *item;
 393                 const EditorDescription *editor = work->data;
 394                 gchar *key;
 395                 work = work->next;
 396
 397                 if (!editor_is_filter(editor->key)) continue;
 398                 key = g_strdup(editor->key);
 399                 item = menu_item_add_sensitive(menu, editor->name, active, G_CALLBACK(vd_drop_menu_filter_cb), vd);
 400                 g_object_set_data_full(G_OBJECT(item), "filter_key", key, vd_drop_menu_edit_item_free);
 401                 }
 402
 403         g_list_free(editors_list);
 404
 405         menu_item_add_divider(menu);
 406         menu_item_add_stock(menu, _("Cancel"), GTK_STOCK_CANCEL, NULL, vd);
 407
 408         return menu;
 409 }
 410
 411 /*
 412  *-----------------------------------------------------------------------------
 413  * pop-up menu
 414  *-----------------------------------------------------------------------------
 415  */
 416
 417 static void vd_pop_menu_up_cb(GtkWidget *widget, gpointer data)
 418 {
 419         ViewDir *vd = data;
 420         gchar *path;
 421
 422         if (!vd->dir_fd || strcmp(vd->dir_fd->path, G_DIR_SEPARATOR_S) == 0) return;
 423         path = remove_level_from_path(vd->dir_fd->path);
 424
 425         if (vd->select_func)
 426                 {
 427                 FileData *fd = file_data_new_simple(path);
 428                 vd->select_func(vd, fd, vd->select_data);
 429                 file_data_unref(fd);
 430                 }
 431
 432         g_free(path);
 433 }
 434
 435 static void vd_pop_menu_slide_cb(GtkWidget *widget, gpointer data)
 436 {
 437         ViewDir *vd = data;
 438
 439         if (!vd->layout) return;
 440         if (!vd->click_fd) return;
 441
 442         layout_set_fd(vd->layout, vd->click_fd);
 443         layout_select_none(vd->layout);
 444         layout_image_slideshow_stop(vd->layout);
 445         layout_image_slideshow_start(vd->layout);
 446 }
 447
 448 static void vd_pop_menu_slide_rec_cb(GtkWidget *widget, gpointer data)
 449 {
 450         ViewDir *vd = data;
 451         GList *list;
 452
 453         if (!vd->layout) return;
 454         if (!vd->click_fd) return;
 455
 456         list = filelist_recursive(vd->click_fd);
 457
 458         layout_image_slideshow_stop(vd->layout);
 459         layout_image_slideshow_start_from_list(vd->layout, list);
 460 }
 461
 462 static void vd_pop_menu_dupe(ViewDir *vd, gint recursive)
 463 {
 464         DupeWindow *dw;
 465         GList *list = NULL;
 466
 467         if (!vd->click_fd) return;
 468
 469         if (recursive)
 470                 {
 471                 list = g_list_append(list, file_data_ref(vd->click_fd));
 472                 }
 473         else
 474                 {
 475                 filelist_read(vd->click_fd, &list, NULL);
 476                 list = filelist_filter(list, FALSE);
 477                 }
 478
 479         dw = dupe_window_new(DUPE_MATCH_NAME);
 480         dupe_window_add_files(dw, list, recursive);
 481
 482         filelist_free(list);
 483 }
 484
 485 static void vd_pop_menu_dupe_cb(GtkWidget *widget, gpointer data)
 486 {
 487         ViewDir *vd = data;
 488         vd_pop_menu_dupe(vd, FALSE);
 489 }
 490
 491 static void vd_pop_menu_dupe_rec_cb(GtkWidget *widget, gpointer data)
 492 {
 493         ViewDir *vd = data;
 494         vd_pop_menu_dupe(vd, TRUE);
 495 }
 496
 497 static void vd_pop_menu_delete_cb(GtkWidget *widget, gpointer data)
 498 {
 499         ViewDir *vd = data;
 500
 501         if (!vd->click_fd) return;
 502         file_util_delete_dir(vd->click_fd, vd->widget);
 503 }
 504
 505 static void vd_pop_menu_copy_path_cb(GtkWidget *widget, gpointer data)
 506 {
 507         ViewDir *vd = data;
 508
 509         if (!vd->click_fd) return;
 510
 511         file_util_copy_path_to_clipboard(vd->click_fd);
 512 }
 513
 514 #define VIEW_DIR_AS_SUBMENU_KEY "view_dir_as_submenu"
 515 static void vd_pop_submenu_dir_view_as_cb(GtkWidget *widget, gpointer data)
 516 {
 517         ViewDir *vd = data;
 518
 519         DirViewType new_type = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), VIEW_DIR_AS_SUBMENU_KEY));
 520         layout_views_set(vd->layout, new_type, vd->layout->options.file_view_type);
 521 }
 522
 523 static void vd_pop_menu_refresh_cb(GtkWidget *widget, gpointer data)
 524 {
 525         ViewDir *vd = data;
 526
 527         if (vd->layout) layout_refresh(vd->layout);
 528 }
 529
 530 static void vd_toggle_show_hidden_files_cb(GtkWidget *widget, gpointer data)
 531 {
 532         ViewDir *vd = data;
 533
 534         options->file_filter.show_hidden_files = !options->file_filter.show_hidden_files;
 535         if (vd->layout) layout_refresh(vd->layout);
 536 }
 537
 538 static void vd_pop_menu_new_rename_cb(gboolean success, const gchar *new_path, gpointer data)
 539 {
 540         ViewDir *vd = data;
 541         FileData *fd = NULL;
 542         if (!success) return;
 543
 544         switch (vd->type)
 545                 {
 546                 case DIRVIEW_LIST:
 547                         {
 548                         vd_refresh(vd);
 549                         fd = vdlist_row_by_path(vd, new_path, NULL);
 550                         };
 551                         break;
 552                 case DIRVIEW_TREE:
 553                         {
 554                         FileData *new_fd = file_data_new_simple(new_path);
 555                         fd = vdtree_populate_path(vd, new_fd, TRUE, TRUE);
 556                         file_data_unref(new_fd);
 557                         }
 558                         break;
 559                 }
 560         vd_rename_by_data(vd, fd);
 561 }
 562
 563 static void vd_pop_menu_new_cb(GtkWidget *widget, gpointer data)
 564 {
 565         ViewDir *vd = data;
 566         FileData *dir_fd = NULL;
 567
 568         switch (vd->type)
 569                 {
 570                 case DIRVIEW_LIST:
 571                         {
 572                         if (!vd->dir_fd) return;
 573                         dir_fd = vd->dir_fd;
 574                         };
 575                         break;
 576                 case DIRVIEW_TREE:
 577                         {
 578                         if (!vd->click_fd) return;
 579                         dir_fd = vd->click_fd;
 580                         };
 581                         break;
 582                 }
 583
 584         file_util_create_dir(dir_fd, widget, vd_pop_menu_new_rename_cb, vd);
 585 }
 586
 587 static void vd_pop_menu_rename_cb(GtkWidget *widget, gpointer data)
 588 {
 589         ViewDir *vd = data;
 590
 591         vd_rename_by_data(vd, vd->click_fd);
 592 }
 593
 594 GtkWidget *vd_pop_menu(ViewDir *vd, FileData *fd)
 595 {
 596         GtkWidget *menu;
 597         GtkWidget *submenu;
 598         GtkWidget *item;
 599         gboolean active;
 600         gboolean rename_delete_active = FALSE;
 601         gboolean new_folder_active = FALSE;
 602         gint i;
 603
 604         active = (fd != NULL);
 605         switch (vd->type)
 606                 {
 607                 case DIRVIEW_LIST:
 608                         {
 609                         /* check using . (always row 0) */
 610                         new_folder_active = (vd->dir_fd && access_file(vd->dir_fd->path , W_OK | X_OK));
 611
 612                         /* ignore .. and . */
 613                         rename_delete_active = (new_folder_active && fd &&
 614                                 strcmp(fd->name, ".") != 0 &&
 615                                 strcmp(fd->name, "..") != 0 &&
 616                                 access_file(fd->path, W_OK | X_OK));
 617                         };
 618                         break;
 619                 case DIRVIEW_TREE:
 620                         {
 621                         if (fd)
 622                                 {
 623                                 gchar *parent;
 624                                 new_folder_active = (fd && access_file(fd->path, W_OK | X_OK));
 625                                 parent = remove_level_from_path(fd->path);
 626                                 rename_delete_active = access_file(parent, W_OK | X_OK);
 627                                 g_free(parent);
 628                                 };
 629                         }
 630                         break;
 631                 }
 632
 633         menu = popup_menu_short_lived();
 634         g_signal_connect(G_OBJECT(menu), "destroy",
 635                          G_CALLBACK(vd_popup_destroy_cb), vd);
 636
 637         menu_item_add_stock_sensitive(menu, _("_Up to parent"), GTK_STOCK_GO_UP,
 638                                       (vd->dir_fd && strcmp(vd->dir_fd->path, G_DIR_SEPARATOR_S) != 0),
 639                                       G_CALLBACK(vd_pop_menu_up_cb), vd);
 640
 641         menu_item_add_divider(menu);
 642         menu_item_add_sensitive(menu, _("_Slideshow"), active,
 643                                 G_CALLBACK(vd_pop_menu_slide_cb), vd);
 644         menu_item_add_sensitive(menu, _("Slideshow recursive"), active,
 645                                 G_CALLBACK(vd_pop_menu_slide_rec_cb), vd);
 646
 647         menu_item_add_divider(menu);
 648         menu_item_add_stock_sensitive(menu, _("Find _duplicates..."), GTK_STOCK_FIND, active,
 649                                       G_CALLBACK(vd_pop_menu_dupe_cb), vd);
 650         menu_item_add_stock_sensitive(menu, _("Find duplicates recursive..."), GTK_STOCK_FIND, active,
 651                                       G_CALLBACK(vd_pop_menu_dupe_rec_cb), vd);
 652
 653         menu_item_add_divider(menu);
 654
 655         menu_item_add_sensitive(menu, _("_New folder..."), new_folder_active,
 656                                 G_CALLBACK(vd_pop_menu_new_cb), vd);
 657
 658         menu_item_add_sensitive(menu, _("_Rename..."), rename_delete_active,
 659                                 G_CALLBACK(vd_pop_menu_rename_cb), vd);
 660         menu_item_add_stock_sensitive(menu, _("_Delete..."), GTK_STOCK_DELETE, rename_delete_active,
 661                                       G_CALLBACK(vd_pop_menu_delete_cb), vd);
 662
 663         menu_item_add(menu, _("_Copy path"),
 664                       G_CALLBACK(vd_pop_menu_copy_path_cb), vd);
 665
 666         menu_item_add_divider(menu);
 667
 668         item = menu_item_add(menu, _("_View as"), NULL, NULL);
 669         submenu = gtk_menu_new();
 670         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
 671
 672         for (i = 0; i < VIEW_DIR_TYPES_COUNT; i++)
 673                 {
 674                 item = menu_item_add_check(submenu, _(menu_view_dir_radio_entries[i].label),
 675                                            ((gint) vd->type == menu_view_dir_radio_entries[i].value),
 676                                            G_CALLBACK(vd_pop_submenu_dir_view_as_cb), vd);
 677                 g_object_set_data(G_OBJECT(item), VIEW_DIR_AS_SUBMENU_KEY, GINT_TO_POINTER(menu_view_dir_radio_entries[i].value));
 678                 }
 679
 680         menu_item_add_check(menu, _("Show _hidden files"), options->file_filter.show_hidden_files,
 681                             G_CALLBACK(vd_toggle_show_hidden_files_cb), vd);
 682
 683         menu_item_add_stock(menu, _("Re_fresh"), GTK_STOCK_REFRESH,
 684                             G_CALLBACK(vd_pop_menu_refresh_cb), vd);
 685
 686         return menu;
 687 }
 688
 689 /*
 690  *-----------------------------------------------------------------------------
 691  * dnd
 692  *-----------------------------------------------------------------------------
 693  */
 694
 695 static GtkTargetEntry vd_dnd_drop_types[] = {
 696         { "text/uri-list", 0, TARGET_URI_LIST }
 697 };
 698 static gint vd_dnd_drop_types_count = 1;
 699
 700 static void vd_dest_set(ViewDir *vd, gint enable)
 701 {
 702         if (enable)
 703                 {
 704                 gtk_drag_dest_set(vd->view,
 705                                   GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
 706                                   vd_dnd_drop_types, vd_dnd_drop_types_count,
 707                                   GDK_ACTION_MOVE | GDK_ACTION_COPY);
 708                 }
 709         else
 710                 {
 711                 gtk_drag_dest_unset(vd->view);
 712                 }
 713 }
 714
 715 static void vd_dnd_get(GtkWidget *widget, GdkDragContext *context,
 716                            GtkSelectionData *selection_data, guint info,
 717                            guint time, gpointer data)
 718 {
 719         ViewDir *vd = data;
 720         GList *list;
 721         gchar *uritext = NULL;
 722         gint length = 0;
 723
 724         if (!vd->click_fd) return;
 725
 726         switch (info)
 727                 {
 728                 case TARGET_URI_LIST:
 729                 case TARGET_TEXT_PLAIN:
 730                         list = g_list_prepend(NULL, vd->click_fd);
 731                         uritext = uri_text_from_filelist(list, &length, (info == TARGET_TEXT_PLAIN));
 732                         g_list_free(list);
 733                         break;
 734                 }
 735         if (uritext)
 736                 {
 737                 gtk_selection_data_set(selection_data, selection_data->target,
 738                                        8, (guchar *)uritext, length);
 739                 g_free(uritext);
 740                 }
 741 }
 742
 743 static void vd_dnd_begin(GtkWidget *widget, GdkDragContext *context, gpointer data)
 744 {
 745         ViewDir *vd = data;
 746
 747         vd_color_set(vd, vd->click_fd, TRUE);
 748         vd_dest_set(vd, FALSE);
 749 }
 750
 751 static void vd_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
 752 {
 753         ViewDir *vd = data;
 754
 755         vd_color_set(vd, vd->click_fd, FALSE);
 756
 757         if (vd->type == DIRVIEW_LIST && context->action == GDK_ACTION_MOVE)
 758                 {
 759                 vd_refresh(vd);
 760                 }
 761         vd_dest_set(vd, TRUE);
 762 }
 763
 764 static void vd_dnd_drop_receive(GtkWidget *widget,
 765                                 GdkDragContext *context, gint x, gint y,
 766                                 GtkSelectionData *selection_data, guint info,
 767                                 guint time, gpointer data)
 768 {
 769         ViewDir *vd = data;
 770         GtkTreePath *tpath;
 771         FileData *fd = NULL;
 772
 773         vd->click_fd = NULL;
 774
 775         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), x, y,
 776                                           &tpath, NULL, NULL, NULL))
 777                 {
 778                 fd = vd_get_fd_from_tree_path(vd, GTK_TREE_VIEW(widget), tpath);
 779                 gtk_tree_path_free(tpath);
 780                 }
 781
 782         if (!fd) return;
 783
 784         if (info == TARGET_URI_LIST)
 785                 {
 786                 GList *list;
 787                 gint active;
 788                 gboolean done = FALSE;
 789
 790                 list = uri_filelist_from_text((gchar *)selection_data->data, TRUE);
 791                 if (!list) return;
 792
 793                 active = access_file(fd->path, W_OK | X_OK);
 794
 795                 vd_color_set(vd, fd, TRUE);
 796
 797                 if (active)
 798                         {
 799                         if (context->actions == GDK_ACTION_COPY)
 800                                 {
 801                                 file_util_copy_simple(list, fd->path, vd->widget);
 802                                 done = TRUE;
 803                                 }
 804                         else if (context->actions == GDK_ACTION_MOVE)
 805                                 {
 806                                 file_util_move_simple(list, fd->path, vd->widget);
 807                                 done = TRUE;
 808                                 }
 809                         }
 810
 811                 if (done == FALSE)
 812                         {
 813                         vd->popup = vd_drop_menu(vd, active);
 814                         gtk_menu_popup(GTK_MENU(vd->popup), NULL, NULL, NULL, NULL, 0, time);
 815                         }
 816
 817                 vd->drop_fd = fd;
 818                 vd->drop_list = list;
 819                 }
 820 }
 821
 822 static void vd_dnd_drop_update(ViewDir *vd, gint x, gint y)
 823 {
 824         GtkTreePath *tpath;
 825         FileData *fd = NULL;
 826
 827         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vd->view), x, y,
 828                                           &tpath, NULL, NULL, NULL))
 829                 {
 830                 fd = vd_get_fd_from_tree_path(vd, GTK_TREE_VIEW(vd->view), tpath);
 831                 gtk_tree_path_free(tpath);
 832                 }
 833
 834         if (fd != vd->drop_fd)
 835                 {
 836                 vd_color_set(vd, vd->drop_fd, FALSE);
 837                 vd_color_set(vd, fd, TRUE);
 838                 if (fd && vd->dnd_drop_update_func) vd->dnd_drop_update_func(vd);
 839                 }
 840
 841         vd->drop_fd = fd;
 842 }
 843
 844 void vd_dnd_drop_scroll_cancel(ViewDir *vd)
 845 {
 846         if (vd->drop_scroll_id)
 847                 {
 848                 g_source_remove(vd->drop_scroll_id);
 849                 vd->drop_scroll_id = 0;
 850                 }
 851 }
 852
 853 static gboolean vd_auto_scroll_idle_cb(gpointer data)
 854 {
 855         ViewDir *vd = data;
 856
 857         if (vd->drop_fd)
 858                 {
 859                 GdkWindow *window;
 860                 gint x, y;
 861                 gint w, h;
 862
 863                 window = vd->view->window;
 864                 gdk_window_get_pointer(window, &x, &y, NULL);
 865                 gdk_drawable_get_size(window, &w, &h);
 866                 if (x >= 0 && x < w && y >= 0 && y < h)
 867                         {
 868                         vd_dnd_drop_update(vd, x, y);
 869                         }
 870                 }
 871
 872         vd->drop_scroll_id = 0;
 873         return FALSE;
 874 }
 875
 876 static gboolean vd_auto_scroll_notify_cb(GtkWidget *widget, gint x, gint y, gpointer data)
 877 {
 878         ViewDir *vd = data;
 879
 880         if (!vd->drop_fd || vd->drop_list) return FALSE;
 881
 882         if (!vd->drop_scroll_id) vd->drop_scroll_id = g_idle_add(vd_auto_scroll_idle_cb, vd);
 883
 884         return TRUE;
 885 }
 886
 887 static gboolean vd_dnd_drop_motion(GtkWidget *widget, GdkDragContext *context,
 888                                    gint x, gint y, guint time, gpointer data)
 889 {
 890         ViewDir *vd = data;
 891
 892         vd->click_fd = NULL;
 893
 894         if (gtk_drag_get_source_widget(context) == vd->view)
 895                 {
 896                 /* from same window */
 897                 gdk_drag_status(context, 0, time);
 898                 return TRUE;
 899                 }
 900         else
 901                 {
 902                 gdk_drag_status(context, context->suggested_action, time);
 903                 }
 904
 905         vd_dnd_drop_update(vd, x, y);
 906
 907         if (vd->drop_fd)
 908                 {
 909                 GtkAdjustment *adj = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(vd->view));
 910                 widget_auto_scroll_start(vd->view, adj, -1, -1, vd_auto_scroll_notify_cb, vd);
 911                 }
 912
 913         return FALSE;
 914 }
 915
 916 static void vd_dnd_drop_leave(GtkWidget *widget, GdkDragContext *context, guint time, gpointer data)
 917 {
 918         ViewDir *vd = data;
 919
 920         if (vd->drop_fd != vd->click_fd) vd_color_set(vd, vd->drop_fd, FALSE);
 921
 922         vd->drop_fd = NULL;
 923
 924         if (vd->dnd_drop_leave_func) vd->dnd_drop_leave_func(vd);
 925 }
 926
 927 void vd_dnd_init(ViewDir *vd)
 928 {
 929         gtk_drag_source_set(vd->view, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
 930                             dnd_file_drag_types, dnd_file_drag_types_count,
 931                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_ASK);
 932         g_signal_connect(G_OBJECT(vd->view), "drag_data_get",
 933                          G_CALLBACK(vd_dnd_get), vd);
 934         g_signal_connect(G_OBJECT(vd->view), "drag_begin",
 935                          G_CALLBACK(vd_dnd_begin), vd);
 936         g_signal_connect(G_OBJECT(vd->view), "drag_end",
 937                          G_CALLBACK(vd_dnd_end), vd);
 938
 939         vd_dest_set(vd, TRUE);
 940         g_signal_connect(G_OBJECT(vd->view), "drag_data_received",
 941                          G_CALLBACK(vd_dnd_drop_receive), vd);
 942         g_signal_connect(G_OBJECT(vd->view), "drag_motion",
 943                          G_CALLBACK(vd_dnd_drop_motion), vd);
 944         g_signal_connect(G_OBJECT(vd->view), "drag_leave",
 945                          G_CALLBACK(vd_dnd_drop_leave), vd);
 946 }
 947
 948 /*
 949  *----------------------------------------------------------------------------
 950  * callbacks
 951  *----------------------------------------------------------------------------
 952  */
 953
 954 void vd_menu_position_cb(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer data)
 955 {
 956         ViewDir *vd = data;
 957         GtkTreeModel *store;
 958         GtkTreeIter iter;
 959         GtkTreePath *tpath;
 960         gint cw, ch;
 961
 962         if (!vd_find_row(vd, vd->click_fd, &iter)) return;
 963         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 964         tpath = gtk_tree_model_get_path(store, &iter);
 965         tree_view_get_cell_clamped(GTK_TREE_VIEW(vd->view), tpath, 0, TRUE, x, y, &cw, &ch);
 966         gtk_tree_path_free(tpath);
 967         *y += ch;
 968         popup_menu_position_clamp(menu, x, y, 0);
 969 }
 970
 971 void vd_activate_cb(GtkTreeView *tview, GtkTreePath *tpath, GtkTreeViewColumn *column, gpointer data)
 972 {
 973         ViewDir *vd = data;
 974         FileData *fd = vd_get_fd_from_tree_path(vd, tview, tpath);
 975
 976         vd_select_row(vd, fd);
 977 }
 978
 979 static GdkColor *vd_color_shifted(GtkWidget *widget)
 980 {
 981         static GdkColor color;
 982         static GtkWidget *done = NULL;
 983
 984         if (done != widget)
 985                 {
 986                 GtkStyle *style;
 987
 988                 style = gtk_widget_get_style(widget);
 989                 memcpy(&color, &style->base[GTK_STATE_NORMAL], sizeof(color));
 990                 shift_color(&color, -1, 0);
 991                 done = widget;
 992                 }
 993
 994         return &color;
 995 }
 996
 997 void vd_color_cb(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
 998                  GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
 999 {
1000         ViewDir *vd = data;
1001         gboolean set;
1002
1003         gtk_tree_model_get(tree_model, iter, DIR_COLUMN_COLOR, &set, -1);
1004         g_object_set(G_OBJECT(cell),
1005                      "cell-background-gdk", vd_color_shifted(vd->view),
1006                      "cell-background-set", set, NULL);
1007 }
1008
1009 gboolean vd_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1010 {
1011         ViewDir *vd = data;
1012         GtkTreePath *tpath;
1013         FileData *fd = NULL;
1014
1015         if (!vd->click_fd) return FALSE;
1016         vd_color_set(vd, vd->click_fd, FALSE);
1017
1018         if (bevent->button != MOUSE_BUTTON_LEFT) return TRUE;
1019
1020         if ((bevent->x != 0 || bevent->y != 0) &&
1021             gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
1022                                           &tpath, NULL, NULL, NULL))
1023                 {
1024                 fd = vd_get_fd_from_tree_path(vd, GTK_TREE_VIEW(widget), tpath);
1025                 gtk_tree_path_free(tpath);
1026                 }
1027
1028         if (fd && vd->click_fd == fd)
1029                 {
1030                 vd_select_row(vd, vd->click_fd);
1031                 }
1032
1033         return FALSE;
1034 }
1035
1036 gboolean vd_press_key_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
1037 {
1038         ViewDir *vd = data;
1039         gboolean ret = FALSE;
1040
1041         switch (vd->type)
1042         {
1043         case DIRVIEW_LIST: ret = vdlist_press_key_cb(widget, event, data); break;
1044         case DIRVIEW_TREE: ret = vdtree_press_key_cb(widget, event, data); break;
1045         }
1046
1047         return ret;
1048 }
1049
1050 gboolean vd_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1051 {
1052         ViewDir *vd = data;
1053         gboolean ret = FALSE;
1054
1055         switch (vd->type)
1056         {
1057         case DIRVIEW_LIST: ret = vdlist_press_cb(widget, bevent, data); break;
1058         case DIRVIEW_TREE: ret = vdtree_press_cb(widget, bevent, data); break;
1059         }
1060
1061         return ret;
1062 }
1063
1064 static void vd_notify_cb(FileData *fd, NotifyType type, gpointer data)
1065 {
1066         ViewDir *vd = data;
1067         gboolean refresh;
1068         gchar *base;
1069
1070         if (!S_ISDIR(fd->mode)) return; /* this gives correct results even on recently deleted files/directories */
1071
1072         DEBUG_1("Notify vd: %s %04x", fd->path, type);
1073
1074         base = remove_level_from_path(fd->path);
1075
1076         if (vd->type == DIRVIEW_LIST)
1077                 {
1078                 refresh = (fd == vd->dir_fd);
1079
1080                 if (!refresh)
1081                         {
1082                         refresh = (strcmp(base, vd->dir_fd->path) == 0);
1083                         }
1084
1085                 if ((type & NOTIFY_CHANGE) && fd->change)
1086                         {
1087                         if (!refresh && fd->change->dest)
1088                                 {
1089                                 gchar *dest_base = remove_level_from_path(fd->change->dest);
1090                                 refresh = (strcmp(dest_base, vd->dir_fd->path) == 0);
1091                                 g_free(dest_base);
1092                                 }
1093
1094                         if (!refresh && fd->change->source)
1095                                 {
1096                                 gchar *source_base = remove_level_from_path(fd->change->source);
1097                                 refresh = (strcmp(source_base, vd->dir_fd->path) == 0);
1098                                 g_free(source_base);
1099                                 }
1100                         }
1101
1102                 if (refresh) vd_refresh(vd);
1103                 }
1104
1105         if (vd->type == DIRVIEW_TREE)
1106                 {
1107                 GtkTreeIter iter;
1108                 FileData *base_fd = file_data_new_simple(base);
1109
1110                 if (vd_find_row(vd, base_fd, &iter))
1111                         {
1112                         vdtree_populate_path_by_iter(vd, &iter, TRUE, vd->dir_fd);
1113                         }
1114
1115                 file_data_unref(base_fd);
1116                 }
1117
1118         g_free(base);
1119 }
1120 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */