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             double factor = transitionClip->baseClip()->getProperty("aspect_ratio").toDouble();
1819             p.setX((int)(size.section('x', 0, 0).toInt() * factor + 0.5));
1820             p.setY(size.section('x', 1, 1).toInt());
1821         }
1822         emit transitionItemSelected(item, getPreviousVideoTrack(info.track), p, true);
1823     }
1824     setDocumentModified();
1825 }
1826
1827 void CustomTrackView::dragMoveEvent(QDragMoveEvent * event)
1828 {
1829     event->setDropAction(Qt::IgnoreAction);
1830     const QPointF pos = mapToScene(event->pos());
1831     if (m_selectionGroup && m_clipDrag) {
1832         m_selectionGroup->setPos(pos.x(), pos.y());
1833         emit mousePosition((int)(m_selectionGroup->scenePos().x() + 0.5));
1834         event->setDropAction(Qt::MoveAction);
1835         event->acceptProposedAction();
1836     } else {
1837         QGraphicsView::dragMoveEvent(event);
1838     }
1839 }
1840
1841 void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event)
1842 {
1843     if (m_selectionGroup && m_clipDrag) {
1844         m_thumbsTimer.stop();
1845         m_waitingThumbs.clear();
1846         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1847         qDeleteAll(items);
1848         scene()->destroyItemGroup(m_selectionGroup);
1849         m_selectionGroup = NULL;
1850     } else QGraphicsView::dragLeaveEvent(event);
1851 }
1852
1853 void CustomTrackView::dropEvent(QDropEvent * event)
1854 {
1855     if (m_selectionGroup && m_clipDrag) {
1856         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1857         resetSelectionGroup();
1858         m_scene->clearSelection();
1859         bool hasVideoClip = false;
1860         QUndoCommand *addCommand = new QUndoCommand();
1861         addCommand->setText(i18n("Add timeline clip"));
1862
1863         for (int i = 0; i < items.count(); i++) {
1864             ClipItem *item = static_cast <ClipItem *>(items.at(i));
1865             if (!hasVideoClip && (item->clipType() == AV || item->clipType() == VIDEO)) hasVideoClip = true;
1866             if (items.count() == 1) {
1867                 updateClipTypeActions(item);
1868             } else {
1869                 updateClipTypeActions(NULL);
1870             }
1871
1872             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false, addCommand);
1873             item->baseClip()->addReference();
1874             m_document->updateClip(item->baseClip()->getId());
1875             ItemInfo info = item->info();
1876
1877             int tracknumber = m_document->tracksCount() - info.track - 1;
1878             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
1879             if (isLocked) item->setItemLocked(true);
1880             ItemInfo clipInfo = info;
1881             clipInfo.track = m_document->tracksCount() - item->track();
1882             if (m_document->renderer()->mltInsertClip(clipInfo, item->xml(), item->baseClip()->producer(item->track())) == -1) {
1883                 emit displayMessage(i18n("Cannot insert clip in timeline"), ErrorMessage);
1884             }
1885
1886             if (item->baseClip()->isTransparent() && getTransitionItemAtStart(info.startPos, info.track) == NULL) {
1887                 // add transparency transition
1888                 QDomElement trans = MainWindow::transitions.getEffectByTag("composite", "composite").cloneNode().toElement();
1889                 new AddTransitionCommand(this, info, getPreviousVideoTrack(info.track), trans, false, true, addCommand);
1890             }
1891             item->setSelected(true);
1892         }
1893         m_commandStack->push(addCommand);
1894         setDocumentModified();
1895         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1896         if (items.count() > 1) groupSelectedItems(true);
1897         event->setDropAction(Qt::MoveAction);
1898         event->accept();
1899     } else QGraphicsView::dropEvent(event);
1900     setFocus();
1901 }
1902
1903
1904 QStringList CustomTrackView::mimeTypes() const
1905 {
1906     QStringList qstrList;
1907     // list of accepted mime types for drop
1908     qstrList.append("text/plain");
1909     qstrList.append("kdenlive/producerslist");
1910     qstrList.append("kdenlive/clip");
1911     return qstrList;
1912 }
1913
1914 Qt::DropActions CustomTrackView::supportedDropActions() const
1915 {
1916     // returns what actions are supported when dropping
1917     return Qt::MoveAction;
1918 }
1919
1920 void CustomTrackView::setDuration(int duration)
1921 {
1922     int diff = qAbs(duration - sceneRect().width());
1923     if (diff * matrix().m11() > -50) {
1924         if (matrix().m11() < 0.4) setSceneRect(0, 0, (duration + 100 / matrix().m11()), sceneRect().height());
1925         else setSceneRect(0, 0, (duration + 300), sceneRect().height());
1926     }
1927     m_projectDuration = duration;
1928 }
1929
1930 int CustomTrackView::duration() const
1931 {
1932     return m_projectDuration;
1933 }
1934
1935 void CustomTrackView::addTrack(TrackInfo type, int ix)
1936 {
1937     if (ix == -1 || ix == m_document->tracksCount()) {
1938         m_document->insertTrack(ix, type);
1939         m_document->renderer()->mltInsertTrack(1, type.type == VIDEOTRACK);
1940     } else {
1941         m_document->insertTrack(m_document->tracksCount() - ix, type);
1942         // insert track in MLT playlist
1943         m_document->renderer()->mltInsertTrack(m_document->tracksCount() - ix, type.type == VIDEOTRACK);
1944
1945         double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1946         QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1947         QList<QGraphicsItem *> selection = m_scene->items(r);
1948         resetSelectionGroup();
1949
1950         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1951         scene()->addItem(m_selectionGroup);
1952         for (int i = 0; i < selection.count(); i++) {
1953             if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
1954                 m_selectionGroup->addToGroup(selection.at(i));
1955                 selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1956             }
1957         }
1958         // Move graphic items
1959         m_selectionGroup->translate(0, m_tracksHeight);
1960
1961         // adjust track number
1962         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1963         for (int i = 0; i < children.count(); i++) {
1964             if (children.at(i)->type() == GROUPWIDGET) {
1965                 AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
1966                 children << grp->childItems();
1967                 continue;
1968             }
1969             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
1970             item->updateItem();
1971             ItemInfo clipinfo = item->info();
1972             if (item->type() == AVWIDGET) {
1973                 ClipItem *clip = static_cast <ClipItem *>(item);
1974                 // We add a move clip command so that we get the correct producer for new track number
1975                 if (clip->clipType() == AV || clip->clipType() == AUDIO) {
1976                     Mlt::Producer *prod;
1977                     if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(clipinfo.track);
1978                     else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
1979                     else prod = clip->baseClip()->producer(clipinfo.track);
1980                     m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod);
1981                 }
1982             } else if (item->type() == TRANSITIONWIDGET) {
1983                 Transition *tr = static_cast <Transition *>(item);
1984                 int track = tr->transitionEndTrack();
1985                 if (track >= ix) {
1986                     tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1987                 }
1988             }
1989         }
1990         resetSelectionGroup(false);
1991     }
1992
1993     int maxHeight = m_tracksHeight * m_document->tracksCount();
1994     for (int i = 0; i < m_guides.count(); i++) {
1995         QLineF l = m_guides.at(i)->line();
1996         l.setP2(QPointF(l.x2(), maxHeight));
1997         m_guides.at(i)->setLine(l);
1998     }
1999     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
2000     setSceneRect(0, 0, sceneRect().width(), maxHeight);
2001     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
2002     viewport()->update();
2003     //setFixedHeight(50 * m_tracksCount);
2004 }
2005
2006 void CustomTrackView::removeTrack(int ix)
2007 {
2008     // Delete track in MLT playlist
2009     m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
2010     m_document->deleteTrack(m_document->tracksCount() - ix - 1);
2011
2012     double startY = ix * (m_tracksHeight + 1) + m_tracksHeight / 2;
2013     QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
2014     QList<QGraphicsItem *> selection = m_scene->items(r);
2015
2016     resetSelectionGroup();
2017
2018     m_selectionGroup = new AbstractGroupItem(m_document->fps());
2019     scene()->addItem(m_selectionGroup);
2020     for (int i = 0; i < selection.count(); i++) {
2021         if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
2022             m_selectionGroup->addToGroup(selection.at(i));
2023             selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
2024         }
2025     }
2026     // Move graphic items
2027     qreal ydiff = 0 - (int) m_tracksHeight;
2028     m_selectionGroup->translate(0, ydiff);
2029
2030     // adjust track number
2031     QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2032     //kDebug() << "// FOUND CLIPS TO MOVE: " << children.count();
2033     for (int i = 0; i < children.count(); i++) {
2034         if (children.at(i)->type() == GROUPWIDGET) {
2035             AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
2036             children << grp->childItems();
2037             continue;
2038         }
2039         if (children.at(i)->type() == AVWIDGET) {
2040             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
2041             clip->updateItem();
2042             ItemInfo clipinfo = clip->info();
2043             // We add a move clip command so that we get the correct producer for new track number
2044             if (clip->clipType() == AV || clip->clipType() == AUDIO) {
2045                 Mlt::Producer *prod;
2046                 if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(clipinfo.track);
2047                 else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
2048                 else prod = clip->baseClip()->producer(clipinfo.track);
2049                 m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod);
2050             }
2051         } else if (children.at(i)->type() == TRANSITIONWIDGET) {
2052             Transition *tr = static_cast <Transition *>(children.at(i));
2053             tr->updateItem();
2054             int track = tr->transitionEndTrack();
2055             if (track >= ix) {
2056                 ItemInfo clipinfo = tr->info();
2057                 tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
2058             }
2059         }
2060     }
2061     resetSelectionGroup(false);
2062
2063     int maxHeight = m_tracksHeight * m_document->tracksCount();
2064     for (int i = 0; i < m_guides.count(); i++) {
2065         QLineF l = m_guides.at(i)->line();
2066         l.setP2(QPointF(l.x2(), maxHeight));
2067         m_guides.at(i)->setLine(l);
2068     }
2069     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
2070     setSceneRect(0, 0, sceneRect().width(), maxHeight);
2071     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
2072     viewport()->update();
2073 }
2074
2075 void CustomTrackView::changeTrack(int ix, TrackInfo type)
2076 {
2077     int tracknumber = m_document->tracksCount() - ix;
2078     m_document->setTrackType(tracknumber - 1, type);
2079     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
2080     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
2081     viewport()->update();
2082 }
2083
2084
2085 void CustomTrackView::slotSwitchTrackAudio(int ix)
2086 {
2087     /*for (int i = 0; i < m_document->tracksCount(); i++)
2088         kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
2089     int tracknumber = m_document->tracksCount() - ix - 1;
2090     m_document->switchTrackAudio(tracknumber, !m_document->trackInfoAt(tracknumber).isMute);
2091     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isMute << m_document->trackInfoAt(tracknumber).isBlind;
2092     m_document->renderer()->mltChangeTrackState(tracknumber + 1, m_document->trackInfoAt(tracknumber).isMute, m_document->trackInfoAt(tracknumber).isBlind);
2093     setDocumentModified();
2094 }
2095
2096 void CustomTrackView::slotSwitchTrackLock(int ix)
2097 {
2098     int tracknumber = m_document->tracksCount() - ix - 1;
2099     LockTrackCommand *command = new LockTrackCommand(this, ix, !m_document->trackInfoAt(tracknumber).isLocked);
2100     m_commandStack->push(command);
2101 }
2102
2103
2104 void CustomTrackView::lockTrack(int ix, bool lock)
2105 {
2106     int tracknumber = m_document->tracksCount() - ix - 1;
2107     m_document->switchTrackLock(tracknumber, lock);
2108     emit doTrackLock(ix, lock);
2109     QList<QGraphicsItem *> selection = m_scene->items(0, ix * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), m_tracksHeight / 2 - 2);
2110
2111     for (int i = 0; i < selection.count(); i++) {
2112         if (selection.at(i)->type() != AVWIDGET && selection.at(i)->type() != TRANSITIONWIDGET) continue;
2113         if (selection.at(i)->isSelected()) {
2114             if (selection.at(i)->type() == AVWIDGET) emit clipItemSelected(NULL);
2115             else emit transitionItemSelected(NULL);
2116         }
2117         static_cast <AbstractClipItem *>(selection.at(i))->setItemLocked(lock);
2118     }
2119     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isLocked;
2120     viewport()->update();
2121     setDocumentModified();
2122 }
2123
2124 void CustomTrackView::slotSwitchTrackVideo(int ix)
2125 {
2126     int tracknumber = m_document->tracksCount() - ix;
2127     m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
2128     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
2129     setDocumentModified();
2130 }
2131
2132 void CustomTrackView::slotRemoveSpace()
2133 {
2134     GenTime pos;
2135     int track = 0;
2136     if (m_menuPosition.isNull()) {
2137         pos = GenTime(cursorPos(), m_document->fps());
2138         bool ok;
2139         track = QInputDialog::getInteger(this, i18n("Remove Space"), i18n("Track"), 0, 0, m_document->tracksCount() - 1, 1, &ok);
2140         if (!ok) return;
2141     } else {
2142         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
2143         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight);
2144     }
2145     ClipItem *item = getClipItemAt(pos, track);
2146     if (item) {
2147         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);
2148         return;
2149     }
2150     int length = m_document->renderer()->mltGetSpaceLength(pos, m_document->tracksCount() - track, true);
2151     //kDebug() << "// GOT LENGT; " << length;
2152     if (length <= 0) {
2153         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);
2154         return;
2155     }
2156
2157     QRectF r(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight / 2 - 1);
2158     QList<QGraphicsItem *> items = m_scene->items(r);
2159
2160     QList<ItemInfo> clipsToMove;
2161     QList<ItemInfo> transitionsToMove;
2162
2163     for (int i = 0; i < items.count(); i++) {
2164         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
2165             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2166             ItemInfo info = item->info();
2167             if (item->type() == AVWIDGET) {
2168                 clipsToMove.append(info);
2169             } else if (item->type() == TRANSITIONWIDGET) {
2170                 transitionsToMove.append(info);
2171             }
2172         }
2173     }
2174
2175     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, GenTime(-length, m_document->fps()), true);
2176     m_commandStack->push(command);
2177 }
2178
2179 void CustomTrackView::slotInsertSpace()
2180 {
2181     GenTime pos;
2182     int track = 0;
2183     if (m_menuPosition.isNull()) {
2184         pos = GenTime(cursorPos(), m_document->fps());
2185     } else {
2186         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
2187         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight) + 1;
2188     }
2189     SpacerDialog d(GenTime(65, m_document->fps()), m_document->timecode(), track, m_document->tracksCount(), this);
2190     if (d.exec() != QDialog::Accepted) return;
2191     GenTime spaceDuration = d.selectedDuration();
2192     track = d.selectedTrack();
2193     ClipItem *item = getClipItemAt(pos, track);
2194     if (item) pos = item->startPos();
2195
2196     int minh = 0;
2197     int maxh = sceneRect().height();
2198     if (track != -1) {
2199         minh = track * m_tracksHeight + m_tracksHeight / 2;
2200         maxh = m_tracksHeight / 2 - 1;
2201     }
2202
2203     QRectF r(pos.frames(m_document->fps()), minh, sceneRect().width() - pos.frames(m_document->fps()), maxh);
2204     QList<QGraphicsItem *> items = m_scene->items(r);
2205
2206     QList<ItemInfo> clipsToMove;
2207     QList<ItemInfo> transitionsToMove;
2208
2209     for (int i = 0; i < items.count(); i++) {
2210         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
2211             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2212             ItemInfo info = item->info();
2213             if (item->type() == AVWIDGET) {
2214                 clipsToMove.append(info);
2215             } else if (item->type() == TRANSITIONWIDGET) {
2216                 transitionsToMove.append(info);
2217             }
2218         }
2219     }
2220
2221     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, spaceDuration, true);
2222     m_commandStack->push(command);
2223 }
2224
2225 void CustomTrackView::insertSpace(QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime duration, const GenTime offset)
2226 {
2227     int diff = duration.frames(m_document->fps());
2228     resetSelectionGroup();
2229     m_selectionGroup = new AbstractGroupItem(m_document->fps());
2230     scene()->addItem(m_selectionGroup);
2231     ClipItem *clip;
2232     Transition *transition;
2233
2234     // Create lists with start pos for each track
2235     QMap <int, int> trackClipStartList;
2236     QMap <int, int> trackTransitionStartList;
2237
2238     for (int i = 1; i < m_document->tracksCount() + 1; i++) {
2239         trackClipStartList[i] = -1;
2240         trackTransitionStartList[i] = -1;
2241     }
2242
2243     if (!clipsToMove.isEmpty()) for (int i = 0; i < clipsToMove.count(); i++) {
2244             clip = getClipItemAtStart(clipsToMove.at(i).startPos + offset, clipsToMove.at(i).track);
2245             if (clip) {
2246                 if (clip->parentItem()) {
2247                     m_selectionGroup->addToGroup(clip->parentItem());
2248                     clip->parentItem()->setFlags(QGraphicsItem::ItemIsSelectable);
2249                 } else {
2250                     m_selectionGroup->addToGroup(clip);
2251                     clip->setFlags(QGraphicsItem::ItemIsSelectable);
2252                 }
2253                 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))
2254                     trackClipStartList[m_document->tracksCount() - clipsToMove.at(i).track] = clipsToMove.at(i).startPos.frames(m_document->fps());
2255             } 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);
2256         }
2257     if (!transToMove.isEmpty()) for (int i = 0; i < transToMove.count(); i++) {
2258             transition = getTransitionItemAtStart(transToMove.at(i).startPos + offset, transToMove.at(i).track);
2259             if (transition) {
2260                 if (transition->parentItem()) m_selectionGroup->addToGroup(transition->parentItem());
2261                 m_selectionGroup->addToGroup(transition);
2262                 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))
2263                     trackTransitionStartList[m_document->tracksCount() - transToMove.at(i).track] = transToMove.at(i).startPos.frames(m_document->fps());
2264                 transition->setFlags(QGraphicsItem::ItemIsSelectable);
2265             } 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);
2266         }
2267     m_selectionGroup->translate(diff, 0);
2268
2269     // update items coordinates
2270     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2271     for (int i = 0; i < itemList.count(); i++) {
2272         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
2273             static_cast < AbstractClipItem *>(itemList.at(i))->updateItem();
2274         } else if (itemList.at(i)->type() == GROUPWIDGET) {
2275             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
2276             for (int j = 0; j < children.count(); j++) {
2277                 static_cast < AbstractClipItem *>(children.at(j))->updateItem();
2278             }
2279         }
2280     }
2281     resetSelectionGroup(false);
2282     if (track != -1) track = m_document->tracksCount() - track;
2283     m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, duration, offset);
2284 }
2285
2286 void CustomTrackView::deleteClip(const QString &clipId)
2287 {
2288     resetSelectionGroup();
2289     QList<QGraphicsItem *> itemList = items();
2290     QUndoCommand *deleteCommand = new QUndoCommand();
2291     deleteCommand->setText(i18n("Delete timeline clips"));
2292     int count = 0;
2293     for (int i = 0; i < itemList.count(); i++) {
2294         if (itemList.at(i)->type() == AVWIDGET) {
2295             ClipItem *item = (ClipItem *)itemList.at(i);
2296             if (item->clipProducer() == clipId) {
2297                 count++;
2298                 if (item->parentItem()) {
2299                     // Clip is in a group, destroy the group
2300                     new GroupClipsCommand(this, QList<ItemInfo>() << item->info(), QList<ItemInfo>(), false, deleteCommand);
2301                 }
2302                 new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteCommand);
2303             }
2304         }
2305     }
2306     if (count == 0) delete deleteCommand;
2307     else m_commandStack->push(deleteCommand);
2308 }
2309
2310 void CustomTrackView::setCursorPos(int pos, bool seek)
2311 {
2312     if (pos == m_cursorPos) return;
2313     emit cursorMoved((int)(m_cursorPos), (int)(pos));
2314     m_cursorPos = pos;
2315     if (seek) m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
2316     else if (m_autoScroll) checkScrolling();
2317     m_cursorLine->setPos(m_cursorPos, 0);
2318 }
2319
2320 void CustomTrackView::updateCursorPos()
2321 {
2322     m_cursorLine->setPos(m_cursorPos, 0);
2323 }
2324
2325 int CustomTrackView::cursorPos()
2326 {
2327     return (int)(m_cursorPos);
2328 }
2329
2330 void CustomTrackView::moveCursorPos(int delta)
2331 {
2332     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
2333     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
2334     m_cursorPos += delta;
2335     m_cursorLine->setPos(m_cursorPos, 0);
2336     m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
2337 }
2338
2339 void CustomTrackView::initCursorPos(int pos)
2340 {
2341     emit cursorMoved((int)(m_cursorPos), (int)(pos));
2342     m_cursorPos = pos;
2343     m_cursorLine->setPos(pos, 0);
2344     checkScrolling();
2345 }
2346
2347 void CustomTrackView::checkScrolling()
2348 {
2349     ensureVisible(m_cursorPos, verticalScrollBar()->value() + 10, 2, 2, 50, 0);
2350 }
2351
2352 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event)
2353 {
2354     if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
2355     QGraphicsView::mouseReleaseEvent(event);
2356     if (m_scrollTimer.isActive()) m_scrollTimer.stop();
2357     if (event->button() == Qt::MidButton) {
2358         return;
2359     }
2360     setDragMode(QGraphicsView::NoDrag);
2361     if (m_operationMode == MOVEGUIDE) {
2362         setCursor(Qt::ArrowCursor);
2363         m_operationMode = NONE;
2364         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
2365         GenTime newPos = GenTime(m_dragGuide->pos().x(), m_document->fps());
2366         if (newPos != m_dragGuide->position()) {
2367             EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), newPos, m_dragGuide->label(), false);
2368             m_commandStack->push(command);
2369             m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
2370             qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
2371             m_document->syncGuides(m_guides);
2372         }
2373         m_dragGuide = NULL;
2374         m_dragItem = NULL;
2375         return;
2376     } else if (m_operationMode == SPACER && m_selectionGroup) {
2377         int track;
2378         if (event->modifiers() != Qt::ControlModifier) {
2379             // We are moving all tracks
2380             track = -1;
2381         } else track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
2382         GenTime timeOffset = GenTime(m_selectionGroup->scenePos().x(), m_document->fps()) - m_selectionGroupInfo.startPos;
2383         if (timeOffset != GenTime()) {
2384             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
2385
2386             QList<ItemInfo> clipsToMove;
2387             QList<ItemInfo> transitionsToMove;
2388
2389             // Create lists with start pos for each track
2390             QMap <int, int> trackClipStartList;
2391             QMap <int, int> trackTransitionStartList;
2392
2393             for (int i = 1; i < m_document->tracksCount() + 1; i++) {
2394                 trackClipStartList[i] = -1;
2395                 trackTransitionStartList[i] = -1;
2396             }
2397
2398             int max = items.count();
2399             for (int i = 0; i < max; i++) {
2400                 if (items.at(i)->type() == GROUPWIDGET)
2401                     items += static_cast <QGraphicsItemGroup *>(items.at(i))->childItems();
2402             }
2403
2404             for (int i = 0; i < items.count(); i++) {
2405                 if (items.at(i)->type() == AVWIDGET) {
2406                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2407                     ItemInfo info = item->info();
2408                     clipsToMove.append(info);
2409                     item->updateItem();
2410                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackClipStartList.value(m_document->tracksCount() - info.track))
2411                         trackClipStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2412                 } else if (items.at(i)->type() == TRANSITIONWIDGET) {
2413                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2414                     ItemInfo info = item->info();
2415                     transitionsToMove.append(info);
2416                     item->updateItem();
2417                     if (trackTransitionStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackTransitionStartList.value(m_document->tracksCount() - info.track))
2418                         trackTransitionStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
2419                 }
2420             }
2421
2422             InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, timeOffset, false);
2423             m_commandStack->push(command);
2424             if (track != -1) track = m_document->tracksCount() - track;
2425             kDebug() << "SPACER TRACK:" << track;
2426             m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, timeOffset, GenTime());
2427         }
2428         resetSelectionGroup(false);
2429         m_operationMode = NONE;
2430     } else if (m_operationMode == RUBBERSELECTION) {
2431         //kDebug() << "// END RUBBER SELECT";
2432         resetSelectionGroup();
2433         groupSelectedItems();
2434         m_operationMode = NONE;
2435     }
2436
2437     if (m_dragItem == NULL && m_selectionGroup == NULL) {
2438         emit transitionItemSelected(NULL);
2439         return;
2440     }
2441     ItemInfo info;
2442     if (m_dragItem) info = m_dragItem->info();
2443
2444     if (m_operationMode == MOVE) {
2445         setCursor(Qt::OpenHandCursor);
2446
2447         if (m_dragItem->parentItem() == 0) {
2448             // we are moving one clip, easy
2449             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2450                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
2451                 Mlt::Producer *prod;
2452                 if (item->isAudioOnly()) prod = item->baseClip()->audioProducer(m_dragItemInfo.track);
2453                 else if (item->isVideoOnly()) prod = item->baseClip()->videoProducer();
2454                 else prod = item->baseClip()->producer(m_dragItemInfo.track);
2455                 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);
2456
2457                 if (success) {
2458                     int tracknumber = m_document->tracksCount() - item->track() - 1;
2459                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2460                     if (isLocked) item->setItemLocked(true);
2461
2462                     QUndoCommand *moveCommand = new QUndoCommand();
2463                     moveCommand->setText(i18n("Move clip"));
2464                     new MoveClipCommand(this, m_dragItemInfo, info, false, moveCommand);
2465                     // Also move automatic transitions (on lower track)
2466                     Transition *tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2467                     if (tr && tr->isAutomatic()) {
2468                         ItemInfo trInfo = tr->info();
2469                         ItemInfo newTrInfo = trInfo;
2470                         newTrInfo.track = info.track;
2471                         newTrInfo.startPos = m_dragItem->startPos();
2472                         if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtEnd(newTrInfo.endPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2473                             // transition end should stay the same
2474                         } else {
2475                             // transition end should be adjusted to clip
2476                             newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2477                         }
2478                         if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2479                     }
2480                     if (tr == NULL || tr->endPos() < m_dragItemInfo.endPos) {
2481                         // Check if there is a transition at clip end
2482                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2483                         if (tr && tr->isAutomatic()) {
2484                             ItemInfo trInfo = tr->info();
2485                             ItemInfo newTrInfo = trInfo;
2486                             newTrInfo.track = info.track;
2487                             newTrInfo.endPos = m_dragItem->endPos();
2488                             if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtStart(trInfo.startPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2489                                 // transition start should stay the same
2490                             } else {
2491                                 // transition start should be moved
2492                                 newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2493                             }
2494                             if (newTrInfo.startPos < newTrInfo.endPos)
2495                                 new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2496                         }
2497                     }
2498                     // Also move automatic transitions (on upper track)
2499                     tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2500                     if (m_dragItemInfo.track == info.track && tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2501                         ItemInfo trInfo = tr->info();
2502                         ItemInfo newTrInfo = trInfo;
2503                         newTrInfo.startPos = m_dragItem->startPos();
2504                         ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2505                         if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2506                             if (!getClipItemAtEnd(newTrInfo.endPos, tr->track())) {
2507                                 // transition end should be adjusted to clip on upper track
2508                                 newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2509                             }
2510                             if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2511                         }
2512                     }
2513                     if (m_dragItemInfo.track == info.track && (tr == NULL || tr->endPos() < m_dragItemInfo.endPos)) {
2514                         // Check if there is a transition at clip end
2515                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2516                         if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2517                             ItemInfo trInfo = tr->info();
2518                             ItemInfo newTrInfo = trInfo;
2519                             newTrInfo.endPos = m_dragItem->endPos();
2520                             ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2521                             if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2522                                 if (!getClipItemAtStart(trInfo.startPos, tr->track())) {
2523                                     // transition start should be moved
2524                                     newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2525                                 }
2526                                 if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2527                             }
2528                         }
2529                     }
2530                     m_commandStack->push(moveCommand);
2531                 } else {
2532                     // undo last move and emit error message
2533                     bool snap = KdenliveSettings::snaptopoints();
2534                     KdenliveSettings::setSnaptopoints(false);
2535                     item->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (int)(m_dragItemInfo.track * m_tracksHeight + 1));
2536                     KdenliveSettings::setSnaptopoints(snap);
2537                     emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(m_dragItemInfo.startPos.frames(m_document->fps()))), ErrorMessage);
2538                 }
2539                 setDocumentModified();
2540             }
2541             if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2542                 Transition *transition = static_cast <Transition *>(m_dragItem);
2543                 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)) {
2544                     // Moving transition failed, revert to previous position
2545                     emit displayMessage(i18n("Cannot move transition"), ErrorMessage);
2546                     transition->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (m_dragItemInfo.track) * m_tracksHeight + 1);
2547                 } else {
2548                     MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2549                     m_commandStack->push(command);
2550                     transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
2551                 }
2552             }
2553         } else {
2554             // Moving several clips. We need to delete them and readd them to new position,
2555             // or they might overlap each other during the move
2556             QGraphicsItemGroup *group = static_cast <QGraphicsItemGroup *>(m_dragItem->parentItem());
2557             QList<QGraphicsItem *> items = group->childItems();
2558
2559             QList<ItemInfo> clipsToMove;
2560             QList<ItemInfo> transitionsToMove;
2561
2562             GenTime timeOffset = GenTime(m_dragItem->scenePos().x(), m_document->fps()) - m_dragItemInfo.startPos;
2563             const int trackOffset = (int)(m_dragItem->scenePos().y() / m_tracksHeight) - m_dragItemInfo.track;
2564             //kDebug() << "// MOVED SEVERAL CLIPS" << timeOffset.frames(25);
2565             if (timeOffset != GenTime() || trackOffset != 0) {
2566                 // remove items in MLT playlist
2567
2568                 // Expand groups
2569                 int max = items.count();
2570                 for (int i = 0; i < max; i++) {
2571                     if (items.at(i)->type() == GROUPWIDGET) {
2572                         items += items.at(i)->childItems();
2573                     }
2574                 }
2575
2576                 for (int i = 0; i < items.count(); i++) {
2577                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2578                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2579                     ItemInfo info = item->info();
2580                     if (item->type() == AVWIDGET) {
2581                         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2582                             // error, clip cannot be removed from playlist
2583                             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2584                         } else {
2585                             clipsToMove.append(info);
2586                         }
2587                     } else {
2588                         transitionsToMove.append(info);
2589                         Transition *tr = static_cast <Transition*>(item);
2590                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2591                     }
2592                 }
2593
2594                 for (int i = 0; i < items.count(); i++) {
2595                     // re-add items in correct place
2596                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
2597                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2598                     item->updateItem();
2599                     ItemInfo info = item->info();
2600                     int tracknumber = m_document->tracksCount() - info.track - 1;
2601                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2602                     if (isLocked) {
2603                         group->removeFromGroup(item);
2604                         item->setItemLocked(true);
2605                     }
2606
2607                     if (item->type() == AVWIDGET) {
2608                         ClipItem *clip = static_cast <ClipItem*>(item);
2609                         info.track = m_document->tracksCount() - info.track;
2610                         Mlt::Producer *prod;
2611                         if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(info.track);
2612                         else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
2613                         else prod = clip->baseClip()->producer(info.track);
2614                         m_document->renderer()->mltInsertClip(info, clip->xml(), prod);
2615                         for (int i = 0; i < clip->effectsCount(); i++) {
2616                             m_document->renderer()->mltAddEffect(info.track, info.startPos, clip->getEffectArgs(clip->effectAt(i)), false);
2617                         }
2618                     } else {
2619                         Transition *tr = static_cast <Transition*>(item);
2620                         int newTrack = tr->transitionEndTrack();
2621                         if (!tr->forcedTrack()) {
2622                             newTrack = getPreviousVideoTrack(info.track);
2623                         }
2624                         tr->updateTransitionEndTrack(newTrack);
2625                         m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2626                     }
2627                 }
2628
2629                 MoveGroupCommand *move = new MoveGroupCommand(this, clipsToMove, transitionsToMove, timeOffset, trackOffset, false);
2630                 m_commandStack->push(move);
2631
2632                 //QPointF top = group->sceneBoundingRect().topLeft();
2633                 //QPointF oldpos = m_selectionGroup->scenePos();
2634                 //kDebug()<<"SELECTION GRP POS: "<<m_selectionGroup->scenePos()<<", TOP: "<<top;
2635                 //group->setPos(top);
2636                 //TODO: get rid of the 3 lines below
2637                 if (m_selectionGroup) {
2638                     m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2639                     m_selectionGroupInfo.track = m_selectionGroup->track();
2640                 }
2641                 setDocumentModified();
2642             }
2643         }
2644         m_document->renderer()->doRefresh();
2645     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
2646         // resize start
2647         if (m_dragItem->type() == AVWIDGET) {
2648             ItemInfo resizeinfo = m_dragItemInfo;
2649             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2650             bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, m_dragItem->startPos() - m_dragItemInfo.startPos);
2651             if (success) {
2652                 QUndoCommand *resizeCommand = new QUndoCommand();
2653                 resizeCommand->setText(i18n("Resize clip"));
2654
2655                 // Check if there is an automatic transition on that clip (lower track)
2656                 Transition *transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2657                 if (transition && transition->isAutomatic()) {
2658                     ItemInfo trInfo = transition->info();
2659                     ItemInfo newTrInfo = trInfo;
2660                     newTrInfo.startPos = m_dragItem->startPos();
2661                     if (newTrInfo.startPos < newTrInfo.endPos)
2662                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2663                 }
2664                 // Check if there is an automatic transition on that clip (upper track)
2665                 transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2666                 if (transition && transition->isAutomatic() && (m_document->tracksCount() - transition->transitionEndTrack()) == m_dragItemInfo.track) {
2667                     ItemInfo trInfo = transition->info();
2668                     ItemInfo newTrInfo = trInfo;
2669                     newTrInfo.startPos = m_dragItem->startPos();
2670                     ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2671                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.startPos < newTrInfo.endPos) {
2672                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2673                     }
2674                 }
2675                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
2676                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2677                 m_commandStack->push(resizeCommand);
2678             } else {
2679                 m_dragItem->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2680                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2681             }
2682         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2683             Transition *transition = static_cast <Transition *>(m_dragItem);
2684             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)) {
2685                 // Cannot resize transition
2686                 transition->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2687                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2688             } else {
2689                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2690                 m_commandStack->push(command);
2691             }
2692
2693         }
2694         if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
2695             // Item was resized, rebuild group;
2696             AbstractGroupItem *group = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
2697             QList <QGraphicsItem *> children = group->childItems();
2698             m_document->clipManager()->removeGroup(group);
2699             scene()->destroyItemGroup(group);
2700             for (int i = 0; i < children.count(); i++) {
2701                 children.at(i)->setSelected(true);
2702             }
2703             groupSelectedItems(false, true);
2704         }
2705         //m_document->renderer()->doRefresh();
2706     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
2707         // resize end
2708         if (m_dragItem->type() == AVWIDGET) {
2709             ItemInfo resizeinfo = info;
2710             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2711             bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.endPos - resizeinfo.startPos);
2712             if (success) {
2713                 QUndoCommand *resizeCommand = new QUndoCommand();
2714                 resizeCommand->setText(i18n("Resize clip"));
2715
2716                 // Check if there is an automatic transition on that clip (lower track)
2717                 Transition *tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2718                 if (tr && tr->isAutomatic()) {
2719                     ItemInfo trInfo = tr->info();
2720                     ItemInfo newTrInfo = trInfo;
2721                     newTrInfo.endPos = m_dragItem->endPos();
2722                     if (newTrInfo.endPos > newTrInfo.startPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2723                 }
2724
2725                 // Check if there is an automatic transition on that clip (upper track)
2726                 tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2727                 if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2728                     ItemInfo trInfo = tr->info();
2729                     ItemInfo newTrInfo = trInfo;
2730                     newTrInfo.endPos = m_dragItem->endPos();
2731                     ClipItem * upperClip = getClipItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2732                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.endPos > newTrInfo.startPos) {
2733                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2734                     }
2735                 }
2736
2737                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2738                 m_commandStack->push(resizeCommand);
2739                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
2740             } else {
2741                 m_dragItem->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2742                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2743             }
2744         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2745             Transition *transition = static_cast <Transition *>(m_dragItem);
2746             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)) {
2747                 // Cannot resize transition
2748                 transition->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2749                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2750             } else {
2751                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2752                 m_commandStack->push(command);
2753             }
2754         }
2755         if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
2756             // Item was resized, rebuild group;
2757             AbstractGroupItem *group = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
2758             QList <QGraphicsItem *> children = group->childItems();
2759             m_document->clipManager()->removeGroup(group);
2760             scene()->destroyItemGroup(group);
2761             for (int i = 0; i < children.count(); i++) {
2762                 children.at(i)->setSelected(true);
2763             }
2764             groupSelectedItems(false, true);
2765         }
2766         //m_document->renderer()->doRefresh();
2767     } else if (m_operationMode == FADEIN) {
2768         // resize fade in effect
2769         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
2770         int ix = item->hasEffect("volume", "fadein");
2771         if (ix != -1) {
2772             QDomElement oldeffect = item->effectAt(ix).cloneNode().toElement();
2773             int start = item->cropStart().frames(m_document->fps());
2774             int end = item->fadeIn();
2775             if (end == 0) {
2776                 slotDeleteEffect(item, oldeffect);
2777             } else {
2778                 end += start;
2779                 QDomElement effect = oldeffect.cloneNode().toElement();
2780                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2781                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2782                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2783                 emit clipItemSelected(item, ix);
2784             }
2785         } else if (item->fadeIn() != 0 && item->hasEffect("", "fade_from_black") == -1) {
2786             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadein").cloneNode().toElement();
2787             EffectsList::setParameter(effect, "out", QString::number(item->fadeIn()));
2788             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2789         }
2790         ix = item->hasEffect("volume", "fade_from_black");
2791         if (ix != -1) {
2792             QDomElement oldeffect = item->effectAt(ix).cloneNode().toElement();
2793             int start = item->cropStart().frames(m_document->fps());
2794             int end = item->fadeIn();
2795             if (end == 0) {
2796                 slotDeleteEffect(item, oldeffect);
2797             } else {
2798                 end += start;
2799                 QDomElement effect = oldeffect.cloneNode().toElement();
2800                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2801                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2802                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2803                 emit clipItemSelected(item, ix);
2804             }
2805         }
2806     } else if (m_operationMode == FADEOUT) {
2807         // resize fade in effect
2808         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
2809         int ix = item->hasEffect("volume", "fadeout");
2810         if (ix != -1) {
2811             QDomElement oldeffect = item->effectAt(ix).cloneNode().toElement();
2812             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
2813             int start = item->fadeOut();
2814             if (start == 0) {
2815                 slotDeleteEffect(item, oldeffect);
2816             } else {
2817                 start = end - start;
2818                 QDomElement effect = oldeffect.cloneNode().toElement();
2819                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2820                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2821                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2822                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2823                 emit clipItemSelected(item, ix);
2824             }
2825         } else if (item->fadeOut() != 0 && item->hasEffect("", "fade_to_black") == -1) {
2826             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadeout").cloneNode().toElement();
2827             EffectsList::setParameter(effect, "in", QString::number(item->fadeOut()));
2828             EffectsList::setParameter(effect, "out", QString::number(0));
2829             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2830         }
2831         ix = item->hasEffect("brightness", "fade_to_black");
2832         if (ix != -1) {
2833             QDomElement oldeffect = item->effectAt(ix).cloneNode().toElement();
2834             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
2835             int start = item->fadeOut();
2836             if (start == 0) {
2837                 slotDeleteEffect(item, oldeffect);
2838             } else {
2839                 start = end - start;
2840                 QDomElement effect = oldeffect.cloneNode().toElement();
2841                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2842                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2843                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2844                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2845                 emit clipItemSelected(item, ix);
2846             }
2847         }
2848     } else if (m_operationMode == KEYFRAME) {
2849         // update the MLT effect
2850         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
2851         QString previous = item->keyframes(item->selectedEffectIndex());
2852         item->updateKeyframeEffect();
2853         QString next = item->keyframes(item->selectedEffectIndex());
2854         EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
2855         m_commandStack->push(command);
2856         updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
2857         emit clipItemSelected(item, item->selectedEffectIndex());
2858     }
2859     if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET && m_dragItem->isSelected()) {
2860         // A transition is selected
2861         QPoint p;
2862         ClipItem *transitionClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track);
2863         if (transitionClip && transitionClip->baseClip()) {
2864             QString size = transitionClip->baseClip()->getProperty("frame_size");
2865             double factor = transitionClip->baseClip()->getProperty("aspect_ratio").toDouble();
2866             p.setX((int)(size.section('x', 0, 0).toInt() * factor + 0.5));
2867             p.setY(size.section('x', 1, 1).toInt());
2868         }
2869         emit transitionItemSelected(static_cast <Transition *>(m_dragItem), getPreviousVideoTrack(m_dragItem->track()), p);
2870     } else emit transitionItemSelected(NULL);
2871     if (m_operationMode != NONE && m_operationMode != MOVE) setDocumentModified();
2872     m_operationMode = NONE;
2873 }
2874
2875 void CustomTrackView::deleteClip(ItemInfo info)
2876 {
2877     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
2878
2879     if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2880         emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2881         return;
2882     }
2883     if (item->isSelected()) emit clipItemSelected(NULL);
2884     item->baseClip()->removeReference();
2885     m_document->updateClip(item->baseClip()->getId());
2886
2887     /*if (item->baseClip()->isTransparent()) {
2888         // also remove automatic transition
2889         Transition *tr = getTransitionItemAt(info.startPos, info.track);
2890         if (tr && tr->isAutomatic()) {
2891             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2892             scene()->removeItem(tr);
2893             delete tr;
2894         }
2895     }*/
2896     scene()->removeItem(item);
2897     m_waitingThumbs.removeAll(item);
2898     if (m_dragItem == item) m_dragItem = NULL;
2899     delete item;
2900     item = NULL;
2901     setDocumentModified();
2902     m_document->renderer()->doRefresh();
2903 }
2904
2905 void CustomTrackView::deleteSelectedClips()
2906 {
2907     resetSelectionGroup();
2908     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2909     if (itemList.count() == 0) {
2910         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
2911         return;
2912     }
2913     scene()->clearSelection();
2914     QUndoCommand *deleteSelected = new QUndoCommand();
2915     deleteSelected->setText(i18n("Delete selected items"));
2916     bool resetGroup = false;
2917
2918     // expand & destroy groups
2919     for (int i = 0; i < itemList.count(); i++) {
2920         if (itemList.at(i)->type() == GROUPWIDGET) {
2921             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
2922             itemList += children;
2923             QList <ItemInfo> clipInfos;
2924             QList <ItemInfo> transitionInfos;
2925             GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2926             for (int j = 0; j < children.count(); j++) {
2927                 if (children.at(j)->type() == AVWIDGET) {
2928                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
2929                     if (!clip->isItemLocked()) clipInfos.append(clip->info());
2930                 } else if (children.at(j)->type() == TRANSITIONWIDGET) {
2931                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
2932                     if (!clip->isItemLocked()) transitionInfos.append(clip->info());
2933                 }
2934             }
2935             if (clipInfos.count() > 0) {
2936                 new GroupClipsCommand(this, clipInfos, transitionInfos, false, deleteSelected);
2937             }
2938         }
2939     }
2940
2941     for (int i = 0; i < itemList.count(); i++) {
2942         if (itemList.at(i)->type() == AVWIDGET) {
2943             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2944             if (item->parentItem()) resetGroup = true;
2945             //kDebug()<<"// DELETE CLP AT: "<<item->info().startPos.frames(25);
2946             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteSelected);
2947             emit clipItemSelected(NULL);
2948         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2949             Transition *item = static_cast <Transition *>(itemList.at(i));
2950             //kDebug()<<"// DELETE TRANS AT: "<<item->info().startPos.frames(25);
2951             if (item->parentItem()) resetGroup = true;
2952             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
2953             emit transitionItemSelected(NULL);
2954         }
2955     }
2956
2957     m_commandStack->push(deleteSelected);
2958 }
2959
2960 void CustomTrackView::changeClipSpeed()
2961 {
2962     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2963     if (itemList.count() == 0) {
2964         emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
2965         return;
2966     }
2967     QUndoCommand *changeSelected = new QUndoCommand();
2968     changeSelected->setText("Edit clip speed");
2969     int count = 0;
2970     int percent = -1;
2971     bool ok;
2972     for (int i = 0; i < itemList.count(); i++) {
2973         if (itemList.at(i)->type() == AVWIDGET) {
2974             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2975             ItemInfo info = item->info();
2976             if (percent == -1) percent = QInputDialog::getInteger(this, i18n("Edit Clip Speed"), i18n("New speed (percents)"), item->speed() * 100, 1, 10000, 1, &ok);
2977             if (!ok) break;
2978             double speed = (double) percent / 100.0;
2979             if (item->speed() != speed && (item->clipType() == VIDEO || item->clipType() == AV)) {
2980                 count++;
2981                 //new ChangeSpeedCommand(this, info, item->speed(), speed, item->clipProducer(), changeSelected);
2982             }
2983         }
2984     }
2985     if (count > 0) m_commandStack->push(changeSelected);
2986     else delete changeSelected;
2987 }
2988
2989 void CustomTrackView::doChangeClipSpeed(ItemInfo info, const double speed, const double oldspeed, int strobe, const QString &id)
2990 {
2991     DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
2992     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
2993     if (!item) {
2994         kDebug() << "ERROR: Cannot find clip for speed change";
2995         emit displayMessage(i18n("Cannot find clip for speed change"), ErrorMessage);
2996         return;
2997     }
2998     info.track = m_document->tracksCount() - item->track();
2999     int endPos = m_document->renderer()->mltChangeClipSpeed(info, speed, oldspeed, strobe, baseclip->producer());
3000     if (endPos >= 0) {
3001         item->setSpeed(speed, strobe);
3002         item->updateRectGeometry();
3003         if (item->cropDuration().frames(m_document->fps()) > endPos)
3004             item->AbstractClipItem::resizeEnd(info.startPos.frames(m_document->fps()) + endPos, speed);
3005         setDocumentModified();
3006     } else emit displayMessage(i18n("Invalid clip"), ErrorMessage);
3007 }
3008
3009 void CustomTrackView::cutSelectedClips()
3010 {
3011     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3012     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
3013     for (int i = 0; i < itemList.count(); i++) {
3014         if (itemList.at(i)->type() == AVWIDGET) {
3015             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3016             if (item->parentItem() && item->parentItem() != m_selectionGroup) {
3017                 emit displayMessage(i18n("Cannot cut a clip in a group"), ErrorMessage);
3018             } else if (currentPos > item->startPos() && currentPos <  item->endPos()) {
3019                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos);
3020                 m_commandStack->push(command);
3021             }
3022         }
3023     }
3024 }
3025
3026 void CustomTrackView::groupClips(bool group)
3027 {
3028     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3029     QList <ItemInfo> clipInfos;
3030     QList <ItemInfo> transitionInfos;
3031     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
3032
3033     // Expand groups
3034     int max = itemList.count();
3035     for (int i = 0; i < max; i++) {
3036         if (itemList.at(i)->type() == GROUPWIDGET) {
3037             itemList += itemList.at(i)->childItems();
3038         }
3039     }
3040
3041     for (int i = 0; i < itemList.count(); i++) {
3042         if (itemList.at(i)->type() == AVWIDGET) {
3043             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
3044             if (!clip->isItemLocked()) clipInfos.append(clip->info());
3045         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3046             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
3047             if (!clip->isItemLocked()) transitionInfos.append(clip->info());
3048         }
3049     }
3050     if (clipInfos.count() > 0) {
3051         GroupClipsCommand *command = new GroupClipsCommand(this, clipInfos, transitionInfos, group);
3052         m_commandStack->push(command);
3053     }
3054 }
3055
3056 void CustomTrackView::doGroupClips(QList <ItemInfo> clipInfos, QList <ItemInfo> transitionInfos, bool group)
3057 {
3058     resetSelectionGroup();
3059     m_scene->clearSelection();
3060     if (!group) {
3061         for (int i = 0; i < clipInfos.count(); i++) {
3062             ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
3063             if (clip == NULL) continue;
3064             if (clip->parentItem() && clip->parentItem()->type() == GROUPWIDGET) {
3065                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
3066                 m_document->clipManager()->removeGroup(grp);
3067                 scene()->destroyItemGroup(grp);
3068             }
3069             clip->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
3070         }
3071         for (int i = 0; i < transitionInfos.count(); i++) {
3072             Transition *tr = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
3073             if (tr == NULL) continue;
3074             if (tr->parentItem() && tr->parentItem()->type() == GROUPWIDGET) {
3075                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(tr->parentItem());
3076                 m_document->clipManager()->removeGroup(grp);
3077                 scene()->destroyItemGroup(grp);
3078             }
3079             tr->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
3080         }
3081         setDocumentModified();
3082         return;
3083     }
3084
3085     QList <QGraphicsItemGroup *> groups;
3086     for (int i = 0; i < clipInfos.count(); i++) {
3087         ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
3088         if (clip) {
3089             clip->setSelected(true);
3090         }
3091     }
3092     for (int i = 0; i < transitionInfos.count(); i++) {
3093         Transition *clip = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
3094         if (clip) {
3095             clip->setSelected(true);
3096         }
3097     }
3098
3099     groupSelectedItems(false, true);
3100     setDocumentModified();
3101 }
3102
3103 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects)
3104 {
3105     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
3106     if (baseclip == NULL) {
3107         emit displayMessage(i18n("No clip copied"), ErrorMessage);
3108         return;
3109     }
3110     ClipItem *item = new ClipItem(baseclip, info, m_document->fps(), xml.attribute("speed", "1").toDouble(), xml.attribute("strobe", "1").toInt());
3111     item->setEffectList(effects);
3112     if (xml.hasAttribute("audio_only")) item->setAudioOnly(true);
3113     else if (xml.hasAttribute("video_only")) item->setVideoOnly(true);
3114     scene()->addItem(item);
3115
3116     int tracknumber = m_document->tracksCount() - info.track - 1;
3117     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3118     if (isLocked) item->setItemLocked(true);
3119
3120     baseclip->addReference();
3121     m_document->updateClip(baseclip->getId());
3122     info.track = m_document->tracksCount() - info.track;
3123     Mlt::Producer *prod;
3124     if (item->isAudioOnly()) prod = baseclip->audioProducer(info.track);
3125     else if (item->isVideoOnly()) prod = baseclip->videoProducer();
3126     else prod = baseclip->producer(info.track);
3127     m_document->renderer()->mltInsertClip(info, xml, prod);
3128     for (int i = 0; i < item->effectsCount(); i++) {
3129         m_document->renderer()->mltAddEffect(info.track, info.startPos, item->getEffectArgs(item->effectAt(i)), false);
3130     }
3131     setDocumentModified();
3132     m_document->renderer()->doRefresh();
3133     m_waitingThumbs.append(item);
3134     m_thumbsTimer.start();
3135 }
3136
3137 void CustomTrackView::slotUpdateClip(const QString &clipId)
3138 {
3139     QList<QGraphicsItem *> list = scene()->items();
3140     ClipItem *clip = NULL;
3141     for (int i = 0; i < list.size(); ++i) {
3142         if (list.at(i)->type() == AVWIDGET) {
3143             clip = static_cast <ClipItem *>(list.at(i));
3144             if (clip->clipProducer() == clipId) {
3145                 ItemInfo info = clip->info();
3146                 info.track = m_document->tracksCount() - clip->track();
3147                 m_document->renderer()->mltUpdateClip(info, clip->xml(), clip->baseClip()->producer());
3148                 clip->refreshClip(true);
3149                 clip->update();
3150             }
3151         }
3152     }
3153 }
3154
3155 ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track)
3156 {
3157     int framepos = (int)(pos.frames(m_document->fps()));
3158     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, track * m_tracksHeight + m_tracksHeight / 2));
3159     ClipItem *clip = NULL;
3160     for (int i = 0; i < list.size(); i++) {
3161         if (list.at(i)->type() == AVWIDGET) {
3162             ClipItem *test = static_cast <ClipItem *>(list.at(i));
3163             if (test->endPos() == pos) clip = test;
3164             break;
3165         }
3166     }
3167     return clip;
3168 }
3169
3170 ClipItem *CustomTrackView::getClipItemAtStart(GenTime pos, int track)
3171 {
3172     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2));
3173     ClipItem *clip = NULL;
3174     for (int i = 0; i < list.size(); i++) {
3175         if (list.at(i)->type() == AVWIDGET) {
3176             ClipItem *test = static_cast <ClipItem *>(list.at(i));
3177             if (test->startPos() == pos) clip = test;
3178             break;
3179         }
3180     }
3181     return clip;
3182 }
3183
3184 ClipItem *CustomTrackView::getClipItemAt(int pos, int track)
3185 {
3186     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, track * m_tracksHeight + m_tracksHeight / 2));
3187     ClipItem *clip = NULL;
3188     for (int i = 0; i < list.size(); i++) {
3189         if (list.at(i)->type() == AVWIDGET) {
3190             clip = static_cast <ClipItem *>(list.at(i));
3191             break;
3192         }
3193     }
3194     return clip;
3195 }
3196
3197 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track)
3198 {
3199     return getClipItemAt((int) pos.frames(m_document->fps()), track);
3200 }
3201
3202 Transition *CustomTrackView::getTransitionItemAt(int pos, int track)
3203 {
3204     QList<QGraphicsItem *> list = scene()->items(QPointF(pos, (track + 1) * m_tracksHeight));
3205     Transition *clip = NULL;
3206     for (int i = 0; i < list.size(); i++) {
3207         if (list.at(i)->type() == TRANSITIONWIDGET) {
3208             clip = static_cast <Transition *>(list.at(i));
3209             break;
3210         }
3211     }
3212     return clip;
3213 }
3214
3215 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track)
3216 {
3217     return getTransitionItemAt(pos.frames(m_document->fps()), track);
3218 }
3219
3220 Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track)
3221 {
3222     int framepos = (int)(pos.frames(m_document->fps()));
3223     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, (track + 1) * m_tracksHeight));
3224     Transition *clip = NULL;
3225     for (int i = 0; i < list.size(); i++) {
3226         if (list.at(i)->type() == TRANSITIONWIDGET) {
3227             Transition *test = static_cast <Transition *>(list.at(i));
3228             if (test->endPos() == pos) clip = test;
3229             break;
3230         }
3231     }
3232     return clip;
3233 }
3234
3235 Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track)
3236 {
3237     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight));
3238     Transition *clip = NULL;
3239     for (int i = 0; i < list.size(); ++i) {
3240         if (list.at(i)->type() == TRANSITIONWIDGET) {
3241             Transition *test = static_cast <Transition *>(list.at(i));
3242             if (test->startPos() == pos) clip = test;
3243             break;
3244         }
3245     }
3246     return clip;
3247 }
3248
3249 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end)
3250 {
3251     if (m_selectionGroup) resetSelectionGroup(false);
3252     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()), start.track);
3253     if (!item) {
3254         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);
3255         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";
3256         return;
3257     }
3258     Mlt::Producer *prod;
3259     if (item->isAudioOnly()) prod = item->baseClip()->audioProducer(end.track);
3260     else if (item->isVideoOnly()) prod = item->baseClip()->videoProducer();
3261     else prod = item->baseClip()->producer(end.track);
3262
3263     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);
3264     if (success) {
3265         bool snap = KdenliveSettings::snaptopoints();
3266         KdenliveSettings::setSnaptopoints(false);
3267         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
3268
3269         int tracknumber = m_document->tracksCount() - end.track - 1;
3270         bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3271         m_scene->clearSelection();
3272         if (isLocked) item->setItemLocked(true);
3273         else {
3274             if (item->isItemLocked()) item->setItemLocked(false);
3275             item->setSelected(true);
3276         }
3277         if (item->baseClip()->isTransparent()) {
3278             // Also move automatic transition
3279             Transition *tr = getTransitionItemAt(start.startPos, start.track);
3280             if (tr && tr->isAutomatic()) {
3281                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
3282                 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);
3283                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
3284             }
3285         }
3286         KdenliveSettings::setSnaptopoints(snap);
3287         setDocumentModified();
3288     } else {
3289         // undo last move and emit error message
3290         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
3291     }
3292     m_document->renderer()->doRefresh();
3293     //kDebug() << " // MOVED CLIP TO: " << end.startPos.frames(25) << ", ITEM START: " << item->startPos().frames(25);
3294 }
3295
3296 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove)
3297 {
3298     // Group Items
3299     /*kDebug() << "//GRP MOVE, REVERS:" << reverseMove;
3300     kDebug() << "// GROUP MOV; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;*/
3301     resetSelectionGroup();
3302     m_scene->clearSelection();
3303
3304     for (int i = 0; i < startClip.count(); i++) {
3305         if (reverseMove) {
3306             startClip[i].startPos = startClip.at(i).startPos - offset;
3307             startClip[i].track = startClip.at(i).track - trackOffset;
3308         }
3309         //kDebug()<<"//LKING FR CLIP AT:"<<startClip.at(i).startPos.frames(25)<<", TK:"<<startClip.at(i).track;
3310         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
3311         if (clip) {
3312             clip->setItemLocked(false);
3313             if (clip->parentItem()) clip->parentItem()->setSelected(true);
3314             else clip->setSelected(true);
3315             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
3316         } else kDebug() << "//MISSING CLIP AT: " << startClip.at(i).startPos.frames(25);
3317     }
3318     for (int i = 0; i < startTransition.count(); i++) {
3319         if (reverseMove) {
3320             startTransition[i].startPos = startTransition.at(i).startPos - offset;
3321             startTransition[i].track = startTransition.at(i).track - trackOffset;
3322         }
3323         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
3324         if (tr) {
3325             tr->setItemLocked(false);
3326             if (tr->parentItem()) tr->parentItem()->setSelected(true);
3327             else tr->setSelected(true);
3328             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());
3329         } else kDebug() << "//MISSING TRANSITION AT: " << startTransition.at(i).startPos.frames(25);
3330     }
3331     groupSelectedItems(true);
3332     if (m_selectionGroup) {
3333         bool snap = KdenliveSettings::snaptopoints();
3334         KdenliveSettings::setSnaptopoints(false);
3335
3336         m_selectionGroup->moveBy(offset.frames(m_document->fps()), trackOffset *(qreal) m_tracksHeight);
3337
3338         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
3339         // Expand groups
3340         int max = children.count();
3341         for (int i = 0; i < max; i++) {
3342             if (children.at(i)->type() == GROUPWIDGET) {
3343                 children += children.at(i)->childItems();
3344             }
3345         }
3346
3347         for (int i = 0; i < children.count(); i++) {
3348             // re-add items in correct place
3349             if (children.at(i)->type() != AVWIDGET && children.at(i)->type() != TRANSITIONWIDGET) continue;
3350             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
3351             item->updateItem();
3352             ItemInfo info = item->info();
3353             int tracknumber = m_document->tracksCount() - info.track - 1;
3354             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3355             if (isLocked) item->setItemLocked(true);
3356             else if (item->isItemLocked()) item->setItemLocked(false);
3357
3358             if (item->type() == AVWIDGET) {
3359                 ClipItem *clip = static_cast <ClipItem*>(item);
3360                 info.track = m_document->tracksCount() - info.track;
3361                 Mlt::Producer *prod;
3362                 if (clip->isAudioOnly()) prod = clip->baseClip()->audioProducer(info.track);
3363                 else if (clip->isVideoOnly()) prod = clip->baseClip()->videoProducer();
3364                 else prod = clip->baseClip()->producer(info.track);
3365                 m_document->renderer()->mltInsertClip(info, clip->xml(), prod);
3366                 kDebug() << "// inserting new clp: " << info.startPos.frames(25);
3367             } else if (item->type() == TRANSITIONWIDGET) {
3368                 Transition *tr = static_cast <Transition*>(item);
3369                 int newTrack = tr->transitionEndTrack();
3370                 kDebug() << "/// TRANSITION CURR TRK: " << newTrack;
3371                 if (!tr->forcedTrack()) {
3372                     newTrack += trackOffset;
3373                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
3374                 }
3375                 tr->updateTransitionEndTrack(newTrack);
3376                 kDebug() << "/// TRANSITION UPDATED TRK: " << newTrack;
3377                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
3378             }
3379         }
3380         KdenliveSettings::setSnaptopoints(snap);
3381         m_document->renderer()->doRefresh();
3382     } else kDebug() << "///////// WARNING; NO GROUP TO MOVE";
3383 }
3384
3385 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end)
3386 {
3387     Transition *item = getTransitionItemAt(start.startPos, start.track);
3388     if (!item) {
3389         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);
3390         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
3391         return;
3392     }
3393     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
3394     bool snap = KdenliveSettings::snaptopoints();
3395     KdenliveSettings::setSnaptopoints(false);
3396     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
3397     if (end.endPos - end.startPos == start.endPos - start.startPos) {
3398         // Transition was moved
3399         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
3400     } else if (end.endPos == start.endPos) {
3401         // Transition start resize
3402         item->resizeStart((int) end.startPos.frames(m_document->fps()));
3403     } else if (end.startPos == start.startPos) {
3404         // Transition end resize;
3405         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3406     } else {
3407         // Move & resize
3408         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
3409         item->resizeStart((int) end.startPos.frames(m_document->fps()));
3410         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3411     }
3412     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
3413     KdenliveSettings::setSnaptopoints(snap);
3414     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
3415     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);
3416     if (m_dragItem && m_dragItem == item) {
3417         QPoint p;
3418         ClipItem *transitionClip = getClipItemAt(item->startPos(), item->track());
3419         if (transitionClip && transitionClip->baseClip()) {
3420             QString size = transitionClip->baseClip()->getProperty("frame_size");
3421             double factor = transitionClip->baseClip()->getProperty("aspect_ratio").toDouble();
3422             p.setX((int)(size.section('x', 0, 0).toInt() * factor + 0.5));
3423             p.setY(size.section('x', 1, 1).toInt());
3424         }
3425         emit transitionItemSelected(item, getPreviousVideoTrack(item->track()), p);
3426     }
3427     m_document->renderer()->doRefresh();
3428 }
3429
3430 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end)
3431 {
3432     bool resizeClipStart = true;
3433     if (start.startPos == end.startPos) resizeClipStart = false;
3434     /*if (resizeClipStart) offset = 1;
3435     else offset = -1;*/
3436     ClipItem *item = getClipItemAt((int)(start.startPos.frames(m_document->fps())), start.track);
3437     if (!item) {
3438         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);
3439         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
3440         return;
3441     }
3442     if (item->parentItem()) {
3443         // Item is part of a group, reset group
3444         resetSelectionGroup();
3445     }
3446     bool snap = KdenliveSettings::snaptopoints();
3447     KdenliveSettings::setSnaptopoints(false);
3448     if (resizeClipStart && start.startPos != end.startPos) {
3449         ItemInfo clipinfo = item->info();
3450         clipinfo.track = m_document->tracksCount() - clipinfo.track;
3451         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - item->startPos());
3452         if (success) {
3453             kDebug() << "RESIZE CLP STRAT TO:" << end.startPos.frames(m_document->fps()) << ", OLD ST: " << start.startPos.frames(25);
3454             item->resizeStart((int) end.startPos.frames(m_document->fps()));
3455             updateClipFade(item);
3456         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3457     } else if (!resizeClipStart) {
3458         ItemInfo clipinfo = item->info();
3459         clipinfo.track = m_document->tracksCount() - clipinfo.track;
3460         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
3461         if (success) {
3462             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
3463             updateClipFade(item);
3464         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
3465     }
3466     if (end.cropStart != start.cropStart) {
3467         kDebug() << "// RESIZE CROP, DIFF: " << (end.cropStart - start.cropStart).frames(25);
3468         ItemInfo clipinfo = end;
3469         clipinfo.track = m_document->tracksCount() - end.track;
3470         bool success = m_document->renderer()->mltResizeClipCrop(clipinfo, end.cropStart - start.cropStart);
3471         if (success) {
3472             item->setCropStart(end.cropStart);
3473             item->resetThumbs(true);
3474         }
3475     }
3476     m_document->renderer()->doRefresh();
3477     KdenliveSettings::setSnaptopoints(snap);
3478 }
3479
3480 void CustomTrackView::updateClipFade(ClipItem * item)
3481 {
3482     int end = item->fadeIn();
3483     if (end != 0) {
3484         // there is a fade in effect
3485         int effectPos = item->hasEffect("volume", "fadein");
3486         if (effectPos != -1) {
3487             QDomElement oldeffect = item->effectAt(effectPos);
3488             int start = item->cropStart().frames(m_document->fps());
3489             int max = item->cropDuration().frames(m_document->fps());
3490             if (end > max) {
3491                 // Make sure the fade effect is not longer than the clip
3492                 item->setFadeIn(max);
3493                 end = item->fadeIn();
3494             }
3495             end += start;
3496             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3497             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3498             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3499                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3500             // if fade effect is displayed, update the effect edit widget with new clip duration
3501             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3502         }
3503         effectPos = item->hasEffect("brightness", "fade_from_black");
3504         if (effectPos != -1) {
3505             QDomElement oldeffect = item->effectAt(effectPos);
3506             int start = item->cropStart().frames(m_document->fps());
3507             int max = item->cropDuration().frames(m_document->fps());
3508             if (end > max) {
3509                 // Make sure the fade effect is not longer than the clip
3510                 item->setFadeIn(max);
3511                 end = item->fadeIn();
3512             }
3513             end += start;
3514             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3515             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3516             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3517                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3518             // if fade effect is displayed, update the effect edit widget with new clip duration
3519             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3520         }
3521     }
3522     int start = item->fadeOut();
3523     if (start != 0) {
3524         // there is a fade out effect
3525         int effectPos = item->hasEffect("volume", "fadeout");
3526         if (effectPos != -1) {
3527             QDomElement oldeffect = item->effectAt(effectPos);
3528             int max = item->cropDuration().frames(m_document->fps());
3529             int end = max + item->cropStart().frames(m_document->fps());
3530             if (start > max) {
3531                 // Make sure the fade effect is not longer than the clip
3532                 item->setFadeOut(max);
3533                 start = item->fadeOut();
3534             }
3535             start = end - start;
3536             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3537             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3538             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3539                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3540             // if fade effect is displayed, update the effect edit widget with new clip duration
3541             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3542         }
3543         effectPos = item->hasEffect("brightness", "fade_to_black");
3544         if (effectPos != -1) {
3545             QDomElement oldeffect = item->effectAt(effectPos);
3546             int max = item->cropDuration().frames(m_document->fps());
3547             int end = max + item->cropStart().frames(m_document->fps());
3548             if (start > max) {
3549                 // Make sure the fade effect is not longer than the clip
3550                 item->setFadeOut(max);
3551                 start = item->fadeOut();
3552             }
3553             start = end - start;
3554             EffectsList::setParameter(oldeffect, "in", QString::number(start));
3555             EffectsList::setParameter(oldeffect, "out", QString::number(end));
3556             if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
3557                 emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
3558             // if fade effect is displayed, update the effect edit widget with new clip duration
3559             if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
3560         }
3561     }
3562 }
3563
3564 double CustomTrackView::getSnapPointForPos(double pos)
3565 {
3566     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
3567 }
3568
3569 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected, QList <GenTime> offsetList, bool skipSelectedItems)
3570 {
3571     QList <GenTime> snaps;
3572     if (selected && offsetList.isEmpty()) offsetList.append(selected->cropDuration());
3573     QList<QGraphicsItem *> itemList = items();
3574     for (int i = 0; i < itemList.count(); i++) {
3575         if (itemList.at(i) == selected) continue;
3576         if (skipSelectedItems && itemList.at(i)->isSelected()) continue;
3577         if (itemList.at(i)->type() == AVWIDGET) {
3578             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3579             GenTime start = item->startPos();
3580             GenTime end = item->endPos();
3581             snaps.append(start);
3582             snaps.append(end);
3583             if (!offsetList.isEmpty()) {
3584                 for (int j = 0; j < offsetList.size(); j++) {
3585                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3586                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3587                 }
3588             }
3589             // Add clip markers
3590             QList < GenTime > markers = item->snapMarkers();
3591             for (int j = 0; j < markers.size(); ++j) {
3592                 GenTime t = markers.at(j);
3593                 snaps.append(t);
3594                 if (!offsetList.isEmpty()) {
3595                     for (int k = 0; k < offsetList.size(); k++) {
3596                         if (t > offsetList.at(k)) snaps.append(t - offsetList.at(k));
3597                     }
3598                 }
3599             }
3600         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3601             Transition *transition = static_cast <Transition*>(itemList.at(i));
3602             GenTime start = transition->startPos();
3603             GenTime end = transition->endPos();
3604             snaps.append(start);
3605             snaps.append(end);
3606             if (!offsetList.isEmpty()) {
3607                 for (int j = 0; j < offsetList.size(); j++) {
3608                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
3609                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
3610                 }
3611             }
3612         }
3613     }
3614
3615     // add cursor position
3616     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3617     snaps.append(pos);
3618     if (!offsetList.isEmpty()) {
3619         for (int j = 0; j < offsetList.size(); j++) {
3620             snaps.append(pos - offsetList.at(j));
3621         }
3622     }
3623
3624     // add guides
3625     for (int i = 0; i < m_guides.count(); i++) {
3626         snaps.append(m_guides.at(i)->position());
3627         if (!offsetList.isEmpty()) {
3628             for (int j = 0; j < offsetList.size(); j++) {
3629                 snaps.append(m_guides.at(i)->position() - offsetList.at(j));
3630             }
3631         }
3632     }
3633
3634     qSort(snaps);
3635     m_scene->setSnapList(snaps);
3636     //for (int i = 0; i < m_snapPoints.size(); ++i)
3637     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
3638 }
3639
3640 void CustomTrackView::slotSeekToPreviousSnap()
3641 {
3642     updateSnapPoints(NULL);
3643     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3644     setCursorPos((int) res.frames(m_document->fps()));
3645     checkScrolling();
3646 }
3647
3648 void CustomTrackView::slotSeekToNextSnap()
3649 {
3650     updateSnapPoints(NULL);
3651     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
3652     setCursorPos((int) res.frames(m_document->fps()));
3653     checkScrolling();
3654 }
3655
3656 void CustomTrackView::clipStart()
3657 {
3658     ClipItem *item = getMainActiveClip();
3659     if (item != NULL) {
3660         setCursorPos((int) item->startPos().frames(m_document->fps()));
3661         checkScrolling();
3662     }
3663 }
3664
3665 void CustomTrackView::clipEnd()
3666 {
3667     ClipItem *item = getMainActiveClip();
3668     if (item != NULL) {
3669         setCursorPos((int) item->endPos().frames(m_document->fps()) - 1);
3670         checkScrolling();
3671     }
3672 }
3673
3674 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c)
3675 {
3676     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
3677     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t);
3678     m_commandStack->push(command);
3679 }
3680
3681 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position)
3682 {
3683     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position);
3684     m_commandStack->push(command);
3685 }
3686
3687 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id)
3688 {
3689     DocClipBase *base = m_document->clipManager()->getClipById(id);
3690     QList <CommentedTime> markers = base->commentedSnapMarkers();
3691
3692     if (markers.isEmpty()) {
3693         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
3694         return;
3695     }
3696     QUndoCommand *deleteMarkers = new QUndoCommand();
3697     deleteMarkers->setText("Delete clip markers");
3698
3699     for (int i = 0; i < markers.size(); i++) {
3700         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), deleteMarkers);
3701     }
3702     m_commandStack->push(deleteMarkers);
3703 }
3704
3705 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment)
3706 {
3707     DocClipBase *base = m_document->clipManager()->getClipById(id);
3708     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
3709     else base->deleteSnapMarker(pos);
3710     setDocumentModified();
3711     viewport()->update();
3712 }
3713
3714 int CustomTrackView::hasGuide(int pos, int offset)
3715 {
3716     for (int i = 0; i < m_guides.count(); i++) {
3717         int guidePos = m_guides.at(i)->position().frames(m_document->fps());
3718         if (qAbs(guidePos - pos) <= offset) return guidePos;
3719         else if (guidePos > pos) return -1;
3720     }
3721     return -1;
3722 }
3723
3724 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment)
3725 {
3726     if (oldPos > GenTime() && pos > GenTime()) {
3727         // move guide
3728         for (int i = 0; i < m_guides.count(); i++) {
3729             if (m_guides.at(i)->position() == oldPos) {
3730                 Guide *item = m_guides.at(i);
3731                 item->updateGuide(pos, comment);
3732                 break;
3733             }
3734         }
3735     } else if (pos > GenTime()) addGuide(pos, comment);
3736     else {
3737         // remove guide
3738         bool found = false;
3739         for (int i = 0; i < m_guides.count(); i++) {
3740             if (m_guides.at(i)->position() == oldPos) {
3741                 delete m_guides.takeAt(i);
3742                 found = true;
3743                 break;
3744             }
3745         }
3746         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3747     }
3748     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3749     m_document->syncGuides(m_guides);
3750 }
3751
3752 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment)
3753 {
3754     for (int i = 0; i < m_guides.count(); i++) {
3755         if (m_guides.at(i)->position() == pos) {
3756             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
3757             return false;
3758         }
3759     }
3760     Guide *g = new Guide(this, pos, comment, m_document->fps(), m_tracksHeight * m_document->tracksCount());
3761     scene()->addItem(g);
3762     m_guides.append(g);
3763     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3764     m_document->syncGuides(m_guides);
3765     return true;
3766 }
3767
3768 void CustomTrackView::slotAddGuide()
3769 {
3770     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
3771     MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
3772     if (d.exec() != QDialog::Accepted) return;
3773     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
3774         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
3775         m_commandStack->push(command);
3776     }
3777 }
3778
3779 void CustomTrackView::slotEditGuide(int guidePos)
3780 {
3781     GenTime pos;
3782     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
3783     else pos = GenTime(guidePos, m_document->fps());
3784     bool found = false;
3785     for (int i = 0; i < m_guides.count(); i++) {
3786         if (m_guides.at(i)->position() == pos) {
3787             slotEditGuide(m_guides.at(i)->info());
3788             found = true;
3789             break;
3790         }
3791     }
3792     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3793 }
3794
3795 void CustomTrackView::slotEditGuide(CommentedTime guide)
3796 {
3797     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
3798     if (d.exec() == QDialog::Accepted) {
3799         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
3800         m_commandStack->push(command);
3801     }
3802 }
3803
3804
3805 void CustomTrackView::slotEditTimeLineGuide()
3806 {
3807     if (m_dragGuide == NULL) return;
3808     CommentedTime guide = m_dragGuide->info();
3809     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
3810     if (d.exec() == QDialog::Accepted) {
3811         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
3812         m_commandStack->push(command);
3813     }
3814 }
3815
3816 void CustomTrackView::slotDeleteGuide(int guidePos)
3817 {
3818     GenTime pos;
3819     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
3820     else pos = GenTime(guidePos, m_document->fps());
3821     bool found = false;
3822     for (int i = 0; i < m_guides.count(); i++) {
3823         if (m_guides.at(i)->position() == pos) {
3824             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
3825             m_commandStack->push(command);
3826             found = true;
3827             break;
3828         }
3829     }
3830     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3831 }
3832
3833
3834 void CustomTrackView::slotDeleteTimeLineGuide()
3835 {
3836     if (m_dragGuide == NULL) return;
3837     EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(), QString(), true);
3838     m_commandStack->push(command);
3839 }
3840
3841
3842 void CustomTrackView::slotDeleteAllGuides()
3843 {
3844     QUndoCommand *deleteAll = new QUndoCommand();
3845     deleteAll->setText("Delete all guides");
3846     for (int i = 0; i < m_guides.count(); i++) {
3847         new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
3848     }
3849     m_commandStack->push(deleteAll);
3850 }
3851
3852 void CustomTrackView::setTool(PROJECTTOOL tool)
3853 {
3854     m_tool = tool;
3855 }
3856
3857 void CustomTrackView::setScale(double scaleFactor, double verticalScale)
3858 {
3859     QMatrix matrix;
3860     matrix = matrix.scale(scaleFactor, verticalScale);
3861     m_scene->setScale(scaleFactor, verticalScale);
3862     m_animationTimer->stop();
3863     delete m_visualTip;
3864     m_visualTip = NULL;
3865     delete m_animation;
3866     m_animation = NULL;
3867     double verticalPos = mapToScene(QPoint(0, viewport()->height() / 2)).y();
3868     setMatrix(matrix);
3869     int diff = sceneRect().width() - m_projectDuration;
3870     if (diff * matrix.m11() < 50) {
3871         if (matrix.m11() < 0.4) setSceneRect(0, 0, (m_projectDuration + 100 / matrix.m11()), sceneRect().height());
3872         else setSceneRect(0, 0, (m_projectDuration + 300), sceneRect().height());
3873     }
3874     centerOn(QPointF(cursorPos(), verticalPos));
3875 }
3876
3877 void CustomTrackView::slotRefreshGuides()
3878 {
3879     if (KdenliveSettings::showmarkers()) {
3880         for (int i = 0; i < m_guides.count(); i++) {
3881             m_guides.at(i)->update();
3882         }
3883     }
3884 }
3885
3886 void CustomTrackView::drawBackground(QPainter * painter, const QRectF &rect)
3887 {
3888     QRectF r = rect;
3889     r.setWidth(r.width() + 1);
3890     painter->setClipRect(r);
3891     painter->drawLine(r.left(), 0, r.right(), 0);
3892     uint max = m_document->tracksCount();
3893     KColorScheme scheme(palette().currentColorGroup(), KColorScheme::Window);
3894     QColor lockedColor = scheme.background(KColorScheme::NegativeBackground).color();
3895     QColor audioColor = palette().alternateBase().color();
3896     QColor base = scheme.background(KColorScheme::NormalBackground).color();
3897     for (uint i = 0; i < max; i++) {
3898         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));
3899         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));
3900         painter->drawLine(r.left(), m_tracksHeight *(i + 1), r.right(), m_tracksHeight *(i + 1));
3901     }
3902     int lowerLimit = m_tracksHeight * m_document->tracksCount() + 1;
3903     if (height() > lowerLimit)
3904         painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
3905 }
3906
3907 bool CustomTrackView::findString(const QString &text)
3908 {
3909     QString marker;
3910     for (int i = 0; i < m_searchPoints.size(); ++i) {
3911         marker = m_searchPoints.at(i).comment();
3912         if (marker.contains(text, Qt::CaseInsensitive)) {
3913             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3914             int vert = verticalScrollBar()->value();
3915             int hor = cursorPos();
3916             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3917             m_findIndex = i;
3918             return true;
3919         }
3920     }
3921     return false;
3922 }
3923
3924 bool CustomTrackView::findNextString(const QString &text)
3925 {
3926     QString marker;
3927     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
3928         marker = m_searchPoints.at(i).comment();
3929         if (marker.contains(text, Qt::CaseInsensitive)) {
3930             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3931             int vert = verticalScrollBar()->value();
3932             int hor = cursorPos();
3933             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3934             m_findIndex = i;
3935             return true;
3936         }
3937     }
3938     m_findIndex = -1;
3939     return false;
3940 }
3941
3942 void CustomTrackView::initSearchStrings()
3943 {
3944     m_searchPoints.clear();
3945     QList<QGraphicsItem *> itemList = items();
3946     for (int i = 0; i < itemList.count(); i++) {
3947         // parse all clip names
3948         if (itemList.at(i)->type() == AVWIDGET) {
3949             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3950             GenTime start = item->startPos();
3951             CommentedTime t(start, item->clipName());
3952             m_searchPoints.append(t);
3953             // add all clip markers
3954             QList < CommentedTime > markers = item->commentedSnapMarkers();
3955             m_searchPoints += markers;
3956         }
3957     }
3958
3959     // add guides
3960     for (int i = 0; i < m_guides.count(); i++) {
3961         m_searchPoints.append(m_guides.at(i)->info());
3962     }
3963
3964     qSort(m_searchPoints);
3965 }
3966
3967 void CustomTrackView::clearSearchStrings()
3968 {
3969     m_searchPoints.clear();
3970     m_findIndex = 0;
3971 }
3972
3973 void CustomTrackView::copyClip()
3974 {
3975     qDeleteAll(m_copiedItems);
3976     m_copiedItems.clear();
3977     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3978     if (itemList.count() == 0) {
3979         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
3980         return;
3981     }
3982     for (int i = 0; i < itemList.count(); i++) {
3983         if (itemList.at(i)->type() == AVWIDGET) {
3984             ClipItem *clip = static_cast <ClipItem *>(itemList.at(i));
3985             ClipItem *clone = clip->clone(clip->info());
3986             m_copiedItems.append(clone);
3987         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3988             Transition *dup = static_cast <Transition *>(itemList.at(i));
3989             m_copiedItems.append(dup->clone());
3990         }
3991     }
3992 }
3993
3994 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const
3995 {
3996     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));
3997     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3998     for (int i = 0; i < collisions.count(); i++) {
3999         if (collisions.at(i)->type() == type) return false;
4000     }
4001     return true;
4002 }
4003
4004 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
4005 {
4006     for (int i = 0; i < items.count(); i++) {
4007         ItemInfo info = items.at(i)->info();
4008         info.startPos += offset;
4009         info.endPos += offset;
4010         info.track += trackOffset;
4011         if (!canBePastedTo(info, items.at(i)->type())) return false;
4012     }
4013     return true;
4014 }
4015
4016 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
4017 {
4018     QPainterPath movePath;
4019     movePath.moveTo(0, 0);
4020
4021     for (int i = 0; i < items.count(); i++) {
4022         ItemInfo info = items.at(i)->info();
4023         info.startPos = info.startPos + offset;
4024         info.endPos = info.endPos + offset;
4025         info.track = info.track + trackOffset;
4026         if (info.startPos < GenTime()) {
4027             // No clip should go below 0
4028             return false;
4029         }
4030         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));
4031         movePath.addRect(rect);
4032     }
4033     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
4034     for (int i = 0; i < collisions.count(); i++) {
4035         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
4036             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
4037             return false;
4038         }
4039     }
4040     return true;
4041 }
4042
4043 void CustomTrackView::pasteClip()
4044 {
4045     if (m_copiedItems.count() == 0) {
4046         emit displayMessage(i18n("No clip copied"), ErrorMessage);
4047         return;
4048     }
4049     QPoint position;
4050     if (m_menuPosition.isNull()) {
4051         position = mapFromGlobal(QCursor::pos());
4052         if (!underMouse() || position.y() > m_tracksHeight * m_document->tracksCount()) {
4053             emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
4054             return;
4055         }
4056     } else position = m_menuPosition;
4057     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
4058     int track = (int)(position.y() / m_tracksHeight);
4059     ItemInfo first = m_copiedItems.at(0)->info();
4060
4061     GenTime offset = pos - first.startPos;
4062     int trackOffset = track - first.track;
4063
4064     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
4065         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
4066         return;
4067     }
4068     QUndoCommand *pasteClips = new QUndoCommand();
4069     pasteClips->setText("Paste clips");
4070
4071     for (int i = 0; i < m_copiedItems.count(); i++) {
4072         // parse all clip names
4073         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
4074             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
4075             ItemInfo info;
4076             info.startPos = clip->startPos() + offset;
4077             info.endPos = clip->endPos() + offset;
4078             info.cropStart = clip->cropStart();
4079             info.track = clip->track() + trackOffset;
4080             if (canBePastedTo(info, AVWIDGET)) {
4081                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
4082             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
4083         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
4084             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
4085             ItemInfo info;
4086             info.startPos = tr->startPos() + offset;
4087             info.endPos = tr->endPos() + offset;
4088             info.track = tr->track() + trackOffset;
4089             if (canBePastedTo(info, TRANSITIONWIDGET)) {
4090                 if (info.startPos >= info.endPos) {
4091                     emit displayMessage(i18n("Invalid transition"), ErrorMessage);
4092                 } else new AddTransitionCommand(this, info, tr->transitionEndTrack() + trackOffset, tr->toXML(), false, true, pasteClips);
4093             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
4094         }
4095     }
4096     m_commandStack->push(pasteClips);
4097 }
4098
4099 void CustomTrackView::pasteClipEffects()
4100 {
4101     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
4102         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
4103         return;
4104     }
4105     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
4106
4107     QUndoCommand *paste = new QUndoCommand();
4108     paste->setText("Paste effects");
4109
4110     QList<QGraphicsItem *> clips = scene()->selectedItems();
4111     for (int i = 0; i < clips.count(); ++i) {
4112         if (clips.at(i)->type() == AVWIDGET) {
4113             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
4114             for (int j = 0; j < clip->effectsCount(); j++) {
4115                 new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), clip->effectAt(j), true, paste);
4116             }
4117         }
4118     }
4119     m_commandStack->push(paste);
4120 }
4121
4122
4123 ClipItem *CustomTrackView::getClipUnderCursor() const
4124 {
4125     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
4126     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
4127     for (int i = 0; i < collisions.count(); i++) {
4128         if (collisions.at(i)->type() == AVWIDGET) {
4129             return static_cast < ClipItem *>(collisions.at(i));
4130         }
4131     }
4132     return NULL;
4133 }
4134
4135 ClipItem *CustomTrackView::getMainActiveClip() const
4136 {
4137     QList<QGraphicsItem *> clips = scene()->selectedItems();
4138     if (clips.isEmpty()) {
4139         return getClipUnderCursor();
4140     } else {
4141         ClipItem *item = NULL;
4142         for (int i = 0; i < clips.count(); ++i) {
4143             if (clips.at(i)->type() == AVWIDGET)
4144                 item = static_cast < ClipItem *>(clips.at(i));
4145             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
4146         }
4147         if (item) return item;
4148     }
4149     return NULL;
4150 }
4151
4152 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const
4153 {
4154     QList<QGraphicsItem *> clips = scene()->selectedItems();
4155     if (clips.isEmpty()) {
4156         return getClipUnderCursor();
4157     } else {
4158         ClipItem *item;
4159         // remove all items in the list that are not clips
4160         for (int i = 0; i < clips.count();) {
4161             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
4162             else i++;
4163         }
4164         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
4165         for (int i = 0; i < clips.count(); ++i) {
4166             if (clips.at(i)->type() == AVWIDGET) {
4167                 item = static_cast < ClipItem *>(clips.at(i));
4168                 if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos)
4169                     return item;
4170             }
4171         }
4172     }
4173     return NULL;
4174 }
4175
4176 void CustomTrackView::setInPoint()
4177 {
4178     AbstractClipItem *clip = getActiveClipUnderCursor(true);
4179     if (clip == NULL) {
4180         if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
4181             clip = m_dragItem;
4182         } else {
4183             emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4184             return;
4185         }
4186     }
4187     ItemInfo startInfo = clip->info();
4188     ItemInfo endInfo = startInfo;
4189     endInfo.startPos = GenTime(m_cursorPos, m_document->fps());
4190     if (endInfo.startPos >= startInfo.endPos) {
4191         // Check for invalid resize
4192         emit displayMessage(i18n("Invalid action"), ErrorMessage);
4193         return;
4194     } else if (endInfo.startPos < startInfo.startPos) {
4195         int length = m_document->renderer()->mltGetSpaceLength(endInfo.startPos, m_document->tracksCount() - startInfo.track, false);
4196         if ((clip->type() == TRANSITIONWIDGET && itemCollision(clip, endInfo) == true) || (
4197                     (clip->type() == AVWIDGET) && length < (startInfo.startPos - endInfo.startPos).frames(m_document->fps()))) {
4198             emit displayMessage(i18n("Invalid action"), ErrorMessage);
4199             return;
4200         }
4201     }
4202     if (clip->type() == TRANSITIONWIDGET) {
4203         m_commandStack->push(new MoveTransitionCommand(this, startInfo, endInfo, true));
4204     } else m_commandStack->push(new ResizeClipCommand(this, startInfo, endInfo, true));
4205 }
4206
4207 void CustomTrackView::setOutPoint()
4208 {
4209     AbstractClipItem *clip = getActiveClipUnderCursor(true);
4210     if (clip == NULL) {
4211         if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
4212             clip = m_dragItem;
4213         } else {
4214             emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4215             return;
4216         }
4217     }
4218     ItemInfo startInfo = clip->info();
4219     ItemInfo endInfo = clip->info();
4220     endInfo.endPos = GenTime(m_cursorPos, m_document->fps());
4221     if (endInfo.endPos <= startInfo.startPos) {
4222         // Check for invalid resize
4223         emit displayMessage(i18n("Invalid action"), ErrorMessage);
4224         return;
4225     } else if (endInfo.endPos > startInfo.endPos) {
4226         int length = m_document->renderer()->mltGetSpaceLength(endInfo.endPos, m_document->tracksCount() - startInfo.track, false);
4227         if ((clip->type() == TRANSITIONWIDGET && itemCollision(clip, endInfo) == true) || (clip->type() == AVWIDGET && length < (endInfo.endPos - startInfo.endPos).frames(m_document->fps()))) {
4228             emit displayMessage(i18n("Invalid action"), ErrorMessage);
4229             return;
4230         }
4231     }
4232
4233
4234     if (clip->type() == TRANSITIONWIDGET) {
4235         m_commandStack->push(new MoveTransitionCommand(this, startInfo, endInfo, true));
4236     } else m_commandStack->push(new ResizeClipCommand(this, startInfo, endInfo, true));
4237 }
4238
4239 void CustomTrackView::slotUpdateAllThumbs()
4240 {
4241     QList<QGraphicsItem *> itemList = items();
4242     //if (itemList.isEmpty()) return;
4243     ClipItem *item;
4244     const QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
4245     for (int i = 0; i < itemList.count(); i++) {
4246         if (itemList.at(i)->type() == AVWIDGET) {
4247             item = static_cast <ClipItem *>(itemList.at(i));
4248             if (item->clipType() != COLOR && item->clipType() != AUDIO) {
4249                 // Check if we have a cached thumbnail
4250                 if (item->clipType() == IMAGE || item->clipType() == TEXT) {
4251                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
4252                     if (QFile::exists(thumb)) {
4253                         QPixmap pix(thumb);
4254                         item->slotSetStartThumb(pix);
4255                     }
4256                 } else {
4257                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
4258                     QString endThumb = startThumb;
4259                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
4260                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
4261                     if (QFile::exists(startThumb)) {
4262                         QPixmap pix(startThumb);
4263                         item->slotSetStartThumb(pix);
4264                     }
4265                     if (QFile::exists(endThumb)) {
4266                         QPixmap pix(endThumb);
4267                         item->slotSetEndThumb(pix);
4268                     }
4269                 }
4270             }
4271             item->refreshClip(false);
4272             qApp->processEvents();
4273         }
4274     }
4275     viewport()->update();
4276 }
4277
4278 void CustomTrackView::saveThumbnails()
4279 {
4280     QList<QGraphicsItem *> itemList = items();
4281     ClipItem *item;
4282     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
4283     for (int i = 0; i < itemList.count(); i++) {
4284         if (itemList.at(i)->type() == AVWIDGET) {
4285             item = static_cast <ClipItem *>(itemList.at(i));
4286             if (item->clipType() != COLOR) {
4287                 // Check if we have a cached thumbnail
4288                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
4289                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
4290                     if (!QFile::exists(thumb)) {
4291                         QPixmap pix(item->startThumb());
4292                         pix.save(thumb);
4293                     }
4294                 } else {
4295                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
4296                     QString endThumb = startThumb;
4297                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
4298                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
4299                     if (!QFile::exists(startThumb)) {
4300                         QPixmap pix(item->startThumb());
4301                         pix.save(startThumb);
4302                     }
4303                     if (!QFile::exists(endThumb)) {
4304                         QPixmap pix(item->endThumb());
4305                         pix.save(endThumb);
4306                     }
4307                 }
4308             }
4309         }
4310     }
4311 }
4312
4313
4314 void CustomTrackView::slotInsertTrack(int ix)
4315 {
4316     kDebug() << "// INSERTING TRK: " << ix;
4317     QDialog d(parentWidget());
4318     Ui::AddTrack_UI view;
4319     view.setupUi(&d);
4320     view.track_nb->setMaximum(m_document->tracksCount() - 1);
4321     view.track_nb->setValue(ix);
4322     d.setWindowTitle(i18n("Insert Track"));
4323
4324     if (d.exec() == QDialog::Accepted) {
4325         ix = view.track_nb->value();
4326         if (view.before_select->currentIndex() == 1) {
4327             ix++;
4328         }
4329         TrackInfo info;
4330         if (view.video_track->isChecked()) {
4331             info.type = VIDEOTRACK;
4332             info.isMute = false;
4333             info.isBlind = false;
4334             info.isLocked = false;
4335         } else {
4336             info.type = AUDIOTRACK;
4337             info.isMute = false;
4338             info.isBlind = true;
4339             info.isLocked = false;
4340         }
4341         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true);
4342         m_commandStack->push(addTrack);
4343         setDocumentModified();
4344     }
4345 }
4346
4347 void CustomTrackView::slotDeleteTrack(int ix)
4348 {
4349     bool ok;
4350     ix = QInputDialog::getInteger(this, i18n("Remove Track"), i18n("Track"), ix, 0, m_document->tracksCount() - 1, 1, &ok);
4351     if (ok) {
4352         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
4353         deleteTimelineTrack(ix, info);
4354         setDocumentModified();
4355         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false);
4356         m_commandStack->push(command);*/
4357     }
4358 }
4359
4360 void CustomTrackView::slotChangeTrack(int ix)
4361 {
4362     QDialog d(parentWidget());
4363     Ui::AddTrack_UI view;
4364     view.setupUi(&d);
4365     view.label->setText(i18n("Change track"));
4366     view.before_select->setHidden(true);
4367     view.track_nb->setMaximum(m_document->tracksCount() - 1);
4368     view.track_nb->setValue(ix);
4369     d.setWindowTitle(i18n("Change Track Type"));
4370
4371     if (m_document->trackInfoAt(m_document->tracksCount() - ix - 1).type == VIDEOTRACK)
4372         view.video_track->setChecked(true);
4373     else
4374         view.audio_track->setChecked(true);
4375
4376     if (d.exec() == QDialog::Accepted) {
4377         TrackInfo info;
4378         info.isLocked = false;
4379         info.isMute = false;
4380         ix = view.track_nb->value();
4381
4382         if (view.video_track->isChecked()) {
4383             info.type = VIDEOTRACK;
4384             info.isBlind = false;
4385         } else {
4386             info.type = AUDIOTRACK;
4387             info.isBlind = true;
4388         }
4389         changeTimelineTrack(ix, info);
4390         setDocumentModified();
4391     }
4392 }
4393
4394
4395 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo)
4396 {
4397     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
4398     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
4399     QList<QGraphicsItem *> selection = m_scene->items(r);
4400     QUndoCommand *deleteTrack = new QUndoCommand();
4401     deleteTrack->setText("Delete track");
4402
4403     // Delete all clips in selected track
4404     for (int i = 0; i < selection.count(); i++) {
4405         if (selection.at(i)->type() == AVWIDGET) {
4406             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
4407             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, true, deleteTrack);
4408             m_scene->removeItem(item);
4409             delete item;
4410             item = NULL;
4411         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
4412             Transition *item =  static_cast <Transition *>(selection.at(i));
4413             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
4414             m_scene->removeItem(item);
4415             delete item;
4416             item = NULL;
4417         }
4418     }
4419
4420     selection = m_scene->items();
4421     new AddTrackCommand(this, ix, trackinfo, false, deleteTrack);
4422     m_commandStack->push(deleteTrack);
4423 }
4424
4425 void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo)
4426 {
4427     TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
4428     ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo);
4429     m_commandStack->push(changeTrack);
4430 }
4431
4432 void CustomTrackView::autoTransition()
4433 {
4434     QList<QGraphicsItem *> itemList = scene()->selectedItems();
4435     if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
4436         emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
4437         return;
4438     }
4439     Transition *tr = static_cast <Transition*>(itemList.at(0));
4440     tr->setAutomatic(!tr->isAutomatic());
4441     QDomElement transition = tr->toXML();
4442     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);
4443 }
4444
4445
4446 QStringList CustomTrackView::getLadspaParams(QDomElement effect) const
4447 {
4448     QStringList result;
4449     QDomNodeList params = effect.elementsByTagName("parameter");
4450     for (int i = 0; i < params.count(); i++) {
4451         QDomElement e = params.item(i).toElement();
4452         if (!e.isNull() && e.attribute("type") == "constant") {
4453             if (e.hasAttribute("factor")) {
4454                 double factor = e.attribute("factor").toDouble();
4455                 double value = e.attribute("value").toDouble();
4456                 value = value / factor;
4457                 result.append(QString::number(value));
4458             } else result.append(e.attribute("value"));
4459         }
4460     }
4461     return result;
4462 }
4463
4464 void CustomTrackView::clipNameChanged(const QString id, const QString name)
4465 {
4466     QList<QGraphicsItem *> list = scene()->items();
4467     ClipItem *clip = NULL;
4468     for (int i = 0; i < list.size(); ++i) {
4469         if (list.at(i)->type() == AVWIDGET) {
4470             clip = static_cast <ClipItem *>(list.at(i));
4471             if (clip->clipProducer() == id) {
4472                 clip->setClipName(name);
4473             }
4474         }
4475     }
4476     viewport()->update();
4477 }
4478
4479 void CustomTrackView::getClipAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
4480 {
4481     minimum = GenTime();
4482     maximum = GenTime();
4483     QList<QGraphicsItem *> selection;
4484     selection = m_scene->items(0, item->track() * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
4485     selection.removeAll(item);
4486     for (int i = 0; i < selection.count(); i++) {
4487         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
4488         if (clip && clip->type() == AVWIDGET) {
4489             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
4490             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
4491         }
4492     }
4493 }
4494
4495 void CustomTrackView::getTransitionAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
4496 {
4497     minimum = GenTime();
4498     maximum = GenTime();
4499     QList<QGraphicsItem *> selection;
4500     selection = m_scene->items(0, (item->track() + 1) * m_tracksHeight, sceneRect().width(), 2);
4501     selection.removeAll(item);
4502     for (int i = 0; i < selection.count(); i++) {
4503         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
4504         if (clip && clip->type() == TRANSITIONWIDGET) {
4505             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
4506             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
4507         }
4508     }
4509 }
4510
4511
4512 void CustomTrackView::loadGroups(const QDomNodeList groups)
4513 {
4514     for (int i = 0; i < groups.count(); i++) {
4515         QDomNodeList children = groups.at(i).childNodes();
4516         scene()->clearSelection();
4517         for (int nodeindex = 0; nodeindex < children.count(); nodeindex++) {
4518             QDomNode n = children.item(nodeindex);
4519             QDomElement elem = n.toElement();
4520             int pos = elem.attribute("position").toInt();
4521             int track = elem.attribute("track").toInt();
4522             if (elem.tagName() == "clipitem") {
4523                 ClipItem *clip = getClipItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
4524                 if (clip) clip->setSelected(true);
4525             } else {
4526                 Transition *clip = getTransitionItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
4527                 if (clip) clip->setSelected(true);
4528             }
4529         }
4530         groupSelectedItems(false, true);
4531     }
4532 }
4533
4534 void CustomTrackView::splitAudio()
4535 {
4536     resetSelectionGroup();
4537     QList<QGraphicsItem *> selection = scene()->selectedItems();
4538     if (selection.isEmpty()) {
4539         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4540         return;
4541     }
4542     QUndoCommand *splitCommand = new QUndoCommand();
4543     splitCommand->setText(i18n("Split audio"));
4544     for (int i = 0; i < selection.count(); i++) {
4545         if (selection.at(i)->type() == AVWIDGET) {
4546             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4547             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4548                 if (clip->parentItem()) {
4549                     emit displayMessage(i18n("Cannot split audio of grouped clips"), ErrorMessage);
4550                 } else {
4551                     new SplitAudioCommand(this, clip->track(), clip->startPos(), splitCommand);
4552                 }
4553             }
4554         }
4555     }
4556     m_commandStack->push(splitCommand);
4557 }
4558
4559 void CustomTrackView::doSplitAudio(const GenTime &pos, int track, bool split)
4560 {
4561     ClipItem *clip = getClipItemAt(pos, track);
4562     if (clip == NULL) {
4563         kDebug() << "// Cannot find clip to split!!!";
4564         return;
4565     }
4566     if (split) {
4567         int start = pos.frames(m_document->fps());
4568         int freetrack = m_document->tracksCount() - track - 1;
4569         for (; freetrack > 0; freetrack--) {
4570             kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
4571             if (m_document->trackInfoAt(freetrack - 1).type == AUDIOTRACK) {
4572                 kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
4573                 if (m_document->renderer()->mltTrackDuration(freetrack) < start || m_document->renderer()->mltGetSpaceLength(pos, freetrack, false) >= clip->cropDuration().frames(m_document->fps())) {
4574                     kDebug() << "FOUND SPACE ON TRK: " << freetrack;
4575                     break;
4576                 }
4577             }
4578         }
4579         kDebug() << "GOT TRK: " << track;
4580         if (freetrack == 0) {
4581             emit displayMessage(i18n("No empty space to put clip audio"), ErrorMessage);
4582         } else {
4583             ItemInfo info;
4584             info.startPos = clip->startPos();
4585             info.endPos = clip->endPos();
4586             info.cropStart = clip->cropStart();
4587             info.track = m_document->tracksCount() - freetrack;
4588             addClip(clip->xml(), clip->clipProducer(), info, clip->effectList());
4589             scene()->clearSelection();
4590             clip->setSelected(true);
4591             ClipItem *audioClip = getClipItemAt(start, info.track);
4592             if (audioClip) {
4593                 clip->setVideoOnly(true);
4594                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->videoProducer());
4595                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - info.track, start, clip->baseClip()->audioProducer(info.track));
4596                 audioClip->setSelected(true);
4597                 audioClip->setAudioOnly(true);
4598                 groupSelectedItems(false, true);
4599             }
4600         }
4601     } else {
4602         // unsplit clip: remove audio part and change video part to normal clip
4603         if (clip->parentItem() == NULL || clip->parentItem()->type() != GROUPWIDGET) {
4604             kDebug() << "//CANNOT FIND CLP GRP";
4605             return;
4606         }
4607         AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
4608         QList<QGraphicsItem *> children = grp->childItems();
4609         if (children.count() != 2) {
4610             kDebug() << "//SOMETHING IS WRONG WITH CLP GRP";
4611             return;
4612         }
4613         for (int i = 0; i < children.count(); i++) {
4614             if (children.at(i) != clip) {
4615                 ClipItem *clp = static_cast <ClipItem *>(children.at(i));
4616                 ItemInfo info = clip->info();
4617                 deleteClip(clp->info());
4618                 clip->setVideoOnly(false);
4619                 m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - info.track, info.startPos.frames(m_document->fps()), clip->baseClip()->producer(info.track));
4620                 break;
4621             }
4622         }
4623         clip->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
4624         m_document->clipManager()->removeGroup(grp);
4625         scene()->destroyItemGroup(grp);
4626     }
4627 }
4628
4629 void CustomTrackView::setVideoOnly()
4630 {
4631     resetSelectionGroup();
4632     QList<QGraphicsItem *> selection = scene()->selectedItems();
4633     if (selection.isEmpty()) {
4634         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4635         return;
4636     }
4637     QUndoCommand *videoCommand = new QUndoCommand();
4638     videoCommand->setText(i18n("Video only"));
4639     for (int i = 0; i < selection.count(); i++) {
4640         if (selection.at(i)->type() == AVWIDGET) {
4641             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4642             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4643                 if (clip->parentItem()) {
4644                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4645                 } else {
4646                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), true, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4647                 }
4648             }
4649         }
4650     }
4651     m_commandStack->push(videoCommand);
4652 }
4653
4654 void CustomTrackView::setAudioOnly()
4655 {
4656     resetSelectionGroup();
4657     QList<QGraphicsItem *> selection = scene()->selectedItems();
4658     if (selection.isEmpty()) {
4659         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4660         return;
4661     }
4662     QUndoCommand *videoCommand = new QUndoCommand();
4663     videoCommand->setText(i18n("Audio only"));
4664     for (int i = 0; i < selection.count(); i++) {
4665         if (selection.at(i)->type() == AVWIDGET) {
4666             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4667             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4668                 if (clip->parentItem()) {
4669                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4670                 } else {
4671                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, true, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4672                 }
4673             }
4674         }
4675     }
4676     m_commandStack->push(videoCommand);
4677 }
4678
4679 void CustomTrackView::setAudioAndVideo()
4680 {
4681     resetSelectionGroup();
4682     QList<QGraphicsItem *> selection = scene()->selectedItems();
4683     if (selection.isEmpty()) {
4684         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
4685         return;
4686     }
4687     QUndoCommand *videoCommand = new QUndoCommand();
4688     videoCommand->setText(i18n("Audio and Video"));
4689     for (int i = 0; i < selection.count(); i++) {
4690         if (selection.at(i)->type() == AVWIDGET) {
4691             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
4692             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
4693                 if (clip->parentItem()) {
4694                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
4695                 } else {
4696                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
4697                 }
4698             }
4699         }
4700     }
4701     m_commandStack->push(videoCommand);
4702 }
4703
4704 void CustomTrackView::doChangeClipType(const GenTime &pos, int track, bool videoOnly, bool audioOnly)
4705 {
4706     ClipItem *clip = getClipItemAt(pos, track);
4707     if (clip == NULL) {
4708         kDebug() << "// Cannot find clip to split!!!";
4709         return;
4710     }
4711     if (videoOnly) {
4712         int start = pos.frames(m_document->fps());
4713         clip->setVideoOnly(true);
4714         clip->setAudioOnly(false);
4715         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->videoProducer());
4716     } else if (audioOnly) {
4717         int start = pos.frames(m_document->fps());
4718         clip->setAudioOnly(true);
4719         clip->setVideoOnly(false);
4720         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->audioProducer(track));
4721     } else {
4722         int start = pos.frames(m_document->fps());
4723         clip->setAudioOnly(false);
4724         clip->setVideoOnly(false);
4725         m_document->renderer()->mltUpdateClipProducer(m_document->tracksCount() - track, start, clip->baseClip()->producer(track));
4726     }
4727     clip->update();
4728     setDocumentModified();
4729 }
4730
4731 void CustomTrackView::updateClipTypeActions(ClipItem *clip)
4732 {
4733     if (clip == NULL || (clip->clipType() != AV && clip->clipType() != PLAYLIST)) {
4734         m_clipTypeGroup->setEnabled(false);
4735     } else {
4736         m_clipTypeGroup->setEnabled(true);
4737         QList <QAction *> actions = m_clipTypeGroup->actions();
4738         QString lookup;
4739         if (clip->isAudioOnly()) lookup = "clip_audio_only";
4740         else if (clip->isVideoOnly()) lookup = "clip_video_only";
4741         else  lookup = "clip_audio_and_video";
4742         for (int i = 0; i < actions.count(); i++) {
4743             if (actions.at(i)->data().toString() == lookup) {
4744                 actions.at(i)->setChecked(true);
4745                 break;
4746             }
4747         }
4748     }
4749 }
4750
4751 void CustomTrackView::reloadTransitionLumas()
4752 {
4753     QString lumaNames;
4754     QString lumaFiles;
4755     QDomElement lumaTransition = MainWindow::transitions.getEffectByTag("luma", "luma");
4756     QDomNodeList params = lumaTransition.elementsByTagName("parameter");
4757     for (int i = 0; i < params.count(); i++) {
4758         QDomElement e = params.item(i).toElement();
4759         if (e.attribute("tag") == "resource") {
4760             lumaNames = e.attribute("paramlistdisplay");
4761             lumaFiles = e.attribute("paramlist");
4762             break;
4763         }
4764     }
4765
4766     QList<QGraphicsItem *> itemList = items();
4767     Transition *transitionitem;
4768     QDomElement transitionXml;
4769     for (int i = 0; i < itemList.count(); i++) {
4770         if (itemList.at(i)->type() == TRANSITIONWIDGET) {
4771             transitionitem = static_cast <Transition*>(itemList.at(i));
4772             transitionXml = transitionitem->toXML();
4773             if (transitionXml.attribute("id") == "luma" && transitionXml.attribute("tag") == "luma") {
4774                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
4775                 for (int i = 0; i < params.count(); i++) {
4776                     QDomElement e = params.item(i).toElement();
4777                     if (e.attribute("tag") == "resource") {
4778                         e.setAttribute("paramlistdisplay", lumaNames);
4779                         e.setAttribute("paramlist", lumaFiles);
4780                         break;
4781                     }
4782                 }
4783             }
4784             if (transitionXml.attribute("id") == "composite" && transitionXml.attribute("tag") == "composite") {
4785                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
4786                 for (int i = 0; i < params.count(); i++) {
4787                     QDomElement e = params.item(i).toElement();
4788                     if (e.attribute("tag") == "luma") {
4789                         e.setAttribute("paramlistdisplay", lumaNames);
4790                         e.setAttribute("paramlist", lumaFiles);
4791                         break;
4792                     }
4793                 }
4794             }
4795         }
4796     }
4797     emit transitionItemSelected(NULL);
4798 }
4799
4800 #include "customtrackview.moc"