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
  29 #include <model/scene.h>
  30 #include <model/layer.h>
  31 #include <model/frame.h>
  32 #include <model/object.h>
  33
  34 #include "item/group.h"
  35
  36
  37 #include <drawing/abstracttool.h>
  38 #include <drawing/brushmanager.h>
  39 #include <drawing/paintarea.h>
  40
  41 #include "item/tweener.h"
  42
  43 #include <dcore/debug.h>
  44
  45 #include <private/guide.h>
  46
  47 namespace YAMF {
  48 namespace Drawing {
  49
  50 struct Photogram::Private
  51 {
  52         Private() : tool(0), scene(0), position(0), isDrawing(false), recorded(false) {}
  53
  54         AbstractTool *tool;
  55         Model::Scene *scene;
  56         struct OnionSkin
  57         {
  58                 int previous;
  59                 int next;
  60                 QHash<QGraphicsItem *, double> opacityMap;
  61         } onionSkin;
  62
  63         int position;
  64
  65         bool isDrawing;
  66         BrushManager *brushManager;
  67         PaintArea *paintArea;
  68
  69         QList<YAMF::Drawing::Private::Guide *> guides;
  70
  71         Model::Object *recorded;
  72 };
  73
  74 Photogram::Photogram(PaintArea *parent) : QGraphicsScene(parent), d(new Private)
  75 {
  76         d->paintArea = parent;
  77
  78         setItemIndexMethod(QGraphicsScene::NoIndex);
  79
  80         d->onionSkin.next = 0;
  81         d->onionSkin.previous = 0;
  82         d->isDrawing = false;
  83
  84         setBackgroundBrush(Qt::gray);
  85
  86         d->brushManager = new BrushManager(this);
  87 }
  88
  89
  90 Photogram::~Photogram()
  91 {
  92         D_END;
  93
  94         clearFocus();
  95         clearSelection();
  96
  97         foreach( QGraphicsView *view, this->views() )
  98         {
  99                 view->setScene(0);
 100         }
 101
 102         foreach(QGraphicsItem *item, items())
 103         {
 104                 removeItem(item);
 105         }
 106
 107         delete d;
 108 }
 109
 110 void Photogram::setCurrent(int pos)
 111 {
 112         d->position = pos;
 113 }
 114
 115 void Photogram::drawCurrentPhotogram()
 116 {
 117         drawPhotogram( d->position );
 118 }
 119
 120
 121
 122 void Photogram::drawItems(QPainter *painter, int numItems, QGraphicsItem *items[], const QStyleOptionGraphicsItem options[], QWidget *widget)
 123 {
 124         for (int i = 0; i < numItems; ++i)
 125         {
 126                 QGraphicsItem *item = items[i];
 127                 painter->save();
 128                 painter->setMatrix(item->sceneMatrix(), true);
 129
 130                 if ( d->onionSkin.opacityMap.contains(item) )
 131                 {
 132                         painter->setOpacity( d->onionSkin.opacityMap[item] );
 133                 }
 134
 135                 item->paint(painter, &options[i], widget);
 136
 137                 painter->restore();
 138         }
 139 }
 140
 141
 142 void Photogram::drawPhotogram(int photogram)
 143 {
 144         if ( photogram < 0 || !d->scene ) return;
 145
 146
 147         if( d->tool )
 148                 d->tool->aboutToChangePhotogram(this);
 149
 150         clean();
 151
 152         bool valid = false;
 153
 154         foreach(Model::Layer *layer, d->scene->layers().values())
 155         {
 156                 if ( layer->isVisible() )
 157                 {
 158                         if( d->onionSkin.previous > 0 )
 159                         {
 160                                 double opacityFactor = 0.5 / (double)qMin(layer->frames().count(),d->onionSkin.previous);
 161
 162                                 double opacity = 0.6;
 163
 164                                 for(int frameIndex = photogram-1; frameIndex > photogram-d->onionSkin.previous-1; frameIndex-- )
 165                                 {
 166                                         Model::Frame * frame = layer->frame(frameIndex);
 167                                         if(frame)
 168                                         {
 169                                                 addFrame( frame, opacity );
 170                                         }
 171                                         opacity -= opacityFactor;
 172                                 }
 173                         }
 174
 175                         if ( d->onionSkin.next > 0 )
 176                         {
 177                                 double opacityFactor = 0.5 / (double)qMin(layer->frames().count(), d->onionSkin.next);
 178                                 double opacity = 0.6;
 179
 180                                 for(int frameIndex = photogram+1; frameIndex < photogram+d->onionSkin.next+1; frameIndex++ )
 181                                 {
 182
 183                                         Model::Frame * frame = layer->frame(frameIndex);
 184                                         if(frame)
 185                                         {
 186                                                 addFrame( frame, opacity );
 187                                         }
 188                                         opacity -= opacityFactor;
 189                                 }
 190                         }
 191
 192                         Model::Frame *frame = layer->frame( photogram );
 193
 194                         if( frame )
 195                         {
 196                                 valid = true;
 197                                 addFrame(frame);
 198                         }
 199                 }
 200         }
 201
 202         if( valid )
 203         {
 204                 if( d->recorded )
 205                 {
 206                         if( d->recorded->frame()->isVisible() )
 207                         {
 208                                 addItem(d->recorded->item());
 209                         }
 210                 }
 211
 212                 foreach(Model::Object *object, d->scene->tweeningObjects())
 213                 {
 214                         if(object->frame()->layer()->isVisible() )
 215                         {
 216                                 int origin = object->frame()->visualIndex();
 217
 218                                 if( Item::Tweener *tweener = object->tweener() )
 219                                 {
 220                                         tweener->setStep(0);
 221
 222                                         if( origin < photogram && photogram < origin+tweener->frames() )
 223                                         {
 224                                                 int step = photogram - origin;
 225
 226                                                 tweener->setStep(step);
 227
 228                                                 addGraphicObject(object);
 229                                         }
 230                                 }
 231                         }
 232                 }
 233
 234                 update();
 235         }
 236
 237         if( d->tool )
 238         {
 239                 d->tool->photogramChanged(this);
 240         }
 241 }
 242
 243 void Photogram::addFrame(Model::Frame *frame, double opacity )
 244 {
 245         if ( frame->isVisible() )
 246         {
 247                 foreach(Model::Object *object, frame->graphics().values() )
 248                 {
 249                         addGraphicObject(object, opacity);
 250                 }
 251         }
 252 }
 253
 254 void Photogram::addGraphicObject(Model::Object *object, double opacity)
 255 {
 256         QGraphicsItem *item = object->item();
 257
 258         if( item )
 259         {
 260                 d->onionSkin.opacityMap.insert(item, opacity);
 261
 262                 if ( Item::Group *group = qgraphicsitem_cast<Item::Group *>(item) )
 263                 {
 264                         group->recoverChilds();
 265                 }
 266
 267                 if( ! qgraphicsitem_cast<Item::Group *>(item->parentItem()))
 268                 {
 269                         addItem(item);
 270                 }
 271         }
 272 }
 273
 274 void Photogram::clean()
 275 {
 276         d->onionSkin.opacityMap.clear();
 277
 278         foreach(QGraphicsItem *item, items() )
 279         {
 280                 if ( item->scene() == this )
 281                 {
 282                         removeItem(item);
 283                 }
 284         }
 285
 286         foreach(YAMF::Drawing::Private::Guide *guide, d->guides )
 287         {
 288                 addItem(guide);
 289         }
 290 }
 291
 292 void Photogram::setNextOnionSkinCount(int n)
 293 {
 294         d->onionSkin.next = n;
 295         drawCurrentPhotogram();
 296 }
 297
 298 void Photogram::setPreviousOnionSkinCount(int n)
 299 {
 300         d->onionSkin.previous = n;
 301
 302         drawCurrentPhotogram();
 303 }
 304
 305 void Photogram::setCurrentScene(Model::Scene *scene)
 306 {
 307         qDeleteAll(d->guides);
 308         d->guides.clear();
 309
 310         clean();
 311         d->scene = scene;
 312
 313         drawCurrentPhotogram();
 314 }
 315
 316 void Photogram::setLayerVisible(int layerIndex, bool visible)
 317 {
 318         if( !d->scene ) return;
 319
 320         if( Model::Layer *layer = d->scene->layer(layerIndex) )
 321         {
 322                 layer->setVisible(visible);
 323         }
 324 }
 325
 326 Model::Scene *Photogram::scene() const
 327 {
 328         return d->scene;
 329 }
 330
 331 void Photogram::setTool(AbstractTool *tool)
 332 {
 333         drawCurrentPhotogram();
 334         if(d->tool)
 335         {
 336                 if(d->tool->type() == AbstractTool::Selection )
 337                 {
 338                         foreach(YAMF::Drawing::Private::Guide *guide, d->guides)
 339                         {
 340                                 guide->setFlag( QGraphicsItem::ItemIsMovable, false );
 341                                 guide->setEnabledSyncCursor(true);
 342                         }
 343                 }
 344                 d->tool->aboutToChangeTool();
 345         }
 346
 347         d->tool = tool;
 348         if(tool->type() == AbstractTool::Selection )
 349         {
 350                 foreach(YAMF::Drawing::Private::Guide *guide, d->guides)
 351                 {
 352                         guide->setFlag( QGraphicsItem::ItemIsMovable, true );
 353                         guide->setEnabledSyncCursor(false);
 354                 }
 355         }
 356         d->tool->init(this);
 357
 358 }
 359
 360 AbstractTool *Photogram::currentTool() const
 361 {
 362         return d->tool;
 363 }
 364
 365
 366 void Photogram::mousePressEvent(QGraphicsSceneMouseEvent *event)
 367 {
 368         QGraphicsScene::mousePressEvent(event);
 369
 370         d->isDrawing = false;
 371
 372         if( event->buttons() == Qt::LeftButton &&  (event->modifiers () == (Qt::ShiftModifier | Qt::ControlModifier)))
 373         {
 374         }
 375         else if (d->tool )
 376         {
 377                 if( d->tool->type() == AbstractTool::Brush && event->isAccepted() ) return;
 378
 379                 if( d->position > -1 )
 380                 {
 381                         if ( event->buttons() == Qt::LeftButton )
 382                         {
 383                                 d->isDrawing = true;
 384                                 d->tool->press(event, d->paintArea);
 385                         }
 386                 }
 387         }
 388 }
 389
 390 void Photogram::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
 391 {
 392         QGraphicsScene::mouseMoveEvent(event);
 393         mouseMoved(event);
 394 }
 395
 396 void Photogram::mouseMoved(QGraphicsSceneMouseEvent *event)
 397 {
 398 //      d->inputInformation->updateFromMouseEvent( event );
 399
 400         if (d->tool /*&& d->isDrawing*/ )
 401         {
 402                 d->tool->move(event, d->paintArea );
 403         }
 404 }
 405
 406 void Photogram::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 407 {
 408         QGraphicsScene::mouseReleaseEvent(event);
 409         mouseReleased(event);
 410 }
 411
 412 void Photogram::mouseReleased(QGraphicsSceneMouseEvent *event)
 413 {
 414 //      d->inputInformation->updateFromMouseEvent( event );
 415
 416         if ( d->tool && d->isDrawing )
 417         {
 418                 d->tool->release(event, d->paintArea );
 419 //              drawCurrentPhotogram(); FIXME esto borra los nodos
 420         }
 421
 422         d->isDrawing = false;
 423 }
 424
 425 void Photogram::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event)
 426 {
 427         QGraphicsScene::mouseDoubleClickEvent(event);
 428
 429 //      d->inputInformation->updateFromMouseEvent( event );
 430
 431         if(d->tool)
 432         {
 433                 d->tool->doubleClick( event, d->paintArea );
 434         }
 435 }
 436
 437 void Photogram::keyPressEvent(QKeyEvent *event)
 438 {
 439         if ( d->tool )
 440         {
 441                 d->tool->keyPressEvent(event);
 442
 443                 if ( event->isAccepted() )
 444                 {
 445                         return;
 446                 }
 447         }
 448
 449         QGraphicsScene::keyPressEvent(event);
 450 }
 451
 452
 453 void Photogram::dragEnterEvent ( QGraphicsSceneDragDropEvent * event )
 454 {
 455
 456         if (event->mimeData()->hasFormat("yamf-ruler"))
 457         {
 458                 event->acceptProposedAction();
 459                 YAMF::Drawing::Private::Guide *guide = 0;
 460                 if(event->mimeData()->data("yamf-ruler") == "verticalLine")
 461                 {
 462                         guide = new YAMF::Drawing::Private::Guide(Qt::Vertical, this);
 463                         guide->setPos(event->scenePos());
 464                 }
 465                 else
 466                 {
 467                         guide = new YAMF::Drawing::Private::Guide(Qt::Horizontal, this);
 468                         guide->setPos(event->scenePos());
 469                 }
 470
 471                 if(guide)
 472                 {
 473                         d->guides << guide;
 474                 }
 475         }
 476 }
 477
 478
 479 void  Photogram::dragLeaveEvent ( QGraphicsSceneDragDropEvent * event)
 480 {
 481         if (event->mimeData()->hasFormat("yamf-ruler"))
 482         {
 483                 removeItem(d->guides.last());
 484                 delete d->guides.takeLast();
 485         }
 486 }
 487
 488 void Photogram::dragMoveEvent ( QGraphicsSceneDragDropEvent * event )
 489 {
 490         if (event->mimeData()->hasFormat("yamf-ruler"))
 491         {
 492                 if(!d->guides.isEmpty())
 493                 {
 494                         d->guides.last()->setPos(event->scenePos());
 495                 }
 496         }
 497 }
 498
 499 void Photogram::dropEvent ( QGraphicsSceneDragDropEvent * event )
 500 {
 501         Q_UNUSED(event);
 502         if(d->tool)
 503         {
 504                 if(d->tool->type() == AbstractTool::Selection )
 505                 {
 506                         d->guides.last()->setEnabledSyncCursor(false);
 507                         d->guides.last()->setFlag( QGraphicsItem::ItemIsMovable, true );
 508                 }
 509         }
 510 }
 511
 512
 513 bool Photogram::event(QEvent *e)
 514 {
 515         return QGraphicsScene::event(e);
 516 }
 517
 518 bool Photogram::isDrawing() const
 519 {
 520         return d->isDrawing;
 521 }
 522
 523 Model::Object *Photogram::recorded() const
 524 {
 525         return d->recorded;
 526 }
 527
 528 void Photogram::recordObject(Model::Object *record)
 529 {
 530         d->recorded = record;
 531 }
 532
 533 BrushManager *Photogram::brushManager() const
 534 {
 535         return d->brushManager;
 536 }
 537
 538 void Photogram::aboutToMousePress()
 539 {
 540         QHash<QGraphicsItem *, double>::iterator it = d->onionSkin.opacityMap.begin();
 541
 542         while(it != d->onionSkin.opacityMap.end() )
 543         {
 544                 if( it.value() != 1.0 )
 545                 {
 546                         it.key()->setAcceptedMouseButtons(Qt::NoButton);
 547                         it.key()->setFlag(QGraphicsItem::ItemIsSelectable, false);
 548                 }
 549                 else
 550                 {
 551                         it.key()->setAcceptedMouseButtons( Qt::LeftButton | Qt::RightButton | Qt::MidButton | Qt::XButton1 | Qt::XButton2 );
 552                 }
 553
 554                 ++it;
 555         }
 556 }
 557
 558 }
 559 }
 560
 561