utils/themeeditor/parsetreemodel.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
  23 #include "parsetreemodel.h"
  24 #include "symbols.h"
  25
  26 #include <cstdlib>
  27
  28 #include <QObject>
  29
  30 ParseTreeModel::ParseTreeModel(const char* document, QObject* parent):
  31         QAbstractItemModel(parent)
  32 {
  33     this->tree = skin_parse(document);
  34
  35     if(tree)
  36         this->root = new ParseTreeNode(tree);
  37     else
  38         this->root = 0;
  39 }
  40
  41
  42 ParseTreeModel::~ParseTreeModel()
  43 {
  44     if(root)
  45         delete root;
  46     if(tree)
  47         skin_free_tree(tree);
  48 }
  49
  50 QString ParseTreeModel::genCode()
  51 {
  52     if(root)
  53         return root->genCode();
  54     else
  55         return "";
  56 }
  57
  58 QString ParseTreeModel::changeTree(const char *document)
  59 {
  60     struct skin_element* test = skin_parse(document);
  61
  62     if(!test)
  63     {
  64         QString error = tr("Error on line ") +
  65                         QString::number(skin_error_line())
  66                         + tr(": ") + QString(skin_error_message());
  67         return error;
  68     }
  69
  70     ParseTreeNode* temp = new ParseTreeNode(test);
  71     if(root && temp->genHash() == root->genHash())
  72     {
  73         delete temp;
  74         return tr("Document Parses Successfully");
  75     }
  76
  77     if(root)
  78     {
  79         emit beginRemoveRows(QModelIndex(), 0, root->numChildren() - 1);
  80         delete root;
  81         emit endRemoveRows();
  82     }
  83
  84     root = temp;
  85
  86     emit beginInsertRows(QModelIndex(), 0, temp->numChildren() - 1);
  87     emit endInsertRows();
  88
  89     return tr("Document Parses Successfully");
  90
  91 }
  92
  93 QModelIndex ParseTreeModel::index(int row, int column,
  94                                   const QModelIndex& parent) const
  95 {
  96     if(!hasIndex(row, column, parent))
  97         return QModelIndex();
  98
  99     ParseTreeNode* foundParent;
 100
 101     if(parent.isValid())
 102         foundParent = static_cast<ParseTreeNode*>(parent.internalPointer());
 103     else
 104         foundParent = root;
 105
 106     if(row < foundParent->numChildren() && row >= 0)
 107         return createIndex(row, column, foundParent->child(row));
 108     else
 109         return QModelIndex();
 110 }
 111
 112 QModelIndex ParseTreeModel::parent(const QModelIndex &child) const
 113 {
 114     if(!child.isValid())
 115         return QModelIndex();
 116
 117     ParseTreeNode* foundParent = static_cast<ParseTreeNode*>
 118                                  (child.internalPointer())->getParent();
 119
 120     if(foundParent == root)
 121         return QModelIndex();
 122
 123     return createIndex(foundParent->getRow(), 0, foundParent);
 124 }
 125
 126 int ParseTreeModel::rowCount(const QModelIndex &parent) const
 127 {
 128     if(!root)
 129         return 0;
 130
 131     if(!parent.isValid())
 132         return root->numChildren();
 133
 134     if(parent.column() != typeColumn)
 135         return 0;
 136
 137     return static_cast<ParseTreeNode*>(parent.internalPointer())->numChildren();
 138 }
 139
 140 int ParseTreeModel::columnCount(const QModelIndex &parent) const
 141 {
 142     if(parent.isValid())
 143         return numColumns;
 144     else
 145         return numColumns;
 146 }
 147
 148 QVariant ParseTreeModel::data(const QModelIndex &index, int role) const
 149 {
 150     if(!index.isValid())
 151         return QVariant();
 152
 153     if(role != Qt::DisplayRole)
 154         return QVariant();
 155
 156     return static_cast<ParseTreeNode*>(index.internalPointer())->
 157             data(index.column());
 158 }
 159
 160 QVariant ParseTreeModel::headerData(int col, Qt::Orientation orientation,
 161                                     int role) const
 162 {
 163     if(orientation != Qt::Horizontal)
 164         return QVariant();
 165
 166     if(col >= numColumns)
 167         return QVariant();
 168
 169     if(role != Qt::DisplayRole)
 170         return QVariant();
 171
 172     switch(col)
 173     {
 174     case typeColumn:
 175         return QObject::tr("Type");
 176
 177     case lineColumn:
 178         return QObject::tr("Line");
 179
 180     case valueColumn:
 181         return QObject::tr("Value");
 182     }
 183
 184     return QVariant();
 185 }
 186
 187 Qt::ItemFlags ParseTreeModel::flags(const QModelIndex &index) const
 188 {
 189     Qt::ItemFlags retval = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 190
 191     ParseTreeNode* element = static_cast<ParseTreeNode*>
 192                              (index.internalPointer());
 193
 194     if((element->isParam()
 195         || element->getElement()->type == TEXT
 196         || element->getElement()->type == COMMENT)
 197         && index.column() == valueColumn)
 198     {
 199         retval |= Qt::ItemIsEditable;
 200     }
 201
 202     return retval;
 203 }
 204
 205 bool ParseTreeModel::setData(const QModelIndex &index, const QVariant &value,
 206                              int role)
 207 {
 208     if(role != Qt::EditRole)
 209         return false;
 210
 211     if(index.column() != valueColumn)
 212         return false;
 213
 214     ParseTreeNode* node = static_cast<ParseTreeNode*>
 215                              (index.internalPointer());
 216
 217     if(node->isParam())
 218     {
 219         struct skin_tag_parameter* param = node->getParam();
 220
 221         /* Now that we've established that we do, in fact, have a parameter,
 222          * set it to its new value if an acceptable one has been entered
 223          */
 224         if(value.toString().trimmed() == QString(QChar(DEFAULTSYM)))
 225         {
 226             if(islower(param->type_code))
 227                 param->type = skin_tag_parameter::DEFAULT;
 228             else
 229                 return false;
 230         }
 231         else if(tolower(param->type_code) == 's'
 232                 || tolower(param->type_code) == 'f')
 233         {
 234             if(param->type == skin_tag_parameter::STRING)
 235                 free(param->data.text);
 236
 237             param->type = skin_tag_parameter::STRING;
 238             param->data.text = strdup(value.toString().trimmed().toAscii());
 239         }
 240         else if(tolower(param->type_code) == 'i')
 241         {
 242             if(!value.canConvert(QVariant::Int))
 243                 return false;
 244
 245             param->type = skin_tag_parameter::NUMERIC;
 246             param->data.numeric = value.toInt();
 247         }
 248         else
 249         {
 250             return false;
 251         }
 252     }
 253     else
 254     {
 255         struct skin_element* element = node->getElement();
 256
 257         if(element->type != COMMENT && element->type != TEXT)
 258             return false;
 259
 260         free(element->text);
 261         element->text = strdup(value.toString().trimmed().toAscii());
 262     }
 263
 264     emit dataChanged(index, index);
 265     return true;
 266 }