yamf/drawing/paintarea.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Jorge Cuadrado                                  *
   3  *   kuadrosxx@gmail.com                                                   *
   4  *   Copyright (C) 2006 by David Cuadrado                                  *
   5  *   krawek@gmail.com                                                      *
   6  *                                                                         *
   7  *   This program is free software; you can redistribute it and/or modify  *
   8  *   it under the terms of the GNU General Public License as published by  *
   9  *   the Free Software Foundation; either version 2 of the License, or     *
  10  *   (at your option) any later version.                                   *
  11  *                                                                         *
  12  *   This program is distributed in the hope that it will be useful,       *
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  15  *   GNU General Public License for more details.                          *
  16  *                                                                         *
  17  *   You should have received a copy of the GNU General Public License     *
  18  *   along with this program; if not, write to the                         *
  19  *   Free Software Foundation, Inc.,                                       *
  20  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  21  ***************************************************************************/
  22
  23 #include "paintarea.h"
  24
  25 #include "private/paintarearotator.h"
  26
  27 #include <QGraphicsScene>
  28 #include <QMouseEvent>
  29 #include <QGraphicsSceneMouseEvent>
  30 #include <QGraphicsRectItem>
  31 #include <QPolygon>
  32 #include <QApplication>
  33 #include <QTimer>
  34 #include <QStyleOptionGraphicsItem>
  35 #include <QClipboard>
  36 #include <QUndoStack>
  37 #include <QMenu>
  38 #include <QToolBar>
  39
  40 #include "photogram.h"
  41 #include <dgraphics/algorithm.h>
  42
  43 #include <dcore/config.h>
  44 #include <dcore/debug.h>
  45 #include <dgui/application.h>
  46 #include <dgui/osd.h>
  47 #include <dgui/commandhistory.h>
  48 #include <dgui/action.h>
  49 #include <dgui/actionmanager.h>
  50 #include <dgui/iconloader.h>
  51
  52 #include <cmath>
  53
  54 #include <model/scene.h>
  55 #include <model/layer.h>
  56 #include <model/frame.h>
  57 #include <model/object.h>
  58 #include <model/library.h>
  59
  60 #include <item/group.h>
  61 #include <item/serializer.h>
  62 #include "yamf/item/tweenerstep.h"
  63 #include "yamf/item/tweener.h"
  64
  65 #include "model/command/base.h"
  66 #include "model/command/groupitem.h"
  67 #include "model/command/ungroupitem.h"
  68 #include "model/command/modifyitem.h"
  69 #include "model/command/modifysymbol.h"
  70 #include "model/command/sendtobackitem.h"
  71 #include "model/command/bringtofrontitem.h"
  72 #include "model/command/sendbackwardsitem.h"
  73 #include "model/command/bringforwardsitem.h"
  74 #include "model/command/manager.h"
  75 #include "yamf/model/command/additemfilter.h"
  76
  77 #include "yamf/model/libraryitem.h"
  78 #include "yamf/model/audiolayer.h"
  79
  80 #include "yamf/effect/factory.h"
  81 #include "yamf/effect/filter.h"
  82
  83 #include <drawing/abstracttool.h>
  84 #include <private/addsymboldialog.h>
  85
  86 namespace YAMF {
  87 namespace Drawing {
  88
  89 #ifdef QT_OPENGL_LIB
  90
  91 #include <QGLWidget>
  92 #include <QGLFramebufferObject>
  93
  94 class GLDevice : public QGLWidget
  95 {
  96         public:
  97                 GLDevice() : QGLWidget()
  98                 {
  99                         makeCurrent();
 100                 }
 101                 ~GLDevice() {};
 102
 103         protected:
 104                 void initializeGL()
 105                 {
 106                         glDisable(GL_DEPTH_TEST);
 107                 }
 108 };
 109 #endif
 110
 111 struct YAMF::Drawing::PaintArea::Private
 112 {
 113         Private(YAMF::Drawing::PaintArea *paintArea, Model::Project *const project) : paintArea(paintArea), project(project), lastScaleFactor(1.0)
 114         {
 115         }
 116
 117         DGui::CommandHistory *history;
 118
 119         YAMF::Drawing::PaintArea *paintArea;
 120
 121         QRectF drawingRect;
 122
 123         bool drawGrid;
 124         double angle;
 125
 126         YAMF::Drawing::Private::PaintAreaRotator *rotator;
 127         Photogram *photogram;
 128
 129         struct FramePosition {
 130                 int layer;
 131                 int frame;
 132         } framePosition;
 133
 134
 135         struct ItemProperties {
 136                 QGraphicsItem *item;
 137                 QString properties;
 138         };
 139
 140         QList<ItemProperties> properties;
 141
 142         QPointF origin;
 143
 144         DGui::ActionManager actionManager;
 145
 146         Model::Project *const project;
 147
 148         double lastScaleFactor;
 149
 150         QToolBar *toolsConfigBar;
 151         QToolBar *effectsConfigBar;
 152
 153         struct RecordStep
 154         {
 155                 Item::TweenerStep *step;
 156         };
 157         QList<RecordStep> steps;
 158
 159         void recordIt();
 160 };
 161
 162 void PaintArea::Private::recordIt()
 163 {
 164         Model::Object *recorded = photogram->recorded();
 165
 166         int currentPos = paintArea->currentFrame()->visualIndex();
 167         int objectPos = recorded->frame()->visualIndex();
 168
 169         RecordStep record;
 170         record.step = new Item::TweenerStep(currentPos-objectPos);
 171
 172         record.step->setPosition(recorded->item()->pos());
 173
 174         steps << record;
 175 }
 176
 177
 178
 179 /**
 180  * @~spanish
 181  * Construye un area de trabajo relacionada con el proyecto @p project.
 182 */
 183 PaintArea::PaintArea(Model::Project *const project, QWidget * parent) : QGraphicsView(parent), d(new Private(this, project) )
 184 {
 185         d->history = new DGui::CommandHistory( project->commandManager()->stack(), this);
 186
 187         d->photogram = new Photogram(this);
 188
 189         d->drawGrid = false;
 190         d->angle = 0;
 191
 192         d->rotator = new YAMF::Drawing::Private::PaintAreaRotator(this, this);
 193
 194         d->drawingRect = QRectF(QPointF(0,0), QSizeF( 500, 400 ) ); // FIXME: configurable
 195
 196         d->photogram->setSceneRect(d->drawingRect);
 197         setScene(d->photogram);
 198
 199         centerDrawingArea();
 200
 201         setUseOpenGL( false );
 202         setInteractive ( true );
 203
 204         restoreState();
 205
 206         setCurrentFrame(-1, -1, -1);
 207
 208         d->origin = mapToScene(QPoint(0, 0));
 209
 210         createActions();
 211         checkActions();
 212
 213         d->toolsConfigBar = new QToolBar(tr("Configure tool"), this);
 214
 215         d->effectsConfigBar = new QToolBar(tr("Configure effects"), this);
 216 }
 217
 218 /**
 219  * @~spanish
 220  * Guarda en la configuracion el estado de las propiedades del area de dibujo.
 221  */
 222 void PaintArea::saveState()
 223 {
 224         DCore::Config *config = dApp->config( "PaintArea" );
 225
 226         config->setValue("render_hints", int(renderHints()));
 227         config->setValue("show_grid", d->drawGrid);
 228
 229         config->endGroup();
 230 }
 231
 232 /**
 233  * @~spanish
 234  * Recupera de la configuracion el estado de las propiedades del area de dibujo.
 235  */
 236 void PaintArea::restoreState()
 237 {
 238         DCore::Config *config = dApp->config( "PaintArea" );
 239
 240         int renderHints = config->value("render_hints", int(this->renderHints())).toInt();
 241         setRenderHints(QPainter::RenderHints(renderHints));
 242
 243         bool showGrid = config->value("show_grid", false).toBool();
 244         setDrawGrid(showGrid);
 245
 246         config->endGroup();
 247 }
 248
 249 /**
 250  * Destructor
 251  */
 252 PaintArea::~PaintArea()
 253 {
 254         d->toolsConfigBar->clear();
 255         saveState();
 256         delete d;
 257 }
 258
 259
 260 /**
 261  * @~spanish
 262  * Crea las acciones relacionadas con el area de dibujo.
 263  */
 264 void PaintArea::createActions()
 265 {
 266         addAction( d->history->undoAction() );
 267         addAction( d->history->redoAction() );
 268
 269         connect(d->project->commandManager(), SIGNAL(historyChanged()), this, SLOT(onHistoryChanged()));
 270
 271         QAction *remove = new QAction(DGui::IconLoader::self()->load("edit-delete.svg"), tr("Delete"), this);
 272         remove->setShortcut(QKeySequence::Delete);
 273         connect(remove, SIGNAL(triggered()), this, SLOT(removeSelectedObjects()));
 274         addAction(remove);
 275
 276         QAction *selectAll = new QAction(DGui::IconLoader::self()->load("select-all.svg"), tr("Select all"), this);
 277         selectAll->setShortcut(QKeySequence::SelectAll);
 278         connect(selectAll, SIGNAL(triggered()), this, SLOT(selectAllObjects()));
 279         addAction(selectAll);
 280
 281         QAction *copy = new QAction( DGui::IconLoader::self()->load("edit-copy.svg"), tr("Copy"), this);
 282         copy->setShortcut(QKeySequence::Copy);
 283         connect(copy, SIGNAL(triggered()), this, SLOT(copySelectedObjects()));
 284         addAction(copy);
 285
 286         QAction *paste = new QAction(DGui::IconLoader::self()->load("edit-paste.svg"), tr("Paste"), this);
 287         paste->setShortcut(QKeySequence::Paste);
 288         connect(paste, SIGNAL(triggered()), this, SLOT(pasteObjects()));
 289         addAction(paste);
 290
 291         QAction *cut = new QAction(DGui::IconLoader::self()->load("edit-cut.svg"), tr("Cut"), this);
 292         cut->setShortcut(QKeySequence::Cut);
 293         connect(cut, SIGNAL(triggered()), this, SLOT(cutSelectedObjects()));
 294         addAction(cut);
 295
 296
 297         d->actionManager.add(selectAll, "selectall", "edit");
 298         d->actionManager.addSeparator("edit");
 299         d->actionManager.add(cut, "cut", "edit");
 300         d->actionManager.add(copy, "copy", "edit");
 301         d->actionManager.add(paste, "paste", "edit");
 302         d->actionManager.addSeparator("edit");
 303         d->actionManager.add(remove, "remove", "edit");
 304
 305         /////////
 306
 307         QAction *group = new QAction(DGui::IconLoader::self()->load("object-group.svg"), tr("Group"), this);
 308         group->setShortcut(Qt::CTRL + Qt::Key_G);
 309         connect(group, SIGNAL(triggered()), this, SLOT(groupSelectedObjects()));
 310         d->actionManager.add(group, "group", "object");
 311         addAction(group);
 312
 313         QAction *ungroup = new QAction(DGui::IconLoader::self()->load("object-ungroup.svg"), tr("Ungroup"), this);
 314         ungroup->setShortcut(Qt::CTRL + Qt::SHIFT + Qt::Key_G);
 315         connect(ungroup, SIGNAL(triggered()), this, SLOT(ungroupSelectedObject()));
 316         d->actionManager.add(ungroup, "ungroup", "object");
 317         addAction(ungroup);
 318
 319         QAction *sendToBack = new QAction(DGui::IconLoader::self()->load("object-send-to-back.svg"), tr("Send to back"), this);
 320         sendToBack->setShortcut(Qt::Key_Home);
 321         connect(sendToBack, SIGNAL(triggered()), this, SLOT(sendToBackSelectedObjects()));
 322         d->actionManager.add(sendToBack, "sendtoback", "object-order");
 323         addAction(sendToBack);
 324
 325         QAction *bringToFront = new QAction(DGui::IconLoader::self()->load("object-bring-to-front.svg"), tr("Bring to front"), this);
 326         bringToFront->setShortcut(Qt::Key_End);
 327         connect(bringToFront, SIGNAL(triggered()), this, SLOT(bringToFrontSelectedObjects()));
 328         d->actionManager.add(bringToFront, "bringtofront", "object-order");
 329         addAction(bringToFront);
 330
 331         QAction *sendBackwards = new QAction(DGui::IconLoader::self()->load("object-send-backwards.svg"), tr("Send backwards"), this);
 332         sendBackwards->setShortcut(Qt::Key_PageDown);
 333         connect(sendBackwards, SIGNAL(triggered()), this, SLOT(sendBackwardsSelectedObjects()));
 334         d->actionManager.add(sendBackwards, "sendbackwards", "object-order");
 335         addAction(sendBackwards);
 336
 337         QAction *bringForwards = new QAction(DGui::IconLoader::self()->load("object-bring-forwards.svg"), tr("Bring forwards"), this);
 338         bringForwards->setShortcut(Qt::Key_PageUp);
 339         connect(bringForwards, SIGNAL(triggered()), this, SLOT(bringForwardsSelectedObjects()));
 340         d->actionManager.add(bringForwards, "bringforwards", "object-order");
 341         addAction(bringForwards);
 342
 343         // Library
 344
 345         QAction *addToLibrary = new QAction(DGui::IconLoader::self()->load("object-bring-forwards.svg"), tr("Add to library..."), this);
 346         connect(addToLibrary, SIGNAL(triggered()), this, SLOT(addToLibrary()));
 347         d->actionManager.add(addToLibrary, "addtolibrary", "library");
 348         addAction(addToLibrary);
 349
 350         QAction *applySymbol = new QAction(DGui::IconLoader::self()->load(""), tr("Apply to symbol..."), this);
 351         connect(applySymbol, SIGNAL(triggered()), this, SLOT(applyCurrentSymbol()));
 352         d->actionManager.add(applySymbol, "applysymbol", "library");
 353
 354         // Item
 355
 356         QAction *recordItem = new QAction(DGui::IconLoader::self()->load("media-record.svg"), tr("Record item"), this);
 357         connect(recordItem, SIGNAL(triggered()), this, SLOT(recordItem()));
 358         d->actionManager.add(recordItem, "recorditem", "item");
 359
 360         QAction *stopRecordItem = new QAction(DGui::IconLoader::self()->load("media-playback-stop.svg"), tr("Stop to record item"), this);
 361         connect(stopRecordItem, SIGNAL(triggered()), this, SLOT(stopRecordItem()));
 362         d->actionManager.add(stopRecordItem, "stoprecorditem", "item");
 363 }
 364
 365 /**
 366  * @~spanish
 367  * Si @p use es verdadero permite que la animación se vea con antialiasing y si es false desactiva el antialiasing.
 368  */
 369 void PaintArea::setAntialiasing(bool use)
 370 {
 371 #ifdef QT_OPENGL_LIB
 372         if ( QGLWidget *gl = dynamic_cast<QGLWidget *>(viewport() ) )
 373         {
 374                 gl->setUpdatesEnabled(false); // works better
 375                 gl->setFormat(QGLFormat(QGL::SampleBuffers | QGL::HasOverlay /*| QGL::DirectRendering | QGL::AccumBuffer | QGL::Rgba */));
 376                 gl->setUpdatesEnabled(true);
 377         }
 378 #endif
 379
 380         setRenderHint(QPainter::Antialiasing, use);
 381         setRenderHint(QPainter::TextAntialiasing, use);
 382 }
 383
 384 /**
 385  * @~spanish
 386  * Si @p opengl es verdadero activa el uso de openGl para dibujar el fotograma.
 387  */
 388 void PaintArea::setUseOpenGL(bool opengl)
 389 {
 390         D_FUNCINFO << opengl;
 391
 392         QCursor cursor(Qt::ArrowCursor);
 393         if ( viewport() )
 394         {
 395                 cursor = viewport()->cursor();
 396         }
 397
 398 #ifdef QT_OPENGL_LIB
 399         if ( opengl )
 400         {
 401                 setViewport(new GLDevice());
 402         }
 403         else
 404         {
 405 //              setViewport( new KTImageDevice() );
 406         }
 407 #else
 408         Q_UNUSED(opengl);
 409         dWarning() << tr("OpenGL isn't supported");
 410 #endif
 411
 412         // to restore the cursor.
 413         if ( viewport() )
 414         {
 415                 viewport()->setCursor(cursor);
 416                 viewport()->setAcceptDrops(true);
 417         }
 418 }
 419
 420 /**
 421  * @~spanish
 422  * Si @p draw es verdadero activa el dibujo de una grilla guia en el area, y si es falso la desactiva.
 423  * Por defecto no se dibuja la grilla.
 424  */
 425 void PaintArea::setDrawGrid(bool draw)
 426 {
 427         d->drawGrid = draw;
 428 //      resetCachedContent();
 429         viewport()->update();
 430 }
 431
 432 /**
 433  * @~spanish
 434  * Se asigna la herramienta @p tool como la herramienta actual.
 435  */
 436 void PaintArea::setTool(AbstractTool *tool )
 437 {
 438         if ( !scene() ) return;
 439
 440         QCursor cursor = tool->action()->cursor();
 441         if( (!cursor.pixmap().isNull() && cursor.mask() != 0 && cursor.shape() == Qt::BitmapCursor && cursor.bitmap() != 0 ) || cursor.shape() != Qt::BitmapCursor )
 442                 viewport()->setCursor(cursor);
 443
 444         d->toolsConfigBar->clear();
 445         tool->setupConfigBar(d->toolsConfigBar);
 446
 447         d->photogram->setTool(tool);
 448 }
 449
 450 /**
 451  * @~spanish
 452  * Retorna si esta activo el dibujo de la grilla.
 453  */
 454 bool PaintArea::drawGrid() const
 455 {
 456         return d->drawGrid;
 457 }
 458
 459 void PaintArea::mousePressEvent( QMouseEvent * event )
 460 {
 461         if ( !canPaint() ) return;
 462
 463         QGraphicsItem *item = d->photogram->itemAt( mapToScene(event->pos()) );
 464
 465         d->effectsConfigBar->clear();
 466         if( item )
 467         {
 468                 if( YAMF::Effect::Filter *filter = dynamic_cast<YAMF::Effect::Filter *>(item) )
 469                 {
 470                         filter->setupConfigBar(d->effectsConfigBar);
 471                 }
 472         }
 473
 474         if ( event->buttons() == Qt::RightButton )
 475         {
 476
 477                 QMenu *menu = this->createMenu();
 478
 479                 if( item )
 480                 {
 481                         // Add effects
 482                         {
 483                                 QMenu *effects = menu->addMenu(tr("Effects"));
 484
 485                                 QAction *blur = effects->addAction(tr("Blur"));
 486                                 blur->setData("blur");
 487
 488                                 QAction *swirl = effects->addAction(tr("Swirl"));
 489                                 swirl->setData("swirl");
 490
 491                                 connect(effects, SIGNAL(triggered(QAction *)), this, SLOT(applyFilter(QAction *)));
 492                         }
 493
 494                         item->setFlag(QGraphicsItem::ItemIsSelectable, true);
 495                         item->setSelected(true);
 496
 497                         menu->addAction(d->actionManager.find("recorditem", "item"));
 498                 }
 499
 500                 if( d->photogram->recorded() )
 501                 {
 502                         menu->addAction(d->actionManager.find("stoprecorditem", "item"));
 503                 }
 504
 505                 menu->addSeparator();
 506
 507                 if( qgraphicsitem_cast<Model::LibraryItem *>(item) )
 508                 {
 509                         menu->addAction(d->actionManager.find("applysymbol", "library"));
 510                 }
 511                 else
 512                 {
 513                         menu->addAction(d->actionManager.find("addtolibrary", "library"));
 514                 }
 515
 516                 menu->addSeparator();
 517
 518                 checkActions();
 519
 520                 menu->exec(event->globalPos());
 521
 522                 delete menu;
 523         }
 524         else
 525         {
 526                 d->photogram->aboutToMousePress();
 527                 QGraphicsView::mousePressEvent(event);
 528         }
 529
 530         foreach(QGraphicsItem *item , d->photogram->selectedItems() )
 531         {
 532                 if( item->flags() & QGraphicsItem::ItemIsMovable )
 533                 {
 534                         Private::ItemProperties prop;
 535                         prop.item = item;
 536
 537                         QDomDocument doc;
 538                         doc.appendChild(Item::Serializer::properties(item, doc));
 539
 540                         prop.properties = doc.toString();
 541                         d->properties << prop;
 542                 }
 543         }
 544 }
 545
 546 void PaintArea::mouseMoveEvent( QMouseEvent * event )
 547 {
 548         if ( !canPaint()) return;
 549
 550         // Rotate
 551         if( !d->photogram->isDrawing() && event->buttons() == Qt::LeftButton &&  (event->modifiers () == (Qt::ShiftModifier | Qt::ControlModifier)))
 552         {
 553                 setUpdatesEnabled(false);
 554
 555                 QGraphicsView::DragMode dragMode = this->dragMode();
 556                 setDragMode(QGraphicsView::NoDrag);
 557
 558                 QPointF p1 = event->pos();
 559                 QPointF p2 = d->drawingRect.center();
 560
 561                 d->rotator->rotateTo( (int)(-(180*DGraphics::Algorithm::angleForPos(p1,p2))/M_PI) );
 562
 563                 setDragMode(dragMode);
 564
 565                 setUpdatesEnabled(true);
 566         }
 567         else
 568         {
 569                 QGraphicsView::mouseMoveEvent(event);
 570
 571                 if( !d->photogram->mouseGrabberItem() && d->photogram->isDrawing() ) // HACK
 572                 {
 573                         QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseMove);
 574                         mouseEvent.setWidget(viewport());
 575
 576                         mouseEvent.setPos( event->pos() );
 577                         mouseEvent.setScenePos(mapToScene(event->pos()));
 578
 579                         mouseEvent.setScreenPos(event->globalPos());
 580                         mouseEvent.setButtons(event->buttons());
 581                         mouseEvent.setButton(event->button());
 582                         mouseEvent.setModifiers(event->modifiers());
 583                         mouseEvent.setAccepted(false);
 584                         d->photogram->mouseMoved(&mouseEvent);
 585                 }
 586         }
 587
 588         emit cursorMoved( mapToScene( event->pos() ) );
 589 }
 590
 591 void PaintArea::mouseReleaseEvent(QMouseEvent *event)
 592 {
 593         QGraphicsView::mouseReleaseEvent(event);
 594
 595         if( ! d->photogram->mouseGrabberItem() && d->photogram->isDrawing() ) // HACK
 596         {
 597                 QGraphicsSceneMouseEvent mouseEvent(QEvent::GraphicsSceneMouseRelease);
 598                 mouseEvent.setWidget(viewport());
 599                 mouseEvent.setPos( event->pos() );
 600                 mouseEvent.setScenePos(mapToScene(event->pos()));
 601                 mouseEvent.setScreenPos(event->globalPos());
 602                 mouseEvent.setButtons(event->buttons());
 603                 mouseEvent.setButton(event->button());
 604                 mouseEvent.setModifiers(event->modifiers());
 605                 mouseEvent.setAccepted(false);
 606 //              QApplication::sendEvent(d->photogram, &mouseEvent);
 607                 d->photogram->mouseReleased(&mouseEvent);
 608         }
 609
 610
 611         Model::Object *recorded = d->photogram->recorded();
 612         QGraphicsItem *ritem = 0;
 613         if( recorded )
 614         {
 615                 ritem = recorded->item();
 616         }
 617
 618         foreach(Private::ItemProperties prop, d->properties)
 619         {
 620                 if(currentFrame()->logicalIndexOf(prop.item) > -1 || ritem == prop.item)
 621                 {
 622                         QDomDocument doc;
 623                         doc.appendChild(Item::Serializer::properties(prop.item, doc));
 624
 625
 626                         if( prop.item == ritem )
 627                         {
 628                                 d->recordIt();
 629                         }
 630                         else if( doc.toString() != prop.properties )
 631                         {
 632                                 Command::ModifyItem *current = new Command::ModifyItem( prop.item, prop.properties, currentFrame() );
 633                                 addCommand( current );
 634                         }
 635                 }
 636         }
 637
 638         d->properties.clear();
 639
 640         checkActions();
 641 }
 642
 643 void PaintArea::tabletEvent( QTabletEvent * event )
 644 {
 645         QGraphicsView::tabletEvent(event );
 646 }
 647
 648 /**
 649  * Función reimplementada para dibujar el fondo del area de dibujo, mostrando el area que va a aparecer en la animación y la grilla si esta activa la opción.
 650  */
 651 void PaintArea::drawBackground(QPainter *painter, const QRectF &rect)
 652 {
 653         QGraphicsView::drawBackground(painter, rect);
 654
 655         if( ! currentFrame() ) return;
 656
 657         painter->save();
 658
 659         bool hasAntialiasing = painter->renderHints() & QPainter::Antialiasing;
 660
 661         painter->setRenderHint(QPainter::Antialiasing, false);
 662
 663         painter->setPen( QPen(QColor(0,0,0,180), 3) );
 664
 665         painter->fillRect( d->drawingRect, Qt::white );
 666         painter->drawRect( d->drawingRect );
 667
 668         QPointF origin = painter->matrix().map(QPoint(0, 0));
 669
 670         if( origin != d->origin )
 671         {
 672                 d->origin = origin;
 673                 emit originChanged( d->origin );
 674         }
 675
 676         if ( d->drawGrid )
 677         {
 678                 int sx = (int)painter->matrix().m11();
 679                 int sy = (int)painter->matrix().m22();
 680
 681                 painter->resetMatrix();
 682                 painter->scale(sx, sy);
 683                 painter->setPen( QPen(QColor(0,0,180, 50), 1) );
 684
 685                 for(int i = 0; i < qMax(width(), height()); i+= 10 )
 686                 {
 687                         painter->drawLine(i, 0, i, height() );
 688                         painter->drawLine(0, i, width(), i );
 689                 }
 690         }
 691
 692         painter->setRenderHint(QPainter::Antialiasing, hasAntialiasing);
 693
 694
 695         painter->restore();
 696 }
 697
 698 /**
 699  * @~spanish
 700  * Función reimplementada para mostrar si el frame actual esta bloqueado.
 701  */
 702 void PaintArea::drawForeground( QPainter *painter, const QRectF &rect )
 703 {
 704         if ( Model::Frame *frame = currentFrame() )
 705         {
 706                 if ( frame->isLocked() )
 707                 {
 708                         painter->fillRect(rect, QColor(201,201,201, 200));
 709
 710                         painter->setFont(QFont("Arial", 30) );
 711                         QFontMetricsF fm(painter->font());
 712                         QString text = tr("Locked");
 713
 714                         painter->drawText(QPointF(d->photogram->sceneRect().topRight().x() - fm.width(text), (d->photogram->sceneRect().topRight().y() + fm.height()) / 2), text);
 715                 }
 716         }
 717 }
 718
 719 /**
 720  * @~spanish
 721  * Retorna verdadero si se puede dibujar sobre el area de dibujo y falso si no.
 722  */
 723 bool PaintArea::canPaint() const
 724 {
 725         if( d->photogram )
 726         {
 727                 Model::Frame *frame = currentFrame();
 728
 729                 if( frame )
 730                 {
 731                         return !frame->isLocked() && !frame->layer()->isLocked();
 732                 }
 733         }
 734
 735         return false;
 736 }
 737
 738 /**
 739  * @~spanish
 740  * Centra la vista del fotograma.
 741  */
 742 void PaintArea::centerDrawingArea()
 743 {
 744         centerOn(d->drawingRect.center());
 745 }
 746
 747 /**
 748  * @internal
 749  */
 750 void PaintArea::onHistoryChanged()
 751 {
 752         if( Model::Scene *scene = d->photogram->scene() )
 753         {
 754                 if( scene->logicalIndex() < 0 )
 755                         d->photogram->setCurrentScene(0);
 756         }
 757
 758         d->photogram->drawCurrentPhotogram();
 759         viewport()->update();
 760 }
 761
 762 /**
 763  * @internal
 764  */
 765 void PaintArea::applyFilter(QAction *act)
 766 {
 767         QList<QGraphicsItem *> selected = d->photogram->selectedItems();
 768
 769         if( selected.isEmpty() ) return;
 770
 771         QGraphicsItem *item = selected.first();
 772         QString filter = act->data().toString();
 773         Model::Frame *frame = currentFrame();
 774
 775         if( frame && item && !filter.isEmpty())
 776         {
 777                 Model::Object *object = frame->graphic(frame->logicalIndexOf(item));
 778
 779                 if( object )
 780                 {
 781                         YAMF::Effect::Filter *effect = YAMF::Effect::Factory::create(filter);
 782
 783                         d->effectsConfigBar->clear();
 784                         effect->setupConfigBar(d->effectsConfigBar);
 785
 786
 787                         YAMF::Command::AddItemFilter *cmd = new YAMF::Command::AddItemFilter(object, effect);
 788                         addCommand(cmd);
 789                 }
 790         }
 791 }
 792
 793 void PaintArea::wheelEvent(QWheelEvent *event)
 794 {
 795         if(event->modifiers () == Qt::ControlModifier)
 796         {
 797                 scaleView(pow(( double)2, -event->delta() / 240.0));
 798         }
 799         else
 800         {
 801                 QGraphicsView::wheelEvent(event);
 802         }
 803 }
 804
 805 bool PaintArea::viewportEvent(QEvent *e)
 806 {
 807         bool ret = QGraphicsView::viewportEvent(e);
 808
 809         if( e->type() == QEvent::Show )
 810         {
 811                 if( d->photogram->items().isEmpty() )
 812                 {
 813                         d->photogram->drawCurrentPhotogram();
 814                 }
 815         }
 816
 817         return ret;
 818 }
 819
 820 /**
 821  * @~spanish
 822  * Escala la vista sobre el fotograma en un factor  @p scaleFactor.
 823  */
 824 void PaintArea::scaleView(double scaleFactor)
 825 {
 826         qreal factor = matrix().scale(scaleFactor, scaleFactor).mapRect(QRectF(0, 0, 1, 1)).width();
 827         if (factor < 0.07 || factor > 100)
 828                 return;
 829
 830
 831         d->lastScaleFactor *= scaleFactor;
 832         scale(scaleFactor, scaleFactor);
 833
 834         emit scaled(d->lastScaleFactor);
 835 }
 836
 837 /**
 838  * @~spanish
 839  * Hace aumento sobre el fotograma actual en un porcentaje  @p percent.
 840  */
 841 void PaintArea::setZoom(int percent)
 842 {
 843         double factor = (double)percent / 100.0;
 844
 845         if( factor == d->lastScaleFactor ) return;
 846
 847         double restoreFactor = 1.0/d->lastScaleFactor;
 848
 849         if( d->lastScaleFactor > 1.0 )
 850         {
 851                 scale(restoreFactor, restoreFactor);
 852         }
 853         else if ( d->lastScaleFactor < 1.0)
 854         {
 855                 scale(restoreFactor, restoreFactor);
 856         }
 857
 858         d->lastScaleFactor = factor;
 859
 860         scale(factor, factor);
 861
 862         emit scaled(factor);
 863 }
 864
 865 /**
 866  * @~spanish
 867  * Rota la vista sobre el fotograma.
 868  */
 869 void PaintArea::setRotationAngle(int angle)
 870 {
 871         rotate(angle - d->angle );
 872         d->angle = angle;
 873 }
 874
 875 /**
 876  * @~spanish
 877  * Retorna el manejador de brochas del area de dibujo.
 878  */
 879 BrushManager *PaintArea::brushManager() const
 880 {
 881         return d->photogram->brushManager();
 882 }
 883
 884 /**
 885  * @~spanish
 886  * Retorna el area en la cual va aparecer en la animación.
 887  */
 888 QRectF PaintArea::drawingRect() const
 889 {
 890         return d->drawingRect;
 891 }
 892
 893 /**
 894  * @~spanish
 895  * Retorna el fotograma actual.
 896  */
 897 Photogram *PaintArea::photogram() const
 898 {
 899         return d->photogram;
 900 }
 901
 902 /**
 903  * @~spanish
 904  * Cambia el frame actual.
 905  */
 906 void PaintArea::setCurrentFrame(int sceneIndex, int layerIndex, int frameIndex)
 907 {
 908 //      dfDebug << "scene = " << sceneIndex << " layer = " << layerIndex << "frame = " << frameIndex;
 909         Model::Scene *scene = d->project->scene(sceneIndex);
 910
 911 //      if( scene )
 912         {
 913                 d->photogram->setCurrentScene(scene);
 914                 d->photogram->setCurrent(frameIndex);
 915                 d->framePosition.layer = layerIndex;
 916                 d->framePosition.frame = frameIndex;
 917         }
 918         d->photogram->drawCurrentPhotogram();
 919         viewport()->update();
 920 }
 921
 922 /**
 923  * @~spanish
 924  * Retorna el proyecto asociado al area de dibujo.
 925  */
 926 Model::Project *PaintArea::project() const
 927 {
 928         return d->project;
 929 }
 930
 931 /**
 932  * @~spanish
 933  * Retorna la escena actual.
 934  */
 935 Model::Scene *PaintArea::currentScene() const
 936 {
 937         return d->photogram->scene();
 938 }
 939
 940 /**
 941  * @~spanish
 942  * Retorna la capa actual.
 943  */
 944 Model::Layer *PaintArea::currentLayer() const
 945 {
 946         Model::Scene *scene = d->photogram->scene();
 947
 948         if( scene )
 949         {
 950                 return scene->layer(d->framePosition.layer);
 951         }
 952
 953
 954         return 0;
 955 }
 956
 957 /**
 958  * @~spanish
 959  * Retorna el frame actual.
 960  */
 961 Model::Frame *PaintArea::currentFrame() const
 962 {
 963         Model::Layer *layer = currentLayer();
 964
 965         if( layer )
 966         {
 967                 return layer->frame(d->framePosition.frame);
 968         }
 969
 970
 971         return 0;
 972 }
 973
 974 /**
 975  * @~spanish
 976  *
 977  */
 978 void PaintArea::addCommand(Command::Base *command)
 979 {
 980         d->project->commandManager()->addCommand(command);
 981 }
 982
 983 /**
 984  * @~spanish
 985  * Retorna la historia de comandos
 986  * @return
 987  */
 988 DGui::CommandHistory *PaintArea::history() const
 989 {
 990         return d->history;
 991 }
 992
 993 /**
 994  * @~spanish
 995  * Retorna la acción que permite remover los elementos seleccionados en el area.
 996  * @return
 997  */
 998 QAction *PaintArea::removeAction()
 999 {
1000         return d->actionManager.find("remove", "edit");
1001 }
1002
1003 /**
1004  * @~spanish
1005  * Retorna la acción que permite agrupar los elementos seleccionados en el area.
1006  * @return
1007  */
1008 QAction *PaintArea::groupAction()
1009 {
1010         return d->actionManager.find("group", "object");
1011 }
1012
1013 /**
1014  * @~spanish
1015  * Retorna la acción que permite des-agrupar los elementos seleccionados en el area.
1016  * @return
1017  */
1018 QAction *PaintArea::ungroupAction()
1019 {
1020         return d->actionManager.find("ungroup", "object");
1021 }
1022
1023 /**
1024  * @~spanish
1025  * Retorna la acción que permite enviar al fondo los elementos seleccionados en el area.
1026  * @return
1027  */
1028 QAction *PaintArea::sendToBackAction()
1029 {
1030         return d->actionManager.find( "sendtoback", "object-order");
1031 }
1032
1033 /**
1034  * @~spanish
1035  * Retorna la acción que permite enviar al frente los elementos seleccionados en el area.
1036  * @return
1037  */
1038 QAction *PaintArea::bringToFrontAction()
1039 {
1040         return d->actionManager.find( "bringtofront", "object-order");
1041 }
1042
1043
1044 /**
1045  * @~spanish
1046  * Retorna la acción que permite enviar hacia atras una unidad los elementos seleccionados en el area.
1047  * @return
1048  */
1049 QAction *PaintArea::sendBackwardsAction()
1050 {
1051         return d->actionManager.find( "sendbackwards", "object-order");
1052 }
1053
1054 /**
1055  * @~spanish
1056  * Retorna la acción que permite enviar hacia adelante una unidad los elementos seleccionados en el area.
1057  */
1058 QAction *PaintArea::bringForwardsAction()
1059 {
1060         return d->actionManager.find( "bringforwards", "object-order");
1061 }
1062
1063 /**
1064  * @~spanish
1065  * Retorna la acción que permite copiar los elementos seleccionados en el area.
1066  */
1067 QAction *PaintArea::copyAction()
1068 {
1069         return d->actionManager.find( "copy", "edit");
1070 }
1071
1072 /**
1073  * @~spanish
1074  * Retorna la acción que permite pegar los elementos que estan en el portapapeles en el area.
1075  */
1076 QAction *PaintArea::pasteAction()
1077 {
1078         return d->actionManager.find( "paste", "edit");
1079 }
1080
1081 /**
1082  * @~spanish
1083  * Retorna la acción que permite cortar los elementos seleccionados en el area.
1084  */
1085 QAction *PaintArea::cutAction()
1086 {
1087         return d->actionManager.find( "cut", "edit");
1088 }
1089
1090 /**
1091  * @~spanish
1092  * Retorna la acción que permite seleccionar todos los elementos en el area.
1093  */
1094 QAction *PaintArea::selectAllAction()
1095 {
1096         return d->actionManager.find("selectall", "edit");
1097 }
1098
1099 /**
1100  * @~spanish
1101  * Crea el menu contextual de el area de dibujo.
1102  */
1103 QMenu *PaintArea::createMenu()
1104 {
1105         QMenu *menu = new QMenu(tr("Drawing area"), this);
1106
1107         Command::Manager *manager = d->project->commandManager();
1108
1109         menu->addAction(d->history->undoAction()->icon(), d->history->undoAction()->text(), d->history, SLOT(undo()))->setEnabled(d->history->undoAction()->isEnabled());
1110         menu->addAction(d->history->redoAction()->icon(), d->history->redoAction()->text(), d->history, SLOT(redo()))->setEnabled(d->history->redoAction()->isEnabled());
1111
1112         menu->addSeparator();
1113         d->actionManager.setupMenu(menu, "edit", false);
1114         menu->addSeparator();
1115
1116         QMenu *order = new QMenu(tr("Order"));
1117         d->actionManager.setupMenu(order, "object-order");
1118
1119         menu->addMenu (order);
1120         menu->addSeparator();
1121
1122         if ( AbstractTool *tool = d->photogram->currentTool() )
1123         {
1124                 if( QMenu *toolMenu = tool->menu() )
1125                 {
1126                         menu->addSeparator();
1127                         menu->addMenu(toolMenu);
1128                 }
1129         }
1130
1131         return menu;
1132 }
1133
1134 /**
1135  * @~spanish
1136  * Retorna la barra de herramientas que provee la interfaz grafica para la configuración de las herramientas.
1137  */
1138 QToolBar *PaintArea::toolsConfigBar() const
1139 {
1140         return d->toolsConfigBar;
1141 }
1142
1143 /**
1144  * @~spanish
1145  * Retorna la barra de herramientas que provee la interfaz grafica para la configuración de los efectos.
1146  */
1147 QToolBar *PaintArea::effectsConfigBar() const
1148 {
1149         return d->effectsConfigBar;
1150 }
1151
1152 void PaintArea::checkActions()
1153 {
1154         if(! scene()->selectedItems().isEmpty())
1155         {
1156                 d->actionManager.setEnabled("object-order", true);
1157                 d->actionManager.find("remove", "edit")->setEnabled(true);
1158                 d->actionManager.find("cut", "edit")->setEnabled(true);
1159                 d->actionManager.find("copy", "edit")->setEnabled(true);
1160                 d->actionManager.find("addtolibrary", "library")->setEnabled(true);
1161         }
1162         else
1163         {
1164                 d->actionManager.setEnabled("object-order", false);
1165                 d->actionManager.find("remove", "edit")->setEnabled(false);
1166                 d->actionManager.find("cut", "edit")->setEnabled(false);
1167                 d->actionManager.find("copy", "edit")->setEnabled(false);
1168                 d->actionManager.find("addtolibrary", "library")->setEnabled(false);
1169         }
1170
1171         QString xml = QApplication::clipboard()->mimeData()->data("yamf-graphics");
1172         if ( !xml.isEmpty() )
1173         {
1174                 d->actionManager.find("paste", "edit")->setEnabled(true);
1175         }
1176         else
1177         {
1178                 d->actionManager.find("paste", "edit")->setEnabled(false);
1179         }
1180 }
1181
1182 /**
1183  * @~spanish
1184  * Remueve los elementos seleccionados.
1185  */
1186 void PaintArea::removeSelectedObjects()
1187 {
1188         QList<QGraphicsItem *> items = d->photogram->selectedItems();
1189         if( items.count() > 0 )
1190         {
1191                 currentFrame()->removeItems(items);
1192                 this->checkActions();
1193         }
1194 }
1195
1196
1197 /**
1198  * @~spanish
1199  * Agrupa los elementos seleccionados.
1200  */
1201 void PaintArea::groupSelectedObjects()
1202 {
1203         QList<QGraphicsItem *> items = d->photogram->selectedItems();
1204         if( items.count() > 0 )
1205         {
1206                 addCommand(new Command::GroupItem(items, currentFrame()));
1207         }
1208 }
1209
1210 /**
1211  * @~spanish
1212  * Desagrupa los elementos seleccionados.
1213  */
1214 void PaintArea::ungroupSelectedObject()
1215 {
1216         QList<QGraphicsItem *> items = d->photogram->selectedItems();
1217         QList<Item::Group *> groups;
1218
1219         Model::Frame *frame = currentFrame();
1220
1221         foreach(QGraphicsItem *item, items)
1222         {
1223                 if( Item::Group *group = qgraphicsitem_cast<Item::Group *>(item) )
1224                 {
1225                         addCommand(new Command::UngroupItem(group, currentFrame()));
1226                 }
1227         }
1228 }
1229
1230 /**
1231  * @~spanish
1232  * Envia atras los elementos seleccionados.
1233  */
1234 void PaintArea::sendToBackSelectedObjects()
1235 {
1236         QList<QGraphicsItem *> items = photogram()->selectedItems();
1237
1238         DGraphics::Algorithm::sort(items, DGraphics::Algorithm::ZAxis);
1239
1240         Model::Frame *frame = currentFrame();
1241         foreach(QGraphicsItem *item, items )
1242         {
1243                 addCommand(new Command::SendToBackItem(frame->graphic(item)));
1244         }
1245 }
1246
1247 /**
1248  * @~spanish
1249  * Trae adelante los elementos seleccionados.
1250  */
1251 void PaintArea::bringToFrontSelectedObjects()
1252 {
1253         QList<QGraphicsItem *> items = photogram()->selectedItems();
1254
1255         DGraphics::Algorithm::sort(items, DGraphics::Algorithm::ZAxis);
1256
1257         QList<QGraphicsItem *>::iterator it = items.end();
1258
1259         Model::Frame *frame = currentFrame();
1260
1261         while(it != items.begin())
1262         {
1263                 --it;
1264                 addCommand(new Command::BringToFrontItem(frame->graphic(*it)));
1265         }
1266 }
1267
1268 /**
1269  * @~spanish
1270  * Envia atras una unidad los elementos seleccionados.
1271  */
1272 void PaintArea::sendBackwardsSelectedObjects()
1273 {
1274         QList<QGraphicsItem *> items = photogram()->selectedItems();
1275
1276         DGraphics::Algorithm::sort(items, DGraphics::Algorithm::ZAxis);
1277
1278         Model::Frame *frame = currentFrame();
1279         foreach(QGraphicsItem *item, items )
1280         {
1281                 addCommand(new Command::SendBackwardsItem(frame->graphic(item)));
1282         }
1283 }
1284
1285
1286 /**
1287  * @~spanish
1288  * Trae al frente una unidad los elementos seleccionados.
1289  */
1290 void PaintArea::bringForwardsSelectedObjects()
1291 {
1292         QList<QGraphicsItem *> items = photogram()->selectedItems();
1293
1294         DGraphics::Algorithm::sort(items, DGraphics::Algorithm::ZAxis);
1295
1296         QList<QGraphicsItem *>::iterator it = items.end();
1297
1298         Model::Frame *frame = currentFrame();
1299
1300         while(it != items.begin())
1301         {
1302                 --it;
1303                 addCommand(new Command::BringForwardsItem(frame->graphic(*it)));
1304         }
1305 }
1306
1307 /**
1308  * @~spanish
1309  * Copia los elementos seleccionados.
1310  */
1311 void PaintArea::copySelectedObjects()
1312 {
1313         QList<QGraphicsItem *> selecteds = scene()->selectedItems();
1314
1315         QDomDocument orig;
1316         QDomElement root = orig.createElement("yamf-graphics");
1317
1318         foreach(QGraphicsItem *item, selecteds)
1319         {
1320                 int index = currentFrame()->logicalIndexOf( item );
1321
1322                 if(index > -1)
1323                 {
1324                         Model::Object *graphic = currentFrame()->graphic(index);
1325                         root.appendChild(graphic->toXml( orig ));
1326                 }
1327         }
1328
1329         orig.appendChild(root);
1330
1331         QMimeData *mimeData = new QMimeData;
1332
1333         mimeData->setData("yamf-graphics", orig.toString().toLocal8Bit());
1334         //TODO: image/svg+xml
1335         QApplication::clipboard()->setMimeData( mimeData );
1336 }
1337
1338 /**
1339  * @~spanish
1340  * Pega los elementos en el portapapeles.
1341  */
1342 void PaintArea::pasteObjects()
1343 {
1344         if( !currentFrame() ) return;
1345
1346         const QMimeData *mimeData = QApplication::clipboard()->mimeData();
1347
1348         QString xml = mimeData->data("yamf-graphics");
1349
1350         QDomDocument doc;
1351         if(!doc.setContent(xml))
1352         {
1353                 return;
1354         }
1355
1356         // TODO: image/svg+xml
1357
1358         QDomElement docElem = doc.documentElement();
1359         QDomNode n = docElem.firstChild();
1360
1361         while(!n.isNull())
1362         {
1363                 QDomElement e = n.toElement();
1364                 if(!e.isNull())
1365                 {
1366                         QString xml;
1367                         QTextStream ts(&xml);
1368                         ts << e;
1369
1370                         Model::Object *object = new Model::Object(currentFrame());
1371                         object->fromXml(xml);
1372
1373                         currentFrame()->addObject(object);
1374                 }
1375                 n = n.nextSibling();
1376         }
1377         d->photogram->drawCurrentPhotogram();
1378 }
1379
1380 /**
1381  * @~spanish
1382  * Corta los elementos seleccionados.
1383  */
1384 void PaintArea::cutSelectedObjects()
1385 {
1386         copySelectedObjects();
1387         removeSelectedObjects();
1388 }
1389
1390 /**
1391  * @~spanish
1392  * Selecciona todos los elementos en el area.
1393  */
1394 void PaintArea::selectAllObjects()
1395 {
1396         foreach(QGraphicsItem *item, photogram()->items() )
1397         {
1398                 item->setFlag(QGraphicsItem::ItemIsSelectable);
1399                 item->setSelected(true);
1400         }
1401 }
1402
1403 /**
1404  * @~spanish
1405  * Añade lso elementos seleccionados a la biblioteca de objetos.
1406  */
1407 void PaintArea::addToLibrary()
1408 {
1409         QList<QGraphicsItem *> selecteds = scene()->selectedItems();
1410
1411         if ( selecteds.isEmpty() )
1412         {
1413                 DGui::Osd::self()->display(tr("No items selected"), DGui::Osd::Error);
1414                 return;
1415         }
1416
1417         YAMF::Drawing::Private::AddSymbolDialog addSymbolDialog;
1418
1419         YAMF::Model::Library *library = d->project->library();
1420
1421         QList<QGraphicsItem *> symbols;
1422
1423         foreach(QGraphicsItem *item, selecteds)
1424         {
1425                 if( YAMF::Common::AbstractSerializable *serializable = dynamic_cast<YAMF::Common::AbstractSerializable *>(item) )
1426                 {
1427                         addSymbolDialog.addSymbol(item);
1428                 }
1429         }
1430
1431         if( addSymbolDialog.exec() == QDialog::Accepted )
1432         {
1433                 for(int i = 0; i < addSymbolDialog.symbolCount(); i++)
1434                 {
1435                         library->addItemSymbol(addSymbolDialog.symbol(i), addSymbolDialog.symbolName(i));
1436                 }
1437         }
1438 }
1439
1440 void PaintArea::applyCurrentSymbol()
1441 {
1442         if( d->photogram->selectedItems().count() > 0 )
1443         {
1444                 if( Model::LibraryItem *libraryItem = qgraphicsitem_cast<Model::LibraryItem *>( d->photogram->selectedItems().first()) )
1445                 {
1446                         YAMF::Command::ModifySymbol *cmd = new YAMF::Command::ModifySymbol(libraryItem);
1447
1448                         addCommand(cmd);
1449                 }
1450         }
1451 }
1452
1453 /**
1454  * @~spanish
1455  * Añade un simbolo de la biblioteca identificado con @p id a el area .
1456  */
1457 void PaintArea::addSymbol(const QString &id)
1458 {
1459         YAMF::Model::LibraryObject *object = d->project->library()->findObject(id);
1460         if( object )
1461         {
1462                 addSymbol(object);
1463         }
1464 }
1465
1466 /**
1467  * @~spanish
1468  * Añade un simbolo @p object de la biblioteca a el area .
1469  */
1470 void PaintArea::addSymbol(YAMF::Model::LibraryObject *object)
1471 {
1472         YAMF::Model::Frame *frame = currentFrame();
1473         YAMF::Model::Scene *scene = currentScene();
1474
1475         switch(object->type())
1476         {
1477                 case YAMF::Model::LibraryObject::Sound:
1478                 {
1479                         Model::LibrarySoundObject *soundObject = dynamic_cast<Model::LibrarySoundObject *>(object);
1480                         if ( scene != 0 )
1481                         {
1482                                 YAMF::Model::AudioLayer *layer = scene->createAudioLayer();
1483                                 layer->fromSymbol(soundObject);
1484                         }
1485                 }
1486                 break;
1487                 case YAMF::Model::LibraryObject::Svg:
1488                 case YAMF::Model::LibraryObject::Item:
1489                 case YAMF::Model::LibraryObject::Image:
1490                 case YAMF::Model::LibraryObject::Text:
1491                 {
1492                         if( frame != 0 )
1493                         {
1494                                 YAMF::Model::LibraryItem *item = new YAMF::Model::LibraryItem(object);
1495                                 frame->addItem(item);
1496                         }
1497                 }
1498                 break;
1499         }
1500 }
1501
1502 /**
1503  * @~spanish
1504  */
1505 void PaintArea::recordItem()
1506 {
1507         Model::Frame *frame = currentFrame();
1508
1509         if( frame && d->photogram->selectedItems().count() > 0 )
1510         {
1511                 QGraphicsItem *item = d->photogram->selectedItems().first();
1512
1513                 int logicalIndex = frame->logicalIndexOf(item);
1514
1515                 if( logicalIndex > -1 )
1516                 {
1517                         d->photogram->recordObject(frame->graphic(logicalIndex));
1518
1519                         d->recordIt();
1520                 }
1521         }
1522 }
1523
1524 /**
1525  * @~spanish
1526  */
1527 void PaintArea::stopRecordItem()
1528 {
1529         Model::Object *object = d->photogram->recorded();
1530         Model::Frame *frame = currentFrame();
1531
1532         int framePos = frame->visualIndex();
1533         int objectPos = object->frame()->visualIndex();
1534
1535         if( object && framePos > objectPos )
1536         {
1537                 int stepsCount = framePos - objectPos;
1538
1539                 Item::Tweener *tweener = new Item::Tweener(stepsCount, object);
1540
1541                 foreach(Private::RecordStep rs, d->steps)
1542                 {
1543                         tweener->addStep(*rs.step);
1544                         delete rs.step;
1545                 }
1546
1547                 object->setTweener(tweener);
1548
1549
1550                 d->photogram->recordObject(0);
1551                 d->steps.clear();
1552         }
1553 }
1554
1555 }
1556 }
1557