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