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                 if(element->type == LINE || i == 0)
 111                     buffer.append('\n');
 112             }
 113             break;
 114
 115         case SUBLINES:
 116             for(int i = 0; i < children.count(); i++)
 117             {
 118                 buffer.append(children[i]->genCode());
 119                 if(i != children.count() - 1)
 120                     buffer.append(MULTILINESYM);
 121             }
 122             buffer.append('\n');
 123             break;
 124
 125         case CONDITIONAL:
 126             /* Inserts a %?, the tag renderer doesn't deal with the TAGSYM */
 127             buffer.append(TAGSYM);
 128             buffer.append(CONDITIONSYM);
 129             buffer.append(children[0]->genCode());
 130
 131             /* Inserting the sublines */
 132             buffer.append(ENUMLISTOPENSYM);
 133             for(int i = 1; i < children.count(); i++)
 134             {
 135                 buffer.append(children[i]->genCode());
 136                 if(i != children.count() - 1)
 137                     buffer.append(ENUMLISTSEPERATESYM);
 138             }
 139             buffer.append(ENUMLISTCLOSESYM);
 140             break;
 141
 142         case TAG:
 143             /* When generating code, we DO NOT insert the leading TAGSYM, leave
 144              * the calling functions to handle that
 145              */
 146             buffer.append(element->tag->name);
 147
 148             if(element->params_count > 0)
 149             {
 150                 /* Rendering parameters if there are any */
 151                 buffer.append(ARGLISTOPENSYM);
 152                 for(int i = 0; i < children.count(); i++)
 153                 {
 154                     buffer.append(children[i]->genCode());
 155                     if(i != children.count() - 1)
 156                         buffer.append(ARGLISTSEPERATESYM);
 157                 }
 158                 buffer.append(ARGLISTCLOSESYM);
 159             }
 160             break;
 161
 162         case TEXT:
 163             for(char* cursor = element->text; *cursor; cursor++)
 164             {
 165                 if(find_escape_character(*cursor))
 166                     buffer.append(TAGSYM);
 167                 buffer.append(*cursor);
 168             }
 169             break;
 170
 171         case COMMENT:
 172             buffer.append(COMMENTSYM);
 173             buffer.append(element->text);
 174             buffer.append('\n');
 175             break;
 176         }
 177     }
 178     else if(param)
 179     {
 180         switch(param->type)
 181         {
 182         case skin_tag_parameter::STRING:
 183             for(char* cursor = param->data.text; *cursor; cursor++)
 184             {
 185                 if(find_escape_character(*cursor))
 186                     buffer.append(TAGSYM);
 187                 buffer.append(*cursor);
 188             }
 189             break;
 190
 191         case skin_tag_parameter::NUMERIC:
 192             buffer.append(QString::number(param->data.numeric, 10));
 193             break;
 194
 195         case skin_tag_parameter::DEFAULT:
 196             buffer.append(DEFAULTSYM);
 197             break;
 198
 199         case skin_tag_parameter::CODE:
 200             buffer.append(QObject::tr("This doesn't belong here"));
 201             break;
 202
 203         }
 204     }
 205     else
 206     {
 207         for(int i = 0; i < children.count(); i++)
 208             buffer.append(children[i]->genCode());
 209     }
 210
 211     return buffer;
 212 }
 213
 214 ParseTreeNode* ParseTreeNode::child(int row)
 215 {
 216     if(row < 0 || row >= children.count())
 217         return 0;
 218
 219     return children[row];
 220 }
 221
 222 int ParseTreeNode::numChildren() const
 223 {
 224     return children.count();
 225 }
 226
 227
 228 QVariant ParseTreeNode::data(int column) const
 229 {
 230     switch(column)
 231     {
 232     case ParseTreeModel::typeColumn:
 233         if(element)
 234         {
 235             switch(element->type)
 236             {
 237             case VIEWPORT:
 238                 return QObject::tr("Viewport");
 239
 240             case LINE:
 241                 return QObject::tr("Logical Line");
 242
 243             case SUBLINES:
 244                 return QObject::tr("Alternator");
 245
 246             case COMMENT:
 247                 return QObject::tr("Comment");
 248
 249             case CONDITIONAL:
 250                 return QObject::tr("Conditional Tag");
 251
 252             case TAG:
 253                 return QObject::tr("Tag");
 254
 255             case TEXT:
 256                 return QObject::tr("Plaintext");
 257             }
 258         }
 259         else if(param)
 260         {
 261             switch(param->type)
 262             {
 263             case skin_tag_parameter::STRING:
 264                 return QObject::tr("String");
 265
 266             case skin_tag_parameter::NUMERIC:
 267                 return QObject::tr("Number");
 268
 269             case skin_tag_parameter::DEFAULT:
 270                 return QObject::tr("Default Argument");
 271
 272             case skin_tag_parameter::CODE:
 273                 return QObject::tr("This doesn't belong here");
 274             }
 275         }
 276         else
 277         {
 278             return QObject::tr("Root");
 279         }
 280
 281         break;
 282
 283     case ParseTreeModel::valueColumn:
 284         if(element)
 285         {
 286             switch(element->type)
 287             {
 288             case VIEWPORT:
 289             case LINE:
 290             case SUBLINES:
 291             case CONDITIONAL:
 292                 return QString();
 293
 294             case TEXT:
 295             case COMMENT:
 296                 return QString(element->text);
 297
 298             case TAG:
 299                 return QString(element->tag->name);
 300             }
 301         }
 302         else if(param)
 303         {
 304             switch(param->type)
 305             {
 306             case skin_tag_parameter::DEFAULT:
 307                 return QObject::tr("-");
 308
 309             case skin_tag_parameter::STRING:
 310                 return QString(param->data.text);
 311
 312             case skin_tag_parameter::NUMERIC:
 313                 return QString::number(param->data.numeric, 10);
 314
 315             case skin_tag_parameter::CODE:
 316                 return QObject::tr("Seriously, something's wrong here");
 317             }
 318         }
 319         else
 320         {
 321             return QString();
 322         }
 323         break;
 324
 325     case ParseTreeModel::lineColumn:
 326         if(element)
 327             return QString::number(element->line, 10);
 328         else
 329             return QString();
 330         break;
 331     }
 332
 333     return QVariant();
 334 }
 335
 336
 337 int ParseTreeNode::getRow() const
 338 {
 339     if(!parent)
 340         return -1;
 341
 342     return parent->children.indexOf(const_cast<ParseTreeNode*>(this));
 343 }
 344
 345 ParseTreeNode* ParseTreeNode::getParent() const
 346 {
 347     return parent;
 348 }
 349
 350 ParseTreeNode::~ParseTreeNode()
 351 {
 352     for(int i = 0; i < children.count(); i++)
 353         delete children[i];
 354 }