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 "filelist.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 static void vficon_select(ViewFile *vf, IconData *id)
 833 {
 834         VFICON_INFO(vf, prev_selection) = id;
 835
 836         if (!id || id->selected & SELECTION_SELECTED) return;
 837
 838         VFICON_INFO(vf, selection) = g_list_append(VFICON_INFO(vf, selection), id);
 839         vficon_selection_add(vf, id, SELECTION_SELECTED, NULL);
 840
 841         vficon_send_update(vf);
 842 }
 843
 844 static void vficon_unselect(ViewFile *vf, IconData *id)
 845 {
 846         VFICON_INFO(vf, prev_selection) = id;
 847
 848         if (!id || !(id->selected & SELECTION_SELECTED) ) return;
 849
 850         VFICON_INFO(vf, selection) = g_list_remove(VFICON_INFO(vf, selection), id);
 851         vficon_selection_remove(vf, id, SELECTION_SELECTED, NULL);
 852
 853         vficon_send_update(vf);
 854 }
 855
 856 static void vficon_select_util(ViewFile *vf, IconData *id, gint select)
 857 {
 858         if (select)
 859                 {
 860                 vficon_select(vf, id);
 861                 }
 862         else
 863                 {
 864                 vficon_unselect(vf, id);
 865                 }
 866 }
 867
 868 static void vficon_select_region_util(ViewFile *vf, IconData *start, IconData *end, gint select)
 869 {
 870         gint row1, col1;
 871         gint row2, col2;
 872         gint t;
 873         gint i, j;
 874
 875         if (!vficon_find_position(vf, start, &row1, &col1) ||
 876             !vficon_find_position(vf, end, &row2, &col2) ) return;
 877
 878         VFICON_INFO(vf, prev_selection) = end;
 879
 880         if (!options->collections.rectangular_selection)
 881                 {
 882                 GList *work;
 883                 IconData *id;
 884
 885                 if (g_list_index(vf->list, start) > g_list_index(vf->list, end))
 886                         {
 887                         id = start;
 888                         start = end;
 889                         end = id;
 890                         }
 891
 892                 work = g_list_find(vf->list, start);
 893                 while (work)
 894                         {
 895                         id = work->data;
 896                         vficon_select_util(vf, id, select);
 897
 898                         if (work->data != end)
 899                                 work = work->next;
 900                         else
 901                                 work = NULL;
 902                         }
 903                 return;
 904                 }
 905
 906         if (row2 < row1)
 907                 {
 908                 t = row1;
 909                 row1 = row2;
 910                 row2 = t;
 911                 }
 912         if (col2 < col1)
 913                 {
 914                 t = col1;
 915                 col1 = col2;
 916                 col2 = t;
 917                 }
 918
 919         DEBUG_1("table: %d x %d to %d x %d", row1, col1, row2, col2);
 920
 921         for (i = row1; i <= row2; i++)
 922                 {
 923                 for (j = col1; j <= col2; j++)
 924                         {
 925                         IconData *id = vficon_find_data(vf, i, j, NULL);
 926                         if (id) vficon_select_util(vf, id, select);
 927                         }
 928                 }
 929 }
 930
 931 gint vficon_index_is_selected(ViewFile *vf, gint row)
 932 {
 933         IconData *id = g_list_nth_data(vf->list, row);
 934
 935         if (!id) return FALSE;
 936
 937         return (id->selected & SELECTION_SELECTED);
 938 }
 939
 940 gint vficon_selection_count(ViewFile *vf, gint64 *bytes)
 941 {
 942         if (bytes)
 943                 {
 944                 gint64 b = 0;
 945                 GList *work;
 946
 947                 work = VFICON_INFO(vf, selection);
 948                 while (work)
 949                         {
 950                         IconData *id = work->data;
 951                         FileData *fd = id->fd;
 952                         g_assert(fd->magick == 0x12345678);
 953                         b += fd->size;
 954
 955                         work = work->next;
 956                         }
 957
 958                 *bytes = b;
 959                 }
 960
 961         return g_list_length(VFICON_INFO(vf, selection));
 962 }
 963
 964 GList *vficon_selection_get_list(ViewFile *vf)
 965 {
 966         GList *list = NULL;
 967         GList *work;
 968
 969         work = VFICON_INFO(vf, selection);
 970         while (work)
 971                 {
 972                 IconData *id = work->data;
 973                 FileData *fd = id->fd;
 974                 g_assert(fd->magick == 0x12345678);
 975
 976                 list = g_list_prepend(list, file_data_ref(fd));
 977
 978                 work = work->next;
 979                 }
 980
 981         list = g_list_reverse(list);
 982
 983         return list;
 984 }
 985
 986 GList *vficon_selection_get_list_by_index(ViewFile *vf)
 987 {
 988         GList *list = NULL;
 989         GList *work;
 990
 991         work = VFICON_INFO(vf, selection);
 992         while (work)
 993                 {
 994                 list = g_list_prepend(list, GINT_TO_POINTER(g_list_index(vf->list, work->data)));
 995                 work = work->next;
 996                 }
 997
 998         return g_list_reverse(list);
 999 }
