?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed crash in iTween network
[yamf.git] / yamf / drawing / tool / itween.cpp
blobf581a0157de6cba39055a4a17adb4e9256ad731a
1 /**************************************************************************
2 * Copyright (C) 2005 by David Cuadrado *
3 * krawek@toonka.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 "itween.h"
22
23 #include <QGraphicsView>
24 #include <QGraphicsSceneMouseEvent>
25 #include <QSet>
26 #include <QHBoxLayout>
27 #include <QRadioButton>
28 #include <QToolBar>
29 #include <QButtonGroup>
30 #include <QXmlStreamWriter>
31
32 #include <dcore/global.h>
33 #include <dcore/debug.h>
34
35 #include <dgui/iconloader.h>
36 #include <dgui/action.h>
37
38 #include <dgraphics/pathhelper.h>
39 #include <dgraphics/algorithm.h>
40
41 #include "yamf/model/object.h"
42 #include "yamf/model/frame.h"
43 #include "yamf/model/scene.h"
44
45 #include "yamf/drawing/paintarea.h"
46 #include "yamf/drawing/brushmanager.h"
47 #include "yamf/drawing/photogram.h"
48 #include "yamf/item/path.h"
49 #include "yamf/item/proxy.h"
50 #include "yamf/item/line.h"
51 #include "yamf/item/converter.h"
52 #include "yamf/item/tweener.h"
53 #include "yamf/item/serializer.h"
54
55 #include "yamf/model/command/addtweening.h"
56 #include "private/contoureditor.h"
57
58 #include <dgraphics/itemtransformer.h>
59
60 #include "commonalgorithms.h"
61
62 #define DEBUG 0
63
64 namespace YAMF {
65 namespace Drawing {
66 class BrushManager;
67
68 namespace Tool {
69
70 struct ITween::Private {
71 Private() : target(0), nodeEditor(0), transformer(0), pathItem(0), paintArea(0) {}
72 enum Type {
73 PathMotion = 0x01,
74 Fill,
75 Transform,
76 NodeMotion
77 };
78
79 DGui::Action * action;
80 QWidget *configWidget;
81 QButtonGroup group;
82
83 Model::Object *target;
84
85 QPointF currentPos;
86 QPointF absItemPos;
87
88
89 Drawing::Tool::Private::ContourEditor *nodeEditor;
90 DGraphics::ItemTransformer* transformer;
91
92 QGraphicsPathItem *pathItem;
93 QPainterPath path;
94 QPointF firstPos;
95 QPointF lastPos;
96
97 Drawing::PaintArea *paintArea;
98
99 Item::Tweener *createObjectTweener(int frames = 1);
100 void saveChanges();
101 void releaseObject();
102 };
103
104 Item::Tweener *ITween::Private::createObjectTweener(int frames)
105 {
106 Item::Tweener *tweener = target->tweener();
107
108 if( tweener == 0 )
109 {
110 tweener = new Item::Tweener(1, target);
111
112 tweener->setPosAt(0, target->item()->scenePos());
113 // tweener->setRotationAt(0, 0);
114 // tweener->setScaleAt(0, 1.0, 1.0);
115
116 // if( item()->type() != QAbstractGraphicsShapeItem::Type ) return;
117 if( QAbstractGraphicsShapeItem *shape = dynamic_cast<QAbstractGraphicsShapeItem *>(target->item()) )
118 {
119 tweener->setBrushAt(0, shape->brush());
120 tweener->setPenAt(0, shape->pen());
121 }
122
123 if( QGraphicsPathItem *path = dynamic_cast<QGraphicsPathItem*>(target->item()) )
124 {
125 tweener->setPathAt(0, path->path());
126 }
127
128 target->setTweener(tweener);
129 }
130
131 frames = qMax(frames, tweener->frames());
132 tweener->setFrames(frames);
133
134 return tweener;
135 }
136
137 void ITween::Private::saveChanges()
138 {
139 if( target )
140 {
141 int objectPos = target->frame()->visualIndex();
142 int framePos = paintArea->currentFrame()->visualIndex();
143 int step = qAbs(framePos - objectPos);
144
145 int frames = step;
146 if( target->tweener() )
147 {
148 frames = qMax(step, target->tweener()->frames());
149 }
150
151 Item::Tweener *tweener = createObjectTweener(frames);
152
153 switch(group.checkedId())
154 {
155 case Private::Transform:
156 {
157 if( currentPos != target->item()->pos() ) // The object was changed
158 {
159 tweener->setPosAt(step, target->item()->pos());
160 }
161
162 if( transformer )
163 {
164 if( transformer->isModified() )
165 {
166 switch(transformer->operation() )
167 {
168 case DGraphics::ItemTransformer::Scale:
169 {
170 tweener->setScaleAt(step, transformer->currentVerticalScale(), transformer->currentHorizontalScale() );
171
172 tweener->setPosAt(step, transformer->currentPosition() );
173 }
174 break;
175 case DGraphics::ItemTransformer::Rotate:
176 {
177 QPointF pos = transformer->currentPosition();
178 tweener->setRotationAt(step, transformer->currentRotation());
179 tweener->setPosAt(step, pos );
180 }
181 break;
182 }
183
184 // transformer->setItem(target->item()); // To reset
185 }
186 }
187 }
188 break;
189 case Private::PathMotion:
190 {
191 if( path.elementCount() < 3 ) break;
192
193 QRectF br = target->item()->sceneBoundingRect();
194 QPointF origin = absItemPos;
195
196 QTransform transform;
197 transform.translate(-origin.x(), -origin.y());
198
199 double factor = 1.0/step;
200
201 QPainterPath npath = transform.map(path);
202
203 int n = 0;
204 for(double percent = 0; percent < 1; percent += factor )
205 {
206 QPointF pos = npath.pointAtPercent(percent);
207 tweener->setPosAt(n, pos);
208
209 n++;
210 }
211
212 #if DEBUG
213 paintArea->currentFrame()->addItem(pathItem);
214 #endif
215 }
216 break;
217 case Private::NodeMotion:
218 {
219 if( QGraphicsPathItem *item = dynamic_cast<QGraphicsPathItem *>(target->item()) )
220 {
221 tweener->setPathAt(step, item->path());
222 }
223 }
224 break;
225 case Private::Fill:
226 {
227 if( QAbstractGraphicsShapeItem *item = dynamic_cast<QAbstractGraphicsShapeItem *>(target->item()) )
228 {
229 tweener->setBrushAt(step, item->brush());
230 tweener->setPenAt(step, item->pen());
231 }
232 }
233 break;
234 default:
235 {
236 }
237 break;
238 }
239
240 paintArea->addCommand(new YAMF::Command::AddTweening(target, tweener));
241 tweener->setStep(step);
242 }
243 }
244
245 void ITween::Private::releaseObject()
246 {
247 if( target )
248 {
249 if( transformer )
250 {
251 transformer->setVisible(false);
252 foreach(QGraphicsItem *node, transformer->nodes())
253 {
254 paintArea->setAlwaysVisible(node, false);
255 }
256 }
257 if(pathItem)
258 {
259 paintArea->setAlwaysVisible(pathItem, false);
260 delete pathItem;
261 pathItem = 0;
262 }
263
264 {
265 if( nodeEditor )
266 {
267 foreach(QGraphicsItem *node, nodeEditor->nodes())
268 {
269 paintArea->setAlwaysVisible(node, false);
270 }
271
272 delete nodeEditor;
273 nodeEditor = 0;
274 }
275 }
276
277 target->scene()->setAlwaysVisible(target, false);
278 if( target->tweener() )
279 {
280 target->tweener()->setFrames(target->tweener()->frames());
281 }
282 target = 0;
283 }
284 }
285
286 ITween::ITween(QObject *parent) : AbstractTool(parent), d(new Private)
287 {
288 d->action = new DGui::Action( DGui::IconLoader::self()->load("itween.svg"), tr("iTween"), this);
289
290 // d->action->setShortcut( QKeySequence(tr("Ctrl+W")) );
291
292 d->configWidget = new QWidget;
293 QHBoxLayout *layout = new QHBoxLayout(d->configWidget);
294 layout->setMargin(0);
295 layout->setSpacing(2);
296
297
298 QRadioButton *transform = new QRadioButton(tr("Transform"));
299 transform->setChecked(true);
300 layout->addWidget(transform);
301
302 QRadioButton *pathMotion = new QRadioButton(tr("Path motion"));
303 layout->addWidget(pathMotion);
304
305 QRadioButton *fill = new QRadioButton(tr("Fill"));
306 layout->addWidget(fill);
307
308 QRadioButton *nodeMotion = new QRadioButton(tr("Node motion"));
309 layout->addWidget(nodeMotion);
310
311 d->group.addButton(pathMotion, Private::PathMotion);
312 d->group.addButton(fill, Private::Fill);
313 d->group.addButton(transform, Private::Transform);
314 d->group.addButton(nodeMotion, Private::NodeMotion);
315
316 connect(&d->group, SIGNAL(buttonClicked(int)), this, SLOT(onChangeTool(int)));
317 }
318
319 ITween::~ITween()
320 {
321 if( d->nodeEditor )
322 {
323 foreach(QGraphicsItem *node, d->nodeEditor->nodes())
324 {
325 paintArea()->setAlwaysVisible(node, false);
326 }
327 delete d->nodeEditor;
328 }
329
330 if( d->transformer )
331 {
332 foreach(QGraphicsItem *node, d->transformer->nodes())
333 {
334 paintArea()->setAlwaysVisible(node, false);
335 }
336 delete d->transformer;
337 }
338
339 if(d->pathItem)
340 {
341 paintArea()->setAlwaysVisible(d->pathItem, false);
342 delete d->pathItem;
343 }
344
345
346 delete d;
347 }
348
349 void ITween::init(Photogram *photogram)
350 {
351 foreach(QGraphicsItem *item, photogram->items() )
352 {
353 item->setFlag(QGraphicsItem::ItemIsSelectable, true);
354 item->setFlag(QGraphicsItem::ItemIsFocusable, true);
355 item->setFlag(QGraphicsItem::ItemIsMovable, true);
356 }
357 }
358
359 QString ITween::id() const
360 {
361 return "itween";
362 }
363
364 void ITween::press(const QGraphicsSceneMouseEvent *input)
365 {
366 PaintArea *paintArea = this->paintArea(); // FIXME
367
368 d->firstPos = input->scenePos();
369 d->lastPos = input->scenePos();
370
371 d->paintArea = paintArea;
372 Photogram *photogram = paintArea->photogram();
373
374 if( d->target )
375 {
376 if( !d->target->item()->isSelected() )
377 {
378 d->saveChanges();
379 d->releaseObject();
380 }
381 }
382
383 QList<QGraphicsItem *> selected = photogram->selectedItems();
384 if( selected.isEmpty() ) return;
385
386 Model::Object *object = paintArea->currentFrame()->graphic(selected.first());
387
388 if( object == 0 )
389 {
390 // If the object has a tweener, it may be not in the current frame.
391 object = paintArea->currentScene()->tweeningObject(selected.first());
392
393 if( !object )
394 return;
395 }
396
397 if( d->target != object )
398 {
399 if( d->target )
400 {
401 d->target->scene()->setAlwaysVisible(d->target, false);
402 }
403
404 d->target = object;
405 d->target->scene()->setAlwaysVisible(d->target, true);
406 }
407 d->createObjectTweener();
408
409 d->currentPos = d->target->item()->pos();
410 d->absItemPos = d->target->item()->boundingRect().topLeft();
411
412 int objectPos = d->target->frame()->visualIndex();
413 int framePos = paintArea->currentFrame()->visualIndex();
414 int step = qAbs(framePos - objectPos);
415
416 int frames = step;
417 if( d->target->tweener() )
418 {
419 frames = qMax(step, d->target->tweener()->frames());
420 }
421
422 if(input->buttons() == Qt::LeftButton)
423 {
424 switch(d->group.checkedId())
425 {
426 case Private::Transform:
427 {
428 QList<DGraphics::ItemTransformer *> transformers;
429
430 if(d->transformer)
431 {
432 transformers << d->transformer;
433 }
434
435 CommonAlgorithms::createTransfromers(transformers, QList<QGraphicsItem*>() << d->target->item(), paintArea);
436
437 if(!transformers.isEmpty())
438 {
439 d->transformer = transformers.first();
440 }
441 #if 0
442 else if( input->modifiers() != Qt::ControlModifier )
443 {
444 if(photogram->mouseGrabberItem() == d->transformer->item())
445 {
446 switch(d->transformer->operation())
447 {
448 case DGraphics::ItemTransformer::Scale:
449 {
450 d->transformer->setOperation(DGraphics::ItemTransformer::Rotate);
451 }
452 break;
453 case DGraphics::ItemTransformer::Rotate:
454 {
455 d->transformer->setOperation(DGraphics::ItemTransformer::Scale);
456 }
457 break;
458 }
459 }
460 }
461 #endif
462 }
463 break;
464 case Private::PathMotion:
465 {
466 d->path = QPainterPath();
467 d->path.moveTo(d->firstPos);
468
469 if(d->pathItem)
470 {
471 paintArea->setAlwaysVisible(d->pathItem, false);
472 delete d->pathItem;
473 d->pathItem = 0;
474 }
475
476 if( d->nodeEditor )
477 {
478 foreach(QGraphicsItem *node, d->nodeEditor->nodes())
479 {
480 paintArea->setAlwaysVisible(node, false);
481 }
482
483 delete d->nodeEditor;
484 d->nodeEditor = 0;
485 }
486
487 d->pathItem = new QGraphicsPathItem;
488 d->pathItem->setZValue(1000);
489
490 {
491 QColor c = Qt::lightGray;
492 c.setAlpha(120);
493
494 QPen pen(c, 1);
495 pen.setStyle(Qt::DashDotDotLine);
496 d->pathItem->setPen(pen);
497 }
498 photogram->addItem( d->pathItem );
499 }
500 break;
501 default:
502 {
503 // qFatal("Not implemented!");
504 }
505 break;
506 }
507 }
508 }
509
510 void ITween::move(const QGraphicsSceneMouseEvent *input)
511 {
512 if( d->target == 0 ) return;
513
514 PaintArea *paintArea = this->paintArea();
515 if(input->buttons() == Qt::LeftButton)
516 {
517 if( d->group.checkedId() == Private::PathMotion )
518 {
519 d->lastPos = paintArea->mapToScene(paintArea->viewport()->mapFromGlobal(QCursor::pos()));;
520 d->path.lineTo( d->lastPos );
521
522 d->pathItem->setPath(d->path);
523 paintArea->brushManager()->map(d->pathItem);
524 }
525 }
526 }
527
528 void ITween::release(const QGraphicsSceneMouseEvent *input)
529 {
530 if( d->target == 0 ) return;
531
532 PaintArea *paintArea = this->paintArea();
533 switch(d->group.checkedId())
534 {
535 case Private::Transform:
536 {
537 d->saveChanges();
538 if(d->transformer)
539 {
540 d->transformer->show();
541 }
542 else
543 {
544 QList<DGraphics::ItemTransformer *> transformers;
545 CommonAlgorithms::createTransfromers(transformers, QList<QGraphicsItem*>() << d->target->item(), paintArea);
546
547 if(!transformers.isEmpty())
548 {
549 d->transformer = transformers.first();
550 }
551 }
552
553 }
554 break;
555 case Private::PathMotion:
556 {
557 if(!d->path.isEmpty())
558 {
559 {
560 double smoothness = 1.0;
561
562 QPolygonF polygon = d->path.toFillPolygon();
563 if(!polygon.isEmpty() && polygon.isClosed())
564 polygon.pop_back();
565
566 d->path = DGraphics::Algorithm::smooth(polygon, smoothness);
567 d->pathItem->setPath(d->path);
568
569 paintArea->setAlwaysVisible(d->pathItem, true);
570
571 }
572
573 d->saveChanges();
574 if( d->nodeEditor )
575 {
576 foreach(QGraphicsItem *node, d->nodeEditor->nodes())
577 {
578 paintArea->setAlwaysVisible(node, false);
579 }
580 delete d->nodeEditor;
581 }
582 d->nodeEditor = new Drawing::Tool::Private::ContourEditor(d->pathItem, paintArea->photogram());
583
584 d->nodeEditor->show();
585 foreach(QGraphicsItem *node, d->nodeEditor->nodes())
586 {
587 paintArea->setAlwaysVisible(node, true);
588 }
589 }
590 }
591 break;
592 case Private::NodeMotion:
593 {
594 QList<Drawing::Tool::Private::ContourEditor *> editors;
595 if( d->nodeEditor )
596 {
597 editors << d->nodeEditor;
598 }
599
600 CommonAlgorithms::createEditors(editors, QList<QGraphicsItem*>() << d->target->item(), paintArea);
601
602 if(!editors.isEmpty())
603 {
604 d->nodeEditor = editors.first();
605 d->nodeEditor->show();
606 }
607
608 d->saveChanges();
609 }
610 break;
611 case Private::Fill:
612 {
613 if( QAbstractGraphicsShapeItem *item = dynamic_cast<QAbstractGraphicsShapeItem *>(d->target->item()) )
614 {
615 paintArea->brushManager()->apply(item);
616 d->saveChanges();
617 }
618 else
619 {
620 d->releaseObject();
621 return;
622 }
623 }
624 break;
625 }
626 }
627
628 DGui::Action * ITween::action() const
629 {
630 return d->action;
631 }
632
633 int ITween::type() const
634 {
635 return AbstractTool::Brush;
636 }
637
638 void ITween::aboutToChangeTool()
639 {
640 PaintArea *paintArea = this->paintArea();
641 d->saveChanges();
642 d->releaseObject();
643
644 if(d->pathItem)
645 {
646 paintArea->setAlwaysVisible(d->pathItem, false);
647 delete d->pathItem;
648 d->pathItem = 0;
649 }
650
651 if( d->nodeEditor )
652 {
653 foreach(QGraphicsItem *node, d->nodeEditor->nodes())
654 {
655 paintArea->setAlwaysVisible(node, false);
656 }
657 delete d->nodeEditor;
658 d->nodeEditor = 0;
659 }
660
661 if( d->transformer )
662 {
663 foreach(QGraphicsItem *node, d->transformer->nodes())
664 {
665 paintArea->setAlwaysVisible(node, false);
666 }
667 delete d->transformer;
668 d->transformer = 0;
669 }
670 }
671
672 void ITween::setupConfigBar(QToolBar *configBar)
673 {
674 configBar->addWidget(d->configWidget)->setVisible(true);
675 }
676
677 void ITween::onChangeTool(int id)
678 {
679 PaintArea *paintArea = this->paintArea();
680 switch(id)
681 {
682 // case Private::Transform:
683 // {
684 // }
685 // break;
686 case Private::NodeMotion:
687 {
688 if(d->pathItem)
689 {
690 paintArea->setAlwaysVisible(d->pathItem, false);
691 delete d->pathItem;
692 d->pathItem = 0;
693 }
694
695 if( d->nodeEditor )
696 {
697 foreach(QGraphicsItem *node, d->nodeEditor->nodes())
698 {
699 paintArea->setAlwaysVisible(node, false);
700 }
701
702 delete d->nodeEditor;
703 d->nodeEditor = 0;
704 }
705 }
706 break;
707 default:
708 {
709 }
710 break;
711 }
712 d->saveChanges();
713 }
714
715 }
716 }
717 }