yamf/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 #include "model/command/lockframe.h"
  35 #include "model/command/changeframevisibility.h"
  36 #include "model/command/renameframe.h"
  37
  38 #include "model/library.h"
  39 #include "model/object.h"
  40 #include "model/objectgroup.h"
  41
  42 #include "item/group.h"
  43 #include "item/tweener.h"
  44
  45 #define INVALID_Z -10000
  46
  47
  48 namespace YAMF {
  49 namespace Model {
  50
  51 struct Frame::Private
  52 {
  53         Private() : objectCount(0)
  54         {
  55         }
  56
  57         QString name;
  58         bool isLocked;
  59         bool isVisible;
  60         GraphicObjects graphics;
  61         int repeat;
  62
  63         int objectCount;
  64
  65         ObjectGroup *createObjectGroup(Frame *frame , QGraphicsItem *item)
  66         {
  67                 ObjectGroup *oGroup = new ObjectGroup(frame);
  68                 if(Item::Group *group = static_cast<Item::Group * >(item))
  69                 {
  70                         foreach(QGraphicsItem *child, group->childs())
  71                         {
  72                                 if(child->type() == Item::Group::Type)
  73                                 {
  74                                         ObjectGroup *ocGroup = createObjectGroup(frame, child);
  75                                         oGroup->addToGroup(ocGroup);
  76
  77                                 }
  78                                 else
  79                                 {
  80                                         Object *object = new Object(child, frame);
  81                                         oGroup->addToGroup(object);
  82                                 }
  83                         }
  84                 }
  85                 return oGroup;
  86         }
  87
  88         void fixZValue( Object *object )
  89         {
  90                 if( QGraphicsItem *item = object->item() )
  91                 {
  92                         if( item->zValue() == INVALID_Z )
  93                         {
  94                                 double zMax = 0;
  95                                 foreach(Object *graphic, graphics.values() )
  96                                 {
  97                                         if( zMax < graphic->item()->zValue() )
  98                                         {
  99                                                 zMax = graphic->item()->zValue();
 100                                         }
 101                                 }
 102                                 item->setZValue(zMax+0.1);
 103                         }
 104                 }
 105         }
 106
 107
 108 };
 109
 110 /**
 111  * @~spanish
 112  * Constructor por defecto
 113  */
 114 Frame::Frame(Layer *parent, const QString& name ) : QObject(parent), d(new Private)
 115 {
 116         d->name = name;
 117         d->isLocked = false;
 118         d->isVisible = true;
 119         d->repeat = 1;
 120 }
 121
 122 /**
 123  * @~spanish
 124  * Destructor
 125  */
 126 Frame::~Frame()
 127 {
 128         d->graphics.clear(true);
 129         delete d;
 130 }
 131
 132 /**
 133  * @~spanish
 134  * Limpia el marco.
 135  */
 136 void Frame::clean()
 137 {
 138         d->graphics.clear(true);
 139 }
 140
 141 /**
 142  * @~spanish
 143  * Pone el nombre del frame
 144  */
 145 void Frame::setFrameName(const QString &name)
 146 {
 147         if(name != d->name)
 148         {
 149                 Command::RenameFrame *cmd = new Command::RenameFrame(this, name, &d->name);
 150                 project()->commandManager()->addCommand(cmd);
 151         }
 152 }
 153
 154 /**
 155  * @~spanish
 156  * Retorna el nombre del frame
 157  */
 158 QString Frame::frameName() const
 159 {
 160         return d->name;
 161 }
 162
 163 /**
 164  * @~spanish
 165  * Si isLocked es verdadero bloquea el frame, de lo contrario lo desbloquea.
 166  */
 167 void Frame::setLocked(bool isLocked)
 168 {
 169         if(isLocked != d->isLocked)
 170         {
 171                 Command::LockFrame *command = new Command::LockFrame(this, isLocked, &d->isLocked);
 172                 project()->commandManager()->addCommand(command);
 173         }
 174 }
 175
 176
 177 /**
 178  * @~spanish
 179  * Returna verdadero cuando el frame esta bloqueado
 180  */
 181 bool Frame::isLocked() const
 182 {
 183         return d->isLocked;
 184 }
 185
 186 /**
 187  * @~spanish
 188  * Cambia la visibilidad del marco.
 189  * Si @p isVisible es verdadero permite la visualización del marco de lo contrario lo oculta.
 190  */
 191 void Frame::setVisible(bool isVisible)
 192 {
 193         if(d->isVisible != isVisible)
 194         {
 195                 Command::ChangeFrameVisibility *command = new Command::ChangeFrameVisibility(this, isVisible, &d->isVisible);
 196                 project()->commandManager()->addCommand(command);
 197         }
 198 }
 199
 200 /**
 201  * @~spanish
 202  * Retorna verdadero si el marco es visible, de lo contrario retorna falso.
 203  */
 204 bool Frame::isVisible() const
 205 {
 206         return d->isVisible;
 207 }
 208
 209 /**
 210  * @~spanish
 211  * Añade un objeto grafico al marco.
 212  */
 213 void Frame::addObject(Object *object)
 214 {
 215         Command::Manager *commandManager = project()->commandManager();
 216
 217         object->setParent(this);
 218
 219         d->fixZValue(object);
 220
 221         if( object->objectName().isEmpty() )
 222         {
 223                 object->setObjectName(tr("Object %1").arg(d->objectCount++));
 224         }
 225
 226         Command::AddObject *command = new Command::AddObject(object, &d->graphics);
 227         commandManager->addCommand(command);
 228 }
 229
 230 /**
 231  * @~spanish
 232  * Remueve el objeto grafico  @p object del marco.
 233  */
 234 void Frame::removeObject(Object *object)
 235 {
 236         Command::RemoveObject *cmd = new Command::RemoveObject(object, &d->graphics, this);
 237         project()->commandManager()->addCommand(cmd);
 238
 239         this->scene()->removeTweeningObject(object);
 240 }
 241
 242 /**
 243  * @~spanish
 244  * Remueve los objetos graficos  @p objects del marco.
 245  */
 246 void Frame::removeObjects(const QList<Object *> &objects)
 247 {
 248         Command::RemoveObject *cmd = new Command::RemoveObject(objects, &d->graphics, this);
 249         project()->commandManager()->addCommand(cmd);
 250
 251         foreach(Object *object, objects)
 252         {
 253                 this->scene()->removeTweeningObject(object);
 254         }
 255 }
 256
 257 /**
 258  * @~spanish
 259  * Remueve los objetos graficos que contiene el ítem @p item del marco.
 260  */
 261 void Frame::removeItem(QGraphicsItem *item)
 262 {
 263         int index = visualIndexOf(item);
 264         if( index >= 0 )
 265         {
 266                 removeObject(graphic(index));
 267         }
 268 }
 269
 270 /**
 271  * @~spanish
 272  * Remueve los objetos graficos que contiene los ítems @p items del marco.
 273  */
 274 void Frame::removeItems(const QList<QGraphicsItem *> &items)
 275 {
 276         QList<Object *> objects;
 277         foreach(QGraphicsItem *item, items)
 278         {
 279                 int index = visualIndexOf(item);
 280                 if( index >= 0 )
 281                 {
 282                         objects << graphic(index);
 283                 }
 284         }
 285
 286         if(!objects.isEmpty())
 287                 removeObjects(objects);
 288 }
 289
 290 /**
 291  * @~spanish
 292  * Añade el item grafico @p item al marco, retornando el objeto grafico que lo contiene.
 293  */
 294 Object *Frame::addItem(QGraphicsItem *item)
 295 {
 296         Object *object = new Object(item, this);
 297         object->setObjectName(tr("Object %1").arg(d->objectCount++));
 298         item->setZValue(INVALID_Z);
 299
 300         addObject(object);
 301
 302         return object;
 303 }
 304
 305 /**
 306  * @~spanish
 307  * Reemplaza el item que contien el objeto grafico de la posición @p logicalIndex por el ítem @p item..
 308  */
 309 void Frame::replaceItem(int logicalIndex, QGraphicsItem *item)
 310 {
 311         Object *toReplace = this->graphic(logicalIndex);
 312
 313         if ( toReplace )
 314         {
 315                 toReplace->setItem( item );
 316         }
 317 }
 318
 319 /**
 320  * @~spanish
 321  * Remueve el objeto grafico que esta en la posición @p logicalIndex del marco.
 322  */
 323 void Frame::removeObjectAt(int logicalIndex)
 324 {
 325         if ( !d->graphics.contains(logicalIndex) )
 326         {
 327                 return;
 328         }
 329
 330         Object *object = graphic(logicalIndex);
 331         removeObject(object);
 332 }
 333
 334 void Frame::detach(Model::Object *object)
 335 {
 336         d->graphics.remove(object);
 337
 338         QGraphicsItem *item = object->item();
 339
 340         if ( item )
 341         {
 342                 QGraphicsScene *scene = item->scene();
 343
 344                 if(scene)
 345                 {
 346                         scene->removeItem(item);
 347                 }
 348         }
 349 }
 350
 351 void Frame::attach(Model::Object *object)
 352 {
 353         d->graphics.add(object);
 354 }
 355
 356 /**
 357  * @~spanish
 358  * Cambia la posición del objeto grafico de la posición @p currentPosition a la posición @p newPosition.
 359  */
 360 bool Frame::moveItem(int currentPosition, int newPosition)
 361 {
 362         D_FUNCINFO << "current "<< currentPosition << " new "  << newPosition;
 363         if(currentPosition == newPosition || currentPosition < 0 || currentPosition >= d->graphics.count() || newPosition < 0 || newPosition >= d->graphics.count())
 364         {
 365                 return false;
 366         }
 367
 368         if(currentPosition < newPosition)
 369         {
 370                 for( int i = currentPosition; i < newPosition; i++)
 371                 {
 372                         double tmp = d->graphics.visualValue(i)->item()->zValue();
 373                         d->graphics.visualValue(i)->item()->setZValue(d->graphics.visualValue(i+1)->item()->zValue());
 374                         d->graphics.visualValue(i+1)->item()->setZValue(tmp);
 375                         d->graphics.moveVisual(i, i+1);
 376                 }
 377         }
 378         else
 379         {
 380                 for( int i = currentPosition; i > newPosition; i--)
 381                 {
 382                         double tmp = d->graphics.visualValue(i)->item()->zValue();
 383                         d->graphics.visualValue(i)->item()->setZValue(d->graphics.visualValue(i-1)->item()->zValue());
 384                         d->graphics.visualValue(i-1)->item()->setZValue(tmp);
 385                         d->graphics.moveVisual(i, i-1);
 386                 }
 387         }
 388         return true;
 389 }
 390
 391
 392
 393 /**
 394  * @~spanish
 395  * Retorna los objetos graficos que contiene el marco.
 396  */
 397 GraphicObjects Frame::graphics() const
 398 {
 399         return d->graphics;
 400 }
 401
 402 /**
 403  * @~spanish
 404  * Retorna el objeto grafico de la posición @p visualIndex.
 405  */
 406 Object *Frame::graphic(int visualIndex) const
 407 {
 408         if ( !d->graphics.containsVisual(visualIndex) )
 409         {
 410                 D_FUNCINFO << " FATAL ERROR: index out of bound " << visualIndex << " FRAME: " << this->visualIndex() << " LAYER: " << layer()->visualIndex();
 411                 return 0;
 412         }
 413
 414         return d->graphics.visualValue(visualIndex);
 415 }
 416
 417 /**
 418  * @~spanish
 419  * Retorna el objecto grafico que contiene al item @p item.
 420  */
 421 Object *Frame::graphic(QGraphicsItem *item) const
 422 {
 423         if( item )
 424         {
 425                 foreach(Object *object, d->graphics.values() )
 426                 {
 427                         if (object->item() == item )
 428                         {
 429                                 return object;
 430                         }
 431                 }
 432         }
 433         return 0;
 434 }
 435
 436 Object *Frame::findGraphic(QGraphicsItem *item) const
 437 {
 438         Object *object = graphic(item);
 439
 440         if( ! object )
 441         {
 442                 object = scene()->tweeningObject(item);
 443         }
 444
 445         return object;
 446 }
 447
 448 /**
 449  * @~spanish
 450  * Retorna el item que contiene el objeto grafico de la posición @p visualIndex.
 451  */
 452 QGraphicsItem *Frame::item(int visualIndex) const
 453 {
 454         Object *object = graphic(visualIndex);
 455
 456         if ( object )
 457         {
 458                 return object->item();
 459         }
 460
 461         return 0;
 462 }
 463
 464 /**
 465  * @~spanish
 466  * Obtiene la posición visual del objeto grafico @p object.
 467  */
 468 int Frame::visualIndexOf(Object *object) const
 469 {
 470         return d->graphics.visualIndex(object);
 471 }
 472
 473 /**
 474  * @~spanish
 475  * Obtiene la posición logica del objeto grafico @p object.
 476  */
 477 int Frame::logicalIndexOf(Object *object) const
 478 {
 479         return d->graphics.logicalIndex(object);
 480 }
 481
 482 /**
 483  * @~spanish
 484  * Obtiene la posición visual del objeto grafico que contiene al ítem @p item.
 485  */
 486 int Frame::visualIndexOf(QGraphicsItem *item) const
 487 {
 488         foreach(Object *object, d->graphics.values() )
 489         {
 490                 if (object->item() == item )
 491                 {
 492                         return d->graphics.visualIndex(object);
 493                 }
 494         }
 495         return -1;
 496 }
 497
 498 /**
 499  * @~spanish
 500  * Obtiene la posición logica del objeto grafico que contiene al ítem @p item.
 501  */
 502 int Frame::logicalIndexOf(QGraphicsItem *item) const
 503 {
 504         foreach(Object *object, d->graphics.values())
 505         {
 506                 if (object->item() == item )
 507                 {
 508                         return d->graphics.logicalIndex(object);
 509                 }
 510         }
 511
 512         return -1;
 513 }
 514
 515
 516 /**
 517  * @~spanish
 518  * Retorna la posición visual del marco.
 519  */
 520 int Frame::visualIndex() const
 521 {
 522         return layer()->visualIndexOf(const_cast<Frame *>(this));
 523 }
 524
 525
 526 /**
 527  * @~spanish
 528  * Retorna la posición logica del marco.
 529  */
 530 int Frame::logicalIndex() const
 531 {
 532         return layer()->logicalIndexOf(const_cast<Frame *>(this));
 533 }
 534
 535 Model::Location Frame::location() const
 536 {
 537         Model::Location loc;
 538         loc.setValue(Location::Scene, scene()->visualIndex() );
 539         loc.setValue(Location::Layer, layer()->visualIndex() );
 540         loc.setValue(Location::Frame, this->visualIndex() );
 541
 542         return loc;
 543 }
 544
 545
 546 /**
 547  * @~spanish
 548  * Retorna la capa en la que esta el marco.
 549  */
 550 Layer *Frame::layer() const
 551 {
 552         return static_cast<Layer *>(parent());
 553 }
 554
 555 /**
 556  * @~spanish
 557  * Retorna la escena en la que esta el marco.
 558  */
 559 Scene *Frame::scene() const
 560 {
 561         return layer()->scene();
 562 }
 563
 564
 565 /**
 566  * @~spanish
 567  * Retorna el proyecto en el que esta el marco.
 568 */
 569 Project *Frame::project() const
 570 {
 571         return layer()->project();
 572 }
 573
 574
 575 /**
 576  * @~spanish
 577  * Construye el marco a partir del xml.
 578  */
 579 void Frame::fromXml(const QString &xml )
 580 {
 581         QDomDocument document;
 582
 583         if (! document.setContent(xml) )
 584         {
 585                 return;
 586         }
 587
 588         QDomElement root = document.documentElement();
 589
 590         setFrameName( root.attribute( "name", frameName() ) );
 591
 592         QDomNode n = root.firstChild();
 593
 594         while( !n.isNull() )
 595         {
 596                 QDomElement e = n.toElement();
 597
 598                 if(!e.isNull())
 599                 {
 600                         if( e.tagName() == "object" )
 601                         {
 602                                 QString objectXml;
 603                                 QTextStream ts(&objectXml);
 604                                 ts << e;
 605
 606                                 Object *last = new Object(this);
 607                                 last->fromXml(objectXml);
 608
 609                                 if( last->item() )
 610                                 {
 611                                         if(last->item()->type() == Item::Group::Type)
 612                                         {
 613                                                 ObjectGroup *oGroup = d->createObjectGroup(this, last->item());
 614                                                 addObject(oGroup);
 615                                         }
 616                                         else
 617                                         {
 618                                                 addObject(last);
 619                                         }
 620                                 }
 621                                 else
 622                                 {
 623                                         delete last;
 624                                 }
 625                         }
 626                 }
 627
 628                 n = n.nextSibling();
 629         }
 630 }
 631
 632 /**
 633  * @~spanish
 634  * Convierte el marco a un documento xml.
 635  */
 636 QDomElement Frame::toXml(QDomDocument &doc) const
 637 {
 638         QDomElement root = doc.createElement("frame");
 639         root.setAttribute("name", d->name );
 640         root.setAttribute("index", visualIndex());
 641         int nclones = layer()->clones(const_cast<Frame *>(this));
 642         if(nclones > 0)
 643         {
 644                 root.setAttribute("clones", nclones);
 645         }
 646
 647         doc.appendChild(root);
 648
 649         foreach(Object *object, d->graphics.visualValues() )
 650         {
 651                 if( dynamic_cast<Common::AbstractSerializable *>(object->item()) )
 652                 {
 653                         root.appendChild( object->toXml(doc) );
 654                 }
 655         }
 656
 657         return root;
 658 }
 659
 660 }
 661 }