← Back to branch summary

~ubuntu-branches/ubuntu/wily/tupi/wily-proposed

« back to all changes in this revision

Viewing changes to src/plugins/tools/selecttool/selecttool.cpp

  • Committer: Package Import Robot
  • Author(s): Dmitry Smirnov
  • Date: 2013-05-13 09:53:35 UTC
  • mfrom: (8.1.1 experimental)
  • Revision ID: package-import@ubuntu.com-20130513095335-3iqdvt9ne07ia25v
Tags: 0.2+git01-1
* Upload to unstable.
* Removed unnecessary versioned Build-Depends.
* Removed obsolete "DM-Upload-Allowed".
* Added Vcs links to collab-maint.
* Standards updated to version 3.9.4.
* Corrected "libavutil51"-->"libavutil-dev" in Build-Depends.
* Updated debian/watch (corrected URL, removed comments).
* Updated get-orig-source (can work from any directory).
* Updated my email address; bumped copyright years.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/tools/selecttool/selecttool.cpp
38
38
#include "tdebug.h"
39
39
#include "tglobal.h"
40
40
#include "talgorithm.h"
41
 
#include "ktgraphicalgorithm.h"
42
 
#include "ktscene.h"
43
 
#include "ktlayer.h"
44
 
#include "ktsvgitem.h"
45
 
#include "ktgraphicobject.h"
46
 
#include "ktinputdeviceinformation.h"
47
 
#include "ktgraphicsscene.h"
 
41
#include "tupgraphicalgorithm.h"
 
42
#include "tupscene.h"
 
43
#include "tuplayer.h"
 
44
#include "tupsvgitem.h"
 
45
#include "tupgraphicobject.h"
 
46
#include "tupinputdeviceinformation.h"
 
47
#include "tupgraphicsscene.h"
48
48
#include "nodemanager.h"
49
 
#include "ktserializer.h"
50
 
#include "ktrequestbuilder.h"
51
 
#include "ktprojectresponse.h"
 
49
#include "tupserializer.h"
 
50
#include "tuprequestbuilder.h"
 
51
#include "tupprojectresponse.h"
52
52
 
53
53
#include <QPointF>
54
54
#include <QKeySequence>
61
61
{
62
62
    QMap<QString, TAction *> actions;
63
63
    QList<NodeManager*> nodeManagers;
64
 
    KTGraphicsScene *scene;
 
64
    TupGraphicsScene *scene;
65
65
    bool selectionFlag;
 
66
    qreal scaleFactor;
 
67
    qreal realFactor;
66
68
};
67
69
 
68
70
SelectTool::SelectTool(): k(new Private), m_configurator(0)
75
77
    delete k;
76
78
}
77
79
 
78
 
void SelectTool::init(KTGraphicsScene *scene)
 