1000
1001 static void vficon_select_by_id(ViewFile *vf, IconData *id)
1002 {
1003         if (!id) return;
1004
1005         if (!(id->selected & SELECTION_SELECTED))
1006                 {
1007                 vficon_select_none(vf);
1008                 vficon_select(vf, id);
1009                 }
1010
1011         vficon_set_focus(vf, id);
1012 }
1013
1014
1015 void vficon_select_by_path(ViewFile *vf, const gchar *path)
1016 {
1017         IconData *id = NULL;
1018         GList *work;
1019
1020         if (!path) return;
1021
1022         work = vf->list;
1023         while (work && !id)
1024                 {
1025                 IconData *chk = work->data;
1026                 work = work->next;
1027                 if (strcmp(chk->fd->path, path) == 0) id = chk;
1028                 }
1029         vficon_select_by_id(vf, id);
1030 }
1031
1032 void vficon_select_by_fd(ViewFile *vf, FileData *fd)
1033 {
1034         IconData *id = NULL;
1035         GList *work;
1036
1037         if (!fd) return;
1038         work = vf->list;
1039         while (work && !id)
1040                 {
1041                 IconData *chk = work->data;
1042                 work = work->next;
1043                 if (chk->fd == fd) id = chk;
1044                 }
1045         vficon_select_by_id(vf, id);
1046 }
1047
1048 void vficon_mark_to_selection(ViewFile *vf, gint mark, MarkToSelectionMode mode)
1049 {
1050         GList *work;
1051
1052         work = vf->list;
1053         while (work)
1054                 {
1055                 IconData *id = work->data;
1056                 FileData *fd = id->fd;
1057                 gboolean mark_val, selected;
1058
1059                 g_assert(fd->magick == 0x12345678);
1060
1061                 mark_val = fd->marks[mark];
1062                 selected = (id->selected & SELECTION_SELECTED);
1063
1064                 switch (mode)
1065                         {
1066                         case MTS_MODE_SET: selected = mark_val;
1067                                 break;
1068                         case MTS_MODE_OR: selected = mark_val | selected;
1069                                 break;
1070                         case MTS_MODE_AND: selected = mark_val & selected;
1071                                 break;
1072                         case MTS_MODE_MINUS: selected = !mark_val & selected;
1073                                 break;
1074                         }
1075
1076                 vficon_select_util(vf, id, selected);
1077
1078                 work = work->next;
1079                 }
1080 }
1081
1082 void vficon_selection_to_mark(ViewFile *vf, gint mark, SelectionToMarkMode mode)
1083 {
1084         GList *slist;
1085         GList *work;
1086
1087         g_assert(mark >= 0 && mark < FILEDATA_MARKS_SIZE);
1088
1089         slist = vficon_selection_get_list(vf);
1090         work = slist;
1091         while (work)
1092                 {
1093                 FileData *fd = work->data;
1094
1095                 switch (mode)
1096                         {
1097                         case STM_MODE_SET: fd->marks[mark] = 1;
1098                                 break;
1099                         case STM_MODE_RESET: fd->marks[mark] = 0;
1100                                 break;
1101                         case STM_MODE_TOGGLE: fd->marks[mark] = !fd->marks[mark];
1102                                 break;
1103                         }
1104
1105                 work = work->next;
1106                 }
1107         filelist_free(slist);
1108 }
1109
1110
1111 /*
1112  *-------------------------------------------------------------------
1113  * focus
1114  *-------------------------------------------------------------------
1115  */
1116
1117 static void vficon_move_focus(ViewFile *vf, gint row, gint col, gint relative)
1118 {
1119         gint new_row;
1120         gint new_col;
1121
1122         if (relative)
1123                 {
1124                 new_row = VFICON_INFO(vf, focus_row);
1125                 new_col = VFICON_INFO(vf, focus_column);
1126
1127                 new_row += row;
1128                 if (new_row < 0) new_row = 0;
1129                 if (new_row >= VFICON_INFO(vf, rows)) new_row = VFICON_INFO(vf, rows) - 1;
1130
1131                 while (col != 0)
1132                         {
1133                         if (col < 0)
1134                                 {
1135                                 new_col--;
1136                                 col++;
1137                                 }
1138                         else
1139                                 {
1140                                 new_col++;
1141                                 col--;
1142                                 }
1143
1144                         if (new_col < 0)
1145                                 {
1146                                 if (new_row > 0)
1147                                         {
1148                                         new_row--;
1149                                         new_col = VFICON_INFO(vf, columns) - 1;
1150                                         }
1151                                 else
1152                                         {
1153                                         new_col = 0;
1154                                         }
1155                                 }
1156                         if (new_col >= VFICON_INFO(vf, columns))
1157                                 {
1158                                 if (new_row < VFICON_INFO(vf, rows) - 1)
1159                                         {
1160                                         new_row++;
1161                                         new_col = 0;
1162                                         }
1163                                 else
1164                                         {
1165                                         new_col = VFICON_INFO(vf, columns) - 1;
1166                                         }
1167                                 }
1168                         }
1169                 }
1170         else
1171                 {
1172                 new_row = row;
1173                 new_col = col;
1174
1175                 if (new_row >= VFICON_INFO(vf, rows))
1176                         {
1177                         if (VFICON_INFO(vf, rows) > 0)
1178                                 new_row = VFICON_INFO(vf, rows) - 1;
1179                         else
1180                                 new_row = 0;
1181                         new_col = VFICON_INFO(vf, columns) - 1;
1182                         }
1183                 if (new_col >= VFICON_INFO(vf, columns)) new_col = VFICON_INFO(vf, columns) - 1;
1184                 }
1185
1186         if (new_row == VFICON_INFO(vf, rows) - 1)
1187                 {
1188                 gint l;
1189
1190                 /* if we moved beyond the last image, go to the last image */
1191
1192                 l = g_list_length(vf->list);
1193                 if (VFICON_INFO(vf, rows) > 1) l -= (VFICON_INFO(vf, rows) - 1) * VFICON_INFO(vf, columns);
1194                 if (new_col >= l) new_col = l - 1;
1195                 }
1196
1197         vficon_set_focus(vf, vficon_find_data(vf, new_row, new_col, NULL));
1198 }
1199
1200 static void vficon_set_focus(ViewFile *vf, IconData *id)
1201 {
1202         GtkTreeIter iter;
1203         gint row, col;
1204
1205         if (g_list_find(vf->list, VFICON_INFO(vf, focus_id)))
1206                 {
1207                 if (id == VFICON_INFO(vf, focus_id))
1208                         {
1209                         /* ensure focus row col are correct */
1210                         vficon_find_position(vf, VFICON_INFO(vf, focus_id), &VFICON_INFO(vf, focus_row), &VFICON_INFO(vf, focus_column));
1211                         return;
1212                         }
1213                 vficon_selection_remove(vf, VFICON_INFO(vf, focus_id), SELECTION_FOCUS, NULL);
1214                 }
1215
1216         if (!vficon_find_position(vf, id, &row, &col))
1217                 {
1218                 VFICON_INFO(vf, focus_id) = NULL;
1219                 VFICON_INFO(vf, focus_row) = -1;
1220                 VFICON_INFO(vf, focus_column) = -1;
1221                 return;
1222                 }
1223
1224         VFICON_INFO(vf, focus_id) = id;
1225         VFICON_INFO(vf, focus_row) = row;
1226         VFICON_INFO(vf, focus_column) = col;
1227         vficon_selection_add(vf, VFICON_INFO(vf, focus_id), SELECTION_FOCUS, NULL);
1228
1229         if (vficon_find_iter(vf, VFICON_INFO(vf, focus_id), &iter, NULL))
1230                 {
1231                 GtkTreePath *tpath;
1232                 GtkTreeViewColumn *column;
1233                 GtkTreeModel *store;
1234
1235                 tree_view_row_make_visible(GTK_TREE_VIEW(vf->listview), &iter, FALSE);
1236
1237                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1238                 tpath = gtk_tree_model_get_path(store, &iter);
1239                 /* focus is set to an extra column with 0 width to hide focus, we draw it ourself */
1240                 column = gtk_tree_view_get_column(GTK_TREE_VIEW(vf->listview), VFICON_MAX_COLUMNS);
1241                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(vf->listview), tpath, column, FALSE);
1242                 gtk_tree_path_free(tpath);
1243                 }
1244 }
1245
1246 static void vficon_update_focus(ViewFile *vf)
1247 {
1248         gint new_row = 0;
1249         gint new_col = 0;
1250
1251         if (VFICON_INFO(vf, focus_id) && vficon_find_position(vf, VFICON_INFO(vf, focus_id), &new_row, &new_col))
1252                 {
1253                 /* first find the old focus, if it exists and is valid */
1254                 }
1255         else
1256                 {
1257                 /* (try to) stay where we were */
1258                 new_row = VFICON_INFO(vf, focus_row);
1259                 new_col = VFICON_INFO(vf, focus_column);
1260                 }
1261
1262         vficon_move_focus(vf, new_row, new_col, FALSE);
1263 }
1264
1265 /* used to figure the page up/down distances */
1266 static gint page_height(ViewFile *vf)
1267 {
1268         GtkAdjustment *adj;
1269         gint page_size;
1270         gint row_height;
1271         gint ret;
1272
1273         adj = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(vf->listview));
1274         page_size = (gint)adj->page_increment;
1275
1276         row_height = options->thumbnails.max_height + THUMB_BORDER_PADDING * 2;
1277         if (VFICON_INFO(vf, show_text)) row_height += options->thumbnails.max_height / 3;
1278
1279         ret = page_size / row_height;
1280         if (ret < 1) ret = 1;
1281
1282         return ret;
1283 }
1284
1285 /*
1286  *-------------------------------------------------------------------
1287  * keyboard
1288  *-------------------------------------------------------------------
1289  */
1290
1291 static void vfi_menu_position_cb(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer data)
1292 {
1293         ViewFile *vf = data;
1294         GtkTreeModel *store;
1295         GtkTreeIter iter;
1296         gint column;
1297         GtkTreePath *tpath;
1298         gint cw, ch;
1299
1300         if (!vficon_find_iter(vf, VFICON_INFO(vf, click_id), &iter, &column)) return;
1301         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1302         tpath = gtk_tree_model_get_path(store, &iter);
1303         tree_view_get_cell_clamped(GTK_TREE_VIEW(vf->listview), tpath, column, FALSE, x, y, &cw, &ch);
1304         gtk_tree_path_free(tpath);
1305         *y += ch;
1306         popup_menu_position_clamp(menu, x, y, 0);
1307 }
1308
1309 gint vficon_press_key_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
1310 {
1311         ViewFile *vf = data;
1312         gint focus_row = 0;
1313         gint focus_col = 0;
1314         IconData *id;
1315         gint stop_signal;
1316
1317         stop_signal = TRUE;
1318         switch (event->keyval)
1319                 {
1320                 case GDK_Left: case GDK_KP_Left:
1321                         focus_col = -1;
1322                         break;
1323                 case GDK_Right: case GDK_KP_Right:
1324                         focus_col = 1;
1325                         break;
1326                 case GDK_Up: case GDK_KP_Up:
1327                         focus_row = -1;
1328                         break;
1329                 case GDK_Down: case GDK_KP_Down:
1330                         focus_row = 1;
1331                         break;
1332                 case GDK_Page_Up: case GDK_KP_Page_Up:
1333                         focus_row = -page_height(vf);
1334                         break;
1335                 case GDK_Page_Down: case GDK_KP_Page_Down:
1336                         focus_row = page_height(vf);
1337                         break;
1338                 case GDK_Home: case GDK_KP_Home:
1339                         focus_row = -VFICON_INFO(vf, focus_row);
1340                         focus_col = -VFICON_INFO(vf, focus_column);
1341                         break;
1342                 case GDK_End: case GDK_KP_End:
1343                         focus_row = VFICON_INFO(vf, rows) - 1 - VFICON_INFO(vf, focus_row);
1344                         focus_col = VFICON_INFO(vf, columns) - 1 - VFICON_INFO(vf, focus_column);
1345                         break;
1346                 case GDK_space:
1347                         id = vficon_find_data(vf, VFICON_INFO(vf, focus_row), VFICON_INFO(vf, focus_column), NULL);
1348                         if (id)
1349                                 {
1350                                 VFICON_INFO(vf, click_id) = id;
1351                                 if (event->state & GDK_CONTROL_MASK)
1352                                         {
1353                                         gint selected;
1354
1355                                         selected = id->selected & SELECTION_SELECTED;
1356                                         if (selected)
1357                                                 {
1358                                                 vficon_unselect(vf, id);
1359                                                 }
1360                                         else
1361                                                 {
1362                                                 vficon_select(vf, id);
1363                                                 vficon_send_layout_select(vf, id);
1364                                                 }
1365                                         }
1366                                 else
1367                                         {
1368                                         vficon_select_none(vf);
1369                                         vficon_select(vf, id);
1370                                         vficon_send_layout_select(vf, id);
1371                                         }
1372                                 }
1373                         break;
1374                 case GDK_Menu:
1375                         id = vficon_find_data(vf, VFICON_INFO(vf, focus_row), VFICON_INFO(vf, focus_column), NULL);
1376                         VFICON_INFO(vf, click_id) = id;
1377
1378                         vficon_selection_add(vf, VFICON_INFO(vf, click_id), SELECTION_PRELIGHT, NULL);
1379                         tip_unschedule(vf);
1380
1381                         vf->popup = vficon_pop_menu(vf, (id != NULL));
1382                         gtk_menu_popup(GTK_MENU(vf->popup), NULL, NULL, vfi_menu_position_cb, vf, 0, GDK_CURRENT_TIME);
1383                         break;
1384                 default:
1385                         stop_signal = FALSE;
1386                         break;
1387                 }
1388
1389         if (focus_row != 0 || focus_col != 0)
1390                 {
1391                 IconData *new_id;
1392                 IconData *old_id;
1393
1394                 old_id = vficon_find_data(vf, VFICON_INFO(vf, focus_row), VFICON_INFO(vf, focus_column), NULL);
1395                 vficon_move_focus(vf, focus_row, focus_col, TRUE);
1396                 new_id = vficon_find_data(vf, VFICON_INFO(vf, focus_row), VFICON_INFO(vf, focus_column), NULL);
1397
1398                 if (new_id != old_id)
1399                         {
1400                         if (event->state & GDK_SHIFT_MASK)
1401                                 {
1402                                 if (!options->collections.rectangular_selection)
1403                                         {
1404                                         vficon_select_region_util(vf, old_id, new_id, FALSE);
1405                                         }
1406                                 else
1407                                         {
1408                                         vficon_select_region_util(vf, VFICON_INFO(vf, click_id), old_id, FALSE);
1409                                         }
1410                                 vficon_select_region_util(vf, VFICON_INFO(vf, click_id), new_id, TRUE);
1411                                 vficon_send_layout_select(vf, new_id);
1412                                 }
1413                         else if (event->state & GDK_CONTROL_MASK)
1414                                 {
1415                                 VFICON_INFO(vf, click_id) = new_id;
1416                                 }
1417                         else
1418                                 {
1419                                 VFICON_INFO(vf, click_id) = new_id;
1420                                 vficon_select_none(vf);
1421                                 vficon_select(vf, new_id);
1422                                 vficon_send_layout_select(vf, new_id);
1423                                 }
1424                         }
1425                 }
1426
1427         if (stop_signal)
1428                 {
1429 #if 0
1430                 g_signal_stop_emission_by_name(GTK_OBJECT(widget), "key_press_event");
1431 #endif
1432                 tip_unschedule(vf);
1433                 }
1434
1435         return stop_signal;
1436 }
1437
1438 /*
1439  *-------------------------------------------------------------------
1440  * mouse
1441  *-------------------------------------------------------------------
1442  */
1443
1444 static gint vficon_motion_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1445 {
1446         ViewFile *vf = data;
1447         IconData *id;
1448
1449         id = vficon_find_data_by_coord(vf, (gint)bevent->x, (gint)bevent->y, NULL);
1450         tip_update(vf, id);
1451
1452         return FALSE;
1453 }
1454
1455 gint vficon_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1456 {
1457         ViewFile *vf = data;
1458         GtkTreeIter iter;
1459         IconData *id;
1460
1461         tip_unschedule(vf);
1462
1463         id = vficon_find_data_by_coord(vf, (gint)bevent->x, (gint)bevent->y, &iter);
1464
1465         VFICON_INFO(vf, click_id) = id;
1466         vficon_selection_add(vf, VFICON_INFO(vf, click_id), SELECTION_PRELIGHT, &iter);
1467
1468         switch (bevent->button)
1469                 {
1470                 case MOUSE_BUTTON_LEFT:
1471                         if (!GTK_WIDGET_HAS_FOCUS(vf->listview))
1472                                 {
1473                                 gtk_widget_grab_focus(vf->listview);
1474                                 }
1475 #if 0
1476                         if (bevent->type == GDK_2BUTTON_PRESS &&
1477                             vf->layout)
1478                                 {
1479                                 vficon_selection_remove(vf, VFICON_INFO(vf, click_id), SELECTION_PRELIGHT, &iter);
1480                                 layout_image_full_screen_start(vf->layout);
1481                                 }
1482 #endif
1483                         break;
1484                 case MOUSE_BUTTON_RIGHT:
1485                         vf->popup = vficon_pop_menu(vf, (id != NULL));
1486                         gtk_menu_popup(GTK_MENU(vf->popup), NULL, NULL, NULL, NULL, bevent->button, bevent->time);
1487                         break;
1488                 default:
1489                         break;
1490                 }
1491
1492         return TRUE;
1493 }
1494
1495 gint vficon_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
1496 {
1497         ViewFile *vf = data;
1498         GtkTreeIter iter;
1499         IconData *id = NULL;
1500         gint was_selected = FALSE;
1501
1502         tip_schedule(vf);
1503
1504         if ((gint)bevent->x != 0 || (gint) bevent->y != 0)
1505                 {
1506                 id = vficon_find_data_by_coord(vf, (gint)bevent->x, (gint)bevent->y, &iter);
1507                 }
1508
1509         if (VFICON_INFO(vf, click_id))
1510                 {
1511                 vficon_selection_remove(vf, VFICON_INFO(vf, click_id), SELECTION_PRELIGHT, NULL);
1512                 }
1513
1514         if (id) was_selected = (id->selected & SELECTION_SELECTED);
1515
1516         if (bevent->button == MOUSE_BUTTON_LEFT &&
1517             id && VFICON_INFO(vf, click_id) == id)
1518                 {
1519                 vficon_set_focus(vf, id);
1520
1521                 if (bevent->state & GDK_CONTROL_MASK)
1522                         {
1523                         gint select;
1524
1525                         select = !(id->selected & SELECTION_SELECTED);
1526                         if ((bevent->state & GDK_SHIFT_MASK) && VFICON_INFO(vf, prev_selection))
1527                                 {
1528                                 vficon_select_region_util(vf, VFICON_INFO(vf, prev_selection), id, select);
1529                                 }
1530                         else
1531                                 {
1532                                 vficon_select_util(vf, id, select);
1533                                 }
1534                         }
1535                 else
1536                         {
1537                         vficon_select_none(vf);
1538
1539                         if ((bevent->state & GDK_SHIFT_MASK) &&
1540                             VFICON_INFO(vf, prev_selection))
1541                                 {
1542                                 vficon_select_region_util(vf, VFICON_INFO(vf, prev_selection), id, TRUE);
1543                                 }
1544                         else
1545                                 {
1546                                 vficon_select_util(vf, id, TRUE);
1547                                 was_selected = FALSE;
1548                                 }
1549                         }
1550                 }
1551         else if (bevent->button == MOUSE_BUTTON_MIDDLE &&
1552                  id && VFICON_INFO(vf, click_id) == id)
1553                 {
1554                 vficon_select_util(vf, id, !(id->selected & SELECTION_SELECTED));
1555                 }
1556
1557         if (id && !was_selected &&
1558             (id->selected & SELECTION_SELECTED))
1559                 {
1560                 vficon_send_layout_select(vf, id);
1561                 }
1562
1563         return TRUE;
1564 }
1565
1566 static gint vficon_leave_cb(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
1567 {
1568         ViewFile *vf = data;
1569
1570         tip_unschedule(vf);
1571         return FALSE;
1572 }
1573
1574 /*
1575  *-------------------------------------------------------------------
1576  * population
1577  *-------------------------------------------------------------------
1578  */
1579
1580 static gboolean vficon_destroy_node_cb(GtkTreeModel *store, GtkTreePath *tpath, GtkTreeIter *iter, gpointer data)
1581 {
1582         GList *list;
1583
1584         gtk_tree_model_get(store, iter, FILE_COLUMN_POINTER, &list, -1);
1585         g_list_free(list);
1586
1587         return FALSE;
1588 }
1589
1590 static void vficon_clear_store(ViewFile *vf)
1591 {
1592         GtkTreeModel *store;
1593
1594         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1595         gtk_tree_model_foreach(store, vficon_destroy_node_cb, NULL);
1596
1597         gtk_list_store_clear(GTK_LIST_STORE(store));
1598 }
1599
1600 static void vficon_set_thumb(ViewFile *vf, FileData *fd, GdkPixbuf *pb)
1601 {
1602         GtkTreeModel *store;
1603         GtkTreeIter iter;
1604         GList *list;
1605
1606         if (!vficon_find_iter(vf, vficon_icon_data(vf, fd), &iter, NULL)) return;
1607
1608         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1609
1610         if (pb) g_object_ref(pb);
1611         if (fd->pixbuf) g_object_unref(fd->pixbuf);
1612         fd->pixbuf = pb;
1613
1614         gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1615         gtk_list_store_set(GTK_LIST_STORE(store), &iter, FILE_COLUMN_POINTER, list, -1);
1616 }
1617
1618 static GList *vficon_add_row(ViewFile *vf, GtkTreeIter *iter)
1619 {
1620         GtkListStore *store;
1621         GList *list = NULL;
1622         gint i;
1623
1624         for (i = 0; i < VFICON_INFO(vf, columns); i++) list = g_list_prepend(list, NULL);
1625
1626         store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview)));
1627         gtk_list_store_append(store, iter);
1628         gtk_list_store_set(store, iter, FILE_COLUMN_POINTER, list, -1);
1629
1630         return list;
1631 }
1632
1633 static void vficon_populate(ViewFile *vf, gint resize, gint keep_position)
1634 {
1635         GtkTreeModel *store;
1636         GtkTreePath *tpath;
1637         gint row;
1638         GList *work;
1639         IconData *visible_id = NULL;
1640
1641         vficon_verify_selections(vf);
1642
1643         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1644
1645         if (keep_position && GTK_WIDGET_REALIZED(vf->listview) &&
1646             gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
1647                 {
1648                 GtkTreeIter iter;
1649                 GList *list;
1650
1651                 gtk_tree_model_get_iter(store, &iter, tpath);
1652                 gtk_tree_path_free(tpath);
1653
1654                 gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1655                 if (list) visible_id = list->data;
1656                 }
1657
1658         vficon_clear_store(vf);
1659
1660         if (resize)
1661                 {
1662                 gint i;
1663                 gint thumb_width;
1664
1665                 thumb_width = vficon_get_icon_width(vf);
1666
1667                 for (i = 0; i < VFICON_MAX_COLUMNS; i++)
1668                         {
1669                         GtkTreeViewColumn *column;
1670                         GtkCellRenderer *cell;
1671                         GList *list;
1672
1673                         column = gtk_tree_view_get_column(GTK_TREE_VIEW(vf->listview), i);
1674                         gtk_tree_view_column_set_visible(column, (i < VFICON_INFO(vf, columns)));
1675                         gtk_tree_view_column_set_fixed_width(column, thumb_width + (THUMB_BORDER_PADDING * 6));
1676
1677                         list = gtk_tree_view_column_get_cell_renderers(column);
1678                         cell = (list) ? list->data : NULL;
1679                         g_list_free(list);
1680
1681                         if (cell && GQV_IS_CELL_RENDERER_ICON(cell))
1682                                 {
1683                                 g_object_set(G_OBJECT(cell), "fixed_width", thumb_width,
1684                                                              "fixed_height", options->thumbnails.max_height,
1685                                                              "show_text", VFICON_INFO(vf, show_text), NULL);
1686                                 }
1687                         }
1688                 if (GTK_WIDGET_REALIZED(vf->listview)) gtk_tree_view_columns_autosize(GTK_TREE_VIEW(vf->listview));
1689                 }
1690
1691         row = -1;
1692         work = vf->list;
1693         while (work)
1694                 {
1695                 GList *list;
1696                 GtkTreeIter iter;
1697
1698                 row++;
1699
1700                 list = vficon_add_row(vf, &iter);
1701                 while (work && list)
1702                         {
1703                         IconData *id;
1704
1705                         id = work->data;
1706                         id->row = row;
1707
1708                         list->data = work->data;
1709                         list = list->next;
1710                         work = work->next;
1711                         }
1712                 }
1713
1714         if (visible_id &&
1715             gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
1716                 {
1717                 GtkTreeIter iter;
1718                 GList *list;
1719
1720                 gtk_tree_model_get_iter(store, &iter, tpath);
1721                 gtk_tree_path_free(tpath);
1722
1723                 gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1724                 if (g_list_find(list, visible_id) == NULL &&
1725                     vficon_find_iter(vf, visible_id, &iter, NULL))
1726                         {
1727                         tree_view_row_make_visible(GTK_TREE_VIEW(vf->listview), &iter, FALSE);
1728                         }
1729                 }
1730
1731         VFICON_INFO(vf, rows) = row + 1;
1732
1733         vficon_send_update(vf);
1734         vficon_thumb_update(vf);
1735 }
1736
1737 static void vficon_populate_at_new_size(ViewFile *vf, gint w, gint h, gint force)
1738 {
1739         gint new_cols;
1740         gint thumb_width;
1741
1742         thumb_width = vficon_get_icon_width(vf);
1743
1744         new_cols = w / (thumb_width + (THUMB_BORDER_PADDING * 6));
1745         if (new_cols < 1) new_cols = 1;
1746
1747         if (!force && new_cols == VFICON_INFO(vf, columns)) return;
1748
1749         VFICON_INFO(vf, columns) = new_cols;
1750
1751         vficon_populate(vf, TRUE, TRUE);
1752
1753         DEBUG_1("col tab pop cols=%d rows=%d", VFICON_INFO(vf, columns), VFICON_INFO(vf, rows));
1754 }
1755
1756 static void vficon_sync(ViewFile *vf)
1757 {
1758         GtkTreeModel *store;
1759         GtkTreeIter iter;
1760         GList *work;
1761         gint r, c;
1762
1763         if (VFICON_INFO(vf, rows) == 0) return;
1764
1765         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1766
1767         r = -1;
1768         c = 0;
1769
1770         work = vf->list;
1771         while (work)
1772                 {
1773                 GList *list;
1774                 r++;
1775                 c = 0;
1776                 if (gtk_tree_model_iter_nth_child(store, &iter, NULL, r))
1777                         {
1778                         gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1779                         gtk_list_store_set(GTK_LIST_STORE(store), &iter, FILE_COLUMN_POINTER, list, -1);
1780                         }
1781                 else
1782                         {
1783                         list = vficon_add_row(vf, &iter);
1784                         }
1785
1786                 while (list)
1787                         {
1788                         IconData *id;
1789
1790                         if (work)
1791                                 {
1792                                 id = work->data;
1793                                 work = work->next;
1794                                 c++;
1795
1796                                 id->row = r;
1797                                 }
1798                         else
1799                                 {
1800                                 id = NULL;
1801                                 }
1802
1803                         list->data = id;
1804                         list = list->next;
1805                         }
1806                 }
1807
1808         r++;
1809         while (gtk_tree_model_iter_nth_child(store, &iter, NULL, r))
1810                 {
1811                 GList *list;
1812
1813                 gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1814                 gtk_list_store_remove(GTK_LIST_STORE(store), &iter);
1815                 g_list_free(list);
1816                 }
1817
1818         VFICON_INFO(vf, rows) = r;
1819
1820         vficon_update_focus(vf);
1821 }
1822
1823 static gint vficon_sync_idle_cb(gpointer data)
1824 {
1825         ViewFile *vf = data;
1826
1827         if (VFICON_INFO(vf, sync_idle_id) == -1) return FALSE;
1828         VFICON_INFO(vf, sync_idle_id) = -1;
1829
1830         vficon_sync(vf);
1831         return FALSE;
1832 }
1833
1834 static void vficon_sync_idle(ViewFile *vf)
1835 {
1836         if (VFICON_INFO(vf, sync_idle_id) == -1)
1837                 {
1838                 /* high priority, the view needs to be resynced before a redraw
1839                  * may contain invalid pointers at this time
1840                  */
1841                 VFICON_INFO(vf, sync_idle_id) = g_idle_add_full(G_PRIORITY_HIGH, vficon_sync_idle_cb, vf, NULL);
1842                 }
1843 }
1844
1845 static void vficon_sized_cb(GtkWidget *widget, GtkAllocation *allocation, gpointer data)
1846 {
1847         ViewFile *vf = data;
1848
1849         vficon_populate_at_new_size(vf, allocation->width, allocation->height, FALSE);
1850 }
1851
1852 /*
1853  *-----------------------------------------------------------------------------
1854  * misc
1855  *-----------------------------------------------------------------------------
1856  */
1857
1858 void vficon_sort_set(ViewFile *vf, SortType type, gint ascend)
1859 {
1860         if (vf->sort_method == type && vf->sort_ascend == ascend) return;
1861
1862         vf->sort_method = type;
1863         vf->sort_ascend = ascend;
1864
1865         if (!vf->list) return;
1866
1867         vf->list = iconlist_sort(vf->list, vf->sort_method, vf->sort_ascend);
1868         vficon_sync(vf);
1869 }
1870
1871 /*
1872  *-----------------------------------------------------------------------------
1873  * thumb updates
1874  *-----------------------------------------------------------------------------
1875  */
1876
1877 static gint vficon_thumb_next(ViewFile *vf);
1878
1879 static void vficon_thumb_status(ViewFile *vf, gdouble val, const gchar *text)
1880 {
1881         if (vf->func_thumb_status)
1882                 {
1883                 vf->func_thumb_status(vf, val, text, vf->data_thumb_status);
1884                 }
1885 }
1886
1887 static void vficon_thumb_cleanup(ViewFile *vf)
1888 {
1889         vficon_thumb_status(vf, 0.0, NULL);
1890
1891         vf->thumbs_count = 0;
1892         vf->thumbs_running = FALSE;
1893
1894         thumb_loader_free(vf->thumbs_loader);
1895         vf->thumbs_loader = NULL;
1896
1897         vf->thumbs_filedata = NULL;
1898 }
1899
1900 static void vficon_thumb_stop(ViewFile *vf)
1901 {
1902         if (vf->thumbs_running) vficon_thumb_cleanup(vf);
1903 }
1904
1905 static void vficon_thumb_do(ViewFile *vf, ThumbLoader *tl, FileData *fd)
1906 {
1907         GdkPixbuf *pixbuf;
1908
1909         if (!fd) return;
1910
1911         pixbuf = thumb_loader_get_pixbuf(tl, TRUE);
1912         vficon_set_thumb(vf, fd, pixbuf);
1913         g_object_unref(pixbuf);
1914
1915         vficon_thumb_status(vf, (gdouble)(vf->thumbs_count) / g_list_length(vf->list), _("Loading thumbs..."));
1916 }
1917
1918 static void vficon_thumb_error_cb(ThumbLoader *tl, gpointer data)
1919 {
1920         ViewFile *vf = data;
1921
1922         if (vf->thumbs_filedata && vf->thumbs_loader == tl)
1923                 {
1924                 vficon_thumb_do(vf, tl, vf->thumbs_filedata);
1925                 }
1926
1927         while (vficon_thumb_next(vf));
1928 }
1929
1930 static void vficon_thumb_done_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 gint vficon_thumb_next(ViewFile *vf)
1943 {
1944         GtkTreePath *tpath;
1945         FileData *fd = NULL;
1946
1947         if (!GTK_WIDGET_REALIZED(vf->listview))
1948                 {
1949                 vficon_thumb_status(vf, 0.0, NULL);
1950                 return FALSE;
1951                 }
1952
1953         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(vf->listview), 0, 0, &tpath, NULL, NULL, NULL))
1954                 {
1955                 GtkTreeModel *store;
1956                 GtkTreeIter iter;
1957                 gint valid = TRUE;
1958
1959                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
1960                 gtk_tree_model_get_iter(store, &iter, tpath);
1961                 gtk_tree_path_free(tpath);
1962
1963                 while (!fd && valid && tree_view_row_get_visibility(GTK_TREE_VIEW(vf->listview), &iter, FALSE) == 0)
1964                         {
1965                         GList *list;
1966
1967                         gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
1968
1969                         while (!fd && list)
1970                                 {
1971                                 IconData *id = list->data;
1972                                 if (id && !id->fd->pixbuf) fd = id->fd;
1973                                 list = list->next;
1974                                 }
1975
1976                         valid = gtk_tree_model_iter_next(store, &iter);
1977                         }
1978                 }
1979
1980         /* then find first undone */
1981
1982         if (!fd)
1983                 {
1984                 GList *work = vf->list;
1985                 while (work && !fd)
1986                         {
1987                         IconData *id = work->data;
1988                         FileData *fd_p = id->fd;
1989                         work = work->next;
1990
1991                         if (!fd_p->pixbuf) fd = fd_p;
1992                         }
1993                 }
1994
1995         if (!fd)
1996                 {
1997                 /* done */
1998                 vficon_thumb_cleanup(vf);
1999                 return FALSE;
2000                 }
2001
2002         vf->thumbs_count++;
2003
2004         vf->thumbs_filedata = fd;
2005
2006         thumb_loader_free(vf->thumbs_loader);
2007
2008         vf->thumbs_loader = thumb_loader_new(options->thumbnails.max_width, options->thumbnails.max_height);
2009         thumb_loader_set_callbacks(vf->thumbs_loader,
2010                                    vficon_thumb_done_cb,
2011                                    vficon_thumb_error_cb,
2012                                    NULL,
2013                                    vf);
2014
2015         if (!thumb_loader_start(vf->thumbs_loader, fd->path))
2016                 {
2017                 /* set icon to unknown, continue */
2018                 DEBUG_1("thumb loader start failed %s", vf->thumbs_loader->path);
2019                 vficon_thumb_do(vf, vf->thumbs_loader, fd);
2020
2021                 return TRUE;
2022                 }
2023
2024         return FALSE;
2025 }
2026
2027 static void vficon_thumb_update(ViewFile *vf)
2028 {
2029         vficon_thumb_stop(vf);
2030
2031         vficon_thumb_status(vf, 0.0, _("Loading thumbs..."));
2032         vf->thumbs_running = TRUE;
2033
2034         while (vficon_thumb_next(vf));
2035 }
2036
2037 /*
2038  *-----------------------------------------------------------------------------
2039  * row stuff
2040  *-----------------------------------------------------------------------------
2041  */
2042
2043 FileData *vficon_index_get_data(ViewFile *vf, gint row)
2044 {
2045         IconData *id;
2046
2047         id = g_list_nth_data(vf->list, row);
2048         return id ? id->fd : NULL;
2049 }
2050
2051 gchar *vficon_index_get_path(ViewFile *vf, gint row)
2052 {
2053         FileData *fd;
2054         IconData *id;
2055
2056         id = g_list_nth_data(vf->list, row);
2057         fd = id ? id->fd : NULL;
2058
2059         return (fd ? fd->path : NULL);
2060 }
2061
2062 gint vficon_index_by_path(ViewFile *vf, const gchar *path)
2063 {
2064         gint p = 0;
2065         GList *work;
2066
2067         if (!path) return -1;
2068
2069         work = vf->list;
2070         while (work)
2071                 {
2072                 IconData *id = work->data;
2073                 FileData *fd = id->fd;
2074                 if (strcmp(path, fd->path) == 0) return p;
2075                 work = work->next;
2076                 p++;
2077                 }
2078
2079         return -1;
2080 }
2081
2082 gint vficon_index_by_fd(ViewFile *vf, FileData *in_fd)
2083 {
2084         gint p = 0;
2085         GList *work;
2086
2087         if (!in_fd) return -1;
2088
2089         work = vf->list;
2090         while (work)
2091                 {
2092                 IconData *id = work->data;
2093                 FileData *fd = id->fd;
2094                 if (fd == in_fd) return p;
2095                 work = work->next;
2096                 p++;
2097                 }
2098
2099         return -1;
2100 }
2101
2102 static gint vficon_index_by_id(ViewFile *vf, IconData *in_id)
2103 {
2104         gint p = 0;
2105         GList *work;
2106
2107         if (!in_id) return -1;
2108
2109         work = vf->list;
2110         while (work)
2111                 {
2112                 IconData *id = work->data;
2113                 if (id == in_id) return p;
2114                 work = work->next;
2115                 p++;
2116                 }
2117
2118         return -1;
2119 }
2120
2121 gint vficon_count(ViewFile *vf, gint64 *bytes)
2122 {
2123         if (bytes)
2124                 {
2125                 gint64 b = 0;
2126                 GList *work;
2127
2128                 work = vf->list;
2129                 while (work)
2130                         {
2131
2132                         IconData *id = work->data;
2133                         FileData *fd = id->fd;
2134                         work = work->next;
2135                         b += fd->size;
2136                         }
2137
2138                 *bytes = b;
2139                 }
2140
2141         return g_list_length(vf->list);
2142 }
2143
2144 GList *vficon_get_list(ViewFile *vf)
2145 {
2146         GList *list = NULL;
2147         GList *work;
2148
2149         work = vf->list;
2150         while (work)
2151                 {
2152                 IconData *id = work->data;
2153                 FileData *fd = id->fd;
2154                 work = work->next;
2155
2156                 list = g_list_prepend(list, file_data_ref(fd));
2157                 }
2158
2159         return g_list_reverse(list);
2160 }
2161
2162 /*
2163  *-----------------------------------------------------------------------------
2164  *
2165  *-----------------------------------------------------------------------------
2166  */
2167
2168 static gint vficon_refresh_real(ViewFile *vf, gint keep_position)
2169 {
2170         gint ret = TRUE;
2171         GList *old_list;
2172         GList *work;
2173         IconData *focus_id;
2174
2175         focus_id = VFICON_INFO(vf, focus_id);
2176
2177         old_list = vf->list;
2178         vf->list = NULL;
2179
2180         if (vf->path)
2181                 {
2182                 ret = iconlist_read(vf->path, &vf->list);
2183                 }
2184
2185         /* check for same files from old_list */
2186         work = old_list;
2187         while (work)
2188                 {
2189                 IconData *id;
2190                 FileData *fd;
2191
2192                 GList *needle;
2193
2194                 id = work->data;
2195                 fd = id->fd;
2196
2197                 needle = vf->list;
2198                 while (needle)
2199                         {
2200                         IconData *idn = needle->data;
2201                         FileData *fdn = idn->fd;
2202                         if (fdn == fd)
2203                                 {
2204                                 /* swap, to retain old thumb, selection */
2205                                 needle->data = id;
2206                                 work->data = idn;
2207                                 needle = NULL;
2208                                 }
2209                         else
2210                                 {
2211                                 needle = needle->next;
2212                                 }
2213                         }
2214
2215                 work = work->next;
2216                 }
2217
2218         vf->list = iconlist_sort(vf->list, vf->sort_method, vf->sort_ascend);
2219
2220         work = old_list;
2221         while (work)
2222                 {
2223                 IconData *id = work->data;
2224                 work = work->next;
2225
2226                 if (id == VFICON_INFO(vf, prev_selection)) VFICON_INFO(vf, prev_selection) = NULL;
2227                 if (id == VFICON_INFO(vf, click_id)) VFICON_INFO(vf, click_id) = NULL;
2228                 }
2229
2230         vficon_populate(vf, TRUE, keep_position);
2231
2232         /* attempt to keep focus on same icon when refreshing */
2233         if (focus_id && g_list_find(vf->list, focus_id))
2234                 {
2235                 vficon_set_focus(vf, focus_id);
2236                 }
2237
2238         iconlist_free(old_list);
2239
2240         return ret;
2241 }
2242
2243 gint vficon_refresh(ViewFile *vf)
2244 {
2245         return vficon_refresh_real(vf, TRUE);
2246 }
2247
2248 /*
2249  *-----------------------------------------------------------------------------
2250  * draw, etc.
2251  *-----------------------------------------------------------------------------
2252  */
2253
2254 typedef struct _ColumnData ColumnData;
2255 struct _ColumnData
2256 {
2257         ViewFile *vf;
2258         gint number;
2259 };
2260
2261 static void vficon_cell_data_cb(GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,
2262                                 GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data)
2263 {
2264         ColumnData *cd = data;
2265         ViewFile *vf;
2266         GtkStyle *style;
2267         GList *list;
2268         GdkColor color_fg;
2269         GdkColor color_bg;
2270         IconData *id;
2271
2272         vf = cd->vf;
2273
2274         gtk_tree_model_get(tree_model, iter, FILE_COLUMN_POINTER, &list, -1);
2275
2276         id = g_list_nth_data(list, cd->number);
2277
2278         if (id) g_assert(id->fd->magick == 0x12345678);
2279
2280         style = gtk_widget_get_style(vf->listview);
2281         if (id && id->selected & SELECTION_SELECTED)
2282                 {
2283                 memcpy(&color_fg, &style->text[GTK_STATE_SELECTED], sizeof(color_fg));
2284                 memcpy(&color_bg, &style->base[GTK_STATE_SELECTED], sizeof(color_bg));
2285                 }
2286         else
2287                 {
2288                 memcpy(&color_fg, &style->text[GTK_STATE_NORMAL], sizeof(color_fg));
2289                 memcpy(&color_bg, &style->base[GTK_STATE_NORMAL], sizeof(color_bg));
2290                 }
2291
2292         if (id && id->selected & SELECTION_PRELIGHT)
2293                 {
2294 #if 0
2295                 shift_color(&color_fg, -1, 0);
2296 #endif
2297                 shift_color(&color_bg, -1, 0);
2298                 }
2299
2300         if (GQV_IS_CELL_RENDERER_ICON(cell))
2301                 {
2302                 if (id)
2303                         {
2304                         g_object_set(cell,      "pixbuf", id->fd->pixbuf,
2305                                                 "text", id->fd->name,
2306                                                 "cell-background-gdk", &color_bg,
2307                                                 "cell-background-set", TRUE,
2308                                                 "foreground-gdk", &color_fg,
2309                                                 "foreground-set", TRUE,
2310                                                 "has-focus", (VFICON_INFO(vf, focus_id) == id), NULL);
2311                         }
2312                 else
2313                         {
2314                         g_object_set(cell,      "pixbuf", NULL,
2315                                                 "text", NULL,
2316                                                 "cell-background-set", FALSE,
2317                                                 "foreground-set", FALSE,
2318                                                 "has-focus", FALSE, NULL);
2319                         }
2320                 }
2321 }
2322
2323 static void vficon_append_column(ViewFile *vf, gint n)
2324 {
2325         ColumnData *cd;
2326         GtkTreeViewColumn *column;
2327         GtkCellRenderer *renderer;
2328
2329         column = gtk_tree_view_column_new();
2330         gtk_tree_view_column_set_min_width(column, 0);
2331
2332         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
2333         gtk_tree_view_column_set_alignment(column, 0.5);
2334
2335         renderer = gqv_cell_renderer_icon_new();
2336         gtk_tree_view_column_pack_start(column, renderer, FALSE);
2337         g_object_set(G_OBJECT(renderer), "xpad", THUMB_BORDER_PADDING * 2,
2338                                          "ypad", THUMB_BORDER_PADDING,
2339                                          "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
2340
2341         g_object_set_data(G_OBJECT(column), "column_number", GINT_TO_POINTER(n));
2342
2343         cd = g_new0(ColumnData, 1);
2344         cd->vf = vf;
2345         cd->number = n;
2346         gtk_tree_view_column_set_cell_data_func(column, renderer, vficon_cell_data_cb, cd, g_free);
2347
2348         gtk_tree_view_append_column(GTK_TREE_VIEW(vf->listview), column);
2349 }
2350
2351 /*
2352  *-----------------------------------------------------------------------------
2353  * base
2354  *-----------------------------------------------------------------------------
2355  */
2356
2357 gint vficon_set_path(ViewFile *vf, const gchar *path)
2358 {
2359         gint ret;
2360
2361         if (!path) return FALSE;
2362         if (vf->path && strcmp(path, vf->path) == 0) return TRUE;
2363
2364         g_free(vf->path);
2365         vf->path = g_strdup(path);
2366
2367         g_list_free(VFICON_INFO(vf, selection));
2368         VFICON_INFO(vf, selection) = NULL;
2369
2370         iconlist_free(vf->list);
2371         vf->list = NULL;
2372
2373         /* NOTE: populate will clear the store for us */
2374         ret = vficon_refresh_real(vf, FALSE);
2375
2376         VFICON_INFO(vf, focus_id) = NULL;
2377         vficon_move_focus(vf, 0, 0, FALSE);
2378
2379         return ret;
2380 }
2381
2382 void vficon_destroy_cb(GtkWidget *widget, gpointer data)
2383 {
2384         ViewFile *vf = data;
2385
2386         if (VFICON_INFO(vf, sync_idle_id) != -1) g_source_remove(VFICON_INFO(vf, sync_idle_id));
2387
2388         tip_unschedule(vf);
2389
2390         vficon_thumb_cleanup(vf);
2391
2392         iconlist_free(vf->list);
2393         g_list_free(VFICON_INFO(vf, selection));
2394 }
2395
2396 ViewFile *vficon_new(ViewFile *vf, const gchar *path)
2397 {
2398         GtkListStore *store;
2399         GtkTreeSelection *selection;
2400         gint i;
2401
2402         vf->info = g_new0(ViewFileInfoIcon, 1);
2403
2404         VFICON_INFO(vf, selection) = NULL;
2405         VFICON_INFO(vf, prev_selection) = NULL;
2406
2407         VFICON_INFO(vf, tip_window) = NULL;
2408         VFICON_INFO(vf, tip_delay_id) = -1;
2409
2410         VFICON_INFO(vf, focus_row) = 0;
2411         VFICON_INFO(vf, focus_column) = 0;
2412         VFICON_INFO(vf, focus_id) = NULL;
2413
2414         VFICON_INFO(vf, show_text) = options->show_icon_names;
2415
2416         VFICON_INFO(vf, sync_idle_id) = -1;
2417
2418         store = gtk_list_store_new(1, G_TYPE_POINTER);
2419         vf->listview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
2420         g_object_unref(store);
2421
2422         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vf->listview));
2423         gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_NONE);
2424
2425         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(vf->listview), FALSE);
2426         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(vf->listview), FALSE);
2427
2428         for (i = 0; i < VFICON_MAX_COLUMNS; i++)
2429                 {
2430                 vficon_append_column(vf, i);
2431                 }
2432
2433         /* zero width column to hide tree view focus, we draw it ourselves */
2434         vficon_append_column(vf, i);
2435         /* end column to fill white space */
2436         vficon_append_column(vf, i);
2437
2438         g_signal_connect(G_OBJECT(vf->listview), "size_allocate",
2439                          G_CALLBACK(vficon_sized_cb), vf);
2440
2441         gtk_widget_set_events(vf->listview, GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK |
2442                               GDK_BUTTON_PRESS_MASK | GDK_LEAVE_NOTIFY_MASK);
2443
2444         g_signal_connect(G_OBJECT(vf->listview),"motion_notify_event",
2445                          G_CALLBACK(vficon_motion_cb), vf);
2446         g_signal_connect(G_OBJECT(vf->listview), "leave_notify_event",
2447                          G_CALLBACK(vficon_leave_cb), vf);
2448
2449         /* force VFICON_INFO(vf, columns) to be at least 1 (sane) - this will be corrected in the size_cb */
2450         vficon_populate_at_new_size(vf, 1, 1, FALSE);
2451
2452         return vf;
2453 }
2454
2455 /*
2456  *-----------------------------------------------------------------------------
2457  * maintenance (for rename, move, remove)
2458  *-----------------------------------------------------------------------------
2459  */
2460
2461 static gint vficon_maint_find_closest(ViewFile *vf, gint row, gint count, GList *ignore_list)
2462 {
2463         GList *list = NULL;
2464         GList *work;
2465         gint rev = row - 1;
2466
2467         row++;
2468
2469         work = ignore_list;
2470         while (work)
2471                 {
2472                 FileData *fd = work->data;
2473                 gint f = vficon_index_by_fd(vf, work->data);
2474                 g_assert(fd->magick == 0x12345678);
2475                 if (f >= 0) list = g_list_prepend(list, GINT_TO_POINTER(f));
2476                 work = work->next;
2477                 }
2478
2479         while (list)
2480                 {
2481                 gint c = TRUE;
2482                 work = list;
2483                 while (work && c)
2484                         {
2485                         gpointer p = work->data;
2486                         work = work->next;
2487                         if (row == GPOINTER_TO_INT(p))
2488                                 {
2489                                 row++;
2490                                 c = FALSE;
2491                                 }
2492                         if (rev == GPOINTER_TO_INT(p))
2493                                 {
2494                                 rev--;
2495                                 c = FALSE;
2496                                 }
2497                         if (!c) list = g_list_remove(list, p);
2498                         }
2499                 if (c && list)
2500                         {
2501                         g_list_free(list);
2502                         list = NULL;
2503                         }
2504                 }
2505         if (row > count - 1)
2506                 {
2507                 if (rev < 0)
2508                         return -1;
2509                 else
2510                         return rev;
2511                 }
2512         else
2513                 {
2514                 return row;
2515                 }
2516 }
2517
2518 gint vficon_maint_renamed(ViewFile *vf, FileData *fd)
2519 {
2520         gint ret = FALSE;
2521         gint row;
2522         gchar *source_base;
2523         gchar *dest_base;
2524         IconData *id = vficon_icon_data(vf, fd);
2525
2526         if (!id) return FALSE;
2527
2528         row = vficon_index_by_id(vf, id);
2529         if (row < 0) return FALSE;
2530
2531         source_base = remove_level_from_path(fd->change->source);
2532         dest_base = remove_level_from_path(fd->change->dest);
2533
2534         if (strcmp(source_base, dest_base) == 0)
2535                 {
2536                 vf->list = g_list_remove(vf->list, id);
2537                 vf->list = iconlist_insert_sort(vf->list, id, vf->sort_method, vf->sort_ascend);
2538
2539                 vficon_sync_idle(vf);
2540                 ret = TRUE;
2541                 }
2542         else
2543                 {
2544                 ret = vficon_maint_removed(vf, fd, NULL);
2545                 }
2546
2547         g_free(source_base);
2548         g_free(dest_base);
2549
2550         return ret;
2551 }
2552
2553 gint vficon_maint_removed(ViewFile *vf, FileData *fd, GList *ignore_list)
2554 {
2555         gint row;
2556         gint new_row = -1;
2557         GtkTreeModel *store;
2558         GtkTreeIter iter;
2559         IconData *id = vficon_icon_data(vf, fd);
2560
2561         if (!id) return FALSE;
2562
2563         row = g_list_index(vf->list, id);
2564         if (row < 0) return FALSE;
2565
2566         if ((id->selected & SELECTION_SELECTED) &&
2567             layout_image_get_collection(vf->layout, NULL) == NULL)
2568                 {
2569                 vficon_unselect(vf, id);
2570
2571                 if (!VFICON_INFO(vf, selection))
2572                         {
2573                         gint n;
2574
2575                         n = vficon_count(vf, NULL);
2576                         if (ignore_list)
2577                                 {
2578                                 new_row = vficon_maint_find_closest(vf, row, n, ignore_list);
2579                                 DEBUG_1("row = %d, closest is %d", row, new_row);
2580                                 }
2581                         else
2582                                 {
2583                                 if (row + 1 < n)
2584                                         {
2585                                         new_row = row + 1;
2586                                         }
2587                                 else if (row > 0)
2588                                         {
2589                                         new_row = row - 1;
2590                                         }
2591                                 }
2592                         }
2593                 else if (ignore_list)
2594                         {
2595                         GList *work;
2596
2597                         work = VFICON_INFO(vf, selection);
2598                         while (work)
2599                                 {
2600                                 IconData *ignore_id;
2601                                 FileData *ignore_fd;
2602                                 GList *tmp;
2603                                 gint match = FALSE;
2604
2605                                 ignore_id = work->data;
2606                                 ignore_fd = ignore_id->fd;
2607                                 g_assert(ignore_fd->magick == 0x12345678);
2608                                 work = work->next;
2609
2610                                 tmp = ignore_list;
2611                                 while (tmp && !match)
2612                                         {
2613                                         FileData *ignore_list_fd = tmp->data;
2614                                         g_assert(ignore_list_fd->magick == 0x12345678);
2615                                         tmp = tmp->next;
2616
2617                                         if (ignore_list_fd == ignore_fd)
2618                                                 {
2619                                                 match = TRUE;
2620                                                 }
2621                                         }
2622                                 if (!match)
2623                                         {
2624                                         new_row = g_list_index(vf->list, ignore_id);
2625                                         work = NULL;
2626                                         }
2627                                 }
2628                         if (new_row == -1)
2629                                 {
2630                                 /* selection all ignored, use closest */
2631                                 new_row = vficon_maint_find_closest(vf, row, vficon_count(vf, NULL), ignore_list);
2632                                 }
2633                         }
2634                 else
2635                         {
2636                         new_row = g_list_index(vf->list, VFICON_INFO(vf, selection)->data);
2637                         }
2638                 if (new_row >= 0)
2639                         {
2640                         IconData *idn = g_list_nth_data(vf->list, new_row);
2641
2642                         vficon_select(vf, idn);
2643                         vficon_send_layout_select(vf, idn);
2644                         }
2645                 }
2646
2647         /* Thumb loader check */
2648         if (fd == vf->thumbs_filedata) vf->thumbs_filedata = NULL;
2649         if (vf->thumbs_count > 0) vf->thumbs_count--;
2650
2651         if (VFICON_INFO(vf, prev_selection) == id) VFICON_INFO(vf, prev_selection) = NULL;
2652         if (VFICON_INFO(vf, click_id) == id) VFICON_INFO(vf, click_id) = NULL;
2653
2654         /* remove pointer to this fd from grid */
2655         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vf->listview));
2656         if (id->row >= 0 &&
2657             gtk_tree_model_iter_nth_child(store, &iter, NULL, id->row))
2658                 {
2659                 GList *list;
2660
2661                 gtk_tree_model_get(store, &iter, FILE_COLUMN_POINTER, &list, -1);
2662                 list = g_list_find(list, id);
2663                 if (list) list->data = NULL;
2664                 }
2665
2666         vf->list = g_list_remove(vf->list, id);
2667         file_data_unref(fd);
2668         g_free(id);
2669
2670         vficon_sync_idle(vf);
2671         vficon_send_update(vf);
2672
2673         return TRUE;
2674 }
2675
2676 gint vficon_maint_moved(ViewFile *vf, FileData *fd, GList *ignore_list)
2677 {
2678         gint ret = FALSE;
2679         gchar *buf;
2680
2681         if (!fd->change->source || !vf->path) return FALSE;
2682
2683         buf = remove_level_from_path(fd->change->source);
2684
2685         if (strcmp(buf, vf->path) == 0)
2686                 {
2687                 ret = vficon_maint_removed(vf, fd, ignore_list);
2688                 }
2689
2690         g_free(buf);
2691
2692         return ret;
2693 }