src/model/frame.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 "frame.h"
  22 #include "layer.h"
  23
  24 #include <dcore/debug.h>
  25
  26 #include <QGraphicsItem>
  27
  28 #include "object.h"
  29 #include "scene.h"
  30 #include "item/builder.h"
  31 #include "model/command/manager.h"
  32 #include "model/command/addobject.h"
  33 #include "model/command/removeobject.h"
  34
  35 #include "model/library.h"
  36 #include "item/group.h"
  37 #include "item/tweener.h"
  38
  39 namespace YAMF {
  40 namespace Model {
  41
  42 struct Frame::Private
  43 {
  44         Private() : objectCount(0)
  45         {
  46         }
  47
  48         QString name;
  49         bool isLocked;
  50         bool isVisible;
  51         GraphicObjects graphics;
  52         int repeat;
  53
  54         int objectCount;
  55 };
  56
  57 Frame::Frame(Layer *parent) : QObject(parent), d(new Private)
  58 {
  59         d->name = tr("Frame");
  60         d->isLocked = false;
  61         d->isVisible = true;
  62         d->repeat = 1;
  63 }
  64
  65 Frame::~Frame()
  66 {
  67         d->graphics.clear(true);
  68         delete d;
  69 }
  70
  71
  72 void Frame::clean()
  73 {
  74         d->graphics.clear(true);
  75 }
  76
  77 void Frame::setFrameName(const QString &name)
  78 {
  79         d->name = name;
  80 }
  81
  82 void Frame::setLocked(bool isLocked)
  83 {
  84         d->isLocked = isLocked;
  85 }
  86
  87 QString Frame::frameName() const
  88 {
  89         return d->name;
  90 }
  91
  92 bool Frame::isLocked() const
  93 {
  94         return d->isLocked;
  95 }
  96
  97 void Frame::setVisible(bool isVisible)
  98 {
  99         d->isVisible = isVisible;
 100 }
 101
 102 bool Frame::isVisible() const
 103 {
 104         return d->isVisible;
 105 }
 106
 107 void Frame::addObject(Object *object)
 108 {
 109         Command::Manager *commandManager = project()->commandManager();
 110
 111         object->setParent(this);
 112
 113         if( QGraphicsItem *item = object->item() )
 114         {
 115                 double zMax = 0;
 116                 foreach(Object *graphic, d->graphics.values() )
 117                 {
 118                         if( zMax < graphic->item()->zValue() )
 119                         {
 120                                 zMax = graphic->item()->zValue();
 121                         }
 122                 }
 123
 124                 item->setZValue(zMax+1);
 125         }
 126
 127         if( object->objectName().isEmpty() )
 128         {
 129                 object->setObjectName(tr("Object %1").arg(d->objectCount++));
 130         }
 131
 132         Command::AddObject *command = new Command::AddObject(object, &d->graphics);
 133         commandManager->addCommand(command);
 134
 135 }
 136
 137 void Frame::removeObject(Object *object)
 138 {
 139         Command::RemoveObject *cmd = new Command::RemoveObject(object, &d->graphics);
 140         project()->commandManager()->addCommand(cmd);
 141
 142         this->scene()->removeTweeningObject(object);
 143 }
 144
 145 void Frame::removeObjects(const QList<Object *> &objects)
 146 {
 147         Command::RemoveObject *cmd = new Command::RemoveObject(objects, &d->graphics);
 148         project()->commandManager()->addCommand(cmd);
 149
 150         foreach(Object *object, objects)
 151                 this->scene()->removeTweeningObject(object);
 152 }
 153
 154 void Frame::removeItem(QGraphicsItem *item)
 155 {
 156         int index = logicalIndexOf(item);
 157         if( index >= 0 )
 158         {
 159                 removeObject(graphic(index));
 160         }
 161 }
 162
 163 void Frame::removeItems(const QList<QGraphicsItem *> &items)
 164 {
 165         QList<Object *> objects;
 166         foreach(QGraphicsItem *item, items)
 167         {
 168                 int index = logicalIndexOf(item);
 169                 if( index >= 0 )
 170                 {
 171                         objects << graphic(index);
 172                 }
 173         }
 174
 175         removeObjects(objects);
 176 }
 177
 178 void Frame::fromXml(const QString &xml )
 179 {
 180         QDomDocument document;
 181
 182         if (! document.setContent(xml) )
 183         {
 184                 return;
 185         }
 186
 187         QDomElement root = document.documentElement();
 188
 189         setFrameName( root.attribute( "name", frameName() ) );
 190
 191         QDomNode n = root.firstChild();
 192
 193         while( !n.isNull() )
 194         {
 195                 QDomElement e = n.toElement();
 196
 197                 if(!e.isNull())
 198                 {
 199                         if( e.tagName() == "object" )
 200                         {
 201                                 QString objectXml;
 202                                 QTextStream ts(&objectXml);
 203                                 ts << e;
 204
 205                                 Object *last = new Object(this);
 206                                 last->fromXml(objectXml);
 207                         }
 208                 }
 209
 210                 n = n.nextSibling();
 211         }
 212 }
 213
 214 QDomElement Frame::toXml(QDomDocument &doc) const
 215 {
 216         QDomElement root = doc.createElement("frame");
 217         root.setAttribute("name", d->name );
 218         doc.appendChild(root);
 219
 220         foreach(Object *object, d->graphics.visualValues() )
 221         {
 222                 root.appendChild( object->toXml(doc) );
 223         }
 224
 225         return root;
 226 }
 227
 228 Object *Frame::addItem(QGraphicsItem *item)
 229 {
 230         Object *object = new Object(item, this);
 231         object->setObjectName(tr("Object %1").arg(d->objectCount++));
 232
 233         addObject(object);
 234
 235         return object;
 236 }
 237
 238
 239
 240
 241 void Frame::replaceItem(int logicalIndex, QGraphicsItem *item)
 242 {
 243         Object *toReplace = this->graphic(logicalIndex);
 244
 245         if ( toReplace )
 246         {
 247                 toReplace->setItem( item );
 248         }
 249 }
 250
 251 bool Frame::moveItem(int currentPosition, int newPosition)
 252 {
 253         D_FUNCINFO << "current "<< currentPosition << " new "  << newPosition;
 254         if(currentPosition == newPosition || currentPosition < 0 || currentPosition >= d->graphics.count() || newPosition < 0 || newPosition >= d->graphics.count())
 255         {
 256                 return false;
 257         }
 258
 259         if(currentPosition < newPosition)
 260         {
 261                 for( int i = currentPosition; i < newPosition; i++)
 262                 {
 263                         double tmp = d->graphics.visualValue(i)->item()->zValue();
 264                         d->graphics.visualValue(i)->item()->setZValue(d->graphics.visualValue(i+1)->item()->zValue());
 265                         d->graphics.visualValue(i+1)->item()->setZValue(tmp);
 266                         d->graphics.moveVisual(i, i+1);
 267                 }
 268         }
 269         else
 270         {
 271                 for( int i = currentPosition; i > newPosition; i--)
 272                 {
 273                         double tmp = d->graphics.visualValue(i)->item()->zValue();
 274                         d->graphics.visualValue(i)->item()->setZValue(d->graphics.visualValue(i-1)->item()->zValue());
 275                         d->graphics.visualValue(i-1)->item()->setZValue(tmp);
 276                         d->graphics.moveVisual(i, i-1);
 277                 }
 278         }
 279         return true;
 280 }
 281
 282 void Frame::removeObjectAt(int logicalIndex)
 283 {
 284         if ( !d->graphics.contains(logicalIndex) )
 285         {
 286                 return;
 287         }
 288
 289         Object *object = graphic(logicalIndex);
 290         removeObject(object);
 291 }
 292
 293 GraphicObjects Frame::graphics() const
 294 {
 295         return d->graphics;
 296 }
 297
 298 Object *Frame::graphic(int logicalIndex) const
 299 {
 300         if ( !d->graphics.contains(logicalIndex) )
 301         {
 302                 D_FUNCINFO << " FATAL ERROR: index out of bound " << logicalIndex;
 303                 return 0;
 304         }
 305
 306         return d->graphics.value(logicalIndex);
 307 }
 308
 309 QGraphicsItem *Frame::item(int logicalIndex) const
 310 {
 311         Object *object = graphic(logicalIndex);
 312
 313         if ( object )
 314         {
 315                 return object->item();
 316         }
 317
 318         return 0;
 319 }
 320
 321 int Frame::visualIndexOf(Object *object) const
 322 {
 323         return d->graphics.visualIndex(object);
 324 }
 325
 326 int Frame::logicalIndexOf(Object *object) const
 327 {
 328         return d->graphics.logicalIndex(object);
 329 }
 330
 331 int Frame::visualIndexOf(QGraphicsItem *item) const
 332 {
 333         foreach(Object *object, d->graphics.values() )
 334         {
 335                 if (object->item() == item )
 336                 {
 337                         return d->graphics.visualIndex(object);
 338                 }
 339         }
 340         return -1;
 341 }
 342
 343 int Frame::logicalIndexOf(QGraphicsItem *item) const
 344 {
 345         foreach(Object *object, d->graphics.values())
 346         {
 347                 if (object->item() == item )
 348                 {
 349                         return d->graphics.logicalIndex(object);
 350                 }
 351         }
 352
 353         return -1;
 354 }
 355
 356
 357 int Frame::logicalIndex() const
 358 {
 359         return layer()->logicalIndexOf(const_cast<Frame *>(this));
 360 }
 361
 362
 363 void Frame::setRepeat(int repeat)
 364 {
 365         d->repeat = repeat;
 366 }
 367
 368 int Frame::repeat() const
 369 {
 370         return d->repeat;
 371 }
 372
 373 int Frame::visualIndex() const
 374 {
 375         return layer()->visualIndexOf(const_cast<Frame *>(this));
 376 }
 377
 378 Layer *Frame::layer() const
 379 {
 380         return static_cast<Layer *>(parent());
 381 }
 382
 383 Scene *Frame::scene() const
 384 {
 385         return layer()->scene();
 386 }
 387
 388 Project *Frame::project() const
 389 {
 390         return layer()->project();
 391 }
 392
 393 }
 394 }