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