tree.c

   1 /*
   2  * Copyright 2006 Timo Hirvonen
   3  */
   4
   5 #include "lib.h"
   6 #include "search_mode.h"
   7 #include "xmalloc.h"
   8 #include "comment.h"
   9 #include "utils.h"
  10 #include "debug.h"
  11 #include "mergesort.h"
  12 #include "options.h"
  13
  14 struct searchable *tree_searchable;
  15 struct window *lib_tree_win;
  16 struct window *lib_track_win;
  17 struct window *lib_cur_win;
  18 LIST_HEAD(lib_artist_head);
  19
  20 /* tree (search) iterators {{{ */
  21 static int tree_search_get_prev(struct iter *iter)
  22 {
  23         struct list_head *head = iter->data0;
  24         struct tree_track *track = iter->data1;
  25         struct artist *artist;
  26         struct album *album;
  27
  28         BUG_ON(iter->data2);
  29         if (head == NULL)
  30                 return 0;
  31         if (track == NULL) {
  32                 /* head, get last track */
  33                 if (head->prev == head) {
  34                         /* empty, iter points to the head already */
  35                         return 0;
  36                 }
  37                 artist = to_artist(head->prev);
  38                 album = to_album(artist->album_head.prev);
  39                 iter->data1 = to_tree_track(album->track_head.prev);
  40                 return 1;
  41         }
  42         /* prev track */
  43         if (track->node.prev == &track->album->track_head || search_restricted) {
  44                 /* prev album */
  45                 if (track->album->node.prev == &track->album->artist->album_head) {
  46                         /* prev artist */
  47                         if (track->album->artist->node.prev == &lib_artist_head)
  48                                 return 0;
  49                         artist = to_artist(track->album->artist->node.prev);
  50                         album = to_album(artist->album_head.prev);
  51                         track = to_tree_track(album->track_head.prev);
  52                 } else {
  53                         album = to_album(track->album->node.prev);
  54                         track = to_tree_track(album->track_head.prev);
  55                 }
  56         } else {
  57                 track = to_tree_track(track->node.prev);
  58         }
  59         iter->data1 = track;
  60         return 1;
  61 }
  62
  63 static int tree_search_get_next(struct iter *iter)
  64 {
  65         struct list_head *head = iter->data0;
  66         struct tree_track *track = iter->data1;
  67         struct artist *artist;
  68         struct album *album;
  69
  70         BUG_ON(iter->data2);
  71         if (head == NULL)
  72                 return 0;
  73         if (track == NULL) {
  74                 /* head, get first track */
  75                 if (head->next == head) {
  76                         /* empty, iter points to the head already */
  77                         return 0;
  78                 }
  79                 artist = to_artist(head->next);
  80                 album = to_album(artist->album_head.next);
  81                 iter->data1 = to_tree_track(album->track_head.next);
  82                 return 1;
  83         }
  84         /* next track */
  85         if (track->node.next == &track->album->track_head || search_restricted) {
  86                 /* next album */
  87                 if (track->album->node.next == &track->album->artist->album_head) {
  88                         /* next artist */
  89                         if (track->album->artist->node.next == &lib_artist_head)
  90                                 return 0;
  91                         artist = to_artist(track->album->artist->node.next);
  92                         album = to_album(artist->album_head.next);
  93                         track = to_tree_track(album->track_head.next);
  94                 } else {
  95                         album = to_album(track->album->node.next);
  96                         track = to_tree_track(album->track_head.next);
  97                 }
  98         } else {
  99                 track = to_tree_track(track->node.next);
 100         }
 101         iter->data1 = track;
 102         return 1;
 103 }
 104 /* }}} */
 105
 106 /* tree window iterators {{{ */
 107 static int tree_get_prev(struct iter *iter)
 108 {
 109         struct list_head *head = iter->data0;
 110         struct artist *artist = iter->data1;
 111         struct album *album = iter->data2;
 112
 113         BUG_ON(head == NULL);
 114         BUG_ON(artist == NULL && album != NULL);
 115         if (artist == NULL) {
 116                 /* head, get last artist and/or album */
 117                 if (head->prev == head) {
 118                         /* empty, iter points to the head already */
 119                         return 0;
 120                 }
 121                 artist = to_artist(head->prev);
 122                 if (artist->expanded) {
 123                         album = to_album(artist->album_head.prev);
 124                 } else {
 125                         album = NULL;
 126                 }
 127                 iter->data1 = artist;
 128                 iter->data2 = album;
 129                 return 1;
 130         }
 131         if (artist->expanded && album) {
 132                 /* prev album */
 133                 if (album->node.prev == &artist->album_head) {
 134                         iter->data2 = NULL;
 135                         return 1;
 136                 } else {
 137                         iter->data2 = to_album(album->node.prev);
 138                         return 1;
 139                 }
 140         }
 141
 142         /* prev artist */
 143         if (artist->node.prev == &lib_artist_head) {
 144                 iter->data1 = NULL;
 145                 iter->data2 = NULL;
 146                 return 0;
 147         }
 148         artist = to_artist(artist->node.prev);
 149         iter->data1 = artist;
 150         iter->data2 = NULL;
 151         if (artist->expanded) {
 152                 /* last album */
 153                 iter->data2 = to_album(artist->album_head.prev);
 154         }
 155         return 1;
 156 }
 157
 158 static int tree_get_next(struct iter *iter)
 159 {
 160         struct list_head *head = iter->data0;
 161         struct artist *artist = iter->data1;
 162         struct album *album = iter->data2;
 163
 164         BUG_ON(head == NULL);
 165         BUG_ON(artist == NULL && album != NULL);
 166         if (artist == NULL) {
 167                 /* head, get first artist */
 168                 if (head->next == head) {
 169                         /* empty, iter points to the head already */
 170                         return 0;
 171                 }
 172                 iter->data1 = to_artist(head->next);
 173                 iter->data2 = NULL;
 174                 return 1;
 175         }
 176         if (artist->expanded) {
 177                 /* next album */
 178                 if (album == NULL) {
 179                         /* first album */
 180                         iter->data2 = to_album(artist->album_head.next);
 181                         return 1;
 182                 }
 183                 if (album->node.next != &artist->album_head) {
 184                         iter->data2 = to_album(album->node.next);
 185                         return 1;
 186                 }
 187         }
 188
 189         /* next artist */
 190         if (artist->node.next == head) {
 191                 iter->data1 = NULL;
 192                 iter->data2 = NULL;
 193                 return 0;
 194         }
 195         iter->data1 = to_artist(artist->node.next);
 196         iter->data2 = NULL;
 197         return 1;
 198 }
 199 /* }}} */
 200
 201 static GENERIC_ITER_PREV(tree_track_get_prev, struct tree_track, node)
 202 static GENERIC_ITER_NEXT(tree_track_get_next, struct tree_track, node)
 203
 204 static inline void tree_search_track_to_iter(struct tree_track *track, struct iter *iter)
 205 {
 206         iter->data0 = &lib_artist_head;
 207         iter->data1 = track;
 208         iter->data2 = NULL;
 209 }
 210
 211 static inline void album_to_iter(struct album *album, struct iter *iter)
 212 {
 213         iter->data0 = &lib_artist_head;
 214         iter->data1 = album->artist;
 215         iter->data2 = album;
 216 }
 217
 218 static inline void artist_to_iter(struct artist *artist, struct iter *iter)
 219 {
 220         iter->data0 = &lib_artist_head;
 221         iter->data1 = artist;
 222         iter->data2 = NULL;
 223 }
 224
 225 static inline void tree_track_to_iter(struct tree_track *track, struct iter *iter)
 226 {
 227         iter->data0 = &track->album->track_head;
 228         iter->data1 = track;
 229         iter->data2 = NULL;
 230 }
 231
 232 /* search (tree) {{{ */
 233 static int tree_search_get_current(void *data, struct iter *iter)
 234 {
 235         struct artist *artist;
 236         struct album *album;
 237         struct tree_track *track;
 238         struct iter tmpiter;
 239
 240         if (list_empty(&lib_artist_head))
 241                 return 0;
 242         if (window_get_sel(lib_track_win, &tmpiter)) {
 243                 track = iter_to_tree_track(&tmpiter);
 244                 tree_search_track_to_iter(track, iter);
 245                 return 1;
 246         }
 247
 248         /* artist not expanded. track_win is empty
 249          * set tmp to the first track of the selected artist */
 250         window_get_sel(lib_tree_win, &tmpiter);
 251         artist = iter_to_artist(&tmpiter);
 252         album = to_album(artist->album_head.next);
 253         track = to_tree_track(album->track_head.next);
 254         tree_search_track_to_iter(track, iter);
 255         return 1;
 256 }
 257
 258 static inline struct tree_track *iter_to_tree_search_track(const struct iter *iter)
 259 {
 260         BUG_ON(iter->data0 != &lib_artist_head);
 261         return iter->data1;
 262 }
 263
 264 static int tree_search_matches(void *data, struct iter *iter, const char *text)
 265 {
 266         struct tree_track *track;
 267         struct iter tmpiter;
 268         unsigned int flags = TI_MATCH_ARTIST | TI_MATCH_ALBUM;
 269
 270         if (!search_restricted)
 271                 flags |= TI_MATCH_TITLE;
 272         track = iter_to_tree_search_track(iter);
 273         if (!track_info_matches(tree_track_info(track), text, flags))
 274                 return 0;
 275         track->album->artist->expanded = 1;
 276         album_to_iter(track->album, &tmpiter);
 277         window_set_sel(lib_tree_win, &tmpiter);
 278
 279         tree_track_to_iter(track, &tmpiter);
 280         window_set_sel(lib_track_win, &tmpiter);
 281         return 1;
 282 }
 283
 284 static const struct searchable_ops tree_search_ops = {
 285         .get_prev = tree_search_get_prev,
 286         .get_next = tree_search_get_next,
 287         .get_current = tree_search_get_current,
 288         .matches = tree_search_matches
 289 };
 290 /* search (tree) }}} */
 291
 292 static inline int album_selected(struct album *album)
 293 {
 294         struct iter sel;
 295
 296         if (window_get_sel(lib_tree_win, &sel))
 297                 return album == iter_to_album(&sel);
 298         return 0;
 299 }
 300
 301 static void tree_sel_changed(void)
 302 {
 303         struct iter sel;
 304         struct album *album;
 305
 306         window_get_sel(lib_tree_win, &sel);
 307         album = iter_to_album(&sel);
 308         if (album == NULL) {
 309                 window_set_empty(lib_track_win);
 310         } else {
 311                 window_set_contents(lib_track_win, &album->track_head);
 312         }
 313 }
 314
 315 static inline void tree_win_get_selected(struct artist **artist, struct album **album)
 316 {
 317         struct iter sel;
 318
 319         *artist = NULL;
 320         *album = NULL;
 321         if (window_get_sel(lib_tree_win, &sel)) {
 322                 *artist = iter_to_artist(&sel);
 323                 *album = iter_to_album(&sel);
 324         }
 325 }
 326
 327 static void artist_free(struct artist *artist)
 328 {
 329         free(artist->name);
 330         free(artist);
 331 }
 332
 333 static void album_free(struct album *album)
 334 {
 335         free(album->name);
 336         free(album);
 337 }
 338
 339 void tree_init(void)
 340 {
 341         struct iter iter;
 342
 343         list_init(&lib_artist_head);
 344
 345         lib_tree_win = window_new(tree_get_prev, tree_get_next);
 346         lib_track_win = window_new(tree_track_get_prev, tree_track_get_next);
 347         lib_cur_win = lib_tree_win;
 348
 349         lib_tree_win->sel_changed = tree_sel_changed;
 350
 351         window_set_empty(lib_track_win);
 352         window_set_contents(lib_tree_win, &lib_artist_head);
 353
 354         iter.data0 = &lib_artist_head;
 355         iter.data1 = NULL;
 356         iter.data2 = NULL;
 357         tree_searchable = searchable_new(NULL, &iter, &tree_search_ops);
 358 }
 359
 360 struct track_info *tree_set_selected(void)
 361 {
 362         struct artist *artist;
 363         struct album *album;
 364         struct track_info *info;
 365         struct iter sel;
 366
 367         if (list_empty(&lib_artist_head))
 368                 return NULL;
 369
 370         tree_win_get_selected(&artist, &album);
 371         if (album == NULL) {
 372                 /* only artist selected, track window is empty
 373                  * => get first album of the selected artist and first track of that album
 374                  */
 375                 album = to_album(artist->album_head.next);
 376                 lib_cur_track = to_tree_track(album->track_head.next);
 377         } else {
 378                 window_get_sel(lib_track_win, &sel);
 379                 lib_cur_track = iter_to_tree_track(&sel);
 380         }
 381
 382         lib_tree_win->changed = 1;
 383         lib_track_win->changed = 1;
 384
 385         info = tree_track_info(lib_cur_track);
 386         track_info_ref(info);
 387         return info;
 388 }
 389
 390 static const char *artist_name_skip_the(const char *a)
 391 {
 392         if (!strncasecmp(a, "the ", 4)) {
 393                 a += 4;
 394                 while (*a == ' ' || *a == '\t')
 395                         ++a;
 396         }
 397         return a;
 398 }
 399
 400 static void find_artist_and_album(const char *artist_name,
 401                 const char *album_name, struct artist **_artist,
 402                 struct album **_album)
 403 {
 404         struct artist *artist;
 405         struct album *album;
 406
 407         list_for_each_entry(artist, &lib_artist_head, node) {
 408                 int res;
 409
 410                 res = u_strcasecmp(artist->name, artist_name);
 411                 if (res == 0) {
 412                         *_artist = artist;
 413                         list_for_each_entry(album, &artist->album_head, node) {
 414                                 res = u_strcasecmp(album->name, album_name);
 415                                 if (res == 0) {
 416                                         *_album = album;
 417                                         return;
 418                                 }
 419                         }
 420                         *_album = NULL;
 421                         return;
 422                 }
 423         }
 424         *_artist = NULL;
 425         *_album = NULL;
 426         return;
 427 }
 428
 429 static int special_name_cmp(const char *a, const char *b)
 430 {
 431         /* keep <Stream> etc. top */
 432         int cmp = (*a != '<') - (*b != '<');
 433
 434         if (cmp)
 435                 return cmp;
 436         return u_strcasecmp(a, b);
 437 }
 438
 439 static void insert_artist(struct artist *artist)
 440 {
 441         const char *a = artist->name;
 442         struct list_head *item;
 443
 444         if (fuzzy_artist_sort)
 445                 a = artist_name_skip_the(a);
 446
 447         list_for_each(item, &lib_artist_head) {
 448                 const char *b = to_artist(item)->name;
 449
 450                 if (fuzzy_artist_sort)
 451                         b = artist_name_skip_the(b);
 452
 453                 if (special_name_cmp(a, b) < 0)
 454                         break;
 455         }
 456         /* add before item */
 457         list_add_tail(&artist->node, item);
 458 }
 459
 460 static int artist_cmp(const struct list_head *a, const struct list_head *b)
 461 {
 462         return special_name_cmp(to_artist(a)->name, to_artist(b)->name);
 463 }
 464
 465 static int fuzzy_artist_cmp(const struct list_head *a, const struct list_head *b)
 466 {
 467         return special_name_cmp(artist_name_skip_the(to_artist(a)->name),
 468                                 artist_name_skip_the(to_artist(b)->name));
 469 }
 470
 471 void tree_sort_artists(void)
 472 {
 473         if (fuzzy_artist_sort)
 474                 list_mergesort(&lib_artist_head, fuzzy_artist_cmp);
 475         else
 476                 list_mergesort(&lib_artist_head, artist_cmp);
 477         window_changed(lib_tree_win);
 478 }
 479
 480 static struct artist *add_artist(const char *name)
 481 {
 482         struct artist *artist;
 483
 484         artist = xnew(struct artist, 1);
 485         artist->name = xstrdup(name);
 486         list_init(&artist->album_head);
 487         artist->expanded = 0;
 488
 489         insert_artist(artist);
 490         return artist;
 491 }
 492
 493 static struct album *artist_add_album(struct artist *artist, const char *name, int date)
 494 {
 495         struct list_head *item;
 496         struct album *album;
 497
 498         album = xnew(struct album, 1);
 499         album->name = xstrdup(name);
 500         album->date = date;
 501         list_init(&album->track_head);
 502         album->artist = artist;
 503
 504         list_for_each(item, &artist->album_head) {
 505                 struct album *a = to_album(item);
 506
 507                 if (date < a->date)
 508                         break;
 509                 if (date > a->date)
 510                         continue;
 511                 if (special_name_cmp(name, a->name) < 0)
 512                         break;
 513         }
 514         /* add before item */
 515         list_add_tail(&album->node, item);
 516         return album;
 517 }
 518
 519 static void album_add_track(struct album *album, struct tree_track *track)
 520 {
 521         /*
 522          * NOTE: This is not perfect.  You should ignore track numbers if
 523          *       either is unset and use filename instead, but usually you
 524          *       have all track numbers set or all unset (within one album
 525          *       of course).
 526          */
 527         static const char * const album_track_sort_keys[] = {
 528                 "discnumber", "tracknumber", "filename", NULL
 529         };
 530         struct list_head *item;
 531
 532         track->album = album;
 533         list_for_each(item, &album->track_head) {
 534                 const struct simple_track *a = (const struct simple_track *)track;
 535                 const struct simple_track *b = (const struct simple_track *)to_tree_track(item);
 536
 537                 if (track_info_cmp(a->info, b->info, album_track_sort_keys) < 0)
 538                         break;
 539         }
 540         /* add before item */
 541         list_add_tail(&track->node, item);
 542 }
 543
 544 void tree_add_track(struct tree_track *track)
 545 {
 546         const struct track_info *ti = tree_track_info(track);
 547         const char *album_name, *artist_name;
 548         struct artist *artist;
 549         struct album *album;
 550         int date;
 551
 552         if (is_url(ti->filename)) {
 553                 artist_name = "<Stream>";
 554                 album_name = "<Stream>";
 555         } else {
 556                 album_name = keyvals_get_val(ti->comments, "album");
 557
 558                 artist_name = keyvals_get_val(ti->comments, "albumartistsort");
 559                 if (!artist_name)
 560                         artist_name= keyvals_get_val(ti->comments, "albumartist");
 561                 if (!artist_name)
 562                         artist_name= keyvals_get_val(ti->comments, "artistsort");
 563                 if (!artist_name) {
 564                         const char *compilation = keyvals_get_val(ti->comments, "compilation");
 565                         if (compilation && (!strcasecmp(compilation, "1") ||
 566                                             !strcasecmp(compilation, "yes")))
 567                                 artist_name = "<Compilations>";
 568                 }
 569                 if (!artist_name)
 570                         artist_name = keyvals_get_val(ti->comments, "artist");
 571
 572                 if (artist_name == NULL)
 573                         artist_name = "<No Name>";
 574                 if (album_name == NULL)
 575                         album_name = "<No Name>";
 576
 577         }
 578
 579         find_artist_and_album(artist_name, album_name, &artist, &album);
 580         if (album) {
 581                 album_add_track(album, track);
 582
 583                 /* is the album where we added the track selected? */
 584                 if (album_selected(album)) {
 585                         /* update track window */
 586                         window_changed(lib_track_win);
 587                 }
 588         } else if (artist) {
 589                 date = comments_get_date(ti->comments, "date");
 590                 album = artist_add_album(artist, album_name, date);
 591                 album_add_track(album, track);
 592
 593                 if (artist->expanded) {
 594                         /* update tree window */
 595                         window_changed(lib_tree_win);
 596                         /* album is not selected => no need to update track_win */
 597                 }
 598         } else {
 599                 date = comments_get_date(ti->comments, "date");
 600                 artist = add_artist(artist_name);
 601                 album = artist_add_album(artist, album_name, date);
 602                 album_add_track(album, track);
 603
 604                 window_changed(lib_tree_win);
 605         }
 606 }
 607
 608 static void remove_sel_artist(struct artist *artist)
 609 {
 610         struct list_head *aitem, *ahead;
 611
 612         ahead = &artist->album_head;
 613         aitem = ahead->next;
 614         while (aitem != ahead) {
 615                 struct list_head *titem, *thead;
 616                 struct list_head *anext = aitem->next;
 617                 struct album *album = to_album(aitem);
 618
 619                 thead = &album->track_head;
 620                 titem = thead->next;
 621                 while (titem != thead) {
 622                         struct list_head *tnext = titem->next;
 623                         struct tree_track *track = to_tree_track(titem);
 624
 625                         editable_remove_track(&lib_editable, (struct simple_track *)track);
 626                         titem = tnext;
 627                 }
 628                 /* all tracks removed => album removed
 629                  * if the last album was removed then the artist was removed too
 630                  */
 631                 aitem = anext;
 632         }
 633 }
 634
 635 static void remove_sel_album(struct album *album)
 636 {
 637         struct list_head *item, *head;
 638
 639         head = &album->track_head;
 640         item = head->next;
 641         while (item != head) {
 642                 struct list_head *next = item->next;
 643                 struct tree_track *track = to_tree_track(item);
 644
 645                 editable_remove_track(&lib_editable, (struct simple_track *)track);
 646                 item = next;
 647         }
 648 }
 649
 650 static void tree_win_remove_sel(void)
 651 {
 652         struct artist *artist;
 653         struct album *album;
 654
 655         tree_win_get_selected(&artist, &album);
 656         if (album) {
 657                 remove_sel_album(album);
 658         } else if (artist) {
 659                 remove_sel_artist(artist);
 660         }
 661 }
 662
 663 static void track_win_remove_sel(void)
 664 {
 665         struct iter sel;
 666         struct tree_track *track;
 667
 668         if (window_get_sel(lib_track_win, &sel)) {
 669                 track = iter_to_tree_track(&sel);
 670                 BUG_ON(track == NULL);
 671                 editable_remove_track(&lib_editable, (struct simple_track *)track);
 672         }
 673 }
 674
 675 void tree_toggle_active_window(void)
 676 {
 677         if (lib_cur_win == lib_tree_win) {
 678                 struct artist *artist;
 679                 struct album *album;
 680
 681                 tree_win_get_selected(&artist, &album);
 682                 if (album) {
 683                         lib_cur_win = lib_track_win;
 684                         lib_tree_win->changed = 1;
 685                         lib_track_win->changed = 1;
 686                 }
 687         } else if (lib_cur_win == lib_track_win) {
 688                 lib_cur_win = lib_tree_win;
 689                 lib_tree_win->changed = 1;
 690                 lib_track_win->changed = 1;
 691         }
 692 }
 693
 694 void tree_toggle_expand_artist(void)
 695 {
 696         struct iter sel;
 697         struct artist *artist;
 698
 699         window_get_sel(lib_tree_win, &sel);
 700         artist = iter_to_artist(&sel);
 701         if (artist) {
 702                 if (artist->expanded) {
 703                         /* deselect album, select artist */
 704                         artist_to_iter(artist, &sel);
 705                         window_set_sel(lib_tree_win, &sel);
 706
 707                         artist->expanded = 0;
 708                         lib_cur_win = lib_tree_win;
 709                 } else {
 710                         artist->expanded = 1;
 711                 }
 712                 window_changed(lib_tree_win);
 713         }
 714 }
 715
 716 static void remove_track(struct tree_track *track)
 717 {
 718         if (album_selected(track->album)) {
 719                 struct iter iter;
 720
 721                 tree_track_to_iter(track, &iter);
 722                 window_row_vanishes(lib_track_win, &iter);
 723         }
 724         list_del(&track->node);
 725 }
 726
 727 static void remove_album(struct album *album)
 728 {
 729         if (album->artist->expanded) {
 730                 struct iter iter;
 731
 732                 album_to_iter(album, &iter);
 733                 window_row_vanishes(lib_tree_win, &iter);
 734         }
 735         list_del(&album->node);
 736 }
 737
 738 static void remove_artist(struct artist *artist)
 739 {
 740         struct iter iter;
 741
 742         artist_to_iter(artist, &iter);
 743         window_row_vanishes(lib_tree_win, &iter);
 744         list_del(&artist->node);
 745 }
 746
 747 void tree_remove(struct tree_track *track)
 748 {
 749         struct album *album = track->album;
 750         struct artist *sel_artist;
 751         struct album *sel_album;
 752
 753         tree_win_get_selected(&sel_artist, &sel_album);
 754
 755         remove_track(track);
 756         /* don't free the track */
 757
 758         if (list_empty(&album->track_head)) {
 759                 struct artist *artist = album->artist;
 760
 761                 if (sel_album == album)
 762                         lib_cur_win = lib_tree_win;
 763
 764                 remove_album(album);
 765                 album_free(album);
 766
 767                 if (list_empty(&artist->album_head)) {
 768                         artist->expanded = 0;
 769                         remove_artist(artist);
 770                         artist_free(artist);
 771                 }
 772         }
 773 }
 774
 775 void tree_remove_sel(void)
 776 {
 777         if (lib_cur_win == lib_tree_win) {
 778                 tree_win_remove_sel();
 779         } else {
 780                 track_win_remove_sel();
 781         }
 782 }
 783
 784 void tree_sel_current(void)
 785 {
 786         if (lib_cur_track) {
 787                 struct iter iter;
 788
 789                 CUR_ARTIST->expanded = 1;
 790
 791                 if (lib_cur_win == lib_tree_win) {
 792                         lib_cur_win = lib_track_win;
 793                         lib_tree_win->changed = 1;
 794                         lib_track_win->changed = 1;
 795                 }
 796
 797                 album_to_iter(CUR_ALBUM, &iter);
 798                 window_set_sel(lib_tree_win, &iter);
 799
 800                 tree_track_to_iter(lib_cur_track, &iter);
 801                 window_set_sel(lib_track_win, &iter);
 802         }
 803 }
 804
 805 static int album_for_each_track(struct album *album, int (*cb)(void *data, struct track_info *ti),
 806                 void *data, int reverse)
 807 {
 808         struct tree_track *track;
 809         int rc = 0;
 810
 811         if (reverse) {
 812                 list_for_each_entry_reverse(track, &album->track_head, node) {
 813                         rc = cb(data, tree_track_info(track));
 814                         if (rc)
 815                                 break;
 816                 }
 817         } else {
 818                 list_for_each_entry(track, &album->track_head, node) {
 819                         rc = cb(data, tree_track_info(track));
 820                         if (rc)
 821                                 break;
 822                 }
 823         }
 824         return rc;
 825 }
 826
 827 static int artist_for_each_track(struct artist *artist, int (*cb)(void *data, struct track_info *ti),
 828                 void *data, int reverse)
 829 {
 830         struct album *album;
 831         int rc = 0;
 832
 833         if (reverse) {
 834                 list_for_each_entry_reverse(album, &artist->album_head, node) {
 835                         rc = album_for_each_track(album, cb, data, 1);
 836                         if (rc)
 837                                 break;
 838                 }
 839         } else {
 840                 list_for_each_entry(album, &artist->album_head, node) {
 841                         rc = album_for_each_track(album, cb, data, 0);
 842                         if (rc)
 843                                 break;
 844                 }
 845         }
 846         return rc;
 847 }
 848
 849 int __tree_for_each_sel(int (*cb)(void *data, struct track_info *ti), void *data, int reverse)
 850 {
 851         int rc = 0;
 852
 853         if (lib_cur_win == lib_tree_win) {
 854                 struct artist *artist;
 855                 struct album *album;
 856
 857                 tree_win_get_selected(&artist, &album);
 858                 if (artist) {
 859                         if (album == NULL) {
 860                                 rc = artist_for_each_track(artist, cb, data, reverse);
 861                         } else {
 862                                 rc = album_for_each_track(album, cb, data, reverse);
 863                         }
 864                 }
 865         } else {
 866                 struct iter sel;
 867                 struct tree_track *track;
 868
 869                 if (window_get_sel(lib_track_win, &sel)) {
 870                         track = iter_to_tree_track(&sel);
 871                         rc = cb(data, tree_track_info(track));
 872                 }
 873         }
 874         return rc;
 875 }
 876
 877 int tree_for_each_sel(int (*cb)(void *data, struct track_info *ti), void *data, int reverse)
 878 {
 879         int rc = __tree_for_each_sel(cb, data, reverse);
 880
 881         window_down(lib_cur_win, 1);
 882         return rc;
 883 }