apps/tagtree.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Miika Pekkarinen
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 /**
  23  * Basic structure on this file was copied from dbtree.c and modified to
  24  * support the tag cache interface.
  25  */
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include "config.h"
  30 #include "system.h"
  31 #include "kernel.h"
  32 #include "splash.h"
  33 #include "icons.h"
  34 #include "tree.h"
  35 #include "action.h"
  36 #include "settings.h"
  37 #include "tagcache.h"
  38 #include "tagtree.h"
  39 #include "lang.h"
  40 #include "logf.h"
  41 #include "playlist.h"
  42 #include "keyboard.h"
  43 #include "gui/list.h"
  44 #include "buffer.h"
  45 #include "playback.h"
  46 #include "yesno.h"
  47 #include "misc.h"
  48 #include "filetypes.h"
  49 #include "audio.h"
  50 #include "appevents.h"
  51 #include "storage.h"
  52 #include "dir_uncached.h"
  53
  54 #define FILE_SEARCH_INSTRUCTIONS ROCKBOX_DIR "/tagnavi.config"
  55
  56 static int tagtree_play_folder(struct tree_context* c);
  57
  58 #define SEARCHSTR_SIZE 256
  59
  60 enum table {
  61     ROOT = 1,
  62     NAVIBROWSE,
  63     ALLSUBENTRIES,
  64     PLAYTRACK,
  65 };
  66
  67 static const struct id3_to_search_mapping {
  68     char   *string;
  69     size_t id3_offset;
  70 } id3_to_search_mapping[] = {
  71     { "",  0 },              /* offset n/a */
  72     { "#directory#",  0 },   /* offset n/a */
  73     { "#title#",  offsetof(struct mp3entry, title) },
  74     { "#artist#", offsetof(struct mp3entry, artist) },
  75     { "#album#",  offsetof(struct mp3entry, album) },
  76     { "#genre#",  offsetof(struct mp3entry, genre_string) },
  77     { "#composer#",  offsetof(struct mp3entry, composer) },
  78     { "#albumartist#",   offsetof(struct mp3entry, albumartist) },
  79 };
  80 enum variables {
  81     var_sorttype = 100,
  82     var_limit,
  83     var_strip,
  84     var_menu_start,
  85     var_include,
  86     var_rootmenu,
  87     var_format,
  88     menu_next,
  89     menu_load,
  90 };
  91
  92 /* Capacity 10 000 entries (for example 10k different artists) */
  93 #define UNIQBUF_SIZE (64*1024)
  94 static long *uniqbuf;
  95
  96 #define MAX_TAGS 5
  97 #define MAX_MENU_ID_SIZE 32
  98
  99 static struct tagcache_search tcs, tcs2;
 100 static bool sort_inverse;
 101
 102 /*
 103  * "%3d. %s" autoscore title %sort = "inverse" %limit = "100"
 104  *
 105  * valid = true
 106  * formatstr = "%-3d. %s"
 107  * tags[0] = tag_autoscore
 108  * tags[1] = tag_title
 109  * tag_count = 2
 110  *
 111  * limit = 100
 112  * sort_inverse = true
 113  */
 114 struct display_format {
 115     char name[32];
 116     struct tagcache_search_clause *clause[TAGCACHE_MAX_CLAUSES];
 117     int clause_count;
 118     char *formatstr;
 119     int group_id;
 120     int tags[MAX_TAGS];
 121     int tag_count;
 122
 123     int limit;
 124     int strip;
 125     bool sort_inverse;
 126 };
 127
 128 static struct display_format *formats[TAGMENU_MAX_FMTS];
 129 static int format_count;
 130
 131 struct search_instruction {
 132     char name[64];
 133     int tagorder[MAX_TAGS];
 134     int tagorder_count;
 135     struct tagcache_search_clause *clause[MAX_TAGS][TAGCACHE_MAX_CLAUSES];
 136     int format_id[MAX_TAGS];
 137     int clause_count[MAX_TAGS];
 138     int result_seek[MAX_TAGS];
 139 };
 140
 141 struct menu_entry {
 142     char name[64];
 143     int type;
 144     struct search_instruction *si;
 145     int link;
 146 };
 147
 148 struct menu_root {
 149     char title[64];
 150     char id[MAX_MENU_ID_SIZE];
 151     int itemcount;
 152     struct menu_entry *items[TAGMENU_MAX_ITEMS];
 153 };
 154
 155 /* Statusbar text of the current view. */
 156 static char current_title[MAX_TAGS][128];
 157
 158 static struct menu_root *menus[TAGMENU_MAX_MENUS];
 159 static struct menu_root *menu;
 160 static struct search_instruction *csi;
 161 static const char *strp;
 162 static int menu_count;
 163 static int rootmenu;
 164
 165 static int current_offset;
 166 static int current_entry_count;
 167
 168 static struct tree_context *tc;
 169
 170 static int get_token_str(char *buf, int size)
 171 {
 172     /* Find the start. */
 173     while (*strp != '"' && *strp != '\0')
 174         strp++;
 175
 176     if (*strp == '\0' || *(++strp) == '\0')
 177         return -1;
 178
 179     /* Read the data. */
 180     while (*strp != '"' && *strp != '\0' && --size > 0)
 181         *(buf++) = *(strp++);
 182
 183     *buf = '\0';
 184     if (*strp != '"')
 185         return -2;
 186
 187     strp++;
 188
 189     return 0;
 190 }
 191
 192 #define MATCH(tag,str1,str2,settag) \
 193     if (!strcasecmp(str1, str2)) { \
 194         *tag = settag; \
 195         return 1; \
 196     }
 197
 198 static int get_tag(int *tag)
 199 {
 200     char buf[128];
 201     int i;
 202
 203     /* Find the start. */
 204     while ((*strp == ' ' || *strp == '>') && *strp != '\0')
 205         strp++;
 206
 207     if (*strp == '\0' || *strp == '?')
 208         return 0;
 209
 210     for (i = 0; i < (int)sizeof(buf)-1; i++)
 211     {
 212         if (*strp == '\0' || *strp == ' ')
 213             break ;
 214         buf[i] = *strp;
 215         strp++;
 216     }
 217     buf[i] = '\0';
 218
 219     MATCH(tag, buf, "album", tag_album);
 220     MATCH(tag, buf, "artist", tag_artist);
 221     MATCH(tag, buf, "bitrate", tag_bitrate);
 222     MATCH(tag, buf, "composer", tag_composer);
 223     MATCH(tag, buf, "comment", tag_comment);
 224     MATCH(tag, buf, "albumartist", tag_albumartist);
 225     MATCH(tag, buf, "ensemble", tag_albumartist);
 226     MATCH(tag, buf, "grouping", tag_grouping);
 227     MATCH(tag, buf, "genre", tag_genre);
 228     MATCH(tag, buf, "length", tag_length);
 229     MATCH(tag, buf, "Lm", tag_virt_length_min);
 230     MATCH(tag, buf, "Ls", tag_virt_length_sec);
 231     MATCH(tag, buf, "Pm", tag_virt_playtime_min);
 232     MATCH(tag, buf, "Ps", tag_virt_playtime_sec);
 233     MATCH(tag, buf, "title", tag_title);
 234     MATCH(tag, buf, "filename", tag_filename);
 235     MATCH(tag, buf, "tracknum", tag_tracknumber);
 236     MATCH(tag, buf, "discnum", tag_discnumber);
 237     MATCH(tag, buf, "year", tag_year);
 238     MATCH(tag, buf, "playcount", tag_playcount);
 239     MATCH(tag, buf, "rating", tag_rating);
 240     MATCH(tag, buf, "lastplayed", tag_lastplayed);
 241     MATCH(tag, buf, "commitid", tag_commitid);
 242     MATCH(tag, buf, "entryage", tag_virt_entryage);
 243     MATCH(tag, buf, "autoscore", tag_virt_autoscore);
 244     MATCH(tag, buf, "%sort", var_sorttype);
 245     MATCH(tag, buf, "%limit", var_limit);
 246     MATCH(tag, buf, "%strip", var_strip);
 247     MATCH(tag, buf, "%menu_start", var_menu_start);
 248     MATCH(tag, buf, "%include", var_include);
 249     MATCH(tag, buf, "%root_menu", var_rootmenu);
 250     MATCH(tag, buf, "%format", var_format);
 251     MATCH(tag, buf, "->", menu_next);
 252     MATCH(tag, buf, "==>", menu_load);
 253
 254     logf("NO MATCH: %s\n", buf);
 255     if (buf[0] == '?')
 256         return 0;
 257
 258     return -1;
 259 }
 260
 261 static int get_clause(int *condition)
 262 {
 263     char buf[4];
 264     int i;
 265
 266     /* Find the start. */
 267     while (*strp == ' ' && *strp != '\0')
 268         strp++;
 269
 270     if (*strp == '\0')
 271         return 0;
 272
 273     for (i = 0; i < (int)sizeof(buf)-1; i++)
 274     {
 275         if (*strp == '\0' || *strp == ' ')
 276             break ;
 277         buf[i] = *strp;
 278         strp++;
 279     }
 280     buf[i] = '\0';
 281
 282     MATCH(condition, buf, "=", clause_is);
 283     MATCH(condition, buf, "==", clause_is);
 284     MATCH(condition, buf, "!=", clause_is_not);
 285     MATCH(condition, buf, ">", clause_gt);
 286     MATCH(condition, buf, ">=", clause_gteq);
 287     MATCH(condition, buf, "<", clause_lt);
 288     MATCH(condition, buf, "<=", clause_lteq);
 289     MATCH(condition, buf, "~", clause_contains);
 290     MATCH(condition, buf, "!~", clause_not_contains);
 291     MATCH(condition, buf, "^", clause_begins_with);
 292     MATCH(condition, buf, "!^", clause_not_begins_with);
 293     MATCH(condition, buf, "$", clause_ends_with);
 294     MATCH(condition, buf, "!$", clause_not_ends_with);
 295     MATCH(condition, buf, "@", clause_oneof);
 296
 297     return 0;
 298 }
 299
 300 static bool read_clause(struct tagcache_search_clause *clause)
 301 {
 302     char buf[SEARCHSTR_SIZE];
 303     unsigned int i;
 304
 305     if (get_tag(&clause->tag) <= 0)
 306         return false;
 307
 308     if (get_clause(&clause->type) <= 0)
 309         return false;
 310
 311     if (get_token_str(buf, sizeof buf) < 0)
 312         return false;
 313
 314     for (i=0; i<ARRAYLEN(id3_to_search_mapping); i++)
 315     {
 316         if (!strcasecmp(buf, id3_to_search_mapping[i].string))
 317             break;
 318     }
 319
 320     if (i<ARRAYLEN(id3_to_search_mapping)) /* runtime search operand found */
 321     {
 322         clause->source = source_runtime+i;
 323         clause->str = buffer_alloc(SEARCHSTR_SIZE);
 324     }
 325     else
 326     {
 327         clause->source = source_constant;
 328         clause->str = buffer_alloc(strlen(buf)+1);
 329         strcpy(clause->str, buf);
 330     }
 331
 332     if (TAGCACHE_IS_NUMERIC(clause->tag))
 333     {
 334         clause->numeric = true;
 335         clause->numeric_data = atoi(clause->str);
 336     }
 337     else
 338         clause->numeric = false;
 339
 340     logf("got clause: %d/%d [%s]", clause->tag, clause->type, clause->str);
 341
 342     return true;
 343 }
 344
 345 static bool read_variable(char *buf, int size)
 346 {
 347     int condition;
 348
 349     if (!get_clause(&condition))
 350         return false;
 351
 352     if (condition != clause_is)
 353         return false;
 354
 355     if (get_token_str(buf, size) < 0)
 356         return false;
 357
 358     return true;
 359 }
 360
 361 /* "%3d. %s" autoscore title %sort = "inverse" %limit = "100" */
 362 static int get_format_str(struct display_format *fmt)
 363 {
 364     int ret;
 365     char buf[128];
 366     int i;
 367
 368     memset(fmt, 0, sizeof(struct display_format));
 369
 370     if (get_token_str(fmt->name, sizeof fmt->name) < 0)
 371         return -10;
 372
 373     /* Determine the group id */
 374     fmt->group_id = 0;
 375     for (i = 0; i < format_count; i++)
 376     {
 377         if (!strcasecmp(formats[i]->name, fmt->name))
 378         {
 379             fmt->group_id = formats[i]->group_id;
 380             break;
 381         }
 382
 383         if (formats[i]->group_id > fmt->group_id)
 384             fmt->group_id = formats[i]->group_id;
 385     }
 386
 387     if (i == format_count)
 388         fmt->group_id++;
 389
 390     logf("format: (%d) %s", fmt->group_id, fmt->name);
 391
 392     if (get_token_str(buf, sizeof buf) < 0)
 393         return -10;
 394
 395     fmt->formatstr = buffer_alloc(strlen(buf) + 1);
 396     strcpy(fmt->formatstr, buf);
 397
 398     while (fmt->tag_count < MAX_TAGS)
 399     {
 400         ret = get_tag(&fmt->tags[fmt->tag_count]);
 401         if (ret < 0)
 402             return -11;
 403
 404         if (ret == 0)
 405             break;
 406
 407         switch (fmt->tags[fmt->tag_count]) {
 408         case var_sorttype:
 409             if (!read_variable(buf, sizeof buf))
 410                 return -12;
 411             if (!strcasecmp("inverse", buf))
 412                 fmt->sort_inverse = true;
 413             break;
 414
 415         case var_limit:
 416             if (!read_variable(buf, sizeof buf))
 417                 return -13;
 418             fmt->limit = atoi(buf);
 419             break;
 420
 421         case var_strip:
 422             if (!read_variable(buf, sizeof buf))
 423                 return -14;
 424             fmt->strip = atoi(buf);
 425             break;
 426
 427         default:
 428             fmt->tag_count++;
 429         }
 430     }
 431
 432     return 1;
 433 }
 434
 435 static int add_format(const char *buf)
 436 {
 437     strp = buf;
 438
 439     if (formats[format_count] == NULL)
 440         formats[format_count] = buffer_alloc(sizeof(struct display_format));
 441
 442     memset(formats[format_count], 0, sizeof(struct display_format));
 443     if (get_format_str(formats[format_count]) < 0)
 444     {
 445         logf("get_format_str() parser failed!");
 446         return -4;
 447     }
 448
 449     while (*strp != '\0' && *strp != '?')
 450         strp++;
 451
 452     if (*strp == '?')
 453     {
 454         int clause_count = 0;
 455         strp++;
 456
 457         while (1)
 458         {
 459             if (clause_count >= TAGCACHE_MAX_CLAUSES)
 460             {
 461                 logf("too many clauses");
 462                 break;
 463             }
 464
 465             formats[format_count]->clause[clause_count] =
 466                 buffer_alloc(sizeof(struct tagcache_search_clause));
 467
 468             if (!read_clause(formats[format_count]->clause[clause_count]))
 469                 break;
 470
 471             clause_count++;
 472         }
 473
 474         formats[format_count]->clause_count = clause_count;
 475     }
 476
 477     format_count++;
 478
 479     return 1;
 480 }
 481
 482 static int get_condition(struct search_instruction *inst)
 483 {
 484     int clause_count;
 485     char buf[128];
 486
 487     switch (*strp)
 488     {
 489         case '=':
 490         {
 491             int i;
 492
 493             if (get_token_str(buf, sizeof buf) < 0)
 494                 return -1;
 495
 496             for (i = 0; i < format_count; i++)
 497             {
 498                 if (!strcasecmp(formats[i]->name, buf))
 499                     break;
 500             }
 501
 502             if (i == format_count)
 503             {
 504                 logf("format not found: %s", buf);
 505                 return -2;
 506             }
 507
 508             inst->format_id[inst->tagorder_count] = formats[i]->group_id;
 509             return 1;
 510         }
 511         case '?':
 512         case ' ':
 513         case '&':
 514             strp++;
 515             return 1;
 516         case '-':
 517         case '\0':
 518             return 0;
 519     }
 520
 521     clause_count = inst->clause_count[inst->tagorder_count];
 522     if (clause_count >= TAGCACHE_MAX_CLAUSES)
 523     {
 524         logf("Too many clauses");
 525         return false;
 526     }
 527
 528     inst->clause[inst->tagorder_count][clause_count] =
 529         buffer_alloc(sizeof(struct tagcache_search_clause));
 530
 531     if (!read_clause(inst->clause[inst->tagorder_count][clause_count]))
 532         return -1;
 533
 534     inst->clause_count[inst->tagorder_count]++;
 535
 536     return 1;
 537 }
 538
 539 /* example search:
 540  * "Best" artist ? year >= "2000" & title !^ "crap" & genre = "good genre" \
 541  *      : album  ? year >= "2000" : songs
 542  * ^  begins with
 543  * *  contains
 544  * $  ends with
 545  */
 546
 547 static bool parse_search(struct menu_entry *entry, const char *str)
 548 {
 549     int ret;
 550     int type;
 551     struct search_instruction *inst = entry->si;
 552     char buf[MAX_PATH];
 553     int i;
 554     struct menu_root *new_menu;
 555
 556     strp = str;
 557
 558     /* Parse entry name */
 559     if (get_token_str(entry->name, sizeof entry->name) < 0)
 560     {
 561         logf("No name found.");
 562         return false;
 563     }
 564
 565     /* Parse entry type */
 566     if (get_tag(&entry->type) <= 0)
 567         return false;
 568
 569     if (entry->type == menu_load)
 570     {
 571         if (get_token_str(buf, sizeof buf) < 0)
 572             return false;
 573
 574         /* Find the matching root menu or "create" it */
 575         for (i = 0; i < menu_count; i++)
 576         {
 577             if (!strcasecmp(menus[i]->id, buf))
 578             {
 579                 entry->link = i;
 580                 return true;
 581             }
 582         }
 583
 584         if (menu_count >= TAGMENU_MAX_MENUS)
 585         {
 586             logf("max menucount reached");
 587             return false;
 588         }
 589
 590         /* Allocate a new menu unless link is found. */
 591         menus[menu_count] = buffer_alloc(sizeof(struct menu_root));
 592         new_menu = menus[menu_count];
 593         memset(new_menu, 0, sizeof(struct menu_root));
 594         strncpy(new_menu->id, buf, MAX_MENU_ID_SIZE-1);
 595         entry->link = menu_count;
 596         ++menu_count;
 597
 598         return true;
 599     }
 600
 601     if (entry->type != menu_next)
 602         return false;
 603
 604     while (inst->tagorder_count < MAX_TAGS)
 605     {
 606         ret = get_tag(&inst->tagorder[inst->tagorder_count]);
 607         if (ret < 0)
 608         {
 609             logf("Parse error #1");
 610             logf("%s", strp);
 611             return false;
 612         }
 613
 614         if (ret == 0)
 615             break ;
 616
 617         logf("tag: %d", inst->tagorder[inst->tagorder_count]);
 618
 619         while ( (ret = get_condition(inst)) > 0 ) ;
 620         if (ret < 0)
 621             return false;
 622
 623         inst->tagorder_count++;
 624
 625         if (get_tag(&type) <= 0 || type != menu_next)
 626             break;
 627     }
 628
 629     return true;
 630 }
 631
 632 static int compare(const void *p1, const void *p2)
 633 {
 634     struct tagentry *e1 = (struct tagentry *)p1;
 635     struct tagentry *e2 = (struct tagentry *)p2;
 636
 637     if (sort_inverse)
 638         return strncasecmp(e2->name, e1->name, MAX_PATH);
 639
 640     return strncasecmp(e1->name, e2->name, MAX_PATH);
 641 }
 642
 643 static void tagtree_buffer_event(struct mp3entry *id3)
 644 {
 645     /* Do not gather data unless proper setting has been enabled. */
 646     if (!global_settings.runtimedb)
 647         return;
 648
 649     logf("be:%s", id3->path);
 650
 651     if (!tagcache_find_index(&tcs, id3->path))
 652     {
 653         logf("tc stat: not found: %s", id3->path);
 654         return;
 655     }
 656
 657     id3->playcount  = tagcache_get_numeric(&tcs, tag_playcount);
 658     if (!id3->rating)
 659         id3->rating = tagcache_get_numeric(&tcs, tag_rating);
 660     id3->lastplayed = tagcache_get_numeric(&tcs, tag_lastplayed);
 661     id3->score      = tagcache_get_numeric(&tcs, tag_virt_autoscore) / 10;
 662     id3->playtime   = tagcache_get_numeric(&tcs, tag_playtime);
 663
 664     /* Store our tagcache index pointer. */
 665     id3->tagcache_idx = tcs.idx_id+1;
 666
 667     tagcache_search_finish(&tcs);
 668 }
 669
 670 static void tagtree_track_finish_event(struct mp3entry *id3)
 671 {
 672     long playcount;
 673     long playtime;
 674     long lastplayed;
 675     long tagcache_idx;
 676
 677     /* Do not gather data unless proper setting has been enabled. */
 678     if (!global_settings.runtimedb)
 679     {
 680         logf("runtimedb gathering not enabled");
 681         return;
 682     }
 683
 684     tagcache_idx=id3->tagcache_idx;
 685     if (!tagcache_idx)
 686     {
 687         logf("No tagcache index pointer found");
 688         return;
 689     }
 690     tagcache_idx--;
 691
 692     /* Don't process unplayed tracks. */
 693     if (id3->elapsed == 0)
 694     {
 695         logf("not logging unplayed track");
 696         return;
 697     }
 698
 699     playcount = id3->playcount + 1;
 700     lastplayed = tagcache_increase_serial();
 701     if (lastplayed < 0)
 702     {
 703         logf("incorrect tc serial:%ld", lastplayed);
 704         return;
 705     }
 706
 707     /* Ignore the last 15s (crossfade etc.) */
 708     playtime = id3->playtime + MIN(id3->length, id3->elapsed + 15 * 1000);
 709
 710     logf("ube:%s", id3->path);
 711     logf("-> %ld/%ld", playcount, playtime);
 712     logf("-> %ld/%ld/%ld", id3->elapsed, id3->length, MIN(id3->length, id3->elapsed + 15 * 1000));
 713
 714     /* Queue the updates to the tagcache system. */
 715     tagcache_update_numeric(tagcache_idx, tag_playcount, playcount);
 716     tagcache_update_numeric(tagcache_idx, tag_playtime, playtime);
 717     tagcache_update_numeric(tagcache_idx, tag_lastplayed, lastplayed);
 718 }
 719
 720 bool tagtree_export(void)
 721 {
 722     splash(0, str(LANG_CREATING));
 723     if (!tagcache_create_changelog(&tcs))
 724     {
 725         splash(HZ*2, ID2P(LANG_FAILED));
 726     }
 727
 728     return false;
 729 }
 730
 731 bool tagtree_import(void)
 732 {
 733     splash(0, ID2P(LANG_WAIT));
 734     if (!tagcache_import_changelog())
 735     {
 736         splash(HZ*2, ID2P(LANG_FAILED));
 737     }
 738
 739     return false;
 740 }
 741
 742 static bool parse_menu(const char *filename);
 743
 744 static int parse_line(int n, const char *buf, void *parameters)
 745 {
 746     char data[256];
 747     int variable;
 748     static bool read_menu;
 749     int i;
 750
 751     (void)parameters;
 752
 753     logf("parse:%d/%s", n, buf);
 754
 755     /* First line, do initialisation. */
 756     if (n == 0)
 757     {
 758         if (strcasecmp(TAGNAVI_VERSION, buf))
 759         {
 760             logf("Version mismatch");
 761             return -1;
 762         }
 763
 764         read_menu = false;
 765     }
 766
 767     if (buf[0] == '#')
 768         return 0;
 769
 770     if (buf[0] == '\0')
 771     {
 772         if (read_menu)
 773         {
 774             /* End the menu */
 775             read_menu = false;
 776         }
 777         return 0;
 778     }
 779
 780     if (!read_menu)
 781     {
 782         strp = buf;
 783         if (get_tag(&variable) <= 0)
 784             return 0;
 785
 786         switch (variable)
 787         {
 788             case var_format:
 789                 if (add_format(strp) < 0)
 790                 {
 791                     logf("Format add fail: %s", data);
 792                 }
 793                 break;
 794
 795             case var_include:
 796                 if (get_token_str(data, sizeof(data)) < 0)
 797                 {
 798                     logf("%%include empty");
 799                     return 0;
 800                 }
 801
 802                 if (!parse_menu(data))
 803                 {
 804                     logf("Load menu fail: %s", data);
 805                 }
 806                 break;
 807
 808             case var_menu_start:
 809                 if (menu_count >= TAGMENU_MAX_MENUS)
 810                 {
 811                     logf("max menucount reached");
 812                     return 0;
 813                 }
 814
 815                 if (get_token_str(data, sizeof data) < 0)
 816                 {
 817                     logf("%%menu_start id empty");
 818                     return 0;
 819                 }
 820
 821                 menu = NULL;
 822                 for (i = 0; i < menu_count; i++)
 823                 {
 824                     if (!strcasecmp(menus[i]->id, data))
 825                     {
 826                         menu = menus[i];
 827                     }
 828                 }
 829
 830                 if (menu == NULL)
 831                 {
 832                     menus[menu_count] = buffer_alloc(sizeof(struct menu_root));
 833                     menu = menus[menu_count];
 834                     ++menu_count;
 835                     memset(menu, 0, sizeof(struct menu_root));
 836                     strncpy(menu->id, data, MAX_MENU_ID_SIZE-1);
 837                 }
 838
 839                 if (get_token_str(menu->title, sizeof(menu->title)) < 0)
 840                 {
 841                     logf("%%menu_start title empty");
 842                     return 0;
 843                 }
 844                 logf("menu: %s", menu->title);
 845                 read_menu = true;
 846                 break;
 847
 848             case var_rootmenu:
 849                 /* Only set root menu once. */
 850                 if (rootmenu >= 0)
 851                     break;
 852
 853                 if (get_token_str(data, sizeof(data)) < 0)
 854                 {
 855                     logf("%%rootmenu empty");
 856                     return 0;
 857                 }
 858
 859                 for (i = 0; i < menu_count; i++)
 860                 {
 861                     if (!strcasecmp(menus[i]->id, data))
 862                     {
 863                         rootmenu = i;
 864                     }
 865                 }
 866                 break;
 867         }
 868
 869         return 0;
 870     }
 871
 872     if (menu->itemcount >= TAGMENU_MAX_ITEMS)
 873     {
 874         logf("max itemcount reached");
 875         return 0;
 876     }
 877
 878     /* Allocate */
 879     if (menu->items[menu->itemcount] == NULL)
 880     {
 881         menu->items[menu->itemcount] = buffer_alloc(sizeof(struct menu_entry));
 882         memset(menu->items[menu->itemcount], 0, sizeof(struct menu_entry));
 883         menu->items[menu->itemcount]->si = buffer_alloc(sizeof(struct search_instruction));
 884     }
 885
 886     memset(menu->items[menu->itemcount]->si, 0, sizeof(struct search_instruction));
 887     if (!parse_search(menu->items[menu->itemcount], buf))
 888         return 0;
 889
 890     menu->itemcount++;
 891
 892     return 0;
 893 }
 894
 895 static bool parse_menu(const char *filename)
 896 {
 897     int fd;
 898     char buf[1024];
 899
 900     if (menu_count >= TAGMENU_MAX_MENUS)
 901     {
 902         logf("max menucount reached");
 903         return false;
 904     }
 905
 906     fd = open(filename, O_RDONLY);
 907     if (fd < 0)
 908     {
 909         logf("Search instruction file not found.");
 910         return false;
 911     }
 912
 913     /* Now read file for real, parsing into si */
 914     fast_readline(fd, buf, sizeof buf, NULL, parse_line);
 915     close(fd);
 916
 917     return true;
 918 }
 919
 920 void tagtree_init(void)
 921 {
 922     format_count = 0;
 923     menu_count = 0;
 924     menu = NULL;
 925     rootmenu = -1;
 926     parse_menu(FILE_SEARCH_INSTRUCTIONS);
 927
 928     /* If no root menu is set, assume it's the first single menu
 929      * we have. That shouldn't normally happen. */
 930     if (rootmenu < 0)
 931         rootmenu = 0;
 932
 933     uniqbuf = buffer_alloc(UNIQBUF_SIZE);
 934
 935     add_event(PLAYBACK_EVENT_TRACK_BUFFER, false, tagtree_buffer_event);
 936     add_event(PLAYBACK_EVENT_TRACK_FINISH, false, tagtree_track_finish_event);
 937 }
 938
 939 static bool show_search_progress(bool init, int count)
 940 {
 941     static int last_tick = 0;
 942
 943     /* Don't show splashes for 1/2 second after starting search */
 944     if (init)
 945     {
 946         last_tick = current_tick + HZ/2;
 947         return true;
 948     }
 949
 950     /* Update progress every 1/10 of a second */
 951     if (current_tick - last_tick > HZ/10)
 952     {
 953         splashf(0, str(LANG_PLAYLIST_SEARCH_MSG), count, str(LANG_OFF_ABORT));
 954         if (action_userabort(TIMEOUT_NOBLOCK))
 955             return false;
 956         last_tick = current_tick;
 957         yield();
 958     }
 959
 960     return true;
 961 }
 962
 963 static int format_str(struct tagcache_search *tcs, struct display_format *fmt,
 964                       char *buf, int buf_size)
 965 {
 966     char fmtbuf[8];
 967     bool read_format = false;
 968     int fmtbuf_pos = 0;
 969     int parpos = 0;
 970     int buf_pos = 0;
 971     int i;
 972
 973     memset(buf, 0, buf_size);
 974     for (i = 0; fmt->formatstr[i] != '\0'; i++)
 975     {
 976         if (fmt->formatstr[i] == '%')
 977         {
 978             read_format = true;
 979             fmtbuf_pos = 0;
 980             if (parpos >= fmt->tag_count)
 981             {
 982                 logf("too many format tags");
 983                 return -1;
 984             }
 985         }
 986
 987         if (read_format)
 988         {
 989             fmtbuf[fmtbuf_pos++] = fmt->formatstr[i];
 990             if (fmtbuf_pos >= buf_size)
 991             {
 992                 logf("format parse error");
 993                 return -2;
 994             }
 995
 996             if (fmt->formatstr[i] == 's')
 997             {
 998                 fmtbuf[fmtbuf_pos] = '\0';
 999                 read_format = false;
1000                 if (fmt->tags[parpos] == tcs->type)
1001                 {
1002                     snprintf(&buf[buf_pos], buf_size - buf_pos, fmtbuf, tcs->result);
1003                 }
1004                 else
1005                 {
1006                     /* Need to fetch the tag data. */
1007                     if (!tagcache_retrieve(tcs, tcs->idx_id, fmt->tags[parpos],
1008                                            &buf[buf_pos], buf_size - buf_pos))
1009                     {
1010                         logf("retrieve failed");
1011                         return -3;
1012                     }
1013                 }
1014                 buf_pos += strlen(&buf[buf_pos]);
1015                 parpos++;
1016             }
1017             else if (fmt->formatstr[i] == 'd')
1018             {
1019                 fmtbuf[fmtbuf_pos] = '\0';
1020                 read_format = false;
1021                 snprintf(&buf[buf_pos], buf_size - buf_pos, fmtbuf,
1022                          tagcache_get_numeric(tcs, fmt->tags[parpos]));
1023                 buf_pos += strlen(&buf[buf_pos]);
1024                 parpos++;
1025             }
1026             continue;
1027         }
1028
1029         buf[buf_pos++] = fmt->formatstr[i];
1030
1031         if (buf_pos - 1 >= buf_size)
1032         {
1033             logf("buffer overflow");
1034             return -4;
1035         }
1036     }
1037
1038     buf[buf_pos++] = '\0';
1039
1040     return 0;
1041 }
1042
1043 static int retrieve_entries(struct tree_context *c, struct tagcache_search *tcs,
1044                             int offset, bool init)
1045 {
1046     struct tagentry *dptr = (struct tagentry *)c->dircache;
1047     struct display_format *fmt;
1048     int i;
1049     int namebufused = 0;
1050     int total_count = 0;
1051     int special_entry_count = 0;
1052     int level = c->currextra;
1053     int tag;
1054     bool sort = false;
1055     int sort_limit;
1056     int strip;
1057
1058     if (init
1059 #ifdef HAVE_TC_RAMCACHE
1060         && !tagcache_is_ramcache()
1061 #endif
1062         )
1063     {
1064         /* Show search progress straight away if the disk needs to spin up,
1065            otherwise show it after the normal 1/2 second delay */
1066         show_search_progress(
1067 #ifdef HAVE_DISK_STORAGE
1068             storage_disk_is_active()
1069 #else
1070             true
1071 #endif
1072             , 0);
1073     }
1074
1075     if (c->currtable == ALLSUBENTRIES)
1076     {
1077         tag = tag_title;
1078         level--;
1079     }
1080     else
1081         tag = csi->tagorder[level];
1082
1083     if (!tagcache_search(tcs, tag))
1084         return -1;
1085
1086     /* Prevent duplicate entries in the search list. */
1087     tagcache_search_set_uniqbuf(tcs, uniqbuf, UNIQBUF_SIZE);
1088
1089     if (level || csi->clause_count[0] || TAGCACHE_IS_NUMERIC(tag))
1090         sort = true;
1091
1092     for (i = 0; i < level; i++)
1093     {
1094         if (TAGCACHE_IS_NUMERIC(csi->tagorder[i]))
1095         {
1096             static struct tagcache_search_clause cc;
1097
1098             memset(&cc, 0, sizeof(struct tagcache_search_clause));
1099             cc.tag = csi->tagorder[i];
1100             cc.type = clause_is;
1101             cc.numeric = true;
1102             cc.numeric_data = csi->result_seek[i];
1103             tagcache_search_add_clause(tcs, &cc);
1104         }
1105         else
1106         {
1107             tagcache_search_add_filter(tcs, csi->tagorder[i],
1108                                        csi->result_seek[i]);
1109         }
1110     }
1111
1112     for (i = 0; i <= level; i++)
1113     {
1114         int j;
1115
1116         for (j = 0; j < csi->clause_count[i]; j++)
1117             tagcache_search_add_clause(tcs, csi->clause[i][j]);
1118     }
1119
1120     current_offset = offset;
1121     current_entry_count = 0;
1122     c->dirfull = false;
1123
1124     fmt = NULL;
1125     for (i = 0; i < format_count; i++)
1126     {
1127         if (formats[i]->group_id == csi->format_id[level])
1128             fmt = formats[i];
1129     }
1130
1131     if (fmt)
1132     {
1133         sort_inverse = fmt->sort_inverse;
1134         sort_limit = fmt->limit;
1135         strip = fmt->strip;
1136         sort = true;
1137     }
1138     else
1139     {
1140         sort_inverse = false;
1141         sort_limit = 0;
1142         strip = 0;
1143     }
1144
1145     if (tag != tag_title && tag != tag_filename)
1146     {
1147         if (offset == 0)
1148         {
1149             dptr->newtable = ALLSUBENTRIES;
1150             dptr->name = str(LANG_TAGNAVI_ALL_TRACKS);
1151             dptr++;
1152             current_entry_count++;
1153         }
1154         if (offset <= 1)
1155         {
1156             dptr->newtable = NAVIBROWSE;
1157             dptr->name = str(LANG_TAGNAVI_RANDOM);
1158             dptr->extraseek = -1;
1159             dptr++;
1160             current_entry_count++;
1161         }
1162         special_entry_count+=2;
1163     }
1164
1165     total_count += special_entry_count;
1166
1167     while (tagcache_get_next(tcs))
1168     {
1169         if (total_count++ < offset)
1170             continue;
1171
1172         dptr->newtable = NAVIBROWSE;
1173         if (tag == tag_title || tag == tag_filename)
1174         {
1175             dptr->newtable = PLAYTRACK;
1176             dptr->extraseek = tcs->idx_id;
1177         }
1178         else
1179             dptr->extraseek = tcs->result_seek;
1180
1181         fmt = NULL;
1182         /* Check the format */
1183         for (i = 0; i < format_count; i++)
1184         {
1185             if (formats[i]->group_id != csi->format_id[level])
1186                 continue;
1187
1188             if (tagcache_check_clauses(tcs, formats[i]->clause,
1189                                        formats[i]->clause_count))
1190             {
1191                 fmt = formats[i];
1192                 break;
1193             }
1194         }
1195
1196         if (!tcs->ramresult || fmt)
1197         {
1198             char buf[MAX_PATH];
1199
1200             if (fmt)
1201             {
1202                 if (format_str(tcs, fmt, buf, sizeof buf) < 0)
1203                 {
1204                     logf("format_str() failed");
1205                     return 0;
1206                 }
1207             }
1208
1209             dptr->name = &c->name_buffer[namebufused];
1210             if (fmt)
1211                 namebufused += strlen(buf)+1;
1212             else
1213                 namebufused += tcs->result_len;
1214
1215             if (namebufused >= c->name_buffer_size)
1216             {
1217                 logf("chunk mode #2: %d", current_entry_count);
1218                 c->dirfull = true;
1219                 sort = false;
1220                 break ;
1221             }
1222             if (fmt)
1223                 strcpy(dptr->name, buf);
1224             else
1225                 strcpy(dptr->name, tcs->result);
1226         }
1227         else
1228             dptr->name = tcs->result;
1229
1230         dptr++;
1231         current_entry_count++;
1232
1233         if (current_entry_count >= global_settings.max_files_in_dir)
1234         {
1235             logf("chunk mode #3: %d", current_entry_count);
1236             c->dirfull = true;
1237             sort = false;
1238             break ;
1239         }
1240
1241         if (init && !tcs->ramsearch)
1242         {
1243             if (!show_search_progress(false, total_count))
1244             {
1245                 tagcache_search_finish(tcs);
1246                 return current_entry_count;
1247             }
1248         }
1249     }
1250
1251     if (sort)
1252         qsort(c->dircache + special_entry_count * c->dentry_size,
1253               current_entry_count - special_entry_count,
1254               c->dentry_size, compare);
1255
1256     if (!init)
1257     {
1258         tagcache_search_finish(tcs);
1259         return current_entry_count;
1260     }
1261
1262     while (tagcache_get_next(tcs))
1263     {
1264         if (!tcs->ramsearch)
1265         {
1266             if (!show_search_progress(false, total_count))
1267                 break;
1268         }
1269         total_count++;
1270     }
1271
1272     tagcache_search_finish(tcs);
1273
1274     if (!sort && (sort_inverse || sort_limit))
1275     {
1276         splashf(HZ*4, ID2P(LANG_SHOWDIR_BUFFER_FULL), total_count);
1277         logf("Too small dir buffer");
1278         return 0;
1279     }
1280
1281     if (sort_limit)
1282         total_count = MIN(total_count, sort_limit);
1283
1284     if (strip)
1285     {
1286         dptr = c->dircache;
1287         for (i = 0; i < total_count; i++, dptr++)
1288         {
1289             int len = strlen(dptr->name);
1290
1291             if (len < strip)
1292                 continue;
1293
1294             dptr->name = &dptr->name[strip];
1295         }
1296     }
1297
1298     return total_count;
1299 }
1300
1301 static int load_root(struct tree_context *c)
1302 {
1303     struct tagentry *dptr = (struct tagentry *)c->dircache;
1304     int i;
1305
1306     tc = c;
1307     c->currtable = ROOT;
1308     if (c->dirlevel == 0)
1309         c->currextra = rootmenu;
1310
1311     menu = menus[c->currextra];
1312     if (menu == NULL)
1313         return 0;
1314
1315     for (i = 0; i < menu->itemcount; i++)
1316     {
1317         dptr->name = menu->items[i]->name;
1318         switch (menu->items[i]->type)
1319         {
1320             case menu_next:
1321                 dptr->newtable = NAVIBROWSE;
1322                 dptr->extraseek = i;
1323                 break;
1324
1325             case menu_load:
1326                 dptr->newtable = ROOT;
1327                 dptr->extraseek = menu->items[i]->link;
1328                 break;
1329         }
1330
1331         dptr++;
1332     }
1333
1334     current_offset = 0;
1335     current_entry_count = i;
1336
1337     return i;
1338 }
1339
1340 int tagtree_load(struct tree_context* c)
1341 {
1342     int count;
1343     int table = c->currtable;
1344
1345     c->dentry_size = sizeof(struct tagentry);
1346     c->dirsindir = 0;
1347
1348     if (!table)
1349     {
1350         c->dirfull = false;
1351         table = ROOT;
1352         c->currtable = table;
1353         c->currextra = rootmenu;
1354     }
1355
1356     switch (table)
1357     {
1358         case ROOT:
1359             count = load_root(c);
1360             break;
1361
1362         case ALLSUBENTRIES:
1363         case NAVIBROWSE:
1364             logf("navibrowse...");
1365             cpu_boost(true);
1366             count = retrieve_entries(c, &tcs, 0, true);
1367             cpu_boost(false);
1368             break;
1369
1370         default:
1371             logf("Unsupported table %d\n", table);
1372             return -1;
1373     }
1374
1375     if (count < 0)
1376     {
1377         c->dirlevel = 0;
1378         count = load_root(c);
1379         splash(HZ, str(LANG_TAGCACHE_BUSY));
1380     }
1381
1382     /* The _total_ numer of entries available. */
1383     c->dirlength = c->filesindir = count;
1384
1385     return count;
1386 }
1387
1388 int tagtree_enter(struct tree_context* c)
1389 {
1390     int rc = 0;
1391     struct tagentry *dptr;
1392     struct mp3entry *id3;
1393     int newextra;
1394     int seek;
1395     int source;
1396
1397     dptr = tagtree_get_entry(c, c->selected_item);
1398
1399     c->dirfull = false;
1400     seek = dptr->extraseek;
1401     if (seek == -1)
1402     {
1403         if(c->filesindir<=2)
1404             return 0;
1405         srand(current_tick);
1406         dptr = (tagtree_get_entry(c, 2+(rand() % (c->filesindir-2))));
1407         seek = dptr->extraseek;
1408     }
1409     newextra = dptr->newtable;
1410
1411     if (c->dirlevel >= MAX_DIR_LEVELS)
1412         return 0;
1413
1414     c->selected_item_history[c->dirlevel]=c->selected_item;
1415     c->table_history[c->dirlevel] = c->currtable;
1416     c->extra_history[c->dirlevel] = c->currextra;
1417     c->pos_history[c->dirlevel] = c->firstpos;
1418     c->dirlevel++;
1419
1420     switch (c->currtable) {
1421         case ROOT:
1422             c->currextra = newextra;
1423
1424             if (newextra == ROOT)
1425             {
1426                 menu = menus[seek];
1427                 c->currextra = seek;
1428             }
1429
1430             else if (newextra == NAVIBROWSE)
1431             {
1432                 int i, j;
1433
1434                 csi = menu->items[seek]->si;
1435                 c->currextra = 0;
1436
1437                 strncpy(current_title[c->currextra], dptr->name,
1438                         sizeof(current_title[0]) - 1);
1439
1440                 /* Read input as necessary. */
1441                 for (i = 0; i < csi->tagorder_count; i++)
1442                 {
1443                     for (j = 0; j < csi->clause_count[i]; j++)
1444                     {
1445                         char* searchstring;
1446                         source = csi->clause[i][j]->source;
1447
1448                         if (source == source_constant)
1449                             continue;
1450
1451                         searchstring=csi->clause[i][j]->str;
1452                         *searchstring = '\0';
1453
1454                         id3 = audio_current_track();
1455
1456                         if (source == source_current_path && id3)
1457                         {
1458                             char *e;
1459                             strncpy(searchstring, id3->path, SEARCHSTR_SIZE);
1460                             e = strrchr(searchstring, '/');
1461                             if (e)
1462                                 *e = '\0';
1463                         }
1464                         else if (source > source_runtime && id3)
1465                         {
1466
1467                             int k = source-source_runtime;
1468                             int offset = id3_to_search_mapping[k].id3_offset;
1469                             char **src = (char**)((char*)id3 + offset);
1470                             if (*src)
1471                             {
1472                                 strncpy(searchstring, *src, SEARCHSTR_SIZE);
1473                                 searchstring[SEARCHSTR_SIZE-1] = '\0';
1474                             }
1475                         }
1476                         else
1477                         {
1478                             rc = kbd_input(searchstring, SEARCHSTR_SIZE);
1479                             if (rc == -1 || !searchstring[0])
1480                             {
1481                                 tagtree_exit(c);
1482                                 return 0;
1483                             }
1484                             if (csi->clause[i][j]->numeric)
1485                                 csi->clause[i][j]->numeric_data = atoi(searchstring);
1486                         }
1487
1488
1489                     }
1490                 }
1491             }
1492             c->currtable = newextra;
1493
1494             break;
1495
1496         case NAVIBROWSE:
1497         case ALLSUBENTRIES:
1498             if (newextra == PLAYTRACK)
1499             {
1500                 if (global_settings.party_mode && audio_status()) {
1501                     splash(HZ, ID2P(LANG_PARTY_MODE));
1502                     break;
1503                 }
1504                 c->dirlevel--;
1505                 /* about to create a new current playlist...
1506                  allow user to cancel the operation */
1507                 if (!warn_on_pl_erase())
1508                     break;
1509
1510                 if (tagtree_play_folder(c) >= 0)
1511                     rc = 2;
1512                 break;
1513             }
1514
1515             c->currtable = newextra;
1516             csi->result_seek[c->currextra] = seek;
1517             if (c->currextra < csi->tagorder_count-1)
1518                 c->currextra++;
1519             else
1520                 c->dirlevel--;
1521
1522             /* Update the statusbar title */
1523             strncpy(current_title[c->currextra], dptr->name,
1524                     sizeof(current_title[0]) - 1);
1525             break;
1526
1527         default:
1528             c->dirlevel--;
1529             break;
1530     }
1531
1532     c->selected_item=0;
1533     gui_synclist_select_item(&tree_lists, c->selected_item);
1534
1535     return rc;
1536 }
1537
1538 void tagtree_exit(struct tree_context* c)
1539 {
1540     c->dirfull = false;
1541     if (c->dirlevel > 0)
1542         c->dirlevel--;
1543     c->selected_item=c->selected_item_history[c->dirlevel];
1544     gui_synclist_select_item(&tree_lists, c->selected_item);
1545     c->currtable = c->table_history[c->dirlevel];
1546     c->currextra = c->extra_history[c->dirlevel];
1547     c->firstpos  = c->pos_history[c->dirlevel];
1548 }
1549
1550 int tagtree_get_filename(struct tree_context* c, char *buf, int buflen)
1551 {
1552     struct tagentry *entry;
1553
1554     entry = tagtree_get_entry(c, c->selected_item);
1555
1556     if (!tagcache_search(&tcs, tag_filename))
1557         return -1;
1558
1559     if (!tagcache_retrieve(&tcs, entry->extraseek, tcs.type, buf, buflen))
1560     {
1561         tagcache_search_finish(&tcs);
1562         return -2;
1563     }
1564
1565     tagcache_search_finish(&tcs);
1566
1567     return 0;
1568 }
1569
1570 static bool insert_all_playlist(struct tree_context *c, int position, bool queue)
1571 {
1572     int i;
1573     char buf[MAX_PATH];
1574     int from, to, direction;
1575     int files_left = c->filesindir;
1576
1577     cpu_boost(true);
1578     if (!tagcache_search(&tcs, tag_filename))
1579     {
1580         splash(HZ, ID2P(LANG_TAGCACHE_BUSY));
1581         cpu_boost(false);
1582         return false;
1583     }
1584
1585     if (position == PLAYLIST_REPLACE)
1586     {
1587         if (playlist_remove_all_tracks(NULL) == 0)
1588             position = PLAYLIST_INSERT_LAST;
1589         else
1590         {
1591             cpu_boost(false);
1592             return false;
1593         }
1594     }
1595
1596     if (position == PLAYLIST_INSERT_FIRST)
1597     {
1598         from = c->filesindir - 1;
1599         to = -1;
1600         direction = -1;
1601     }
1602     else
1603     {
1604         from = 0;
1605         to = c->filesindir;
1606         direction = 1;
1607     }
1608
1609     for (i = from; i != to; i += direction)
1610     {
1611         /* Count back to zero */
1612         if (!show_search_progress(false, files_left--))
1613             break;
1614
1615         if (!tagcache_retrieve(&tcs, tagtree_get_entry(c, i)->extraseek,
1616                                tcs.type, buf, sizeof buf))
1617         {
1618             continue;
1619         }
1620
1621         if (playlist_insert_track(NULL, buf, position, queue, false) < 0)
1622         {
1623             logf("playlist_insert_track failed");
1624             break;
1625         }
1626         yield();
1627     }
1628     playlist_sync(NULL);
1629     tagcache_search_finish(&tcs);
1630     cpu_boost(false);
1631
1632     return true;
1633 }
1634
1635 bool tagtree_insert_selection_playlist(int position, bool queue)
1636 {
1637     struct tagentry *dptr;
1638     char buf[MAX_PATH];
1639     int dirlevel = tc->dirlevel;
1640
1641     /* We need to set the table to allsubentries. */
1642     show_search_progress(true, 0);
1643
1644     dptr = tagtree_get_entry(tc, tc->selected_item);
1645
1646     /* Insert a single track? */
1647     if (dptr->newtable == PLAYTRACK)
1648     {
1649         if (tagtree_get_filename(tc, buf, sizeof buf) < 0)
1650         {
1651             logf("tagtree_get_filename failed");
1652             return false;
1653         }
1654         playlist_insert_track(NULL, buf, position, queue, true);
1655
1656         return true;
1657     }
1658
1659     if (dptr->newtable == NAVIBROWSE)
1660     {
1661         tagtree_enter(tc);
1662         tagtree_load(tc);
1663         dptr = tagtree_get_entry(tc, tc->selected_item);
1664     }
1665     else if (dptr->newtable != ALLSUBENTRIES)
1666     {
1667         logf("unsupported table: %d", dptr->newtable);
1668         return false;
1669     }
1670
1671     /* Now the current table should be allsubentries. */
1672     if (dptr->newtable != PLAYTRACK)
1673     {
1674         tagtree_enter(tc);
1675         tagtree_load(tc);
1676         dptr = tagtree_get_entry(tc, tc->selected_item);
1677
1678         /* And now the newtable should be playtrack. */
1679         if (dptr->newtable != PLAYTRACK)
1680         {
1681             logf("newtable: %d !!", dptr->newtable);
1682             tc->dirlevel = dirlevel;
1683             return false;
1684         }
1685     }
1686
1687     if (tc->filesindir <= 0)
1688         splash(HZ, ID2P(LANG_END_PLAYLIST));
1689     else
1690     {
1691         logf("insert_all_playlist");
1692         if (!insert_all_playlist(tc, position, queue))
1693             splash(HZ*2, ID2P(LANG_FAILED));
1694     }
1695
1696     /* Finally return the dirlevel to its original value. */
1697     while (tc->dirlevel > dirlevel)
1698         tagtree_exit(tc);
1699     tagtree_load(tc);
1700
1701     return true;
1702 }
1703
1704 static int tagtree_play_folder(struct tree_context* c)
1705 {
1706     if (playlist_create(NULL, NULL) < 0)
1707     {
1708         logf("Failed creating playlist\n");
1709         return -1;
1710     }
1711
1712     if (!insert_all_playlist(c, PLAYLIST_INSERT_LAST, false))
1713         return -2;
1714
1715     if (global_settings.playlist_shuffle)
1716         c->selected_item = playlist_shuffle(current_tick, c->selected_item);
1717     if (!global_settings.play_selected)
1718         c->selected_item = 0;
1719     gui_synclist_select_item(&tree_lists, c->selected_item);
1720
1721     playlist_start(c->selected_item,0);
1722
1723     return 0;
1724 }
1725
1726 struct tagentry* tagtree_get_entry(struct tree_context *c, int id)
1727 {
1728     struct tagentry *entry = (struct tagentry *)c->dircache;
1729     int realid = id - current_offset;
1730
1731     /* Load the next chunk if necessary. */
1732     if (realid >= current_entry_count || realid < 0)
1733     {
1734         cpu_boost(true);
1735         if (retrieve_entries(c, &tcs2, MAX(0, id - (current_entry_count / 2)),
1736                              false) < 0)
1737         {
1738             logf("retrieve failed");
1739             cpu_boost(false);
1740             return NULL;
1741         }
1742         realid = id - current_offset;
1743         cpu_boost(false);
1744     }
1745
1746     return &entry[realid];
1747 }
1748
1749 char *tagtree_get_title(struct tree_context* c)
1750 {
1751     switch (c->currtable)
1752     {
1753         case ROOT:
1754             return menu->title;
1755
1756         case NAVIBROWSE:
1757         case ALLSUBENTRIES:
1758             return current_title[c->currextra];
1759     }
1760
1761     return "?";
1762 }
1763
1764 int tagtree_get_attr(struct tree_context* c)
1765 {
1766     int attr = -1;
1767     switch (c->currtable)
1768     {
1769         case NAVIBROWSE:
1770             if (csi->tagorder[c->currextra] == tag_title)
1771                 attr = FILE_ATTR_AUDIO;
1772             else
1773                 attr = ATTR_DIRECTORY;
1774             break;
1775
1776         case ALLSUBENTRIES:
1777             attr = FILE_ATTR_AUDIO;
1778             break;
1779
1780         default:
1781             attr = ATTR_DIRECTORY;
1782             break;
1783     }
1784
1785     return attr;
1786 }
1787
1788 int tagtree_get_icon(struct tree_context* c)
1789 {
1790     int icon = Icon_Folder;
1791
1792     if (tagtree_get_attr(c) == FILE_ATTR_AUDIO)
1793         icon = Icon_Audio;
1794
1795     return icon;
1796 }