utils/themeeditor/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 int ParseTreeNode::openConditionals = 0;
  29
  30 /* Root element constructor */
  31 ParseTreeNode::ParseTreeNode(struct skin_element* data)
  32     : parent(0), element(0), param(0), children()
  33 {
  34     while(data)
  35     {
  36         children.append(new ParseTreeNode(data, this));
  37         data = data->next;
  38     }
  39 }
  40
  41 /* Normal element constructor */
  42 ParseTreeNode::ParseTreeNode(struct skin_element* data, ParseTreeNode* parent)
  43     : parent(parent), element(data), param(0), children()
  44 {
  45     switch(element->type)
  46     {
  47
  48     case TAG:
  49         for(int i = 0; i < element->params_count; i++)
  50         {
  51             if(element->params[i].type == skin_tag_parameter::CODE)
  52                 children.append(new ParseTreeNode(element->params[i].data.code,
  53                                               this));
  54             else
  55                 children.append(new ParseTreeNode(&element->params[i], this));
  56         }
  57         break;
  58
  59         /* CONDITIONAL and SUBLINES fall through to the same code */
  60     case CONDITIONAL:
  61     case SUBLINES:
  62         for(int i = 0; i < element->children_count; i++)
  63         {
  64             children.append(new ParseTreeNode(data->children[i], this));
  65         }
  66         break;
  67
  68     case VIEWPORT:
  69     case LINE:
  70         for(int i = 0; i < data->children_count; i++)
  71         {
  72             for(struct skin_element* current = data->children[i]; current;
  73                 current = current->next)
  74             {
  75                 children.append(new ParseTreeNode(current, this));
  76             }
  77         }
  78         break;
  79
  80     default:
  81         break;
  82     }
  83 }
  84
  85 /* Parameter constructor */
  86 ParseTreeNode::ParseTreeNode(skin_tag_parameter *data, ParseTreeNode *parent)
  87     : parent(parent), element(0), param(data), children()
  88 {
  89
  90 }
  91
  92 QString ParseTreeNode::genCode() const
  93 {
  94     QString buffer = "";
  95
  96     if(element)
  97     {
  98         switch(element->type)
  99         {
 100
 101         case VIEWPORT:
 102             if(children[0]->element->type == TAG)
 103                 buffer.append(TAGSYM);
 104             buffer.append(children[0]->genCode());
 105             if(children[0]->element->type == TAG)
 106                 buffer.append('\n');
 107             for(int i = 1; i < children.count(); i++)
 108                 buffer.append(children[i]->genCode());
 109             break;
 110
 111         case LINE:
 112             for(int i = 0; i < children.count(); i++)
 113             {
 114                 /*
 115                   Adding a % in case of tag, because the tag rendering code
 116                   doesn't insert its own
 117                  */
 118                 if(children[i]->element->type == TAG)
 119                     buffer.append(TAGSYM);
 120                 buffer.append(children[i]->genCode());
 121             }
 122             if(openConditionals == 0)
 123                 buffer.append('\n');
 124             break;
 125
 126         case SUBLINES:
 127             for(int i = 0; i < children.count(); i++)
 128             {
 129                 buffer.append(children[i]->genCode());
 130                 if(i != children.count() - 1)
 131                     buffer.append(MULTILINESYM);
 132             }
 133             buffer.append('\n');
 134             break;
 135
 136         case CONDITIONAL:
 137             openConditionals++;
 138             /* Inserts a %?, the tag renderer doesn't deal with the TAGSYM */
 139             buffer.append(TAGSYM);
 140             buffer.append(CONDITIONSYM);
 141             buffer.append(children[0]->genCode());
 142
 143             /* Inserting the sublines */
 144             buffer.append(ENUMLISTOPENSYM);
 145             for(int i = 1; i < children.count(); i++)
 146             {
 147                 buffer.append(children[i]->genCode());
 148                 if(i != children.count() - 1)
 149                     buffer.append(ENUMLISTSEPERATESYM);
 150             }
 151             buffer.append(ENUMLISTCLOSESYM);
 152             openConditionals--;
 153             break;
 154
 155         case TAG:
 156             /* When generating code, we DO NOT insert the leading TAGSYM, leave
 157              * the calling functions to handle that
 158              */
 159             buffer.append(element->tag->name);
 160
 161             if(element->params_count > 0)
 162             {
 163                 /* Rendering parameters if there are any */
 164                 buffer.append(ARGLISTOPENSYM);
 165                 for(int i = 0; i < children.count(); i++)
 166                 {
 167                     buffer.append(children[i]->genCode());
 168                     if(i != children.count() - 1)
 169                         buffer.append(ARGLISTSEPERATESYM);
 170                 }
 171                 buffer.append(ARGLISTCLOSESYM);
 172             }
 173             break;
 174
 175         case TEXT:
 176             for(char* cursor = element->text; *cursor; cursor++)
 177             {
 178                 if(find_escape_character(*cursor))
 179                     buffer.append(TAGSYM);
 180                 buffer.append(*cursor);
 181             }
 182             break;
 183
 184         case COMMENT:
 185             buffer.append(COMMENTSYM);
 186             buffer.append(element->text);
 187             buffer.append('\n');
 188             break;
 189         }
 190     }
 191     else if(param)
 192     {
 193         switch(param->type)
 194         {
 195         case skin_tag_parameter::STRING:
 196             for(char* cursor = param->data.text; *cursor; cursor++)
 197             {
 198                 if(find_escape_character(*cursor))
 199                     buffer.append(TAGSYM);
 200                 buffer.append(*cursor);
 201             }
 202             break;
 203
 204         case skin_tag_parameter::NUMERIC:
 205             buffer.append(QString::number(param->data.numeric, 10));
 206             break;
 207
 208         case skin_tag_parameter::DEFAULT:
 209             buffer.append(DEFAULTSYM);
 210             break;
 211
 212         case skin_tag_parameter::CODE:
 213             buffer.append(QObject::tr("This doesn't belong here"));
 214             break;
 215
 216         }
 217     }
 218     else
 219     {
 220         for(int i = 0; i < children.count(); i++)
 221             buffer.append(children[i]->genCode());
 222     }
 223
 224     return buffer;
 225 }
 226
 227 /* A more or less random hashing algorithm */
 228 int ParseTreeNode::genHash() const
 229 {
 230     int hash = 0;
 231
 232     if(element)
 233     {
 234         hash += element->type;
 235         switch(element->type)
 236         {
 237         case VIEWPORT:
 238         case LINE:
 239         case SUBLINES:
 240         case CONDITIONAL:
 241             hash += element->children_count;
 242             break;
 243
 244         case TAG:
 245             for(unsigned int i = 0; i < strlen(element->tag->name); i++)
 246                 hash += element->tag->name[i];
 247             break;
 248
 249         case COMMENT:
 250         case TEXT:
 251             for(unsigned int i = 0; i < strlen(element->text); i++)
 252             {
 253                 if(i % 2)
 254                     hash += element->text[i] % element->type;
 255                 else
 256                     hash += element->text[i] % element->type * 2;
 257             }
 258             break;
 259         }
 260
 261     }
 262
 263     if(param)
 264     {
 265         hash += param->type;
 266         switch(param->type)
 267         {
 268         case skin_tag_parameter::DEFAULT:
 269         case skin_tag_parameter::CODE:
 270             break;
 271
 272         case skin_tag_parameter::NUMERIC:
 273             hash += param->data.numeric * (param->data.numeric / 4);
 274             break;
 275
 276         case skin_tag_parameter::STRING:
 277             for(unsigned int i = 0; i < strlen(param->data.text); i++)
 278             {
 279                 if(i % 2)
 280                     hash += param->data.text[i] * 2;
 281                 else
 282                     hash += param->data.text[i];
 283             }
 284             break;
 285         }
 286     }
 287
 288     for(int i = 0; i < children.count(); i++)
 289     {
 290         hash += children[i]->genHash();
 291     }
 292
 293     return hash;
 294 }
 295
 296 ParseTreeNode* ParseTreeNode::child(int row)
 297 {
 298     if(row < 0 || row >= children.count())
 299         return 0;
 300
 301     return children[row];
 302 }
 303
 304 int ParseTreeNode::numChildren() const
 305 {
 306         return children.count();
 307 }
 308
 309
 310 QVariant ParseTreeNode::data(int column) const
 311 {
 312     switch(column)
 313     {
 314     case ParseTreeModel::typeColumn:
 315         if(element)
 316         {
 317             switch(element->type)
 318             {
 319             case VIEWPORT:
 320                 return QObject::tr("Viewport");
 321
 322             case LINE:
 323                 return QObject::tr("Logical Line");
 324
 325             case SUBLINES:
 326                 return QObject::tr("Alternator");
 327
 328             case COMMENT:
 329                 return QObject::tr("Comment");
 330
 331             case CONDITIONAL:
 332                 return QObject::tr("Conditional Tag");
 333
 334             case TAG:
 335                 return QObject::tr("Tag");
 336
 337             case TEXT:
 338                 return QObject::tr("Plaintext");
 339             }
 340         }
 341         else if(param)
 342         {
 343             switch(param->type)
 344             {
 345             case skin_tag_parameter::STRING:
 346                 return QObject::tr("String");
 347
 348             case skin_tag_parameter::NUMERIC:
 349                 return QObject::tr("Number");
 350
 351             case skin_tag_parameter::DEFAULT:
 352                 return QObject::tr("Default Argument");
 353
 354             case skin_tag_parameter::CODE:
 355                 return QObject::tr("This doesn't belong here");
 356             }
 357         }
 358         else
 359         {
 360             return QObject::tr("Root");
 361         }
 362
 363         break;
 364
 365     case ParseTreeModel::valueColumn:
 366         if(element)
 367         {
 368             switch(element->type)
 369             {
 370             case VIEWPORT:
 371             case LINE:
 372             case SUBLINES:
 373             case CONDITIONAL:
 374                 return QString();
 375
 376             case TEXT:
 377             case COMMENT:
 378                 return QString(element->text);
 379
 380             case TAG:
 381                 return QString(element->tag->name);
 382             }
 383         }
 384         else if(param)
 385         {
 386             switch(param->type)
 387             {
 388             case skin_tag_parameter::DEFAULT:
 389                 return QObject::tr("-");
 390
 391             case skin_tag_parameter::STRING:
 392                 return QString(param->data.text);
 393
 394             case skin_tag_parameter::NUMERIC:
 395                 return QString::number(param->data.numeric, 10);
 396
 397             case skin_tag_parameter::CODE:
 398                 return QObject::tr("Seriously, something's wrong here");
 399             }
 400         }
 401         else
 402         {
 403             return QString();
 404         }
 405         break;
 406
 407     case ParseTreeModel::lineColumn:
 408         if(element)
 409             return QString::number(element->line, 10);
 410         else
 411             return QString();
 412         break;
 413     }
 414
 415     return QVariant();
 416 }
 417
 418
 419 int ParseTreeNode::getRow() const
 420 {
 421     if(!parent)
 422         return -1;
 423
 424     return parent->children.indexOf(const_cast<ParseTreeNode*>(this));
 425 }
 426
 427 ParseTreeNode* ParseTreeNode::getParent() const
 428 {
 429     return parent;
 430 }
 431
 432 ParseTreeNode::~ParseTreeNode()
 433 {
 434     for(int i = 0; i < children.count(); i++)
 435         delete children[i];
 436 }