src/view_file_icon.c

   1 /*
   2  * Geeqie
   3  * (C) 2006 John Ellis
   4  * Copyright (C) 2008 The Geeqie Team
   5  *
   6  * Author: John Ellis
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13 #include "main.h"
  14 #include "view_file_icon.h"
  15
  16 #include "cellrenderericon.h"
  17 #include "collect.h"
  18 #include "collect-io.h"
  19 #include "collect-table.h"
  20 #include "debug.h"
  21 #include "dnd.h"
  22 #include "editors.h"
  23 #include "img-view.h"
  24 #include "info.h"
  25 #include "filedata.h"
  26 #include "layout.h"
  27 #include "layout_image.h"
  28 #include "menu.h"
  29 #include "thumb.h"
  30 #include "utilops.h"
  31 #include "ui_bookmark.h"
  32 #include "ui_fileops.h"
  33 #include "ui_menu.h"
  34 #include "ui_tree_edit.h"
  35
  36
  37 #include <gdk/gdkkeysyms.h> /* for keyboard values */
  38
  39 #define VFICON_INFO_POINTER(_vf_) ((ViewFileInfoIcon *)(_vf_->info))
  40 #define VFICON_INFO(_vf_, _part_) (VFICON_INFO_POINTER(_vf_)->_part_)
  41
  42 /* between these, the icon width is increased by thumb_max_width / 2 */
  43 #define THUMB_MIN_ICON_WIDTH 128
  44 #define THUMB_MAX_ICON_WIDTH 150
  45
  46 #define VFICON_MAX_COLUMNS 32
  47 #define THUMB_BORDER_PADDING 2
  48
  49 #define VFICON_TIP_DELAY 500
  50
  51 enum {
  52         FILE_COLUMN_POINTER = 0,
  53         FILE_COLUMN_COUNT
  54 };
  55
  56 typedef enum {
  57         SELECTION_NONE          = 0,
  58         SELECTION_SELECTED      = 1 << 0,
  59         SELECTION_PRELIGHT      = 1 << 1,
  60         SELECTION_FOCUS         = 1 << 2
  61 } SelectionType;
  62
  63 typedef struct _IconData IconData;
  64 struct _IconData
  65 {
  66         SelectionType selected;
  67         gint row;
  68         FileData *fd;
  69 };
  70
  71 static gint vficon_index_by_id(ViewFile *vf, IconData *in_id);
  72
  73 static IconData *vficon_icon_data(ViewFile *vf, FileData *fd)
  74 {
  75         IconData *id = NULL;
  76         GList *work;
  77
  78         if (!fd) return NULL;
  79         work = vf->list;
  80         while (work && !id)
  81                 {
  82                 IconData *chk = work->data;
  83                 work = work->next;
  84                 if (chk->fd == fd) id = chk;
  85                 }
  86         return id;
  87 }
  88
  89
  90 static gint iconlist_read(const gchar *path, GList **list)
  91 {
  92         GList *temp;
  93         GList *work;
  94
  95         if (!filelist_read(path, &temp, NULL)) return FALSE;
  96
  97         work = temp;
  98         while (work)
  99                 {
 100                 FileData *fd;
 101                 IconData *id;
 102
 103                 fd = work->data;
 104                 g_assert(fd->magick == 0x12345678);
 105                 id = g_new0(IconData, 1);
 106
 107                 id->selected = SELECTION_NONE;
 108                 id->row = -1;
 109                 id->fd = fd;
 110
 111                 work->data = id;
 112                 work = work->next;
 113                 }
 114
 115         *list = temp;
 116
 117         return TRUE;
 118 }
 119
 120 static void iconlist_free(GList *list)
 121 {
 122         GList *work = list;
 123         while (work)
 124                 {
 125                 IconData *id = work->data;
 126                 file_data_unref(id->fd);
 127                 g_free(id);
 128                 work = work->next;
 129                 }
 130
 131         g_list_free(list);
 132
 133 }
 134
 135 gint iconlist_sort_file_cb(void *a, void *b)
 136 {
 137         IconData *ida = a;
 138         IconData *idb = b;
 139         return filelist_sort_compare_filedata(ida->fd, idb->fd);
 140 }
 141 GList *iconlist_sort(GList *list, SortType method, gint ascend)
 142 {
 143         return filelist_sort_full(list, method, ascend, (GCompareFunc) iconlist_sort_file_cb);
 144 }
 145
 146 GList *iconlist_insert_sort(GList *list, IconData *id, SortType method, gint ascend)
 147 {
 148         return filelist_insert_sort_full(list, id, method, ascend, (GCompareFunc) iconlist_sort_file_cb);
 149 }
 150
 151
 152 static void vficon_toggle_filenames(ViewFile *vf);
 153 static void vficon_selection_remove(ViewFile *vf, IconData *id, SelectionType mask, GtkTreeIter *iter);
 154 static void vficon_move_focus(ViewFile *vf, gint row, gint col, gint relative);
 155 static void vficon_set_focus(ViewFile *vf, IconData *id);
 156 static void vficon_thumb_update(ViewFile *vf);
 157 static void vficon_populate_at_new_size(ViewFile *vf, gint w, gint h, gint force);
 158
 159
 160 /*
 161  *-----------------------------------------------------------------------------
 162  * pop-up menu
 163  *-----------------------------------------------------------------------------
 164  */
 165
 166 static GList *vficon_pop_menu_file_list(ViewFile *vf)
 167 {
 168         if (!VFICON_INFO(vf, click_id)) return NULL;
 169
 170         if (VFICON_INFO(vf, click_id)->selected & SELECTION_SELECTED)
 171                 {
 172                 return vficon_selection_get_list(vf);
 173                 }
 174
 175         return g_list_append(NULL, file_data_ref(VFICON_INFO(vf, click_id)->fd));
 176 }
 177
 178 static void vficon_pop_menu_edit_cb(GtkWidget *widget, gpointer data)
 179 {
 180         ViewFile *vf;
 181         gint n;
 182         GList *list;
 183
 184         vf = submenu_item_get_data(widget);
 185         n = GPOINTER_TO_INT(data);
 186
 187         if (!vf) return;
 188
 189         list = vficon_pop_menu_file_list(vf);
 190         start_editor_from_filelist(n, list);
 191         filelist_free(list);
 192 }
 193
 194 static void vficon_pop_menu_info_cb(GtkWidget *widget, gpointer data)
 195 {
 196         ViewFile *vf = data;
 197
 198         info_window_new(NULL, vficon_pop_menu_file_list(vf), NULL);
 199 }
 200
 201 static void vficon_pop_menu_view_cb(GtkWidget *widget, gpointer data)
 202 {
 203         ViewFile *vf = data;
 204
 205         if (!VFICON_INFO(vf, click_id)) return;
 206
 207         if (VFICON_INFO(vf, click_id)->selected & SELECTION_SELECTED)
 208                 {
 209                 GList *list;
 210
 211                 list = vficon_selection_get_list(vf);
 212                 view_window_new_from_list(list);
 213                 filelist_free(list);
 214                 }
 215         else
 216                 {
 217                 view_window_new(VFICON_INFO(vf, click_id)->fd);
 218                 }
 219 }
 220
 221 static void vficon_pop_menu_copy_cb(GtkWidget *widget, gpointer data)
 222 {
 223         ViewFile *vf = data;
 224
 225         file_util_copy(NULL, vficon_pop_menu_file_list(vf), NULL, vf->listview);
 226 }
 227
 228 static void vficon_pop_menu_move_cb(GtkWidget *widget, gpointer data)
 229 {
 230         ViewFile *vf = data;
 231
 232         file_util_move(NULL, vficon_pop_menu_file_list(vf), NULL, vf->listview);
 233 }
 234
 235 static void vficon_pop_menu_rename_cb(GtkWidget *widget, gpointer data)
 236 {
 237         ViewFile *vf = data;
 238
 239         file_util_rename(NULL, vficon_pop_menu_file_list(vf), vf->listview);
 240 }
 241
 242 static void vficon_pop_menu_delete_cb(GtkWidget *widget, gpointer data)
 243 {
 244         ViewFile *vf = data;
 245
 246         file_util_delete(NULL, vficon_pop_menu_file_list(vf), vf->listview);
 247 }
 248
 249 static void vficon_pop_menu_copy_path_cb(GtkWidget *widget, gpointer data)
 250 {
 251         ViewFile *vf = data;
 252
 253         file_util_copy_path_list_to_clipboard(vficon_pop_menu_file_list(vf));
 254 }
 255
 256 static void vficon_pop_menu_sort_cb(GtkWidget *widget, gpointer data)
 257 {
 258         ViewFile *vf;
 259         SortType type;
 260
 261         if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) return;
 262
 263         vf = submenu_item_get_data(widget);
 264         if (!vf) return;
 265
 266         type = (SortType)GPOINTER_TO_INT(data);
 267
 268         if (vf->layout)
 269                 {
 270                 layout_sort_set(vf->layout, type, vf->sort_ascend);
 271                 }
 272         else
 273                 {
 274                 vficon_sort_set(vf, type, vf->sort_ascend);
 275                 }
 276 }
 277
 278 static void vficon_pop_menu_sort_ascend_cb(GtkWidget *widget, gpointer data)
 279 {
 280         ViewFile *vf = data;
 281
 282         if (vf->layout)
 283                 {
 284                 layout_sort_set(vf->layout, vf->sort_method, !vf->sort_ascend);
 285                 }
 286         else
 287                 {
 288                 vficon_sort_set(vf, vf->sort_method, !vf->sort_ascend);
 289                 }
 290 }
 291
 292 static void vficon_pop_menu_list_cb(GtkWidget *widget, gpointer data)
 293 {
 294         ViewFile *vf = data;
 295
 296         if (vf->layout) layout_views_set(vf->layout, vf->layout->dir_view_type, FALSE);
 297 }
 298
 299 static void vficon_pop_menu_show_names_cb(GtkWidget *widget, gpointer data)
 300 {
 301         ViewFile *vf = data;
 302
 303         vficon_toggle_filenames(vf);
 304 }
 305
 306 static void vficon_pop_menu_refresh_cb(GtkWidget *widget, gpointer data)
 307 {
 308         ViewFile *vf = data;
 309
 310         vficon_refresh(vf);
 311 }
 312
 313 static void vficon_popup_destroy_cb(GtkWidget *widget, gpointer data)
 314 {
 315         ViewFile *vf = data;
 316         vficon_selection_remove(vf, VFICON_INFO(vf, click_id), SELECTION_PRELIGHT, NULL);
 317         VFICON_INFO(vf, click_id) = NULL;
 318         vf->popup = NULL;
 319 }
 320
 321 static GtkWidget *vficon_pop_menu(ViewFile *vf, gint active)
 322 {
 323         GtkWidget *menu;
 324         GtkWidget *item;
 325         GtkWidget *submenu;
 326
 327         menu = popup_menu_short_lived();
 328
 329         g_signal_connect(G_OBJECT(menu), "destroy",
 330                          G_CALLBACK(vficon_popup_destroy_cb), vf);
 331
 332         submenu_add_edit(menu, &item, G_CALLBACK(vficon_pop_menu_edit_cb), vf);
 333         gtk_widget_set_sensitive(item, active);
 334
 335         menu_item_add_stock_sensitive(menu, _("_Properties"), GTK_STOCK_PROPERTIES, active,
 336                                       G_CALLBACK(vficon_pop_menu_info_cb), vf);
 337
 338         menu_item_add_stock_sensitive(menu, _("View in _new window"), GTK_STOCK_NEW, active,
 339                                       G_CALLBACK(vficon_pop_menu_view_cb), vf);
 340         menu_item_add_divider(menu);
 341
 342         menu_item_add_stock_sensitive(menu, _("_Copy..."), GTK_STOCK_COPY, active,
 343                                       G_CALLBACK(vficon_pop_menu_copy_cb), vf);
 344         menu_item_add_sensitive(menu, _("_Move..."), active,
 345                                 G_CALLBACK(vficon_pop_menu_move_cb), vf);
 346         menu_item_add_sensitive(menu, _("_Rename..."), active,
 347                                 G_CALLBACK(vficon_pop_menu_rename_cb), vf);
 348         menu_item_add_stock_sensitive(menu, _("_Delete..."), GTK_STOCK_DELETE, active,
 349                                       G_CALLBACK(vficon_pop_menu_delete_cb), vf);
 350         if (options->show_copy_path)
 351                 menu_item_add_sensitive(menu, _("_Copy path"), active,
 352                                         G_CALLBACK(vficon_pop_menu_copy_path_cb), vf);
 353         menu_item_add_divider(menu);
 354
 355         submenu = submenu_add_sort(NULL, G_CALLBACK(vficon_pop_menu_sort_cb), vf,
 356                                    FALSE, FALSE, TRUE, vf->sort_method);
 357         menu_item_add_divider(submenu);
 358         menu_item_add_check(submenu, _("Ascending"), vf->sort_ascend,
 359                             G_CALLBACK(vficon_pop_menu_sort_ascend_cb), vf);
 360
 361         item = menu_item_add(menu, _("_Sort"), NULL, NULL);
 362         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
 363
 364         menu_item_add_check(menu, _("View as _icons"), TRUE,
 365                             G_CALLBACK(vficon_pop_menu_list_cb), vf);
 366         menu_item_add_check(menu, _("Show filename _text"), VFICON_INFO(vf, show_text),
 367                             G_CALLBACK(vficon_pop_menu_show_names_cb), vf);
 368         menu_item_add_stock(menu, _("Re_fresh"), GTK_STOCK_REFRESH, G_CALLBACK(vficon_pop_menu_refresh_cb), vf);
 369
 370         return menu;
 371 }
 372
 373 /*
 374  *-------------------------------------------------------------------
 375  * signals
 376  *-------------------------------------------------------------------
 377  */
 378
 379 static void vficon_send_update(ViewFile *vf)
 380 {
 381         if (vf->func_status) vf->func_status(vf, vf->data_status);
 382 }
 383
 384 static void vficon_send_layout_select(ViewFile *vf, IconData *id)
 385 {
 386         FileData *read_ahead_fd = NULL;
 387         FileData *sel_fd;
 388         FileData *cur_fd;
 389
 390         if (!vf->layout || !id || !id->fd) return;
 391
 392         sel_fd = id->fd;
 393
 394         cur_fd = layout_image_get_fd(vf->layout);
 395         if (sel_fd == cur_fd) return; /* no change */
 396
 397         if (options->image.enable_read_ahead)
 398                 {
 399                 gint row;
 400
 401                 row = g_list_index(vf->list, id);
 402                 if (row > vficon_index_by_fd(vf, cur_fd) &&
 403                     row + 1 < vficon_count(vf, NULL))
 404                         {
 405                         read_ahead_fd = vficon_index_get_data(vf, row + 1);
 406                         }
 407                 else if (row > 0)
 408                         {
 409                         read_ahead_fd = vficon_index_get_data(vf, row - 1);
 410                         }
 411                 }
 412
 413         layout_image_set_with_ahead(vf->layout, sel_fd, read_ahead_fd);
 414 }
 415
 416 static void vficon_toggle_filenames(ViewFile *vf)
 417 {
 418         VFICON_INFO(vf, show_text) = !VFICON_INFO(vf, show_text);
 419         options->show_icon_names = VFICON_INFO(vf, show_text);
 420
 421         vficon_populate_at_new_size(vf, vf->listview->allocation.width, vf->listview->allocation.height, TRUE);
 422 }
 423
 424 static gint vficon_get_icon_width(ViewFile *vf)
 425 {
 426         gint width;
 427
 428         if (!VFICON_INFO(vf, show_text)) return options->thumbnails.max_width;
 429
 430         width = options->thumbnails.max_width + options->thumbnails.max_width / 2;
 431         if (width < THUMB_MIN_ICON_WIDTH) width = THUMB_MIN_ICON_WIDTH;
 432         if (width > THUMB_MAX_ICON_WIDTH) width = options->thumbnails.max_width;
 433
 434         return width;
 435 }
 436
 437 /*
 438  *-------------------------------------------------------------------
 439  * misc utils
 440  *-------------------------------------------------------------------
 441  */
 442
 443 static gint vficon_find_position(ViewFile *vf, IconData *id, gint *row, gint *col)
 444 {
 445         gint n;
 446
 447         n = g_list_index(vf->list, id);
 448
 449         if (n < 0) return FALSE;
 450
 451         *row = n / VFICON_INFO(vf, columns);
 452         *col = n - (*row * VFICON_INFO(vf, columns));
 453
 454         return TRUE;
 455 }
 456
 457 static gint vficon_find_iter(ViewFile *vf, IconData *id, GtkTreeIter *iter, gint *column)
 458 {
 459         GtkTreeModel *store;
 460         gint row, col;
 461
 462         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
 463         if (!vficon_find_position(vf, id, &row, &col)) return FALSE;
 464         if (!gtk_tree_model_iter_nth_child(store, iter, NULL, row)) return FALSE;
 465         if (column) *column = col;
 466
 467         return TRUE;
 468 }
 469
 470 static IconData *vficon_find_data(ViewFile *vf, gint row, gint col, GtkTreeIter *iter)
 471 {
 472         GtkTreeModel *store;
 473         GtkTreeIter p;
 474
 475         if (row < 0 || col < 0) return NULL;
 476
 477         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
 478         if (gtk_tree_model_iter_nth_child(store, &p, NULL, row))
 479                 {
 480                 GList *list;
 481
 482                 gtk_tree_model_get(store, &p, FILE_COLUMN_POINTER, &list, -1);
 483                 if (!list) return NULL;
 484
 485                 if (iter) *iter = p;
 486
 487                 return g_list_nth_data(list, col);
 488                 }
 489
 490         return NULL;
 491 }
 492
 493 static IconData *vficon_find_data_by_coord(ViewFile *vf, gint x, gint y, GtkTreeIter *iter)
 494 {
 495         GtkTreePath *tpath;
 496         GtkTreeViewColumn *column;
 497
 498         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), x, y,
 499                                           &tpath, &column, NULL, NULL))
 500                 {
 501                 GtkTreeModel *store;
 502                 GtkTreeIter row;
 503                 GList *list;
 504                 gint n;
 505
 506                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
 507                 gtk_tree_model_get_iter(store, &row, tpath);
 508                 gtk_tree_path_free(tpath);
 509
 510                 gtk_tree_model_get(store, &row, FILE_COLUMN_POINTER, &list, -1);
 511
 512                 n = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(column), "column_number"));
 513                 if (list)
 514                         {
 515                         if (iter) *iter = row;
 516                         return g_list_nth_data(list, n);
 517                         }
 518                 }
 519
 520         return NULL;
 521 }
 522
 523 /*
 524  *-------------------------------------------------------------------
 525  * tooltip type window
 526  *-------------------------------------------------------------------
 527  */
 528
 529 static void tip_show(ViewFile *vf)
 530 {
 531         GtkWidget *label;
 532         gint x, y;
 533
 534         if (VFICON_INFO(vf, tip_window)) return;
 535
 536         gdk_window_get_pointer(gtk_tree_view_get_bin_window(GTK_TREE_VIEW(vf->listview)), &x, &y, NULL);
 537
 538         VFICON_INFO(vf, tip_id) = vficon_find_data_by_coord(vf, x, y, NULL);
 539         if (!VFICON_INFO(vf, tip_id)) return;
 540
 541         VFICON_INFO(vf, tip_window) = gtk_window_new(GTK_WINDOW_POPUP);
 542         gtk_window_set_resizable(GTK_WINDOW(VFICON_INFO(vf, tip_window)), FALSE);
 543         gtk_container_set_border_width(GTK_CONTAINER(VFICON_INFO(vf, tip_window)), 2);
 544
 545         label = gtk_label_new(VFICON_INFO(vf, tip_id)->fd->name);
 546
 547         g_object_set_data(G_OBJECT(VFICON_INFO(vf, tip_window)), "tip_label", label);
 548         gtk_container_add(GTK_CONTAINER(VFICON_INFO(vf, tip_window)), label);
 549         gtk_widget_show(label);
 550
 551         gdk_window_get_pointer(NULL, &x, &y, NULL);
 552
 553         if (!GTK_WIDGET_REALIZED(VFICON_INFO(vf, tip_window))) gtk_widget_realize(VFICON_INFO(vf, tip_window));
 554         gtk_window_move(GTK_WINDOW(VFICON_INFO(vf, tip_window)), x + 16, y + 16);
 555         gtk_widget_show(VFICON_INFO(vf, tip_window));
 556 }
 557
 558 static void tip_hide(ViewFile *vf)
 559 {
 560         if (VFICON_INFO(vf, tip_window)) gtk_widget_destroy(VFICON_INFO(vf, tip_window));
 561         VFICON_INFO(vf, tip_window) = NULL;
 562 }
 563
 564 static gint tip_schedule_cb(gpointer data)
 565 {
 566         ViewFile *vf = data;
 567         GtkWidget *window;
 568
 569         if (VFICON_INFO(vf, tip_delay_id) == -1) return FALSE;
 570
 571         window = gtk_widget_get_toplevel(vf->listview);
 572
 573         if (GTK_WIDGET_SENSITIVE(window) &&
 574             GTK_WINDOW(window)->has_focus)
 575                 {
 576                 tip_show(vf);
 577                 }
 578
 579         VFICON_INFO(vf, tip_delay_id) = -1;
 580         return FALSE;
 581 }
 582
 583 static void tip_schedule(ViewFile *vf)
 584 {
 585         tip_hide(vf);
 586
 587         if (VFICON_INFO(vf, tip_delay_id) != -1)
 588                 {
 589                 g_source_remove(VFICON_INFO(vf, tip_delay_id));
 590                 VFICON_INFO(vf, tip_delay_id) = -1;
 591                 }
 592
 593         if (!VFICON_INFO(vf, show_text))
 594                 {
 595                 VFICON_INFO(vf, tip_delay_id) = g_timeout_add(VFICON_TIP_DELAY, tip_schedule_cb, vf);
 596                 }
 597 }
 598
 599 static void tip_unschedule(ViewFile *vf)
 600 {
 601         tip_hide(vf);
 602
 603         if (VFICON_INFO(vf, tip_delay_id) != -1) g_source_remove(VFICON_INFO(vf, tip_delay_id));
 604         VFICON_INFO(vf, tip_delay_id) = -1;
 605 }
 606
 607 static void tip_update(ViewFile *vf, IconData *id)
 608 {
 609         if (VFICON_INFO(vf, tip_window))
 610                 {
 611                 gint x, y;
 612
 613                 gdk_window_get_pointer(NULL, &x, &y, NULL);
 614                 gtk_window_move(GTK_WINDOW(VFICON_INFO(vf, tip_window)), x + 16, y + 16);
 615
 616                 if (id != VFICON_INFO(vf, tip_id))
 617                         {
 618                         GtkWidget *label;
 619
 620                         VFICON_INFO(vf, tip_id) = id;
 621
 622                         if (!VFICON_INFO(vf, tip_id))
 623                                 {
 624                                 tip_hide(vf);
 625                                 tip_schedule(vf);
 626                                 return;
 627                                 }
 628
 629                         label = g_object_get_data(G_OBJECT(VFICON_INFO(vf, tip_window)), "tip_label");
 630                         gtk_label_set_text(GTK_LABEL(label), VFICON_INFO(vf, tip_id)->fd->name);
 631                         }
 632                 }
 633         else
 634                 {
 635                 tip_schedule(vf);
 636                 }
 637 }
 638
 639 /*
 640  *-------------------------------------------------------------------
 641  * dnd
 642  *-------------------------------------------------------------------
 643  */
 644
 645 static void vficon_dnd_get(GtkWidget *widget, GdkDragContext *context,
 646                            GtkSelectionData *selection_data, guint info,
 647                            guint time, gpointer data)
 648 {
 649         ViewFile *vf = data;
 650         GList *list = NULL;
 651         gchar *uri_text = NULL;
 652         gint total;
 653
 654         if (!VFICON_INFO(vf, click_id)) return;
 655
 656         if (VFICON_INFO(vf, click_id)->selected & SELECTION_SELECTED)
 657                 {
 658                 list = vficon_selection_get_list(vf);
 659                 }
 660         else
 661                 {
 662                 list = g_list_append(NULL, file_data_ref(VFICON_INFO(vf, click_id)->fd));
 663                 }
 664
 665         if (!list) return;
 666         uri_text = uri_text_from_filelist(list, &total, (info == TARGET_TEXT_PLAIN));
 667         filelist_free(list);
 668
 669         DEBUG_1(uri_text);
 670
 671         gtk_selection_data_set(selection_data, selection_data->target,
 672                                8, (guchar *)uri_text, total);
 673         g_free(uri_text);
 674 }
 675
 676 static void vficon_dnd_begin(GtkWidget *widget, GdkDragContext *context, gpointer data)
 677 {
 678         ViewFile *vf = data;
 679
 680         tip_unschedule(vf);
 681
 682         if (VFICON_INFO(vf, click_id) && VFICON_INFO(vf, click_id)->fd->pixbuf)
 683                 {
 684                 gint items;
 685
 686                 if (VFICON_INFO(vf, click_id)->selected & SELECTION_SELECTED)
 687                         items = g_list_length(VFICON_INFO(vf, selection));
 688                 else
 689                         items = 1;
 690
 691                 dnd_set_drag_icon(widget, context, VFICON_INFO(vf, click_id)->fd->pixbuf, items);
 692                 }
 693 }
 694
 695 static void vficon_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
 696 {
 697         ViewFile *vf = data;
 698
 699         vficon_selection_remove(vf, VFICON_INFO(vf, click_id), SELECTION_PRELIGHT, NULL);
 700
 701         if (context->action == GDK_ACTION_MOVE)
 702                 {
 703                 vficon_refresh(vf);
 704                 }
 705
 706         tip_unschedule(vf);
 707 }
 708
 709 void vficon_dnd_init(ViewFile *vf)
 710 {
 711         gtk_drag_source_set(vf->listview, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
 712                             dnd_file_drag_types, dnd_file_drag_types_count,
 713                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
 714         g_signal_connect(G_OBJECT(vf->listview), "drag_data_get",
 715                          G_CALLBACK(vficon_dnd_get), vf);
 716         g_signal_connect(G_OBJECT(vf->listview), "drag_begin",
 717                          G_CALLBACK(vficon_dnd_begin), vf);
 718         g_signal_connect(G_OBJECT(vf->listview), "drag_end",
 719                          G_CALLBACK(vficon_dnd_end), vf);
 720 }
 721
 722 /*
 723  *-------------------------------------------------------------------
 724  * cell updates
 725  *-------------------------------------------------------------------
 726  */
 727
 728 static void vficon_selection_set(ViewFile *vf, IconData *id, SelectionType value, GtkTreeIter *iter)
 729 {
 730         GtkTreeModel *store;
 731         GList *list;
 732
 733         if (!id) return;
 734
 735
 736         if (id->selected == value) return;
 737         id->selected = value;
 738
 739         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
 740         if (iter)
 741                 {
 742                 gtk_tree_model_get(store, iter, FILE_COLUMN_POINTER, &list, -1);
 743                 if (list) gtk_list_store_set(GTK_LIST_STORE(store), iter, FILE_COLUMN_POINTER, list, -1);
 744                 }
 745         else
 746                 {
 747                 GtkTreeIter row;
 748
 749                 if (vficon_find_iter(vf, id, &row, NULL))
 750                         {
 751                         gtk_tree_model_get(store, &row, FILE_COLUMN_POINTER, &list, -1);
 752                         if (list) gtk_list_store_set(GTK_LIST_STORE(store), &row, FILE_COLUMN_POINTER, list, -1);
 753                         }
 754                 }
 755 }
 756
 757 static void vficon_selection_add(ViewFile *vf, IconData *id, SelectionType mask, GtkTreeIter *iter)
 758 {
 759         if (!id) return;
 760
 761         vficon_selection_set(vf, id, id->selected | mask, iter);
 762 }
 763
 764 static void vficon_selection_remove(ViewFile *vf, IconData *id, SelectionType mask, GtkTreeIter *iter)
 765 {
 766         if (!id) return;
 767
 768         vficon_selection_set(vf, id, id->selected & ~mask, iter);
 769 }
 770
 771 /*
 772  *-------------------------------------------------------------------
 773  * selections
 774  *-------------------------------------------------------------------
 775  */
 776
 777 static void vficon_verify_selections(ViewFile *vf)
 778 {
 779         GList *work;
 780
 781         work = VFICON_INFO(vf, selection);
 782         while (work)
 783                 {
 784                 IconData *id = work->data;
 785                 work = work->next;
 786
 787                 if (vficon_index_by_id(vf, id) >= 0) continue;
 788
 789                 VFICON_INFO(vf, selection) = g_list_remove(VFICON_INFO(vf, selection), id);
 790                 }
 791 }
 792
 793 void vficon_select_all(ViewFile *vf)
 794 {
 795         GList *work;
 796
 797         g_list_free(VFICON_INFO(vf, selection));
 798         VFICON_INFO(vf, selection) = NULL;
 799
 800         work = vf->list;
 801         while (work)
 802                 {
 803                 IconData *id = work->data;
 804                 work = work->next;
 805
 806                 VFICON_INFO(vf, selection) = g_list_append(VFICON_INFO(vf, selection), id);
 807                 vficon_selection_add(vf, id, SELECTION_SELECTED, NULL);
 808                 }
 809
 810         vficon_send_update(vf);
 811 }
 812
 813 void vficon_select_none(ViewFile *vf)
 814 {
 815         GList *work;
 816
 817         work = VFICON_INFO(vf, selection);
 818         while (work)
 819                 {
 820                 IconData *id = work->data;
 821                 work = work->next;
 822
 823                 vficon_selection_remove(vf, id, SELECTION_SELECTED, NULL);
 824                 }
 825
 826         g_list_free(VFICON_INFO(vf, selection));
 827         VFICON_INFO(vf, selection) = NULL;
 828
 829         vficon_send_update(vf);
 830 }
 831
 832 void vficon_select_invert(ViewFile *vf)
 833 {
 834         GList *work;
 835
 836         work = vf->list;
 837         while (work)
 838                 {
 839                 IconData *id = work->data;
 840                 work = work->next;
 841
 842                 if (id->selected & SELECTION_SELECTED)
 843                         {
 844                         VFICON_INFO(vf, selection) = g_list_remove(VFICON_INFO(vf, selection), id);
 845                         vficon_selection_remove(vf, id, SELECTION_SELECTED, NULL);
 846                         }
 847                 else
 848                         {
 849                         VFICON_INFO(vf, selection) = g_list_append(VFICON_INFO(vf, selection), id);
 850                         vficon_selection_add(vf, id, SELECTION_SELECTED, NULL);
 851                         }
 852                 }
 853
 854         vficon_send_update(vf);
 855 }
 856
 857 static void vficon_select(ViewFile *vf, IconData *id)
 858 {
 859         VFICON_INFO(vf, prev_selection) = id;
 860
 861         if (!id || id->selected & SELECTION_SELECTED) return;
 862
 863         VFICON_INFO(vf, selection) = g_list_append(VFICON_INFO(vf, selection), id);
 864         vficon_selection_add(vf, id, SELECTION_SELECTED, NULL);
 865
 866         vficon_send_update(vf);
 867 }
 868
 869 static void vficon_unselect(ViewFile *vf, IconData *id)
 870 {
 871         VFICON_INFO(vf, prev_selection) = id;
 872
 873         if (!id || !(id->selected & SELECTION_SELECTED) ) return;
 874
 875         VFICON_INFO(vf, selection) = g_list_remove(VFICON_INFO(vf, selection), id);
 876         vficon_selection_remove(vf, id, SELECTION_SELECTED, NULL);
 877
 878         vficon_send_update(vf);
 879 }
 880
 881 static void vficon_select_util(ViewFile *vf, IconData *id, gint select)
 882 {
 883         if (select)
 884                 {
 885                 vficon_select(vf, id);
 886                 }
 887         else
 888                 {
 889                 vficon_unselect(vf, id);
 890                 }
 891 }
 892
 893 static void vficon_select_region_util(ViewFile *vf, IconData *start, IconData *end, gint select)
 894 {
 895         gint row1, col1;
 896         gint row2, col2;
 897         gint t;
 898         gint i, j;
 899
 900         if (!vficon_find_position(vf, start, &row1, &col1) ||
 901             !vficon_find_position(vf, end, &row2, &col2) ) return;
 902
 903         VFICON_INFO(vf, prev_selection) = end;
 904
 905         if (!options->collections.rectangular_selection)
 906                 {
 907                 GList *work;
 908                 IconData *id;
 909
 910                 if (g_list_index(vf->list, start) > g_list_index(vf->list, end))
 911                         {
 912                         id = start;
 913                         start = end;
 914                         end = id;
 915                         }
 916
 917                 work = g_list_find(vf->list, start);
 918                 while (work)
 919                         {
 920                         id = work->data;
 921                         vficon_select_util(vf, id, select);
 922
 923                         if (work->data != end)
 924                                 work = work->next;
 925                         else
 926                                 work = NULL;
 927                         }
 928                 return;
 929                 }
 930
 931         if (row2 < row1)
 932                 {
 933                 t = row1;
 934                 row1 = row2;
 935                 row2 = t;
 936                 }
 937         if (col2 < col1)
 938                 {
 939                 t = col1;
 940                 col1 = col2;
 941                 col2 = t;
 942                 }
 943
 944         DEBUG_1("table: %d x %d to %d x %d", row1, col1, row2, col2);
 945
 946         for (i = row1; i <= row2; i++)
 947                 {
 948                 for (j = col1; j <= col2; j++)
 949                         {
 950                         IconData *id = vficon_find_data(vf, i, j, NULL);
 951                         if (id) vficon_select_util(vf, id, select);
 952                         }
 953                 }
 954 }
 955
 956 gint vficon_index_is_selected(ViewFile *vf, gint row)
 957 {
 958         IconData *id = g_list_nth_data(vf->list, row);
 959
 960         if (!id) return FALSE;
 961
 962         return (id->selected & SELECTION_SELECTED);
 963 }
 964
 965 gint vficon_selection_count(ViewFile *vf, gint64 *bytes)
 966 {
 967         if (bytes)
 968                 {
 969                 gint64 b = 0;
 970                 GList *work;
 971
 972                 work = VFICON_INFO(vf, selection);
 973                 while (work)
 974                         {
 975                         IconData *id = work->data;
 976                         FileData *fd = id->fd;
 977                         g_assert(fd->magick == 0x12345678);
 978                         b += fd->size;
 979
 980                         work = work->next;
 981                         }
 982
 983                 *bytes = b;
 984                 }
 985
 986         return g_list_length(VFICON_INFO(vf, selection));
 987 }
 988
 989 GList *vficon_selection_get_list(ViewFile *vf)
 990 {
 991         GList *list = NULL;
 992         GList *work;
 993
 994         work = VFICON_INFO(vf, selection);
 995         while (work)
 996                 {
 997                 IconData *id = work->data;
 998                 FileData *fd = id->fd;
 999                 g_assert(fd->magick == 0x12345678);
1000
1001                 list = g_list_prepend(list, file_data_ref(fd));
1002
1003                 work = work->next;
1004                 }
1005
1006         list = g_list_reverse(list);
1007
1008         return list;
1009 }
1010
1011 GList *vficon_selection_get_list_by_index(ViewFile *vf)
1012 {
1013         GList *list = NULL;
1014         GList *work;
1015
1016         work = VFICON_INFO(vf, selection);
1017         while (work)
1018                 {
1019                 list = g_list_prepend(list, GINT_TO_POINTER(g_list_index(vf->list, work->data)));
1020                 work = work->next;
1021                 }
1022
1023         return g_list_reverse(list);
1024 }
1025
1026 static void vficon_select_by_id(ViewFile *vf, IconData *id)
1027 {
1028         if (!id) return;
1029
1030         if (!(id->selected & SELECTION_SELECTED))
1031                 {
1032                 vficon_select_none(vf);
1033                 vficon_select(vf, id);
1034                 }
1035
1036         vficon_set_focus(vf, id);
1037 }
1038
1039 void vficon_select_by_fd(ViewFile *vf, FileData *fd)
1040 {
1041         IconData *id = NULL;
1042         GList *work;
1043
1044         if (!fd) return;
1045         work = vf->list;
1046         while (work && !id)
1047                 {
1048                 IconData *chk = work->data;
1049                 work = work->next;
1050                 if (chk->fd == fd) id = chk;
1051                 }
1052         vficon_select_by_id(vf, id);
1053 }
1054
1055 void vficon_mark_to_selection(ViewFile *vf, gint mark, MarkToSelectionMode mode)
1056 {
1057         GList *work;
1058
1059         work = vf->list;
1060         while (work)
1061                 {
1062                 IconData *id = work->data;
1063                 FileData *fd = id->fd;
1064                 gboolean mark_val, selected;
1065
1066                 g_assert(fd->magick == 0x12345678);
1067
1068                 mark_val = fd->marks[mark];
1069                 selected = (id->selected & SELECTION_SELECTED);
1070
1071                 switch (mode)
1072                         {
1073                         case MTS_MODE_SET: selected = mark_val;
1074                                 break;
1075                         case MTS_MODE_OR: selected = mark_val | selected;
1076                                 break;
1077                         case MTS_MODE_AND: selected = mark_val & selected;
1078                                 break;
1079                         case MTS_MODE_MINUS: selected = !mark_val & selected;
1080                                 break;
1081                         }
1082
1083                 vficon_select_util(vf, id, selected);
1084
1085                 work = work->next;
1086                 }
1087 }
1088
1089 void vficon_selection_to_mark(ViewFile *vf, gint mark, SelectionToMarkMode mode)
1090 {
1091         GList *slist;
1092         GList *work;
1093
1094         g_assert(mark >= 0 && mark < FILEDATA_MARKS_SIZE);
1095
1096         slist = vficon_selection_get_list(vf);
1097         work = slist;
1098         while (work)
1099                 {
1100                 FileData *fd = work->data;
1101
1102                 switch (mode)
1103                         {
1104                         case STM_MODE_SET: fd->marks[mark] = 1;
1105                                 break;
1106                         case STM_MODE_RESET: fd->marks[mark] = 0;
1107                                 break;
1108                         case STM_MODE_TOGGLE: fd->marks[mark] = !fd->marks[mark];
1109                                 break;
1110                         }
1111
1112                 work = work->next;
1113                 }
1114         filelist_free(slist);
1115 }
1116
1117
1118 /*
1119  *-------------------------------------------------------------------
1120  * focus
1121  *-------------------------------------------------------------------
1122  */
1123
1124 static void vficon_move_focus(ViewFile *vf, gint row, gint col, gint relative)
1125 {
1126         gint new_row;
1127         gint new_col;
1128
1129         if (relative)
1130                 {
1131                 new_row = VFICON_INFO(vf, focus_row);
1132                 new_col = VFICON_INFO(vf, focus_column);
1133
1134                 new_row += row;
1135                 if (new_row < 0) new_row = 0;
1136                 if (new_row >= VFICON_INFO(vf, rows)) new_row = VFICON_INFO(vf, rows) - 1;
1137
1138                 while (col != 0)
1139                         {
1140                         if (col < 0)
1141                                 {
1142                                 new_col--;
1143                                 col++;
1144                                 }
1145                         else
1146                                 {
1147                                 new_col++;
1148                                 col--;
1149                                 }
1150
1151                         if (new_col < 0)
1152                                 {
1153                                 if (new_row > 0)
1154                                         {
1155                                         new_row--;
1156                                         new_col = VFICON_INFO(vf, columns) - 1;
1157                                         }
1158                                 else
1159                                         {
1160                                         new_col = 0;
1161                                         }
1162                                 }
1163                         if (new_col >= VFICON_INFO(vf, columns))
1164                                 {
1165                                 if (new_row < VFICON_INFO(vf, rows) - 1)
1166                                         {
1167                                         new_row++;
1168                                         new_col = 0;
1169                                         }
1170                                 else
1171                                         {
1172                                         new_col = VFICON_INFO(vf, columns) - 1;
1173                                         }
1174                                 }
1175                         }
1176                 }
1177         else
1178                 {
1179                 new_row = row;
1180                 new_col = col;
1181
1182                 if (new_row >= VFICON_INFO(vf, rows))
1183                         {
1184                         if (VFICON_INFO(vf, rows) > 0)
1185                                 new_row = VFICON_INFO(vf, rows) - 1;
1186                         else
1187                                 new_row = 0;
1188                         new_col = VFICON_INFO(vf, columns) - 1;
1189                         }
1190                 if (new_col >= VFICON_INFO(vf, columns)) new_col = VFICON_INFO(vf, columns) - 1;
1191                 }
1192
1193         if (new_row == VFICON_INFO(vf, rows) - 1)
1194                 {
1195                 gint l;
1196
1197                 /* if we moved beyond the last image, go to the last image */
1198
1199                 l = g_list_length(vf->list);
1200                 if (VFICON_INFO(vf, rows) > 1) l -= (VFICON_INFO(vf, rows) - 1) * VFICON_INFO(vf, columns);
1201                 if (new_col >= l) new_col = l - 1;
1202                 }
1203
1204         vficon_set_focus(vf, vficon_find_data(vf, new_row, new_col, NULL));
1205 }
1206
1207 static void vficon_set_focus(ViewFile *vf, IconData *id)
1208 {
1209         GtkTreeIter iter;
1210         gint row, col;
1211
1212         if (g_list_find(vf->list, VFICON_INFO(vf, focus_id)))
1213                 {
1214                 if (id == VFICON_INFO(vf, focus_id))
1215                         {
1216                         /* ensure focus row col are correct */
1217                         vficon_find_position(vf, VFICON_INFO(vf, focus_id), &VFICON_INFO(vf, focus_row), &VFICON_INFO(vf, focus_column));
1218                         return;
1219                         }
1220                 vficon_selection_remove(vf, VFICON_INFO(vf, focus_id), SELECTION_FOCUS, NULL);
1221                 }
1222
1223         if (!vficon_find_position(vf, id, &row, &col))
1224                 {
1225                 VFICON_INFO(vf, focus_id) = NULL;
1226                 VFICON_INFO(vf, focus_row) = -1;
1227                 VFICON_INFO(vf, focus_column) = -1;
1228                 return;
1229                 }
1230
1231         VFICON_INFO(vf, focus_id) = id;
1232         VFICON_INFO(vf, focus_row) = row;
1233         VFICON_INFO(vf, focus_column) = col;
1234         vficon_selection_add(vf, VFICON_INFO(vf, focus_id), SELECTION_FOCUS, NULL);
1235
1236         if (vficon_find_iter(vf, VFICON_INFO(vf, focus_id), &iter, NULL))
1237                 {
1238                 GtkTreePath *tpath;
1239                 GtkTreeViewColumn *column;
1240                 GtkTreeModel *store;
1241
1242                 tree_view_row_make_visible(GTK_TREE_VIEW(vf->listview), &iter, FALSE);
1243
1244                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1245                 tpath = gtk_tree_model_get_path(store, &iter);
1246                 /* focus is set to an extra column with 0 width to hide focus, we draw it ourself */
1247                 column = gtk_tree_view_get_column(GTK_TREE_VIEW(vf->listview), VFICON_MAX_COLUMNS);
1248                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(vf->listview), tpath, column, FALSE);
1249                 gtk_tree_path_free(tpath);
1250                 }
1251 }
1252
1253 static void vficon_update_focus(ViewFile *vf)
1254 {
1255         gint new_row = 0;
1256         gint new_col = 0;
1257
1258         if (VFICON_INFO(vf, focus_id) && vficon_find_position(vf, VFICON_INFO(vf, focus_id), &new_row, &new_col))
1259                 {
1260                 /* first find the old focus, if it exists and is valid */
1261                 }
1262         else
1263                 {
1264                 /* (try to) stay where we were */
1265                 new_row = VFICON_INFO(vf, focus_row);
1266                 new_col = VFICON_INFO(vf, focus_column);
1267                 }
1268
1269         vficon_move_focus(vf, new_row, new_col, FALSE);
1270 }
1271
1272 /* used to figure the page up/down distances */
1273 static gint page_height(ViewFile *vf)
1274 {
1275         GtkAdjustment *adj;
1276         gint page_size;
1277         gint row_height;
1278         gint ret;
1279
1280         adj = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(vf->listview));
1281         page_size = (gint)adj->page_increment;
1282
1283         row_height = options->thumbnails.max_height + THUMB_BORDER_PADDING * 2;
1284         if (VFICON_INFO(vf, show_text)) row_height += options->thumbnails.max_height / 3;
1285
1286         ret = page_size / row_height;
1287         if (ret < 1) ret = 1;
1288
1289         return ret;
1290 }
1291
1292 /*
1293  *-------------------------------------------------------------------
1294  * keyboard
1295  *-------------------------------------------------------------------
1296  */
1297
1298 static void vfi_menu_position_cb(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer data)
1299 {
1300         ViewFile *vf = data;
1301         GtkTreeModel *store;
1302         GtkTreeIter iter;
1303         gint column;
1304         GtkTreePath *tpath;
1305         gint cw, ch;
1306
1307         if (!vficon_find_iter(vf, VFICON_INFO(vf, click_id), &iter, &column)) return;
1308         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1309         tpath = gtk_tree_model_get_path(store, &iter);
1310         tree_view_get_cell_clamped(GTK_TREE_VIEW(vf->listview), tpath, column, FALSE, x, y, &cw, &ch);
1311         gtk_tree_path_free(tpath);
1312         *y += ch;
1313         popup_menu_position_clamp(menu, x, y, 0);
1314 }
1315
1316 gint vficon_press_key_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
1317 {
1318         ViewFile *vf = data;
1319         gint focus_row = 0;
1320         gint focus_col = 0;
1321         IconData *id;
1322         gint stop_signal;
1323
1324         stop_signal = TRUE;
1325         switch (event->keyval)
1326                 {
1327                 case GDK_Left: case GDK_KP_Left:
1328                         focus_col = -1;
1329                         break;
1330                 case GDK_Right: case GDK_KP_Right:
1331                         focus_col = 1;
1332                         break;
1333                 case GDK_Up: case GDK_KP_Up:
1334                         focus_row = -1;
1335                         break;
1336                 case GDK_Down: case GDK_KP_Down:
1337                         focus_row = 1;
1338                         break;
1339                 case GDK_Page_Up: case GDK_KP_Page_Up:
1340                         focus_row = -page_height(vf);
1341                         break;
1342                 case GDK_Page_Down: case GDK_KP_Page_Down:
1343                         focus_row = page_height(vf);
1344                         break;
1345                 case GDK_Home: case GDK_KP_Home:
1346                         focus_row = -VFICON_INFO(vf, focus_row);
1347                         focus_col = -VFICON_INFO(vf, focus_column);
1348                         break;
1349                 case GDK_End: case GDK_KP_End:
1350                         focus_row = VFICON_INFO(vf, rows) - 1 - VFICON_INFO(vf, focus_row);
1351                         focus_col = VFICON_INFO(vf, columns) - 1 - VFICON_INFO(vf, focus_column);
1352                         break;
1353                 case GDK_space:
1354                         id = vficon_find_data(vf, VFICON_INFO(vf, focus_row), VFICON_INFO(vf, focus_column), NULL);
1355                         if (id)
1356                                 {
1357                                 VFICON_INFO(vf, click_id) = id;
1358                                 if (event->state & GDK_CONTROL_MASK)
1359                                         {
1360                                         gint selected;
1361
1362                                         selected = id->selected & SELECTION_SELECTED;
1363                                         if (selected)
1364                                                 {
1365                                                 vficon_unselect(vf, id);
1366                                                 }
1367                                         else
1368                                                 {
1369                                                 vficon_select(vf, id);
1370                                                 vficon_send_layout_select(vf, id);
1371                                                 }
1372                                         }
1373                                 else
1374                                         {
1375                                         vficon_select_none(vf);
1376                                         vficon_select(vf, id);
1377                                         vficon_send_layout_select(vf, id);
1378                                         }
1379                                 }
1380                         break;
1381                 case GDK_Menu:
1382                         id = vficon_find_data(vf, VFICON_INFO(vf, focus_row), VFICON_INFO(vf, focus_column), NULL);
1383                         VFICON_INFO(vf, click_id) = id;
1384
1385                         vficon_selection_add(vf, VFICON_INFO(vf, click_id), SELECTION_PRELIGHT, NULL);
1386                         tip_unschedule(vf);
1387
1388                         vf->popup = vficon_pop_menu(vf, (id != NULL));
1389                         gtk_menu_popup(GTK_MENU(vf->popup), NULL, NULL, vfi_menu_position_cb, vf, 0, GDK_CURRENT_TIME);
1390                         break;
1391                 default:
1392                         stop_signal = FALSE;
1393                         break;
1394                 }
1395
1396         if (focus_row != 0 || focus_col != 0)
1397                 {
1398                 IconData *new_id;
1399                 IconData *old_id;
1400
1401                 old_id = vficon_find_data(vf, VFICON_INFO(vf, focus_row), VFICON_INFO(vf, focus_column), NULL);
1402                 vficon_move_focus(vf, focus_row, focus_col, TRUE);
1403                 new_id = vficon_find_data(vf, VFICON_INFO(vf, focus_row), VFICON_INFO(vf, focus_column), NULL);
1404
1405                 if (new_id != old_id)
1406                         {
1407                         if (event->state & GDK_SHIFT_MASK)
1408                                 {
1409                                 if (!options->collections.rectangular_selection)
1410                                         {
1411                                         vficon_select_region_util(vf, old_id, new_id, FALSE);
1412                                         }
1413                                 else
1414                                         {
1415                                         vficon_select_region_util(vf, VFICON_INFO(vf, click_id), old_id, FALSE);
1416                                         }
1417                                 vficon_select_region_util(vf, VFICON_INFO(vf, click_id), new_id, TRUE);
1418                                 vficon_send_layout_select(vf, new_id);
1419                                 }
1420                         else if (event->state & GDK_CONTROL_MASK)
1421                                 {
1422                                 VFICON_INFO(vf, click_id) = new_id;
1423                                 }
1424                         else
1425                                 {
1426                                 VFICON_INFO(vf, click_id) = new_id;
1427                                 vficon_select_none(vf);
1428                                 vficon_select(vf, new_id);
1429                                 vficon_send_layout_select(vf, new_id);
1430                                 }
1431                         }
1432                 }
1433
1434         if (stop_signal)
1435                 {
1436 #if 0
1437                 g_signal_stop_emission_by_name(GTK_OBJECT(widget), "key_press_event");
1438 #endif
1439                 tip_unschedule(vf);
1440                 }
1441
1442         return stop_signal;
1443 }
1444
1445 /*
1446  *-------------------------------------------------------------------
1447  * mouse
1448  *-------------------------------------------------------------------
1449  */
1450
1451 static gint vficon_motion_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1452 {
1453         ViewFile *vf = data;
1454         IconData *id;
1455
1456         id = vficon_find_data_by_coord(vf, (gint)bevent->x, (gint)bevent->y, NULL);
1457         tip_update(vf, id);
1458
1459         return FALSE;
1460 }
1461
1462 gint vficon_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1463 {
1464         ViewFile *vf = data;
1465         GtkTreeIter iter;
1466         IconData *id;
1467
1468         tip_unschedule(vf);
1469
1470         id = vficon_find_data_by_coord(vf, (gint)bevent->x, (gint)bevent->y, &iter);
1471
1472         VFICON_INFO(vf, click_id) = id;
1473         vficon_selection_add(vf, VFICON_INFO(vf, click_id), SELECTION_PRELIGHT, &iter);
1474
1475         switch (bevent->button)
1476                 {
1477                 case MOUSE_BUTTON_LEFT:
1478                         if (!GTK_WIDGET_HAS_FOCUS(vf->listview))
1479                                 {
1480                                 gtk_widget_grab_focus(vf->listview);
1481                                 }
1482 #if 0
1483                         if (bevent->type == GDK_2BUTTON_PRESS &&
1484                             vf->layout)
1485                                 {
1486                                 vficon_selection_remove(vf, VFICON_INFO(vf, click_id), SELECTION_PRELIGHT, &iter);
1487                                 layout_image_full_screen_start(vf->layout);
1488                                 }
1489 #endif
1490                         break;
1491                 case MOUSE_BUTTON_RIGHT:
1492                         vf->popup = vficon_pop_menu(vf, (id != NULL));
1493                         gtk_menu_popup(GTK_MENU(vf->popup), NULL, NULL, NULL, NULL, bevent->button, bevent->time);
1494                         break;
1495                 default:
1496                         break;
1497                 }
1498
1499         return TRUE;
1500 }
1501
1502 gint vficon_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1503 {
1504         ViewFile *vf = data;
1505         GtkTreeIter iter;
1506         IconData *id = NULL;
1507         gint was_selected;
1508
1509         tip_schedule(vf);
1510
1511         if ((gint)bevent->x != 0 || (gint)bevent->y != 0)
1512                 {
1513                 id = vficon_find_data_by_coord(vf, (gint)bevent->x, (gint)bevent->y, &iter);
1514                 }
1515
1516         if (VFICON_INFO(vf, click_id))
1517                 {
1518                 vficon_selection_remove(vf, VFICON_INFO(vf, click_id), SELECTION_PRELIGHT, NULL);
1519                 }
1520
1521         if (!id || VFICON_INFO(vf, click_id) != id) return TRUE;
1522
1523         was_selected = (id->selected & SELECTION_SELECTED);
1524
1525         switch (bevent->button)
1526                 {
1527                 case MOUSE_BUTTON_LEFT:
1528                         {
1529                         vficon_set_focus(vf, id);
1530
1531                         if (bevent->state & GDK_CONTROL_MASK)
1532                                 {
1533                                 gint select;
1534
1535                                 select = !(id->selected & SELECTION_SELECTED);
1536                                 if ((bevent->state & GDK_SHIFT_MASK) && VFICON_INFO(vf, prev_selection))
1537                                         {
1538                                         vficon_select_region_util(vf, VFICON_INFO(vf, prev_selection), id, select);
1539                                         }
1540                                 else
1541                                         {
1542                                         vficon_select_util(vf, id, select);
1543                                         }
1544                                 }
1545                         else
1546                                 {
1547                                 vficon_select_none(vf);
1548
1549                                 if ((bevent->state & GDK_SHIFT_MASK) && VFICON_INFO(vf, prev_selection))
1550                                         {
1551                                         vficon_select_region_util(vf, VFICON_INFO(vf, prev_selection), id, TRUE);
1552                                         }
1553                                 else
1554                                         {
1555                                         vficon_select_util(vf, id, TRUE);
1556                                         was_selected = FALSE;
1557                                         }
1558                                 }
1559                         }
1560                         break;
1561                 case MOUSE_BUTTON_MIDDLE:
1562                         {
1563                         vficon_select_util(vf, id, !(id->selected & SELECTION_SELECTED));
1564                         }
1565                         break;
1566                 default:
1567                         break;
1568                 }
1569
1570         if (!was_selected && (id->selected & SELECTION_SELECTED))
1571                 {
1572                 vficon_send_layout_select(vf, id);
1573                 }
1574
1575         return TRUE;
1576 }
1577
1578 static gint vficon_leave_cb(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
1579 {
1580         ViewFile *vf = data;
1581
1582         tip_unschedule(vf);
1583         return FALSE;
1584 }
1585
1586 /*
1587  *-------------------------------------------------------------------
1588  * population
1589  *-------------------------------------------------------------------
1590  */
1591
1592 static gboolean vficon_destroy_node_cb(GtkTreeModel *store, GtkTreePath *tpath, GtkTreeIter *iter, gpointer data)
1593 {
1594         GList *list;
1595
1596         gtk_tree_model_get(store, iter, FILE_COLUMN_POINTER, &list, -1);
1597         g_list_free(list);
1598
1599         return FALSE;
1600 }
1601
1602 static void vficon_clear_store(ViewFile *vf)
1603 {
1604         GtkTreeModel *store;
1605
1606         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1607         gtk_tree_model_foreach(store, vficon_destroy_node_cb, NULL);
1608
1609         gtk_list_store_clear(GTK_LIST_STORE(store));
1610 }
1611
1612 static void vficon_set_thumb(ViewFile *vf, FileData *fd, GdkPixbuf *pb)
1613 {
1614         GtkTreeModel *store;
1615         GtkTreeIter iter;
1616         GList *list;
1617
1618         if (!vficon_find_iter(vf, vficon_icon_data(vf, fd), &iter, NULL)) return;
1619
1620         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1621
1622         if (pb) g_object_ref(pb);
1623         if (fd->pixbuf) g_object_unref(fd->pixbuf);
1624         fd->pixbuf = pb;
1625
1626         gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1627         gtk_list_store_set(GTK_LIST_STORE(store), &iter, FILE_COLUMN_POINTER, list, -1);
1628 }
1629
1630 static GList *vficon_add_row(ViewFile *vf, GtkTreeIter *iter)
1631 {
1632         GtkListStore *store;
1633         GList *list = NULL;
1634         gint i;
1635
1636         for (i = 0; i < VFICON_INFO(vf, columns); i++) list = g_list_prepend(list, NULL);
1637
1638         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview)));
1639         gtk_list_store_append(store, iter);
1640         gtk_list_store_set(store, iter, FILE_COLUMN_POINTER, list, -1);
1641
1642         return list;
1643 }
1644
1645 static void vficon_populate(ViewFile *vf, gint resize, gint keep_position)
1646 {
1647         GtkTreeModel *store;
1648         GtkTreePath *tpath;
1649         gint row;
1650         GList *work;
1651         IconData *visible_id = NULL;
1652
1653         vficon_verify_selections(vf);
1654
1655         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1656
1657         if (keep_position && GTK_WIDGET_REALIZED(vf->listview) &&
1658             gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
1659                 {
1660                 GtkTreeIter iter;
1661                 GList *list;
1662
1663                 gtk_tree_model_get_iter(store, &iter, tpath);
1664                 gtk_tree_path_free(tpath);
1665
1666                 gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1667                 if (list) visible_id = list->data;
1668                 }
1669
1670         vficon_clear_store(vf);
1671
1672         if (resize)
1673                 {
1674                 gint i;
1675                 gint thumb_width;
1676
1677                 thumb_width = vficon_get_icon_width(vf);
1678
1679                 for (i = 0; i < VFICON_MAX_COLUMNS; i++)
1680                         {
1681                         GtkTreeViewColumn *column;
1682                         GtkCellRenderer *cell;
1683                         GList *list;
1684
1685                         column = gtk_tree_view_get_column(GTK_TREE_VIEW(vf->listview), i);
1686                         gtk_tree_view_column_set_visible(column, (i < VFICON_INFO(vf, columns)));
1687                         gtk_tree_view_column_set_fixed_width(column, thumb_width + (THUMB_BORDER_PADDING * 6));
1688
1689                         list = gtk_tree_view_column_get_cell_renderers(column);
1690                         cell = (list) ? list->data : NULL;
1691                         g_list_free(list);
1692
1693                         if (cell && GQV_IS_CELL_RENDERER_ICON(cell))
1694                                 {
1695                                 g_object_set(G_OBJECT(cell), "fixed_width", thumb_width,
1696                                                              "fixed_height", options->thumbnails.max_height,
1697                                                              "show_text", VFICON_INFO(vf, show_text), NULL);
1698                                 }
1699                         }
1700                 if (GTK_WIDGET_REALIZED(vf->listview)) gtk_tree_view_columns_autosize(GTK_TREE_VIEW(vf->listview));
1701                 }
1702
1703         row = -1;
1704         work = vf->list;
1705         while (work)
1706                 {
1707                 GList *list;
1708                 GtkTreeIter iter;
1709
1710                 row++;
1711
1712                 list = vficon_add_row(vf, &iter);
1713                 while (work && list)
1714                         {
1715                         IconData *id;
1716
1717                         id = work->data;
1718                         id->row = row;
1719
1720                         list->data = work->data;
1721                         list = list->next;
1722                         work = work->next;
1723                         }
1724                 }
1725
1726         if (visible_id &&
1727             gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
1728                 {
1729                 GtkTreeIter iter;
1730                 GList *list;
1731
1732                 gtk_tree_model_get_iter(store, &iter, tpath);
1733                 gtk_tree_path_free(tpath);
1734
1735                 gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1736                 if (g_list_find(list, visible_id) == NULL &&
1737                     vficon_find_iter(vf, visible_id, &iter, NULL))
1738                         {
1739                         tree_view_row_make_visible(GTK_TREE_VIEW(vf->listview), &iter, FALSE);
1740                         }
1741                 }
1742
1743         VFICON_INFO(vf, rows) = row + 1;
1744
1745         vficon_send_update(vf);
1746         vficon_thumb_update(vf);
1747 }
1748
1749 static void vficon_populate_at_new_size(ViewFile *vf, gint w, gint h, gint force)
1750 {
1751         gint new_cols;
1752         gint thumb_width;
1753
1754         thumb_width = vficon_get_icon_width(vf);
1755
1756         new_cols = w / (thumb_width + (THUMB_BORDER_PADDING * 6));
1757         if (new_cols < 1) new_cols = 1;
1758
1759         if (!force && new_cols == VFICON_INFO(vf, columns)) return;
1760
1761         VFICON_INFO(vf, columns) = new_cols;
1762
1763         vficon_populate(vf, TRUE, TRUE);
1764
1765         DEBUG_1("col tab pop cols=%d rows=%d", VFICON_INFO(vf, columns), VFICON_INFO(vf, rows));
1766 }
1767
1768 static void vficon_sync(ViewFile *vf)
1769 {
1770         GtkTreeModel *store;
1771         GtkTreeIter iter;
1772         GList *work;
1773         gint r, c;
1774
1775         if (VFICON_INFO(vf, rows) == 0) return;
1776
1777         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1778
1779         r = -1;
1780         c = 0;
1781
1782         work = vf->list;
1783         while (work)
1784                 {
1785                 GList *list;
1786                 r++;
1787                 c = 0;
1788                 if (gtk_tree_model_iter_nth_child(store, &iter, NULL, r))
1789                         {
1790                         gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1791                         gtk_list_store_set(GTK_LIST_STORE(store), &iter, FILE_COLUMN_POINTER, list, -1);
1792                         }
1793                 else
1794                         {
1795                         list = vficon_add_row(vf, &iter);
1796                         }
1797
1798                 while (list)
1799                         {
1800                         IconData *id;
1801
1802                         if (work)
1803                                 {
1804                                 id = work->data;
1805                                 work = work->next;
1806                                 c++;
1807
1808                                 id->row = r;
1809                                 }
1810                         else
1811                                 {
1812                                 id = NULL;
1813                                 }
1814
1815                         list->data = id;
1816                         list = list->next;
1817                         }
1818                 }
1819
1820         r++;
1821         while (gtk_tree_model_iter_nth_child(store, &iter, NULL, r))
1822                 {
1823                 GList *list;
1824
1825                 gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1826                 gtk_list_store_remove(GTK_LIST_STORE(store), &iter);
1827                 g_list_free(list);
1828                 }
1829
1830         VFICON_INFO(vf, rows) = r;
1831
1832         vficon_update_focus(vf);
1833 }
1834
1835 static gint vficon_sync_idle_cb(gpointer data)
1836 {
1837         ViewFile *vf = data;
1838
1839         if (VFICON_INFO(vf, sync_idle_id) == -1) return FALSE;
1840         VFICON_INFO(vf, sync_idle_id) = -1;
1841
1842         vficon_sync(vf);
1843         return FALSE;
1844 }
1845
1846 static void vficon_sync_idle(ViewFile *vf)
1847 {
1848         if (VFICON_INFO(vf, sync_idle_id) == -1)
1849                 {
1850                 /* high priority, the view needs to be resynced before a redraw
1851                  * may contain invalid pointers at this time
1852                  */
1853                 VFICON_INFO(vf, sync_idle_id) = g_idle_add_full(G_PRIORITY_HIGH, vficon_sync_idle_cb, vf, NULL);
1854                 }
1855 }
1856
1857 static void vficon_sized_cb(GtkWidget *widget, GtkAllocation *allocation, gpointer data)
1858 {
1859         ViewFile *vf = data;
1860
1861         vficon_populate_at_new_size(vf, allocation->width, allocation->height, FALSE);
1862 }
1863
1864 /*
1865  *-----------------------------------------------------------------------------
1866  * misc
1867  *-----------------------------------------------------------------------------
1868  */
1869
1870 void vficon_sort_set(ViewFile *vf, SortType type, gint ascend)
1871 {
1872         if (vf->sort_method == type && vf->sort_ascend == ascend) return;
1873
1874         vf->sort_method = type;
1875         vf->sort_ascend = ascend;
1876
1877         if (!vf->list) return;
1878
1879         vf->list = iconlist_sort(vf->list, vf->sort_method, vf->sort_ascend);
1880         vficon_sync(vf);
1881 }
1882
1883 /*
1884  *-----------------------------------------------------------------------------
1885  * thumb updates
1886  *-----------------------------------------------------------------------------
1887  */
1888
1889 static gint vficon_thumb_next(ViewFile *vf);
1890
1891 static void vficon_thumb_status(ViewFile *vf, gdouble val, const gchar *text)
1892 {
1893         if (vf->func_thumb_status)
1894                 {
1895                 vf->func_thumb_status(vf, val, text, vf->data_thumb_status);
1896                 }
1897 }
1898
1899 static void vficon_thumb_cleanup(ViewFile *vf)
1900 {
1901         vficon_thumb_status(vf, 0.0, NULL);
1902
1903         vf->thumbs_count = 0;
1904         vf->thumbs_running = FALSE;
1905
1906         thumb_loader_free(vf->thumbs_loader);
1907         vf->thumbs_loader = NULL;
1908
1909         vf->thumbs_filedata = NULL;
1910 }
1911
1912 static void vficon_thumb_stop(ViewFile *vf)
1913 {
1914         if (vf->thumbs_running) vficon_thumb_cleanup(vf);
1915 }
1916
1917 static void vficon_thumb_do(ViewFile *vf, ThumbLoader *tl, FileData *fd)
1918 {
1919         GdkPixbuf *pixbuf;
1920
1921         if (!fd) return;
1922
1923         pixbuf = thumb_loader_get_pixbuf(tl, TRUE);
1924         vficon_set_thumb(vf, fd, pixbuf);
1925         g_object_unref(pixbuf);
1926
1927         vficon_thumb_status(vf, (gdouble)(vf->thumbs_count) / g_list_length(vf->list), _("Loading thumbs..."));
1928 }
1929
1930 static void vficon_thumb_error_cb(ThumbLoader *tl, gpointer data)
1931 {
1932         ViewFile *vf = data;
1933
1934         if (vf->thumbs_filedata && vf->thumbs_loader == tl)
1935                 {
1936                 vficon_thumb_do(vf, tl, vf->thumbs_filedata);
1937                 }
1938
1939         while (vficon_thumb_next(vf));
1940 }
1941
1942 static void vficon_thumb_done_cb(ThumbLoader *tl, gpointer data)
1943 {
1944         ViewFile *vf = data;
1945
1946         if (vf->thumbs_filedata && vf->thumbs_loader == tl)
1947                 {
1948                 vficon_thumb_do(vf, tl, vf->thumbs_filedata);
1949                 }
1950
1951         while (vficon_thumb_next(vf));
1952 }
1953
1954 static gint vficon_thumb_next(ViewFile *vf)
1955 {
1956         GtkTreePath *tpath;
1957         FileData *fd = NULL;
1958
1959         if (!GTK_WIDGET_REALIZED(vf->listview))
1960                 {
1961                 vficon_thumb_status(vf, 0.0, NULL);
1962                 return FALSE;
1963                 }
1964
1965         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
1966                 {
1967                 GtkTreeModel *store;
1968                 GtkTreeIter iter;
1969                 gint valid = TRUE;
1970
1971                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1972                 gtk_tree_model_get_iter(store, &iter, tpath);
1973                 gtk_tree_path_free(tpath);
1974
1975                 while (!fd && valid && tree_view_row_get_visibility(GTK_TREE_VIEW(vf->listview), &iter, FALSE) == 0)
1976                         {
1977                         GList *list;
1978
1979                         gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1980
1981                         while (!fd && list)
1982                                 {
1983                                 IconData *id = list->data;
1984                                 if (id && !id->fd->pixbuf) fd = id->fd;
1985                                 list = list->next;
1986                                 }
1987
1988                         valid = gtk_tree_model_iter_next(store, &iter);
1989                         }
1990                 }
1991
1992         /* then find first undone */
1993
1994         if (!fd)
1995                 {
1996                 GList *work = vf->list;
1997                 while (work && !fd)
1998                         {
1999                         IconData *id = work->data;
2000                         FileData *fd_p = id->fd;
2001                         work = work->next;
2002
2003                         if (!fd_p->pixbuf) fd = fd_p;
2004                         }
2005                 }
2006
2007         if (!fd)
2008                 {
2009                 /* done */
2010                 vficon_thumb_cleanup(vf);
2011                 return FALSE;
2012                 }
2013
2014         vf->thumbs_count++;
2015
2016         vf->thumbs_filedata = fd;
2017
2018         thumb_loader_free(vf->thumbs_loader);
2019
2020         vf->thumbs_loader = thumb_loader_new(options->thumbnails.max_width, options->thumbnails.max_height);
2021         thumb_loader_set_callbacks(vf->thumbs_loader,
2022                                    vficon_thumb_done_cb,
2023                                    vficon_thumb_error_cb,
2024                                    NULL,
2025                                    vf);
2026
2027         if (!thumb_loader_start(vf->thumbs_loader, fd->path))
2028                 {
2029                 /* set icon to unknown, continue */
2030                 DEBUG_1("thumb loader start failed %s", vf->thumbs_loader->path);
2031                 vficon_thumb_do(vf, vf->thumbs_loader, fd);
2032
2033                 return TRUE;
2034                 }
2035
2036         return FALSE;
2037 }
2038
2039 static void vficon_thumb_update(ViewFile *vf)
2040 {
2041         vficon_thumb_stop(vf);
2042
2043         vficon_thumb_status(vf, 0.0, _("Loading thumbs..."));
2044         vf->thumbs_running = TRUE;
2045
2046         while (vficon_thumb_next(vf));
2047 }
2048
2049 /*
2050  *-----------------------------------------------------------------------------
2051  * row stuff
2052  *-----------------------------------------------------------------------------
2053  */
2054
2055 FileData *vficon_index_get_data(ViewFile *vf, gint row)
2056 {
2057         IconData *id;
2058
2059         id = g_list_nth_data(vf->list, row);
2060         return id ? id->fd : NULL;
2061 }
2062
2063 gchar *vficon_index_get_path(ViewFile *vf, gint row)
2064 {
2065         FileData *fd;
2066         IconData *id;
2067
2068         id = g_list_nth_data(vf->list, row);
2069         fd = id ? id->fd : NULL;
2070
2071         return (fd ? fd->path : NULL);
2072 }
2073
2074 gint vficon_index_by_path(ViewFile *vf, const gchar *path)
2075 {
2076         gint p = 0;
2077         GList *work;
2078
2079         if (!path) return -1;
2080
2081         work = vf->list;
2082         while (work)
2083                 {
2084                 IconData *id = work->data;
2085                 FileData *fd = id->fd;
2086                 if (strcmp(path, fd->path) == 0) return p;
2087                 work = work->next;
2088                 p++;
2089                 }
2090
2091         return -1;
2092 }
2093
2094 gint vficon_index_by_fd(ViewFile *vf, FileData *in_fd)
2095 {
2096         gint p = 0;
2097         GList *work;
2098
2099         if (!in_fd) return -1;
2100
2101         work = vf->list;
2102         while (work)
2103                 {
2104                 IconData *id = work->data;
2105                 FileData *fd = id->fd;
2106                 if (fd == in_fd) return p;
2107                 work = work->next;
2108                 p++;
2109                 }
2110
2111         return -1;
2112 }
2113
2114 static gint vficon_index_by_id(ViewFile *vf, IconData *in_id)
2115 {
2116         gint p = 0;
2117         GList *work;
2118
2119         if (!in_id) return -1;
2120
2121         work = vf->list;
2122         while (work)
2123                 {
2124                 IconData *id = work->data;
2125                 if (id == in_id) return p;
2126                 work = work->next;
2127                 p++;
2128                 }
2129
2130         return -1;
2131 }
2132
2133 gint vficon_count(ViewFile *vf, gint64 *bytes)
2134 {
2135         if (bytes)
2136                 {
2137                 gint64 b = 0;
2138                 GList *work;
2139
2140                 work = vf->list;
2141                 while (work)
2142                         {
2143                         IconData *id = work->data;
2144                         FileData *fd = id->fd;
2145                         work = work->next;
2146
2147                         b += fd->size;
2148                         }
2149
2150                 *bytes = b;
2151                 }
2152
2153         return g_list_length(vf->list);
2154 }
2155
2156 GList *vficon_get_list(ViewFile *vf)
2157 {
2158         GList *list = NULL;
2159         GList *work;
2160
2161         work = vf->list;
2162         while (work)
2163                 {
2164                 IconData *id = work->data;
2165                 FileData *fd = id->fd;
2166                 work = work->next;
2167
2168                 list = g_list_prepend(list, file_data_ref(fd));
2169                 }
2170
2171         return g_list_reverse(list);
2172 }
2173
2174 /*
2175  *-----------------------------------------------------------------------------
2176  *
2177  *-----------------------------------------------------------------------------
2178  */
2179
2180 static gint vficon_refresh_real(ViewFile *vf, gint keep_position)
2181 {
2182         gint ret = TRUE;
2183         GList *old_list;
2184         GList *work;
2185         IconData *focus_id;
2186
2187         focus_id = VFICON_INFO(vf, focus_id);
2188
2189         old_list = vf->list;
2190         vf->list = NULL;
2191
2192         if (vf->path)
2193                 {
2194                 ret = iconlist_read(vf->path, &vf->list);
2195                 }
2196
2197         /* check for same files from old_list */
2198         work = old_list;
2199         while (work)
2200                 {
2201                 IconData *id = work->data;
2202                 FileData *fd = id->fd;
2203                 GList *needle = vf->list;
2204
2205                 while (needle)
2206                         {
2207                         IconData *idn = needle->data;
2208                         FileData *fdn = idn->fd;
2209
2210                         if (fdn == fd)
2211                                 {
2212                                 /* swap, to retain old thumb, selection */
2213                                 needle->data = id;
2214                                 work->data = idn;
2215                                 needle = NULL;
2216                                 }
2217                         else
2218                                 {
2219                                 needle = needle->next;
2220                                 }
2221                         }
2222
2223                 work = work->next;
2224                 }
2225
2226         vf->list = iconlist_sort(vf->list, vf->sort_method, vf->sort_ascend);
2227
2228         work = old_list;
2229         while (work)
2230                 {
2231                 IconData *id = work->data;
2232                 work = work->next;
2233
2234                 if (id == VFICON_INFO(vf, prev_selection)) VFICON_INFO(vf, prev_selection) = NULL;
2235                 if (id == VFICON_INFO(vf, click_id)) VFICON_INFO(vf, click_id) = NULL;
2236                 }
2237
2238         vficon_populate(vf, TRUE, keep_position);
2239
2240         /* attempt to keep focus on same icon when refreshing */
2241         if (focus_id && g_list_find(vf->list, focus_id))
2242                 {
2243                 vficon_set_focus(vf, focus_id);
2244                 }
2245
2246         iconlist_free(old_list);
2247
2248         return ret;
2249 }
2250
2251 gint vficon_refresh(ViewFile *vf)
2252 {
2253         return vficon_refresh_real(vf, TRUE);
2254 }
2255
2256 /*
2257  *-----------------------------------------------------------------------------
2258  * draw, etc.
2259  *-----------------------------------------------------------------------------
2260  */
2261
2262 typedef struct _ColumnData ColumnData;
2263 struct _ColumnData
2264 {
2265         ViewFile *vf;
2266         gint number;
2267 };
2268
2269 static void vficon_cell_data_cb(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
2270                                 GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
2271 {
2272         ColumnData *cd = data;
2273         ViewFile *vf;
2274         GtkStyle *style;
2275         GList *list;
2276         GdkColor color_fg;
2277         GdkColor color_bg;
2278         IconData *id;
2279
2280         vf = cd->vf;
2281
2282         gtk_tree_model_get(tree_model, iter, FILE_COLUMN_POINTER, &list, -1);
2283
2284         id = g_list_nth_data(list, cd->number);
2285
2286         if (id) g_assert(id->fd->magick == 0x12345678);
2287
2288         style = gtk_widget_get_style(vf->listview);
2289         if (id && id->selected & SELECTION_SELECTED)
2290                 {
2291                 memcpy(&color_fg, &style->text[GTK_STATE_SELECTED], sizeof(color_fg));
2292                 memcpy(&color_bg, &style->base[GTK_STATE_SELECTED], sizeof(color_bg));
2293                 }
2294         else
2295                 {
2296                 memcpy(&color_fg, &style->text[GTK_STATE_NORMAL], sizeof(color_fg));
2297                 memcpy(&color_bg, &style->base[GTK_STATE_NORMAL], sizeof(color_bg));
2298                 }
2299
2300         if (id && id->selected & SELECTION_PRELIGHT)
2301                 {
2302 #if 0
2303                 shift_color(&color_fg, -1, 0);
2304 #endif
2305                 shift_color(&color_bg, -1, 0);
2306                 }
2307
2308         if (GQV_IS_CELL_RENDERER_ICON(cell))
2309                 {
2310                 if (id)
2311                         {
2312                         g_object_set(cell,      "pixbuf", id->fd->pixbuf,
2313                                                 "text", id->fd->name,
2314                                                 "cell-background-gdk", &color_bg,
2315                                                 "cell-background-set", TRUE,
2316                                                 "foreground-gdk", &color_fg,
2317                                                 "foreground-set", TRUE,
2318                                                 "has-focus", (VFICON_INFO(vf, focus_id) == id), NULL);
2319                         }
2320                 else
2321                         {
2322                         g_object_set(cell,      "pixbuf", NULL,
2323                                                 "text", NULL,
2324                                                 "cell-background-set", FALSE,
2325                                                 "foreground-set", FALSE,
2326                                                 "has-focus", FALSE, NULL);
2327                         }
2328                 }
2329 }
2330
2331 static void vficon_append_column(ViewFile *vf, gint n)
2332 {
2333         ColumnData *cd;
2334         GtkTreeViewColumn *column;
2335         GtkCellRenderer *renderer;
2336
2337         column = gtk_tree_view_column_new();
2338         gtk_tree_view_column_set_min_width(column, 0);
2339
2340         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
2341         gtk_tree_view_column_set_alignment(column, 0.5);
2342
2343         renderer = gqv_cell_renderer_icon_new();
2344         gtk_tree_view_column_pack_start(column, renderer, FALSE);
2345         g_object_set(G_OBJECT(renderer), "xpad", THUMB_BORDER_PADDING * 2,
2346                                          "ypad", THUMB_BORDER_PADDING,
2347                                          "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
2348
2349         g_object_set_data(G_OBJECT(column), "column_number", GINT_TO_POINTER(n));
2350
2351         cd = g_new0(ColumnData, 1);
2352         cd->vf = vf;
2353         cd->number = n;
2354         gtk_tree_view_column_set_cell_data_func(column, renderer, vficon_cell_data_cb, cd, g_free);
2355
2356         gtk_tree_view_append_column(GTK_TREE_VIEW(vf->listview), column);
2357 }
2358
2359 /*
2360  *-----------------------------------------------------------------------------
2361  * base
2362  *-----------------------------------------------------------------------------
2363  */
2364
2365 gint vficon_set_path(ViewFile *vf, const gchar *path)
2366 {
2367         gint ret;
2368
2369         if (!path) return FALSE;
2370         if (vf->path && strcmp(path, vf->path) == 0) return TRUE;
2371
2372         g_free(vf->path);
2373         vf->path = g_strdup(path);
2374
2375         g_list_free(VFICON_INFO(vf, selection));
2376         VFICON_INFO(vf, selection) = NULL;
2377
2378         iconlist_free(vf->list);
2379         vf->list = NULL;
2380
2381         /* NOTE: populate will clear the store for us */
2382         ret = vficon_refresh_real(vf, FALSE);
2383
2384         VFICON_INFO(vf, focus_id) = NULL;
2385         vficon_move_focus(vf, 0, 0, FALSE);
2386
2387         return ret;
2388 }
2389
2390 void vficon_destroy_cb(GtkWidget *widget, gpointer data)
2391 {
2392         ViewFile *vf = data;
2393
2394         if (VFICON_INFO(vf, sync_idle_id) != -1) g_source_remove(VFICON_INFO(vf, sync_idle_id));
2395
2396         tip_unschedule(vf);
2397
2398         vficon_thumb_cleanup(vf);
2399
2400         iconlist_free(vf->list);
2401         g_list_free(VFICON_INFO(vf, selection));
2402 }
2403
2404 ViewFile *vficon_new(ViewFile *vf, const gchar *path)
2405 {
2406         GtkListStore *store;
2407         GtkTreeSelection *selection;
2408         gint i;
2409
2410         vf->info = g_new0(ViewFileInfoIcon, 1);
2411
2412         VFICON_INFO(vf, selection) = NULL;
2413         VFICON_INFO(vf, prev_selection) = NULL;
2414
2415         VFICON_INFO(vf, tip_window) = NULL;
2416         VFICON_INFO(vf, tip_delay_id) = -1;
2417
2418         VFICON_INFO(vf, focus_row) = 0;
2419         VFICON_INFO(vf, focus_column) = 0;
2420         VFICON_INFO(vf, focus_id) = NULL;
2421
2422         VFICON_INFO(vf, show_text) = options->show_icon_names;
2423
2424         VFICON_INFO(vf, sync_idle_id) = -1;
2425
2426         store = gtk_list_store_new(1, G_TYPE_POINTER);
2427         vf->listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
2428         g_object_unref(store);
2429
2430         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vf->listview));
2431         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_NONE);
2432
2433         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(vf->listview), FALSE);
2434         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(vf->listview), FALSE);
2435
2436         for (i = 0; i < VFICON_MAX_COLUMNS; i++)
2437                 {
2438                 vficon_append_column(vf, i);
2439                 }
2440
2441         /* zero width column to hide tree view focus, we draw it ourselves */
2442         vficon_append_column(vf, i);
2443         /* end column to fill white space */
2444         vficon_append_column(vf, i);
2445
2446         g_signal_connect(G_OBJECT(vf->listview), "size_allocate",
2447                          G_CALLBACK(vficon_sized_cb), vf);
2448
2449         gtk_widget_set_events(vf->listview, GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK |
2450                               GDK_BUTTON_PRESS_MASK | GDK_LEAVE_NOTIFY_MASK);
2451
2452         g_signal_connect(G_OBJECT(vf->listview),"motion_notify_event",
2453                          G_CALLBACK(vficon_motion_cb), vf);
2454         g_signal_connect(G_OBJECT(vf->listview), "leave_notify_event",
2455                          G_CALLBACK(vficon_leave_cb), vf);
2456
2457         /* force VFICON_INFO(vf, columns) to be at least 1 (sane) - this will be corrected in the size_cb */
2458         vficon_populate_at_new_size(vf, 1, 1, FALSE);
2459
2460         return vf;
2461 }
2462
2463 /*
2464  *-----------------------------------------------------------------------------
2465  * maintenance (for rename, move, remove)
2466  *-----------------------------------------------------------------------------
2467  */
2468
2469 static gint vficon_maint_find_closest(ViewFile *vf, gint row, gint count, GList *ignore_list)
2470 {
2471         GList *list = NULL;
2472         GList *work;
2473         gint rev = row - 1;
2474
2475         row++;
2476
2477         work = ignore_list;
2478         while (work)
2479                 {
2480                 FileData *fd = work->data;
2481                 gint f = vficon_index_by_fd(vf, fd);
2482                 g_assert(fd->magick == 0x12345678);
2483
2484                 if (f >= 0) list = g_list_prepend(list, GINT_TO_POINTER(f));
2485                 work = work->next;
2486                 }
2487
2488         while (list)
2489                 {
2490                 gint c = TRUE;
2491
2492                 work = list;
2493                 while (work && c)
2494                         {
2495                         gpointer p = work->data;
2496
2497                         work = work->next;
2498                         if (row == GPOINTER_TO_INT(p))
2499                                 {
2500                                 row++;
2501                                 c = FALSE;
2502                                 }
2503                         if (rev == GPOINTER_TO_INT(p))
2504                                 {
2505                                 rev--;
2506                                 c = FALSE;
2507                                 }
2508                         if (!c) list = g_list_remove(list, p);
2509                         }
2510
2511                 if (c && list)
2512                         {
2513                         g_list_free(list);
2514                         list = NULL;
2515                         }
2516                 }
2517
2518         if (row > count - 1)
2519                 {
2520                 if (rev < 0)
2521                         return -1;
2522                 else
2523                         return rev;
2524                 }
2525         else
2526                 {
2527                 return row;
2528                 }
2529 }
2530
2531 gint vficon_maint_renamed(ViewFile *vf, FileData *fd)
2532 {
2533         gint ret = FALSE;
2534         gint row;
2535         gchar *source_base;
2536         gchar *dest_base;
2537         IconData *id = vficon_icon_data(vf, fd);
2538
2539         if (!id) return FALSE;
2540
2541         row = vficon_index_by_id(vf, id);
2542         if (row < 0) return FALSE;
2543
2544         source_base = remove_level_from_path(fd->change->source);
2545         dest_base = remove_level_from_path(fd->change->dest);
2546
2547         if (strcmp(source_base, dest_base) == 0)
2548                 {
2549                 vf->list = g_list_remove(vf->list, id);
2550                 vf->list = iconlist_insert_sort(vf->list, id, vf->sort_method, vf->sort_ascend);
2551
2552                 vficon_sync_idle(vf);
2553                 ret = TRUE;
2554                 }
2555         else
2556                 {
2557                 ret = vficon_maint_removed(vf, fd, NULL);
2558                 }
2559
2560         g_free(source_base);
2561         g_free(dest_base);
2562
2563         return ret;
2564 }
2565
2566 gint vficon_maint_removed(ViewFile *vf, FileData *fd, GList *ignore_list)
2567 {
2568         gint row;
2569         gint new_row = -1;
2570         GtkTreeModel *store;
2571         GtkTreeIter iter;
2572         IconData *id = vficon_icon_data(vf, fd);
2573
2574         if (!id) return FALSE;
2575
2576         row = g_list_index(vf->list, id);
2577         if (row < 0) return FALSE;
2578
2579         if ((id->selected & SELECTION_SELECTED) &&
2580             layout_image_get_collection(vf->layout, NULL) == NULL)
2581                 {
2582                 vficon_unselect(vf, id);
2583
2584                 if (!VFICON_INFO(vf, selection))
2585                         {
2586                         gint n;
2587
2588                         n = vficon_count(vf, NULL);
2589                         if (ignore_list)
2590                                 {
2591                                 new_row = vficon_maint_find_closest(vf, row, n, ignore_list);
2592                                 DEBUG_1("row = %d, closest is %d", row, new_row);
2593                                 }
2594                         else
2595                                 {
2596                                 if (row + 1 < n)
2597                                         {
2598                                         new_row = row + 1;
2599                                         }
2600                                 else if (row > 0)
2601                                         {
2602                                         new_row = row - 1;
2603                                         }
2604                                 }
2605                         }
2606                 else if (ignore_list)
2607                         {
2608                         GList *work;
2609
2610                         work = VFICON_INFO(vf, selection);
2611                         while (work)
2612                                 {
2613                                 IconData *ignore_id;
2614                                 FileData *ignore_fd;
2615                                 GList *tmp;
2616                                 gint match = FALSE;
2617
2618                                 ignore_id = work->data;
2619                                 ignore_fd = ignore_id->fd;
2620                                 g_assert(ignore_fd->magick == 0x12345678);
2621                                 work = work->next;
2622
2623                                 tmp = ignore_list;
2624                                 while (tmp && !match)
2625                                         {
2626                                         FileData *ignore_list_fd = tmp->data;
2627                                         g_assert(ignore_list_fd->magick == 0x12345678);
2628                                         tmp = tmp->next;
2629
2630                                         if (ignore_list_fd == ignore_fd)
2631                                                 {
2632                                                 match = TRUE;
2633                                                 }
2634                                         }
2635
2636                                 if (!match)
2637                                         {
2638                                         new_row = g_list_index(vf->list, ignore_id);
2639                                         work = NULL;
2640                                         }
2641                                 }
2642
2643                         if (new_row == -1)
2644                                 {
2645                                 /* selection all ignored, use closest */
2646                                 new_row = vficon_maint_find_closest(vf, row, vficon_count(vf, NULL), ignore_list);
2647                                 }
2648                         }
2649                 else
2650                         {
2651                         new_row = g_list_index(vf->list, VFICON_INFO(vf, selection)->data);
2652                         }
2653
2654                 if (new_row >= 0)
2655                         {
2656                         IconData *idn = g_list_nth_data(vf->list, new_row);
2657
2658                         vficon_select(vf, idn);
2659                         vficon_send_layout_select(vf, idn);
2660                         }
2661                 }
2662
2663         /* Thumb loader check */
2664         if (fd == vf->thumbs_filedata) vf->thumbs_filedata = NULL;
2665         if (vf->thumbs_count > 0) vf->thumbs_count--;
2666
2667         if (VFICON_INFO(vf, prev_selection) == id) VFICON_INFO(vf, prev_selection) = NULL;
2668         if (VFICON_INFO(vf, click_id) == id) VFICON_INFO(vf, click_id) = NULL;
2669
2670         /* remove pointer to this fd from grid */
2671         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
2672         if (id->row >= 0 &&
2673             gtk_tree_model_iter_nth_child(store, &iter, NULL, id->row))
2674                 {
2675                 GList *list;
2676
2677                 gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
2678                 list = g_list_find(list, id);
2679                 if (list) list->data = NULL;
2680                 }
2681
2682         vf->list = g_list_remove(vf->list, id);
2683         file_data_unref(fd);
2684         g_free(id);
2685
2686         vficon_sync_idle(vf);
2687         vficon_send_update(vf);
2688
2689         return TRUE;
2690 }
2691
2692 gint vficon_maint_moved(ViewFile *vf, FileData *fd, GList *ignore_list)
2693 {
2694         gint ret = FALSE;
2695         gchar *buf;
2696
2697         if (!fd->change->source || !vf->path) return FALSE;
2698
2699         buf = remove_level_from_path(fd->change->source);
2700
2701         if (strcmp(buf, vf->path) == 0)
2702                 {
2703                 ret = vficon_maint_removed(vf, fd, ignore_list);
2704                 }
2705
2706         g_free(buf);
2707
2708         return ret;
2709 }