utils/themeeditor/models/parsetreenode.cpp

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2010 Robert Bieber
  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 #include "symbols.h"
  23 #include "tag_table.h"
  24
  25 #include "parsetreenode.h"
  26 #include "parsetreemodel.h"
  27
  28 #include "rbimage.h"
  29
  30 #include <iostream>
  31
  32 int ParseTreeNode::openConditionals = 0;
  33
  34 /* Root element constructor */
  35 ParseTreeNode::ParseTreeNode(struct skin_element* data)
  36     : parent(0), element(0), param(0), children()
  37 {
  38     while(data)
  39     {
  40         children.append(new ParseTreeNode(data, this));
  41         data = data->next;
  42     }
  43 }
  44
  45 /* Normal element constructor */
  46 ParseTreeNode::ParseTreeNode(struct skin_element* data, ParseTreeNode* parent)
  47     : parent(parent), element(data), param(0), children()
  48 {
  49     switch(element->type)
  50     {
  51
  52     case TAG:
  53         for(int i = 0; i < element->params_count; i++)
  54         {
  55             if(element->params[i].type == skin_tag_parameter::CODE)
  56                 children.append(new ParseTreeNode(element->params[i].data.code,
  57                                               this));
  58             else
  59                 children.append(new ParseTreeNode(&element->params[i], this));
  60         }
  61         break;
  62
  63     case CONDITIONAL:
  64         for(int i = 0; i < element->params_count; i++)
  65             children.append(new ParseTreeNode(&data->params[i], this));
  66         for(int i = 0; i < element->children_count; i++)
  67             children.append(new ParseTreeNode(data->children[i], this));
  68         break;
  69
  70     case SUBLINES:
  71         for(int i = 0; i < element->children_count; i++)
  72         {
  73             children.append(new ParseTreeNode(data->children[i], this));
  74         }
  75         break;
  76
  77 case VIEWPORT:
  78         for(int i = 0; i < element->params_count; i++)
  79             children.append(new ParseTreeNode(&data->params[i], this));
  80         /* Deliberate fall-through here */
  81
  82     case LINE:
  83         for(int i = 0; i < data->children_count; i++)
  84         {
  85             for(struct skin_element* current = data->children[i]; current;
  86                 current = current->next)
  87             {
  88                 children.append(new ParseTreeNode(current, this));
  89             }
  90         }
  91         break;
  92
  93     default:
  94         break;
  95     }
  96 }
  97
  98 /* Parameter constructor */
  99 ParseTreeNode::ParseTreeNode(skin_tag_parameter *data, ParseTreeNode *parent)
 100     : parent(parent), element(0), param(data), children()
 101 {
 102
 103 }
 104
 105 ParseTreeNode::~ParseTreeNode()
 106 {
 107     for(int i = 0; i < children.count(); i++)
 108         delete children[i];
 109 }
 110
 111 QString ParseTreeNode::genCode() const
 112 {
 113     QString buffer = "";
 114
 115     if(element)
 116     {
 117         switch(element->type)
 118         {
 119         case UNKNOWN:
 120             break;
 121         case VIEWPORT:
 122             /* Generating the Viewport tag, if necessary */
 123             if(element->tag)
 124             {
 125                 buffer.append(TAGSYM);
 126                 buffer.append(element->tag->name);
 127                 buffer.append(ARGLISTOPENSYM);
 128                 for(int i = 0; i < element->params_count; i++)
 129                 {
 130                     buffer.append(children[i]->genCode());
 131                     if(i != element->params_count - 1)
 132                         buffer.append(ARGLISTSEPERATESYM);
 133                 }
 134                 buffer.append(ARGLISTCLOSESYM);
 135                 buffer.append('\n');
 136             }
 137
 138             for(int i = element->params_count; i < children.count(); i++)
 139                 buffer.append(children[i]->genCode());
 140             break;
 141
 142         case LINE:
 143             for(int i = 0; i < children.count(); i++)
 144             {
 145                 buffer.append(children[i]->genCode());
 146             }
 147             if(openConditionals == 0
 148                && !(parent && parent->element->type == SUBLINES))
 149             {
 150                 buffer.append('\n');
 151             }
 152             break;
 153
 154         case SUBLINES:
 155             for(int i = 0; i < children.count(); i++)
 156             {
 157                 buffer.append(children[i]->genCode());
 158                 if(i != children.count() - 1)
 159                     buffer.append(MULTILINESYM);
 160             }
 161             if(openConditionals == 0)
 162                 buffer.append('\n');
 163             break;
 164
 165         case CONDITIONAL:
 166             openConditionals++;
 167
 168             /* Inserting the tag part */
 169             buffer.append(TAGSYM);
 170             buffer.append(CONDITIONSYM);
 171             buffer.append(element->tag->name);
 172             if(element->params_count > 0)
 173             {
 174                 buffer.append(ARGLISTOPENSYM);
 175                 for(int i = 0; i < element->params_count; i++)
 176                 {
 177                     buffer.append(children[i]->genCode());
 178                     if( i != element->params_count - 1)
 179                         buffer.append(ARGLISTSEPERATESYM);
 180                     buffer.append(ARGLISTCLOSESYM);
 181                 }
 182             }
 183
 184             /* Inserting the sublines */
 185             buffer.append(ENUMLISTOPENSYM);
 186             for(int i = element->params_count; i < children.count(); i++)
 187             {
 188                 buffer.append(children[i]->genCode());
 189                 if(i != children.count() - 1)
 190                     buffer.append(ENUMLISTSEPERATESYM);
 191             }
 192             buffer.append(ENUMLISTCLOSESYM);
 193             openConditionals--;
 194             break;
 195
 196         case TAG:
 197             buffer.append(TAGSYM);
 198             buffer.append(element->tag->name);
 199
 200             if(element->params_count > 0)
 201             {
 202                 /* Rendering parameters if there are any */
 203                 buffer.append(ARGLISTOPENSYM);
 204                 for(int i = 0; i < children.count(); i++)
 205                 {
 206                     buffer.append(children[i]->genCode());
 207                     if(i != children.count() - 1)
 208                         buffer.append(ARGLISTSEPERATESYM);
 209                 }
 210                 buffer.append(ARGLISTCLOSESYM);
 211             }
 212             break;
 213
 214         case TEXT:
 215             for(char* cursor = (char*)element->data; *cursor; cursor++)
 216             {
 217                 if(find_escape_character(*cursor))
 218                     buffer.append(TAGSYM);
 219                 buffer.append(*cursor);
 220             }
 221             break;
 222
 223         case COMMENT:
 224             buffer.append(COMMENTSYM);
 225             buffer.append((char*)element->data);
 226             buffer.append('\n');
 227             break;
 228         }
 229     }
 230     else if(param)
 231     {
 232         switch(param->type)
 233         {
 234         case skin_tag_parameter::STRING:
 235             for(char* cursor = param->data.text; *cursor; cursor++)
 236             {
 237                 if(find_escape_character(*cursor))
 238                     buffer.append(TAGSYM);
 239                 buffer.append(*cursor);
 240             }
 241             break;
 242
 243         case skin_tag_parameter::NUMERIC:
 244             buffer.append(QString::number(param->data.numeric, 10));
 245             break;
 246
 247         case skin_tag_parameter::DEFAULT:
 248             buffer.append(DEFAULTSYM);
 249             break;
 250
 251         case skin_tag_parameter::CODE:
 252             buffer.append(QObject::tr("This doesn't belong here"));
 253             break;
 254
 255         }
 256     }
 257     else
 258     {
 259         for(int i = 0; i < children.count(); i++)
 260             buffer.append(children[i]->genCode());
 261     }
 262
 263     return buffer;
 264 }
 265
 266 /* A more or less random hashing algorithm */
 267 int ParseTreeNode::genHash() const
 268 {
 269     int hash = 0;
 270     char *text;
 271
 272     if(element)
 273     {
 274         hash += element->type;
 275         switch(element->type)
 276         {
 277         case UNKNOWN:
 278             break;
 279         case VIEWPORT:
 280         case LINE:
 281         case SUBLINES:
 282         case CONDITIONAL:
 283             hash += element->children_count;
 284             break;
 285
 286         case TAG:
 287             for(unsigned int i = 0; i < strlen(element->tag->name); i++)
 288                 hash += element->tag->name[i];
 289             break;
 290
 291         case COMMENT:
 292         case TEXT:
 293             text = (char*)element->data;
 294             for(unsigned int i = 0; i < strlen(text); i++)
 295             {
 296                 if(i % 2)
 297                     hash += text[i] % element->type;
 298                 else
 299                     hash += text[i] % element->type * 2;
 300             }
 301             break;
 302         }
 303
 304     }
 305
 306     if(param)
 307     {
 308         hash += param->type;
 309         switch(param->type)
 310         {
 311         case skin_tag_parameter::DEFAULT:
 312         case skin_tag_parameter::CODE:
 313             break;
 314
 315         case skin_tag_parameter::NUMERIC:
 316             hash += param->data.numeric * (param->data.numeric / 4);
 317             break;
 318
 319         case skin_tag_parameter::STRING:
 320             for(unsigned int i = 0; i < strlen(param->data.text); i++)
 321             {
 322                 if(i % 2)
 323                     hash += param->data.text[i] * 2;
 324                 else
 325                     hash += param->data.text[i];
 326             }
 327             break;
 328         }
 329     }
 330
 331     for(int i = 0; i < children.count(); i++)
 332     {
 333         hash += children[i]->genHash();
 334     }
 335
 336     return hash;
 337 }
 338
 339 ParseTreeNode* ParseTreeNode::child(int row)
 340 {
 341     if(row < 0 || row >= children.count())
 342         return 0;
 343
 344     return children[row];
 345 }
 346
 347 int ParseTreeNode::numChildren() const
 348 {
 349         return children.count();
 350 }
 351
 352
 353 QVariant ParseTreeNode::data(int column) const
 354 {
 355     switch(column)
 356     {
 357     case ParseTreeModel::typeColumn:
 358         if(element)
 359         {
 360             switch(element->type)
 361             {
 362             case UNKNOWN:
 363                 return QObject::tr("Unknown");
 364             case VIEWPORT:
 365                 return QObject::tr("Viewport");
 366
 367             case LINE:
 368                 return QObject::tr("Logical Line");
 369
 370             case SUBLINES:
 371                 return QObject::tr("Alternator");
 372
 373             case COMMENT:
 374                 return QObject::tr("Comment");
 375
 376             case CONDITIONAL:
 377                 return QObject::tr("Conditional Tag");
 378
 379             case TAG:
 380                 return QObject::tr("Tag");
 381
 382             case TEXT:
 383                 return QObject::tr("Plaintext");
 384             }
 385         }
 386         else if(param)
 387         {
 388             switch(param->type)
 389             {
 390             case skin_tag_parameter::STRING:
 391                 return QObject::tr("String");
 392
 393             case skin_tag_parameter::NUMERIC:
 394                 return QObject::tr("Number");
 395
 396             case skin_tag_parameter::DEFAULT:
 397                 return QObject::tr("Default Argument");
 398
 399             case skin_tag_parameter::CODE:
 400                 return QObject::tr("This doesn't belong here");
 401             }
 402         }
 403         else
 404         {
 405             return QObject::tr("Root");
 406         }
 407
 408         break;
 409
 410     case ParseTreeModel::valueColumn:
 411         if(element)
 412         {
 413             switch(element->type)
 414             {
 415             case UNKNOWN:
 416             case VIEWPORT:
 417             case LINE:
 418             case SUBLINES:
 419                 return QString();
 420
 421             case CONDITIONAL:
 422                 return QString(element->tag->name);
 423
 424             case TEXT:
 425             case COMMENT:
 426                 return QString((char*)element->data);
 427
 428             case TAG:
 429                 return QString(element->tag->name);
 430             }
 431         }
 432         else if(param)
 433         {
 434             switch(param->type)
 435             {
 436             case skin_tag_parameter::DEFAULT:
 437                 return QObject::tr("-");
 438
 439             case skin_tag_parameter::STRING:
 440                 return QString(param->data.text);
 441
 442             case skin_tag_parameter::NUMERIC:
 443                 return QString::number(param->data.numeric, 10);
 444
 445             case skin_tag_parameter::CODE:
 446                 return QObject::tr("Seriously, something's wrong here");
 447             }
 448         }
 449         else
 450         {
 451             return QString();
 452         }
 453         break;
 454
 455     case ParseTreeModel::lineColumn:
 456         if(element)
 457             return QString::number(element->line, 10);
 458         else
 459             return QString();
 460         break;
 461     }
 462
 463     return QVariant();
 464 }
 465
 466
 467 int ParseTreeNode::getRow() const
 468 {
 469     if(!parent)
 470         return -1;
 471
 472     return parent->children.indexOf(const_cast<ParseTreeNode*>(this));
 473 }
 474
 475 ParseTreeNode* ParseTreeNode::getParent() const
 476 {
 477     return parent;
 478 }
 479
 480 /* This version is called for the root node and for viewports */
 481 void ParseTreeNode::render(const RBRenderInfo& info)
 482 {
 483     /* Parameters don't get rendered */
 484     if(!element && param)
 485         return;
 486
 487     /* If we're at the root, we need to render each viewport */
 488     if(!element && !param)
 489     {
 490         for(int i = 0; i < children.count(); i++)
 491         {
 492             children[i]->render(info);
 493         }
 494
 495         return;
 496     }
 497
 498     if(element->type != VIEWPORT)
 499     {
 500         std::cerr << QObject::tr("Error in parse tree").toStdString()
 501                 << std::endl;
 502         return;
 503     }
 504
 505     rendered = new RBViewport(element, info);
 506
 507     for(int i = element->params_count; i < children.count(); i++)
 508         children[i]->render(info, dynamic_cast<RBViewport*>(rendered));
 509
 510 }
 511
 512 /* This version is called for logical lines, tags, conditionals and such */
 513 void ParseTreeNode::render(const RBRenderInfo &info, RBViewport* viewport,
 514                            bool noBreak)
 515 {
 516     if(element->type == LINE)
 517     {
 518         for(int i = 0; i < children.count(); i++)
 519             children[i]->render(info, viewport);
 520         if(!noBreak)
 521             viewport->newLine();
 522     }
 523     else if(element->type == TEXT)
 524     {
 525         viewport->write(QString(static_cast<char*>(element->data)));
 526     }
 527     else if(element->type == TAG)
 528     {
 529         if(!execTag(info, viewport))
 530             viewport->write(evalTag(info).toString());
 531     }
 532     else if(element->type == CONDITIONAL)
 533     {
 534         int child = evalTag(info, true, element->children_count).toInt();
 535         children[element->params_count + child]->render(info, viewport, true);
 536     }
 537     else if(element->type == SUBLINES)
 538     {
 539         /* First we build a list of the times for each branch */
 540         QList<double> times;
 541         for(int i = 0; i < children.count() ; i++)
 542             times.append(findBranchTime(children[i], info));
 543
 544         /* Now we figure out which branch to select */
 545         double timeLeft = info.device()->data(QString("?pc")).toDouble();
 546         int branch = 0;
 547         while(timeLeft > 0)
 548         {
 549             timeLeft -= times[branch];
 550             if(timeLeft >= 0)
 551                 branch++;
 552             else
 553                 break;
 554             if(branch >= times.count())
 555                 branch = 0;
 556         }
 557
 558         /* In case we end up on a disabled branch, skip ahead.  If we find that
 559          * all the branches are disabled, don't render anything
 560          */
 561         int originalBranch = branch;
 562         while(times[branch] == 0)
 563         {
 564             branch++;
 565             if(branch == originalBranch)
 566             {
 567                 branch = -1;
 568                 break;
 569             }
 570             if(branch >= times.count())
 571                 branch = 0;
 572         }
 573
 574         /* ...and finally render the selected branch */
 575         if(branch >= 0)
 576             children[branch]->render(info, viewport, true);
 577     }
 578 }
 579
 580 bool ParseTreeNode::execTag(const RBRenderInfo& info, RBViewport* viewport)
 581 {
 582
 583     QString filename;
 584     QString id;
 585     int x, y, tiles, tile, maxWidth, maxHeight, width, height;
 586     char c, hAlign, vAlign;
 587     RBImage* image;
 588
 589     /* Two switch statements to narrow down the tag name */
 590     switch(element->tag->name[0])
 591     {
 592
 593     case 'a':
 594         switch(element->tag->name[1])
 595         {
 596         case 'c':
 597             /* %ac */
 598             viewport->alignText(RBViewport::Center);
 599             return true;
 600
 601         case 'l':
 602             /* %al */
 603             viewport->alignText(RBViewport::Left);
 604             return true;
 605
 606         case 'r':
 607             /* %ar */
 608             viewport->alignText(RBViewport::Right);
 609             return true;
 610         }
 611
 612         return false;
 613
 614     case 'w':
 615         switch(element->tag->name[1])
 616         {
 617         case 'd':
 618             info.screen()->disableStatusBar();
 619             return true;
 620
 621         case 'e':
 622             info.screen()->enableStatusBar();
 623             return true;
 624
 625         case 'i':
 626             info.screen()->disableStatusBar();
 627             viewport->enableStatusBar();
 628             return true;
 629         }
 630
 631         return false;
 632
 633     case 'x':
 634         switch(element->tag->name[1])
 635         {
 636         case 'd':
 637             /* %xd */
 638             id = "";
 639             id.append(element->params[0].data.text[0]);
 640             c = element->params[0].data.text[1];
 641
 642             if(c == '\0')
 643             {
 644                 tile = 1;
 645             }
 646             else
 647             {
 648                 if(isupper(c))
 649                     tile = c - 'A' + 25;
 650                 else
 651                     tile = c - 'a';
 652             }
 653
 654             if(info.screen()->getImage(id))
 655             {
 656                 image = new RBImage(*(info.screen()->getImage(id)), viewport);
 657                 image->setTile(tile);
 658                 image->show();
 659             }
 660
 661             return true;
 662
 663         case 'l':
 664             /* %xl */
 665             id = element->params[0].data.text;
 666             filename = info.settings()->value("imagepath", "") + "/" +
 667                        element->params[1].data.text;
 668             x = element->params[2].data.numeric;
 669             y = element->params[3].data.numeric;
 670             if(element->params_count > 4)
 671                 tiles = element->params[4].data.numeric;
 672             else
 673                 tiles = 1;
 674
 675             info.screen()->loadImage(id, new RBImage(filename, tiles, x, y,
 676                                                      viewport));
 677             return true;
 678
 679         case '\0':
 680             /* %x */
 681             id = element->params[0].data.text;
 682             filename = info.settings()->value("imagepath", "") + "/" +
 683                        element->params[1].data.text;
 684             x = element->params[2].data.numeric;
 685             y = element->params[3].data.numeric;
 686             image = new RBImage(filename, 1, x, y, viewport);
 687             info.screen()->loadImage(id, new RBImage(filename, 1, x, y,
 688                                                      viewport));
 689             info.screen()->getImage(id)->show();
 690             return true;
 691
 692         }
 693
 694         return false;
 695
 696     case 'C':
 697         switch(element->tag->name[1])
 698         {
 699         case 'd':
 700             /* %Cd */
 701             info.screen()->showAlbumArt(viewport);
 702             return true;
 703
 704         case 'l':
 705             /* %Cl */
 706             x = element->params[0].data.numeric;
 707             y = element->params[1].data.numeric;
 708             maxWidth = element->params[2].data.numeric;
 709             maxHeight = element->params[3].data.numeric;
 710             hAlign = element->params_count > 4
 711                      ? element->params[4].data.text[0] : 'c';
 712             vAlign = element->params_count > 5
 713                      ? element->params[5].data.text[0] : 'c';
 714             width = info.device()->data("artwidth").toInt();
 715             height = info.device()->data("artheight").toInt();
 716             info.screen()->setAlbumArt(new RBAlbumArt(viewport, x, y, maxWidth,
 717                                                       maxHeight, width, height,
 718                                                       hAlign, vAlign));
 719             return true;
 720         }
 721
 722         return false;
 723
 724     case 'F':
 725
 726         switch(element->tag->name[1])
 727         {
 728
 729         case 'l':
 730             /* %Fl */
 731             x = element->params[0].data.numeric;
 732             filename = info.settings()->value("themebase", "") + "/fonts/" +
 733                        element->params[1].data.text;
 734             info.screen()->loadFont(x, new RBFont(filename));
 735             return true;
 736
 737         }
 738
 739         return false;
 740
 741     case 'V':
 742
 743         switch(element->tag->name[1])
 744         {
 745
 746         case 'b':
 747             /* %Vb */
 748             viewport->setBGColor(RBScreen::
 749                                  stringToColor(QString(element->params[0].
 750                                                        data.text),
 751                                                Qt::white));
 752             return true;
 753
 754         case 'd':
 755             /* %Vd */
 756             id = element->params[0].data.text;
 757             info.screen()->showViewport(id);
 758             return true;
 759
 760         case 'f':
 761             /* %Vf */
 762             viewport->setFGColor(RBScreen::
 763                                  stringToColor(QString(element->params[0].
 764                                                        data.text),
 765                                                Qt::black));
 766             return true;
 767
 768         case 'p':
 769             /* %Vp */
 770             viewport->showPlaylist(info, element->params[0].data.numeric,
 771                                    element->params[1].data.code,
 772                                    element->params[2].data.code);
 773             return true;
 774
 775         case 'I':
 776             /* %VI */
 777             info.screen()->makeCustomUI(element->params[0].data.text);
 778             return true;
 779
 780         }
 781
 782         return false;
 783
 784     case 'X':
 785
 786         switch(element->tag->name[1])
 787         {
 788         case '\0':
 789             /* %X */
 790             filename = QString(element->params[0].data.text);
 791             info.screen()->setBackdrop(filename);
 792             return true;
 793         }
 794
 795         return false;
 796
 797     }
 798
 799     return false;
 800
 801 }
 802
 803 QVariant ParseTreeNode::evalTag(const RBRenderInfo& info, bool conditional,
 804                                 int branches)
 805 {
 806     if(!conditional)
 807     {
 808         return info.device()->data(QString(element->tag->name));
 809     }
 810     else
 811     {
 812         /* If we're evaluating for a conditional, we return the child branch
 813          * index that should be selected.  For true/false values, this is
 814          * 0 for true, 1 for false, and we also have to make sure not to
 815          * ever exceed the number of available children
 816          */
 817
 818         int child;
 819         QVariant val = info.device()->data("?" + QString(element->tag->name));
 820         if(val.isNull())
 821             val = info.device()->data(QString(element->tag->name));
 822
 823         if(val.isNull())
 824         {
 825             child = 1;
 826         }
 827         else if(QString(element->tag->name) == "bl")
 828         {
 829             /* bl has to be scaled to the number of available children, but it
 830              * also has an initial -1 value for an unknown state */
 831             child = val.toInt();
 832             if(child == -1)
 833             {
 834                 child = 0;
 835             }
 836             else
 837             {
 838                 child = ((branches - 1) * child / 100) + 1;
 839             }
 840         }
 841         else if(QString(element->tag->name) == "px")
 842         {
 843             child = val.toInt();
 844             child = branches * child / 100;
 845         }
 846         else if(val.type() == QVariant::Bool)
 847         {
 848             /* Boolean values have to be reversed, because conditionals are
 849              * always of the form %?tag<true|false>
 850              */
 851             if(val.toBool())
 852                 child = 0;
 853             else
 854                 child = 1;
 855         }
 856         else if(val.type() == QVariant::String)
 857         {
 858             if(val.toString().length() > 0)
 859                 child = 0;
 860             else
 861                 child = 1;
 862         }
 863         else
 864         {
 865             child = val.toInt();
 866         }
 867
 868         if(child < 0)
 869             child = 0;
 870
 871         if(child < branches)
 872             return child;
 873         else
 874             return branches - 1;
 875     }
 876 }
 877
 878 double ParseTreeNode::findBranchTime(ParseTreeNode *branch,
 879                                      const RBRenderInfo& info)
 880 {
 881     double retval = 2;
 882     for(int i = 0; i < branch->children.count(); i++)
 883     {
 884         ParseTreeNode* current = branch->children[i];
 885         if(current->element->type == TAG)
 886         {
 887             if(current->element->tag->name[0] == 't'
 888                && current->element->tag->name[1] == '\0')
 889             {
 890                 retval = atof(current->element->params[0].data.text);
 891             }
 892         }
 893         else if(current->element->type == CONDITIONAL)
 894         {
 895             retval = findConditionalTime(current, info);
 896         }
 897     }
 898     return retval;
 899 }
 900
 901 double ParseTreeNode::findConditionalTime(ParseTreeNode *conditional,
 902                                           const RBRenderInfo& info)
 903 {
 904     int child = conditional->evalTag(info, true,
 905                                      conditional->children.count()).toInt();
 906     return findBranchTime(conditional->children[child], info);
 907 }