yamf/model/scene.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by David Cuadrado                                  *
   3  *   krawek@gmail.com                                              *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (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 General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "scene.h"
  22 #include <dcore/debug.h>
  23
  24 #include <QDir>
  25 #include <QGraphicsItem>
  26 #include <QSet>
  27
  28 #include "object.h"
  29 #include "layer.h"
  30
  31 #include "audiolayer.h"
  32
  33 #include "item/group.h"
  34 #include "item/builder.h"
  35
  36 #include "model/command/manager.h"
  37 #include "model/command/insertlayer.h"
  38 #include "model/command/removelayer.h"
  39 #include "model/command/movelayer.h"
  40
  41 #include "model/command/renamescene.h"
  42
  43 #include "yamf/model/audiolayer.h"
  44
  45 namespace YAMF {
  46 namespace Model {
  47
  48 struct Scene::Private
  49 {
  50         Layers layers;
  51
  52         AudioLayers audioLayers;
  53
  54         QString name;
  55         bool isLocked;
  56         int layerCount;
  57         bool isVisible;
  58
  59         QSet<Object *> tweeningObjects;
  60         QSet<Object *> alwaysVisible;
  61 };
  62
  63
  64 /**
  65  * Constructor por defecto
  66  */
  67 Scene::Scene(Project *parent, const QString &name) : QObject(parent), d(new Private)
  68 {
  69         d->name = name;
  70         d->isLocked = false;
  71         d->layerCount = 0;
  72         d->isVisible = true;
  73 }
  74
  75 /**
  76  * Destructor
  77  */
  78 Scene::~Scene()
  79 {
  80         D_END;
  81
  82         d->layers.clear(true);
  83
  84         delete d;
  85 }
  86
  87 /**
  88  * Pone un nombre a la escena
  89  */
  90 void Scene::setSceneName(const QString &name)
  91 {
  92         if(name != d->name)
  93         {
  94                 Command::RenameScene *cmd = new Command::RenameScene(this, name, &d->name);
  95                 project()->commandManager()->addCommand(cmd);
  96         }
  97 }
  98
  99 /**
 100  * retorna el nombre de la escena
 101  */
 102 QString Scene::sceneName() const
 103 {
 104         return d->name;
 105 }
 106
 107 /**
 108  * Bloquea la escena
 109  */
 110 void Scene::setLocked(bool isLocked)
 111 {
 112         d->isLocked = isLocked;
 113 }
 114
 115 /**
 116  * Returna verdadero cuando la escena esta bloqueada
 117  */
 118 bool Scene::isLocked() const
 119 {
 120         return d->isLocked;
 121 }
 122
 123 /**
 124  * @~spanish
 125  * Cambia la visibilidad de la escena.
 126  * Si @p isVisible es verdadero permite la visualización del marco de lo contrario lo oculta.
 127  */
 128 void Scene::setVisible(bool isVisible)
 129 {
 130         d->isVisible = isVisible;
 131 }
 132
 133 /**
 134  * @~spanish
 135  * Retorna verdadero si la escena es visible, de lo contrario retorna falso.
 136  */
 137 bool Scene::isVisible() const
 138 {
 139         return d->isVisible;
 140 }
 141
 142 /**
 143  * Retorna la lista de layers
 144  */
 145 Layers Scene::layers() const
 146 {
 147         return d->layers;
 148 }
 149
 150 /**
 151  * @~spanish
 152  * Retorna los layers de audio que tiene la escena.
 153  */
 154 AudioLayers Scene::audioLayers() const
 155 {
 156         return d->audioLayers;
 157 }
 158
 159 /**
 160  * @~spanish
 161  * Crea una capa y la inserta, en la posición @p visualIndex y con el nombre name;
 162  * por defecto añadirá la capa al final de la escena.
 163  */
 164 AudioLayer *Scene::createAudioLayer(int position, const QString &name)
 165 {
 166         D_FUNCINFO << position;
 167
 168         AudioLayer *layer = new AudioLayer(this, name);
 169
 170         insertLayer(position, layer);
 171         layer->setLayerName(tr("Sound layer %1").arg(d->layerCount+1));
 172
 173         return layer;
 174 }
 175
 176 /**
 177  * @~spanish
 178  * Remueve la capa que esta en la posición @p visualIndex.
 179  * FIXME
 180  */
 181 bool Scene::removeLayer( int visualIndex)
 182 {
 183         Layer *layer = this->layer(visualIndex);
 184         if ( layer )
 185         {
 186                 d->layers.removeAll(visualIndex);
 187                 delete layer;
 188                 return true;
 189         }
 190
 191         return false;
 192 }
 193
 194
 195 /**
 196  * Retorna el layer que se encuentra en la posición indicada
 197  * @param position
 198  * @return
 199  */
 200 Layer *Scene::layer(int visualIndex) const
 201 {
 202         if ( !d->layers.containsVisual(visualIndex) )
 203         {
 204                 D_FUNCINFO << " FATAL ERROR: index out of bound " << visualIndex;
 205                 return 0;
 206         }
 207
 208         return d->layers.visualValue(visualIndex);
 209 }
 210
 211 /**
 212  * @~spanish
 213  * Crea una capa de audio y la inserta, en la posición @p visualIndex y con el nombre name;
 214  * por defecto añadirá la capa de audio al final de la escena.
 215  */
 216 Model::Layer *Scene::createLayer(int visualIndex, const QString &name)
 217 {
 218         QString layerName = name;
 219         if( layerName.isEmpty() )
 220         {
 221                 layerName = tr("Layer %1").arg(d->layerCount+1);
 222         }
 223
 224         Model::Layer *layer = new Model::Layer(this, layerName);
 225
 226         insertLayer(visualIndex, layer);
 227 //      layer->setLayerName(layerName);
 228
 229         return layer;
 230 }
 231
 232 /**
 233  * @~spanish
 234  * Inserte la capa @p layer en la posición @p visualIndex a la escena.
 235  */
 236 void Scene::insertLayer(int visualIndex, Model::Layer *layer)
 237 {
 238         Command::InsertLayer *cmd = new Command::InsertLayer(layer, &d->layers, visualIndex);
 239         project()->commandManager()->addCommand(cmd);
 240
 241         d->layerCount++;
 242 }
 243
 244 /**
 245  * @~spanish
 246  * Añade la capa @p layer a la escena.
 247  */
 248 void Scene::addLayer(Model::Layer *layer)
 249 {
 250         Command::InsertLayer *cmd = new Command::InsertLayer(layer, &d->layers);
 251         project()->commandManager()->addCommand(cmd);
 252
 253         d->layerCount++;
 254 }
 255
 256 /**
 257  * @~spanish
 258  * Remueve la capa @p layer de la escena.
 259  */
 260 void Scene::removeLayer(Model::Layer *layer)
 261 {
 262         Command::RemoveLayer *cmd = new Command::RemoveLayer(layer, &d->layers);
 263         project()->commandManager()->addCommand(cmd);
 264 }
 265
 266
 267 /**
 268  * Mueve el layer a la posicion indicada
 269  */
 270 bool Scene::moveLayer(int from, int to)
 271 {
 272         if ( from < 0 || from >= d->layers.count() || to < 0 || to >= d->layers.count() )
 273         {
 274                 return false;
 275         }
 276
 277         Command::MoveLayer *cmd = new Command::MoveLayer(this, from, to, &d->layers);
 278         project()->commandManager()->addCommand(cmd);
 279
 280         return true;
 281 }
 282
 283 /**
 284  * Retorna la posición logica de la escena.
 285  */
 286 int Scene::logicalIndex() const
 287 {
 288         if ( Project *project = dynamic_cast<Project *>(parent()) )
 289         {
 290                 return project->logicalIndexOf(const_cast<Scene *>(this) );
 291         }
 292
 293         return -1;
 294 }
 295
 296 /**
 297  * Retorna la posición visual de la escena.
 298  */
 299 int Scene::visualIndex() const
 300 {
 301         if ( Project *project = dynamic_cast<Project *>(parent()) )
 302         {
 303                 return project->visualIndexOf(const_cast<Scene *>(this) );
 304         }
 305
 306         return -1;
 307 }
 308
 309 /**
 310  * Retorna la posición visual de la capa @p layer.
 311  */
 312 int Scene::visualIndexOf(Layer *layer) const
 313 {
 314         return d->layers.visualIndex(layer);
 315 }
 316
 317 /**
 318  * Retorna la posición logica de la capa @p layer.
 319  */
 320 int Scene::logicalIndexOf(Layer *layer) const
 321 {
 322         return d->layers.logicalIndex(layer);
 323 }
 324
 325 /**
 326  * @~spanish
 327  * Retorna el proyecto en el que esta la escena.
 328  */
 329 Project *Scene::project() const
 330 {
 331         return static_cast<Project *>(parent());
 332 }
 333
 334 void Scene::addTweeningObject(Object *object)
 335 {
 336         d->tweeningObjects << object;
 337 }
 338
 339 void Scene::removeTweeningObject(Object *object)
 340 {
 341         d->tweeningObjects.remove(object);
 342 }
 343
 344 void Scene::setAlwaysVisible(Object *object, bool visible)
 345 {
 346         if( visible)
 347         {
 348                 d->alwaysVisible << object;
 349         }
 350         else
 351         {
 352                 d->alwaysVisible.remove(object);
 353         }
 354 }
 355
 356 QList<Object *> Scene::alwaysVisible() const
 357 {
 358         return d->alwaysVisible.toList();
 359 }
 360
 361 QList<Object *> Scene::tweeningObjects() const
 362 {
 363         return d->tweeningObjects.toList();
 364 }
 365
 366 bool Scene::containsTweeningObject(Object *object) const
 367 {
 368         return d->tweeningObjects.contains(object);
 369 }
 370
 371 Model::Object *Scene::tweeningObject(QGraphicsItem *item) const
 372 {
 373         Model::Object *ret = 0;
 374         foreach(Model::Object *obj, d->tweeningObjects )
 375         {
 376                 if( obj->item() == item )
 377                 {
 378                         ret = obj;
 379                         break;
 380                 }
 381         }
 382
 383         return ret;
 384 }
 385
 386 Model::Location Scene::location() const
 387 {
 388         Model::Location loc;
 389         loc.setValue(Location::Scene, visualIndex());
 390
 391         return loc;
 392 }
 393
 394 /**
 395  * @~spanish
 396  * Construye la escena a partir del xml.
 397 */
 398 void Scene::fromXml(const QString &xml )
 399 {
 400         QDomDocument document;
 401
 402         if (! document.setContent(xml) )
 403         {
 404                 return;
 405         }
 406
 407         QDomElement root = document.documentElement();
 408         QDomNode n = root.firstChild();
 409         setSceneName( root.attribute( "name", sceneName()) );
 410
 411         while( !n.isNull() )
 412         {
 413                 QDomElement e = n.toElement();
 414
 415                 if(!e.isNull())
 416                 {
 417                         if ( e.tagName() == "layer" )
 418                         {
 419                                 int pos = d->layers.count();
 420
 421                                 {
 422                                         QString newDoc;
 423
 424                                         {
 425                                                 QTextStream ts(&newDoc);
 426                                                 ts << n;
 427                                         }
 428
 429                                         QDomDocument doc;
 430                                         if( !doc.setContent(newDoc) ) return;
 431
 432                                         QDomElement root = doc.documentElement();
 433                                         QString name = root.attribute("name");
 434                                         int type = root.attribute("type").toInt();
 435
 436
 437                                         Layer *layer = 0;
 438
 439                                         switch(type)
 440                                         {
 441                                                 case Layer::Audio:
 442                                                 {
 443                                                         layer = createAudioLayer(-1, name);
 444                                                 }
 445                                                 break;
 446                                                 default:
 447                                                 {
 448                                                         layer = createLayer(-1, name);
 449                                                 }
 450                                                 break;
 451                                         }
 452
 453                                         layer->fromXml( newDoc );
 454                                 }
 455                         }
 456                 }
 457
 458                 n = n.nextSibling();
 459         }
 460 }
 461
 462 /**
 463  * @~spanish
 464  * Convierte la escena a un documento xml.
 465  */
 466 QDomElement Scene::toXml(QDomDocument &doc) const
 467 {
 468         QDomElement root = doc.createElement("scene");
 469         root.setAttribute("name", d->name );
 470
 471         foreach(Layer *layer, d->layers.visualValues())
 472         {
 473                 root.appendChild( layer->toXml(doc) );
 474         }
 475
 476         foreach(AudioLayer *sound, d->audioLayers)
 477         {
 478                 root.appendChild(sound->toXml(doc));
 479         }
 480
 481
 482         return root;
 483 }
 484
 485
 486 }
 487 }