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 extern "C"
  23 {
  24 #include "symbols.h"
  25 }
  26
  27 #include "parsetreenode.h"
  28
  29 /* Root element constructor */
  30 ParseTreeNode::ParseTreeNode(struct skin_element* data)
  31     : parent(0), element(0), param(0), children()
  32 {
  33     while(data)
  34     {
  35         children.append(new ParseTreeNode(data, this));
  36         data = data->next;
  37     }
  38 }
  39
  40 /* Normal element constructor */
  41 ParseTreeNode::ParseTreeNode(struct skin_element* data, ParseTreeNode* parent)
  42     : parent(parent), element(data), param(0), children()
  43 {
  44     switch(element->type)
  45     {
  46
  47     case TAG:
  48         for(int i = 0; i < element->params_count; i++)
  49         {
  50             if(element->params[i].type == skin_tag_parameter::CODE)
  51                 children.append(new ParseTreeNode(element->params[i].data.code,
  52                                               this));
  53             else
  54                 children.append(new ParseTreeNode(&element->params[i], this));
  55         }
  56         break;
  57
  58         /* CONDITIONAL and SUBLINES fall through to the same code */
  59     case CONDITIONAL:
  60     case SUBLINES:
  61         for(int i = 0; i < element->children_count; i++)
  62         {
  63             children.append(new ParseTreeNode(data->children[i], this));
  64         }
  65         break;
  66
  67     case LINE:
  68         for(struct skin_element* current = data->children[0]; current;
  69             current = current->next)
  70         {
  71             children.append(new ParseTreeNode(current, this));
  72         }
  73         break;
  74
  75     default:
  76         break;
  77     }
  78 }
  79
  80 /* Parameter constructor */
  81 ParseTreeNode::ParseTreeNode(skin_tag_parameter *data, ParseTreeNode *parent)
  82     : parent(parent), element(0), param(data), children()
  83 {
  84
  85 }
  86
  87 QString ParseTreeNode::genCode() const
  88 {
  89     QString buffer = "";
  90
  91     if(element)
  92     {
  93         switch(element->type)
  94         {
  95         case LINE:
  96             for(int i = 0; i < children.count(); i++)
  97             {
  98                 /*
  99                Adding a % in case of tag, because the tag rendering code
 100                doesn't insert its own
 101             */
 102                 if(children[i]->element->type == TAG)
 103                     buffer.append(TAGSYM);
 104                 buffer.append(children[i]->genCode());
 105             }
 106             break;
 107
 108         case SUBLINES:
 109             for(int i = 0; i < children.count(); i++)
 110             {
 111                 buffer.append(children[i]->genCode());
 112                 if(i != children.count() - 1)
 113                     buffer.append(MULTILINESYM);
 114             }
 115             break;
 116
 117         case CONDITIONAL:
 118             /* Inserts a %?, the tag renderer doesn't deal with the TAGSYM */
 119             buffer.append(TAGSYM);
 120             buffer.append(CONDITIONSYM);
 121             buffer.append(children[0]->genCode());
 122
 123             /* Inserting the sublines */
 124             buffer.append(ENUMLISTOPENSYM);
 125             for(int i = 1; i < children.count(); i++)
 126             {
 127                 buffer.append(children[i]->genCode());
 128                 if(i != children.count() - 1)
 129                     buffer.append(ENUMLISTSEPERATESYM);
 130             }
 131             buffer.append(ENUMLISTCLOSESYM);
 132             break;
 133
 134         case TAG:
 135             /* When generating code, we DO NOT insert the leading TAGSYM, leave
 136              * the calling functions to handle that
 137              */
 138             buffer.append(element->name);
 139
 140             if(element->params_count > 0)
 141             {
 142                 /* Rendering parameters if there are any */
 143                 buffer.append(ARGLISTOPENSYM);
 144                 for(int i = 0; i < children.count(); i++)
 145                 {
 146                     buffer.append(children[i]->genCode());
 147                     if(i != children.count() - 1)
 148                         buffer.append(ARGLISTSEPERATESYM);
 149                 }
 150                 buffer.append(ARGLISTCLOSESYM);
 151             }
 152             break;
 153
 154         case NEWLINE:
 155             buffer.append('\n');
 156             break;
 157
 158         case TEXT:
 159             buffer.append(element->text);
 160             break;
 161
 162         case COMMENT:
 163             buffer.append(COMMENTSYM);
 164             buffer.append(element->text);
 165             break;
 166         }
 167     }
 168     else if(param)
 169     {
 170         switch(param->type)
 171         {
 172         case skin_tag_parameter::STRING:
 173             buffer.append(param->data.text);
 174             break;
 175
 176         case skin_tag_parameter::NUMERIC:
 177             buffer.append(QString::number(param->data.numeric, 10));
 178             break;
 179
 180         case skin_tag_parameter::DEFAULT:
 181             buffer.append(DEFAULTSYM);
 182             break;
 183
 184         case skin_tag_parameter::CODE:
 185             buffer.append(QObject::tr("This doesn't belong here"));
 186             break;
 187
 188         }
 189     }
 190     else
 191     {
 192         for(int i = 0; i < children.count(); i++)
 193             buffer.append(children[i]->genCode());
 194     }
 195
 196     return buffer;
 197 }
 198
 199 ParseTreeNode* ParseTreeNode::child(int row)
 200 {
 201     if(row < 0 || row >= children.count())
 202         return 0;
 203
 204     return children[row];
 205 }
 206
 207 int ParseTreeNode::numChildren() const
 208 {
 209     return children.count();
 210 }
 211
 212
 213 QVariant ParseTreeNode::data(int column) const
 214 {
 215     switch(column)
 216     {
 217         /* Column 0 is the element type */
 218     case 0:
 219         if(element)
 220         {
 221             switch(element->type)
 222             {
 223             case LINE:
 224                 return QObject::tr("Logical Line");
 225
 226             case SUBLINES:
 227                 return QObject::tr("Alternator");
 228
 229             case COMMENT:
 230                 return QObject::tr("Comment");
 231
 232             case CONDITIONAL:
 233                 return QObject::tr("Conditional Tag");
 234
 235             case TAG:
 236                 return QObject::tr("Tag");
 237
 238             case NEWLINE:
 239                 return QObject::tr("Newline");
 240
 241             case TEXT:
 242                 return QObject::tr("Plaintext");
 243             }
 244         }
 245         else if(param)
 246         {
 247             switch(param->type)
 248             {
 249             case skin_tag_parameter::STRING:
 250                 return QObject::tr("String");
 251
 252             case skin_tag_parameter::NUMERIC:
 253                 return QObject::tr("Number");
 254
 255             case skin_tag_parameter::DEFAULT:
 256                 return QObject::tr("Default Argument");
 257
 258             case skin_tag_parameter::CODE:
 259                 return QObject::tr("This doesn't belong here");
 260             }
 261         }
 262         else
 263         {
 264             return QObject::tr("Root");
 265         }
 266
 267         break;
 268
 269         /* Column 1 is the value */
 270     case 1:
 271         if(element)
 272         {
 273             switch(element->type)
 274             {
 275             case LINE:
 276                 return QString();
 277
 278             case SUBLINES:
 279                 return QString();
 280
 281             case NEWLINE:
 282                 return QObject::tr("\\n");
 283
 284             case TEXT:
 285             case COMMENT:
 286                 return QString(element->text);
 287
 288             case CONDITIONAL:
 289             case TAG:
 290                 return QString(element->name);
 291             }
 292         }
 293         else if(param)
 294         {
 295             switch(param->type)
 296             {
 297             case skin_tag_parameter::DEFAULT:
 298                 return QObject::tr("-");
 299
 300             case skin_tag_parameter::STRING:
 301                 return QString(param->data.text);
 302
 303             case skin_tag_parameter::NUMERIC:
 304                 return QString::number(param->data.numeric, 10);
 305
 306             case skin_tag_parameter::CODE:
 307                 return QObject::tr("Seriously, something's wrong here");
 308             }
 309         }
 310         else
 311         {
 312             return QString();
 313         }
 314         break;
 315
 316         /* Column 2 is the line number */
 317     case 2:
 318         if(element)
 319             return QString::number(element->line, 10);
 320         else
 321             return QString();
 322         break;
 323     }
 324
 325     return QVariant();
 326 }
 327
 328
 329 int ParseTreeNode::getRow() const
 330 {
 331     if(!parent)
 332         return -1;
 333
 334     return parent->children.indexOf(const_cast<ParseTreeNode*>(this));
 335 }
 336
 337 ParseTreeNode* ParseTreeNode::getParent() const
 338 {
 339     return parent;
 340 }
 341
 342 ParseTreeNode::~ParseTreeNode()
 343 {
 344     for(int i = 0; i < children.count(); i++)
 345         delete children[i];
 346 }