yamf/drawing/photogram.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by David Cuadrado                                  *
   3  *   krawek@gmail.com                                                     *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "photogram.h"
  22
  23 #include <QGraphicsItem>
  24 #include <QGraphicsView>
  25 #include <QStyleOptionGraphicsItem>
  26 #include <QGraphicsSceneMouseEvent>
  27 #include <QKeyEvent>
  28 #include <QSet>
  29
  30 #include <model/scene.h>
  31 #include <model/layer.h>
  32 #include <model/frame.h>
  33 #include <model/object.h>
  34
  35 #include "item/group.h"
  36
  37
  38 #include <drawing/abstracttool.h>
  39 #include <drawing/brushmanager.h>
  40 #include <drawing/paintarea.h>
  41
  42 #include "item/tweener.h"
  43
  44 #include <dcore/debug.h>
  45
  46 #include <private/guide.h>
  47
  48 namespace YAMF {
  49 namespace Drawing {
  50
  51 struct Photogram::Private
  52 {
  53         Private() : tool(0), scene(0), position(0), isDrawing(false) {}
  54
  55         AbstractTool *tool;
  56         Model::Scene *scene;
  57         struct OnionSkin
  58         {
  59                 int previous;
  60                 int next;
  61                 QHash<QGraphicsItem *, double> opacityMap;
  62         } onionSkin;
  63
  64         int position;
  65
  66         bool isDrawing;
  67         BrushManager *brushManager;
  68         PaintArea *paintArea;
  69
  70         QList<YAMF::Drawing::Private::Guide *> guides;
  71 };
  72
  73 /**
  74  * @~spanish
  75  * Construye un fotograma.
  76  */
  77 Photogram::Photogram(PaintArea *parent) : QGraphicsScene(parent), d(new Private)
  78 {
  79         d->paintArea = parent;
  80
  81         setItemIndexMethod(QGraphicsScene::NoIndex);
  82
  83         d->onionSkin.next = 0;
  84         d->onionSkin.previous = 0;
  85         d->isDrawing = false;
  86
  87         setBackgroundBrush(Qt::gray);
  88
  89         d->brushManager = new BrushManager(this);
  90 }
  91
  92
  93 /**
  94  * Destructor
  95  */
  96 Photogram::~Photogram()
  97 {
  98         D_END;
  99
 100         clearFocus();
 101         clearSelection();
 102
 103         foreach( QGraphicsView *view, this->views() )
 104         {
 105                 view->setScene(0);
 106         }
 107
 108         foreach(QGraphicsItem *item, items())
 109         {
 110                 removeItem(item);
 111         }
 112
 113         delete d->tool;
 114         delete d;
 115 }
 116
 117 /**
 118  * @~spanish
 119  * Asigna @p pos como la posición del fotograma.
 120  */
 121 void Photogram::setCurrent(int pos)
 122 {
 123         d->position = pos;
 124 }
 125
 126 /**
 127  * @~spanish
 128  * Dibuja el fotograma actual.
 129  */
 130 void Photogram::drawCurrentPhotogram()
 131 {
 132         drawPhotogram( d->position );
 133 }
 134
 135
 136
 137 /**
 138  * @~spanish
 139  * Función reimplementada para proveer la funcionalidad de papel cebolla.
 140  */
 141 void Photogram::drawItems(QPainter *painter, int numItems, QGraphicsItem *items[], const QStyleOptionGraphicsItem options[], QWidget *widget)
 142 {
 143         for (int i = 0; i < numItems; ++i)
 144         {
 145                 QGraphicsItem *item = items[i];
 146                 painter->save();
 147                 painter->setMatrix(item->sceneMatrix(), true);
 148
 149                 if ( d->onionSkin.opacityMap.contains(item) )
 150                 {
 151                         painter->setOpacity( d->onionSkin.opacityMap[item] );
 152                 }
 153
 154                 item->paint(painter, &options[i], widget);
 155
 156                 painter->restore();
 157         }
 158 }
 159
 160
 161 /**
 162  * @~spanish
 163  * Dibuja el fotograma de la posición @p photogram.
 164  */
 165 void Photogram::drawPhotogram(int photogram)
 166 {
 167         if ( photogram < 0 || !d->scene ) return;
 168
 169
 170         if( d->tool )
 171                 d->tool->aboutToChangePhotogram(this);
 172
 173         clean();
 174
 175         bool valid = false;
 176
 177         foreach(Model::Layer *layer, d->scene->layers().values())
 178         {
 179                 if ( layer->isVisible() )
 180                 {
 181                         if( d->onionSkin.previous > 0 )
 182                         {
 183                                 double opacityFactor = 0.5 / (double)qMin(layer->frames().count(),d->onionSkin.previous);
 184
 185                                 double opacity = 0.6;
 186
 187                                 for(int frameIndex = photogram-1; frameIndex > photogram-d->onionSkin.previous-1; frameIndex-- )
 188                                 {
 189                                         Model::Frame * frame = layer->frame(frameIndex);
 190                                         if(frame)
 191                                         {
 192                                                 addFrame( frame, opacity );
 193                                         }
 194                                         opacity -= opacityFactor;
 195                                 }
 196                         }
 197
 198                         if ( d->onionSkin.next > 0 )
 199                         {
 200                                 double opacityFactor = 0.5 / (double)qMin(layer->frames().count(), d->onionSkin.next);
 201                                 double opacity = 0.6;
 202
 203                                 for(int frameIndex = photogram+1; frameIndex < photogram+d->onionSkin.next+1; frameIndex++ )
 204                                 {
 205                                         Model::Frame * frame = layer->frame(frameIndex);
 206                                         if(frame)
 207                                         {
 208                                                 addFrame( frame, opacity );
 209                                         }
 210                                         opacity -= opacityFactor;
 211                                 }
 212                         }
 213
 214                         Model::Frame *frame = layer->frame( photogram );
 215
 216                         if( frame )
 217                         {
 218                                 valid = true;
 219                                 addFrame(frame);
 220                         }
 221                 }
 222         }
 223
 224         if( valid )
 225         {
 226                 foreach(Model::Object *obj, d->scene->alwaysVisible() )
 227                 {
 228                         if( obj->frame()->isVisible() )
 229                         {
 230                                 addItem(obj->item());
 231                         }
 232                 }
 233
 234                 foreach(Model::Object *object, d->scene->tweeningObjects())
 235                 {
 236                         if(object->frame()->layer()->isVisible() )
 237                         {
 238                                 int origin = object->frame()->visualIndex();
 239
 240                                 if( Item::Tweener *tweener = object->tweener() )
 241                                 {
 242                                         if( origin < photogram && photogram <= origin+tweener->frames() )
 243                                         {
 244                                                 tweener->setStep(0);
 245                                                 int step = photogram - origin;
 246
 247                                                 tweener->setStep(step);
 248
 249                                                 addGraphicObject(object);
 250                                         }
 251                                 }
 252                         }
 253                 }
 254
 255                 update();
 256         }
 257
 258         if( d->tool )
 259         {
 260                 d->tool->photogramChanged(this);
 261         }
 262 }
 263
 264 /**
 265  * @~spanish
 266  * Añade el frame al fotograma,si este es visible.
 267  */
 268 void Photogram::addFrame(Model::Frame *frame, double opacity )
 269 {
 270         if ( frame->isVisible() )
 271         {
 272                 foreach(Model::Object *object, frame->graphics().values() )
 273                 {
 274                         addGraphicObject(object, opacity);
 275                 }
 276         }
 277 }
 278
 279 /**
 280  * @~spanish
 281  * Añade el objeto grafico @p object al fotograma, con un factor de opacidad @p opacity.
 282  */
 283 void Photogram::addGraphicObject(Model::Object *object, double opacity)
 284 {
 285         QGraphicsItem *item = object->item();
 286
 287         if( item )
 288         {
 289                 d->onionSkin.opacityMap.insert(item, opacity);
 290
 291                 if ( Item::Group *group = qgraphicsitem_cast<Item::Group *>(item) )
 292                 {
 293                         group->recoverChilds();
 294                 }
 295
 296                 if( ! qgraphicsitem_cast<Item::Group *>(item->parentItem()))
 297                 {
 298                         addItem(item);
 299                 }
 300         }
 301 }
 302
 303 /**
 304  * @~spanish
 305  * Limpia el fotograma.
 306  */
 307 void Photogram::clean()
 308 {
 309         d->onionSkin.opacityMap.clear();
 310
 311         foreach(QGraphicsItem *item, items() )
 312         {
 313                 if ( item->scene() == this )
 314                 {
 315                         removeItem(item);
 316                 }
 317         }
 318
 319         foreach(YAMF::Drawing::Private::Guide *guide, d->guides )
 320         {
 321                 addItem(guide);
 322         }
 323 }
 324
 325 /**
 326  * @~spanish
 327  * Asigna los papel cebolla hacia adelante del fotograma.
 328  */
 329 void Photogram::setNextOnionSkinCount(int n)
 330 {
 331         d->onionSkin.next = n;
 332         drawCurrentPhotogram();
 333 }
 334
 335 /**
 336  * @~spanish
 337  * Asigna los papel cebolla hacia atras del fotograma.
 338  */
 339 void Photogram::setPreviousOnionSkinCount(int n)
 340 {
 341         d->onionSkin.previous = n;
 342
 343         drawCurrentPhotogram();
 344 }
 345
 346 /**
 347  * @~spanish
 348  * Asigna la scena actual del fotograma.
 349  */
 350 void Photogram::setCurrentScene(Model::Scene *scene)
 351 {
 352         qDeleteAll(d->guides);
 353         d->guides.clear();
 354
 355         clean();
 356         d->scene = scene;
 357
 358         drawCurrentPhotogram();
 359 }
 360
 361 /**
 362  * @~spanish
 363  * Asigna la visibilidad del layer que esta en la posición @p layerIndex a @p visible.
 364  */
 365 void Photogram::setLayerVisible(int layerIndex, bool visible)
 366 {
 367         if( !d->scene ) return;
 368
 369         if( Model::Layer *layer = d->scene->layer(layerIndex) )
 370         {
 371                 layer->setVisible(visible);
 372         }
 373 }
 374
 375 /**
 376  * @~spanish
 377  * Retorna la escena del fotograma.
 378  */
 379 Model::Scene *Photogram::scene() const
 380 {
 381         return d->scene;
 382 }
 383
 384 /**
 385  * @~spanish
 386  * Asigna @p tool como la herramienta actual.
 387  */
 388 void Photogram::setTool(AbstractTool *tool)
 389 {
 390         drawCurrentPhotogram();
 391         if(d->tool)
 392         {
 393                 if(d->tool->type() == AbstractTool::Selection )
 394                 {
 395                         foreach(YAMF::Drawing::Private::Guide *guide, d->guides)
 396                         {
 397                                 guide->setFlag( QGraphicsItem::ItemIsMovable, false );
 398                                 guide->setEnabledSyncCursor(true);
 399                         }
 400                 }
 401                 d->tool->aboutToChangeTool();
 402         }
 403
 404         d->tool = tool;
 405         if(tool->type() == AbstractTool::Selection )
 406         {
 407                 foreach(YAMF::Drawing::Private::Guide *guide, d->guides)
 408                 {
 409                         guide->setFlag( QGraphicsItem::ItemIsMovable, true );
 410                         guide->setEnabledSyncCursor(false);
 411                 }
 412         }
 413         d->tool->init(this);
 414
 415 }
 416
 417 /**
 418  * @~spanish
 419  * Retorna la herramienta actual.
 420  */
 421 AbstractTool *Photogram::currentTool() const
 422 {
 423         return d->tool;
 424 }
 425
 426
 427 /**
 428  * @~spanish
 429  * Función reimplementada para informar a la herramienta actual del evento de presionado de un boton del mouse.
 430  */
 431 void Photogram::mousePressEvent(QGraphicsSceneMouseEvent *event)
 432 {
 433         QGraphicsScene::mousePressEvent(event);
 434
 435         d->isDrawing = false;
 436
 437         if( event->buttons() == Qt::LeftButton &&  (event->modifiers () == (Qt::ShiftModifier | Qt::ControlModifier)))
 438         {
 439         }
 440         else if (d->tool )
 441         {
 442 //              if( d->tool->type() == AbstractTool::Brush && event->isAccepted() ) return;
 443
 444                 if( d->position > -1 )
 445                 {
 446                         if ( event->buttons() == Qt::LeftButton )
 447                         {
 448                                 d->isDrawing = true;
 449                                 d->tool->press(event);
 450                         }
 451                 }
 452         }
 453 }
 454
 455 /**
 456  * @~spanish
 457  * Función reimplementada para informar a la herramienta actual del evento de movimiento del mouse.
 458  */
 459 void Photogram::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 460 {
 461         QGraphicsScene::mouseMoveEvent(event);
 462         mouseMoved(event);
 463 }
 464 /**
 465  * @~spanish
 466  * Función que informa a la herramienta actual del movimiento del mouse.
 467  */
 468 void Photogram::mouseMoved(QGraphicsSceneMouseEvent *event)
 469 {
 470 //      d->inputInformation->updateFromMouseEvent( event );
 471
 472         if (d->tool /*&& d->isDrawing*/ )
 473         {
 474                 d->tool->move(event);
 475         }
 476 }
 477
 478 /**
 479  * @~spanish
 480  * Función reimplementada para informar a la herramienta actual del evento de liberación de un boton del mouse.
 481  */
 482 void Photogram::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 483 {
 484         QGraphicsScene::mouseReleaseEvent(event);
 485         mouseReleased(event);
 486 }
 487
 488 /**
 489  * @~spanish
 490  * Función que informa a la herramienta actual de liberación de un boton del mouse.
 491  */
 492 void Photogram::mouseReleased(QGraphicsSceneMouseEvent *event)
 493 {
 494 //      d->inputInformation->updateFromMouseEvent( event );
 495
 496         if ( d->tool && d->isDrawing )
 497         {
 498                 d->tool->release(event);
 499 //              drawCurrentPhotogram(); FIXME esto borra los nodos
 500         }
 501
 502         d->isDrawing = false;
 503 }
 504
 505 /**
 506  * @~spanish
 507  * Función reimplementada para informar a la herramienta actual del evento de doble click.
 508  */
 509 void Photogram::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
 510 {
 511         QGraphicsScene::mouseDoubleClickEvent(event);
 512
 513 //      d->inputInformation->updateFromMouseEvent( event );
 514
 515         if(d->tool)
 516         {
 517                 d->tool->doubleClick( event);
 518         }
 519 }
 520 /**
 521  *
 522  * @~spanish
 523  * Función reimplementada para informar a la herramienta actual del evento de preción de una tecla.
 524  */
 525 void Photogram::keyPressEvent(QKeyEvent *event)
 526 {
 527         if ( d->tool )
 528         {
 529                 d->tool->keyPressEvent(event);
 530
 531                 if ( event->isAccepted() )
 532                 {
 533                         return;
 534                 }
 535         }
 536
 537         QGraphicsScene::keyPressEvent(event);
 538 }
 539
 540
 541 /**
 542  * @~spanish
 543  * Función reimplementada para la creación de lineas guias.
 544  */
 545 void Photogram::dragEnterEvent ( QGraphicsSceneDragDropEvent * event )
 546 {
 547         if (event->mimeData()->hasFormat("yamf-ruler"))
 548         {
 549                 event->acceptProposedAction();
 550                 YAMF::Drawing::Private::Guide *guide = 0;
 551                 if(event->mimeData()->data("yamf-ruler") == "verticalLine")
 552                 {
 553                         guide = new YAMF::Drawing::Private::Guide(Qt::Vertical, this);
 554                         guide->setPos(event->scenePos());
 555                 }
 556                 else
 557                 {
 558                         guide = new YAMF::Drawing::Private::Guide(Qt::Horizontal, this);
 559                         guide->setPos(event->scenePos());
 560                 }
 561
 562                 if(guide)
 563                 {
 564                         d->guides << guide;
 565                 }
 566         }
 567 }
 568
 569 /**
 570  * @~spanish
 571  * Función reimplementada para la creación de lineas guias.
 572  */
 573 void  Photogram::dragLeaveEvent ( QGraphicsSceneDragDropEvent * event)
 574 {
 575         if (event->mimeData()->hasFormat("yamf-ruler"))
 576         {
 577                 removeItem(d->guides.last());
 578                 delete d->guides.takeLast();
 579         }
 580 }
 581
 582 /**
 583  * @~spanish
 584  * Función reimplementada para la creación de lineas guias.
 585  */
 586 void Photogram::dragMoveEvent ( QGraphicsSceneDragDropEvent * event )
 587 {
 588         if (event->mimeData()->hasFormat("yamf-ruler"))
 589         {
 590                 if(!d->guides.isEmpty())
 591                 {
 592                         d->guides.last()->setPos(event->scenePos());
 593                 }
 594         }
 595 }
 596
 597 /**
 598  * @~spanish
 599  * Función reimplementada para la creación de lineas guias.
 600  */
 601 void Photogram::dropEvent ( QGraphicsSceneDragDropEvent * event )
 602 {
 603         Q_UNUSED(event);
 604         if(d->tool)
 605         {
 606                 if(d->tool->type() == AbstractTool::Selection )
 607                 {
 608                         d->guides.last()->setEnabledSyncCursor(false);
 609                         d->guides.last()->setFlag( QGraphicsItem::ItemIsMovable, true );
 610                 }
 611         }
 612 }
 613
 614
 615 bool Photogram::event(QEvent *e)
 616 {
 617         return QGraphicsScene::event(e);
 618 }
 619
 620 /**
 621  * @~spanish
 622  * Retorna verdadero si se esta dibujando.
 623  */
 624 bool Photogram::isDrawing() const
 625 {
 626         return d->isDrawing;
 627 }
 628
 629
 630 /**
 631  * @~spanish
 632  * Retorna el manejador de brochas del photograma.
 633  */
 634 BrushManager *Photogram::brushManager() const
 635 {
 636         return d->brushManager;
 637 }
 638
 639 /**
 640  * @~spanish
 641  * Evita la selección de elementos que estan en el papel cebolla.
 642  */
 643 void Photogram::aboutToMousePress()
 644 {
 645         QHash<QGraphicsItem *, double>::iterator it = d->onionSkin.opacityMap.begin();
 646
 647         while(it != d->onionSkin.opacityMap.end() )
 648         {
 649                 if( it.value() != 1.0 )
 650                 {
 651                         it.key()->setAcceptedMouseButtons(Qt::NoButton);
 652                         it.key()->setFlag(QGraphicsItem::ItemIsSelectable, false);
 653                 }
 654                 else
 655                 {
 656                         it.key()->setAcceptedMouseButtons( Qt::LeftButton | Qt::RightButton | Qt::MidButton | Qt::XButton1 | Qt::XButton2 );
 657                 }
 658
 659                 ++it;
 660         }
 661 }
 662
 663 }
 664 }
 665
 666