80
void SelectTool::init(TupGraphicsScene *scene)
79
81
{
80
82
    #ifdef K_DEBUG
81
83
           T_FUNCINFOX("tools");
84
86
    qDeleteAll(k->nodeManagers);
85
87
    k->nodeManagers.clear();
86
88
    k->scene = scene;
87
 
 
88
 
    foreach (QGraphicsView *view, scene->views()) {
89
 
             view->setDragMode(QGraphicsView::RubberBandDrag);
90
 
             foreach (QGraphicsItem *item, scene->items()) {
91
 
 
92
 
                      // SQA: Temporary code for debug issues
 
89
    k->scene->clearSelection();
 
90
 
 
91
    reset(scene);
 
92
 
 
93
    /*
 
94
    foreach (QGraphicsView *view, scene->views()) {
 
95
             view->setDragMode(QGraphicsView::RubberBandDrag);
 
96
             foreach (QGraphicsItem *item, scene->items()) {
 
97
                      if (!qgraphicsitem_cast<Node *>(item)) {
 
98
                          if (scene->spaceMode() == TupProject::FRAMES_EDITION) {
 
99
                              if (item->zValue() >= 10000 && item->toolTip().length()==0) {
 
100
                              // if (item->zValue() >= 10000 && !item->toolTip().contains("Tween")) {
 
101
                                  item->setFlags(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemIsMovable);
 
102
                              } else {
 
103
                                  item->setFlag(QGraphicsItem::ItemIsSelectable, false);
 
104
                                  item->setFlag(QGraphicsItem::ItemIsMovable, false);
 
105
                              }
 
106
                          } else {
 
107
                              item->setFlags(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemIsMovable);
 
108
                          }
 
109
                      }
 
110
             }
 
111
    }
 
112
    */
 
113
}
 
114
 
 
115
void SelectTool::reset(TupGraphicsScene *scene)
 
116
{
 
117
    #ifdef K_DEBUG
 
118
           T_FUNCINFOX("tools");
 
119
    #endif
 
120
 
 
121
    foreach (QGraphicsView *view, scene->views()) {
 
122
             view->setDragMode(QGraphicsView::RubberBandDrag);
 
123
             foreach (QGraphicsItem *item, scene->items()) {
 
124
                      // SQA: Temporary code for debugging issues
93
125
                      /*
94
126
                      QDomDocument dom;
95
 
                      dom.appendChild(dynamic_cast<KTAbstractSerializable *>(item)->toXml(dom));
 
127
                      dom.appendChild(dynamic_cast<TupAbstractSerializable *>(item)->toXml(dom));
96
128
                      QDomElement root = dom.documentElement();
97
129
                      tFatal() << "SelectTool::init() - XML: ";
98
130
                      tFatal() << dom.toString();
99
131
                      */
100
132
 
101
133
                      if (!qgraphicsitem_cast<Node *>(item)) {
102
 
                          if (scene->spaceMode() == KTProject::FRAMES_EDITION) {
 
134
                          if (scene->spaceMode() == TupProject::FRAMES_EDITION) {
103
135
                              if (item->zValue() >= 10000 && item->toolTip().length()==0) {
 
136
                              // if (item->zValue() >= 10000 && !item->toolTip().contains("Tween")) {
104
137
                                  item->setFlags(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemIsMovable);
105
138
                              } else {
106
139
                                  item->setFlag(QGraphicsItem::ItemIsSelectable, false);
119
152
    return QStringList() << tr("Select");
120
153
}
121
154
 
122
 
void SelectTool::press(const KTInputDeviceInformation *input, KTBrushManager *brushManager, KTGraphicsScene *scene)
 
155
void SelectTool::press(const TupInputDeviceInformation *input, TupBrushManager *brushManager, TupGraphicsScene *scene)
123
156
{
124
157
    Q_UNUSED(brushManager);
125
158
 
143
176
        selectedObjects << scene->mouseGrabberItem();
144
177
 
145
178
    foreach (QGraphicsItem *item, selectedObjects) {
146
 
             if (item && dynamic_cast<KTAbstractSerializable* > (item)) {
 
179
             if (item && dynamic_cast<TupAbstractSerializable* > (item)) {
147
180
                 bool found = false;
148
181
                 foreach (NodeManager *nodeManager, k->nodeManagers) {
149
182
                          if (item == nodeManager->parentItem()) {
154
187
            
155
188
                 if (!found) {
156
189
                     NodeManager *manager = new NodeManager(item, scene);
 
190
                     manager->resizeNodes(k->realFactor);
157
191
                     k->nodeManagers << manager;
158
192
                 }
159
193
             }
162
196
    k->scene = scene;
163
197
}
164
198
 
165
 
void SelectTool::move(const KTInputDeviceInformation *input, KTBrushManager *brushManager, KTGraphicsScene *scene)
 
199
void SelectTool::move(const TupInputDeviceInformation *input, TupBrushManager *brushManager, TupGraphicsScene *scene)
166
200
{
167
201
    Q_UNUSED(brushManager);
168
202
 
170
204
        QTimer::singleShot(0, this, SLOT(syncNodes()));
171
205
}
172
206
 
173
 
void SelectTool::release(const KTInputDeviceInformation *input, KTBrushManager *brushManager, KTGraphicsScene *scene)
 
207
void SelectTool::release(const TupInputDeviceInformation *input, TupBrushManager *brushManager, TupGraphicsScene *scene)
174
208
{
175
209
    Q_UNUSED(input);
176
210
    Q_UNUSED(brushManager);
195
229
        }
196
230
        
197
231
        foreach (QGraphicsItem *item, selectedObjects) {
198
 
                 if (item && dynamic_cast<KTAbstractSerializable* > (item)) {
 
232
                 if (item && dynamic_cast<TupAbstractSerializable* > (item)) {
199
233
                     NodeManager *manager = new NodeManager(item, scene);
 
234
                     manager->resizeNodes(k->realFactor);
200
235
                     k->nodeManagers << manager;
201
236
                 }
202
237
        }
204
239
        foreach (NodeManager *manager, k->nodeManagers) {
205
240
                 if (manager->isModified()) {
206
241
                     QDomDocument doc;
207
 
                     doc.appendChild(KTSerializer::properties(manager->parentItem(), doc));
 
242
                     doc.appendChild(TupSerializer::properties(manager->parentItem(), doc));
208
243
 
209
244
                     QGraphicsItem *item = manager->parentItem();
210
 
                     KTSvgItem *svg = qgraphicsitem_cast<KTSvgItem *>(item);
 
245
                     TupSvgItem *svg = qgraphicsitem_cast<TupSvgItem *>(item);
211
246
 
212
247
                     int position = -1;
213
 
                     KTLibraryObject::Type type;
 
248
                     TupLibraryObject::Type type;
214
249
 
215
250
                     if (svg) {
216
 
 
217
 
                         if (k->scene->spaceMode() == KTProject::FRAMES_EDITION) {
 
251
                         if (k->scene->spaceMode() == TupProject::FRAMES_EDITION) {
218
252
                             position = k->scene->currentFrame()->indexOf(svg);
219
 
                         } else if (k->scene->spaceMode() == KTProject::BACKGROUND_EDITION) {
220
 
                                    KTBackground *bg = k->scene->scene()->background();
 
253
                         } else if (k->scene->spaceMode() == TupProject::BACKGROUND_EDITION) {
 
254
                                    TupBackground *bg = k->scene->scene()->background();
221
255
                                    position = bg->frame()->indexOf(svg); 
222
256
                         }
223
 
                         type = KTLibraryObject::Svg;
224
 
 
 
257
                         type = TupLibraryObject::Svg;
225
258
                     } else {
226
259
 
227
 
                         if (k->scene->spaceMode() == KTProject::FRAMES_EDITION) {
 
260
                         if (k->scene->spaceMode() == TupProject::FRAMES_EDITION) {
228
261
                             position = k->scene->currentFrame()->indexOf(manager->parentItem());
229
 
                         } else if (k->scene->spaceMode() == KTProject::BACKGROUND_EDITION) {
230
 
                                    KTBackground *bg = k->scene->scene()->background();
 
262
                             tError() << "SelectTool::release() - Vector position: " << position;
 
263
                             tError() << "Frame Index: " << k->scene->currentFrameIndex();
 
264
                             tError() << "Layer Index: " << k->scene->currentLayerIndex();
 
265
                             tError() << "Scene Index: " << k->scene->currentSceneIndex();
 
266
                         } else if (k->scene->spaceMode() == TupProject::BACKGROUND_EDITION) {
 
267
                                    TupBackground *bg = k->scene->scene()->background();
231
268
                                    position = bg->frame()->indexOf(manager->parentItem());
232
269
                         }
233
 
                         type = KTLibraryObject::Item;
 
270
                         type = TupLibraryObject::Item;
234
271
                     }
235
272
 
236
273
                     if (position != -1) {
240
277
 
241
278
                         manager->restoreItem();
242
279
 
243
 
                         KTProjectRequest event = KTRequestBuilder::createItemRequest( 
 
280
                         TupProjectRequest event = TupRequestBuilder::createItemRequest( 
244
281
                                    k->scene->currentSceneIndex(), 
245
282
                                    k->scene->currentLayerIndex(), 
246
283
                                    k->scene->currentFrameIndex(), position, QPointF(), 
247
284
                                    k->scene->spaceMode(), type,
248
 
                                    KTProjectRequest::Transform, doc.toString());
 
285
                                    TupProjectRequest::Transform, doc.toString());
249
286
                         emit requested(&event);
250
287
                     } else {
251
288
                         #ifdef K_DEBUG
252
 
                                tFatal() << "SelectTool::release() - position is " << position; 
 
289
                                tError() << "SelectTool::release() - position is " << position; 
253
290
                         #endif
254
291
                     }
255
292
                 }
260
297
void SelectTool::setupActions()
261
298
{
262
299
    k->selectionFlag = false;
 
300
    k->scaleFactor = 1;
 
301
    k->realFactor = 1;
263
302
 
264
 
    TAction *select = new TAction(QPixmap(THEME_DIR + "icons/selection.png"), tr("Object Selection"), this);
 
303
    TAction *select = new TAction(QPixmap(kAppProp->themeDir() + "icons/selection.png"), tr("Object Selection"), this);
265
304
    select->setShortcut(QKeySequence(tr("O")));
266
305
 
267
306
    k->actions.insert(tr("Select"), select);
274
313
 
275
314
int SelectTool::toolType() const
276
315
{
277
 
    return KTToolInterface::Selection;
 
316
    return TupToolInterface::Selection;
278
317
}
279
318
 
280
319
QWidget *SelectTool::configurator() 
287
326
    return m_configurator;
288
327
}
289
328
 
290
 
void SelectTool::aboutToChangeScene(KTGraphicsScene *scene)
 
329
void SelectTool::aboutToChangeScene(TupGraphicsScene *scene)
291
330
{
292
331
    #ifdef K_DEBUG
293
332
           T_FUNCINFOX("tools");
314
353
    }
315
354
}
316
355
 
317
 
void SelectTool::itemResponse(const KTItemResponse *event)
 
356
void SelectTool::itemResponse(const TupItemResponse *event)
318
357
{
319
358
    #ifdef K_DEBUG
320
359
           T_FUNCINFOX("tools");
321
360
    #endif
322
361
 
323
362
    QGraphicsItem *item = 0;
324
 
    KTScene *scene = 0;
325
 
    KTLayer *layer = 0;
326
 
    KTFrame *frame = 0;
 
363
    TupScene *scene = 0;
 
364
    TupLayer *layer = 0;
 
365
    TupFrame *frame = 0;
327
366
 
328
 
    KTProject *project = k->scene->scene()->project();
 
367
    TupProject *project = k->scene->scene()->project();
329
368
    
330
369
    if (project) {
331
370
 
333
372
 
334
373
        if (scene) {
335
374
 
336
 
            if (project->spaceContext() == KTProject::FRAMES_EDITION) {
 
375
            if (project->spaceContext() == TupProject::FRAMES_EDITION) {
337
376
 
338
377
                layer = scene->layer(event->layerIndex());
339
378
 
340
379
                if (layer) {
341
380
                    frame = layer->frame(event->frameIndex());
342
381
                    if (frame) {
343
 
                        if (event->itemType() == KTLibraryObject::Svg && frame->svgItemsCount()>0) {
 
382
                        if (event->itemType() == TupLibraryObject::Svg && frame->svgItemsCount()>0) {
344
383
                            item = frame->svg(event->itemIndex());
345
384
                        } else if (frame->graphicItemsCount()>0) {
346
385
                                   item = frame->item(event->itemIndex());
349
388
                        return;
350
389
                    }
351
390
                }
352
 
            } else if (project->spaceContext() == KTProject::BACKGROUND_EDITION) {
353
 
                       KTBackground *bg = scene->background();
 
391
            } else if (project->spaceContext() == TupProject::BACKGROUND_EDITION) {
 
392
                       TupBackground *bg = scene->background();
354
393
                       if (bg) {
355
 
                           KTFrame *frame = bg->frame();
 
394
                           TupFrame *frame = bg->frame();
356
395
                           if (frame) {
357
 
                               if (event->itemType() == KTLibraryObject::Svg && frame->svgItemsCount()>0) {
 
396
                               if (event->itemType() == TupLibraryObject::Svg && frame->svgItemsCount()>0) {
358
397
                                   item = frame->svg(event->itemIndex());
359
398
                               } else if (frame->graphicItemsCount()>0) {
360
399
                                          item = frame->item(event->itemIndex());
372
411
 
373
412
    switch (event->action()) {
374
413
 
375
 
            case KTProjectRequest::Transform:
 
414
            case TupProjectRequest::Transform:
376
415
            {
377
416
                 if (item) {
378
417
 
393
432
                 }
394
433
            }
395
434
            break;
396
 
            case KTProjectRequest::Remove:
 
435
            case TupProjectRequest::Remove:
397
436
            {
398
437
                 // Do nothing
399
438
            }
439
478
               || (event->key() == Qt::Key_Right) || (event->key() == Qt::Key_Down)) {
440
479
 
441
480
               if (!k->selectionFlag) {
442
 
                   QPair<int, int> flags = KTToolPlugin::setKeyAction(event->key(), event->modifiers());
 
481
                   QPair<int, int> flags = TupToolPlugin::setKeyAction(event->key(), event->modifiers());
443
482
                   if (flags.first != -1 && flags.second != -1)
444
483
                       emit callForPlugin(flags.first, flags.second);
445
484
               } else {
474
513
               foreach (NodeManager *nodeManager, k->nodeManagers)
475
514
                        nodeManager->setProportion(true);
476
515
    } else {
477
 
        QPair<int, int> flags = KTToolPlugin::setKeyAction(event->key(), event->modifiers());
 
516
        QPair<int, int> flags = TupToolPlugin::setKeyAction(event->key(), event->modifiers());
478
517
        if (flags.first != -1 && flags.second != -1)
479
518
            emit callForPlugin(flags.first, flags.second);
480
519
    }
490
529
    }
491
530
}
492
531
 
493
 
void SelectTool::updateItems(KTGraphicsScene *scene)
 
532
void SelectTool::updateItems(TupGraphicsScene *scene)
494
533
{
495
534
    foreach (QGraphicsView *view, scene->views()) {
496
535
             view->setDragMode(QGraphicsView::RubberBandDrag);
497
536
             foreach (QGraphicsItem *item, scene->items()) {
498
537
                      if (!qgraphicsitem_cast<Node *>(item)) {
499
 
                          if (scene->spaceMode() == KTProject::FRAMES_EDITION) {
 
538
                          if (scene->spaceMode() == TupProject::FRAMES_EDITION) {
500
539
                              if (item->zValue() >= 10000) {
501
540
                                  item->setFlags(QGraphicsItem::ItemIsSelectable | QGraphicsItem::ItemIsMovable);
502
541
                              } else {
542
581
                      if (manager->isModified()) {
543
582
 
544
583
                          QDomDocument doc;
545
 
                          doc.appendChild(KTSerializer::properties(manager->parentItem(), doc));
 
584
                          doc.appendChild(TupSerializer::properties(manager->parentItem(), doc));
546
585
 
547
 
                          KTSvgItem *svg = qgraphicsitem_cast<KTSvgItem *>(manager->parentItem());
 
586
                          TupSvgItem *svg = qgraphicsitem_cast<TupSvgItem *>(manager->parentItem());
548
587
                          int position = -1;
549
 
                          KTLibraryObject::Type type;
 
588
                          TupLibraryObject::Type type;
550
589
 
551
590
                          if (svg) {
552
591
                              position  = k->scene->currentFrame()->indexOf(svg);
553
 
                              type = KTLibraryObject::Svg;
 
592
                              type = TupLibraryObject::Svg;
554
593
                          } else {
555
594
                              position  = k->scene->currentFrame()->indexOf(manager->parentItem());
556
 
                              type = KTLibraryObject::Item;
 
595
                              type = TupLibraryObject::Item;
557
596
                          }
558
597
 
559
598
                          foreach (QGraphicsView *view, k->scene->views())
561
600
 
562
601
                          manager->restoreItem();
563
602
 
564
 
                          KTProjectRequest event = KTRequestBuilder::createItemRequest(
 
603
                          TupProjectRequest event = TupRequestBuilder::createItemRequest(
565
604
                                                   k->scene->currentSceneIndex(),
566
605
                                                   k->scene->currentLayerIndex(),
567
606
                                                   k->scene->currentFrameIndex(), position, QPointF(), 
568
607
                                                   k->scene->spaceMode(), type,
569
 
                                                   KTProjectRequest::Transform, doc.toString());
 
608
                                                   TupProjectRequest::Transform, doc.toString());
570
609
                          emit requested(&event);
571
610
                      }
572
611
             }
578
617
    return QCursor(Qt::ArrowCursor);
579
618
}
580
619
 
581
 
Q_EXPORT_PLUGIN2(kt_select, SelectTool);
 
620
void SelectTool::resizeNodes(qreal scaleFactor)
 
621
{
 
622
    k->scaleFactor *= scaleFactor;
 
623
    updateRealZoomFactor();
 
624
 
 
625
    foreach (NodeManager *manager, k->nodeManagers)
 
626
             manager->resizeNodes(k->realFactor);
 
627
}
 
628
 
 
629
void SelectTool::updateZoomFactor(qreal globalFactor)
 
630
{
 
631
    k->scaleFactor = globalFactor;
 
632
    updateRealZoomFactor();
 
633
}
 
634
 
 
635
void SelectTool::updateRealZoomFactor()
 
636
{
 
637
    if (k->scaleFactor <= 1)
 
638
        k->realFactor = 1;
 
639
    else if (k->scaleFactor > 1 && k->scaleFactor < 1.5)
 
640
             k->realFactor = 0.8;
 
641
    else if (k->scaleFactor >= 1.5 && k->scaleFactor < 2)
 
642
             k->realFactor = 0.6;
 
643
    else if (k->scaleFactor >= 2 && k->scaleFactor <= 3)
 
644
             k->realFactor = 0.4;
 
645
    else if (k->scaleFactor > 3)
 
646
             k->realFactor = 0.3;
 
647
    else if (k->scaleFactor > 4)
 
648
             k->realFactor = 0.2;
 
649
}
 
650
 
 
651
void SelectTool::sceneResponse(const TupSceneResponse *event)
 
652
{
 
653
    if (event->action() == TupProjectRequest::Select)
 
654
        reset(k->scene);
 
655
}
 
656
 
 
657
Q_EXPORT_PLUGIN2(tup_select, SelectTool);