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