utils/themeeditor/models/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 #include "rbscreen.h"
  26 #include "rbrenderinfo.h"
  27
  28 #include <cstdlib>
  29
  30 #include <QObject>
  31 #include <QPixmap>
  32 #include <QMap>
  33 #include <QDir>
  34
  35 #include <iostream>
  36
  37 ParseTreeModel::ParseTreeModel(const char* document, QObject* parent):
  38         QAbstractItemModel(parent)
  39 {
  40     this->tree = skin_parse(document);
  41
  42     if(tree)
  43         this->root = new ParseTreeNode(tree);
  44     else
  45         this->root = 0;
  46
  47     scene = new QGraphicsScene();
  48 }
  49
  50
  51 ParseTreeModel::~ParseTreeModel()
  52 {
  53     if(root)
  54         delete root;
  55     if(tree)
  56         skin_free_tree(tree);
  57 }
  58
  59 QString ParseTreeModel::genCode()
  60 {
  61     if(root)
  62         return root->genCode();
  63     else
  64         return "";
  65 }
  66
  67 QString ParseTreeModel::changeTree(const char *document)
  68 {
  69     struct skin_element* test = skin_parse(document);
  70
  71     if(!test)
  72     {
  73         QString error = tr("Error on line ") +
  74                         QString::number(skin_error_line())
  75                         + tr(": ") + QString(skin_error_message());
  76         return error;
  77     }
  78
  79     ParseTreeNode* temp = new ParseTreeNode(test);
  80
  81     if(root)
  82     {
  83         emit beginRemoveRows(QModelIndex(), 0, root->numChildren() - 1);
  84         delete root;
  85         emit endRemoveRows();
  86     }
  87
  88     root = temp;
  89
  90     emit beginInsertRows(QModelIndex(), 0, temp->numChildren() - 1);
  91     emit endInsertRows();
  92
  93     return tr("Document Parses Successfully");
  94
  95 }
  96
  97 QModelIndex ParseTreeModel::index(int row, int column,
  98                                   const QModelIndex& parent) const
  99 {
 100     if(!hasIndex(row, column, parent))
 101         return QModelIndex();
 102
 103     ParseTreeNode* foundParent;
 104
 105     if(parent.isValid())
 106         foundParent = static_cast<ParseTreeNode*>(parent.internalPointer());
 107     else
 108         foundParent = root;
 109
 110     if(row < foundParent->numChildren() && row >= 0)
 111         return createIndex(row, column, foundParent->child(row));
 112     else
 113         return QModelIndex();
 114 }
 115
 116 QModelIndex ParseTreeModel::parent(const QModelIndex &child) const
 117 {
 118     if(!child.isValid())
 119         return QModelIndex();
 120
 121     ParseTreeNode* foundParent = static_cast<ParseTreeNode*>
 122                                  (child.internalPointer())->getParent();
 123
 124     if(foundParent == root)
 125         return QModelIndex();
 126
 127     return createIndex(foundParent->getRow(), 0, foundParent);
 128 }
 129
 130 int ParseTreeModel::rowCount(const QModelIndex &parent) const
 131 {
 132     if(!root)
 133         return 0;
 134
 135     if(!parent.isValid())
 136         return root->numChildren();
 137
 138     if(parent.column() != typeColumn)
 139         return 0;
 140
 141     return static_cast<ParseTreeNode*>(parent.internalPointer())->numChildren();
 142 }
 143
 144 int ParseTreeModel::columnCount(const QModelIndex &parent) const
 145 {
 146     if(parent.isValid())
 147         return numColumns;
 148     else
 149         return numColumns;
 150 }
 151
 152 QVariant ParseTreeModel::data(const QModelIndex &index, int role) const
 153 {
 154     if(!index.isValid())
 155         return QVariant();
 156
 157     if(role != Qt::DisplayRole)
 158         return QVariant();
 159
 160     return static_cast<ParseTreeNode*>(index.internalPointer())->
 161             data(index.column());
 162 }
 163
 164 QVariant ParseTreeModel::headerData(int col, Qt::Orientation orientation,
 165                                     int role) const
 166 {
 167     if(orientation != Qt::Horizontal)
 168         return QVariant();
 169
 170     if(col >= numColumns)
 171         return QVariant();
 172
 173     if(role != Qt::DisplayRole)
 174         return QVariant();
 175
 176     switch(col)
 177     {
 178     case typeColumn:
 179         return QObject::tr("Type");
 180
 181     case lineColumn:
 182         return QObject::tr("Line");
 183
 184     case valueColumn:
 185         return QObject::tr("Value");
 186     }
 187
 188     return QVariant();
 189 }
 190
 191 Qt::ItemFlags ParseTreeModel::flags(const QModelIndex &index) const
 192 {
 193     Qt::ItemFlags retval = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 194
 195     ParseTreeNode* element = static_cast<ParseTreeNode*>
 196                              (index.internalPointer());
 197
 198     if((element->isParam()
 199         || element->getElement()->type == TEXT
 200         || element->getElement()->type == COMMENT)
 201         && index.column() == valueColumn)
 202     {
 203         retval |= Qt::ItemIsEditable;
 204     }
 205
 206     return retval;
 207 }
 208
 209 bool ParseTreeModel::setData(const QModelIndex &index, const QVariant &value,
 210                              int role)
 211 {
 212     if(role != Qt::EditRole)
 213         return false;
 214
 215     if(index.column() != valueColumn)
 216         return false;
 217
 218     ParseTreeNode* node = static_cast<ParseTreeNode*>
 219                              (index.internalPointer());
 220
 221     if(node->isParam())
 222     {
 223         struct skin_tag_parameter* param = node->getParam();
 224
 225         /* Now that we've established that we do, in fact, have a parameter,
 226          * set it to its new value if an acceptable one has been entered
 227          */
 228         if(value.toString().trimmed() == QString(QChar(DEFAULTSYM)))
 229         {
 230             if(islower(param->type_code))
 231                 param->type = skin_tag_parameter::DEFAULT;
 232             else
 233                 return false;
 234         }
 235         else if(tolower(param->type_code) == 's'
 236                 || tolower(param->type_code) == 'f')
 237         {
 238             if(param->type == skin_tag_parameter::STRING)
 239                 free(param->data.text);
 240
 241             param->type = skin_tag_parameter::STRING;
 242             param->data.text = strdup(value.toString().trimmed().toAscii());
 243         }
 244         else if(tolower(param->type_code) == 'i')
 245         {
 246             if(!value.canConvert(QVariant::Int))
 247                 return false;
 248
 249             param->type = skin_tag_parameter::INTEGER;
 250             param->data.number = value.toInt();
 251         }
 252         else
 253         {
 254             return false;
 255         }
 256     }
 257     else
 258     {
 259         struct skin_element* element = node->getElement();
 260
 261         if(element->type != COMMENT && element->type != TEXT)
 262             return false;
 263
 264         free(element->data);
 265         element->data = strdup(value.toString().trimmed().toAscii());
 266     }
 267
 268     emit dataChanged(index, index);
 269     return true;
 270 }
 271
 272 QGraphicsScene* ParseTreeModel::render(ProjectModel* project,
 273                                        DeviceState* device, const QString* file)
 274 {
 275     scene->clear();
 276
 277     /* Setting the background */
 278     scene->setBackgroundBrush(QBrush(QPixmap(":/render/scenebg.png")));
 279
 280     /* Preparing settings */
 281     QMap<QString, QString> settings;
 282     if(project)
 283         settings = project->getSettings();
 284
 285     /* Setting themebase if it can't be derived from the project */
 286     if(settings.value("themebase", "") == "" && file && QFile::exists(*file))
 287     {
 288         QDir base(*file);
 289         base.cdUp();
 290         settings.insert("themebase", base.canonicalPath());
 291     }
 292
 293     /* Finding imagebase and determining remote/wps status */
 294     bool remote = false;
 295     bool wps = false;
 296     if(file)
 297     {
 298         QString skinFile = *file;
 299         QStringList decomp = skinFile.split("/");
 300         skinFile = decomp[decomp.count() - 1];
 301         skinFile.chop(skinFile.length() - skinFile.lastIndexOf("."));
 302         settings.insert("imagepath", settings.value("themebase","") + "/wps/" +
 303                         skinFile);
 304
 305         decomp = file->split(".");
 306         QString extension = decomp.last();
 307         if(extension[0] == 'r')
 308             remote = true;
 309         if(extension.right(3) == "wps")
 310             wps = true;
 311     }
 312
 313     /* Rendering SBS, if necessary */
 314     RBScreen* sbsScreen = 0;
 315     if(wps && device->data("rendersbs").toBool())
 316     {
 317         QString sbsFile = settings.value(remote ? "rsbs" : "sbs", "");
 318         sbsFile.replace("/.rockbox" , settings.value("themebase",""));
 319
 320         if(QFile::exists(sbsFile))
 321         {
 322             QFile sbs(sbsFile);
 323             sbs.open(QFile::ReadOnly | QFile::Text);
 324             ParseTreeModel sbsModel(QString(sbs.readAll()).toAscii());
 325
 326             if(sbsModel.root != 0)
 327             {
 328                 RBRenderInfo sbsInfo(&sbsModel, project, &settings, device,
 329                                      sbsScreen);
 330
 331                 sbsScreen = new RBScreen(sbsInfo, remote);
 332                 scene->addItem(sbsScreen);
 333
 334                 sbsInfo = RBRenderInfo(&sbsModel, project, &settings, device,
 335                                        sbsScreen);
 336                 sbsModel.root->render(sbsInfo);
 337             }
 338
 339         }
 340     }
 341
 342     RBScreen* screen = 0;
 343     RBRenderInfo info(this, project, &settings, device, screen, sbsScreen);
 344
 345     /* Adding the screen */
 346     if(sbsScreen)
 347         screen = new RBScreen(info, remote, sbsScreen->getCustomUI());
 348     else
 349         screen = new RBScreen(info, remote);
 350
 351     if(!sbsScreen)
 352         scene->addItem(screen);
 353
 354     info = RBRenderInfo(this, project, &settings, device, screen, sbsScreen);
 355
 356
 357     /* Rendering the tree */
 358     if(root)
 359         root->render(info);
 360
 361     return scene;
 362 }