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 #include "rbprogressbar.h"
  30 #include "rbtoucharea.h"
  31
  32 #include <iostream>
  33 #include <cmath>
  34 #include <cassert>
  35
  36 #include <QDebug>
  37
  38 int ParseTreeNode::openConditionals = 0;
  39 bool ParseTreeNode::breakFlag = false;
  40
  41 /* Root element constructor */
  42 ParseTreeNode::ParseTreeNode(struct skin_element* data, ParseTreeModel* model)
  43     : parent(0), element(0), param(0), children(), model(model)
  44 {
  45     while(data)
  46     {
  47         children.append(new ParseTreeNode(data, this, model));
  48         data = data->next;
  49     }
  50 }
  51
  52 /* Normal element constructor */
  53 ParseTreeNode::ParseTreeNode(struct skin_element* data, ParseTreeNode* parent,
  54                              ParseTreeModel* model)
  55                                  : parent(parent), element(data), param(0),
  56                                  children(), model(model)
  57 {
  58     switch(element->type)
  59     {
  60
  61     case TAG:
  62         for(int i = 0; i < element->params_count; i++)
  63         {
  64             if(element->params[i].type == skin_tag_parameter::CODE)
  65                 children.append(new ParseTreeNode(element->params[i].data.code,
  66                                               this, model));
  67             else
  68                 children.append(new ParseTreeNode(&element->params[i], this,
  69                                                   model));
  70         }
  71         break;
  72
  73     case CONDITIONAL:
  74         for(int i = 0; i < element->params_count; i++)
  75             children.append(new ParseTreeNode(&data->params[i], this, model));
  76         for(int i = 0; i < element->children_count; i++)
  77             children.append(new ParseTreeNode(data->children[i], this, model));
  78         break;
  79
  80     case LINE_ALTERNATOR:
  81         for(int i = 0; i < element->children_count; i++)
  82         {
  83             children.append(new ParseTreeNode(data->children[i], this, model));
  84         }
  85         break;
  86
  87 case VIEWPORT:
  88         for(int i = 0; i < element->params_count; i++)
  89             children.append(new ParseTreeNode(&data->params[i], this, model));
  90         /* Deliberate fall-through here */
  91
  92     case LINE:
  93         for(int i = 0; i < data->children_count; i++)
  94         {
  95             for(struct skin_element* current = data->children[i]; current;
  96                 current = current->next)
  97             {
  98                 children.append(new ParseTreeNode(current, this, model));
  99             }
 100         }
 101         break;
 102
 103     default:
 104         break;
 105     }
 106 }
 107
 108 /* Parameter constructor */
 109 ParseTreeNode::ParseTreeNode(skin_tag_parameter *data, ParseTreeNode *parent,
 110                              ParseTreeModel *model)
 111                                  : parent(parent), element(0), param(data),
 112                                  children(), model(model)
 113 {
 114
 115 }
 116
 117 ParseTreeNode::~ParseTreeNode()
 118 {
 119     for(int i = 0; i < children.count(); i++)
 120         delete children[i];
 121 }
 122
 123 QString ParseTreeNode::genCode() const
 124 {
 125     QString buffer = "";
 126
 127     if(element)
 128     {
 129         switch(element->type)
 130         {
 131         case UNKNOWN:
 132             break;
 133         case VIEWPORT:
 134             /* Generating the Viewport tag, if necessary */
 135             if(element->tag)
 136             {
 137                 buffer.append(TAGSYM);
 138                 buffer.append(element->tag->name);
 139                 buffer.append(ARGLISTOPENSYM);
 140                 for(int i = 0; i < element->params_count; i++)
 141                 {
 142                     buffer.append(children[i]->genCode());
 143                     if(i != element->params_count - 1)
 144                         buffer.append(ARGLISTSEPARATESYM);
 145                 }
 146                 buffer.append(ARGLISTCLOSESYM);
 147                 buffer.append('\n');
 148             }
 149
 150             for(int i = element->params_count; i < children.count(); i++)
 151                 buffer.append(children[i]->genCode());
 152             break;
 153
 154         case LINE:
 155             for(int i = 0; i < children.count(); i++)
 156             {
 157                 buffer.append(children[i]->genCode());
 158             }
 159             if(openConditionals == 0
 160                && !(parent && parent->element->type == LINE_ALTERNATOR)
 161                && !(children.count() > 0 &&
 162                     children[children.count() - 1]->getElement()->type
 163                     == COMMENT))
 164             {
 165                 buffer.append('\n');
 166             }
 167             break;
 168
 169         case LINE_ALTERNATOR:
 170             for(int i = 0; i < children.count(); i++)
 171             {
 172                 buffer.append(children[i]->genCode());
 173                 if(i != children.count() - 1)
 174                     buffer.append(MULTILINESYM);
 175             }
 176             if(openConditionals == 0)
 177                 buffer.append('\n');
 178             break;
 179
 180         case CONDITIONAL:
 181             openConditionals++;
 182
 183             /* Inserting the tag part */
 184             buffer.append(TAGSYM);
 185             buffer.append(CONDITIONSYM);
 186             buffer.append(element->tag->name);
 187             if(element->params_count > 0)
 188             {
 189                 buffer.append(ARGLISTOPENSYM);
 190                 for(int i = 0; i < element->params_count; i++)
 191                 {
 192                     buffer.append(children[i]->genCode());
 193                     if( i != element->params_count - 1)
 194                         buffer.append(ARGLISTSEPARATESYM);
 195                     buffer.append(ARGLISTCLOSESYM);
 196                 }
 197             }
 198
 199             /* Inserting the sublines */
 200             buffer.append(ENUMLISTOPENSYM);
 201             for(int i = element->params_count; i < children.count(); i++)
 202             {
 203                 buffer.append(children[i]->genCode());
 204                 if(i != children.count() - 1)
 205                     buffer.append(ENUMLISTSEPARATESYM);
 206             }
 207             buffer.append(ENUMLISTCLOSESYM);
 208             openConditionals--;
 209             break;
 210
 211         case TAG:
 212             buffer.append(TAGSYM);
 213             buffer.append(element->tag->name);
 214
 215             if(element->params_count > 0)
 216             {
 217                 /* Rendering parameters if there are any */
 218                 buffer.append(ARGLISTOPENSYM);
 219                 for(int i = 0; i < children.count(); i++)
 220                 {
 221                     buffer.append(children[i]->genCode());
 222                     if(i != children.count() - 1)
 223                         buffer.append(ARGLISTSEPARATESYM);
 224                 }
 225                 buffer.append(ARGLISTCLOSESYM);
 226             }
 227             if(element->tag->params[strlen(element->tag->params) - 1] == '\n')
 228                 buffer.append('\n');
 229             break;
 230
 231         case TEXT:
 232             for(char* cursor = (char*)element->data; *cursor; cursor++)
 233             {
 234                 if(find_escape_character(*cursor))
 235                     buffer.append(TAGSYM);
 236                 buffer.append(*cursor);
 237             }
 238             break;
 239
 240         case COMMENT:
 241             buffer.append(COMMENTSYM);
 242             buffer.append((char*)element->data);
 243             buffer.append('\n');
 244             break;
 245         }
 246     }
 247     else if(param)
 248     {
 249         switch(param->type)
 250         {
 251         case skin_tag_parameter::STRING:
 252             for(char* cursor = param->data.text; *cursor; cursor++)
 253             {
 254                 if(find_escape_character(*cursor))
 255                     buffer.append(TAGSYM);
 256                 buffer.append(*cursor);
 257             }
 258             break;
 259
 260         case skin_tag_parameter::INTEGER:
 261             buffer.append(QString::number(param->data.number, 10));
 262             break;
 263
 264         case skin_tag_parameter::DECIMAL:
 265             buffer.append(QString::number(param->data.number / 10., 'f', 1));
 266             break;
 267
 268         case skin_tag_parameter::DEFAULT:
 269             buffer.append(DEFAULTSYM);
 270             break;
 271
 272         case skin_tag_parameter::CODE:
 273             buffer.append(QObject::tr("This doesn't belong here"));
 274             break;
 275
 276         }
 277     }
 278     else
 279     {
 280         for(int i = 0; i < children.count(); i++)
 281             buffer.append(children[i]->genCode());
 282     }
 283
 284     return buffer;
 285 }
 286
 287 /* A more or less random hashing algorithm */
 288 int ParseTreeNode::genHash() const
 289 {
 290     int hash = 0;
 291     char *text;
 292
 293     if(element)
 294     {
 295         hash += element->type;
 296         switch(element->type)
 297         {
 298         case UNKNOWN:
 299             break;
 300         case VIEWPORT:
 301         case LINE:
 302         case LINE_ALTERNATOR:
 303         case CONDITIONAL:
 304             hash += element->children_count;
 305             break;
 306
 307         case TAG:
 308             for(unsigned int i = 0; i < strlen(element->tag->name); i++)
 309                 hash += element->tag->name[i];
 310             break;
 311
 312         case COMMENT:
 313         case TEXT:
 314             text = (char*)element->data;
 315             for(unsigned int i = 0; i < strlen(text); i++)
 316             {
 317                 if(i % 2)
 318                     hash += text[i] % element->type;
 319                 else
 320                     hash += text[i] % element->type * 2;
 321             }
 322             break;
 323         }
 324
 325     }
 326
 327     if(param)
 328     {
 329         hash += param->type;
 330         switch(param->type)
 331         {
 332         case skin_tag_parameter::DEFAULT:
 333         case skin_tag_parameter::CODE:
 334             break;
 335
 336         case skin_tag_parameter::INTEGER:
 337             hash += param->data.number * (param->data.number / 4);
 338             break;
 339
 340         case skin_tag_parameter::STRING:
 341             for(unsigned int i = 0; i < strlen(param->data.text); i++)
 342             {
 343                 if(i % 2)
 344                     hash += param->data.text[i] * 2;
 345                 else
 346                     hash += param->data.text[i];
 347             }
 348             break;
 349
 350         case skin_tag_parameter::DECIMAL:
 351             hash += param->data.number;
 352             break;
 353         }
 354     }
 355
 356     for(int i = 0; i < children.count(); i++)
 357     {
 358         hash += children[i]->genHash();
 359     }
 360
 361     return hash;
 362 }
 363
 364 ParseTreeNode* ParseTreeNode::child(int row)
 365 {
 366     if(row < 0 || row >= children.count())
 367         return 0;
 368
 369     return children[row];
 370 }
 371
 372 int ParseTreeNode::numChildren() const
 373 {
 374         return children.count();
 375 }
 376
 377
 378 QVariant ParseTreeNode::data(int column) const
 379 {
 380     switch(column)
 381     {
 382     case ParseTreeModel::typeColumn:
 383         if(element)
 384         {
 385             switch(element->type)
 386             {
 387             case UNKNOWN:
 388                 return QObject::tr("Unknown");
 389             case VIEWPORT:
 390                 return QObject::tr("Viewport");
 391
 392             case LINE:
 393                 return QObject::tr("Logical Line");
 394
 395             case LINE_ALTERNATOR:
 396                 return QObject::tr("Alternator");
 397
 398             case COMMENT:
 399                 return QObject::tr("Comment");
 400
 401             case CONDITIONAL:
 402                 return QObject::tr("Conditional Tag");
 403
 404             case TAG:
 405                 return QObject::tr("Tag");
 406
 407             case TEXT:
 408                 return QObject::tr("Plaintext");
 409             }
 410         }
 411         else if(param)
 412         {
 413             switch(param->type)
 414             {
 415             case skin_tag_parameter::STRING:
 416                 return QObject::tr("String");
 417
 418             case skin_tag_parameter::INTEGER:
 419                 return QObject::tr("Integer");
 420
 421             case skin_tag_parameter::DECIMAL:
 422                 return QObject::tr("Decimal");
 423
 424             case skin_tag_parameter::DEFAULT:
 425                 return QObject::tr("Default Argument");
 426
 427             case skin_tag_parameter::CODE:
 428                 return QObject::tr("This doesn't belong here");
 429             }
 430         }
 431         else
 432         {
 433             return QObject::tr("Root");
 434         }
 435
 436         break;
 437
 438     case ParseTreeModel::valueColumn:
 439         if(element)
 440         {
 441             switch(element->type)
 442             {
 443             case UNKNOWN:
 444             case VIEWPORT:
 445             case LINE:
 446             case LINE_ALTERNATOR:
 447                 return QString();
 448
 449             case CONDITIONAL:
 450                 return QString(element->tag->name);
 451
 452             case TEXT:
 453             case COMMENT:
 454                 return QString((char*)element->data);
 455
 456             case TAG:
 457                 return QString(element->tag->name);
 458             }
 459         }
 460         else if(param)
 461         {
 462             switch(param->type)
 463             {
 464             case skin_tag_parameter::DEFAULT:
 465                 return QObject::tr("-");
 466
 467             case skin_tag_parameter::STRING:
 468                 return QString(param->data.text);
 469
 470             case skin_tag_parameter::INTEGER:
 471                 return QString::number(param->data.number, 10);
 472
 473             case skin_tag_parameter::DECIMAL:
 474                 return QString::number(param->data.number / 10., 'f', 1);
 475
 476             case skin_tag_parameter::CODE:
 477                 return QObject::tr("Seriously, something's wrong here");
 478
 479             }
 480         }
 481         else
 482         {
 483             return QString();
 484         }
 485         break;
 486
 487     case ParseTreeModel::lineColumn:
 488         if(element)
 489             return QString::number(element->line, 10);
 490         else
 491             return QString();
 492         break;
 493     }
 494
 495     return QVariant();
 496 }
 497
 498
 499 int ParseTreeNode::getRow() const
 500 {
 501     if(!parent)
 502         return -1;
 503
 504     return parent->children.indexOf(const_cast<ParseTreeNode*>(this));
 505 }
 506
 507 ParseTreeNode* ParseTreeNode::getParent() const
 508 {
 509     return parent;
 510 }
 511
 512 /* This version is called for the root node and for viewports */
 513 void ParseTreeNode::render(const RBRenderInfo& info)
 514 {
 515     /* Parameters don't get rendered */
 516     if(!element && param)
 517         return;
 518
 519     /* If we're at the root, we need to render each viewport */
 520     if(!element && !param)
 521     {
 522         for(int i = 0; i < children.count(); i++)
 523         {
 524             children[i]->render(info);
 525         }
 526
 527         return;
 528     }
 529
 530     if(element->type != VIEWPORT)
 531     {
 532         std::cerr << QObject::tr("Error in parse tree").toStdString()
 533                 << std::endl;
 534         return;
 535     }
 536
 537     rendered = new RBViewport(element, info, this);
 538
 539     for(int i = element->params_count; i < children.count(); i++)
 540         children[i]->render(info, dynamic_cast<RBViewport*>(rendered));
 541
 542 }
 543
 544 /* This version is called for logical lines, tags, conditionals and such */
 545 void ParseTreeNode::render(const RBRenderInfo &info, RBViewport* viewport,
 546                            bool noBreak)
 547 {
 548     if(!element)
 549         return;
 550
 551     if(element->type == LINE)
 552     {
 553         for(int i = 0; i < children.count(); i++)
 554             children[i]->render(info, viewport);
 555         if(!noBreak && !breakFlag)
 556             viewport->newLine();
 557         else
 558             viewport->flushText();
 559
 560         if(breakFlag)
 561             breakFlag = false;
 562     }
 563     else if(element->type == TEXT)
 564     {
 565         viewport->write(QString(static_cast<char*>(element->data)));
 566     }
 567     else if(element->type == TAG)
 568     {
 569         if(!execTag(info, viewport))
 570             viewport->write(evalTag(info).toString());
 571         if(element->tag->flags & NOBREAK)
 572             breakFlag = true;
 573     }
 574     else if(element->type == CONDITIONAL)
 575     {
 576         int child = evalTag(info, true, element->children_count).toInt();
 577         int max = children.count() - element->params_count;
 578         if(child < max)
 579         {
 580             children[element->params_count + child]
 581                     ->render(info, viewport, true);
 582         }
 583     }
 584     else if(element->type == LINE_ALTERNATOR)
 585     {
 586         /* First we build a list of the times for each branch */
 587         QList<double> times;
 588         for(int i = 0; i < children.count() ; i++)
 589             times.append(findBranchTime(children[i], info));
 590
 591         double totalTime = 0;
 592         for(int i = 0; i < children.count(); i++)
 593             totalTime += times[i];
 594
 595         /* Now we figure out which branch to select */
 596         double timeLeft = info.device()->data(QString("simtime")).toDouble();
 597
 598         /* Skipping any full cycles */
 599         timeLeft -= totalTime * std::floor(timeLeft / totalTime);
 600
 601         int branch = 0;
 602         while(timeLeft > 0)
 603         {
 604             timeLeft -= times[branch];
 605             if(timeLeft >= 0)
 606                 branch++;
 607             else
 608                 break;
 609             if(branch >= times.count())
 610                 branch = 0;
 611         }
 612
 613         /* In case we end up on a disabled branch, skip ahead.  If we find that
 614          * all the branches are disabled, don't render anything
 615          */
 616         int originalBranch = branch;
 617         while(times[branch] == 0)
 618         {
 619             branch++;
 620             if(branch == originalBranch)
 621             {
 622                 branch = -1;
 623                 break;
 624             }
 625             if(branch >= times.count())
 626                 branch = 0;
 627         }
 628
 629         /* ...and finally render the selected branch */
 630         if(branch >= 0)
 631             children[branch]->render(info, viewport, true);
 632     }
 633 }
 634
 635 bool ParseTreeNode::execTag(const RBRenderInfo& info, RBViewport* viewport)
 636 {
 637
 638     QString filename;
 639     QString id;
 640     int x, y, tiles, tile, maxWidth, maxHeight, width, height;
 641     char c, hAlign, vAlign;
 642     RBImage* image;
 643     QPixmap temp;
 644     RBFont* fLoad;
 645
 646     /* Two switch statements to narrow down the tag name */
 647     switch(element->tag->name[0])
 648     {
 649
 650     case 'a':
 651         switch(element->tag->name[1])
 652         {
 653         case 'c':
 654             /* %ac */
 655             viewport->alignText(RBViewport::Center);
 656             return true;
 657
 658         case 'l':
 659             /* %al */
 660             viewport->alignText(RBViewport::Left);
 661             return true;
 662
 663         case 'r':
 664             /* %ar */
 665             viewport->alignText(RBViewport::Right);
 666             return true;
 667
 668         case 'x':
 669             /* %ax */
 670             info.screen()->RtlMirror();
 671             return true;
 672
 673         case 'L':
 674             /* %aL */
 675             if(info.device()->data("rtl").toBool())
 676                 viewport->alignText(RBViewport::Right);
 677             else
 678                 viewport->alignText(RBViewport::Left);
 679             return true;
 680
 681         case 'R':
 682             /* %aR */
 683             if(info.device()->data("rtl").toBool())
 684                 viewport->alignText(RBViewport::Left);
 685             else
 686                 viewport->alignText(RBViewport::Right);
 687             return true;
 688         }
 689
 690         return false;
 691
 692     case 'p':
 693         switch(element->tag->name[1])
 694         {
 695         case 'b':
 696             /* %pb */
 697             new RBProgressBar(viewport, info, this);
 698             return true;
 699
 700         case 'v':
 701             /* %pv */
 702             if(element->params_count > 0)
 703             {
 704                 new RBProgressBar(viewport, info, this, true);
 705                 return true;
 706             }
 707             else
 708                 return false;
 709         }
 710
 711         return false;
 712
 713     case 's':
 714         switch(element->tag->name[1])
 715         {
 716         case '\0':
 717             /* %s */
 718             viewport->scrollText(info.device()->data("simtime").toDouble());
 719             return true;
 720         }
 721
 722         return false;
 723
 724     case 'w':
 725         switch(element->tag->name[1])
 726         {
 727         case 'd':
 728             /* %wd */
 729             info.screen()->breakSBS();
 730             return true;
 731
 732         case 'e':
 733             /* %we */
 734             /* Totally extraneous */
 735             return true;
 736
 737         case 'i':
 738             /* %wi */
 739             viewport->enableStatusBar();
 740             return true;
 741         }
 742
 743         return false;
 744
 745     case 'x':
 746         switch(element->tag->name[1])
 747         {
 748         case 'd':
 749             /* %xd */
 750
 751             /* Breaking up into cases, getting the id first */
 752             if(element->params_count == 1)
 753             {
 754                 /* The old fashioned style */
 755                 id = "";
 756                 id.append(element->params[0].data.text[0]);
 757             }
 758             else
 759             {
 760                 id = QString(element->params[0].data.text);
 761             }
 762
 763
 764             if(info.screen()->getImage(id))
 765             {
 766                 /* Fetching the image if available */
 767                 image = new RBImage(*(info.screen()->getImage(id)), viewport);
 768             }
 769             else
 770             {
 771                 image = 0;
 772             }
 773
 774             /* Now determining the particular tile to load */
 775             if(element->params_count == 1)
 776             {
 777                 c = element->params[0].data.text[1];
 778
 779                 if(c == '\0')
 780                 {
 781                     tile = 1;
 782                 }
 783                 else
 784                 {
 785                     if(isupper(c))
 786                         tile = c - 'A' + 25;
 787                     else
 788                         tile = c - 'a';
 789                 }
 790
 791             }else{
 792                 /* If the next param is just an int, use it as the tile */
 793                 if(element->params[1].type == skin_tag_parameter::INTEGER)
 794                 {
 795                     tile = element->params[1].data.number - 1;
 796                 }
 797                 else
 798                 {
 799                     tile = children[1]->evalTag(info, true,
 800                                                 image->numTiles()).toInt();
 801
 802                     /* Adding the offset if there is one */
 803                     if(element->params_count == 3)
 804                         tile += element->params[2].data.number;
 805                     if(tile < 0)
 806                     {
 807                         /* If there is no image for the current status, then
 808                          * just refrain from showing anything
 809                          */
 810                         delete image;
 811                         return true;
 812                     }
 813                 }
 814             }
 815
 816             if(image)
 817             {
 818                 image->setTile(tile);
 819                 image->show();
 820                 image->enableMovement();
 821             }
 822
 823             return true;
 824
 825         case 'l':
 826             /* %xl */
 827             id = element->params[0].data.text;
 828             if(element->params[1].data.text == QString("__list_icons__"))
 829             {
 830                 filename = info.settings()->value("iconset", "");
 831                 filename.replace(".rockbox",
 832                                  info.settings()->value("themebase"));
 833                 temp.load(filename);
 834                 if(!temp.isNull())
 835                 {
 836                     tiles = temp.height() / temp.width();
 837                 }
 838             }
 839             else
 840             {
 841                 filename = info.settings()->value("imagepath", "") + "/" +
 842                            element->params[1].data.text;
 843                 tiles = 1;
 844             }
 845             x = element->params[2].data.number;
 846             y = element->params[3].data.number;
 847             if(element->params_count > 4)
 848                 tiles = element->params[4].data.number;
 849
 850             info.screen()->loadImage(id, new RBImage(filename, tiles, x, y,
 851                                                      this, viewport));
 852             return true;
 853
 854         case '\0':
 855             /* %x */
 856             id = element->params[0].data.text;
 857             filename = info.settings()->value("imagepath", "") + "/" +
 858                        element->params[1].data.text;
 859             x = element->params[2].data.number;
 860             y = element->params[3].data.number;
 861             image = new RBImage(filename, 1, x, y, this, viewport);
 862             info.screen()->loadImage(id, image);
 863             image->show();
 864             image->enableMovement();
 865
 866             return true;
 867
 868         }
 869
 870         return false;
 871
 872     case 'C':
 873         switch(element->tag->name[1])
 874         {
 875         case 'd':
 876             /* %Cd */
 877             info.screen()->showAlbumArt(viewport);
 878             return true;
 879
 880         case 'l':
 881             /* %Cl */
 882             x = element->params[0].data.number;
 883             y = element->params[1].data.number;
 884             maxWidth = element->params[2].data.number;
 885             maxHeight = element->params[3].data.number;
 886             hAlign = element->params_count > 4
 887                      ? element->params[4].data.text[0] : 'c';
 888             vAlign = element->params_count > 5
 889                      ? element->params[5].data.text[0] : 'c';
 890             width = info.device()->data("artwidth").toInt();
 891             height = info.device()->data("artheight").toInt();
 892             info.screen()->setAlbumArt(new RBAlbumArt(viewport, x, y, maxWidth,
 893                                                       maxHeight, width, height,
 894                                                       this, hAlign, vAlign));
 895             return true;
 896         }
 897
 898         return false;
 899
 900     case 'F':
 901
 902         switch(element->tag->name[1])
 903         {
 904
 905         case 'l':
 906             /* %Fl */
 907             x = element->params[0].data.number;
 908             filename = info.settings()->value("themebase", "") + "/fonts/" +
 909                        element->params[1].data.text;
 910             fLoad = new RBFont(filename);
 911             if(!fLoad->isValid())
 912                 dynamic_cast<RBScene*>(info.screen()->scene())
 913                 ->addWarning(QObject::tr("Missing font file: ") + filename);
 914             info.screen()->loadFont(x, fLoad);
 915             return true;
 916
 917         }
 918
 919         return false;
 920
 921     case 'T':
 922         switch(element->tag->name[1])
 923         {
 924         case '\0':
 925             /* %T */
 926             if(element->params_count < 5)
 927                 return false;
 928             int x = element->params[0].data.number;
 929             int y = element->params[1].data.number;
 930             int width = element->params[2].data.number;
 931             int height = element->params[3].data.number;
 932             QString action(element->params[4].data.text);
 933             RBTouchArea* temp = new RBTouchArea(width, height, action, info,
 934                                                 viewport);
 935             temp->setPos(x, y);
 936             return true;
 937         }
 938
 939         return false;
 940
 941     case 'V':
 942
 943         switch(element->tag->name[1])
 944         {
 945
 946         case 'b':
 947             /* %Vb */
 948             viewport->setBGColor(RBScreen::
 949                                  stringToColor(QString(element->params[0].
 950                                                        data.text),
 951                                                Qt::white));
 952             return true;
 953
 954         case 'd':
 955             /* %Vd */
 956             id = element->params[0].data.text;
 957             info.screen()->showViewport(id);
 958             return true;
 959
 960         case 'f':
 961             /* %Vf */
 962             viewport->setFGColor(RBScreen::
 963                                  stringToColor(QString(element->params[0].
 964                                                        data.text),
 965                                                Qt::black));
 966             return true;
 967
 968         case 'p':
 969             /* %Vp */
 970             viewport->showPlaylist(info, element->params[0].data.number,
 971                                    children[1]);
 972             return true;
 973
 974         case 'I':
 975             /* %VI */
 976             info.screen()->makeCustomUI(element->params[0].data.text);
 977             return true;
 978
 979         }
 980
 981         return false;
 982
 983     case 'X':
 984
 985         switch(element->tag->name[1])
 986         {
 987         case '\0':
 988             /* %X */
 989             filename = QString(element->params[0].data.text);
 990             info.screen()->setBackdrop(filename);
 991             return true;
 992         }
 993
 994         return false;
 995
 996     }
 997
 998     return false;
 999
1000 }
1001
1002 QVariant ParseTreeNode::evalTag(const RBRenderInfo& info, bool conditional,
1003                                 int branches)
1004 {
1005     if(!conditional)
1006     {
1007         if(element->tag->name[0] == 'c' && !info.device()->data("cc").toBool())
1008             return QString();
1009
1010         if(QString(element->tag->name) == "Sx")
1011             return element->params[0].data.text;
1012         return info.device()->data(QString(element->tag->name),
1013                                    element->params_count, element->params);
1014     }
1015     else
1016     {
1017         /* If we're evaluating for a conditional, we return the child branch
1018          * index that should be selected.  For true/false values, this is
1019          * 0 for true, 1 for false, and we also have to make sure not to
1020          * ever exceed the number of available children
1021          */
1022
1023         int child;
1024         QVariant val = info.device()->data("?" + QString(element->tag->name));
1025         if(val.isNull())
1026             val = info.device()->data(QString(element->tag->name),
1027                                       element->params_count, element->params);
1028
1029         if(val.isNull())
1030         {
1031             child = 1;
1032         }
1033         else if(QString(element->tag->name) == "bl")
1034         {
1035             /* bl has to be scaled to the number of available children, but it
1036              * also has an initial -1 value for an unknown state */
1037             child = val.toInt();
1038             if(child == -1)
1039             {
1040                 child = 0;
1041             }
1042             else
1043             {
1044                 child = ((branches - 1) * child / 100) + 1;
1045             }
1046         }
1047         else if(QString(element->tag->name) == "pv")
1048         {
1049             /* ?pv gets scaled to the number of available children, sandwiched
1050              * in between mute and 0/>0dB.  I assume a floor of -50dB for the
1051              * time being
1052              */
1053             int dB = val.toInt();
1054
1055             if(dB < -50)
1056                 child = 0;
1057             else if(dB == 0)
1058                 child = branches - 2;
1059             else if(dB > 0)
1060                 child = branches - 1;
1061             else
1062             {
1063                 int options = branches - 3;
1064                 child = (options * (dB + 50)) / 50;
1065             }
1066         }
1067         else if(QString(element->tag->name) == "px")
1068         {
1069             child = val.toInt();
1070             child = branches * child / 100;
1071         }
1072         else if(val.type() == QVariant::Bool)
1073         {
1074             /* Boolean values have to be reversed, because conditionals are
1075              * always of the form %?tag<true|false>
1076              */
1077             if(val.toBool())
1078                 child = 0;
1079             else
1080                 child = 1;
1081         }
1082         else if(element->tag->name[0] == 'i' || element->tag->name[0] == 'I'
1083                 || element->tag->name[0] == 'f' || element->tag->name[0] == 'F')
1084         {
1085             if(info.device()->data("id3available").toBool())
1086                 child = 0;
1087             else
1088                 child = 1;
1089         }
1090         else if(val.type() == QVariant::String)
1091         {
1092             if(val.toString().length() > 0)
1093                 child = 0;
1094             else
1095                 child = 1;
1096         }
1097         else
1098         {
1099             child = val.toInt();
1100         }
1101
1102         if(child < 0)
1103             child = 0;
1104
1105         if(child < branches)
1106             return child;
1107         else if(branches == 1)
1108             return 2;
1109         else
1110             return branches - 1;
1111     }
1112 }
1113
1114 double ParseTreeNode::findBranchTime(ParseTreeNode *branch,
1115                                      const RBRenderInfo& info)
1116 {
1117     double retval = 2;
1118     for(int i = 0; i < branch->children.count(); i++)
1119     {
1120         ParseTreeNode* current = branch->children[i];
1121         if(current->element->type == TAG)
1122         {
1123             if(current->element->tag->name[0] == 't'
1124                && current->element->tag->name[1] == '\0')
1125             {
1126                 retval = current->element->params[0].data.number / 10.;
1127             }
1128         }
1129         else if(current->element->type == CONDITIONAL)
1130         {
1131             retval = findConditionalTime(current, info);
1132         }
1133     }
1134     return retval;
1135 }
1136
1137 double ParseTreeNode::findConditionalTime(ParseTreeNode *conditional,
1138                                           const RBRenderInfo& info)
1139 {
1140     int child = conditional->evalTag(info, true,
1141                                      conditional->children.count()).toInt();
1142     if(child >= conditional->children.count())
1143         child = conditional->children.count() - 1;
1144
1145     return findBranchTime(conditional->children[child], info);
1146 }
1147
1148 void ParseTreeNode::modParam(QVariant value, int index)
1149 {
1150     if(element)
1151     {
1152         if(index < 0)
1153             return;
1154         while(index >= children.count())
1155         {
1156             /* Padding children with defaults until we make the necessary
1157              * parameter available
1158              */
1159             skin_tag_parameter* newParam = new skin_tag_parameter;
1160             newParam->type = skin_tag_parameter::DEFAULT;
1161             /* We'll need to manually delete the extra parameters in the
1162              * destructor
1163              */
1164             extraParams.append(children.count());
1165
1166             children.append(new ParseTreeNode(newParam, this, model));
1167             element->params_count++;
1168         }
1169
1170         children[index]->modParam(value);
1171     }
1172     else if(param)
1173     {
1174         if(value.type() == QVariant::Double)
1175         {
1176             param->type = skin_tag_parameter::DECIMAL;
1177             param->data.number = static_cast<int>(value.toDouble() * 10);
1178         }
1179         else if(value.type() == QVariant::String)
1180         {
1181             param->type = skin_tag_parameter::STRING;
1182             free(param->data.text);
1183             param->data.text = strdup(value.toString().toStdString().c_str());
1184         }
1185         else if(value.type() == QVariant::Int)
1186         {
1187             param->type = skin_tag_parameter::INTEGER;
1188             param->data.number = value.toInt();
1189         }
1190
1191         model->paramChanged(this);
1192
1193     }
1194 }