git.sesse.net Git - kdenlive/blob - src/customtrackview.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Jean-Baptiste Mardelle (jb@kdenlive.org)        *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  18  ***************************************************************************/
  19
  20
  21 #include "customtrackview.h"
  22 #include "customtrackscene.h"
  23 #include "docclipbase.h"
  24 #include "clipitem.h"
  25 #include "definitions.h"
  26 #include "moveclipcommand.h"
  27 #include "movetransitioncommand.h"
  28 #include "resizeclipcommand.h"
  29 #include "editguidecommand.h"
  30 #include "addtimelineclipcommand.h"
  31 #include "addeffectcommand.h"
  32 #include "editeffectcommand.h"
  33 #include "moveeffectcommand.h"
  34 #include "addtransitioncommand.h"
  35 #include "edittransitioncommand.h"
  36 #include "editkeyframecommand.h"
  37 #include "changespeedcommand.h"
  38 #include "addmarkercommand.h"
  39 #include "razorclipcommand.h"
  40 #include "kdenlivesettings.h"
  41 #include "transition.h"
  42 #include "clipmanager.h"
  43 #include "renderer.h"
  44 #include "markerdialog.h"
  45 #include "mainwindow.h"
  46 #include "ui_keyframedialog_ui.h"
  47 #include "clipdurationdialog.h"
  48 #include "abstractgroupitem.h"
  49 #include "insertspacecommand.h"
  50 #include "spacerdialog.h"
  51 #include "addtrackcommand.h"
  52 #include "changetrackcommand.h"
  53 #include "movegroupcommand.h"
  54 #include "ui_addtrack_ui.h"
  55 #include "initeffects.h"
  56 #include "locktrackcommand.h"
  57 #include "groupclipscommand.h"
  58 #include "splitaudiocommand.h"
  59 #include "changecliptypecommand.h"
  60
  61 #include <KDebug>
  62 #include <KLocale>
  63 #include <KUrl>
  64 #include <KIcon>
  65 #include <KCursor>
  66 #include <KColorScheme>
  67
  68 #include <QMouseEvent>
  69 #include <QStylePainter>
  70 #include <QGraphicsItem>
  71 #include <QDomDocument>
  72 #include <QScrollBar>
  73 #include <QApplication>
  74 #include <QInputDialog>
  75
  76
  77 bool sortGuidesList(const Guide *g1 , const Guide *g2)
  78 {
  79     return (*g1).position() < (*g2).position();
  80 }
  81
  82
  83 //TODO:
  84 // disable animation if user asked it in KDE's global settings
  85 // http://lists.kde.org/?l=kde-commits&m=120398724717624&w=2
  86 // needs something like below (taken from dolphin)
  87 // #include <kglobalsettings.h>
  88 // const bool animate = KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects;
  89 // const int duration = animate ? 1500 : 1;
  90
  91 CustomTrackView::CustomTrackView(KdenliveDoc *doc, CustomTrackScene* projectscene, QWidget *parent) :
  92         QGraphicsView(projectscene, parent),
  93         m_tracksHeight(KdenliveSettings::trackheight()),
  94         m_projectDuration(0),
  95         m_cursorPos(0),
  96         m_document(doc),
  97         m_scene(projectscene),
  98         m_cursorLine(NULL),
  99         m_operationMode(NONE),
 100         m_moveOpMode(NONE),
 101         m_dragItem(NULL),
 102         m_dragGuide(NULL),
 103         m_visualTip(NULL),
 104         m_animation(NULL),
 105         m_clickPoint(),
 106         m_autoScroll(KdenliveSettings::autoscroll()),
 107         m_pasteEffectsAction(NULL),
 108         m_ungroupAction(NULL),
 109         m_scrollOffset(0),
 110         m_clipDrag(false),
 111         m_findIndex(0),
 112         m_tool(SELECTTOOL),
 113         m_copiedItems(),
 114         m_menuPosition(),
 115         m_blockRefresh(false),
 116         m_selectionGroup(NULL)
 117 {
 118     if (doc) m_commandStack = doc->commandStack();
 119     else m_commandStack = NULL;
 120     setMouseTracking(true);
 121     setAcceptDrops(true);
 122     KdenliveSettings::setTrackheight(m_tracksHeight);
 123     m_animationTimer = new QTimeLine(800);
 124     m_animationTimer->setFrameRange(0, 5);
 125     m_animationTimer->setUpdateInterval(100);
 126     m_animationTimer->setLoopCount(0);
 127     m_tipColor = QColor(0, 192, 0, 200);
 128     QColor border = QColor(255, 255, 255, 100);
 129     m_tipPen.setColor(border);
 130     m_tipPen.setWidth(3);
 131     setContentsMargins(0, 0, 0, 0);
 132     const int maxWidth = m_tracksHeight * m_document->tracksCount();
 133     setSceneRect(0, 0, sceneRect().width(), maxWidth);
 134     verticalScrollBar()->setMaximum(maxWidth);
 135     m_cursorLine = projectscene->addLine(0, 0, 0, maxWidth);
 136     m_cursorLine->setZValue(1000);
 137
 138     KIcon razorIcon("edit-cut");
 139     m_razorCursor = QCursor(razorIcon.pixmap(22, 22));
 140
 141     KIcon spacerIcon("kdenlive-spacer-tool");
 142     m_spacerCursor = QCursor(spacerIcon.pixmap(22, 22));
 143     verticalScrollBar()->setTracking(true);
 144     // Line below was supposed to scroll guides label with scrollbar, not implemented yet
 145     //connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(slotRefreshGuides()));
 146     connect(&m_scrollTimer, SIGNAL(timeout()), this, SLOT(slotCheckMouseScrolling()));
 147     m_scrollTimer.setInterval(100);
 148     m_scrollTimer.setSingleShot(true);
 149
 150     connect(&m_thumbsTimer, SIGNAL(timeout()), this, SLOT(slotFetchNextThumbs()));
 151     m_thumbsTimer.setInterval(500);
 152     m_thumbsTimer.setSingleShot(true);
 153 }
 154
 155 CustomTrackView::~CustomTrackView()
 156 {
 157     qDeleteAll(m_guides);
 158     m_waitingThumbs.clear();
 159 }
 160
 161 void CustomTrackView::setDocumentModified()
 162 {
 163     m_document->setModified(true);
 164 }
 165
 166 void CustomTrackView::setContextMenu(QMenu *timeline, QMenu *clip, QMenu *transition, QActionGroup *clipTypeGroup)
 167 {
 168     m_timelineContextMenu = timeline;
 169     m_timelineContextClipMenu = clip;
 170     m_clipTypeGroup = clipTypeGroup;
 171     QList <QAction *> list = m_timelineContextClipMenu->actions();
 172     for (int i = 0; i < list.count(); i++) {
 173         if (list.at(i)->data().toString() == "paste_effects") m_pasteEffectsAction = list.at(i);
 174         else if (list.at(i)->data().toString() == "ungroup_clip") m_ungroupAction = list.at(i);
 175     }
 176
 177     m_timelineContextTransitionMenu = transition;
 178     list = m_timelineContextTransitionMenu->actions();
 179     for (int i = 0; i < list.count(); i++) {
 180         if (list.at(i)->data().toString() == "auto") {
 181             m_autoTransition = list.at(i);
 182             break;
 183         }
 184     }
 185
 186     m_timelineContextMenu->addSeparator();
 187     m_deleteGuide = new KAction(KIcon("edit-delete"), i18n("Delete Guide"), this);
 188     connect(m_deleteGuide, SIGNAL(triggered()), this, SLOT(slotDeleteTimeLineGuide()));
 189     m_timelineContextMenu->addAction(m_deleteGuide);
 190
 191     m_editGuide = new KAction(KIcon("document-properties"), i18n("Edit Guide"), this);
 192     connect(m_editGuide, SIGNAL(triggered()), this, SLOT(slotEditTimeLineGuide()));
 193     m_timelineContextMenu->addAction(m_editGuide);
 194 }
 195
 196 void CustomTrackView::checkAutoScroll()
 197 {
 198     m_autoScroll = KdenliveSettings::autoscroll();
 199 }
 200
 201 /*sQList <TrackInfo> CustomTrackView::tracksList() const {
 202     return m_scene->m_tracksList;
 203 }*/
 204
 205 void CustomTrackView::checkTrackHeight()
 206 {
 207     if (m_tracksHeight == KdenliveSettings::trackheight()) return;
 208     m_tracksHeight = KdenliveSettings::trackheight();
 209     emit trackHeightChanged();
 210     QList<QGraphicsItem *> itemList = items();
 211     ClipItem *item;
 212     Transition *transitionitem;
 213     bool snap = KdenliveSettings::snaptopoints();
 214     KdenliveSettings::setSnaptopoints(false);
 215     for (int i = 0; i < itemList.count(); i++) {
 216         if (itemList.at(i)->type() == AVWIDGET) {
 217             item = (ClipItem*) itemList.at(i);
 218             item->setRect(0, 0, item->rect().width(), m_tracksHeight - 1);
 219             item->setPos((qreal) item->startPos().frames(m_document->fps()), (qreal) item->track() * m_tracksHeight + 1);
 220             item->resetThumbs(true);
 221         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
 222             transitionitem = (Transition*) itemList.at(i);
 223             transitionitem->setRect(0, 0, transitionitem->rect().width(), m_tracksHeight / 3 * 2 - 1);
 224             transitionitem->setPos((qreal) transitionitem->startPos().frames(m_document->fps()), (qreal) transitionitem->track() * m_tracksHeight + m_tracksHeight / 3 * 2);
 225         }
 226     }
 227     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), m_tracksHeight * m_document->tracksCount());
 228
 229     for (int i = 0; i < m_guides.count(); i++) {
 230         QLineF l = m_guides.at(i)->line();
 231         l.setP2(QPointF(l.x2(), m_tracksHeight * m_document->tracksCount()));
 232         m_guides.at(i)->setLine(l);
 233     }
 234
 235     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_document->tracksCount());
 236 //     verticalScrollBar()->setMaximum(m_tracksHeight * m_document->tracksCount());
 237     KdenliveSettings::setSnaptopoints(snap);
 238     viewport()->update();
 239 }
 240
 241 /** Zoom or move viewport on mousewheel
 242  *
 243  * If mousewheel+Ctrl, zooms in/out on the timeline.
 244  *
 245  * With Ctrl, moves viewport towards end of timeline if down/back,
 246  * opposite on up/forward.
 247  *
 248  * See also http://www.kdenlive.org/mantis/view.php?id=265 */
 249 void CustomTrackView::wheelEvent(QWheelEvent * e)
 250 {
 251     if (e->modifiers() == Qt::ControlModifier) {
 252         if (e->delta() > 0) emit zoomIn();
 253         else emit zoomOut();
 254     } else {
 255         if (e->delta() <= 0) horizontalScrollBar()->setValue(horizontalScrollBar()->value() + horizontalScrollBar()->singleStep());
 256         else  horizontalScrollBar()->setValue(horizontalScrollBar()->value() - horizontalScrollBar()->singleStep());
 257     }
 258 }
 259
 260 int CustomTrackView::getPreviousVideoTrack(int track)
 261 {
 262     track = m_document->tracksCount() - track - 1;
 263     track --;
 264     for (int i = track; i > -1; i--) {
 265         if (m_document->trackInfoAt(i).type == VIDEOTRACK) return i + 1;
 266     }
 267     return 0;
 268 }
 269
 270
 271 void CustomTrackView::slotFetchNextThumbs()
 272 {
 273     if (!m_waitingThumbs.isEmpty()) {
 274         ClipItem *item = m_waitingThumbs.takeFirst();
 275         while ((item == NULL) && !m_waitingThumbs.isEmpty()) {
 276             item = m_waitingThumbs.takeFirst();
 277         }
 278         if (item) item->slotFetchThumbs();
 279         if (!m_waitingThumbs.isEmpty()) m_thumbsTimer.start();
 280     }
 281 }
 282
 283 void CustomTrackView::slotCheckMouseScrolling()
 284 {
 285     if (m_scrollOffset == 0) {
 286         m_scrollTimer.stop();
 287         return;
 288     }
 289     horizontalScrollBar()->setValue(horizontalScrollBar()->value() + m_scrollOffset);
 290     m_scrollTimer.start();
 291 }
 292
 293 void CustomTrackView::slotCheckPositionScrolling()
 294 {
 295     // If mouse is at a border of the view, scroll
 296     if (m_moveOpMode != SEEK) return;
 297     if (mapFromScene(m_cursorPos, 0).x() < 3) {
 298         horizontalScrollBar()->setValue(horizontalScrollBar()->value() - 2);
 299         QTimer::singleShot(200, this, SLOT(slotCheckPositionScrolling()));
 300         setCursorPos(mapToScene(QPoint(-2, 0)).x());
 301     } else if (viewport()->width() - 3 < mapFromScene(m_cursorPos + 1, 0).x()) {
 302         horizontalScrollBar()->setValue(horizontalScrollBar()->value() + 2);
 303         setCursorPos(mapToScene(QPoint(viewport()->width(), 0)).x() + 1);
 304         QTimer::singleShot(200, this, SLOT(slotCheckPositionScrolling()));
 305     }
 306 }
 307
 308
 309 // virtual
 310
 311 void CustomTrackView::mouseMoveEvent(QMouseEvent * event)
 312 {
 313     int pos = event->x();
 314     int mappedXPos = (int)(mapToScene(event->pos()).x() + 0.5);
 315     emit mousePosition(mappedXPos);
 316
 317     if (event->buttons() & Qt::MidButton) return;
 318     if (m_operationMode == RUBBERSELECTION || (event->modifiers() == Qt::ControlModifier && m_tool != SPACERTOOL)) {
 319         QGraphicsView::mouseMoveEvent(event);
 320         m_moveOpMode = NONE;
 321         return;
 322     }
 323
 324     if (event->buttons() != Qt::NoButton) {
 325         bool move = (event->pos() - m_clickEvent).manhattanLength() >= QApplication::startDragDistance();
 326         if (m_dragItem && m_tool == SELECTTOOL) {
 327             if (m_operationMode == MOVE && move) {
 328                 QGraphicsView::mouseMoveEvent(event);
 329                 // If mouse is at a border of the view, scroll
 330                 if (pos < 5) {
 331                     m_scrollOffset = -30;
 332                     m_scrollTimer.start();
 333                 } else if (viewport()->width() - pos < 10) {
 334                     m_scrollOffset = 30;
 335                     m_scrollTimer.start();
 336                 } else if (m_scrollTimer.isActive()) m_scrollTimer.stop();
 337
 338             } else if (m_operationMode == RESIZESTART && move) {
 339                 double snappedPos = getSnapPointForPos(mappedXPos);
 340                 m_document->renderer()->pause();
 341                 m_dragItem->resizeStart((int)(snappedPos));
 342             } else if (m_operationMode == RESIZEEND && move) {
 343                 double snappedPos = getSnapPointForPos(mappedXPos);
 344                 m_document->renderer()->pause();
 345                 m_dragItem->resizeEnd((int)(snappedPos));
 346             } else if (m_operationMode == FADEIN && move) {
 347                 ((ClipItem*) m_dragItem)->setFadeIn((int)(mappedXPos - m_dragItem->startPos().frames(m_document->fps())));
 348             } else if (m_operationMode == FADEOUT && move) {
 349                 ((ClipItem*) m_dragItem)->setFadeOut((int)(m_dragItem->endPos().frames(m_document->fps()) - mappedXPos));
 350             } else if (m_operationMode == KEYFRAME && move) {
 351                 GenTime keyFramePos = GenTime(mappedXPos, m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
 352                 double pos = mapToScene(event->pos()).toPoint().y();
 353                 QRectF br = m_dragItem->sceneBoundingRect();
 354                 double maxh = 100.0 / br.height();
 355                 pos = (br.bottom() - pos) * maxh;
 356                 m_dragItem->updateKeyFramePos(keyFramePos, pos);
 357             }
 358
 359             delete m_animation;
 360             m_animation = NULL;
 361             delete m_visualTip;
 362             m_visualTip = NULL;
 363             return;
 364         } else if (m_operationMode == MOVEGUIDE) {
 365             delete m_animation;
 366             m_animation = NULL;
 367             delete m_visualTip;
 368             m_visualTip = NULL;
 369             QGraphicsView::mouseMoveEvent(event);
 370             return;
 371         } else if (m_operationMode == SPACER && move && m_selectionGroup) {
 372             // spacer tool
 373             int mappedClick = (int)(mapToScene(m_clickEvent).x() + 0.5);
 374             m_selectionGroup->setPos(mappedXPos + (((int) m_selectionGroup->boundingRect().topLeft().x() + 0.5) - mappedClick) , m_selectionGroup->pos().y());
 375         }
 376     }
 377
 378     if (m_tool == RAZORTOOL) {
 379         setCursor(m_razorCursor);
 380         //QGraphicsView::mouseMoveEvent(event);
 381         //return;
 382     } else if (m_tool == SPACERTOOL) {
 383         setCursor(m_spacerCursor);
 384         return;
 385     }
 386
 387     QList<QGraphicsItem *> itemList = items(event->pos());
 388     QGraphicsRectItem *item = NULL;
 389     OPERATIONTYPE opMode = NONE;
 390
 391     if (itemList.count() == 1 && itemList.at(0)->type() == GUIDEITEM) {
 392         opMode = MOVEGUIDE;
 393     } else for (int i = 0; i < itemList.count(); i++) {
 394             if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
 395                 item = (QGraphicsRectItem*) itemList.at(i);
 396                 break;
 397             }
 398         }
 399
 400     if (item && event->buttons() == Qt::NoButton) {
 401         AbstractClipItem *clip = static_cast <AbstractClipItem*>(item);
 402         if (m_tool == RAZORTOOL) {
 403             // razor tool over a clip, display current frame in monitor
 404             if (false && /*!m_blockRefresh && */item->type() == AVWIDGET) {
 405                 //TODO: solve crash when showing frame when moving razor over clip
 406                 emit showClipFrame(((ClipItem *) item)->baseClip(), mappedXPos - (clip->startPos() - clip->cropStart()).frames(m_document->fps()));
 407             }
 408             event->accept();
 409             return;
 410         }
 411         opMode = clip->operationMode(mapToScene(event->pos()));
 412         const double size = 5;
 413         if (opMode == m_moveOpMode) {
 414             QGraphicsView::mouseMoveEvent(event);
 415             return;
 416         } else {
 417             if (m_visualTip) {
 418                 m_animationTimer->stop();
 419                 delete m_animation;
 420                 m_animation = NULL;
 421                 delete m_visualTip;
 422                 m_visualTip = NULL;
 423             }
 424         }
 425         m_moveOpMode = opMode;
 426         if (opMode == MOVE) {
 427             setCursor(Qt::OpenHandCursor);
 428         } else if (opMode == RESIZESTART) {
 429             setCursor(KCursor("left_side", Qt::SizeHorCursor));
 430             if (m_visualTip == NULL) {
 431                 QRectF rect = clip->sceneBoundingRect();
 432                 QPolygon polygon;
 433                 polygon << QPoint(0, - size * 2);
 434                 polygon << QPoint(size * 2, 0);
 435                 polygon << QPoint(0, size * 2);
 436                 polygon << QPoint(0, - size * 2);
 437
 438                 m_visualTip = new QGraphicsPolygonItem(polygon);
 439                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 440                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 441                 m_visualTip->setPos(rect.x(), rect.y() + rect.height() / 2);
 442                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 443                 m_visualTip->setZValue(100);
 444                 m_animation = new QGraphicsItemAnimation;
 445                 m_animation->setItem(m_visualTip);
 446                 m_animation->setTimeLine(m_animationTimer);
 447                 m_animation->setScaleAt(.5, 2, 1);
 448                 m_animation->setScaleAt(1, 1, 1);
 449                 scene()->addItem(m_visualTip);
 450                 m_animationTimer->start();
 451             }
 452         } else if (opMode == RESIZEEND) {
 453             setCursor(KCursor("right_side", Qt::SizeHorCursor));
 454             if (m_visualTip == NULL) {
 455                 QRectF rect = clip->sceneBoundingRect();
 456                 QPolygon polygon;
 457                 polygon << QPoint(0, - size * 2);
 458                 polygon << QPoint(- size * 2, 0);
 459                 polygon << QPoint(0, size * 2);
 460                 polygon << QPoint(0, - size * 2);
 461
 462                 m_visualTip = new QGraphicsPolygonItem(polygon);
 463                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 464                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 465                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 466                 m_visualTip->setPos(rect.right(), rect.y() + rect.height() / 2);
 467                 m_visualTip->setZValue(100);
 468                 m_animation = new QGraphicsItemAnimation;
 469                 m_animation->setItem(m_visualTip);
 470                 m_animation->setTimeLine(m_animationTimer);
 471                 m_animation->setScaleAt(.5, 2, 1);
 472                 m_animation->setScaleAt(1, 1, 1);
 473                 scene()->addItem(m_visualTip);
 474                 m_animationTimer->start();
 475             }
 476         } else if (opMode == FADEIN) {
 477             if (m_visualTip == NULL) {
 478                 ClipItem *item = (ClipItem *) clip;
 479                 QRectF rect = clip->sceneBoundingRect();
 480                 m_visualTip = new QGraphicsEllipseItem(-size, -size, size * 2, size * 2);
 481                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 482                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 483                 m_visualTip->setPos(rect.x() + item->fadeIn(), rect.y());
 484                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 485                 m_visualTip->setZValue(100);
 486                 m_animation = new QGraphicsItemAnimation;
 487                 m_animation->setItem(m_visualTip);
 488                 m_animation->setTimeLine(m_animationTimer);
 489                 m_animation->setScaleAt(.5, 2, 2);
 490                 m_animation->setScaleAt(1, 1, 1);
 491                 scene()->addItem(m_visualTip);
 492                 m_animationTimer->start();
 493             }
 494             setCursor(Qt::PointingHandCursor);
 495         } else if (opMode == FADEOUT) {
 496             if (m_visualTip == NULL) {
 497                 ClipItem *item = (ClipItem *) clip;
 498                 QRectF rect = clip->sceneBoundingRect();
 499                 m_visualTip = new QGraphicsEllipseItem(-size, -size, size * 2, size * 2);
 500                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 501                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 502                 m_visualTip->setPos(rect.right() - item->fadeOut(), rect.y());
 503                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 504                 m_visualTip->setZValue(100);
 505                 m_animation = new QGraphicsItemAnimation;
 506                 m_animation->setItem(m_visualTip);
 507                 m_animation->setTimeLine(m_animationTimer);
 508                 m_animation->setScaleAt(.5, 2, 2);
 509                 m_animation->setScaleAt(1, 1, 1);
 510                 scene()->addItem(m_visualTip);
 511                 m_animationTimer->start();
 512             }
 513             setCursor(Qt::PointingHandCursor);
 514         } else if (opMode == TRANSITIONSTART) {
 515             if (m_visualTip == NULL) {
 516                 QRectF rect = clip->sceneBoundingRect();
 517                 QPolygon polygon;
 518                 polygon << QPoint(0, - size * 2);
 519                 polygon << QPoint(size * 2, 0);
 520                 polygon << QPoint(0, 0);
 521                 polygon << QPoint(0, - size * 2);
 522
 523                 m_visualTip = new QGraphicsPolygonItem(polygon);
 524                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 525                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 526                 m_visualTip->setPos(rect.x(), rect.bottom());
 527                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 528                 m_visualTip->setZValue(100);
 529                 m_animation = new QGraphicsItemAnimation;
 530                 m_animation->setItem(m_visualTip);
 531                 m_animation->setTimeLine(m_animationTimer);
 532                 m_animation->setScaleAt(.5, 2, 2);
 533                 m_animation->setScaleAt(1, 1, 1);
 534                 scene()->addItem(m_visualTip);
 535                 m_animationTimer->start();
 536             }
 537             setCursor(Qt::PointingHandCursor);
 538         } else if (opMode == TRANSITIONEND) {
 539             if (m_visualTip == NULL) {
 540                 QRectF rect = clip->sceneBoundingRect();
 541                 QPolygon polygon;
 542                 polygon << QPoint(0, - size * 2);
 543                 polygon << QPoint(- size * 2, 0);
 544                 polygon << QPoint(0, 0);
 545                 polygon << QPoint(0, - size * 2);
 546
 547                 m_visualTip = new QGraphicsPolygonItem(polygon);
 548                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 549                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 550                 m_visualTip->setPos(rect.right(), rect.bottom());
 551                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 552                 m_visualTip->setZValue(100);
 553                 m_animation = new QGraphicsItemAnimation;
 554                 m_animation->setItem(m_visualTip);
 555                 m_animation->setTimeLine(m_animationTimer);
 556                 m_animation->setScaleAt(.5, 2, 2);
 557                 m_animation->setScaleAt(1, 1, 1);
 558                 scene()->addItem(m_visualTip);
 559                 m_animationTimer->start();
 560             }
 561             setCursor(Qt::PointingHandCursor);
 562         } else if (opMode == KEYFRAME) {
 563             setCursor(Qt::PointingHandCursor);
 564         }
 565     } // no clip under mouse
 566     else if (m_tool == RAZORTOOL) {
 567         event->accept();
 568         return;
 569     } else if (opMode == MOVEGUIDE) {
 570         m_moveOpMode = opMode;
 571         setCursor(Qt::SplitHCursor);
 572     } else {
 573         if (m_visualTip) {
 574             m_animationTimer->stop();
 575             delete m_animation;
 576             m_animation = NULL;
 577             delete m_visualTip;
 578             m_visualTip = NULL;
 579
 580         }
 581         setCursor(Qt::ArrowCursor);
 582         if (event->buttons() != Qt::NoButton && event->modifiers() == Qt::NoModifier) {
 583             QGraphicsView::mouseMoveEvent(event);
 584             m_moveOpMode = SEEK;
 585             setCursorPos(mappedXPos);
 586             slotCheckPositionScrolling();
 587             return;
 588         } else m_moveOpMode = NONE;
 589     }
 590     QGraphicsView::mouseMoveEvent(event);
 591 }
 592
 593 // virtual
 594 void CustomTrackView::mousePressEvent(QMouseEvent * event)
 595 {
 596     //kDebug() << "mousePressEvent STARTED";
 597     setFocus(Qt::MouseFocusReason);
 598     m_menuPosition = QPoint();
 599
 600     // special cases (middle click button or ctrl / shift click
 601     if (event->button() == Qt::MidButton) {
 602         m_document->renderer()->switchPlay();
 603         m_blockRefresh = false;
 604         m_operationMode = NONE;
 605         return;
 606     }
 607
 608     if (event->modifiers() & Qt::ShiftModifier) {
 609         setDragMode(QGraphicsView::RubberBandDrag);
 610         if (!(event->modifiers() & Qt::ControlModifier)) {
 611             resetSelectionGroup();
 612             scene()->clearSelection();
 613         }
 614         QGraphicsView::mousePressEvent(event);
 615         m_blockRefresh = false;
 616         m_operationMode = RUBBERSELECTION;
 617         return;
 618     }
 619
 620     m_blockRefresh = true;
 621     m_dragGuide = NULL;
 622     bool collision = false;
 623
 624     if (m_tool != RAZORTOOL) activateMonitor();
 625     else if (m_document->renderer()->playSpeed() != 0.0) {
 626         m_document->renderer()->pause();
 627         return;
 628     }
 629     m_clickEvent = event->pos();
 630
 631     // check item under mouse
 632     QList<QGraphicsItem *> collisionList = items(m_clickEvent);
 633
 634     if (event->modifiers() == Qt::ControlModifier && m_tool != SPACERTOOL && collisionList.count() == 0) {
 635         setDragMode(QGraphicsView::ScrollHandDrag);
 636         QGraphicsView::mousePressEvent(event);
 637         m_blockRefresh = false;
 638         m_operationMode = NONE;
 639         return;
 640     }
 641
 642     // if a guide and a clip were pressed, just select the guide
 643     for (int i = 0; i < collisionList.count(); ++i) {
 644         if (collisionList.at(i)->type() == GUIDEITEM) {
 645             // a guide item was pressed
 646             m_dragGuide = (Guide *) collisionList.at(i);
 647             if (event->button() == Qt::LeftButton) { // move it
 648                 m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, true);
 649                 collision = true;
 650                 m_operationMode = MOVEGUIDE;
 651                 // deselect all clips so that only the guide will move
 652                 m_scene->clearSelection();
 653                 resetSelectionGroup(false);
 654                 updateSnapPoints(NULL);
 655                 QGraphicsView::mousePressEvent(event);
 656                 return;
 657             } else // show context menu
 658                 break;
 659         }
 660     }
 661
 662     // Find first clip, transition or group under mouse (when no guides selected)
 663     int ct = 0;
 664     AbstractGroupItem *dragGroup = NULL;
 665     AbstractClipItem *collisionClip = NULL;
 666     bool found = false;
 667     while (!m_dragGuide && ct < collisionList.count()) {
 668         if (collisionList.at(ct)->type() == AVWIDGET || collisionList.at(ct)->type() == TRANSITIONWIDGET) {
 669             collisionClip = static_cast <AbstractClipItem *>(collisionList.at(ct));
 670             if (collisionClip == m_dragItem) {
 671                 collisionClip = NULL;
 672             } else m_dragItem = collisionClip;
 673             found = true;
 674             m_dragItemInfo = m_dragItem->info();
 675             if (m_dragItem->parentItem() && m_dragItem->parentItem()->type() == GROUPWIDGET && m_dragItem->parentItem() != m_selectionGroup) {
 676                 // kDebug()<<"// KLIK FOUND GRP: "<<m_dragItem->sceneBoundingRect();
 677                 dragGroup = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
 678             }
 679             break;
 680         }
 681         ct++;
 682     }
 683     if (!found) m_dragItem = NULL;
 684
 685     if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
 686         // update transition menu action
 687         m_autoTransition->setChecked(static_cast<Transition *>(m_dragItem)->isAutomatic());
 688         m_autoTransition->setEnabled(true);
 689     } else m_autoTransition->setEnabled(false);
 690
 691     // context menu requested
 692     if (event->button() == Qt::RightButton) {
 693         if (m_dragItem) {
 694             if (dragGroup) dragGroup->setSelected(true);
 695             else if (!m_dragItem->isSelected()) {
 696                 resetSelectionGroup(false);
 697                 m_scene->clearSelection();
 698                 m_dragItem->setSelected(true);
 699             }
 700         } else if (!m_dragGuide) {
 701             // check if there is a guide close to mouse click
 702             QList<QGraphicsItem *> guidesCollisionList = items(event->pos().x() - 5, event->pos().y(), 10, 2); // a rect of height < 2 does not always collide with the guide
 703             for (int i = 0; i < guidesCollisionList.count(); i++) {
 704                 if (guidesCollisionList.at(i)->type() == GUIDEITEM) {
 705                     m_dragGuide = static_cast <Guide *>(guidesCollisionList.at(i));
 706                     break;
 707                 }
 708             }
 709             // keep this to support multiple guides context menu in the future (?)
 710             /*if (guidesCollisionList.at(0)->type() != GUIDEITEM)
 711                 guidesCollisionList.removeAt(0);
 712             }
 713             if (!guidesCollisionList.isEmpty())
 714             m_dragGuide = static_cast <Guide *>(guidesCollisionList.at(0));*/
 715         }
 716
 717         m_operationMode = NONE;
 718         displayContextMenu(event->globalPos(), m_dragItem, dragGroup);
 719         m_menuPosition = m_clickEvent;
 720         m_dragItem = NULL;
 721         event->accept();
 722         return;
 723     }
 724
 725     // No item under click
 726     if (m_dragItem == NULL || m_tool == SPACERTOOL) {
 727         resetSelectionGroup(false);
 728         setCursor(Qt::ArrowCursor);
 729         m_scene->clearSelection();
 730         //event->accept();
 731         emit clipItemSelected(NULL);
 732         updateClipTypeActions(NULL);
 733         if (m_tool == SPACERTOOL) {
 734             QList<QGraphicsItem *> selection;
 735             if (event->modifiers() == Qt::ControlModifier) {
 736                 // Ctrl + click, select all items on track after click position
 737                 int track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
 738                 selection = items(m_clickEvent.x(), track * m_tracksHeight + m_tracksHeight / 2, mapFromScene(sceneRect().width(), 0).x() - m_clickEvent.x(), m_tracksHeight / 2 - 2);
 739
 740                 kDebug() << "SPACER TOOL + CTRL, SELECTING ALL CLIPS ON TRACK " << track << " WITH SELECTION RECT " << m_clickEvent.x() << "/" <<  track * m_tracksHeight + 1 << "; " << mapFromScene(sceneRect().width(), 0).x() - m_clickEvent.x() << "/" << m_tracksHeight - 2;
 741             } else {
 742                 // Select all items on all tracks after click position
 743                 selection = items(event->pos().x(), 1, mapFromScene(sceneRect().width(), 0).x() - event->pos().x(), sceneRect().height());
 744                 kDebug() << "SELELCTING ELEMENTS WITHIN =" << event->pos().x() << "/" <<  1 << ", " << mapFromScene(sceneRect().width(), 0).x() - event->pos().x() << "/" << sceneRect().height();
 745             }
 746
 747             QList <GenTime> offsetList;
 748             for (int i = 0; i < selection.count(); i++) {
 749                 if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
 750                     AbstractClipItem *item = static_cast<AbstractClipItem *>(selection.at(i));
 751                     offsetList.append(item->startPos());
 752                     offsetList.append(item->endPos());
 753                     selection.at(i)->setSelected(true);
 754                 }
 755                 if (selection.at(i)->type() == GROUPWIDGET) {
 756                     QList<QGraphicsItem *> children = selection.at(i)->childItems();
 757                     for (int j = 0; j < children.count(); j++) {
 758                         AbstractClipItem *item = static_cast<AbstractClipItem *>(children.at(j));
 759                         offsetList.append(item->startPos());
 760                         offsetList.append(item->endPos());
 761                     }
 762                     selection.at(i)->setSelected(true);
 763                 }
 764             }
 765
 766             if (!offsetList.isEmpty()) {
 767                 qSort(offsetList);
 768                 QList <GenTime> cleandOffsetList;
 769                 GenTime startOffset = offsetList.takeFirst();
 770                 for (int k = 0; k < offsetList.size(); k++) {
 771                     GenTime newoffset = offsetList.at(k) - startOffset;
 772                     if (newoffset != GenTime() && !cleandOffsetList.contains(newoffset)) {
 773                         cleandOffsetList.append(newoffset);
 774                     }
 775                 }
 776                 updateSnapPoints(NULL, cleandOffsetList, true);
 777             }
 778             groupSelectedItems(true);
 779             m_operationMode = SPACER;
 780         } else setCursorPos((int)(mapToScene(event->x(), 0).x()));
 781         QGraphicsView::mousePressEvent(event);
 782         return;
 783     }
 784
 785     // Razor tool
 786     if (m_tool == RAZORTOOL && m_dragItem) {
 787         if (m_dragItem->type() == TRANSITIONWIDGET) {
 788             emit displayMessage(i18n("Cannot cut a transition"), ErrorMessage);
 789             event->accept();
 790             m_dragItem = NULL;
 791             return;
 792         } else if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
 793             emit displayMessage(i18n("Cannot cut a clip in a group"), ErrorMessage);
 794             event->accept();
 795             m_dragItem = NULL;
 796             return;
 797         }
 798         AbstractClipItem *clip = static_cast <AbstractClipItem *>(m_dragItem);
 799         RazorClipCommand* command = new RazorClipCommand(this, clip->info(), GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()));
 800         m_document->renderer()->pause();
 801         m_commandStack->push(command);
 802         setDocumentModified();
 803         m_dragItem = NULL;
 804         event->accept();
 805         return;
 806     }
 807
 808     if (dragGroup == NULL) updateSnapPoints(m_dragItem);
 809     else {
 810         QList <GenTime> offsetList;
 811         QList<QGraphicsItem *> children = dragGroup->childItems();
 812         for (int i = 0; i < children.count(); i++) {
 813             if (children.at(i)->type() == AVWIDGET || children.at(i)->type() == TRANSITIONWIDGET) {
 814                 AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
 815                 offsetList.append(item->startPos());
 816                 offsetList.append(item->endPos());
 817             }
 818         }
 819         if (!offsetList.isEmpty()) {
 820             qSort(offsetList);
 821             GenTime startOffset = offsetList.takeFirst();
 822             QList <GenTime> cleandOffsetList;
 823             for (int k = 0; k < offsetList.size(); k++) {
 824                 GenTime newoffset = offsetList.at(k) - startOffset;
 825                 if (newoffset != GenTime() && !cleandOffsetList.contains(newoffset)) {
 826                     cleandOffsetList.append(newoffset);
 827                 }
 828             }
 829             updateSnapPoints(NULL, cleandOffsetList, true);
 830         }
 831     }
 832
 833     bool itemSelected = false;
 834     if (m_dragItem->isSelected()) itemSelected = true;
 835     else if (m_dragItem->parentItem() && m_dragItem->parentItem()->isSelected()) itemSelected = true;
 836     else if (dragGroup && dragGroup->isSelected()) itemSelected = true;
 837     if (event->modifiers() == Qt::ControlModifier || itemSelected == false) {
 838         if (event->modifiers() != Qt::ControlModifier) m_scene->clearSelection();
 839         resetSelectionGroup();
 840         dragGroup = NULL;
 841         if (m_dragItem->parentItem() && m_dragItem->parentItem()->type() == GROUPWIDGET) {
 842             //kDebug()<<"// KLIK FOUND GRP: "<<m_dragItem->sceneBoundingRect();
 843             dragGroup = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
 844         }
 845         bool selected = !m_dragItem->isSelected();
 846         if (dragGroup) dragGroup->setSelected(selected);
 847         else m_dragItem->setSelected(selected);
 848
 849         groupSelectedItems();
 850         ClipItem *clip = static_cast <ClipItem *>(m_dragItem);
 851         updateClipTypeActions(dragGroup == NULL ? clip : NULL);
 852         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
 853     }
 854
 855     if (collisionClip != NULL || m_dragItem == NULL) {
 856         if (m_dragItem && m_dragItem->type() == AVWIDGET && !m_dragItem->isItemLocked()) {
 857             kDebug() << "//////// CLIP ITEM SELECTED, TRANSMITTING . . . . . . .";
 858             ClipItem *selected = static_cast <ClipItem*>(m_dragItem);
 859             emit clipItemSelected(selected);
 860         } else emit clipItemSelected(NULL);
 861     }
 862
 863     // If clicked item is selected, allow move
 864     if (event->modifiers() != Qt::ControlModifier && m_operationMode == NONE/* && (m_dragItem->isSelected() || (dragGroup && dragGroup->isSelected()))*/) QGraphicsView::mousePressEvent(event);
 865
 866     m_clickPoint = QPoint((int)(mapToScene(event->pos()).x() - m_dragItem->startPos().frames(m_document->fps())), (int)(event->pos().y() - m_dragItem->pos().y()));
 867     m_operationMode = m_dragItem->operationMode(mapToScene(event->pos()));
 868
 869     if (m_operationMode == KEYFRAME) {
 870         m_dragItem->updateSelectedKeyFrame();
 871         m_blockRefresh = false;
 872         return;
 873     } else if (m_operationMode == MOVE) {
 874         setCursor(Qt::ClosedHandCursor);
 875     } else if (m_operationMode == TRANSITIONSTART && event->modifiers() != Qt::ControlModifier) {
 876         ItemInfo info;
 877         info.startPos = m_dragItem->startPos();
 878         info.track = m_dragItem->track();
 879         int transitiontrack = getPreviousVideoTrack(info.track);
 880         ClipItem *transitionClip = NULL;
 881         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
 882         if (transitionClip && transitionClip->endPos() < m_dragItem->endPos()) {
 883             info.endPos = transitionClip->endPos();
 884         } else info.endPos = info.startPos + GenTime(65, m_document->fps());
 885         if (info.endPos == info.startPos) info.endPos = info.startPos + GenTime(65, m_document->fps());
 886         // Check there is no other transition at that place
 887         double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
 888         QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
 889         QList<QGraphicsItem *> selection = m_scene->items(r);
 890         bool transitionAccepted = true;
 891         for (int i = 0; i < selection.count(); i++) {
 892             if (selection.at(i)->type() == TRANSITIONWIDGET) {
 893                 Transition *tr = static_cast <Transition *>(selection.at(i));
 894                 if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
 895                     if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
 896                 } else transitionAccepted = false;
 897             }
 898         }
 899         if (transitionAccepted) slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack);
 900         else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
 901     } else if (m_operationMode == TRANSITIONEND && event->modifiers() != Qt::ControlModifier) {
 902         ItemInfo info;
 903         info.endPos = GenTime(m_dragItem->endPos().frames(m_document->fps()), m_document->fps());
 904         info.track = m_dragItem->track();
 905         int transitiontrack = getPreviousVideoTrack(info.track);
 906         ClipItem *transitionClip = NULL;
 907         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
 908         if (transitionClip && transitionClip->startPos() > m_dragItem->startPos()) {
 909             info.startPos = transitionClip->startPos();
 910         } else info.startPos = info.endPos - GenTime(65, m_document->fps());
 911         if (info.endPos == info.startPos) info.startPos = info.endPos - GenTime(65, m_document->fps());
 912         QDomElement transition = MainWindow::transitions.getEffectByTag("luma", "dissolve").cloneNode().toElement();
 913         EffectsList::setParameter(transition, "reverse", "1");
 914
 915         // Check there is no other transition at that place
 916         double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
 917         QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
 918         QList<QGraphicsItem *> selection = m_scene->items(r);
 919         bool transitionAccepted = true;
 920         for (int i = 0; i < selection.count(); i++) {
 921             if (selection.at(i)->type() == TRANSITIONWIDGET) {
 922                 Transition *tr = static_cast <Transition *>(selection.at(i));
 923                 if (info.endPos - tr->endPos() > GenTime(5, m_document->fps())) {
 924                     if (tr->endPos() > info.startPos) info.startPos = tr->endPos();
 925                 } else transitionAccepted = false;
 926             }
 927         }
 928         if (transitionAccepted) slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack, transition);
 929         else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
 930
 931     } else if ((m_operationMode == RESIZESTART || m_operationMode == RESIZEEND) && m_selectionGroup) {
 932         resetSelectionGroup(false);
 933         m_dragItem->setSelected(true);
 934     }
 935
 936     m_blockRefresh = false;
 937     //kDebug()<<pos;
 938     //QGraphicsView::mousePressEvent(event);
 939 }
 940
 941 void CustomTrackView::resetSelectionGroup(bool selectItems)
 942 {
 943     if (m_selectionGroup) {
 944         // delete selection group
 945         bool snap = KdenliveSettings::snaptopoints();
 946         KdenliveSettings::setSnaptopoints(false);
 947
 948         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
 949         scene()->destroyItemGroup(m_selectionGroup);
 950         for (int i = 0; i < children.count(); i++) {
 951             if (children.at(i)->type() == AVWIDGET || children.at(i)->type() == TRANSITIONWIDGET) {
 952                 if (!static_cast <AbstractClipItem *>(children.at(i))->isItemLocked()) {
 953                     children.at(i)->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
 954                     children.at(i)->setSelected(selectItems);
 955                 }
 956             } else if (children.at(i)->type() == GROUPWIDGET) {
 957                 children.at(i)->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
 958                 children.at(i)->setSelected(selectItems);
 959             }
 960         }
 961         m_selectionGroup = NULL;
 962         KdenliveSettings::setSnaptopoints(snap);
 963     }
 964 }
 965
 966 void CustomTrackView::groupSelectedItems(bool force, bool createNewGroup)
 967 {
 968     if (m_selectionGroup) {
 969         kDebug() << "///// ERROR, TRYING TO OVERRIDE EXISTING GROUP";
 970         return;
 971     }
 972     QList<QGraphicsItem *> selection = m_scene->selectedItems();
 973     if (selection.isEmpty()) return;
 974     QPointF top = selection.at(0)->sceneBoundingRect().topLeft();
 975     // Find top left position of selection
 976     for (int i = 1; i < selection.count(); i++) {
 977         if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET) {
 978             QPointF currenttop = selection.at(i)->sceneBoundingRect().topLeft();
 979             if (currenttop.x() < top.x()) top.setX(currenttop.x());
 980             if (currenttop.y() < top.y()) top.setY(currenttop.y());
 981         }
 982     }
 983
 984     if (force || selection.count() > 1) {
 985         bool snap = KdenliveSettings::snaptopoints();
 986         KdenliveSettings::setSnaptopoints(false);
 987         if (createNewGroup) {
 988             AbstractGroupItem *newGroup = m_document->clipManager()->createGroup();
 989             newGroup->translate(-top.x(), -top.y() + 1);
 990             newGroup->setPos(top.x(), top.y() - 1);
 991             scene()->addItem(newGroup);
 992
 993             // CHeck if we are trying to include a group in a group
 994             QList <AbstractGroupItem *> groups;
 995             for (int i = 0; i < selection.count(); i++) {
 996                 if (selection.at(i)->type() == GROUPWIDGET && !groups.contains(static_cast<AbstractGroupItem *>(selection.at(i)))) {
 997                     groups.append(static_cast<AbstractGroupItem *>(selection.at(i)));
 998                 } else if (selection.at(i)->parentItem() && !groups.contains(static_cast<AbstractGroupItem *>(selection.at(i)->parentItem()))) groups.append(static_cast<AbstractGroupItem *>(selection.at(i)->parentItem()));
 999             }
1000             if (!groups.isEmpty()) {
1001                 // ungroup previous groups
1002                 while (!groups.isEmpty()) {
1003                     AbstractGroupItem *grp = groups.takeFirst();
1004                     m_document->clipManager()->removeGroup(grp);
1005                     scene()->destroyItemGroup(grp);
1006                 }
1007                 selection = m_scene->selectedItems();
1008             }
1009
1010             for (int i = 0; i < selection.count(); i++) {
1011                 if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
1012                     newGroup->addToGroup(selection.at(i));
1013                     selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1014                 }
1015             }
1016             KdenliveSettings::setSnaptopoints(snap);
1017         } else {
1018             m_selectionGroup = new AbstractGroupItem(m_document->fps());
1019             m_selectionGroup->translate(-top.x(), -top.y() + 1);
1020             m_selectionGroup->setPos(top.x(), top.y() - 1);
1021             scene()->addItem(m_selectionGroup);
1022             for (int i = 0; i < selection.count(); i++) {
1023                 if (selection.at(i)->parentItem() == NULL && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
1024                     m_selectionGroup->addToGroup(selection.at(i));
1025                     selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1026                 }
1027             }
1028             KdenliveSettings::setSnaptopoints(snap);
1029             if (m_selectionGroup) {
1030                 m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
1031                 m_selectionGroupInfo.track = m_selectionGroup->track();
1032             }
1033         }
1034     } else resetSelectionGroup();
1035 }
1036
1037 void CustomTrackView::mouseDoubleClickEvent(QMouseEvent *event)
1038 {
1039     if (m_dragItem && m_dragItem->hasKeyFrames()) {
1040         if (m_moveOpMode == KEYFRAME) {
1041             // user double clicked on a keyframe, open edit dialog
1042             QDialog d(parentWidget());
1043             Ui::KeyFrameDialog_UI view;
1044             view.setupUi(&d);
1045             view.kfr_position->setText(m_document->timecode().getTimecode(GenTime(m_dragItem->selectedKeyFramePos(), m_document->fps()) - m_dragItem->cropStart()));
1046             view.kfr_value->setValue(m_dragItem->selectedKeyFrameValue());
1047             view.kfr_value->setFocus();
1048             if (d.exec() == QDialog::Accepted) {
1049                 int pos = m_document->timecode().getFrameCount(view.kfr_position->text());
1050                 m_dragItem->updateKeyFramePos(GenTime(pos, m_document->fps()) + m_dragItem->cropStart(), (double) view.kfr_value->value() * m_dragItem->keyFrameFactor());
1051                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
1052                 QString previous = item->keyframes(item->selectedEffectIndex());
1053                 item->updateKeyframeEffect();
1054                 QString next = item->keyframes(item->selectedEffectIndex());
1055                 EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
1056                 m_commandStack->push(command);
1057                 updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
1058                 emit clipItemSelected(item, item->selectedEffectIndex());
1059             }
1060
1061         } else  {
1062             // add keyframe
1063             GenTime keyFramePos = GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
1064             m_dragItem->addKeyFrame(keyFramePos, mapToScene(event->pos()).toPoint().y());
1065             ClipItem * item = static_cast <ClipItem *>(m_dragItem);
1066             QString previous = item->keyframes(item->selectedEffectIndex());
1067             item->updateKeyframeEffect();
1068             QString next = item->keyframes(item->selectedEffectIndex());
1069             EditKeyFrameCommand *command = new EditKeyFrameCommand(this, m_dragItem->track(), m_dragItem->startPos(), item->selectedEffectIndex(), previous, next, false);
1070             m_commandStack->push(command);
1071             updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
1072             emit clipItemSelected(item, item->selectedEffectIndex());
1073         }
1074     } else if (m_dragItem && !m_dragItem->isItemLocked()) {
1075         ClipDurationDialog d(m_dragItem, m_document->timecode(), this);
1076         GenTime minimum;
1077         GenTime maximum;
1078         if (m_dragItem->type() == TRANSITIONWIDGET) {
1079             getTransitionAvailableSpace(m_dragItem, minimum, maximum);
1080         } else {
1081             getClipAvailableSpace(m_dragItem, minimum, maximum);
1082         }
1083         //kDebug()<<"// GOT MOVE POS: "<<minimum.frames(25)<<" - "<<maximum.frames(25);
1084         d.setMargins(minimum, maximum);
1085         if (d.exec() == QDialog::Accepted) {
1086             if (m_dragItem->type() == TRANSITIONWIDGET) {
1087                 // move & resize transition
1088                 ItemInfo startInfo;
1089                 startInfo.startPos = m_dragItem->startPos();
1090                 startInfo.endPos = m_dragItem->endPos();
1091                 startInfo.track = m_dragItem->track();
1092                 ItemInfo endInfo;
1093                 endInfo.startPos = d.startPos();
1094                 endInfo.endPos = endInfo.startPos + d.duration();
1095                 endInfo.track = m_dragItem->track();
1096                 MoveTransitionCommand *command = new MoveTransitionCommand(this, startInfo, endInfo, true);
1097                 m_commandStack->push(command);
1098             } else {
1099                 // move and resize clip
1100                 QUndoCommand *moveCommand = new QUndoCommand();
1101                 moveCommand->setText(i18n("Edit clip"));
1102                 ItemInfo clipInfo = m_dragItem->info();
1103                 if (d.duration() < m_dragItem->cropDuration() || d.cropStart() != clipInfo.cropStart) {
1104                     // duration was reduced, so process it first
1105                     ItemInfo startInfo = clipInfo;
1106                     clipInfo.endPos = clipInfo.startPos + d.duration();
1107                     clipInfo.cropStart = d.cropStart();
1108                     new ResizeClipCommand(this, startInfo, clipInfo, true, moveCommand);
1109                 }
1110                 if (d.startPos() != clipInfo.startPos) {
1111                     ItemInfo startInfo = clipInfo;
1112                     clipInfo.startPos = d.startPos();
1113                     clipInfo.endPos = m_dragItem->endPos() + (clipInfo.startPos - startInfo.startPos);
1114                     new MoveClipCommand(this, startInfo, clipInfo, true, moveCommand);
1115                 }
1116                 if (d.duration() > m_dragItem->cropDuration()) {
1117                     // duration was increased, so process it after move
1118                     ItemInfo startInfo = clipInfo;
1119                     clipInfo.endPos = clipInfo.startPos + d.duration();
1120                     clipInfo.cropStart = d.cropStart();
1121                     new ResizeClipCommand(this, startInfo, clipInfo, true, moveCommand);
1122                 }
1123                 m_commandStack->push(moveCommand);
1124             }
1125         }
1126     } else {
1127         QList<QGraphicsItem *> collisionList = items(event->pos());
1128         if (collisionList.count() == 1 && collisionList.at(0)->type() == GUIDEITEM) {
1129             Guide *editGuide = (Guide *) collisionList.at(0);
1130             if (editGuide) slotEditGuide(editGuide->info());
1131         }
1132     }
1133 }
1134
1135
1136 void CustomTrackView::editKeyFrame(const GenTime pos, const int track, const int index, const QString keyframes)
1137 {
1138     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), track);
1139     if (clip) {
1140         clip->setKeyframes(index, keyframes);
1141         updateEffect(m_document->tracksCount() - clip->track(), clip->startPos(), clip->effectAt(index), index);
1142     } else emit displayMessage(i18n("Cannot find clip with keyframe"), ErrorMessage);
1143 }
1144
1145
1146 void CustomTrackView::displayContextMenu(QPoint pos, AbstractClipItem *clip, AbstractGroupItem *group)
1147 {
1148     m_deleteGuide->setEnabled(m_dragGuide != NULL);
1149     m_editGuide->setEnabled(m_dragGuide != NULL);
1150     if (clip == NULL) m_timelineContextMenu->popup(pos);
1151     else if (group != NULL) {
1152         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1153         m_ungroupAction->setEnabled(true);
1154         updateClipTypeActions(NULL);
1155         m_timelineContextClipMenu->popup(pos);
1156     } else {
1157         m_ungroupAction->setEnabled(false);
1158         if (clip->type() == AVWIDGET) {
1159             ClipItem *item = static_cast <ClipItem*>(clip);
1160             updateClipTypeActions(item);
1161             m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1162             m_timelineContextClipMenu->popup(pos);
1163         } else if (clip->type() == TRANSITIONWIDGET) m_timelineContextTransitionMenu->popup(pos);
1164     }
1165 }
1166
1167 void CustomTrackView::activateMonitor()
1168 {
1169     emit activateDocumentMonitor();
1170 }
1171
1172 void CustomTrackView::dragEnterEvent(QDragEnterEvent * event)
1173 {
1174     if (event->mimeData()->hasFormat("kdenlive/clip")) {
1175         m_clipDrag = true;
1176         resetSelectionGroup();
1177         QStringList list = QString(event->mimeData()->data("kdenlive/clip")).split(';');
1178         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1179         QPoint pos;
1180         DocClipBase *clip = m_document->getBaseClip(list.at(0));
1181         if (clip == NULL) {
1182             kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << list.at(0);
1183             return;
1184         }
1185         ItemInfo info;
1186         info.startPos = GenTime();
1187         info.cropStart = GenTime(list.at(1).toInt(), m_document->fps());
1188         info.endPos = GenTime(list.at(2).toInt() - list.at(1).toInt(), m_document->fps());
1189         info.track = (int)(1 / m_tracksHeight);
1190         ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0, 1);
1191         m_selectionGroup->addToGroup(item);
1192         item->setFlags(QGraphicsItem::ItemIsSelectable);
1193         //TODO: check if we do not overlap another clip when first dropping in timeline
1194         // if (insertPossible(m_selectionGroup, event->pos()))
1195         QList <GenTime> offsetList;
1196         offsetList.append(info.endPos);
1197         updateSnapPoints(NULL, offsetList);
1198         scene()->addItem(m_selectionGroup);
1199         event->acceptProposedAction();
1200     } else if (event->mimeData()->hasFormat("kdenlive/producerslist")) {
1201         m_clipDrag = true;
1202         QStringList ids = QString(event->mimeData()->data("kdenlive/producerslist")).split(';');
1203         m_scene->clearSelection();
1204         resetSelectionGroup(false);
1205
1206         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1207         QPoint pos;
1208         GenTime start;
1209         QList <GenTime> offsetList;
1210         for (int i = 0; i < ids.size(); ++i) {
1211             DocClipBase *clip = m_document->getBaseClip(ids.at(i));
1212             if (clip == NULL) {
1213                 kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << ids.at(i);
1214                 return;
1215             }
1216             ItemInfo info;
1217             info.startPos = start;
1218             info.endPos = info.startPos + clip->duration();
1219             info.track = (int)(1 / m_tracksHeight);
1220             ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0, 1, false);
1221             start += clip->duration();
1222             offsetList.append(start);
1223             m_selectionGroup->addToGroup(item);
1224             item->setFlags(QGraphicsItem::ItemIsSelectable);
1225             m_waitingThumbs.append(item);
1226         }
1227         //TODO: check if we do not overlap another clip when first dropping in timeline
1228         //if (insertPossible(m_selectionGroup, event->pos()))
1229         updateSnapPoints(NULL, offsetList);
1230         scene()->addItem(m_selectionGroup);
1231         m_thumbsTimer.start();
1232         event->acceptProposedAction();
1233
1234     } else {
1235         // the drag is not a clip (may be effect, ...)
1236         m_clipDrag = false;
1237         QGraphicsView::dragEnterEvent(event);
1238     }
1239 }
1240
1241
1242 bool CustomTrackView::insertPossible(AbstractGroupItem *group, const QPoint &pos) const
1243 {
1244     QPolygonF path;
1245     QList<QGraphicsItem *> children = group->childItems();
1246     for (int i = 0; i < children.count(); i++) {
1247         if (children.at(i)->type() == AVWIDGET) {
1248             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
1249             ItemInfo info = clip->info();
1250             kDebug() << " / / INSERT : " << pos.x();
1251             QRectF shape = QRectF(clip->startPos().frames(m_document->fps()), clip->track() * m_tracksHeight + 1, clip->cropDuration().frames(m_document->fps()) - 0.02, m_tracksHeight - 1);
1252             kDebug() << " / / INSERT RECT: " << shape;
1253             path = path.united(QPolygonF(shape));
1254         }
1255     }
1256
1257     QList<QGraphicsItem*> collindingItems = scene()->items(path, Qt::IntersectsItemShape);
1258     if (collindingItems.isEmpty()) return true;
1259     else {
1260         for (int i = 0; i < collindingItems.count(); i++) {
1261             QGraphicsItem *collision = collindingItems.at(i);
1262             if (collision->type() == AVWIDGET) {
1263                 // Collision
1264                 kDebug() << "// COLLISIION DETECTED";
1265                 return false;
1266             }
1267         }
1268         return true;
1269     }
1270
1271 }
1272
1273
1274 bool CustomTrackView::itemCollision(AbstractClipItem *item, ItemInfo newPos)
1275 {
1276     QRectF shape = QRectF(newPos.startPos.frames(m_document->fps()), newPos.track * m_tracksHeight + 1, (newPos.endPos - newPos.startPos).frames(m_document->fps()) - 0.02, m_tracksHeight - 1);
1277     QList<QGraphicsItem*> collindingItems = scene()->items(shape, Qt::IntersectsItemShape);
1278     collindingItems.removeAll(item);
1279     if (collindingItems.isEmpty()) return false;
1280     else {
1281         for (int i = 0; i < collindingItems.count(); i++) {
1282             QGraphicsItem *collision = collindingItems.at(i);
1283             if (collision->type() == item->type()) {
1284                 // Collision
1285                 kDebug() << "// COLLISIION DETECTED";
1286                 return true;
1287             }
1288         }
1289         return false;
1290     }
1291 }
1292
1293 void CustomTrackView::slotRefreshEffects(ClipItem *clip)
1294 {
1295     int track = m_document->tracksCount() - clip->track();
1296     GenTime pos = clip->startPos();
1297     if (!m_document->renderer()->mltRemoveEffect(track, pos, "-1", false, false)) {
1298         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1299         return;
1300     }
1301     bool success = true;
1302     for (int i = 0; i < clip->effectsCount(); i++) {
1303         if (!m_document->renderer()->mltAddEffect(track, pos, clip->getEffectArgs(clip->effectAt(i)), false)) success = false;
1304     }
1305     if (!success) emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1306     m_document->renderer()->doRefresh();
1307 }
1308
1309 void CustomTrackView::addEffect(int track, GenTime pos, QDomElement effect)
1310 {
1311     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1312     if (clip) {
1313         // Special case: speed effect
1314         if (effect.attribute("id") == "speed") {
1315             if (clip->clipType() != VIDEO && clip->clipType() != AV && clip->clipType() != PLAYLIST) {
1316                 emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1317                 return;
1318             }
1319             ItemInfo info = clip->info();
1320             double speed = EffectsList::parameter(effect, "speed").toDouble() / 100.0;
1321             int strobe = EffectsList::parameter(effect, "strobe").toInt();
1322             if (strobe == 0) strobe = 1;
1323             doChangeClipSpeed(info, speed, 1.0, strobe, clip->baseClip()->getId());
1324             clip->addEffect(effect);
1325             if (clip->isSelected()) emit clipItemSelected(clip);
1326             return;
1327         }
1328
1329         EffectsParameterList params = clip->addEffect(effect);
1330         if (!m_document->renderer()->mltAddEffect(track, pos, params))
1331             emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1332         if (clip->isSelected()) emit clipItemSelected(clip);
1333     } else emit displayMessage(i18n("Cannot find clip to add effect"), ErrorMessage);
1334 }
1335
1336 void CustomTrackView::deleteEffect(int track, GenTime pos, QDomElement effect)
1337 {
1338     QString index = effect.attribute("kdenlive_ix");
1339     // Special case: speed effect
1340     if (effect.attribute("id") == "speed") {
1341         ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1342         if (clip) {
1343             ItemInfo info = clip->info();
1344             doChangeClipSpeed(info, 1.0, clip->speed(), 1, clip->baseClip()->getId());
1345             clip->deleteEffect(index);
1346             emit clipItemSelected(clip);
1347             return;
1348         }
1349     }
1350     if (!m_document->renderer()->mltRemoveEffect(track, pos, index, true) && effect.attribute("disabled") != "1") {
1351         kDebug() << "// ERROR REMOV EFFECT: " << index << ", DISABLE: " << effect.attribute("disabled");
1352         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1353         return;
1354     }
1355     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1356     if (clip) {
1357         clip->deleteEffect(index);
1358         emit clipItemSelected(clip);
1359     }
1360 }
1361
1362 void CustomTrackView::slotAddGroupEffect(QDomElement effect, AbstractGroupItem *group)
1363 {
1364     QList<QGraphicsItem *> itemList = group->childItems();
1365     QUndoCommand *effectCommand = new QUndoCommand();
1366     QString effectName;
1367     QDomNode namenode = effect.elementsByTagName("name").item(0);
1368     if (!namenode.isNull()) effectName = i18n(namenode.toElement().text().toUtf8().data());
1369     else effectName = i18n("effect");
1370     effectCommand->setText(i18n("Add %1", effectName));
1371     int count = 0;
1372     for (int i = 0; i < itemList.count(); i++) {
1373         if (itemList.at(i)->type() == AVWIDGET) {
1374             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1375             if (effect.attribute("type") == "audio") {
1376                 // Don't add audio effects on video clips
1377                 if (item->isVideoOnly() || (item->clipType() != AUDIO && item->clipType() != AV && item->clipType() != PLAYLIST)) continue;
1378             } else if (effect.hasAttribute("type") == false) {
1379                 // Don't add video effect on audio clips
1380                 if (item->isAudioOnly() || item->clipType() == AUDIO) continue;
1381             }
1382
1383             if (item->hasEffect(effect.attribute("tag"), effect.attribute("id")) != -1 && effect.attribute("unique", "0") != "0") {
1384                 emit displayMessage(i18n("Effect already present in clip"), ErrorMessage);
1385                 continue;
1386             }
1387             if (item->isItemLocked()) {
1388                 continue;
1389             }
1390             item->initEffect(effect);
1391             if (effect.attribute("tag") == "ladspa") {
1392                 QString ladpsaFile = m_document->getLadspaFile();
1393                 initEffects::ladspaEffectFile(ladpsaFile, effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1394                 effect.setAttribute("src", ladpsaFile);
1395             }
1396             new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), effect, true, effectCommand);
1397             count++;
1398         }
1399     }
1400     if (count > 0) {
1401         m_commandStack->push(effectCommand);
1402         setDocumentModified();
1403     } else delete effectCommand;
1404 }
1405
1406 void CustomTrackView::slotAddEffect(QDomElement effect, GenTime pos, int track)
1407 {
1408     QList<QGraphicsItem *> itemList;
1409     QUndoCommand *effectCommand = new QUndoCommand();
1410     QString effectName;
1411     QDomNode namenode = effect.elementsByTagName("name").item(0);
1412     if (!namenode.isNull()) effectName = i18n(namenode.toElement().text().toUtf8().data());
1413     else effectName = i18n("effect");
1414     effectCommand->setText(i18n("Add %1", effectName));
1415     int count = 0;
1416     if (track == -1) itemList = scene()->selectedItems();
1417     if (itemList.isEmpty()) {
1418         ClipItem *clip = getClipItemAt((int) pos.frames(m_document->fps()), track);
1419         if (clip) itemList.append(clip);
1420         else emit displayMessage(i18n("Select a clip if you want to apply an effect"), ErrorMessage);
1421     }
1422     kDebug() << "// REQUESTING EFFECT ON CLIP: " << pos.frames(25) << ", TRK: " << track << "SELECTED ITEMS: " << itemList.count();
1423     for (int i = 0; i < itemList.count(); i++) {
1424         if (itemList.at(i)->type() == AVWIDGET) {
1425             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1426             if (effect.attribute("type") == "audio") {
1427                 // Don't add audio effects on video clips
1428                 if (item->isVideoOnly() || (item->clipType() != AUDIO && item->clipType() != AV && item->clipType() != PLAYLIST)) {
1429                     emit displayMessage(i18n("Cannot add an audio effect to this clip"), ErrorMessage);
1430                     continue;
1431                 }
1432             } else if (effect.hasAttribute("type") == false) {
1433                 // Don't add video effect on audio clips
1434                 if (item->isAudioOnly() || item->clipType() == AUDIO) {
1435                     emit displayMessage(i18n("Cannot add a video effect to this clip"), ErrorMessage);
1436                     continue;
1437                 }
1438             }
1439             if (item->hasEffect(effect.attribute("tag"), effect.attribute("id")) != -1 && effect.attribute("unique", "0") != "0") {
1440                 emit displayMessage(i18n("Effect already present in clip"), ErrorMessage);
1441                 continue;
1442             }
1443             if (item->isItemLocked()) {
1444                 continue;
1445             }
1446             item->initEffect(effect);
1447             if (effect.attribute("tag") == "ladspa") {
1448                 QString ladpsaFile = m_document->getLadspaFile();
1449                 initEffects::ladspaEffectFile(ladpsaFile, effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1450                 effect.setAttribute("src", ladpsaFile);
1451             }
1452             new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), effect, true, effectCommand);
1453             count++;
1454         }
1455     }
1456     if (count > 0) {
1457         m_commandStack->push(effectCommand);
1458         setDocumentModified();
1459     } else delete effectCommand;
1460 }
1461
1462 void CustomTrackView::slotDeleteEffect(ClipItem *clip, QDomElement effect)
1463 {
1464     AddEffectCommand *command = new AddEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), effect, false);
1465     m_commandStack->push(command);
1466     setDocumentModified();
1467 }
1468
1469 void CustomTrackView::updateEffect(int track, GenTime pos, QDomElement effect, int ix, bool triggeredByUser)
1470 {
1471     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1472     if (clip) {
1473
1474         // Special case: speed effect
1475         if (effect.attribute("id") == "speed") {
1476             ItemInfo info = clip->info();
1477             double speed = EffectsList::parameter(effect, "speed").toDouble() / 100.0;
1478             int strobe = EffectsList::parameter(effect, "strobe").toInt();
1479             if (strobe == 0) strobe = 1;
1480             doChangeClipSpeed(info, speed, clip->speed(), strobe, clip->baseClip()->getId());
1481             clip->setEffectAt(ix, effect);
1482             if (ix == clip->selectedEffectIndex()) {
1483                 clip->setSelectedEffect(ix);
1484             }
1485             return;
1486         }
1487
1488         EffectsParameterList effectParams = clip->getEffectArgs(effect);
1489         if (effect.attribute("tag") == "ladspa") {
1490             // Update the ladspa affect file
1491             initEffects::ladspaEffectFile(effect.attribute("src"), effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1492         }
1493         // check if we are trying to reset a keyframe effect
1494         if (effectParams.hasParam("keyframes") && effectParams.paramValue("keyframes").isEmpty()) {
1495             clip->initEffect(effect);
1496             effectParams = clip->getEffectArgs(effect);
1497         }
1498         if (effectParams.paramValue("disabled") == "1") {
1499             if (m_document->renderer()->mltRemoveEffect(track, pos, effectParams.paramValue("kdenlive_ix"), false)) {
1500                 kDebug() << "//////  DISABLING EFFECT: " << ix << ", CURRENTLA: " << clip->selectedEffectIndex();
1501             } else emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1502         } else if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - clip->track(), clip->startPos(), effectParams))
1503             emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
1504
1505         clip->setEffectAt(ix, effect);
1506         if (ix == clip->selectedEffectIndex()) {
1507             clip->setSelectedEffect(ix);
1508             if (!triggeredByUser) emit clipItemSelected(clip, ix);
1509         }
1510         if (effect.attribute("tag") == "volume" || effect.attribute("tag") == "brightness") {
1511             // A fade effect was modified, update the clip
1512             if (effect.attribute("id") == "fadein" || effect.attribute("id") == "fade_from_black") {
1513                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1514                 clip->setFadeIn(pos);
1515             }
1516             if (effect.attribute("id") == "fadeout" || effect.attribute("id") == "fade_to_black") {
1517                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1518                 clip->setFadeOut(pos);
1519             }
1520         }
1521     }
1522     setDocumentModified();
1523 }
1524
1525 void CustomTrackView::moveEffect(int track, GenTime pos, int oldPos, int newPos)
1526 {
1527     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1528     if (clip && !clip->effectAt(newPos - 1).isNull() && !clip->effectAt(oldPos - 1).isNull()) {
1529         QDomElement act = clip->effectAt(newPos - 1).cloneNode().toElement();
1530         QDomElement before = clip->effectAt(oldPos - 1).cloneNode().toElement();
1531         clip->setEffectAt(oldPos - 1, act);
1532         clip->setEffectAt(newPos - 1, before);
1533         m_document->renderer()->mltMoveEffect(track, pos, oldPos, newPos);
1534         emit clipItemSelected(clip, newPos - 1);
1535         setDocumentModified();
1536     } else emit displayMessage(i18n("Cannot move effect"), ErrorMessage);
1537 }
1538
1539 void CustomTrackView::slotChangeEffectState(ClipItem *clip, int effectPos, bool disable)
1540 {
1541     QDomElement effect = clip->effectAt(effectPos).cloneNode().toElement();
1542     QDomElement oldEffect = effect.cloneNode().toElement();
1543     if (effect.attribute("id") == "speed") {
1544         if (clip) {
1545             ItemInfo info = clip->info();
1546             effect.setAttribute("disabled", (int) disable);
1547             if (disable) doChangeClipSpeed(info, 1.0, clip->speed(), 1, clip->baseClip()->getId());
1548             else {
1549                 double speed = EffectsList::parameter(effect, "speed").toDouble() / 100.0;
1550                 int strobe = EffectsList::parameter(effect, "strobe").toInt();
1551                 if (strobe == 0) strobe = 1;
1552                 doChangeClipSpeed(info, speed, 1.0, strobe, clip->baseClip()->getId());
1553             }
1554             return;
1555         }
1556     }
1557     effect.setAttribute("disabled", (int) disable);
1558     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldEffect, effect, effectPos, true);
1559     m_commandStack->push(command);
1560     setDocumentModified();;
1561 }
1562
1563 void CustomTrackView::slotChangeEffectPosition(ClipItem *clip, int currentPos, int newPos)
1564 {
1565     MoveEffectCommand *command = new MoveEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), currentPos, newPos);
1566     m_commandStack->push(command);
1567     setDocumentModified();
1568 }
1569
1570 void CustomTrackView::slotUpdateClipEffect(ClipItem *clip, QDomElement oldeffect, QDomElement effect, int ix)
1571 {
1572     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldeffect, effect, ix, true);
1573     m_commandStack->push(command);
1574 }
1575
1576 void CustomTrackView::cutClip(ItemInfo info, GenTime cutTime, bool cut)
1577 {
1578     if (cut) {
1579         // cut clip
1580         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
1581         if (!item || cutTime >= item->endPos() || cutTime <= item->startPos()) {
1582             emit displayMessage(i18n("Cannot find clip to cut"), ErrorMessage);
1583             kDebug() << "/////////  ERROR CUTTING CLIP : (" << item->startPos().frames(25) << "-" << item->endPos().frames(25) << "), INFO: (" << info.startPos.frames(25) << "-" << info.endPos.frames(25) << ")" << ", CUT: " << cutTime.frames(25);
1584             m_blockRefresh = false;
1585             return;
1586         }
1587         if (item->parentItem()) {
1588             // Item is part of a group, reset group
1589             resetSelectionGroup();
1590         }
1591         kDebug() << "/////////  CUTTING CLIP : (" << item->startPos().frames(25) << "-" << item->endPos().frames(25) << "), INFO: (" << info.startPos.frames(25) << "-" << info.endPos.frames(25) << ")" << ", CUT: " << cutTime.frames(25);
1592
1593         m_document->renderer()->mltCutClip(m_document->tracksCount() - info.track, cutTime);
1594         int cutPos = (int) cutTime.frames(m_document->fps());
1595         ItemInfo newPos;
1596         double speed = item->speed();
1597         newPos.startPos = cutTime;
1598         newPos.endPos = info.endPos;
1599         if (speed == 1) newPos.cropStart = item->info().cropStart + (cutTime - info.startPos);
1600         else newPos.cropStart = item->info().cropStart + (cutTime - info.startPos) * speed;
1601         newPos.track = info.track;
1602         ClipItem *dup = item->clone(newPos);
1603         // remove unwanted effects (fade in) from 2nd part of cutted clip
1604         int ix = dup->hasEffect(QString(), "fadein");
1605         if (ix != -1) {
1606             QDomElement oldeffect = item->effectAt(ix);
1607             dup->deleteEffect(oldeffect.attribute("kdenlive_ix"));
1608         }
1609         ix = dup->hasEffect(QString(), "fade_from_black");
1610         if (ix != -1) {
1611             QDomElement oldeffect = item->effectAt(ix);
1612             dup->deleteEffect(oldeffect.attribute("kdenlive_ix"));
1613         }
1614         item->resizeEnd(cutPos, false);
1615         scene()->addItem(dup);
1616         if (item->checkKeyFrames()) slotRefreshEffects(item);
1617         if (dup->checkKeyFrames()) slotRefreshEffects(dup);
1618         item->baseClip()->addReference();
1619         m_document->updateClip(item->baseClip()->getId());
1620         setDocumentModified();
1621         //kDebug() << "/////////  CUTTING CLIP RESULT: (" << item->startPos().frames(25) << "-" << item->endPos().frames(25) << "), DUP: (" << dup->startPos().frames(25) << "-" << dup->endPos().frames(25) << ")" << ", CUT: " << cutTime.frames(25);
1622     } else {
1623         // uncut clip
1624
1625         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
1626         ClipItem *dup = getClipItemAt((int) cutTime.frames(m_document->fps()) + 1, info.track);
1627         if (!item || !dup || item == dup) {
1628             emit displayMessage(i18n("Cannot find clip to uncut"), ErrorMessage);
1629             m_blockRefresh = false;
1630             return;
1631         }
1632         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, cutTime) == false) {
1633             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(cutTime.frames(m_document->fps())), info.track), ErrorMessage);
1634             return;
1635         }
1636
1637         /*kDebug() << "// UNCUTTING CLIPS: ITEM 1 (" << item->startPos().frames(25) << "x" << item->endPos().frames(25) << ")";
1638         kDebug() << "// UNCUTTING CLIPS: ITEM 2 (" << dup->startPos().frames(25) << "x" << dup->endPos().frames(25) << ")";
1639         kDebug() << "// UNCUTTING CLIPS, INFO (" << info.startPos.frames(25) << "x" << info.endPos.frames(25) << ") , CUT: " << cutTime.frames(25);;*/
1640         //deleteClip(dup->info());
1641
1642
1643         if (dup->isSelected()) emit clipItemSelected(NULL);
1644         dup->baseClip()->removeReference();
1645         m_document->updateClip(dup->baseClip()->getId());
1646         scene()->removeItem(dup);
1647         delete dup;
1648
1649         ItemInfo clipinfo = item->info();
1650         clipinfo.track = m_document->tracksCount() - clipinfo.track;
1651         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, info.endPos - info.startPos);
1652         if (success) {
1653             item->resizeEnd((int) info.endPos.frames(m_document->fps()));
1654             setDocumentModified();
1655         } else
1656             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1657
1658     }
1659     QTimer::singleShot(3000, this, SLOT(slotEnableRefresh()));
1660 }
1661
1662 void CustomTrackView::slotEnableRefresh()
1663 {
1664     m_blockRefresh = false;
1665 }
1666
1667 void CustomTrackView::slotAddTransitionToSelectedClips(QDomElement transition)
1668 {
1669     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1670     if (itemList.count() == 1) {
1671         if (itemList.at(0)->type() == AVWIDGET) {
1672             ClipItem *item = (ClipItem *) itemList.at(0);
1673             ItemInfo info;
1674             info.track = item->track();
1675             ClipItem *transitionClip = NULL;
1676             const int transitiontrack = getPreviousVideoTrack(info.track);
1677             GenTime pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1678             if (pos < item->startPos() + item->cropDuration() / 2) {
1679                 // add transition to clip start
1680                 info.startPos = item->startPos();
1681                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1682                 if (transitionClip && transitionClip->endPos() < item->endPos()) {
1683                     info.endPos = transitionClip->endPos();
1684                 } else info.endPos = info.startPos + GenTime(65, m_document->fps());
1685                 // Check there is no other transition at that place
1686                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1687                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1688                 QList<QGraphicsItem *> selection = m_scene->items(r);
1689                 bool transitionAccepted = true;
1690                 for (int i = 0; i < selection.count(); i++) {
1691                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1692                         Transition *tr = static_cast <Transition *>(selection.at(i));
1693                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1694                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1695                         } else transitionAccepted = false;
1696                     }
1697                 }
1698                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1699                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1700
1701             } else {
1702                 // add transition to clip  end
1703                 info.endPos = item->endPos();
1704                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1705                 if (transitionClip && transitionClip->startPos() > item->startPos()) {
1706                     info.startPos = transitionClip->startPos();
1707                 } else info.startPos = info.endPos - GenTime(65, m_document->fps());
1708                 if (transition.attribute("tag") == "luma") EffectsList::setParameter(transition, "reverse", "1");
1709                 else if (transition.attribute("id") == "slide") EffectsList::setParameter(transition, "invert", "1");
1710
1711                 // Check there is no other transition at that place
1712                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1713                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1714                 QList<QGraphicsItem *> selection = m_scene->items(r);
1715                 bool transitionAccepted = true;
1716                 for (int i = 0; i < selection.count(); i++) {
1717                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1718                         Transition *tr = static_cast <Transition *>(selection.at(i));
1719                         if (info.endPos - tr->endPos() > GenTime(5, m_document->fps())) {
1720                             if (tr->endPos() > info.startPos) info.startPos = tr->endPos();
1721                         } else transitionAccepted = false;
1722                     }
1723                 }
1724                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1725                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1726             }
1727         }
1728     } else for (int i = 0; i < itemList.count(); i++) {
1729             if (itemList.at(i)->type() == AVWIDGET) {
1730                 ClipItem *item = (ClipItem *) itemList.at(i);
1731                 ItemInfo info;
1732                 info.startPos = item->startPos();
1733                 info.endPos = info.startPos + GenTime(65, m_document->fps());
1734                 info.track = item->track();
1735
1736                 // Check there is no other transition at that place
1737                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1738                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1739                 QList<QGraphicsItem *> selection = m_scene->items(r);
1740                 bool transitionAccepted = true;
1741                 for (int i = 0; i < selection.count(); i++) {
1742                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1743                         Transition *tr = static_cast <Transition *>(selection.at(i));
1744                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1745                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1746                         } else transitionAccepted = false;
1747                     }
1748                 }
1749                 int transitiontrack = getPreviousVideoTrack(info.track);
1750                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1751                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1752             }
1753         }
1754 }
1755
1756 void CustomTrackView::slotAddTransition(ClipItem* /*clip*/, ItemInfo transitionInfo, int endTrack, QDomElement transition)
1757 {
1758     if (transitionInfo.startPos >= transitionInfo.endPos) {
1759         emit displayMessage(i18n("Invalid transition"), ErrorMessage);
1760         return;
1761     }
1762     AddTransitionCommand* command = new AddTransitionCommand(this, transitionInfo, endTrack, transition, false, true);
1763     m_commandStack->push(command);
1764     setDocumentModified();
1765 }
1766
1767 void CustomTrackView::addTransition(ItemInfo transitionInfo, int endTrack, QDomElement params)
1768 {
1769     Transition *tr = new Transition(transitionInfo, endTrack, m_document->fps(), params, true);
1770     //kDebug() << "---- ADDING transition " << params.attribute("value");
1771     if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, tr->toXML())) {
1772         scene()->addItem(tr);
1773         setDocumentModified();
1774     } else {
1775         emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1776         delete tr;
1777     }
1778 }
1779
1780 void CustomTrackView::deleteTransition(ItemInfo transitionInfo, int endTrack, QDomElement /*params*/)
1781 {
1782     Transition *item = getTransitionItemAt(transitionInfo.startPos, transitionInfo.track);
1783     if (!item) {
1784         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
1785         return;
1786     }
1787     m_document->renderer()->mltDeleteTransition(item->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, item->toXML());
1788     if (m_dragItem == item) m_dragItem = NULL;
1789     delete item;
1790     emit transitionItemSelected(NULL);
1791     setDocumentModified();
1792 }
1793
1794 void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old)
1795 {
1796     //kDebug() << "TRANS UPDATE, TRACKS: " << old.attribute("transition_btrack") << ", NEW: " << tr->toXML().attribute("transition_btrack");
1797     EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, tr->toXML(), false);
1798     m_commandStack->push(command);
1799     setDocumentModified();
1800 }
1801
1802 void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition, bool updateTransitionWidget)
1803 {
1804     Transition *item = getTransitionItemAt(pos, track);
1805     if (!item) {
1806         kWarning() << "Unable to find transition at pos :" << pos.frames(m_document->fps()) << ", ON track: " << track;
1807         return;
1808     }
1809     m_document->renderer()->mltUpdateTransition(oldTransition.attribute("tag"), transition.attribute("tag"), transition.attribute("transition_btrack").toInt(), m_document->tracksCount() - transition.attribute("transition_atrack").toInt(), item->startPos(), item->endPos(), transition);
1810     //kDebug() << "ORIGINAL TRACK: "<< oldTransition.attribute("transition_btrack") << ", NEW TRACK: "<<transition.attribute("transition_btrack");
1811     item->setTransitionParameters(transition);
1812     if (updateTransitionWidget) {
1813         ItemInfo info = item->info();
1814         QPoint p;
1815         ClipItem *transitionClip = getClipItemAt(info.startPos, info.track);
1816         if (transitionClip && transitionClip->baseClip()) {
1817             QString size = transitionClip->baseClip()->getProperty("frame_size");
1818             p.setX(size.section('x', 0, 0).toInt());
1819             p.setY(size.section('x', 1, 1).toInt());
1820         }
1821         emit transitionItemSelected(item, getPreviousVideoTrack(info.track), p, true);
1822     }
1823     setDocumentModified();
1824 }
1825
1826 void CustomTrackView::dragMoveEvent(QDragMoveEvent * event)
1827 {
1828     event->setDropAction(Qt::IgnoreAction);
1829     const QPointF pos = mapToScene(event->pos());
1830     if (m_selectionGroup && m_clipDrag) {
1831         m_selectionGroup->setPos(pos.x(), pos.y());
1832         emit mousePosition((int)(m_selectionGroup->scenePos().x() + 0.5));
1833         event->setDropAction(Qt::MoveAction);
1834         event->acceptProposedAction();
1835     } else {
1836         QGraphicsView::dragMoveEvent(event);
1837     }
1838 }
1839
1840 void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event)
1841 {
1842     if (m_selectionGroup && m_clipDrag) {
1843         m_thumbsTimer.stop();
1844         m_waitingThumbs.clear();
1845         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1846         qDeleteAll(items);
1847         scene()->destroyItemGroup(m_selectionGroup);
1848         m_selectionGroup = NULL;
1849     } else QGraphicsView::dragLeaveEvent(event);
1850 }
1851
1852 void CustomTrackView::dropEvent(QDropEvent * event)
1853 {
1854     if (m_selectionGroup && m_clipDrag) {
1855         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1856         resetSelectionGroup();
1857         m_scene->clearSelection();
1858         bool hasVideoClip = false;
1859         QUndoCommand *addCommand = new QUndoCommand();
1860         addCommand->setText(i18n("Add timeline clip"));
1861
1862         for (int i = 0; i < items.count(); i++) {
1863             ClipItem *item = static_cast <ClipItem *>(items.at(i));
1864             if (!hasVideoClip && (item->clipType() == AV || item->clipType() == VIDEO)) hasVideoClip = true;
1865             if (items.count() == 1) {
1866                 updateClipTypeActions(item);
1867             } else {
1868                 updateClipTypeActions(NULL);
1869             }
1870
1871             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false, addCommand);
1872             item->baseClip()->addReference();
1873             m_document->updateClip(item->baseClip()->getId());
1874             ItemInfo info = item->info();
1875
1876             int tracknumber = m_document->tracksCount() - info.track - 1;
1877             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
1878             if (isLocked) item->setItemLocked(true);
1879             ItemInfo clipInfo = info;
1880             clipInfo.track = m_document->tracksCount() - item->track();
1881             if (m_document->renderer()->mltInsertClip(clipInfo, item->xml(), item->baseClip()->producer(item->track())) == -1) {
1882                 emit displayMessage(i18n("Cannot insert clip in timeline"), ErrorMessage);
1883             }
1884
1885             if (item->baseClip()->isTransparent() && getTransitionItemAtStart(info.startPos, info.track) == NULL) {
1886                 // add transparency transition
1887                 QDomElement trans = MainWindow::transitions.getEffectByTag("composite", "composite").cloneNode().toElement();
1888                 new AddTransitionCommand(this, info, getPreviousVideoTrack(info.track), trans, false, true, addCommand);
1889             }
1890             item->setSelected(true);
1891         }
1892         m_commandStack->push(addCommand);
1893         setDocumentModified();
1894         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1895         if (items.count() > 1) groupSelectedItems(true);
1896         event->setDropAction(Qt::MoveAction);
1897         event->accept();
1898     } else QGraphicsView::dropEvent(event);
1899     setFocus();
1900 }
1901
1902
1903 QStringList CustomTrackView::mimeTypes() const
1904 {
1905     QStringList qstrList;
1906     // list of accepted mime types for drop
1907     qstrList.append("text/plain");
1908     qstrList.append("kdenlive/producerslist");
1909     qstrList.append("kdenlive/clip");
1910     return qstrList;
1911 }
1912
1913 Qt::DropActions CustomTrackView::supportedDropActions() const
1914 {
1915     // returns what actions are supported when dropping
1916     return Qt::MoveAction;
1917 }
1918
1919 void CustomTrackView::setDuration(int duration)
1920 {
1921     int diff = qAbs(duration - sceneRect().width());
1922     if (diff * matrix().m11() > -50) {
1923         if (matrix().m11() < 0.4) setSceneRect(0, 0, (duration + 100 / matrix().m11()), sceneRect().height());
1924         else setSceneRect(0, 0, (duration + 300), sceneRect().height());
1925     }
1926     m_projectDuration = duration;
1927 }
1928
1929 int CustomTrackView::duration() const
1930 {
1931     return m_projectDuration;
1932 }
1933
1934 void CustomTrackView::addTrack(TrackInfo type, int ix)
1935 {
1936     if (ix == -1 || ix == m_document->tracksCount()) {
1937         m_document->insertTrack(ix, type);
1938         m_document->renderer()->mltInsertTrack(1, type.type == VIDEOTRACK);
1939     } else {
1940         m_document->insertTrack(m_document->tracksCount() - ix, type);
1941         // insert track in MLT playlist
1942         m_document->renderer()->mltInsertTrack(m_document->tracksCount() - ix, type.type == VIDEOTRACK);
1943
1944         double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1945         QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1946         QList<QGraphicsItem *> selection = m_scene->items(r);
1947         resetSelectionGroup();
1948
1949         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1950         scene()->addItem(m_selectionGroup);
1951         for (int i = 0; i < selection.count(); i++) {
1952             if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
1953                 m_selectionGroup->addToGroup(selection.at(i));
1954                 selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1955             }
1956         }
1957         // Move graphic items
1958         m_selectionGroup->translate(0, m_tracksHeight);
1959
1960         // adjust track number
1961         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1962         for (int i = 0; i < children.count(); i++) {
1963             if (children.at(i)->type() == GROUPWIDGET) {
1964                 AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
1965                 children << grp->childItems();
1966                 continue;
1967             }
1968             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
1969             item->updateItem();
1970             ItemInfo clipinfo = item->info();
1971             if (item->type() == AVWIDGET) {
1972                 ClipItem *clip = static_cast <ClipItem *>(item);
1973                 // We add a move clip command so that we get the correct producer for new track number
1974                 if (clip->clipType() == AV || clip->clipType() == AUDIO) {
1975                     Mlt::Producer *prod;
1976                     if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(clipinfo.track);
1977                     else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
1978                     else prod = clip->baseClip()->producer(clipinfo.track);
1979                     m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod);
1980                 }
1981             } else if (item->type() == TRANSITIONWIDGET) {
1982                 Transition *tr = static_cast <Transition *>(item);
1983                 int track = tr->transitionEndTrack();
1984                 if (track >= ix) {
1985                     tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1986                 }
1987             }
1988         }
1989         resetSelectionGroup(false);
1990     }
1991
1992     int maxHeight = m_tracksHeight * m_document->tracksCount();
1993     for (int i = 0; i < m_guides.count(); i++) {
1994         QLineF l = m_guides.at(i)->line();
1995         l.setP2(QPointF(l.x2(), maxHeight));
1996         m_guides.at(i)->setLine(l);
1997     }
1998     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
1999     setSceneRect(0, 0, sceneRect().width(), maxHeight);
2000     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
2001     viewport()->update();
2002     //setFixedHeight(50 * m_tracksCount);
2003 }
2004
2005 void CustomTrackView::removeTrack(int ix)
2006 {
2007     // Delete track in MLT playlist
2008     m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
2009     m_document->deleteTrack(m_document->tracksCount() - ix - 1);
2010
2011     double startY = ix * (m_tracksHeight + 1) + m_tracksHeight / 2;
2012     QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
2013     QList<QGraphicsItem *> selection = m_scene->items(r);
2014
2015     resetSelectionGroup();
2016
2017     m_selectionGroup = new AbstractGroupItem(m_document->fps());
2018     scene()->addItem(m_selectionGroup);
2019     for (int i = 0; i < selection.count(); i++) {
2020         if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
2021             m_selectionGroup->addToGroup(selection.at(i));
2022             selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
2023         }
2024     }
2025     // Move graphic items
2026     qreal ydiff = 0 - (int) m_tracksHeight;
2027     m_selectionGroup->translate(0, ydiff);
2028
2029     // adjust track number
2030     QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2031     //kDebug() << "// FOUND CLIPS TO MOVE: " << children.count();
2032     for (int i = 0; i < children.count(); i++) {
2033         if (children.at(i)->type() == GROUPWIDGET) {
2034             AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
2035             children << grp->childItems();
2036             continue;
2037         }
2038         if (children.at(i)->type() == AVWIDGET) {
2039             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
2040             clip->updateItem();
2041             ItemInfo clipinfo = clip->info();
2042             // We add a move clip command so that we get the correct producer for new track number
2043             if (clip->clipType() == AV || clip->clipType() == AUDIO) {
2044                 Mlt::Producer *prod;
2045                 if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(clipinfo.track);
2046                 else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
2047                 else prod = clip->baseClip()->producer(clipinfo.track);
2048                 m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod);
2049             }
2050         } else if (children.at(i)->type() == TRANSITIONWIDGET) {
2051             Transition *tr = static_cast <Transition *>(children.at(i));
2052             tr->updateItem();
2053             int track = tr->transitionEndTrack();
2054             if (track >= ix) {
2055                 ItemInfo clipinfo = tr->info();
2056                 tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
2057             }
2058         }
2059     }
2060     resetSelectionGroup(false);
2061
2062     int maxHeight = m_tracksHeight * m_document->tracksCount();
2063     for (int i = 0; i < m_guides.count(); i++) {
2064         QLineF l = m_guides.at(i)->line();
2065         l.setP2(QPointF(l.x2(), maxHeight));
2066         m_guides.at(i)->setLine(l);
2067     }
2068     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
2069     setSceneRect(0, 0, sceneRect().width(), maxHeight);
2070     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
2071     viewport()->update();
2072 }
2073
2074 void CustomTrackView::changeTrack(int ix, TrackInfo type)
2075 {
2076     int tracknumber = m_document->tracksCount() - ix;
2077     m_document->setTrackType(tracknumber - 1, type);
2078     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
2079     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
2080     viewport()->update();
2081 }
2082
2083
2084 void CustomTrackView::slotSwitchTrackAudio(int ix)
2085 {
2086     /*for (int i = 0; i < m_document->tracksCount(); i++)
2087         kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
2088     int tracknumber = m_document->tracksCount() - ix - 1;
2089     m_document->switchTrackAudio(tracknumber, !m_document->trackInfoAt(tracknumber).isMute);
2090     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isMute << m_document->trackInfoAt(tracknumber).isBlind;
2091     m_document->renderer()->mltChangeTrackState(tracknumber + 1, m_document->trackInfoAt(tracknumber).isMute, m_document->trackInfoAt(tracknumber).isBlind);
2092     setDocumentModified();
2093 }
2094
2095 void CustomTrackView::slotSwitchTrackLock(int ix)
2096 {
2097     int tracknumber = m_document->tracksCount() - ix - 1;
2098     LockTrackCommand *command = new LockTrackCommand(this, ix, !m_document->trackInfoAt(tracknumber).isLocked);
2099     m_commandStack->push(command);
2100 }
2101
2102
2103 void CustomTrackView::lockTrack(int ix, bool lock)
2104 {
2105     int tracknumber = m_document->tracksCount() - ix - 1;
2106     m_document->switchTrackLock(tracknumber, lock);
2107     emit doTrackLock(ix, lock);
2108     QList<QGraphicsItem *> selection = m_scene->items(0, ix * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), m_tracksHeight / 2 - 2);
2109
2110     for (int i = 0; i < selection.count(); i++) {
2111         if (selection.at(i)->type() != AVWIDGET && selection.at(i)->type() != TRANSITIONWIDGET) continue;
2112         if (selection.at(i)->isSelected()) {
2113             if (selection.at(i)->type() == AVWIDGET) emit clipItemSelected(NULL);
2114             else emit transitionItemSelected(NULL);
2115         }
2116         static_cast <AbstractClipItem *>(selection.at(i))->setItemLocked(lock);
2117     }
2118     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isLocked;
2119     viewport()->update();
2120     setDocumentModified();
2121 }
2122
2123 void CustomTrackView::slotSwitchTrackVideo(int ix)
2124 {
2125     int tracknumber = m_document->tracksCount() - ix;
2126     m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
2127     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
2128     setDocumentModified();
2129 }
2130
2131 void CustomTrackView::slotRemoveSpace()
2132 {
2133     GenTime pos;
2134     int track = 0;
2135     if (m_menuPosition.isNull()) {
2136         pos = GenTime(cursorPos(), m_document->fps());
2137         bool ok;
2138         track = QInputDialog::getInteger(this, i18n("Remove Space"), i18n("Track"), 0, 0, m_document->tracksCount() - 1, 1, &ok);
2139         if (!ok) return;
2140     } else {
2141         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
2142         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight);
2143     }
2144     ClipItem *item = getClipItemAt(pos, track);
2145     if (item) {
2146         emit displayMessage(i18n("You must be in an empty space to remove space (time: %1, track: %2)", m_document->timecode().getTimecodeFromFrames(mapToScene(m_menuPosition).x()), track), ErrorMessage);
2147         return;
2148     }
2149     int length = m_document->renderer()->mltGetSpaceLength(pos, m_document->tracksCount() - track, true);
2150     //kDebug() << "// GOT LENGT; " << length;
2151     if (length <= 0) {
2152         emit displayMessage(i18n("You must be in an empty space to remove space (time=%1, track:%2)", m_document->timecode().getTimecodeFromFrames(mapToScene(m_menuPosition).x()), track), ErrorMessage);
2153         return;
2154     }
2155
2156     QRectF r(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight / 2 - 1);
2157     QList<QGraphicsItem *> items = m_scene->items(r);
2158
2159     QList<ItemInfo> clipsToMove;
2160     QList<ItemInfo> transitionsToMove;
2161
2162     for (int i = 0; i < items.count(); i++) {
2163         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
2164             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2165             ItemInfo info = item->info();
2166             if (item->type() == AVWIDGET) {
2167                 clipsToMove.append(info);
2168             } else if (item->type() == TRANSITIONWIDGET) {
2169                 transitionsToMove.append(info);
2170             }
2171         }
2172     }
2173
2174     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, GenTime(-length, m_document->fps()), true);
2175     m_commandStack->push(command);
2176 }
2177
2178 void CustomTrackView::slotInsertSpace()
2179 {
2180     GenTime pos;
2181     int track = 0;
2182     if (m_menuPosition.isNull()) {
2183         pos = GenTime(cursorPos(), m_document->fps());
2184     } else {
2185         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
2186         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight) + 1;
2187     }
2188     SpacerDialog d(GenTime(65, m_document->fps()), m_document->timecode(), track, m_document->tracksCount(), this);
2189     if (d.exec() != QDialog::Accepted) return;
2190     GenTime spaceDuration = d.selectedDuration();
2191     track = d.selectedTrack();
2192     ClipItem *item = getClipItemAt(pos, track);
2193     if (item) pos = item->startPos();
2194
2195     int minh = 0;
2196     int maxh = sceneRect().height();
2197     if (track != -1) {
2198         minh = track * m_tracksHeight + m_tracksHeight / 2;
2199         maxh = m_tracksHeight / 2 - 1;
2200     }
2201
2202     QRectF r(pos.frames(m_document->fps()), minh, sceneRect().width() - pos.frames(m_document->fps()), maxh);
2203     QList<QGraphicsItem *> items = m_scene->items(r);
2204
2205     QList<ItemInfo> clipsToMove;
2206     QList<ItemInfo> transitionsToMove;
2207
2208     for (int i = 0; i < items.count(); i++) {
2209         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
2210             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2211             ItemInfo info = item->info();
2212             if (item->type() == AVWIDGET) {
2213                 clipsToMove.append(info);
2214             } else if (item->type() == TRANSITIONWIDGET) {
2215                 transitionsToMove.append(info);
2216             }
2217         }
2218     }
2219
2220     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, spaceDuration, true);
2221     m_commandStack->push(command);
2222 }
2223
2224 void CustomTrackView::insertSpace(QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime duration, const GenTime offset)
2225 {
2226     int diff = duration.frames(m_document->fps());
2227     resetSelectionGroup();
2228     m_selectionGroup = new AbstractGroupItem(m_document->fps());
2229     scene()->addItem(m_selectionGroup);
2230     ClipItem *clip;
2231     Transition *transition;
2232
2233     // Create lists with start pos for each track
2234     QMap <int, int> trackClipStartList;
2235     QMap <int, int> trackTransitionStartList;
2236
2237     for (int i = 1; i < m_document->tracksCount() + 1; i++) {
2238         trackClipStartList[i] = -1;
2239         trackTransitionStartList[i] = -1;
2240     }
2241
2242     if (!clipsToMove.isEmpty()) for (int i = 0; i < clipsToMove.count(); i++) {
2243             clip = getClipItemAtStart(clipsToMove.at(i).startPos + offset, clipsToMove.at(i).track);
2244             if (clip) {
2245                 if (clip->parentItem()) {
2246                     m_selectionGroup->addToGroup(clip->parentItem());
2247                     clip->parentItem()->setFlags(QGraphicsItem::ItemIsSelectable);
2248                 } else {
2249                     m_selectionGroup->addToGroup(clip);
2250                     clip->setFlags(QGraphicsItem::ItemIsSelectable);
2251                 }
2252                 if (trackClipStartList.value(m_document->tracksCount() - clipsToMove.at(i).track) == -1 || clipsToMove.at(i).startPos.frames(m_document->fps()) < trackClipStartList.value(m_document->tracksCount() - clipsToMove.at(i).track))
2253                     trackClipStartList[m_document->tracksCount() - clipsToMove.at(i).track] = clipsToMove.at(i).startPos.frames(m_document->fps());
2254             } else emit displayMessage(i18n("Cannot move clip at position %1, track %2", m_document->timecode().getTimecodeFromFrames(clipsToMove.at(i).startPos.frames(m_document->fps())), clipsToMove.at(i).track), ErrorMessage);
2255         }
2256     if (!transToMove.isEmpty()) for (int i = 0; i < transToMove.count(); i++) {
2257             transition = getTransitionItemAtStart(transToMove.at(i).startPos + offset, transToMove.at(i).track);
2258             if (transition) {
2259                 if (transition->parentItem()) m_selectionGroup->addToGroup(transition->parentItem());
2260                 m_selectionGroup->addToGroup(transition);
2261                 if (trackTransitionStartList.value(m_document->tracksCount() - transToMove.at(i).track) == -1 || transToMove.at(i).startPos.frames(m_document->fps()) < trackTransitionStartList.value(m_document->tracksCount() - transToMove.at(i).track))
2262                     trackTransitionStartList[m_document->tracksCount() - transToMove.at(i).track] = transToMove.at(i).startPos.frames(m_document->fps());
2263                 transition->setFlags(QGraphicsItem::ItemIsSelectable);
2264             } else emit displayMessage(i18n("Cannot move transition at position %1, track %2", m_document->timecode().getTimecodeFromFrames(transToMove.at(i).startPos.frames(m_document->fps())), transToMove.at(i).track), ErrorMessage);
2265         }
2266     m_selectionGroup->translate(diff, 0);
2267
2268     // update items coordinates
2269     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2270     for (int i = 0; i < itemList.count(); i++) {
2271         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
2272             static_cast < AbstractClipItem *>(itemList.at(i))->updateItem();
2273         } else if (itemList.at(i)->type() == GROUPWIDGET) {
2274             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
2275             for (int j = 0; j < children.count(); j++) {
2276                 static_cast < AbstractClipItem *>(children.at(j))->updateItem();
2277             }
2278         }
2279     }
2280     resetSelectionGroup(false);
2281     if (track != -1) track = m_document->tracksCount() - track;
2282     m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, duration, offset);
2283 }
2284
2285 void CustomTrackView::deleteClip(const QString &clipId)
2286 {
2287     resetSelectionGroup();
2288     QList<QGraphicsItem *> itemList = items();
2289     QUndoCommand *deleteCommand = new QUndoCommand();
2290     deleteCommand->setText(i18n("Delete timeline clips"));
2291     int count = 0;
2292     for (int i = 0; i < itemList.count(); i++) {
2293         if (itemList.at(i)->type() == AVWIDGET) {
2294             ClipItem *item = (ClipItem *)itemList.at(i);
2295             if (item->clipProducer() == clipId) {
2296                 count++;
2297                 if (item->parentItem()) {
2298                     // Clip is in a group, destroy the group
2299                     new GroupClipsCommand(this, QList<ItemInfo>() << item->info(), QList<ItemInfo>(), false, deleteCommand);
2300                 }
2301                 new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteCommand);
2302             }
2303         }
2304     }
2305     if (count == 0) delete deleteCommand;
2306     else m_commandStack->push(deleteCommand);
2307 }
2308
2309 void CustomTrackView::setCursorPos(int pos, bool seek)
2310 {
2311     if (pos == m_cursorPos) return;
2312     emit cursorMoved((int)(m_cursorPos), (int)(pos));
2313     m_cursorPos = pos;
2314     if (seek) m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
2315     else if (m_autoScroll) checkScrolling();
2316     m_cursorLine->setPos(m_cursorPos, 0);
2317 }
2318
2319 void CustomTrackView::updateCursorPos()
2320 {
2321     m_cursorLine->setPos(m_cursorPos, 0);
2322 }
2323
2324 int CustomTrackView::cursorPos()
2325 {
2326     return (int)(m_cursorPos);
2327 }
2328
2329 void CustomTrackView::moveCursorPos(int delta)
2330 {
2331     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
2332     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
2333     m_cursorPos += delta;
2334     m_cursorLine->setPos(m_cursorPos, 0);
2335     m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
2336 }
2337
2338 void CustomTrackView::initCursorPos(int pos)
2339 {
2340     emit cursorMoved((int)(m_cursorPos), (int)(pos));
2341     m_cursorPos = pos;
2342     m_cursorLine->setPos(pos, 0);
2343     checkScrolling();
2344 }
2345
2346 void CustomTrackView::checkScrolling()
2347 {
2348     ensureVisible(m_cursorPos, verticalScrollBar()->value() + 10, 2, 2, 50, 0);
2349 }
2350
2351 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event)
2352 {
2353     if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
2354     QGraphicsView::mouseReleaseEvent(event);
2355     if (m_scrollTimer.isActive()) m_scrollTimer.stop();
2356     if (event->button() == Qt::MidButton) {
2357         return;
2358     }
2359     setDragMode(QGraphicsView::NoDrag);
2360     if (m_operationMode == MOVEGUIDE) {
2361         setCursor(Qt::ArrowCursor);
2362         m_operationMode = NONE;
2363         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
2364         GenTime newPos = GenTime(m_dragGuide->pos().x(), m_document->fps());
2365         if (newPos != m_dragGuide->position()) {
2366             EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), newPos, m_dragGuide->label(), false);
2367             m_commandStack->push(command);
2368             m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
2369             qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
2370             m_document->syncGuides(m_guides);
2371         }
2372         m_dragGuide = NULL;
2373         m_dragItem = NULL;
2374         return;
2375     } else if (m_operationMode == SPACER && m_selectionGroup) {
2376         int track;
2377         if (event->modifiers() != Qt::ControlModifier) {
2378             // We are moving all tracks
2379             track = -1;
2380         } else track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
2381         GenTime timeOffset = GenTime(m_selectionGroup->scenePos().x(), m_document->fps()) - m_selectionGroupInfo.startPos;
2382         if (timeOffset != GenTime()) {
2383             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
2384
2385             QList<ItemInfo> clipsToMove;
2386             QList<ItemInfo> transitionsToMove;
2387
2388             // Create lists with start pos for each track
2389             QMap <int, int> trackClipStartList;
2390             QMap <int, int> trackTransitionStartList;
2391
2392             for (int i = 1; i < m_document->tracksCount() + 1; i++) {
2393                 trackClipStartList[i] = -1;
2394                 trackTransitionStartList[i] = -1;
2395             }
2396
2397             int max = items.count();
2398             for (int i = 0; i < max; i++) {
2399                 if (items.at(i)->type() == GROUPWIDGET)
2400                     items += static_cast <QGraphicsItemGroup *>(items.at(i))->childItems();
2401             }
2402
2403             for (int i = 0; i < items.count(); i++) {
2404                 if (items.at(i)->type() == AVWIDGET) {
2405                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2406                     ItemInfo info = item->info();
2407                     clipsToMove.append(info);
2408                     item->updateItem();
2409                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackClipStartList.value(m_document->tracksCount() - info.track))
2410                         trackClipStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2411                 } else if (items.at(i)->type() == TRANSITIONWIDGET) {
2412                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2413                     ItemInfo info = item->info();
2414                     transitionsToMove.append(info);
2415                     item->updateItem();
2416                     if (trackTransitionStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackTransitionStartList.value(m_document->tracksCount() - info.track))
2417                         trackTransitionStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2418                 }
2419             }
2420
2421             InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, timeOffset, false);
2422             m_commandStack->push(command);
2423             if (track != -1) track = m_document->tracksCount() - track;
2424             kDebug() << "SPACER TRACK:" << track;
2425             m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, timeOffset, GenTime());
2426         }
2427         resetSelectionGroup(false);
2428         m_operationMode = NONE;
2429     } else if (m_operationMode == RUBBERSELECTION) {
2430         //kDebug() << "// END RUBBER SELECT";
2431         resetSelectionGroup();
2432         groupSelectedItems();
2433         m_operationMode = NONE;
2434     }
2435
2436     if (m_dragItem == NULL && m_selectionGroup == NULL) {
2437         emit transitionItemSelected(NULL);
2438         return;
2439     }
2440     ItemInfo info;
2441     if (m_dragItem) info = m_dragItem->info();
2442
2443     if (m_operationMode == MOVE) {
2444         setCursor(Qt::OpenHandCursor);
2445
2446         if (m_dragItem->parentItem() == 0) {
2447             // we are moving one clip, easy
2448             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2449                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
2450                 Mlt::Producer *prod;
2451                 if (item->isAudioOnly()) prod = item->baseClip()->audioProducer(m_dragItemInfo.track);
2452                 else if (item->isVideoOnly()) prod = item->baseClip()->videoProducer();
2453                 else prod = item->baseClip()->producer(m_dragItemInfo.track);
2454                 bool success = m_document->renderer()->mltMoveClip((int)(m_document->tracksCount() - m_dragItemInfo.track), (int)(m_document->tracksCount() - m_dragItem->track()), (int) m_dragItemInfo.startPos.frames(m_document->fps()), (int)(m_dragItem->startPos().frames(m_document->fps())), prod);
2455
2456                 if (success) {
2457                     int tracknumber = m_document->tracksCount() - item->track() - 1;
2458                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2459                     if (isLocked) item->setItemLocked(true);
2460
2461                     QUndoCommand *moveCommand = new QUndoCommand();
2462                     moveCommand->setText(i18n("Move clip"));
2463                     new MoveClipCommand(this, m_dragItemInfo, info, false, moveCommand);
2464                     // Also move automatic transitions (on lower track)
2465                     Transition *tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2466                     if (tr && tr->isAutomatic()) {
2467                         ItemInfo trInfo = tr->info();
2468                         ItemInfo newTrInfo = trInfo;
2469                         newTrInfo.track = info.track;
2470                         newTrInfo.startPos = m_dragItem->startPos();
2471                         if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtEnd(newTrInfo.endPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2472                             // transition end should stay the same
2473                         } else {
2474                             // transition end should be adjusted to clip
2475                             newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2476                         }
2477                         if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2478                     }
2479                     if (tr == NULL || tr->endPos() < m_dragItemInfo.endPos) {
2480                         // Check if there is a transition at clip end
2481                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2482                         if (tr && tr->isAutomatic()) {
2483                             ItemInfo trInfo = tr->info();
2484                             ItemInfo newTrInfo = trInfo;
2485                             newTrInfo.track = info.track;
2486                             newTrInfo.endPos = m_dragItem->endPos();
2487                             if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtStart(trInfo.startPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2488                                 // transition start should stay the same
2489                             } else {
2490                                 // transition start should be moved
2491                                 newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2492                             }
2493                             if (newTrInfo.startPos < newTrInfo.endPos)
2494                                 new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2495                         }
2496                     }
2497                     // Also move automatic transitions (on upper track)
2498                     tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2499                     if (m_dragItemInfo.track == info.track && tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2500                         ItemInfo trInfo = tr->info();
2501                         ItemInfo newTrInfo = trInfo;
2502                         newTrInfo.startPos = m_dragItem->startPos();
2503                         ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2504                         if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2505                             if (!getClipItemAtEnd(newTrInfo.endPos, tr->track())) {
2506                                 // transition end should be adjusted to clip on upper track
2507                                 newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2508                             }
2509                             if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2510                         }
2511                     }
2512                     if (m_dragItemInfo.track == info.track && (tr == NULL || tr->endPos() < m_dragItemInfo.endPos)) {
2513                         // Check if there is a transition at clip end
2514                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2515                         if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2516                             ItemInfo trInfo = tr->info();
2517                             ItemInfo newTrInfo = trInfo;
2518                             newTrInfo.endPos = m_dragItem->endPos();
2519                             ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2520                             if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2521                                 if (!getClipItemAtStart(trInfo.startPos, tr->track())) {
2522                                     // transition start should be moved
2523                                     newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2524                                 }
2525                                 if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2526                             }
2527                         }
2528                     }
2529                     m_commandStack->push(moveCommand);
2530                 } else {
2531                     // undo last move and emit error message
2532                     bool snap = KdenliveSettings::snaptopoints();
2533                     KdenliveSettings::setSnaptopoints(false);
2534                     item->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (int)(m_dragItemInfo.track * m_tracksHeight + 1));
2535                     KdenliveSettings::setSnaptopoints(snap);
2536                     emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(m_dragItemInfo.startPos.frames(m_document->fps()))), ErrorMessage);
2537                 }
2538                 setDocumentModified();
2539             }
2540             if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2541                 Transition *transition = static_cast <Transition *>(m_dragItem);
2542                 if (!m_document->renderer()->mltMoveTransition(transition->transitionTag(), (int)(m_document->tracksCount() - m_dragItemInfo.track), (int)(m_document->tracksCount() - m_dragItem->track()), transition->transitionEndTrack(), m_dragItemInfo.startPos, m_dragItemInfo.endPos, info.startPos, info.endPos)) {
2543                     // Moving transition failed, revert to previous position
2544                     emit displayMessage(i18n("Cannot move transition"), ErrorMessage);
2545                     transition->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (m_dragItemInfo.track) * m_tracksHeight + 1);
2546                 } else {
2547                     MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2548                     m_commandStack->push(command);
2549                     transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
2550                 }
2551             }
2552         } else {
2553             // Moving several clips. We need to delete them and readd them to new position,
2554             // or they might overlap each other during the move
2555             QGraphicsItemGroup *group = static_cast <QGraphicsItemGroup *>(m_dragItem->parentItem());
2556             QList<QGraphicsItem *> items = group->childItems();
2557
2558             QList<ItemInfo> clipsToMove;
2559             QList<ItemInfo> transitionsToMove;
2560
2561             GenTime timeOffset = GenTime(m_dragItem->scenePos().x(), m_document->fps()) - m_dragItemInfo.startPos;
2562             const int trackOffset = (int)(m_dragItem->scenePos().y() / m_tracksHeight) - m_dragItemInfo.track;
2563             //kDebug() << "// MOVED SEVERAL CLIPS" << timeOffset.frames(25);
2564             if (timeOffset != GenTime() || trackOffset != 0) {
2565                 // remove items in MLT playlist
2566
2567                 // Expand groups
2568                 int max = items.count();
2569                 for (int i = 0; i < max; i++) {
2570                     if (items.at(i)->type() == GROUPWIDGET) {
2571                         items += items.at(i)->childItems();
2572                     }
2573                 }
2574
2575                 for (int i = 0; i < items.count(); i++) {
2576                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2577                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2578                     ItemInfo info = item->info();
2579                     if (item->type() == AVWIDGET) {
2580                         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2581                             // error, clip cannot be removed from playlist
2582                             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2583                         } else {
2584                             clipsToMove.append(info);
2585                         }
2586                     } else {
2587                         transitionsToMove.append(info);
2588                         Transition *tr = static_cast <Transition*>(item);
2589                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2590                     }
2591                 }
2592
2593                 for (int i = 0; i < items.count(); i++) {
2594                     // re-add items in correct place
2595                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2596                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2597                     item->updateItem();
2598                     ItemInfo info = item->info();
2599                     int tracknumber = m_document->tracksCount() - info.track - 1;
2600                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2601                     if (isLocked) {
2602                         group->removeFromGroup(item);
2603                         item->setItemLocked(true);
2604                     }
2605
2606                     if (item->type() == AVWIDGET) {
2607                         ClipItem *clip = static_cast <ClipItem*>(item);
2608                         info.track = m_document->tracksCount() - info.track;
2609                         Mlt::Producer *prod;
2610                         if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(info.track);
2611                         else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
2612                         else prod = clip->baseClip()->producer(info.track);
2613                         m_document->renderer()->mltInsertClip(info, clip->xml(), prod);
2614                         for (int i = 0; i < clip->effectsCount(); i++) {
2615                             m_document->renderer()->mltAddEffect(info.track, info.startPos, clip->getEffectArgs(clip->effectAt(i)), false);
2616                         }
2617                     } else {
2618                         Transition *tr = static_cast <Transition*>(item);
2619                         int newTrack = tr->transitionEndTrack();
2620                         if (!tr->forcedTrack()) {
2621                             newTrack = getPreviousVideoTrack(info.track);
2622                         }
2623                         tr->updateTransitionEndTrack(newTrack);
2624                         m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2625                     }
2626                 }
2627
2628                 MoveGroupCommand *move = new MoveGroupCommand(this, clipsToMove, transitionsToMove, timeOffset, trackOffset, false);
2629                 m_commandStack->push(move);
2630
2631                 //QPointF top = group->sceneBoundingRect().topLeft();
2632                 //QPointF oldpos = m_selectionGroup->scenePos();
2633                 //kDebug()<<"SELECTION GRP POS: "<<m_selectionGroup->scenePos()<<", TOP: "<<top;
2634                 //group->setPos(top);
2635                 //TODO: get rid of the 3 lines below
2636                 if (m_selectionGroup) {
2637                     m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2638                     m_selectionGroupInfo.track = m_selectionGroup->track();
2639                 }
2640                 setDocumentModified();
2641             }
2642         }
2643         m_document->renderer()->doRefresh();
2644     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
2645         // resize start
2646         if (m_dragItem->type() == AVWIDGET) {
2647             ItemInfo resizeinfo = m_dragItemInfo;
2648             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2649             bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, m_dragItem->startPos() - m_dragItemInfo.startPos);
2650             if (success) {
2651                 QUndoCommand *resizeCommand = new QUndoCommand();
2652                 resizeCommand->setText(i18n("Resize clip"));
2653
2654                 // Check if there is an automatic transition on that clip (lower track)
2655                 Transition *transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2656                 if (transition && transition->isAutomatic()) {
2657                     ItemInfo trInfo = transition->info();
2658                     ItemInfo newTrInfo = trInfo;
2659                     newTrInfo.startPos = m_dragItem->startPos();
2660                     if (newTrInfo.startPos < newTrInfo.endPos)
2661                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2662                 }
2663                 // Check if there is an automatic transition on that clip (upper track)
2664                 transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2665                 if (transition && transition->isAutomatic() && (m_document->tracksCount() - transition->transitionEndTrack()) == m_dragItemInfo.track) {
2666                     ItemInfo trInfo = transition->info();
2667                     ItemInfo newTrInfo = trInfo;
2668                     newTrInfo.startPos = m_dragItem->startPos();
2669                     ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2670                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.startPos < newTrInfo.endPos) {
2671                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2672                     }
2673                 }
2674                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
2675                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2676                 m_commandStack->push(resizeCommand);
2677             } else {
2678                 m_dragItem->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2679                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2680             }
2681         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2682             Transition *transition = static_cast <Transition *>(m_dragItem);
2683             if (!m_document->renderer()->mltMoveTransition(transition->transitionTag(), (int)(m_document->tracksCount() - m_dragItemInfo.track), (int)(m_document->tracksCount() - m_dragItemInfo.track), transition->transitionEndTrack(), m_dragItemInfo.startPos, m_dragItemInfo.endPos, info.startPos, info.endPos)) {
2684                 // Cannot resize transition
2685                 transition->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2686                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2687             } else {
2688                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2689                 m_commandStack->push(command);
2690             }
2691
2692         }
2693         if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
2694             // Item was resized, rebuild group;
2695             AbstractGroupItem *group = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
2696             QList <QGraphicsItem *> children = group->childItems();
2697             m_document->clipManager()->removeGroup(group);
2698             scene()->destroyItemGroup(group);
2699             for (int i = 0; i < children.count(); i++) {
2700                 children.at(i)->setSelected(true);
2701             }
2702             groupSelectedItems(false, true);
2703         }
2704         //m_document->renderer()->doRefresh();
2705     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
2706         // resize end
2707         if (m_dragItem->type() == AVWIDGET) {
2708             ItemInfo resizeinfo = info;
2709             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2710             bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.endPos - resizeinfo.startPos);
2711             if (success) {
2712                 QUndoCommand *resizeCommand = new QUndoCommand();
2713                 resizeCommand->setText(i18n("Resize clip"));
2714
2715                 // Check if there is an automatic transition on that clip (lower track)
2716                 Transition *tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2717                 if (tr && tr->isAutomatic()) {
2718                     ItemInfo trInfo = tr->info();
2719                     ItemInfo newTrInfo = trInfo;
2720                     newTrInfo.endPos = m_dragItem->endPos();
2721                     if (newTrInfo.endPos > newTrInfo.startPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2722                 }
2723
2724                 // Check if there is an automatic transition on that clip (upper track)
2725                 tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2726                 if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2727                     ItemInfo trInfo = tr->info();
2728                     ItemInfo newTrInfo = trInfo;
2729                     newTrInfo.endPos = m_dragItem->endPos();
2730                     ClipItem * upperClip = getClipItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2731                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.endPos > newTrInfo.startPos) {
2732                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2733                     }
2734                 }
2735
2736                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2737                 m_commandStack->push(resizeCommand);
2738                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
2739             } else {
2740                 m_dragItem->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2741                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2742             }
2743         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2744             Transition *transition = static_cast <Transition *>(m_dragItem);
2745             if (!m_document->renderer()->mltMoveTransition(transition->transitionTag(), (int)(m_document->tracksCount() - m_dragItemInfo.track), (int)(m_document->tracksCount() - m_dragItemInfo.track), 0, m_dragItemInfo.startPos, m_dragItemInfo.endPos, info.startPos, info.endPos)) {
2746                 // Cannot resize transition
2747                 transition->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2748                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2749             } else {
2750                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2751                 m_commandStack->push(command);
2752             }
2753         }
2754         if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
2755             // Item was resized, rebuild group;
2756             AbstractGroupItem *group = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
2757             QList <QGraphicsItem *> children = group->childItems();
2758             m_document->clipManager()->removeGroup(group);
2759             scene()->destroyItemGroup(group);
2760             for (int i = 0; i < children.count(); i++) {
2761                 children.at(i)->setSelected(true);
2762             }
2763             groupSelectedItems(false, true);
2764         }
2765         //m_document->renderer()->doRefresh();
2766     } else if (m_operationMode == FADEIN) {
2767         // resize fade in effect
2768         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
2769         int ix = item->hasEffect("volume", "fadein");
2770         if (ix != -1) {
2771             QDomElement oldeffect = item->effectAt(ix).cloneNode().toElement();
2772             int start = item->cropStart().frames(m_document->fps());
2773             int end = item->fadeIn();
2774             if (end == 0) {
2775                 slotDeleteEffect(item, oldeffect);
2776             } else {
2777                 end += start;
2778                 QDomElement effect = oldeffect.cloneNode().toElement();
2779                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2780                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2781                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2782                 emit clipItemSelected(item, ix);
2783             }
2784         } else if (item->fadeIn() != 0 && item->hasEffect("", "fade_from_black") == -1) {
2785             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadein").cloneNode().toElement();
2786             EffectsList::setParameter(effect, "out", QString::number(item->fadeIn()));
2787             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2788         }
2789         ix = item->hasEffect("volume", "fade_from_black");
2790         if (ix != -1) {
2791             QDomElement oldeffect = item->effectAt(ix).cloneNode().toElement();
2792             int start = item->cropStart().frames(m_document->fps());
2793             int end = item->fadeIn();
2794             if (end == 0) {
2795                 slotDeleteEffect(item, oldeffect);
2796             } else {
2797                 end += start;
2798                 QDomElement effect = oldeffect.cloneNode().toElement();
2799                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2800                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2801                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2802                 emit clipItemSelected(item, ix);
2803             }
2804         }
2805     } else if (m_operationMode == FADEOUT) {
2806         // resize fade in effect
2807         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
2808         int ix = item->hasEffect("volume", "fadeout");
2809         if (ix != -1) {
2810             QDomElement oldeffect = item->effectAt(ix).cloneNode().toElement();
2811             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
2812             int start = item->fadeOut();
2813             if (start == 0) {
2814                 slotDeleteEffect(item, oldeffect);
2815             } else {
2816                 start = end - start;
2817                 QDomElement effect = oldeffect.cloneNode().toElement();
2818                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2819                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2820                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2821                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2822                 emit clipItemSelected(item, ix);
2823             }
2824         } else if (item->fadeOut() != 0 && item->hasEffect("", "fade_to_black") == -1) {
2825             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadeout").cloneNode().toElement();
2826             EffectsList::setParameter(effect, "in", QString::number(item->fadeOut()));
2827             EffectsList::setParameter(effect, "out", QString::number(0));
2828             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2829         }
2830         ix = item->hasEffect("brightness", "fade_to_black");
2831         if (ix != -1) {
2832             QDomElement oldeffect = item->effectAt(ix).cloneNode().toElement();
2833             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
2834             int start = item->fadeOut();
2835             if (start == 0) {
2836                 slotDeleteEffect(item, oldeffect);
2837             } else {
2838                 start = end - start;
2839                 QDomElement effect = oldeffect.cloneNode().toElement();
2840                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2841                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2842                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2843                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2844                 emit clipItemSelected(item, ix);
2845             }
2846         }
2847     } else if (m_operationMode == KEYFRAME) {
2848         // update the MLT effect
2849         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
2850         QString previous = item->keyframes(item->selectedEffectIndex());
2851         item->updateKeyframeEffect();
2852         QString next = item->keyframes(item->selectedEffectIndex());
2853         EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
2854         m_commandStack->push(command);
2855         updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
2856         emit clipItemSelected(item, item->selectedEffectIndex());
2857     }
2858     if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET && m_dragItem->isSelected()) {
2859         // A transition is selected
2860         QPoint p;
2861         ClipItem *transitionClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track);
2862         if (transitionClip && transitionClip->baseClip()) {
2863             QString size = transitionClip->baseClip()->getProperty("frame_size");
2864             p.setX(size.section('x', 0, 0).toInt());
2865             p.setY(size.section('x', 1, 1).toInt());
2866         }
2867         emit transitionItemSelected(static_cast <Transition *>(m_dragItem), getPreviousVideoTrack(m_dragItem->track()), p);
2868     } else emit transitionItemSelected(NULL);
2869     if (m_operationMode != NONE && m_operationMode != MOVE) setDocumentModified();
2870     m_operationMode = NONE;
2871 }
2872
2873 void CustomTrackView::deleteClip(ItemInfo info)
2874 {
2875     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
2876
2877     if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2878         emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2879         return;
2880     }
2881     if (item->isSelected()) emit clipItemSelected(NULL);
2882     item->baseClip()->removeReference();
2883     m_document->updateClip(item->baseClip()->getId());
2884
2885     /*if (item->baseClip()->isTransparent()) {
2886         // also remove automatic transition
2887         Transition *tr = getTransitionItemAt(info.startPos, info.track);
2888         if (tr && tr->isAutomatic()) {
2889             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2890             scene()->removeItem(tr);
2891             delete tr;
2892         }
2893     }*/
2894     scene()->removeItem(item);
2895     m_waitingThumbs.removeAll(item);
2896     if (m_dragItem == item) m_dragItem = NULL;
2897     delete item;
2898     item = NULL;
2899     setDocumentModified();
2900     m_document->renderer()->doRefresh();
2901 }
2902
2903 void CustomTrackView::deleteSelectedClips()
2904 {
2905     resetSelectionGroup();
2906     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2907     if (itemList.count() == 0) {
2908         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
2909         return;
2910     }
2911     scene()->clearSelection();
2912     QUndoCommand *deleteSelected = new QUndoCommand();
2913     deleteSelected->setText(i18n("Delete selected items"));
2914     bool resetGroup = false;
2915
2916     // expand & destroy groups
2917     for (int i = 0; i < itemList.count(); i++) {
2918         if (itemList.at(i)->type() == GROUPWIDGET) {
2919             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
2920             itemList += children;
2921             QList <ItemInfo> clipInfos;
2922             QList <ItemInfo> transitionInfos;
2923             GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2924             for (int j = 0; j < children.count(); j++) {
2925                 if (children.at(j)->type() == AVWIDGET) {
2926                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
2927                     if (!clip->isItemLocked()) clipInfos.append(clip->info());
2928                 } else if (children.at(j)->type() == TRANSITIONWIDGET) {
2929                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
2930                     if (!clip->isItemLocked()) transitionInfos.append(clip->info());
2931                 }
2932             }
2933             if (clipInfos.count() > 0) {
2934                 new GroupClipsCommand(this, clipInfos, transitionInfos, false, deleteSelected);
2935             }
2936         }
2937     }
2938
2939     for (int i = 0; i < itemList.count(); i++) {
2940         if (itemList.at(i)->type() == AVWIDGET) {
2941             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2942             if (item->parentItem()) resetGroup = true;
2943             //kDebug()<<"// DELETE CLP AT: "<<item->info().startPos.frames(25);
2944             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteSelected);
2945             emit clipItemSelected(NULL);
2946         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2947             Transition *item = static_cast <Transition *>(itemList.at(i));
2948             //kDebug()<<"// DELETE TRANS AT: "<<item->info().startPos.frames(25);
2949             if (item->parentItem()) resetGroup = true;
2950             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
2951             emit transitionItemSelected(NULL);
2952         }
2953     }
2954
2955     m_commandStack->push(deleteSelected);
2956 }
2957
2958 void CustomTrackView::changeClipSpeed()
2959 {
2960     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2961     if (itemList.count() == 0) {
2962         emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
2963         return;
2964     }
2965     QUndoCommand *changeSelected = new QUndoCommand();
2966     changeSelected->setText("Edit clip speed");
2967     int count = 0;
2968     int percent = -1;
2969     bool ok;
2970     for (int i = 0; i < itemList.count(); i++) {
2971         if (itemList.at(i)->type() == AVWIDGET) {
2972             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2973             ItemInfo info = item->info();
2974             if (percent == -1) percent = QInputDialog::getInteger(this, i18n("Edit Clip Speed"), i18n("New speed (percents)"), item->speed() * 100, 1, 10000, 1, &ok);
2975             if (!ok) break;
2976             double speed = (double) percent / 100.0;
2977             if (item->speed() != speed && (item->clipType() == VIDEO || item->clipType() == AV)) {
2978                 count++;
2979                 //new ChangeSpeedCommand(this, info, item->speed(), speed, item->clipProducer(), changeSelected);
2980             }
2981         }
2982     }
2983     if (count > 0) m_commandStack->push(changeSelected);
2984     else delete changeSelected;
2985 }
2986
2987 void CustomTrackView::doChangeClipSpeed(ItemInfo info, const double speed, const double oldspeed, int strobe, const QString &id)
2988 {
2989     DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
2990     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
2991     if (!item) {
2992         kDebug() << "ERROR: Cannot find clip for speed change";
2993         emit displayMessage(i18n("Cannot find clip for speed change"), ErrorMessage);
2994         return;
2995     }
2996     info.track = m_document->tracksCount() - item->track();
2997     int endPos = m_document->renderer()->mltChangeClipSpeed(info, speed, oldspeed, strobe, baseclip->producer());
2998     if (endPos >= 0) {
2999         item->setSpeed(speed, strobe);
3000         item->updateRectGeometry();
3001         if (item->cropDuration().frames(m_document->fps()) > endPos)
3002             item->AbstractClipItem::resizeEnd(info.startPos.frames(m_document->fps()) + endPos, speed);
3003         setDocumentModified();
3004     } else emit displayMessage(i18n("Invalid clip"), ErrorMessage);
3005 }
3006
3007 void CustomTrackView::cutSelectedClips()
3008 {
3009     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3010     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
3011     for (int i = 0; i < itemList.count(); i++) {
3012         if (itemList.at(i)->type() == AVWIDGET) {
3013             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3014             if (item->parentItem() && item->parentItem() != m_selectionGroup) {
3015                 emit displayMessage(i18n("Cannot cut a clip in a group"), ErrorMessage);
3016             } else if (currentPos > item->startPos() && currentPos <  item->endPos()) {
3017                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos);
3018                 m_commandStack->push(command);
3019             }
3020         }
3021     }
3022 }
3023
3024 void CustomTrackView::groupClips(bool group)
3025 {
3026     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3027     QList <ItemInfo> clipInfos;
3028     QList <ItemInfo> transitionInfos;
3029     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
3030
3031     // Expand groups
3032     int max = itemList.count();
3033     for (int i = 0; i < max; i++) {
3034         if (itemList.at(i)->type() == GROUPWIDGET) {
3035             itemList += itemList.at(i)->childItems();
3036         }
3037     }
3038
3039     for (int i = 0; i < itemList.count(); i++) {
3040         if (itemList.at(i)->type() == AVWIDGET) {
3041             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
3042             if (!clip->isItemLocked()) clipInfos.append(clip->info());
3043         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3044             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
3045             if (!clip->isItemLocked()) transitionInfos.append(clip->info());
3046         }
3047     }
3048     if (clipInfos.count() > 0) {
3049         GroupClipsCommand *command = new GroupClipsCommand(this, clipInfos, transitionInfos, group);
3050         m_commandStack->push(command);
3051     }
3052 }
3053
3054 void CustomTrackView::doGroupClips(QList <ItemInfo> clipInfos, QList <ItemInfo> transitionInfos, bool group)
3055 {
3056     resetSelectionGroup();
3057     m_scene->clearSelection();
3058     if (!group) {
3059         for (int i = 0; i < clipInfos.count(); i++) {
3060             ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
3061             if (clip == NULL) continue;
3062             if (clip->parentItem() && clip->parentItem()->type() == GROUPWIDGET) {
3063                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
3064                 m_document->clipManager()->removeGroup(grp);
3065                 scene()->destroyItemGroup(grp);
3066             }
3067             clip->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
3068         }
3069         for (int i = 0; i < transitionInfos.count(); i++) {
3070             Transition *tr = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
3071             if (tr == NULL) continue;
3072             if (tr->parentItem() && tr->parentItem()->type() == GROUPWIDGET) {
3073                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(tr->parentItem());
3074                 m_document->clipManager()->removeGroup(grp);
3075                 scene()->destroyItemGroup(grp);
3076             }
3077             tr->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
3078         }
3079         setDocumentModified();
3080         return;
3081     }
3082
3083     QList <QGraphicsItemGroup *> groups;
3084     for (int i = 0; i < clipInfos.count(); i++) {
3085         ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
3086         if (clip) {
3087             clip->setSelected(true);
3088         }
3089     }
3090     for (int i = 0; i < transitionInfos.count(); i++) {
3091         Transition *clip = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
3092         if (clip) {
3093             clip->setSelected(true);
3094         }
3095     }
3096
3097     groupSelectedItems(false, true);
3098     setDocumentModified();
3099 }
3100
3101 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects)
3102 {
3103     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
3104     if (baseclip == NULL) {
3105         emit displayMessage(i18n("No clip copied"), ErrorMessage);
3106         return;
3107     }
3108     ClipItem *item = new ClipItem(baseclip, info, m_document->fps(), xml.attribute("speed", "1").toDouble(), xml.attribute("strobe", "1").toInt());
3109     item->setEffectList(effects);
3110     if (xml.hasAttribute("audio_only")) item->setAudioOnly(true);
3111     else if (xml.hasAttribute("video_only")) item->setVideoOnly(true);
3112     scene()->addItem(item);
3113
3114     int tracknumber = m_document->tracksCount() - info.track - 1;
3115     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3116     if (isLocked) item->setItemLocked(true);
3117
3118     baseclip->addReference();
3119     m_document->updateClip(baseclip->getId());
3120     info.track = m_document->tracksCount() - info.track;
3121     Mlt::Producer *prod;
3122     if (item->isAudioOnly()) prod = baseclip->audioProducer(info.track);
3123     else if (item->isVideoOnly()) prod = baseclip->videoProducer();
3124     else prod = baseclip->producer(info.track);
3125     m_document->renderer()->mltInsertClip(info, xml, prod);
3126     for (int i = 0; i < item->effectsCount(); i++) {
3127         m_document->renderer()->mltAddEffect(info.track, info.startPos, item->getEffectArgs(item->effectAt(i)), false);
3128     }
3129     setDocumentModified();
3130     m_document->renderer()->doRefresh();
3131     m_waitingThumbs.append(item);
3132     m_thumbsTimer.start();
3133 }
3134
3135 void CustomTrackView::slotUpdateClip(const QString &clipId)
3136 {
3137     QList<QGraphicsItem *> list = scene()->items();
3138     ClipItem *clip = NULL;
3139     for (int i = 0; i < list.size(); ++i) {
3140         if (list.at(i)->type() == AVWIDGET) {
3141             clip = static_cast <ClipItem *>(list.at(i));
3142             if (clip->clipProducer() == clipId) {
3143                 ItemInfo info = clip->info();
3144                 info.track = m_document->tracksCount() - clip->track();
3145                 m_document->renderer()->mltUpdateClip(info, clip->xml(), clip->baseClip()->producer());
3146                 clip->refreshClip(true);
3147                 clip->update();
3148             }
3149         }
3150     }
3151 }
3152
3153 ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track)
3154 {
3155     int framepos = (int)(pos.frames(m_document->fps()));
3156     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, track * m_tracksHeight + m_tracksHeight / 2));
3157     ClipItem *clip = NULL;
3158     for (int i = 0; i < list.size(); i++) {
3159         if (list.at(i)->type() == AVWIDGET) {
3160             ClipItem *test = static_cast <ClipItem *>(list.at(i));
3161             if (test->endPos() == pos) clip = test;
3162             break;
3163         }
3164     }
3165     return clip;
3166 }
3167
3168 ClipItem *CustomTrackView::getClipItemAtStart(GenTime pos, int track)
3169 {
3170     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2));
3171     ClipItem *clip = NULL;
3172     for (int i = 0; i < list.size(); i++) {
3173         if (list.at(i)->type() == AVWIDGET) {
3174             ClipItem *test = static_cast <ClipItem *>(list.at(i));
3175             if (test->startPos() == pos) clip = test;
3176             break;
3177         }
3178     }
3179     return clip;
3180 }
3181
3182 ClipItem *CustomTrackView::getClipItemAt(int pos, int track)
3183 {
3184     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, track * m_tracksHeight + m_tracksHeight / 2));
3185     ClipItem *clip = NULL;
3186     for (int i = 0; i < list.size(); i++) {
3187         if (list.at(i)->type() == AVWIDGET) {
3188             clip = static_cast <ClipItem *>(list.at(i));
3189             break;
3190         }
3191     }
3192     return clip;
3193 }
3194
3195 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track)
3196 {
3197     return getClipItemAt((int) pos.frames(m_document->fps()), track);
3198 }
3199
3200 Transition *CustomTrackView::getTransitionItemAt(int pos, int track)
3201 {
3202     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, (track + 1) * m_tracksHeight));
3203     Transition *clip = NULL;
3204     for (int i = 0; i < list.size(); i++) {
3205         if (list.at(i)->type() == TRANSITIONWIDGET) {
3206             clip = static_cast <Transition *>(list.at(i));
3207             break;
3208         }
3209     }
3210     return clip;
3211 }
3212
3213 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track)
3214 {
3215     return getTransitionItemAt(pos.frames(m_document->fps()), track);
3216 }
3217
3218 Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track)
3219 {
3220     int framepos = (int)(pos.frames(m_document->fps()));
3221     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, (track + 1) * m_tracksHeight));
3222     Transition *clip = NULL;
3223     for (int i = 0; i < list.size(); i++) {
3224         if (list.at(i)->type() == TRANSITIONWIDGET) {
3225             Transition *test = static_cast <Transition *>(list.at(i));
3226             if (test->endPos() == pos) clip = test;
3227             break;
3228         }
3229     }
3230     return clip;
3231 }
3232
3233 Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track)
3234 {
3235     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight));
3236     Transition *clip = NULL;
3237     for (int i = 0; i < list.size(); ++i) {
3238         if (list.at(i)->type() == TRANSITIONWIDGET) {
3239             Transition *test = static_cast <Transition *>(list.at(i));
3240             if (test->startPos() == pos) clip = test;
3241             break;
3242         }
3243     }
3244     return clip;
3245 }
3246
3247 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end)
3248 {
3249     if (m_selectionGroup) resetSelectionGroup(false);
3250     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()), start.track);
3251     if (!item) {
3252         emit displayMessage(i18n("Cannot move clip at time: %1 on track %2", m_document->timecode().getTimecodeFromFrames(start.startPos.frames(m_document->fps())), start.track), ErrorMessage);
3253         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";
3254         return;
3255     }
3256     Mlt::Producer *prod;
3257     if (item->isAudioOnly()) prod = item->baseClip()->audioProducer(end.track);
3258     else if (item->isVideoOnly()) prod = item->baseClip()->videoProducer();
3259     else prod = item->baseClip()->producer(end.track);
3260
3261     bool success = m_document->renderer()->mltMoveClip((int)(m_document->tracksCount() - start.track), (int)(m_document->tracksCount() - end.track), (int) start.startPos.frames(m_document->fps()), (int)end.startPos.frames(m_document->fps()), prod);
3262     if (success) {
3263         bool snap = KdenliveSettings::snaptopoints();
3264         KdenliveSettings::setSnaptopoints(false);
3265         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
3266
3267         int tracknumber = m_document->tracksCount() - end.track - 1;
3268         bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3269         m_scene->clearSelection();
3270         if (isLocked) item->setItemLocked(true);
3271         else {
3272             if (item->isItemLocked()) item->setItemLocked(false);
3273             item->setSelected(true);
3274         }
3275         if (item->baseClip()->isTransparent()) {
3276             // Also move automatic transition
3277             Transition *tr = getTransitionItemAt(start.startPos, start.track);
3278             if (tr && tr->isAutomatic()) {
3279                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
3280                 m_document->renderer()->mltMoveTransition(tr->transitionTag(), m_document->tracksCount() - start.track, m_document->tracksCount() - end.track, tr->transitionEndTrack(), start.startPos, start.endPos, end.startPos, end.endPos);
3281                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
3282             }
3283         }
3284         KdenliveSettings::setSnaptopoints(snap);
3285         setDocumentModified();
3286     } else {
3287         // undo last move and emit error message
3288         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
3289     }
3290     m_document->renderer()->doRefresh();
3291     //kDebug() << " // MOVED CLIP TO: " << end.startPos.frames(25) << ", ITEM START: " << item->startPos().frames(25);
3292 }
3293
3294 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove)
3295 {
3296     // Group Items
3297     /*kDebug() << "//GRP MOVE, REVERS:" << reverseMove;
3298     kDebug() << "// GROUP MOV; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;*/
3299     resetSelectionGroup();
3300     m_scene->clearSelection();
3301
3302     for (int i = 0; i < startClip.count(); i++) {
3303         if (reverseMove) {
3304             startClip[i].startPos = startClip.at(i).startPos - offset;
3305             startClip[i].track = startClip.at(i).track - trackOffset;
3306         }
3307         //kDebug()<<"//LKING FR CLIP AT:"<<startClip.at(i).startPos.frames(25)<<", TK:"<<startClip.at(i).track;
3308         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
3309         if (clip) {
3310             clip->setItemLocked(false);
3311             if (clip->parentItem()) clip->parentItem()->setSelected(true);
3312             else clip->setSelected(true);
3313             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
3314         } else kDebug() << "//MISSING CLIP AT: " << startClip.at(i).startPos.frames(25);
3315     }
3316     for (int i = 0; i < startTransition.count(); i++) {
3317         if (reverseMove) {
3318             startTransition[i].startPos = startTransition.at(i).startPos - offset;
3319             startTransition[i].track = startTransition.at(i).track - trackOffset;
3320         }
3321         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
3322         if (tr) {
3323             tr->setItemLocked(false);
3324             if (tr->parentItem()) tr->parentItem()->setSelected(true);
3325             else tr->setSelected(true);
3326             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - startTransition.at(i).track, startTransition.at(i).startPos, startTransition.at(i).endPos, tr->toXML());
3327         } else kDebug() << "//MISSING TRANSITION AT: " << startTransition.at(i).startPos.frames(25);
3328     }
3329     groupSelectedItems(true);
3330     if (m_selectionGroup) {
3331         bool snap = KdenliveSettings::snaptopoints();
3332         KdenliveSettings::setSnaptopoints(false);
3333
3334         m_selectionGroup->moveBy(offset.frames(m_document->fps()), trackOffset *(qreal) m_tracksHeight);
3335
3336         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
3337         // Expand groups
3338         int max = children.count();
3339         for (int i = 0; i < max; i++) {
3340             if (children.at(i)->type() == GROUPWIDGET) {
3341                 children += children.at(i)->childItems();
3342             }
3343         }
3344
3345         for (int i = 0; i < children.count(); i++) {
3346             // re-add items in correct place
3347             if (children.at(i)->type() != AVWIDGET && children.at(i)->type() != TRANSITIONWIDGET) continue;
3348             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
3349             item->updateItem();
3350             ItemInfo info = item->info();
3351             int tracknumber = m_document->tracksCount() - info.track - 1;
3352             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3353             if (isLocked) item->setItemLocked(true);
3354             else if (item->isItemLocked()) item->setItemLocked(false);
3355
3356             if (item->type() == AVWIDGET) {
3357                 ClipItem *clip = static_cast <ClipItem*>(item);
3358                 info.track = m_document->tracksCount() - info.track;
3359                 Mlt::Producer *prod;
3360                 if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(info.track);
3361                 else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
3362                 else prod = clip->baseClip()->producer(info.track);
3363                 m_document->renderer()->mltInsertClip(info, clip->xml(), prod);
3364                 kDebug() << "// inserting new clp: " << info.startPos.frames(25);
3365             } else if (item->type() == TRANSITIONWIDGET) {
3366                 Transition *tr = static_cast <Transition*>(item);
3367                 int newTrack = tr->transitionEndTrack();
3368                 kDebug() << "/// TRANSITION CURR TRK: " << newTrack;
3369                 if (!tr->forcedTrack()) {
3370                     newTrack += trackOffset;
3371                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
3372                 }
3373                 tr->updateTransitionEndTrack(newTrack);
3374                 kDebug() << "/// TRANSITION UPDATED TRK: " << newTrack;
3375                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
3376             }
3377         }
3378         KdenliveSettings::setSnaptopoints(snap);
3379         m_document->renderer()->doRefresh();
3380     } else kDebug() << "///////// WARNING; NO GROUP TO MOVE";
3381 }
3382
3383 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end)
3384 {
3385     Transition *item = getTransitionItemAt(start.startPos, start.track);
3386     if (!item) {
3387         emit displayMessage(i18n("Cannot move transition at time: %1 on track %2", m_document->timecode().getTimecodeFromFrames(start.startPos.frames(m_document->fps())), start.track), ErrorMessage);
3388         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
3389         return;
3390     }
3391     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
3392     bool snap = KdenliveSettings::snaptopoints();
3393     KdenliveSettings::setSnaptopoints(false);
3394     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
3395     if (end.endPos - end.startPos == start.endPos - start.startPos) {
3396         // Transition was moved
3397         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
3398     } else if (end.endPos == start.endPos) {
3399         // Transition start resize
3400         item->resizeStart((int) end.startPos.frames(m_document->fps()));
3401     } else if (end.startPos == start.startPos) {
3402         // Transition end resize;
3403         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3404     } else {
3405         // Move & resize
3406         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
3407         item->resizeStart((int) end.startPos.frames(m_document->fps()));
3408         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3409     }
3410     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
3411     KdenliveSettings::setSnaptopoints(snap);
3412     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
3413     m_document->renderer()->mltMoveTransition(item->transitionTag(), m_document->tracksCount() - start.track, m_document->tracksCount() - end.track, item->transitionEndTrack(), start.startPos, start.endPos, end.startPos, end.endPos);
3414     if (m_dragItem && m_dragItem == item) {
3415         QPoint p;
3416         ClipItem *transitionClip = getClipItemAt(item->startPos(), item->track());
3417         if (transitionClip && transitionClip->baseClip()) {
3418             QString size = transitionClip->baseClip()->getProperty("frame_size");
3419             p.setX(size.section('x', 0, 0).toInt());
3420             p.setY(size.section('x', 1, 1).toInt());
3421         }
3422         emit transitionItemSelected(item, getPreviousVideoTrack(item->track()), p);
3423     }
3424     m_document->renderer()->doRefresh();
3425 }
3426
3427 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end)
3428 {
3429     bool resizeClipStart = true;
3430     if (start.startPos == end.startPos) resizeClipStart = false;
3431     /*if (resizeClipStart) offset = 1;
3432     else offset = -1;*/
3433     ClipItem *item = getClipItemAt((int)(start.startPos.frames(m_document->fps())), start.track);
3434     if (!item) {
3435         emit displayMessage(i18n("Cannot move clip at time: %1 on track %2", m_document->timecode().getTimecodeFromFrames(start.startPos.frames(m_document->fps())), start.track), ErrorMessage);
3436         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
3437         return;
3438     }
3439     if (item->parentItem()) {
3440         // Item is part of a group, reset group
3441         resetSelectionGroup();
3442     }
3443     bool snap = KdenliveSettings::snaptopoints();
3444     KdenliveSettings::setSnaptopoints(false);
3445     if (resizeClipStart && start.startPos != end.startPos) {
3446         ItemInfo clipinfo = item->info();
3447         clipinfo.track = m_document->tracksCount() - clipinfo.track;
3448         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - item->startPos());
3449         if (success) {
3450             kDebug() << "RESIZE CLP STRAT TO:" << end.startPos.frames(m_document->fps()) << ", OLD ST: " << start.startPos.frames(25);
3451             item->resizeStart((int) end.startPos.frames(m_document->fps()));
3452             updateClipFade(item);
3453         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3454     } else if (!resizeClipStart) {
3455         ItemInfo clipinfo = item->info();
3456         clipinfo.track = m_document->tracksCount() - clipinfo.track;
3457         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
3458         if (success) {
3459             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3460             updateClipFade(item);
3461         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3462     }
3463     if (end.cropStart != start.cropStart) {
3464         kDebug() << "// RESIZE CROP, DIFF: " << (end.cropStart - start.cropStart).frames(25);
3465         ItemInfo clipinfo = end;
3466         clipinfo.track = m_document->tracksCount() - end.track;
3467         bool success = m_document->renderer()->mltResizeClipCrop(clipinfo, end.cropStart - start.cropStart);
3468         if (success) {
3469             item->setCropStart(end.cropStart);
3470             item->resetThumbs(true);
3471         }
3472     }
3473     m_document->renderer()->doRefresh();
3474     KdenliveSettings::setSnaptopoints(snap);
3475 }
3476
3477 void CustomTrackView::updateClipFade(ClipItem * item)
3478 {
3479     int end = item->fadeIn();
3480     if (end != 0) {
3481         // there is a fade in effect
3482         int effectPos = item->hasEffect("volume", "fadein");
3483         if (effectPos != -1) {
3484             QDomElement oldeffect = item->effectAt(effectPos);
3485             int start = item->cropStart().frames(m_document->fps());
3486             int max = item->cropDuration().frames(m_document->fps());
3487             if (end > max) {
3488                 // Make sure the fade effect is not longer than the clip
3489                 item->setFadeIn(max);
3490                 end = item->fadeIn();
3491             }
3492             end += start;
3493             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3494             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3495             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3496                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3497             // if fade effect is displayed, update the effect edit widget with new clip duration
3498             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3499         }
3500         effectPos = item->hasEffect("brightness", "fade_from_black");
3501         if (effectPos != -1) {
3502             QDomElement oldeffect = item->effectAt(effectPos);
3503             int start = item->cropStart().frames(m_document->fps());
3504             int max = item->cropDuration().frames(m_document->fps());
3505             if (end > max) {
3506                 // Make sure the fade effect is not longer than the clip
3507                 item->setFadeIn(max);
3508                 end = item->fadeIn();
3509             }
3510             end += start;
3511             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3512             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3513             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3514                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3515             // if fade effect is displayed, update the effect edit widget with new clip duration
3516             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3517         }
3518     }
3519     int start = item->fadeOut();
3520     if (start != 0) {
3521         // there is a fade out effect
3522         int effectPos = item->hasEffect("volume", "fadeout");
3523         if (effectPos != -1) {
3524             QDomElement oldeffect = item->effectAt(effectPos);
3525             int max = item->cropDuration().frames(m_document->fps());
3526             int end = max + item->cropStart().frames(m_document->fps());
3527             if (start > max) {
3528                 // Make sure the fade effect is not longer than the clip
3529                 item->setFadeOut(max);
3530                 start = item->fadeOut();
3531             }
3532             start = end - start;
3533             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3534             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3535             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3536                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3537             // if fade effect is displayed, update the effect edit widget with new clip duration
3538             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3539         }
3540         effectPos = item->hasEffect("brightness", "fade_to_black");
3541         if (effectPos != -1) {
3542             QDomElement oldeffect = item->effectAt(effectPos);
3543             int max = item->cropDuration().frames(m_document->fps());
3544             int end = max + item->cropStart().frames(m_document->fps());
3545             if (start > max) {
3546                 // Make sure the fade effect is not longer than the clip
3547                 item->setFadeOut(max);
3548                 start = item->fadeOut();
3549             }
3550             start = end - start;
3551             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3552             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3553             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3554                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3555             // if fade effect is displayed, update the effect edit widget with new clip duration
3556             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3557         }
3558     }
3559 }
3560
3561 double CustomTrackView::getSnapPointForPos(double pos)
3562 {
3563     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
3564 }
3565
3566 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected, QList <GenTime> offsetList, bool skipSelectedItems)
3567 {
3568     QList <GenTime> snaps;
3569     if (selected && offsetList.isEmpty()) offsetList.append(selected->cropDuration());
3570     QList<QGraphicsItem *> itemList = items();
3571     for (int i = 0; i < itemList.count(); i++) {
3572         if (itemList.at(i) == selected) continue;
3573         if (skipSelectedItems && itemList.at(i)->isSelected()) continue;
3574         if (itemList.at(i)->type() == AVWIDGET) {
3575             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3576             GenTime start = item->startPos();
3577             GenTime end = item->endPos();
3578             snaps.append(start);
3579             snaps.append(end);
3580             if (!offsetList.isEmpty()) {
3581                 for (int j = 0; j < offsetList.size(); j++) {
3582                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3583                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3584                 }
3585             }
3586             // Add clip markers
3587             QList < GenTime > markers = item->snapMarkers();
3588             for (int j = 0; j < markers.size(); ++j) {
3589                 GenTime t = markers.at(j);
3590                 snaps.append(t);
3591                 if (!offsetList.isEmpty()) {
3592                     for (int k = 0; k < offsetList.size(); k++) {
3593                         if (t > offsetList.at(k)) snaps.append(t - offsetList.at(k));
3594                     }
3595                 }
3596             }
3597         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3598             Transition *transition = static_cast <Transition*>(itemList.at(i));
3599             GenTime start = transition->startPos();
3600             GenTime end = transition->endPos();
3601             snaps.append(start);
3602             snaps.append(end);
3603             if (!offsetList.isEmpty()) {
3604                 for (int j = 0; j < offsetList.size(); j++) {
3605                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3606                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3607                 }
3608             }
3609         }
3610     }
3611
3612     // add cursor position
3613     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3614     snaps.append(pos);
3615     if (!offsetList.isEmpty()) {
3616         for (int j = 0; j < offsetList.size(); j++) {
3617             snaps.append(pos - offsetList.at(j));
3618         }
3619     }
3620
3621     // add guides
3622     for (int i = 0; i < m_guides.count(); i++) {
3623         snaps.append(m_guides.at(i)->position());
3624         if (!offsetList.isEmpty()) {
3625             for (int j = 0; j < offsetList.size(); j++) {
3626                 snaps.append(m_guides.at(i)->position() - offsetList.at(j));
3627             }
3628         }
3629     }
3630
3631     qSort(snaps);
3632     m_scene->setSnapList(snaps);
3633     //for (int i = 0; i < m_snapPoints.size(); ++i)
3634     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
3635 }
3636
3637 void CustomTrackView::slotSeekToPreviousSnap()
3638 {
3639     updateSnapPoints(NULL);
3640     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3641     setCursorPos((int) res.frames(m_document->fps()));
3642     checkScrolling();
3643 }
3644
3645 void CustomTrackView::slotSeekToNextSnap()
3646 {
3647     updateSnapPoints(NULL);
3648     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3649     setCursorPos((int) res.frames(m_document->fps()));
3650     checkScrolling();
3651 }
3652
3653 void CustomTrackView::clipStart()
3654 {
3655     ClipItem *item = getMainActiveClip();
3656     if (item != NULL) {
3657         setCursorPos((int) item->startPos().frames(m_document->fps()));
3658         checkScrolling();
3659     }
3660 }
3661
3662 void CustomTrackView::clipEnd()
3663 {
3664     ClipItem *item = getMainActiveClip();
3665     if (item != NULL) {
3666         setCursorPos((int) item->endPos().frames(m_document->fps()) - 1);
3667         checkScrolling();
3668     }
3669 }
3670
3671 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c)
3672 {
3673     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
3674     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t);
3675     m_commandStack->push(command);
3676 }
3677
3678 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position)
3679 {
3680     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position);
3681     m_commandStack->push(command);
3682 }
3683
3684 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id)
3685 {
3686     DocClipBase *base = m_document->clipManager()->getClipById(id);
3687     QList <CommentedTime> markers = base->commentedSnapMarkers();
3688
3689     if (markers.isEmpty()) {
3690         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
3691         return;
3692     }
3693     QUndoCommand *deleteMarkers = new QUndoCommand();
3694     deleteMarkers->setText("Delete clip markers");
3695
3696     for (int i = 0; i < markers.size(); i++) {
3697         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), deleteMarkers);
3698     }
3699     m_commandStack->push(deleteMarkers);
3700 }
3701
3702 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment)
3703 {
3704     DocClipBase *base = m_document->clipManager()->getClipById(id);
3705     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
3706     else base->deleteSnapMarker(pos);
3707     setDocumentModified();
3708     viewport()->update();
3709 }
3710
3711 int CustomTrackView::hasGuide(int pos, int offset)
3712 {
3713     for (int i = 0; i < m_guides.count(); i++) {
3714         int guidePos = m_guides.at(i)->position().frames(m_document->fps());
3715         if (qAbs(guidePos - pos) <= offset) return guidePos;
3716         else if (guidePos > pos) return -1;
3717     }
3718     return -1;
3719 }
3720
3721 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment)
3722 {
3723     if (oldPos > GenTime() && pos > GenTime()) {
3724         // move guide
3725         for (int i = 0; i < m_guides.count(); i++) {
3726             if (m_guides.at(i)->position() == oldPos) {
3727                 Guide *item = m_guides.at(i);
3728                 item->updateGuide(pos, comment);
3729                 break;
3730             }
3731         }
3732     } else if (pos > GenTime()) addGuide(pos, comment);
3733     else {
3734         // remove guide
3735         bool found = false;
3736         for (int i = 0; i < m_guides.count(); i++) {
3737             if (m_guides.at(i)->position() == oldPos) {
3738                 delete m_guides.takeAt(i);
3739                 found = true;
3740                 break;
3741             }
3742         }
3743         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3744     }
3745     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3746     m_document->syncGuides(m_guides);
3747 }
3748
3749 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment)
3750 {
3751     for (int i = 0; i < m_guides.count(); i++) {
3752         if (m_guides.at(i)->position() == pos) {
3753             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
3754             return false;
3755         }
3756     }
3757     Guide *g = new Guide(this, pos, comment, m_document->fps(), m_tracksHeight * m_document->tracksCount());
3758     scene()->addItem(g);
3759     m_guides.append(g);
3760     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3761     m_document->syncGuides(m_guides);
3762     return true;
3763 }
3764
3765 void CustomTrackView::slotAddGuide()
3766 {
3767     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
3768     MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
3769     if (d.exec() != QDialog::Accepted) return;
3770     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
3771         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
3772         m_commandStack->push(command);
3773     }
3774 }
3775
3776 void CustomTrackView::slotEditGuide(int guidePos)
3777 {
3778     GenTime pos;
3779     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
3780     else pos = GenTime(guidePos, m_document->fps());
3781     bool found = false;
3782     for (int i = 0; i < m_guides.count(); i++) {
3783         if (m_guides.at(i)->position() == pos) {
3784             slotEditGuide(m_guides.at(i)->info());
3785             found = true;
3786             break;
3787         }
3788     }
3789     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3790 }
3791
3792 void CustomTrackView::slotEditGuide(CommentedTime guide)
3793 {
3794     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
3795     if (d.exec() == QDialog::Accepted) {
3796         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
3797         m_commandStack->push(command);
3798     }
3799 }
3800
3801
3802 void CustomTrackView::slotEditTimeLineGuide()
3803 {
3804     if (m_dragGuide == NULL) return;
3805     CommentedTime guide = m_dragGuide->info();
3806     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
3807     if (d.exec() == QDialog::Accepted) {
3808         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
3809         m_commandStack->push(command);
3810     }
3811 }
3812
3813 void CustomTrackView::slotDeleteGuide(int guidePos)
3814 {
3815     GenTime pos;
3816     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
3817     else pos = GenTime(guidePos, m_document->fps());
3818     bool found = false;
3819     for (int i = 0; i < m_guides.count(); i++) {
3820         if (m_guides.at(i)->position() == pos) {
3821             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
3822             m_commandStack->push(command);
3823             found = true;
3824             break;
3825         }
3826     }
3827     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3828 }
3829
3830
3831 void CustomTrackView::slotDeleteTimeLineGuide()
3832 {
3833     if (m_dragGuide == NULL) return;
3834     EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(), QString(), true);
3835     m_commandStack->push(command);
3836 }
3837
3838
3839 void CustomTrackView::slotDeleteAllGuides()
3840 {
3841     QUndoCommand *deleteAll = new QUndoCommand();
3842     deleteAll->setText("Delete all guides");
3843     for (int i = 0; i < m_guides.count(); i++) {
3844         new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
3845     }
3846     m_commandStack->push(deleteAll);
3847 }
3848
3849 void CustomTrackView::setTool(PROJECTTOOL tool)
3850 {
3851     m_tool = tool;
3852 }
3853
3854 void CustomTrackView::setScale(double scaleFactor, double verticalScale)
3855 {
3856     QMatrix matrix;
3857     matrix = matrix.scale(scaleFactor, verticalScale);
3858     m_scene->setScale(scaleFactor, verticalScale);
3859     m_animationTimer->stop();
3860     delete m_visualTip;
3861     m_visualTip = NULL;
3862     delete m_animation;
3863     m_animation = NULL;
3864     double verticalPos = mapToScene(QPoint(0, viewport()->height() / 2)).y();
3865     setMatrix(matrix);
3866     int diff = sceneRect().width() - m_projectDuration;
3867     if (diff * matrix.m11() < 50) {
3868         if (matrix.m11() < 0.4) setSceneRect(0, 0, (m_projectDuration + 100 / matrix.m11()), sceneRect().height());
3869         else setSceneRect(0, 0, (m_projectDuration + 300), sceneRect().height());
3870     }
3871     centerOn(QPointF(cursorPos(), verticalPos));
3872 }
3873
3874 void CustomTrackView::slotRefreshGuides()
3875 {
3876     if (KdenliveSettings::showmarkers()) {
3877         for (int i = 0; i < m_guides.count(); i++) {
3878             m_guides.at(i)->update();
3879         }
3880     }
3881 }
3882
3883 void CustomTrackView::drawBackground(QPainter * painter, const QRectF &rect)
3884 {
3885     QRectF r = rect;
3886     r.setWidth(r.width() + 1);
3887     painter->setClipRect(r);
3888     painter->drawLine(r.left(), 0, r.right(), 0);
3889     uint max = m_document->tracksCount();
3890     KColorScheme scheme(palette().currentColorGroup(), KColorScheme::Window);
3891     QColor lockedColor = scheme.background(KColorScheme::NegativeBackground).color();
3892     QColor audioColor = palette().alternateBase().color();
3893     QColor base = scheme.background(KColorScheme::NormalBackground).color();
3894     for (uint i = 0; i < max; i++) {
3895         if (m_document->trackInfoAt(max - i - 1).isLocked == true) painter->fillRect(r.left(), m_tracksHeight * i + 1, r.right() - r.left() + 1, m_tracksHeight - 1, QBrush(lockedColor));
3896         else if (m_document->trackInfoAt(max - i - 1).type == AUDIOTRACK) painter->fillRect(r.left(), m_tracksHeight * i + 1, r.right() - r.left() + 1, m_tracksHeight - 1, QBrush(audioColor));
3897         painter->drawLine(r.left(), m_tracksHeight *(i + 1), r.right(), m_tracksHeight *(i + 1));
3898     }
3899     int lowerLimit = m_tracksHeight * m_document->tracksCount() + 1;
3900     if (height() > lowerLimit)
3901         painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
3902 }
3903
3904 bool CustomTrackView::findString(const QString &text)
3905 {
3906     QString marker;
3907     for (int i = 0; i < m_searchPoints.size(); ++i) {
3908         marker = m_searchPoints.at(i).comment();
3909         if (marker.contains(text, Qt::CaseInsensitive)) {
3910             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3911             int vert = verticalScrollBar()->value();
3912             int hor = cursorPos();
3913             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3914             m_findIndex = i;
3915             return true;
3916         }
3917     }
3918     return false;
3919 }
3920
3921 bool CustomTrackView::findNextString(const QString &text)
3922 {
3923     QString marker;
3924     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
3925         marker = m_searchPoints.at(i).comment();
3926         if (marker.contains(text, Qt::CaseInsensitive)) {
3927             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3928             int vert = verticalScrollBar()->value();
3929             int hor = cursorPos();
3930             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3931             m_findIndex = i;
3932             return true;
3933         }
3934     }
3935     m_findIndex = -1;
3936     return false;
3937 }
3938
3939 void CustomTrackView::initSearchStrings()
3940 {
3941     m_searchPoints.clear();
3942     QList<QGraphicsItem *> itemList = items();
3943     for (int i = 0; i < itemList.count(); i++) {
3944         // parse all clip names
3945         if (itemList.at(i)->type() == AVWIDGET) {
3946             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3947             GenTime start = item->startPos();
3948             CommentedTime t(start, item->clipName());
3949             m_searchPoints.append(t);
3950             // add all clip markers
3951             QList < CommentedTime > markers = item->commentedSnapMarkers();
3952             m_searchPoints += markers;
3953         }
3954     }
3955
3956     // add guides
3957     for (int i = 0; i < m_guides.count(); i++) {
3958         m_searchPoints.append(m_guides.at(i)->info());
3959     }
3960
3961     qSort(m_searchPoints);
3962 }
3963
3964 void CustomTrackView::clearSearchStrings()
3965 {
3966     m_searchPoints.clear();
3967     m_findIndex = 0;
3968 }
3969
3970 void CustomTrackView::copyClip()
3971 {
3972     qDeleteAll(m_copiedItems);
3973     m_copiedItems.clear();
3974     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3975     if (itemList.count() == 0) {
3976         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
3977         return;
3978     }
3979     for (int i = 0; i < itemList.count(); i++) {
3980         if (itemList.at(i)->type() == AVWIDGET) {
3981             ClipItem *clip = static_cast <ClipItem *>(itemList.at(i));
3982             ClipItem *clone = clip->clone(clip->info());
3983             m_copiedItems.append(clone);
3984         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3985             Transition *dup = static_cast <Transition *>(itemList.at(i));
3986             m_copiedItems.append(dup->clone());
3987         }
3988     }
3989 }
3990
3991 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const
3992 {
3993     QRectF rect((double) info.startPos.frames(m_document->fps()), (double)(info.track * m_tracksHeight + 1), (double)(info.endPos - info.startPos).frames(m_document->fps()), (double)(m_tracksHeight - 1));
3994     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3995     for (int i = 0; i < collisions.count(); i++) {
3996         if (collisions.at(i)->type() == type) return false;
3997     }
3998     return true;
3999 }
4000
4001 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
4002 {
4003     for (int i = 0; i < items.count(); i++) {
4004         ItemInfo info = items.at(i)->info();
4005         info.startPos += offset;
4006         info.endPos += offset;
4007         info.track += trackOffset;
4008         if (!canBePastedTo(info, items.at(i)->type())) return false;
4009     }
4010     return true;
4011 }
4012
4013 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
4014 {
4015     QPainterPath movePath;
4016     movePath.moveTo(0, 0);
4017
4018     for (int i = 0; i < items.count(); i++) {
4019         ItemInfo info = items.at(i)->info();
4020         info.startPos = info.startPos + offset;
4021         info.endPos = info.endPos + offset;
4022         info.track = info.track + trackOffset;
4023         if (info.startPos < GenTime()) {
4024             // No clip should go below 0
4025             return false;
4026         }
4027         QRectF rect((double) info.startPos.frames(m_document->fps()), (double)(info.track * m_tracksHeight + 1), (double)(info.endPos - info.startPos).frames(m_document->fps()), (double)(m_tracksHeight - 1));
4028         movePath.addRect(rect);
4029     }
4030     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
4031     for (int i = 0; i < collisions.count(); i++) {
4032         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
4033             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
4034             return false;
4035         }
4036     }
4037     return true;
4038 }
4039
4040 void CustomTrackView::pasteClip()
4041 {
4042     if (m_copiedItems.count() == 0) {
4043         emit displayMessage(i18n("No clip copied"), ErrorMessage);
4044         return;
4045     }
4046     QPoint position;
4047     if (m_menuPosition.isNull()) {
4048         position = mapFromGlobal(QCursor::pos());
4049         if (!underMouse() || position.y() > m_tracksHeight * m_document->tracksCount()) {
4050             emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
4051             return;
4052         }
4053     } else position = m_menuPosition;
4054     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
4055     int track = (int)(position.y() / m_tracksHeight);
4056     ItemInfo first = m_copiedItems.at(0)->info();
4057
4058     GenTime offset = pos - first.startPos;
4059     int trackOffset = track - first.track;
4060
4061     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
4062         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
4063         return;
4064     }
4065     QUndoCommand *pasteClips = new QUndoCommand();
4066     pasteClips->setText("Paste clips");
4067
4068     for (int i = 0; i < m_copiedItems.count(); i++) {
4069         // parse all clip names
4070         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
4071             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
4072             ItemInfo info;
4073             info.startPos = clip->startPos() + offset;
4074             info.endPos = clip->endPos() + offset;
4075             info.cropStart = clip->cropStart();
4076             info.track = clip->track() + trackOffset;
4077             if (canBePastedTo(info, AVWIDGET)) {
4078                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
4079             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
4080         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
4081             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
4082             ItemInfo info;
4083             info.startPos = tr->startPos() + offset;
4084             info.endPos = tr->endPos() + offset;
4085             info.track = tr->track() + trackOffset;
4086             if (canBePastedTo(info, TRANSITIONWIDGET)) {
4087                 if (info.startPos >= info.endPos) {
4088                     emit displayMessage(i18n("Invalid transition"), ErrorMessage);
4089                 } else new AddTransitionCommand(this, info, tr->transitionEndTrack() + trackOffset, tr->toXML(), false, true, pasteClips);
4090             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
4091         }
4092     }
4093     m_commandStack->push(pasteClips);
4094 }
4095
4096 void CustomTrackView::pasteClipEffects()
4097 {
4098     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
4099         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
4100         return;
4101     }
4102     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
4103
4104     QUndoCommand *paste = new QUndoCommand();
4105     paste->setText("Paste effects");
4106
4107     QList<QGraphicsItem *> clips = scene()->selectedItems();
4108     for (int i = 0; i < clips.count(); ++i) {
4109         if (clips.at(i)->type() == AVWIDGET) {
4110             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
4111             for (int j = 0; j < clip->effectsCount(); j++) {
4112                 new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), clip->effectAt(j), true, paste);
4113             }
4114         }
4115     }
4116     m_commandStack->push(paste);
4117 }
4118
4119
4120 ClipItem *CustomTrackView::getClipUnderCursor() const
4121 {
4122     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
4123     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
4124     for (int i = 0; i < collisions.count(); i++) {
4125         if (collisions.at(i)->type() == AVWIDGET) {
4126             return static_cast < ClipItem *>(collisions.at(i));
4127         }
4128     }
4129     return NULL;
4130 }
4131
4132 ClipItem *CustomTrackView::getMainActiveClip() const
4133 {
4134     QList<QGraphicsItem *> clips = scene()->selectedItems();
4135     if (clips.isEmpty()) {
4136         return getClipUnderCursor();
4137     } else {
4138         ClipItem *item = NULL;
4139         for (int i = 0; i < clips.count(); ++i) {
4140             if (clips.at(i)->type() == AVWIDGET)
4141                 item = static_cast < ClipItem *>(clips.at(i));
4142             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
4143         }
4144         if (item) return item;
4145     }
4146     return NULL;
4147 }
4148
4149 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const
4150 {
4151     QList<QGraphicsItem *> clips = scene()->selectedItems();
4152     if (clips.isEmpty()) {
4153         return getClipUnderCursor();
4154     } else {
4155         ClipItem *item;
4156         // remove all items in the list that are not clips
4157         for (int i = 0; i < clips.count();) {
4158             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
4159             else i++;
4160         }
4161         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
4162         for (int i = 0; i < clips.count(); ++i) {
4163             if (clips.at(i)->type() == AVWIDGET) {
4164                 item = static_cast < ClipItem *>(clips.at(i));
4165                 if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos)
4166                     return item;
4167             }
4168         }
4169     }
4170     return NULL;
4171 }
4172
4173 void CustomTrackView::setInPoint()
4174 {
4175     AbstractClipItem *clip = getActiveClipUnderCursor(true);
4176     if (clip == NULL) {
4177         if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
4178             clip = m_dragItem;
4179         } else {
4180             emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4181             return;
4182         }
4183     }
4184     ItemInfo startInfo = clip->info();
4185     ItemInfo endInfo = startInfo;
4186     endInfo.startPos = GenTime(m_cursorPos, m_document->fps());
4187     if (endInfo.startPos >= startInfo.endPos) {
4188         // Check for invalid resize
4189         emit displayMessage(i18n("Invalid action"), ErrorMessage);
4190         return;
4191     } else if (endInfo.startPos < startInfo.startPos) {
4192         int length = m_document->renderer()->mltGetSpaceLength(endInfo.startPos, m_document->tracksCount() - startInfo.track, false);
4193         if ((clip->type() == TRANSITIONWIDGET && itemCollision(clip, endInfo) == true) || (
4194                     (clip->type() == AVWIDGET) && length < (startInfo.startPos - endInfo.startPos).frames(m_document->fps()))) {
4195             emit displayMessage(i18n("Invalid action"), ErrorMessage);
4196             return;
4197         }
4198     }
4199     if (clip->type() == TRANSITIONWIDGET) {
4200         m_commandStack->push(new MoveTransitionCommand(this, startInfo, endInfo, true));
4201     } else m_commandStack->push(new ResizeClipCommand(this, startInfo, endInfo, true));
4202 }
4203
4204 void CustomTrackView::setOutPoint()
4205 {
4206     AbstractClipItem *clip = getActiveClipUnderCursor(true);
4207     if (clip == NULL) {
4208         if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
4209             clip = m_dragItem;
4210         } else {
4211             emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4212             return;
4213         }
4214     }
4215     ItemInfo startInfo = clip->info();
4216     ItemInfo endInfo = clip->info();
4217     endInfo.endPos = GenTime(m_cursorPos, m_document->fps());
4218     if (endInfo.endPos <= startInfo.startPos) {
4219         // Check for invalid resize
4220         emit displayMessage(i18n("Invalid action"), ErrorMessage);
4221         return;
4222     } else if (endInfo.endPos > startInfo.endPos) {
4223         int length = m_document->renderer()->mltGetSpaceLength(endInfo.endPos, m_document->tracksCount() - startInfo.track, false);
4224         if ((clip->type() == TRANSITIONWIDGET && itemCollision(clip, endInfo) == true) || (clip->type() == AVWIDGET && length < (endInfo.endPos - startInfo.endPos).frames(m_document->fps()))) {
4225             emit displayMessage(i18n("Invalid action"), ErrorMessage);
4226             return;
4227         }
4228     }
4229
4230
4231     if (clip->type() == TRANSITIONWIDGET) {
4232         m_commandStack->push(new MoveTransitionCommand(this, startInfo, endInfo, true));
4233     } else m_commandStack->push(new ResizeClipCommand(this, startInfo, endInfo, true));
4234 }
4235
4236 void CustomTrackView::slotUpdateAllThumbs()
4237 {
4238     QList<QGraphicsItem *> itemList = items();
4239     //if (itemList.isEmpty()) return;
4240     ClipItem *item;
4241     const QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
4242     for (int i = 0; i < itemList.count(); i++) {
4243         if (itemList.at(i)->type() == AVWIDGET) {
4244             item = static_cast <ClipItem *>(itemList.at(i));
4245             if (item->clipType() != COLOR && item->clipType() != AUDIO) {
4246                 // Check if we have a cached thumbnail
4247                 if (item->clipType() == IMAGE || item->clipType() == TEXT) {
4248                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
4249                     if (QFile::exists(thumb)) {
4250                         QPixmap pix(thumb);
4251                         item->slotSetStartThumb(pix);
4252                     }
4253                 } else {
4254                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
4255                     QString endThumb = startThumb;
4256                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
4257                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
4258                     if (QFile::exists(startThumb)) {
4259                         QPixmap pix(startThumb);
4260                         item->slotSetStartThumb(pix);
4261                     }
4262                     if (QFile::exists(endThumb)) {
4263                         QPixmap pix(endThumb);
4264                         item->slotSetEndThumb(pix);
4265                     }
4266                 }
4267             }
4268             item->refreshClip(false);
4269             qApp->processEvents();
4270         }
4271     }
4272     viewport()->update();
4273 }
4274
4275 void CustomTrackView::saveThumbnails()
4276 {
4277     QList<QGraphicsItem *> itemList = items();
4278     ClipItem *item;
4279     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
4280     for (int i = 0; i < itemList.count(); i++) {
4281         if (itemList.at(i)->type() == AVWIDGET) {
4282             item = static_cast <ClipItem *>(itemList.at(i));
4283             if (item->clipType() != COLOR) {
4284                 // Check if we have a cached thumbnail
4285                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
4286                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
4287                     if (!QFile::exists(thumb)) {
4288                         QPixmap pix(item->startThumb());
4289                         pix.save(thumb);
4290                     }
4291                 } else {
4292                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
4293                     QString endThumb = startThumb;
4294                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
4295                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
4296                     if (!QFile::exists(startThumb)) {
4297                         QPixmap pix(item->startThumb());
4298                         pix.save(startThumb);
4299                     }
4300                     if (!QFile::exists(endThumb)) {
4301                         QPixmap pix(item->endThumb());
4302                         pix.save(endThumb);
4303                     }
4304                 }
4305             }
4306         }
4307     }
4308 }
4309
4310
4311 void CustomTrackView::slotInsertTrack(int ix)
4312 {
4313     kDebug() << "// INSERTING TRK: " << ix;
4314     QDialog d(parentWidget());
4315     Ui::AddTrack_UI view;
4316     view.setupUi(&d);
4317     view.track_nb->setMaximum(m_document->tracksCount() - 1);
4318     view.track_nb->setValue(ix);
4319     d.setWindowTitle(i18n("Insert Track"));
4320
4321     if (d.exec() == QDialog::Accepted) {
4322         ix = view.track_nb->value();
4323         if (view.before_select->currentIndex() == 1) {
4324             ix++;
4325         }
4326         TrackInfo info;
4327         if (view.video_track->isChecked()) {
4328             info.type = VIDEOTRACK;
4329             info.isMute = false;
4330             info.isBlind = false;
4331             info.isLocked = false;
4332         } else {
4333             info.type = AUDIOTRACK;
4334             info.isMute = false;
4335             info.isBlind = true;
4336             info.isLocked = false;
4337         }
4338         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true);
4339         m_commandStack->push(addTrack);
4340         setDocumentModified();
4341     }
4342 }
4343
4344 void CustomTrackView::slotDeleteTrack(int ix)
4345 {
4346     bool ok;
4347     ix = QInputDialog::getInteger(this, i18n("Remove Track"), i18n("Track"), ix, 0, m_document->tracksCount() - 1, 1, &ok);
4348     if (ok) {
4349         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
4350         deleteTimelineTrack(ix, info);
4351         setDocumentModified();
4352         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false);
4353         m_commandStack->push(command);*/
4354     }
4355 }
4356
4357 void CustomTrackView::slotChangeTrack(int ix)
4358 {
4359     QDialog d(parentWidget());
4360     Ui::AddTrack_UI view;
4361     view.setupUi(&d);
4362     view.label->setText(i18n("Change track"));
4363     view.before_select->setHidden(true);
4364     view.track_nb->setMaximum(m_document->tracksCount() - 1);
4365     view.track_nb->setValue(ix);
4366     d.setWindowTitle(i18n("Change Track Type"));
4367
4368     if (m_document->trackInfoAt(m_document->tracksCount() - ix - 1).type == VIDEOTRACK)
4369         view.video_track->setChecked(true);
4370     else
4371         view.audio_track->setChecked(true);
4372
4373     if (d.exec() == QDialog::Accepted) {
4374         TrackInfo info;
4375         info.isLocked = false;
4376         info.isMute = false;
4377         ix = view.track_nb->value();
4378
4379         if (view.video_track->isChecked()) {
4380             info.type = VIDEOTRACK;
4381             info.isBlind = false;
4382         } else {
4383             info.type = AUDIOTRACK;
4384             info.isBlind = true;
4385         }
4386         changeTimelineTrack(ix, info);
4387         setDocumentModified();
4388     }
4389 }
4390
4391
4392 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo)
4393 {
4394     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
4395     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
4396     QList<QGraphicsItem *> selection = m_scene->items(r);
4397     QUndoCommand *deleteTrack = new QUndoCommand();
4398     deleteTrack->setText("Delete track");
4399
4400     // Delete all clips in selected track
4401     for (int i = 0; i < selection.count(); i++) {
4402         if (selection.at(i)->type() == AVWIDGET) {
4403             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
4404             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, true, deleteTrack);
4405             m_scene->removeItem(item);
4406             delete item;
4407             item = NULL;
4408         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
4409             Transition *item =  static_cast <Transition *>(selection.at(i));
4410             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
4411             m_scene->removeItem(item);
4412             delete item;
4413             item = NULL;
4414         }
4415     }
4416
4417     selection = m_scene->items();
4418     new AddTrackCommand(this, ix, trackinfo, false, deleteTrack);
4419     m_commandStack->push(deleteTrack);
4420 }
4421
4422 void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo)
4423 {
4424     TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
4425     ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo);
4426     m_commandStack->push(changeTrack);
4427 }
4428
4429 void CustomTrackView::autoTransition()
4430 {
4431     QList<QGraphicsItem *> itemList = scene()->selectedItems();
4432     if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
4433         emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
4434         return;
4435     }
4436     Transition *tr = static_cast <Transition*>(itemList.at(0));
4437     tr->setAutomatic(!tr->isAutomatic());
4438     QDomElement transition = tr->toXML();
4439     m_document->renderer()->mltUpdateTransition(transition.attribute("tag"), transition.attribute("tag"), transition.attribute("transition_btrack").toInt(), m_document->tracksCount() - transition.attribute("transition_atrack").toInt(), tr->startPos(), tr->endPos(), transition);
4440 }
4441
4442
4443 QStringList CustomTrackView::getLadspaParams(QDomElement effect) const
4444 {
4445     QStringList result;
4446     QDomNodeList params = effect.elementsByTagName("parameter");
4447     for (int i = 0; i < params.count(); i++) {
4448         QDomElement e = params.item(i).toElement();
4449         if (!e.isNull() && e.attribute("type") == "constant") {
4450             if (e.hasAttribute("factor")) {
4451                 double factor = e.attribute("factor").toDouble();
4452                 double value = e.attribute("value").toDouble();
4453                 value = value / factor;
4454                 result.append(QString::number(value));
4455             } else result.append(e.attribute("value"));
4456         }
4457     }
4458     return result;
4459 }
4460
4461 void CustomTrackView::clipNameChanged(const QString id, const QString name)
4462 {
4463     QList<QGraphicsItem *> list = scene()->items();
4464     ClipItem *clip = NULL;
4465     for (int i = 0; i < list.size(); ++i) {
4466         if (list.at(i)->type() == AVWIDGET) {
4467             clip = static_cast <ClipItem *>(list.at(i));
4468             if (clip->clipProducer() == id) {
4469                 clip->setClipName(name);
4470             }
4471         }
4472     }
4473     viewport()->update();
4474 }
4475
4476 void CustomTrackView::getClipAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
4477 {
4478     minimum = GenTime();
4479     maximum = GenTime();
4480     QList<QGraphicsItem *> selection;
4481     selection = m_scene->items(0, item->track() * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
4482     selection.removeAll(item);
4483     for (int i = 0; i < selection.count(); i++) {
4484         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
4485         if (clip && clip->type() == AVWIDGET) {
4486             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
4487             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
4488         }
4489     }
4490 }
4491
4492 void CustomTrackView::getTransitionAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
4493 {
4494     minimum = GenTime();
4495     maximum = GenTime();
4496     QList<QGraphicsItem *> selection;
4497     selection = m_scene->items(0, (item->track() + 1) * m_tracksHeight, sceneRect().width(), 2);
4498     selection.removeAll(item);
4499     for (int i = 0; i < selection.count(); i++) {
4500         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
4501         if (clip && clip->type() == TRANSITIONWIDGET) {
4502             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
4503             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
4504         }
4505     }
4506 }
4507
4508
4509 void CustomTrackView::loadGroups(const QDomNodeList groups)
4510 {
4511     for (int i = 0; i < groups.count(); i++) {
4512         QDomNodeList children = groups.at(i).childNodes();
4513         scene()->clearSelection();
4514         for (int nodeindex = 0; nodeindex < children.count(); nodeindex++) {
4515             QDomNode n = children.item(nodeindex);
4516             QDomElement elem = n.toElement();
4517             int pos = elem.attribute("position").toInt();
4518             int track = elem.attribute("track").toInt();
4519             if (elem.tagName() == "clipitem") {
4520                 ClipItem *clip = getClipItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
4521                 if (clip) clip->setSelected(true);
4522             } else {
4523                 Transition *clip = getTransitionItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
4524                 if (clip) clip->setSelected(true);
4525             }
4526         }
4527         groupSelectedItems(false, true);
4528     }
4529 }
4530
4531 void CustomTrackView::splitAudio()
4532 {
4533     resetSelectionGroup();
4534     QList<QGraphicsItem *> selection = scene()->selectedItems();
4535     if (selection.isEmpty()) {
4536         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4537         return;
4538     }
4539     QUndoCommand *splitCommand = new QUndoCommand();
4540     splitCommand->setText(i18n("Split audio"));
4541     for (int i = 0; i < selection.count(); i++) {
4542         if (selection.at(i)->type() == AVWIDGET) {
4543             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4544             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4545                 if (clip->parentItem()) {
4546                     emit displayMessage(i18n("Cannot split audio of grouped clips"), ErrorMessage);
4547                 } else {
4548                     new SplitAudioCommand(this, clip->track(), clip->startPos(), splitCommand);
4549                 }
4550             }
4551         }
4552     }
4553     m_commandStack->push(splitCommand);
4554 }
4555
4556 void CustomTrackView::doSplitAudio(const GenTime &pos, int track, bool split)
4557 {
4558     ClipItem *clip = getClipItemAt(pos, track);
4559     if (clip == NULL) {
4560         kDebug() << "// Cannot find clip to split!!!";
4561         return;
4562     }
4563     if (split) {
4564         int start = pos.frames(m_document->fps());
4565         int freetrack = m_document->tracksCount() - track - 1;
4566         for (; freetrack > 0; freetrack--) {
4567             kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
4568             if (m_document->trackInfoAt(freetrack - 1).type == AUDIOTRACK) {
4569                 kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
4570                 if (m_document->renderer()->mltTrackDuration(freetrack) < start || m_document->renderer()->mltGetSpaceLength(pos, freetrack, false) >= clip->cropDuration().frames(m_document->fps())) {
4571                     kDebug() << "FOUND SPACE ON TRK: " << freetrack;
4572                     break;
4573                 }
4574             }
4575         }
4576         kDebug() << "GOT TRK: " << track;
4577         if (freetrack == 0) {
4578             emit displayMessage(i18n("No empty space to put clip audio"), ErrorMessage);
4579         } else {
4580             ItemInfo info;
4581             info.startPos = clip->startPos();
4582             info.endPos = clip->endPos();
4583             info.cropStart = clip->cropStart();
4584             info.track = m_document->tracksCount() - freetrack;
4585             addClip(clip->xml(), clip->clipProducer(), info, clip->effectList());
4586             scene()->clearSelection();
4587             clip->setSelected(true);
4588             ClipItem *audioClip = getClipItemAt(start, info.track);
4589             if (audioClip) {
4590                 clip->setVideoOnly(true);
4591                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->videoProducer());
4592                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - info.track, start, clip->baseClip()->audioProducer(info.track));
4593                 audioClip->setSelected(true);
4594                 audioClip->setAudioOnly(true);
4595                 groupSelectedItems(false, true);
4596             }
4597         }
4598     } else {
4599         // unsplit clip: remove audio part and change video part to normal clip
4600         if (clip->parentItem() == NULL || clip->parentItem()->type() != GROUPWIDGET) {
4601             kDebug() << "//CANNOT FIND CLP GRP";
4602             return;
4603         }
4604         AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
4605         QList<QGraphicsItem *> children = grp->childItems();
4606         if (children.count() != 2) {
4607             kDebug() << "//SOMETHING IS WRONG WITH CLP GRP";
4608             return;
4609         }
4610         for (int i = 0; i < children.count(); i++) {
4611             if (children.at(i) != clip) {
4612                 ClipItem *clp = static_cast <ClipItem *>(children.at(i));
4613                 ItemInfo info = clip->info();
4614                 deleteClip(clp->info());
4615                 clip->setVideoOnly(false);
4616                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - info.track, info.startPos.frames(m_document->fps()), clip->baseClip()->producer(info.track));
4617                 break;
4618             }
4619         }
4620         clip->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
4621         m_document->clipManager()->removeGroup(grp);
4622         scene()->destroyItemGroup(grp);
4623     }
4624 }
4625
4626 void CustomTrackView::setVideoOnly()
4627 {
4628     resetSelectionGroup();
4629     QList<QGraphicsItem *> selection = scene()->selectedItems();
4630     if (selection.isEmpty()) {
4631         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4632         return;
4633     }
4634     QUndoCommand *videoCommand = new QUndoCommand();
4635     videoCommand->setText(i18n("Video only"));
4636     for (int i = 0; i < selection.count(); i++) {
4637         if (selection.at(i)->type() == AVWIDGET) {
4638             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4639             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4640                 if (clip->parentItem()) {
4641                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4642                 } else {
4643                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), true, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4644                 }
4645             }
4646         }
4647     }
4648     m_commandStack->push(videoCommand);
4649 }
4650
4651 void CustomTrackView::setAudioOnly()
4652 {
4653     resetSelectionGroup();
4654     QList<QGraphicsItem *> selection = scene()->selectedItems();
4655     if (selection.isEmpty()) {
4656         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4657         return;
4658     }
4659     QUndoCommand *videoCommand = new QUndoCommand();
4660     videoCommand->setText(i18n("Audio only"));
4661     for (int i = 0; i < selection.count(); i++) {
4662         if (selection.at(i)->type() == AVWIDGET) {
4663             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4664             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4665                 if (clip->parentItem()) {
4666                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4667                 } else {
4668                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, true, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4669                 }
4670             }
4671         }
4672     }
4673     m_commandStack->push(videoCommand);
4674 }
4675
4676 void CustomTrackView::setAudioAndVideo()
4677 {
4678     resetSelectionGroup();
4679     QList<QGraphicsItem *> selection = scene()->selectedItems();
4680     if (selection.isEmpty()) {
4681         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4682         return;
4683     }
4684     QUndoCommand *videoCommand = new QUndoCommand();
4685     videoCommand->setText(i18n("Audio and Video"));
4686     for (int i = 0; i < selection.count(); i++) {
4687         if (selection.at(i)->type() == AVWIDGET) {
4688             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4689             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4690                 if (clip->parentItem()) {
4691                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4692                 } else {
4693                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4694                 }
4695             }
4696         }
4697     }
4698     m_commandStack->push(videoCommand);
4699 }
4700
4701 void CustomTrackView::doChangeClipType(const GenTime &pos, int track, bool videoOnly, bool audioOnly)
4702 {
4703     ClipItem *clip = getClipItemAt(pos, track);
4704     if (clip == NULL) {
4705         kDebug() << "// Cannot find clip to split!!!";
4706         return;
4707     }
4708     if (videoOnly) {
4709         int start = pos.frames(m_document->fps());
4710         clip->setVideoOnly(true);
4711         clip->setAudioOnly(false);
4712         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->videoProducer());
4713     } else if (audioOnly) {
4714         int start = pos.frames(m_document->fps());
4715         clip->setAudioOnly(true);
4716         clip->setVideoOnly(false);
4717         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->audioProducer(track));
4718     } else {
4719         int start = pos.frames(m_document->fps());
4720         clip->setAudioOnly(false);
4721         clip->setVideoOnly(false);
4722         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->producer(track));
4723     }
4724     clip->update();
4725     setDocumentModified();
4726 }
4727
4728 void CustomTrackView::updateClipTypeActions(ClipItem *clip)
4729 {
4730     if (clip == NULL || (clip->clipType() != AV && clip->clipType() != PLAYLIST)) {
4731         m_clipTypeGroup->setEnabled(false);
4732     } else {
4733         m_clipTypeGroup->setEnabled(true);
4734         QList <QAction *> actions = m_clipTypeGroup->actions();
4735         QString lookup;
4736         if (clip->isAudioOnly()) lookup = "clip_audio_only";
4737         else if (clip->isVideoOnly()) lookup = "clip_video_only";
4738         else  lookup = "clip_audio_and_video";
4739         for (int i = 0; i < actions.count(); i++) {
4740             if (actions.at(i)->data().toString() == lookup) {
4741                 actions.at(i)->setChecked(true);
4742                 break;
4743             }
4744         }
4745     }
4746 }
4747
4748 void CustomTrackView::reloadTransitionLumas()
4749 {
4750     QString lumaNames;
4751     QString lumaFiles;
4752     QDomElement lumaTransition = MainWindow::transitions.getEffectByTag("luma", "luma");
4753     QDomNodeList params = lumaTransition.elementsByTagName("parameter");
4754     for (int i = 0; i < params.count(); i++) {
4755         QDomElement e = params.item(i).toElement();
4756         if (e.attribute("tag") == "resource") {
4757             lumaNames = e.attribute("paramlistdisplay");
4758             lumaFiles = e.attribute("paramlist");
4759             break;
4760         }
4761     }
4762
4763     QList<QGraphicsItem *> itemList = items();
4764     Transition *transitionitem;
4765     QDomElement transitionXml;
4766     for (int i = 0; i < itemList.count(); i++) {
4767         if (itemList.at(i)->type() == TRANSITIONWIDGET) {
4768             transitionitem = static_cast <Transition*>(itemList.at(i));
4769             transitionXml = transitionitem->toXML();
4770             if (transitionXml.attribute("id") == "luma" && transitionXml.attribute("tag") == "luma") {
4771                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
4772                 for (int i = 0; i < params.count(); i++) {
4773                     QDomElement e = params.item(i).toElement();
4774                     if (e.attribute("tag") == "resource") {
4775                         e.setAttribute("paramlistdisplay", lumaNames);
4776                         e.setAttribute("paramlist", lumaFiles);
4777                         break;
4778                     }
4779                 }
4780             }
4781             if (transitionXml.attribute("id") == "composite" && transitionXml.attribute("tag") == "composite") {
4782                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
4783                 for (int i = 0; i < params.count(); i++) {
4784                     QDomElement e = params.item(i).toElement();
4785                     if (e.attribute("tag") == "luma") {
4786                         e.setAttribute("paramlistdisplay", lumaNames);
4787                         e.setAttribute("paramlist", lumaFiles);
4788                         break;
4789                     }
4790                 }
4791             }
4792         }
4793     }
4794     emit transitionItemSelected(NULL);
4795 }
4796
4797 #include "customtrackview.moc"