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