src/view_dir_tree.c

   1 /*
   2  * Copyright (C) 2006 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * Author: John Ellis
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "main.h"
  23 #include "view_dir_tree.h"
  24
  25
  26 #include "dnd.h"
  27 #include "dupe.h"
  28 #include "filedata.h"
  29 #include "layout.h"
  30 #include "layout_image.h"
  31 #include "layout_util.h"
  32 #include "utilops.h"
  33 #include "ui_fileops.h"
  34 #include "ui_menu.h"
  35 #include "ui_tree_edit.h"
  36 #include "view_dir.h"
  37
  38 #include <gdk/gdkkeysyms.h> /* for keyboard values */
  39
  40
  41 #define VDTREE(_vd_) ((ViewDirInfoTree *)(_vd_->info))
  42
  43
  44 typedef struct _PathData PathData;
  45 struct _PathData
  46 {
  47         gchar *name;
  48         FileData *node;
  49 };
  50
  51
  52 static void vdtree_row_expanded(GtkTreeView *treeview, GtkTreeIter *iter, GtkTreePath *tpath, gpointer data);
  53
  54
  55 /*
  56  *----------------------------------------------------------------------------
  57  * utils
  58  *----------------------------------------------------------------------------
  59  */
  60
  61 static void set_cursor(GtkWidget *widget, GdkCursorType cursor_type)
  62 {
  63         GdkCursor *cursor = NULL;
  64
  65         if (!widget || !gtk_widget_get_window(widget)) return;
  66
  67         if (cursor_type > -1) cursor = gdk_cursor_new(cursor_type);
  68         gdk_window_set_cursor(gtk_widget_get_window(widget), cursor);
  69         if (cursor) gdk_cursor_unref(cursor);
  70         gdk_flush();
  71 }
  72
  73 static void vdtree_busy_push(ViewDir *vd)
  74 {
  75         if (VDTREE(vd)->busy_ref == 0) set_cursor(vd->view, GDK_WATCH);
  76         VDTREE(vd)->busy_ref++;
  77 }
  78
  79 static void vdtree_busy_pop(ViewDir *vd)
  80 {
  81         if (VDTREE(vd)->busy_ref == 1) set_cursor(vd->view, -1);
  82         if (VDTREE(vd)->busy_ref > 0) VDTREE(vd)->busy_ref--;
  83 }
  84
  85 gboolean vdtree_find_row(ViewDir *vd, FileData *fd, GtkTreeIter *iter, GtkTreeIter *parent)
  86 {
  87         GtkTreeModel *store;
  88         gboolean valid;
  89
  90         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
  91         if (parent)
  92                 {
  93                 valid = gtk_tree_model_iter_children(store, iter, parent);
  94                 }
  95         else
  96                 {
  97                 valid = gtk_tree_model_get_iter_first(store, iter);
  98                 }
  99         while (valid)
 100                 {
 101                 NodeData *nd;
 102                 GtkTreeIter found;
 103
 104                 gtk_tree_model_get(GTK_TREE_MODEL(store), iter, DIR_COLUMN_POINTER, &nd, -1);
 105                 if (nd->fd == fd) return TRUE;
 106
 107                 if (vdtree_find_row(vd, fd, &found, iter))
 108                         {
 109                         memcpy(iter, &found, sizeof(found));
 110                         return TRUE;
 111                         }
 112
 113                 valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(store), iter);
 114                 }
 115
 116         return FALSE;
 117 }
 118
 119 static void vdtree_icon_set_by_iter(ViewDir *vd, GtkTreeIter *iter, GdkPixbuf *pixbuf)
 120 {
 121         GtkTreeModel *store;
 122         GdkPixbuf *old;
 123
 124         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 125         gtk_tree_model_get(store, iter, DIR_COLUMN_ICON, &old, -1);
 126         if (old != vd->pf->deny)
 127                 {
 128                 gtk_tree_store_set(GTK_TREE_STORE(store), iter, DIR_COLUMN_ICON, pixbuf, -1);
 129                 }
 130 }
 131
 132 static void vdtree_expand_by_iter(ViewDir *vd, GtkTreeIter *iter, gboolean expand)
 133 {
 134         GtkTreeModel *store;
 135         GtkTreePath *tpath;
 136         NodeData *nd;
 137         FileData *fd = NULL;
 138
 139         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 140         tpath = gtk_tree_model_get_path(store, iter);
 141
 142         if (expand)
 143                 {
 144                 /* block signal handler, icon is set here, the caller of vdtree_expand_by_iter must make sure
 145                    that the iter is populated */
 146                 g_signal_handlers_block_by_func(G_OBJECT(vd->view), vdtree_row_expanded, vd);
 147                 gtk_tree_view_expand_row(GTK_TREE_VIEW(vd->view), tpath, FALSE);
 148                 gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);
 149                 fd = (nd) ? nd->fd : NULL;
 150
 151                 if (fd && islink(fd->path))
 152                         {
 153                         vdtree_icon_set_by_iter(vd, iter, vd->pf->link);
 154                         }
 155                 else
 156                         {
 157                         vdtree_icon_set_by_iter(vd, iter, vd->pf->open);
 158                         }
 159
 160                 g_signal_handlers_unblock_by_func(G_OBJECT(vd->view), vdtree_row_expanded, vd);
 161                 }
 162         else
 163                 {
 164                 /* signal handler vdtree_row_collapsed is called, it updates the icon */
 165                 gtk_tree_view_collapse_row(GTK_TREE_VIEW(vd->view), tpath);
 166                 }
 167         gtk_tree_path_free(tpath);
 168 }
 169
 170 static void vdtree_expand_by_data(ViewDir *vd, FileData *fd, gboolean expand)
 171 {
 172         GtkTreeIter iter;
 173
 174         if (vd_find_row(vd, fd, &iter))
 175                 {
 176                 vdtree_expand_by_iter(vd, &iter, expand);
 177                 }
 178 }
 179
 180 static void vdtree_node_free(NodeData *nd)
 181 {
 182         if (!nd) return;
 183
 184         if (nd->fd) file_data_unref(nd->fd);
 185         g_free(nd);
 186 }
 187
 188 /*
 189  *----------------------------------------------------------------------------
 190  * dnd
 191  *----------------------------------------------------------------------------
 192  */
 193
 194 static gboolean vdtree_dnd_drop_expand_cb(gpointer data)
 195 {
 196         ViewDir *vd = data;
 197         GtkTreeIter iter;
 198
 199         if (vd->drop_fd && vd_find_row(vd, vd->drop_fd, &iter))
 200                 {
 201                 vdtree_populate_path_by_iter(vd, &iter, FALSE, vd->dir_fd);
 202                 vdtree_expand_by_data(vd, vd->drop_fd, TRUE);
 203                 }
 204
 205         VDTREE(vd)->drop_expand_id = 0;
 206         return FALSE;
 207 }
 208
 209 static void vdtree_dnd_drop_expand_cancel(ViewDir *vd)
 210 {
 211         if (VDTREE(vd)->drop_expand_id)
 212                 {
 213                 g_source_remove(VDTREE(vd)->drop_expand_id);
 214                 VDTREE(vd)->drop_expand_id = 0;
 215                 }
 216 }
 217
 218 static void vdtree_dnd_drop_expand(ViewDir *vd)
 219 {
 220         vdtree_dnd_drop_expand_cancel(vd);
 221         VDTREE(vd)->drop_expand_id = g_timeout_add(1000, vdtree_dnd_drop_expand_cb, vd);
 222 }
 223
 224 /*
 225  *----------------------------------------------------------------------------
 226  * parts lists
 227  *----------------------------------------------------------------------------
 228  */
 229
 230 static GList *parts_list(const gchar *path)
 231 {
 232         GList *list = NULL;
 233         const gchar *strb, *strp;
 234         gint l;
 235
 236         strp = path;
 237
 238         if (*strp != G_DIR_SEPARATOR) return NULL;
 239
 240         strp++;
 241         strb = strp;
 242         l = 0;
 243
 244         while (*strp != '\0')
 245                 {
 246                 if (*strp == G_DIR_SEPARATOR)
 247                         {
 248                         if (l > 0) list = g_list_prepend(list, g_strndup(strb, l));
 249                         strp++;
 250                         strb = strp;
 251                         l = 0;
 252                         }
 253                 else
 254                         {
 255                         strp++;
 256                         l++;
 257                         }
 258                 }
 259         if (l > 0) list = g_list_prepend(list, g_strndup(strb, l));
 260
 261         list = g_list_reverse(list);
 262
 263         list = g_list_prepend(list, g_strdup(G_DIR_SEPARATOR_S));
 264
 265         return list;
 266 }
 267
 268 static void parts_list_free(GList *list)
 269 {
 270         GList *work = list;
 271         while (work)
 272                 {
 273                 PathData *pd = work->data;
 274                 g_free(pd->name);
 275                 g_free(pd);
 276                 work = work->next;
 277                 }
 278
 279         g_list_free(list);
 280 }
 281
 282 static GList *parts_list_add_node_points(ViewDir *vd, GList *list)
 283 {
 284         GList *work;
 285         GtkTreeModel *store;
 286         GtkTreeIter iter;
 287         gboolean valid;
 288
 289         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 290         valid = gtk_tree_model_get_iter_first(store, &iter);
 291
 292         work = list;
 293         while (work)
 294                 {
 295                 PathData *pd;
 296                 FileData *fd = NULL;
 297
 298                 pd = g_new0(PathData, 1);
 299                 pd->name = work->data;
 300
 301                 while (valid && !fd)
 302                         {
 303                         NodeData *nd;
 304
 305                         gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &nd, -1);
 306                         if (nd->fd && strcmp(nd->fd->name, pd->name) == 0)
 307                                 {
 308                                 fd = nd->fd;
 309                                 }
 310                         else
 311                                 {
 312                                 valid = gtk_tree_model_iter_next(store, &iter);
 313                                 }
 314                         }
 315
 316                 pd->node = fd;
 317                 work->data = pd;
 318
 319                 if (fd)
 320                         {
 321                         GtkTreeIter parent;
 322                         memcpy(&parent, &iter, sizeof(parent));
 323                         valid = gtk_tree_model_iter_children(store, &iter, &parent);
 324                         }
 325
 326                 work = work->next;
 327                 }
 328
 329         return list;
 330 }
 331
 332
 333 /*
 334  *----------------------------------------------------------------------------
 335  * node traversal, management
 336  *----------------------------------------------------------------------------
 337  */
 338
 339 static gboolean vdtree_find_iter_by_data(ViewDir *vd, GtkTreeIter *parent, NodeData *nd, GtkTreeIter *iter)
 340 {
 341         GtkTreeModel *store;
 342
 343         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 344         if (!nd || !gtk_tree_model_iter_children(store, iter, parent)) return -1;
 345         do      {
 346                 NodeData *cnd;
 347
 348                 gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &cnd, -1);
 349                 if (cnd == nd) return TRUE;
 350                 } while (gtk_tree_model_iter_next(store, iter));
 351
 352         return FALSE;
 353 }
 354
 355 static NodeData *vdtree_find_iter_by_name(ViewDir *vd, GtkTreeIter *parent, const gchar *name, GtkTreeIter *iter)
 356 {
 357         GtkTreeModel *store;
 358
 359         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 360         if (!name || !gtk_tree_model_iter_children(store, iter, parent)) return NULL;
 361         do      {
 362                 NodeData *nd;
 363
 364                 gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);
 365                 if (nd && strcmp(nd->fd->name, name) == 0) return nd;
 366                 } while (gtk_tree_model_iter_next(store, iter));
 367
 368         return NULL;
 369 }
 370
 371 static NodeData *vdtree_find_iter_by_fd(ViewDir *vd, GtkTreeIter *parent, FileData *fd, GtkTreeIter *iter)
 372 {
 373         GtkTreeModel *store;
 374
 375         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 376         if (!fd || !gtk_tree_model_iter_children(store, iter, parent)) return NULL;
 377         do      {
 378                 NodeData *nd;
 379
 380                 gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);
 381                 if (nd && nd->fd == fd) return nd;
 382                 } while (gtk_tree_model_iter_next(store, iter));
 383
 384         return NULL;
 385 }
 386
 387 static void vdtree_add_by_data(ViewDir *vd, FileData *fd, GtkTreeIter *parent)
 388 {
 389         GtkTreeStore *store;
 390         GtkTreeIter child;
 391         NodeData *nd;
 392         GdkPixbuf *pixbuf;
 393         NodeData *end;
 394         GtkTreeIter empty;
 395         gchar *link = NULL;
 396
 397         if (!fd) return;
 398
 399         if (access_file(fd->path, R_OK | X_OK))
 400                 {
 401                 if (islink(fd->path))
 402                         {
 403                         pixbuf = vd->pf->link;
 404                         }
 405                 else
 406                         {
 407                         pixbuf = vd->pf->close;
 408                         }
 409                 }
 410         else
 411                 {
 412                 pixbuf = vd->pf->deny;
 413                 }
 414
 415         nd = g_new0(NodeData, 1);
 416         nd->fd = fd;
 417         nd->version = fd->version;
 418         nd->expanded = FALSE;
 419         nd->last_update = time(NULL);
 420
 421         if (islink(fd->path))
 422                 {
 423                 link = realpath(fd->path, NULL);
 424                 }
 425         else
 426                 {
 427                 link = NULL;
 428                 }
 429
 430         store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view)));
 431         gtk_tree_store_append(store, &child, parent);
 432         gtk_tree_store_set(store, &child, DIR_COLUMN_POINTER, nd,
 433                                          DIR_COLUMN_ICON, pixbuf,
 434                                          DIR_COLUMN_NAME, nd->fd->name,
 435                                          DIR_COLUMN_LINK, link,
 436                                          DIR_COLUMN_COLOR, FALSE, -1);
 437
 438         /* all nodes are created with an "empty" node, so that the expander is shown
 439          * this is removed when the child is populated */
 440         end = g_new0(NodeData, 1);
 441         end->fd = NULL;
 442         end->expanded = TRUE;
 443
 444         gtk_tree_store_append(store, &empty, &child);
 445         gtk_tree_store_set(store, &empty, DIR_COLUMN_POINTER, end,
 446                                           DIR_COLUMN_NAME, "empty", -1);
 447
 448         if (parent)
 449                 {
 450                 NodeData *pnd;
 451                 GtkTreePath *tpath;
 452
 453                 gtk_tree_model_get(GTK_TREE_MODEL(store), parent, DIR_COLUMN_POINTER, &pnd, -1);
 454                 tpath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), parent);
 455                 if (options->tree_descend_subdirs &&
 456                     gtk_tree_view_row_expanded(GTK_TREE_VIEW(vd->view), tpath) &&
 457                     !nd->expanded)
 458                         {
 459                         vdtree_populate_path_by_iter(vd, &child, FALSE, vd->dir_fd);
 460                         }
 461                 gtk_tree_path_free(tpath);
 462                 }
 463
 464         g_free(link);
 465 }
 466
 467 gboolean vdtree_populate_path_by_iter(ViewDir *vd, GtkTreeIter *iter, gboolean force, FileData *target_fd)
 468 {
 469         GtkTreeModel *store;
 470         GList *list;
 471         GList *work;
 472         GList *old;
 473         time_t current_time;
 474         GtkTreeIter child;
 475         NodeData *nd;
 476         gboolean add_hidden = FALSE;
 477         gchar *link = NULL;
 478
 479         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 480         gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);
 481
 482         if (!nd) return FALSE;
 483
 484         current_time = time(NULL);
 485
 486         if (nd->expanded)
 487                 {
 488                 if (!nd->fd || !isdir(nd->fd->path))
 489                         {
 490                         if (vd->click_fd == nd->fd) vd->click_fd = NULL;
 491                         if (vd->drop_fd == nd->fd) vd->drop_fd = NULL;
 492                         gtk_tree_store_remove(GTK_TREE_STORE(store), iter);
 493                         vdtree_node_free(nd);
 494                         return FALSE;
 495                         }
 496                 if (!force && current_time - nd->last_update < 2)
 497                         {
 498                         DEBUG_1("Too frequent update of %s", nd->fd->path);
 499                         return TRUE;
 500                         }
 501                 file_data_check_changed_files(nd->fd); /* make sure we have recent info */
 502                 }
 503
 504         /* when hidden files are not enabled, and the user enters a hidden path,
 505          * allow the tree to display that path by specifically inserting the hidden entries
 506          */
 507         if (!options->file_filter.show_hidden_files &&
 508             target_fd &&
 509             strncmp(nd->fd->path, target_fd->path, strlen(nd->fd->path)) == 0)
 510                 {
 511                 gint n;
 512
 513                 n = strlen(nd->fd->path);
 514                 if (target_fd->path[n] == G_DIR_SEPARATOR && target_fd->path[n+1] == '.')
 515                         add_hidden = TRUE;
 516                 }
 517
 518         if (nd->expanded && (!force && !add_hidden) && nd->fd->version == nd->version)
 519                 return TRUE;
 520
 521         vdtree_busy_push(vd);
 522
 523         filelist_read(nd->fd, NULL, &list);
 524
 525         if (add_hidden)
 526                 {
 527                 gint n;
 528                 gchar *name8;
 529
 530                 n = strlen(nd->fd->path) + 1;
 531
 532                 while (target_fd->path[n] != '\0' && target_fd->path[n] != G_DIR_SEPARATOR) n++;
 533                 name8 = g_strndup(target_fd->path, n);
 534
 535                 if (isdir(name8))
 536                         {
 537                         list = g_list_prepend(list, file_data_new_dir(name8));
 538                         }
 539
 540                 g_free(name8);
 541                 }
 542
 543         old = NULL;
 544         if (gtk_tree_model_iter_children(store, &child, iter))
 545                 {
 546                 do      {
 547                         NodeData *cnd;
 548
 549                         gtk_tree_model_get(store, &child, DIR_COLUMN_POINTER, &cnd, -1);
 550                         old = g_list_prepend(old, cnd);
 551                         } while (gtk_tree_model_iter_next(store, &child));
 552                 }
 553
 554         work = list;
 555         while (work)
 556                 {
 557                 FileData *fd;
 558
 559                 fd = work->data;
 560                 work = work->next;
 561
 562                 if (strcmp(fd->name, ".") == 0 || strcmp(fd->name, "..") == 0)
 563                         {
 564                         file_data_unref(fd);
 565                         }
 566                 else
 567                         {
 568                         NodeData *cnd;
 569
 570                         cnd = vdtree_find_iter_by_fd(vd, iter, fd, &child);
 571                         if (cnd)
 572                                 {
 573                                 if (cnd->expanded && cnd->version != fd->version)
 574                                         {
 575                                         vdtree_populate_path_by_iter(vd, &child, FALSE, target_fd);
 576                                         }
 577
 578                                 gtk_tree_store_set(GTK_TREE_STORE(store), &child, DIR_COLUMN_NAME, fd->name, -1);
 579
 580                                 if (islink(fd->path))
 581                                         {
 582                                         link = realpath(fd->path, NULL);
 583                                         }
 584                                 else
 585                                         {
 586                                         link = NULL;
 587                                         }
 588
 589                                 gtk_tree_store_set(GTK_TREE_STORE(store), &child, DIR_COLUMN_LINK, link, -1);
 590
 591                                 cnd->version = fd->version;
 592                                 old = g_list_remove(old, cnd);
 593                                 file_data_unref(fd);
 594                                 }
 595                         else
 596                                 {
 597                                 vdtree_add_by_data(vd, fd, iter);
 598                                 }
 599                         }
 600                 }
 601
 602         work = old;
 603         while (work)
 604                 {
 605                 NodeData *cnd = work->data;
 606                 work = work->next;
 607
 608                 if (vd->click_fd == cnd->fd) vd->click_fd = NULL;
 609                 if (vd->drop_fd == cnd->fd) vd->drop_fd = NULL;
 610
 611                 if (vdtree_find_iter_by_data(vd, iter, cnd, &child))
 612                         {
 613                         gtk_tree_store_remove(GTK_TREE_STORE(store), &child);
 614                         vdtree_node_free(cnd);
 615                         }
 616                 }
 617
 618         g_list_free(old);
 619         g_list_free(list);
 620
 621         vdtree_busy_pop(vd);
 622
 623         nd->expanded = TRUE;
 624         nd->last_update = current_time;
 625
 626         g_free(link);
 627
 628         return TRUE;
 629 }
 630
 631 FileData *vdtree_populate_path(ViewDir *vd, FileData *target_fd, gboolean expand, gboolean force)
 632 {
 633         GList *list;
 634         GList *work;
 635         FileData *fd = NULL;
 636
 637         if (!target_fd) return NULL;
 638
 639         vdtree_busy_push(vd);
 640
 641         list = parts_list(target_fd->path);
 642         list = parts_list_add_node_points(vd, list);
 643
 644         work = list;
 645         while (work)
 646                 {
 647                 PathData *pd = work->data;
 648                 if (pd->node == NULL)
 649                         {
 650                         PathData *parent_pd;
 651                         GtkTreeIter parent_iter;
 652                         GtkTreeIter iter;
 653                         NodeData *nd;
 654
 655                         if (work == list)
 656                                 {
 657                                 /* should not happen */
 658                                 log_printf("vdtree warning, root node not found\n");
 659                                 parts_list_free(list);
 660                                 vdtree_busy_pop(vd);
 661                                 return NULL;
 662                                 }
 663
 664                         parent_pd = work->prev->data;
 665
 666                         if (!vd_find_row(vd, parent_pd->node, &parent_iter) ||
 667                             !vdtree_populate_path_by_iter(vd, &parent_iter, force, target_fd) ||
 668                             (nd = vdtree_find_iter_by_name(vd, &parent_iter, pd->name, &iter)) == NULL)
 669                                 {
 670                                 log_printf("vdtree warning, aborted at %s\n", parent_pd->name);
 671                                 parts_list_free(list);
 672                                 vdtree_busy_pop(vd);
 673                                 return NULL;
 674                                 }
 675
 676                         pd->node = nd->fd;
 677
 678                         if (pd->node)
 679                                 {
 680                                 if (expand)
 681                                         {
 682                                         vdtree_expand_by_iter(vd, &parent_iter, TRUE);
 683                                         vdtree_expand_by_iter(vd, &iter, TRUE);
 684                                         }
 685                                 vdtree_populate_path_by_iter(vd, &iter, force, target_fd);
 686                                 }
 687                         }
 688                 else
 689                         {
 690                         GtkTreeIter iter;
 691
 692                         if (vd_find_row(vd, pd->node, &iter))
 693                                 {
 694                                 if (expand) vdtree_expand_by_iter(vd, &iter, TRUE);
 695                                 vdtree_populate_path_by_iter(vd, &iter, force, target_fd);
 696                                 }
 697                         }
 698
 699                 work = work->next;
 700                 }
 701
 702         work = g_list_last(list);
 703         if (work)
 704                 {
 705                 PathData *pd = work->data;
 706                 fd = pd->node;
 707                 }
 708         parts_list_free(list);
 709
 710         vdtree_busy_pop(vd);
 711
 712         return fd;
 713 }
 714
 715 /*
 716  *----------------------------------------------------------------------------
 717  * access
 718  *----------------------------------------------------------------------------
 719  */
 720
 721 static gboolean selection_is_ok = FALSE;
 722
 723 static gboolean vdtree_select_cb(GtkTreeSelection *selection, GtkTreeModel *store, GtkTreePath *tpath,
 724                                  gboolean path_currently_selected, gpointer data)
 725 {
 726         return selection_is_ok;
 727 }
 728
 729 gboolean vdtree_set_fd(ViewDir *vd, FileData *dir_fd)
 730 {
 731         FileData *fd;
 732         GtkTreeIter iter;
 733
 734         if (!dir_fd) return FALSE;
 735         if (vd->dir_fd == dir_fd) return TRUE;
 736
 737         file_data_unref(vd->dir_fd);
 738         vd->dir_fd = file_data_ref(dir_fd);;
 739
 740         fd = vdtree_populate_path(vd, vd->dir_fd, TRUE, FALSE);
 741
 742         if (!fd) return FALSE;
 743
 744         if (vd_find_row(vd, fd, &iter))
 745                 {
 746                 GtkTreeModel *store;
 747                 GtkTreePath *tpath, *old_tpath;
 748                 GtkTreeSelection *selection;
 749
 750                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
 751
 752                 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vd->view));
 753
 754                 /* hack, such that selection is only allowed to be changed from here */
 755                 selection_is_ok = TRUE;
 756                 gtk_tree_selection_select_iter(selection, &iter);
 757                 selection_is_ok = FALSE;
 758
 759                 gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &old_tpath, NULL);
 760                 tpath = gtk_tree_model_get_path(store, &iter);
 761
 762                 if (!old_tpath || gtk_tree_path_compare(tpath, old_tpath) != 0)
 763                         {
 764                         /* setting the cursor scrolls the view; do not do that unless it is necessary */
 765                         gtk_tree_view_set_cursor(GTK_TREE_VIEW(vd->view), tpath, NULL, FALSE);
 766
 767                         /* gtk_tree_view_set_cursor scrolls the window itself, but it sometimes
 768                            does not work (switch from dir_list to dir_tree) */
 769                         tree_view_row_make_visible(GTK_TREE_VIEW(vd->view), &iter, TRUE);
 770                         }
 771                 gtk_tree_path_free(tpath);
 772                 gtk_tree_path_free(old_tpath);
 773                 }
 774
 775         return TRUE;
 776 }
 777
 778 void vdtree_refresh(ViewDir *vd)
 779 {
 780         vdtree_populate_path(vd, vd->dir_fd, FALSE, TRUE);
 781 }
 782
 783 const gchar *vdtree_row_get_path(ViewDir *vd, gint row)
 784 {
 785 /** @FIXME no get row path */
 786         log_printf("FIXME: no get row path\n");
 787         return NULL;
 788 }
 789
 790 /*
 791  *----------------------------------------------------------------------------
 792  * callbacks
 793  *----------------------------------------------------------------------------
 794  */
 795
 796 gboolean vdtree_press_key_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
 797 {
 798         ViewDir *vd = data;
 799         GtkTreePath *tpath;
 800         GtkTreeIter iter;
 801         FileData *fd = NULL;
 802
 803         gtk_tree_view_get_cursor(GTK_TREE_VIEW(vd->view), &tpath, NULL);
 804         if (tpath)
 805                 {
 806                 GtkTreeModel *store;
 807                 NodeData *nd;
 808
 809                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
 810                 gtk_tree_model_get_iter(store, &iter, tpath);
 811                 gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &nd, -1);
 812
 813                 gtk_tree_path_free(tpath);
 814
 815                 fd = (nd) ? nd->fd : NULL;
 816                 }
 817
 818         switch (event->keyval)
 819                 {
 820                 case GDK_KEY_Menu:
 821                         vd->click_fd = fd;
 822                         vd_color_set(vd, vd->click_fd, TRUE);
 823
 824                         vd->popup = vd_pop_menu(vd, vd->click_fd);
 825                         gtk_menu_popup(GTK_MENU(vd->popup), NULL, NULL, vd_menu_position_cb, vd, 0, GDK_CURRENT_TIME);
 826
 827                         return TRUE;
 828                         break;
 829                 case GDK_KEY_plus:
 830                 case GDK_KEY_Right:
 831                 case GDK_KEY_KP_Add:
 832                         if (fd)
 833                                 {
 834                                 vdtree_populate_path_by_iter(vd, &iter, FALSE, vd->dir_fd);
 835
 836                                 if (islink(fd->path))
 837                                         {
 838                                         vdtree_icon_set_by_iter(vd, &iter, vd->pf->link);
 839                                         }
 840                                 else
 841                                         {
 842                                         vdtree_icon_set_by_iter(vd, &iter, vd->pf->open);
 843                                         }
 844                                 }
 845                         break;
 846                 }
 847
 848         return FALSE;
 849 }
 850
 851 static gboolean vdtree_clicked_on_expander(GtkTreeView *treeview, GtkTreePath *tpath,
 852                                            GtkTreeViewColumn *column, gint x, gint y, gint *left_of_expander)
 853 {
 854         gint depth;
 855         gint size;
 856         gint sep;
 857         gint exp_width;
 858
 859         if (column != gtk_tree_view_get_expander_column(treeview)) return FALSE;
 860
 861         gtk_widget_style_get(GTK_WIDGET(treeview), "expander-size", &size, "horizontal-separator", &sep, NULL);
 862         depth = gtk_tree_path_get_depth(tpath);
 863
 864         exp_width = sep + size + sep;
 865
 866         if (x <= depth * exp_width)
 867                 {
 868                 if (left_of_expander) *left_of_expander = !(x >= (depth - 1) * exp_width);
 869                 return TRUE;
 870                 }
 871
 872         return FALSE;
 873 }
 874
 875 gboolean vdtree_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
 876 {
 877         ViewDir *vd = data;
 878         GtkTreePath *tpath;
 879         GtkTreeViewColumn *column;
 880         GtkTreeIter iter;
 881         NodeData *nd = NULL;
 882         FileData *fd;
 883
 884         if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget), bevent->x, bevent->y,
 885                                           &tpath, &column, NULL, NULL))
 886                 {
 887                 GtkTreeModel *store;
 888                 gint left_of_expander;
 889
 890                 store = gtk_tree_view_get_model(GTK_TREE_VIEW(widget));
 891                 gtk_tree_model_get_iter(store, &iter, tpath);
 892                 gtk_tree_model_get(store, &iter, DIR_COLUMN_POINTER, &nd, -1);
 893                 gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget), tpath, NULL, FALSE);
 894
 895                 if (vdtree_clicked_on_expander(GTK_TREE_VIEW(widget), tpath, column, bevent->x, bevent->y, &left_of_expander))
 896                         {
 897                         vd->click_fd = NULL;
 898
 899                         /* clicking this region should automatically reveal an expander, if necessary
 900                          * treeview bug: the expander will not expand until a button_motion_event highlights it.
 901                          */
 902                         if (bevent->button == MOUSE_BUTTON_LEFT &&
 903                             !left_of_expander &&
 904                             !gtk_tree_view_row_expanded(GTK_TREE_VIEW(vd->view), tpath))
 905                                 {
 906                                 vdtree_populate_path_by_iter(vd, &iter, FALSE, vd->dir_fd);
 907
 908                                 fd = (nd) ? nd->fd : NULL;
 909                                 if (fd && islink(fd->path))
 910                                         {
 911                                         vdtree_icon_set_by_iter(vd, &iter, vd->pf->link);
 912                                         }
 913                                 else
 914                                         {
 915                                         vdtree_icon_set_by_iter(vd, &iter, vd->pf->open);
 916                                         }
 917                                 }
 918
 919                         gtk_tree_path_free(tpath);
 920                         return FALSE;
 921                         }
 922
 923                 gtk_tree_path_free(tpath);
 924                 }
 925
 926         vd->click_fd = (nd) ? nd->fd : NULL;
 927         vd_color_set(vd, vd->click_fd, TRUE);
 928
 929         if (bevent->button == MOUSE_BUTTON_RIGHT)
 930                 {
 931                 vd->popup = vd_pop_menu(vd, vd->click_fd);
 932                 gtk_menu_popup(GTK_MENU(vd->popup), NULL, NULL, NULL, NULL,
 933                                bevent->button, bevent->time);
 934                 }
 935
 936         return (bevent->button != MOUSE_BUTTON_LEFT);
 937 }
 938
 939 static void vdtree_row_expanded(GtkTreeView *treeview, GtkTreeIter *iter, GtkTreePath *tpath, gpointer data)
 940 {
 941         ViewDir *vd = data;
 942         GtkTreeModel *store;
 943         NodeData *nd = NULL;
 944         FileData *fd;
 945
 946         gtk_tree_view_set_tooltip_column(treeview, DIR_COLUMN_LINK);
 947
 948         vdtree_populate_path_by_iter(vd, iter, FALSE, NULL);
 949         store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
 950
 951         gtk_tree_model_get_iter(store, iter, tpath);
 952         gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);
 953
 954         fd = (nd) ? nd->fd : NULL;
 955         if (fd && islink(fd->path))
 956                 {
 957                 vdtree_icon_set_by_iter(vd, iter, vd->pf->link);
 958                 }
 959         else
 960                 {
 961                 vdtree_icon_set_by_iter(vd, iter, vd->pf->open);
 962                 }
 963 }
 964
 965 static void vdtree_row_collapsed(GtkTreeView *treeview, GtkTreeIter *iter, GtkTreePath *tpath, gpointer data)
 966 {
 967         ViewDir *vd = data;
 968         GtkTreeModel *store;
 969         NodeData *nd = NULL;
 970         FileData *fd;
 971
 972         vdtree_populate_path_by_iter(vd, iter, FALSE, NULL);
 973         store = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
 974
 975         gtk_tree_model_get_iter(store, iter, tpath);
 976         gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);
 977
 978         fd = (nd) ? nd->fd : NULL;
 979         if (fd && islink(fd->path))
 980                 {
 981                 vdtree_icon_set_by_iter(vd, iter, vd->pf->link);
 982                 }
 983         else
 984                 {
 985                 vdtree_icon_set_by_iter(vd, iter, vd->pf->close);
 986                 }
 987 }
 988
 989 static gint vdtree_sort_cb(GtkTreeModel *store, GtkTreeIter *a, GtkTreeIter *b, gpointer data)
 990 {
 991         NodeData *nda;
 992         NodeData *ndb;
 993
 994         gtk_tree_model_get(store, a, DIR_COLUMN_POINTER, &nda, -1);
 995         gtk_tree_model_get(store, b, DIR_COLUMN_POINTER, &ndb, -1);
 996
 997         if (!nda->fd && !ndb->fd) return 0;
 998         if (!nda->fd) return 1;
 999         if (!ndb->fd) return -1;
1000
1001         if (options->file_sort.case_sensitive)
1002                 return strcmp(nda->fd->collate_key_name, ndb->fd->collate_key_name);
1003         else
1004                 return strcmp(nda->fd->collate_key_name_nocase, ndb->fd->collate_key_name_nocase);
1005 }
1006
1007 /*
1008  *----------------------------------------------------------------------------
1009  * core
1010  *----------------------------------------------------------------------------
1011  */
1012
1013 static void vdtree_setup_root(ViewDir *vd)
1014 {
1015         const gchar *path = G_DIR_SEPARATOR_S;
1016         FileData *fd;
1017
1018
1019         fd = file_data_new_dir(path);
1020         vdtree_add_by_data(vd, fd, NULL);
1021
1022         vdtree_expand_by_data(vd, fd, TRUE);
1023         vdtree_populate_path(vd, fd, FALSE, FALSE);
1024 }
1025
1026 static gboolean vdtree_destroy_node_cb(GtkTreeModel *store, GtkTreePath *tpath, GtkTreeIter *iter, gpointer data)
1027 {
1028         NodeData *nd;
1029
1030         gtk_tree_model_get(store, iter, DIR_COLUMN_POINTER, &nd, -1);
1031         vdtree_node_free(nd);
1032
1033         return FALSE;
1034 }
1035
1036 void vdtree_destroy_cb(GtkWidget *widget, gpointer data)
1037 {
1038         ViewDir *vd = data;
1039         GtkTreeModel *store;
1040
1041         vdtree_dnd_drop_expand_cancel(vd);
1042         vd_dnd_drop_scroll_cancel(vd);
1043         widget_auto_scroll_stop(vd->view);
1044
1045         store = gtk_tree_view_get_model(GTK_TREE_VIEW(vd->view));
1046         gtk_tree_model_foreach(store, vdtree_destroy_node_cb, vd);
1047 }
1048
1049 ViewDir *vdtree_new(ViewDir *vd, FileData *dir_fd)
1050 {
1051         GtkTreeStore *store;
1052         GtkTreeSelection *selection;
1053         GtkTreeViewColumn *column;
1054         GtkCellRenderer *renderer;
1055
1056         vd->info = g_new0(ViewDirInfoTree, 1);
1057
1058         vd->type = DIRVIEW_TREE;
1059
1060         vd->dnd_drop_leave_func = vdtree_dnd_drop_expand_cancel;
1061         vd->dnd_drop_update_func = vdtree_dnd_drop_expand;
1062
1063         store = gtk_tree_store_new(6, G_TYPE_POINTER, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING);
1064         vd->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
1065         g_object_unref(store);
1066
1067         gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(vd->view), FALSE);
1068         gtk_tree_view_set_enable_search(GTK_TREE_VIEW(vd->view), FALSE);
1069         gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), vdtree_sort_cb, vd, NULL);
1070         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store),
1071                                              GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
1072
1073         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(vd->view));
1074         gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
1075         gtk_tree_selection_set_select_function(selection, vdtree_select_cb, vd, NULL);
1076
1077         column = gtk_tree_view_column_new();
1078         gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_GROW_ONLY);
1079
1080         renderer = gtk_cell_renderer_pixbuf_new();
1081         gtk_tree_view_column_pack_start(column, renderer, FALSE);
1082         gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", DIR_COLUMN_ICON);
1083         gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, NULL);
1084
1085         renderer = gtk_cell_renderer_text_new();
1086         gtk_tree_view_column_pack_start(column, renderer, TRUE);
1087         gtk_tree_view_column_add_attribute(column, renderer, "text", DIR_COLUMN_NAME);
1088         gtk_tree_view_column_set_cell_data_func(column, renderer, vd_color_cb, vd, NULL);
1089
1090         gtk_tree_view_append_column(GTK_TREE_VIEW(vd->view), column);
1091
1092         gtk_tree_view_set_tooltip_column(GTK_TREE_VIEW(vd->view), DIR_COLUMN_LINK);
1093
1094         vdtree_setup_root(vd);
1095
1096         g_signal_connect(G_OBJECT(vd->view), "row_expanded",
1097                          G_CALLBACK(vdtree_row_expanded), vd);
1098         g_signal_connect(G_OBJECT(vd->view), "row_collapsed",
1099                          G_CALLBACK(vdtree_row_collapsed), vd);
1100
1101         return vd;
1102 }
1103 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */