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