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