studio/src/plugins/gui_editor/expression_loader.cpp

   1 // Ryzom Core Studio - GUI Editor Plugin
   2 //
   3 // Copyright (C) 2010-2014  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   4 //
   5 // This program is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU Affero General Public License as
   7 // published by the Free Software Foundation, either version 3 of the
   8 // License, or (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU Affero General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU Affero General Public License
  16 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 #include "expression_loader.h"
  19 #include "expression_info.h"
  20
  21 #include <QFile>
  22 #include <QXmlStreamReader>
  23
  24 class ExpressionLoaderPvt
  25 {
  26 public:
  27
  28         bool parseName()
  29         {
  30                 QString text = reader.readElementText( QXmlStreamReader::ErrorOnUnexpectedElement );
  31                 if( reader.hasError() )
  32                         return false;
  33
  34                 m_info->name = text;
  35
  36                 return true;
  37         }
  38
  39         bool parseValue()
  40         {
  41                 QString text = reader.readElementText( QXmlStreamReader::ErrorOnUnexpectedElement );
  42                 if( reader.hasError() )
  43                         return false;
  44
  45                 if( text.toLower() == "true" )
  46                         m_info->value = true;
  47                 else
  48                         m_info->value = false;
  49
  50                 return true;
  51         }
  52
  53         bool parseCategory()
  54         {
  55                 QString text = reader.readElementText( QXmlStreamReader::ErrorOnUnexpectedElement );
  56                 if( reader.hasError() )
  57                         return false;
  58
  59                 m_info->category = text;
  60
  61                 return true;
  62         }
  63
  64         bool parseVariable()
  65         {
  66                 QString text = reader.readElementText( QXmlStreamReader::ErrorOnUnexpectedElement );
  67                 if( reader.hasError() )
  68                         return false;
  69
  70                 if( text.toLower() == "true" )
  71                         m_info->variable = true;
  72                 else
  73                         m_info->variable = false;
  74
  75                 return true;
  76         }
  77
  78         bool parseSlot()
  79         {
  80                 QString text = reader.readElementText( QXmlStreamReader::ErrorOnUnexpectedElement );
  81                 if( reader.hasError() )
  82                         return false;
  83
  84                 m_info->slotNames.push_back( text );
  85
  86                 return true;
  87         }
  88
  89         bool parseSlots()
  90         {
  91                 bool error = false;
  92
  93                 while( !reader.atEnd() )
  94                 {
  95                         reader.readNext();
  96
  97                         if( reader.isStartElement() )
  98                         {
  99                                 QString name = reader.name().toString();
 100                                 if( name == "slot" )
 101                                         error = !parseSlot();
 102                         }
 103                         else
 104                         if( reader.isEndElement() )
 105                         {
 106                                 if( reader.name() == "slots" )
 107                                         break;
 108                         }
 109                 }
 110
 111                 if( reader.atEnd() )
 112                         return false;
 113
 114                 return true;
 115         }
 116
 117         bool load( QFile *f )
 118         {
 119                 reader.clear();
 120                 reader.setDevice( f );
 121
 122                 bool error = false;
 123
 124                 // start of document
 125                 reader.readNext();
 126                 if( reader.atEnd() )
 127                         return false;
 128
 129                 // root node
 130                 reader.readNext();
 131                 if( reader.atEnd() )
 132                         return false;
 133
 134                 if( reader.isStartElement() )
 135                 {
 136                         // Not an expression file?
 137                         if( reader.name() != "expression" )
 138                                 return false;
 139                 }
 140
 141                 while( !reader.atEnd() )
 142                 {
 143                         reader.readNext();
 144
 145                         if( reader.isStartElement() )
 146                         {
 147                                 QString name = reader.name().toString();
 148
 149                                 if( name == "name" )
 150                                         error = !parseName();
 151                                 else
 152                                 if( name == "value" )
 153                                         error = !parseValue();
 154                                 else
 155                                 if( name == "category" )
 156                                         error = !parseCategory();
 157                                 else
 158                                 if( name == "variable" )
 159                                         error = !parseVariable();
 160                                 else
 161                                 if( name == "slots" )
 162                                         error = !parseSlots();
 163                         }
 164
 165                         if( error )
 166                                 break;
 167                 }
 168
 169                 if( error || reader.hasError() )
 170                 {
 171                         return false;
 172                 }
 173
 174                 return true;
 175         }
 176
 177         void setInfo( ExpressionInfo *info ){ m_info = info; }
 178
 179 private:
 180         QXmlStreamReader reader;
 181         ExpressionInfo *m_info;
 182 };
 183
 184 ExpressionLoader::ExpressionLoader()
 185 {
 186         m_pvt = new ExpressionLoaderPvt;
 187 }
 188
 189 ExpressionLoader::~ExpressionLoader()
 190 {
 191         delete m_pvt;
 192         m_pvt = NULL;
 193 }
 194
 195 ExpressionInfo* ExpressionLoader::load( const QString &filename )
 196 {
 197         ExpressionInfo *info = NULL;
 198         bool ok = false;
 199
 200         QFile f( filename );
 201         if( !f.open( QIODevice::ReadOnly | QIODevice::Text ) )
 202                 return NULL;
 203
 204         info = new ExpressionInfo();
 205         m_pvt->setInfo( info );
 206         ok = m_pvt->load( &f );
 207
 208         f.close();
 209
 210         if( !ok )
 211         {
 212                 delete info;
 213                 info = NULL;
 214         }
 215
 216         return info;
 217 }
 218
 219