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     std::cout << rendered->children().count() << std::endl;
 511 }
 512
 513 /* This version is called for logical lines and such */
 514 void ParseTreeNode::render(const RBRenderInfo &info, RBViewport* viewport)
 515 {
 516     if(element->type == LINE)
 517     {
 518         for(int i = 0; i < children.count(); i++)
 519             children[i]->render(info, viewport);
 520         viewport->newline();
 521     }
 522     else if(element->type == TAG)
 523     {
 524         QString filename;
 525         QString id;
 526         int x, y, tiles, tile;
 527         char c;
 528         RBImage* image;
 529
 530         /* Two switch statements to narrow down the tag name */
 531         switch(element->tag->name[0])
 532         {
 533
 534         case 'x':
 535             switch(element->tag->name[1])
 536             {
 537             case 'd':
 538                 /* %xd */
 539                 id = "";
 540                 id.append(element->params[0].data.text[0]);
 541                 c = element->params[0].data.text[1];
 542
 543                 if(c == '\0')
 544                 {
 545                     tile = 1;
 546                 }
 547                 else
 548                 {
 549                     if(isupper(c))
 550                         tile = c - 'A' + 25;
 551                     else
 552                         tile = c - 'a';
 553                 }
 554
 555                 image = info.screen()->getImage(id);
 556                 if(image)
 557                 {
 558                     image->setTile(tile);
 559                     image->show();
 560                 }
 561                 break;
 562
 563             case 'l':
 564                 /* %xl */
 565                 id = element->params[0].data.text;
 566                 filename = info.settings()->value("imagepath", "") + "/" +
 567                            element->params[1].data.text;
 568                 x = element->params[2].data.numeric;
 569                 y = element->params[3].data.numeric;
 570                 if(element->params_count > 4)
 571                     tiles = element->params[4].data.numeric;
 572                 else
 573                     tiles = 1;
 574
 575                 info.screen()->loadImage(id, new RBImage(filename, tiles, x, y,
 576                                                          viewport));
 577                 break;
 578
 579             case '\0':
 580                 /* %x */
 581                 id = element->params[0].data.text;
 582                 filename = info.settings()->value("imagepath", "") + "/" +
 583                            element->params[1].data.text;
 584                 x = element->params[2].data.numeric;
 585                 y = element->params[3].data.numeric;
 586                 image = new RBImage(filename, 1, x, y, viewport);
 587                 info.screen()->loadImage(id, new RBImage(filename, 1, x, y,
 588                                                          viewport));
 589                 info.screen()->getImage(id)->show();
 590                 break;
 591
 592             }
 593
 594             break;
 595
 596         case 'X':
 597
 598             switch(element->tag->name[1])
 599             {
 600             case '\0':
 601                 /* %X */
 602                 filename = QString(element->params[0].data.text);
 603                 info.screen()->setBackdrop(filename);
 604                 break;
 605             }
 606
 607             break;
 608
 609         }
 610     }
 611 }