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 "docclipbase.h"
  23 #include "clipitem.h"
  24 #include "definitions.h"
  25 #include "commands/moveclipcommand.h"
  26 #include "commands/movetransitioncommand.h"
  27 #include "commands/resizeclipcommand.h"
  28 #include "commands/editguidecommand.h"
  29 #include "commands/addtimelineclipcommand.h"
  30 #include "commands/addeffectcommand.h"
  31 #include "commands/editeffectcommand.h"
  32 #include "commands/moveeffectcommand.h"
  33 #include "commands/addtransitioncommand.h"
  34 #include "commands/edittransitioncommand.h"
  35 #include "commands/editkeyframecommand.h"
  36 #include "commands/changespeedcommand.h"
  37 #include "commands/addmarkercommand.h"
  38 #include "commands/razorclipcommand.h"
  39 #include "kdenlivesettings.h"
  40 #include "transition.h"
  41 #include "clipmanager.h"
  42 #include "renderer.h"
  43 #include "markerdialog.h"
  44 #include "mainwindow.h"
  45 #include "ui_keyframedialog_ui.h"
  46 #include "clipdurationdialog.h"
  47 #include "abstractgroupitem.h"
  48 #include "commands/insertspacecommand.h"
  49 #include "spacerdialog.h"
  50 #include "commands/addtrackcommand.h"
  51 #include "commands/changeeffectstatecommand.h"
  52 #include "commands/movegroupcommand.h"
  53 #include "ui_addtrack_ui.h"
  54 #include "initeffects.h"
  55 #include "commands/locktrackcommand.h"
  56 #include "commands/groupclipscommand.h"
  57 #include "commands/splitaudiocommand.h"
  58 #include "commands/changecliptypecommand.h"
  59 #include "trackdialog.h"
  60 #include "tracksconfigdialog.h"
  61 #include "commands/configtrackscommand.h"
  62 #include "commands/rebuildgroupcommand.h"
  63 #include "commands/razorgroupcommand.h"
  64 #include "profilesdialog.h"
  65
  66 #include "lib/audio/audioEnvelope.h"
  67 #include "lib/audio/audioCorrelation.h"
  68
  69 #include <KDebug>
  70 #include <KLocale>
  71 #include <KUrl>
  72 #include <KIcon>
  73 #include <KCursor>
  74 #include <KMessageBox>
  75 #include <KIO/NetAccess>
  76
  77 #include <QMouseEvent>
  78 #include <QStylePainter>
  79 #include <QGraphicsItem>
  80 #include <QDomDocument>
  81 #include <QScrollBar>
  82 #include <QApplication>
  83 #include <QInputDialog>
  84
  85
  86 #if QT_VERSION >= 0x040600
  87 #include <QGraphicsDropShadowEffect>
  88 #endif
  89
  90 //#define DEBUG
  91
  92 bool sortGuidesList(const Guide *g1 , const Guide *g2)
  93 {
  94     return (*g1).position() < (*g2).position();
  95 }
  96
  97
  98 //TODO:
  99 // disable animation if user asked it in KDE's global settings
 100 // http://lists.kde.org/?l=kde-commits&m=120398724717624&w=2
 101 // needs something like below (taken from dolphin)
 102 // #include <kglobalsettings.h>
 103 // const bool animate = KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects;
 104 // const int duration = animate ? 1500 : 1;
 105
 106 CustomTrackView::CustomTrackView(KdenliveDoc *doc, CustomTrackScene* projectscene, QWidget *parent) :
 107     QGraphicsView(projectscene, parent),
 108     m_tracksHeight(KdenliveSettings::trackheight()),
 109     m_projectDuration(0),
 110     m_cursorPos(0),
 111     m_document(doc),
 112     m_scene(projectscene),
 113     m_cursorLine(NULL),
 114     m_operationMode(NONE),
 115     m_moveOpMode(NONE),
 116     m_dragItem(NULL),
 117     m_dragGuide(NULL),
 118     m_visualTip(NULL),
 119     m_animation(NULL),
 120     m_clickPoint(),
 121     m_autoScroll(KdenliveSettings::autoscroll()),
 122     m_pasteEffectsAction(NULL),
 123     m_ungroupAction(NULL),
 124     m_scrollOffset(0),
 125     m_clipDrag(false),
 126     m_findIndex(0),
 127     m_tool(SELECTTOOL),
 128     m_copiedItems(),
 129     m_menuPosition(),
 130     m_blockRefresh(false),
 131     m_selectionGroup(NULL),
 132     m_selectedTrack(0),
 133     m_audioCorrelator(NULL),
 134     m_audioAlignmentReference(NULL),
 135     m_controlModifier(false)
 136 {
 137     if (doc) {
 138         m_commandStack = doc->commandStack();
 139     } else {
 140         m_commandStack = NULL;
 141     }
 142     m_ct = 0;
 143     setMouseTracking(true);
 144     setAcceptDrops(true);
 145     setFrameShape(QFrame::NoFrame);
 146     setLineWidth(0);
 147     //setCacheMode(QGraphicsView::CacheBackground);
 148     setAutoFillBackground(false);
 149     setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
 150     setContentsMargins(0, 0, 0, 0);
 151
 152     m_activeTrackBrush = KStatefulBrush(KColorScheme::View, KColorScheme::ActiveBackground, KSharedConfig::openConfig(KdenliveSettings::colortheme()));
 153
 154     m_animationTimer = new QTimeLine(800);
 155     m_animationTimer->setFrameRange(0, 5);
 156     m_animationTimer->setUpdateInterval(100);
 157     m_animationTimer->setLoopCount(0);
 158
 159     m_tipColor = QColor(0, 192, 0, 200);
 160     m_tipPen.setColor(QColor(255, 255, 255, 100));
 161     m_tipPen.setWidth(3);
 162
 163     const int maxHeight = m_tracksHeight * m_document->tracksCount();
 164     setSceneRect(0, 0, sceneRect().width(), maxHeight);
 165     verticalScrollBar()->setMaximum(maxHeight);
 166     verticalScrollBar()->setTracking(true);
 167     // repaint guides when using vertical scroll
 168     connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(slotRefreshGuides()));
 169
 170     m_cursorLine = projectscene->addLine(0, 0, 0, maxHeight);
 171     m_cursorLine->setZValue(1000);
 172     QPen pen1 = QPen();
 173     pen1.setWidth(1);
 174     pen1.setColor(palette().text().color());
 175     m_cursorLine->setPen(pen1);
 176     m_cursorLine->setFlag(QGraphicsItem::ItemIgnoresTransformations, true);
 177
 178     connect(&m_scrollTimer, SIGNAL(timeout()), this, SLOT(slotCheckMouseScrolling()));
 179     m_scrollTimer.setInterval(100);
 180     m_scrollTimer.setSingleShot(true);
 181
 182     connect(&m_thumbsTimer, SIGNAL(timeout()), this, SLOT(slotFetchNextThumbs()));
 183     m_thumbsTimer.setInterval(500);
 184     m_thumbsTimer.setSingleShot(true);
 185
 186     KIcon razorIcon("edit-cut");
 187     m_razorCursor = QCursor(razorIcon.pixmap(22, 22));
 188
 189     KIcon spacerIcon("kdenlive-spacer-tool");
 190     m_spacerCursor = QCursor(spacerIcon.pixmap(22, 22));
 191 }
 192
 193 CustomTrackView::~CustomTrackView()
 194 {
 195     qDeleteAll(m_guides);
 196     m_guides.clear();
 197     m_waitingThumbs.clear();
 198     delete m_animationTimer;
 199 }
 200
 201 //virtual
 202 void CustomTrackView::keyPressEvent(QKeyEvent * event)
 203 {
 204     if (event->key() == Qt::Key_Up) {
 205         slotTrackUp();
 206         event->accept();
 207     } else if (event->key() == Qt::Key_Down) {
 208         slotTrackDown();
 209         event->accept();
 210     } else QWidget::keyPressEvent(event);
 211 }
 212
 213 void CustomTrackView::setDocumentModified()
 214 {
 215     m_document->setModified(true);
 216 }
 217
 218 void CustomTrackView::setContextMenu(QMenu *timeline, QMenu *clip, QMenu *transition, QActionGroup *clipTypeGroup, QMenu *markermenu)
 219 {
 220     m_timelineContextMenu = timeline;
 221     m_timelineContextClipMenu = clip;
 222     m_clipTypeGroup = clipTypeGroup;
 223     connect(m_timelineContextMenu, SIGNAL(aboutToHide()), this, SLOT(slotResetMenuPosition()));
 224
 225     m_markerMenu = new QMenu(i18n("Go to marker..."), this);
 226     m_markerMenu->setEnabled(false);
 227     markermenu->addMenu(m_markerMenu);
 228     connect(m_markerMenu, SIGNAL(triggered(QAction *)), this, SLOT(slotGoToMarker(QAction *)));
 229     QList <QAction *> list = m_timelineContextClipMenu->actions();
 230     for (int i = 0; i < list.count(); i++) {
 231         if (list.at(i)->data().toString() == "paste_effects") m_pasteEffectsAction = list.at(i);
 232         else if (list.at(i)->data().toString() == "ungroup_clip") m_ungroupAction = list.at(i);
 233     }
 234
 235     m_timelineContextTransitionMenu = transition;
 236     list = m_timelineContextTransitionMenu->actions();
 237     for (int i = 0; i < list.count(); i++) {
 238         if (list.at(i)->data().toString() == "auto") {
 239             m_autoTransition = list.at(i);
 240             break;
 241         }
 242     }
 243
 244     m_timelineContextMenu->addSeparator();
 245     m_deleteGuide = new KAction(KIcon("edit-delete"), i18n("Delete Guide"), this);
 246     connect(m_deleteGuide, SIGNAL(triggered()), this, SLOT(slotDeleteTimeLineGuide()));
 247     m_timelineContextMenu->addAction(m_deleteGuide);
 248
 249     m_editGuide = new KAction(KIcon("document-properties"), i18n("Edit Guide"), this);
 250     connect(m_editGuide, SIGNAL(triggered()), this, SLOT(slotEditTimeLineGuide()));
 251     m_timelineContextMenu->addAction(m_editGuide);
 252 }
 253
 254 void CustomTrackView::slotDoResetMenuPosition()
 255 {
 256     m_menuPosition = QPoint();
 257 }
 258
 259 void CustomTrackView::slotResetMenuPosition()
 260 {
 261     // after a short time (so that the action is triggered / or menu is closed, we reset the menu pos
 262     QTimer::singleShot(300, this, SLOT(slotDoResetMenuPosition()));
 263 }
 264
 265 void CustomTrackView::checkAutoScroll()
 266 {
 267     m_autoScroll = KdenliveSettings::autoscroll();
 268 }
 269
 270 /*sQList <TrackInfo> CustomTrackView::tracksList() const {
 271     return m_scene->m_tracksList;
 272 }*/
 273
 274
 275 int CustomTrackView::getFrameWidth()
 276 {
 277     return (int) (m_tracksHeight * m_document->mltProfile().display_aspect_num / m_document->mltProfile().display_aspect_den + 0.5);
 278 }
 279
 280 void CustomTrackView::updateSceneFrameWidth()
 281 {
 282     int frameWidth = getFrameWidth();
 283     QList<QGraphicsItem *> itemList = items();
 284     ClipItem *item;
 285     for (int i = 0; i < itemList.count(); i++) {
 286         if (itemList.at(i)->type() == AVWIDGET) {
 287             item = (ClipItem*) itemList.at(i);
 288             item->resetFrameWidth(frameWidth);
 289             item->resetThumbs(true);
 290         }
 291     }
 292 }
 293
 294 bool CustomTrackView::checkTrackHeight()
 295 {
 296     if (m_tracksHeight == KdenliveSettings::trackheight()) return false;
 297     m_tracksHeight = KdenliveSettings::trackheight();
 298     emit trackHeightChanged();
 299     QList<QGraphicsItem *> itemList = items();
 300     ClipItem *item;
 301     Transition *transitionitem;
 302     int frameWidth = getFrameWidth();
 303     bool snap = KdenliveSettings::snaptopoints();
 304     KdenliveSettings::setSnaptopoints(false);
 305     for (int i = 0; i < itemList.count(); i++) {
 306         if (itemList.at(i)->type() == AVWIDGET) {
 307             item = (ClipItem*) itemList.at(i);
 308             item->setRect(0, 0, item->rect().width(), m_tracksHeight - 1);
 309             item->setPos((qreal) item->startPos().frames(m_document->fps()), (qreal) item->track() * m_tracksHeight + 1);
 310             item->resetFrameWidth(frameWidth);
 311             item->resetThumbs(true);
 312         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
 313             transitionitem = (Transition*) itemList.at(i);
 314             transitionitem->setRect(0, 0, transitionitem->rect().width(), m_tracksHeight / 3 * 2 - 1);
 315             transitionitem->setPos((qreal) transitionitem->startPos().frames(m_document->fps()), (qreal) transitionitem->track() * m_tracksHeight + m_tracksHeight / 3 * 2);
 316         }
 317     }
 318     double newHeight = m_tracksHeight * m_document->tracksCount() * matrix().m22();
 319     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), newHeight - 1);
 320
 321     for (int i = 0; i < m_guides.count(); i++) {
 322         QLineF l = m_guides.at(i)->line();
 323         l.setP2(QPointF(l.x2(), newHeight));
 324         m_guides.at(i)->setLine(l);
 325     }
 326
 327     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_document->tracksCount());
 328 //     verticalScrollBar()->setMaximum(m_tracksHeight * m_document->tracksCount());
 329     KdenliveSettings::setSnaptopoints(snap);
 330     viewport()->update();
 331     return true;
 332 }
 333
 334 /** Zoom or move viewport on mousewheel
 335  *
 336  * If mousewheel+Ctrl, zooms in/out on the timeline.
 337  *
 338  * With Ctrl, moves viewport towards end of timeline if down/back,
 339  * opposite on up/forward.
 340  *
 341  * See also http://www.kdenlive.org/mantis/view.php?id=265 */
 342 void CustomTrackView::wheelEvent(QWheelEvent * e)
 343 {
 344     if (e->modifiers() == Qt::ControlModifier) {
 345         if (e->delta() > 0) emit zoomIn();
 346         else emit zoomOut();
 347     } else {
 348         if (e->delta() <= 0) horizontalScrollBar()->setValue(horizontalScrollBar()->value() + horizontalScrollBar()->singleStep());
 349         else  horizontalScrollBar()->setValue(horizontalScrollBar()->value() - horizontalScrollBar()->singleStep());
 350     }
 351 }
 352
 353 int CustomTrackView::getPreviousVideoTrack(int track)
 354 {
 355     track = m_document->tracksCount() - track - 1;
 356     track --;
 357     for (int i = track; i > -1; i--) {
 358         if (m_document->trackInfoAt(i).type == VIDEOTRACK) return i + 1;
 359     }
 360     return 0;
 361 }
 362
 363
 364 void CustomTrackView::slotFetchNextThumbs()
 365 {
 366     if (!m_waitingThumbs.isEmpty()) {
 367         ClipItem *item = m_waitingThumbs.takeFirst();
 368         while (item == NULL && !m_waitingThumbs.isEmpty()) {
 369             item = m_waitingThumbs.takeFirst();
 370         }
 371         if (item) item->slotFetchThumbs();
 372         if (!m_waitingThumbs.isEmpty()) m_thumbsTimer.start();
 373     }
 374 }
 375
 376 void CustomTrackView::slotCheckMouseScrolling()
 377 {
 378     if (m_scrollOffset == 0) {
 379         m_scrollTimer.stop();
 380         return;
 381     }
 382     horizontalScrollBar()->setValue(horizontalScrollBar()->value() + m_scrollOffset);
 383     m_scrollTimer.start();
 384 }
 385
 386 void CustomTrackView::slotCheckPositionScrolling()
 387 {
 388     // If mouse is at a border of the view, scroll
 389     if (m_moveOpMode != SEEK) return;
 390     if (mapFromScene(m_cursorPos, 0).x() < 3) {
 391         horizontalScrollBar()->setValue(horizontalScrollBar()->value() - 2);
 392         QTimer::singleShot(200, this, SLOT(slotCheckPositionScrolling()));
 393         setCursorPos(mapToScene(QPoint(-2, 0)).x());
 394     } else if (viewport()->width() - 3 < mapFromScene(m_cursorPos + 1, 0).x()) {
 395         horizontalScrollBar()->setValue(horizontalScrollBar()->value() + 2);
 396         setCursorPos(mapToScene(QPoint(viewport()->width(), 0)).x() + 1);
 397         QTimer::singleShot(200, this, SLOT(slotCheckPositionScrolling()));
 398     }
 399 }
 400
 401
 402 // virtual
 403 void CustomTrackView::mouseMoveEvent(QMouseEvent * event)
 404 {
 405     int pos = event->x();
 406     int mappedXPos = qMax((int)(mapToScene(event->pos()).x() + 0.5), 0);
 407
 408     double snappedPos = getSnapPointForPos(mappedXPos);
 409     emit mousePosition(mappedXPos);
 410
 411     if (event->buttons() & Qt::MidButton) return;
 412     if (dragMode() == QGraphicsView::RubberBandDrag || (event->modifiers() == Qt::ControlModifier && m_tool != SPACERTOOL && m_operationMode != RESIZESTART && m_operationMode != RESIZEEND)) {
 413         event->setAccepted(true);
 414         m_moveOpMode = NONE;
 415         QGraphicsView::mouseMoveEvent(event);
 416         return;
 417     }
 418
 419     if (event->buttons() != Qt::NoButton) {
 420         bool move = (event->pos() - m_clickEvent).manhattanLength() >= QApplication::startDragDistance();
 421         if (m_dragItem && m_tool == SELECTTOOL) {
 422             if (m_operationMode == MOVE && move) {
 423                 QGraphicsView::mouseMoveEvent(event);
 424                 // If mouse is at a border of the view, scroll
 425                 if (pos < 5) {
 426                     m_scrollOffset = -30;
 427                     m_scrollTimer.start();
 428                 } else if (viewport()->width() - pos < 10) {
 429                     m_scrollOffset = 30;
 430                     m_scrollTimer.start();
 431                 } else if (m_scrollTimer.isActive()) {
 432                     m_scrollTimer.stop();
 433                 }
 434             } else if (m_operationMode == RESIZESTART && move) {
 435                 m_document->renderer()->pause();
 436                 if (!m_controlModifier && m_dragItem->type() == AVWIDGET && m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
 437                     AbstractGroupItem *parent = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
 438                     if (parent)
 439                         parent->resizeStart((int)(snappedPos - m_dragItemInfo.startPos.frames(m_document->fps())));
 440                 } else {
 441                     m_dragItem->resizeStart((int)(snappedPos));
 442                 }
 443                 QString crop = m_document->timecode().getDisplayTimecode(m_dragItem->cropStart(), KdenliveSettings::frametimecode());
 444                 QString duration = m_document->timecode().getDisplayTimecode(m_dragItem->cropDuration(), KdenliveSettings::frametimecode());
 445                 QString offset = m_document->timecode().getDisplayTimecode(m_dragItem->cropStart() - m_dragItemInfo.cropStart, KdenliveSettings::frametimecode());
 446                 emit displayMessage(i18n("Crop from start:") + ' ' + crop + ' ' + i18n("Duration:") + ' ' + duration + ' ' + i18n("Offset:") + ' ' + offset, InformationMessage);
 447             } else if (m_operationMode == RESIZEEND && move) {
 448                 m_document->renderer()->pause();
 449                 if (!m_controlModifier && m_dragItem->type() == AVWIDGET && m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
 450                     AbstractGroupItem *parent = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
 451                     if (parent)
 452                         parent->resizeEnd((int)(snappedPos - m_dragItemInfo.endPos.frames(m_document->fps())));
 453                 } else {
 454                     m_dragItem->resizeEnd((int)(snappedPos));
 455                 }
 456                 QString duration = m_document->timecode().getDisplayTimecode(m_dragItem->cropDuration(), KdenliveSettings::frametimecode());
 457                 QString offset = m_document->timecode().getDisplayTimecode(m_dragItem->cropDuration() - m_dragItemInfo.cropDuration, KdenliveSettings::frametimecode());
 458                 emit displayMessage(i18n("Duration:") + ' ' + duration + ' ' + i18n("Offset:") + ' ' + offset, InformationMessage);
 459             } else if (m_operationMode == FADEIN && move) {
 460                 ((ClipItem*) m_dragItem)->setFadeIn((int)(mappedXPos - m_dragItem->startPos().frames(m_document->fps())));
 461             } else if (m_operationMode == FADEOUT && move) {
 462                 ((ClipItem*) m_dragItem)->setFadeOut((int)(m_dragItem->endPos().frames(m_document->fps()) - mappedXPos));
 463             } else if (m_operationMode == KEYFRAME && move) {
 464                 GenTime keyFramePos = GenTime(mappedXPos, m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
 465                 double pos = mapToScene(event->pos()).toPoint().y();
 466                 QRectF br = m_dragItem->sceneBoundingRect();
 467                 double maxh = 100.0 / br.height();
 468                 pos = (br.bottom() - pos) * maxh;
 469                 m_dragItem->updateKeyFramePos(keyFramePos, pos);
 470                 QString position = m_document->timecode().getDisplayTimecodeFromFrames(m_dragItem->editedKeyFramePos(), KdenliveSettings::frametimecode());
 471                 emit displayMessage(position + " : " + QString::number(m_dragItem->editedKeyFrameValue()), InformationMessage);
 472             }
 473             removeTipAnimation();
 474             return;
 475         } else if (m_operationMode == MOVEGUIDE) {
 476             removeTipAnimation();
 477             QGraphicsView::mouseMoveEvent(event);
 478             return;
 479         } else if (m_operationMode == SPACER && move && m_selectionGroup) {
 480             // spacer tool
 481             snappedPos = getSnapPointForPos(mappedXPos + m_spacerOffset);
 482             if (snappedPos < 0) snappedPos = 0;
 483
 484             // Make sure there is no collision
 485             QList<QGraphicsItem *> children = m_selectionGroup->childItems();
 486             QPainterPath shape = m_selectionGroup->clipGroupShape(QPointF(snappedPos - m_selectionGroup->sceneBoundingRect().left(), 0));
 487             QList<QGraphicsItem*> collidingItems = scene()->items(shape, Qt::IntersectsItemShape);
 488             collidingItems.removeAll(m_selectionGroup);
 489             for (int i = 0; i < children.count(); i++) {
 490                 if (children.at(i)->type() == GROUPWIDGET) {
 491                     QList<QGraphicsItem *> subchildren = children.at(i)->childItems();
 492                     for (int j = 0; j < subchildren.count(); j++)
 493                         collidingItems.removeAll(subchildren.at(j));
 494                 }
 495                 collidingItems.removeAll(children.at(i));
 496             }
 497             bool collision = false;
 498             int offset = 0;
 499             for (int i = 0; i < collidingItems.count(); i++) {
 500                 if (!collidingItems.at(i)->isEnabled()) continue;
 501                 if (collidingItems.at(i)->type() == AVWIDGET && snappedPos < m_selectionGroup->sceneBoundingRect().left()) {
 502                     AbstractClipItem *item = static_cast <AbstractClipItem *>(collidingItems.at(i));
 503                     // Moving backward, determine best pos
 504                     QPainterPath clipPath;
 505                     clipPath.addRect(item->sceneBoundingRect());
 506                     QPainterPath res = shape.intersected(clipPath);
 507                     offset = qMax(offset, (int)(res.boundingRect().width() + 0.5));
 508                 }
 509             }
 510             snappedPos += offset;
 511             // make sure we have no collision
 512             shape = m_selectionGroup->clipGroupShape(QPointF(snappedPos - m_selectionGroup->sceneBoundingRect().left(), 0));
 513             collidingItems = scene()->items(shape, Qt::IntersectsItemShape);
 514             collidingItems.removeAll(m_selectionGroup);
 515             for (int i = 0; i < children.count(); i++) {
 516                 if (children.at(i)->type() == GROUPWIDGET) {
 517                     QList<QGraphicsItem *> subchildren = children.at(i)->childItems();
 518                     for (int j = 0; j < subchildren.count(); j++)
 519                         collidingItems.removeAll(subchildren.at(j));
 520                 }
 521                 collidingItems.removeAll(children.at(i));
 522             }
 523
 524             for (int i = 0; i < collidingItems.count(); i++) {
 525                 if (!collidingItems.at(i)->isEnabled()) continue;
 526                 if (collidingItems.at(i)->type() == AVWIDGET) {
 527                     collision = true;
 528                     break;
 529                 }
 530             }
 531
 532
 533             if (!collision) {
 534                 // Check transitions
 535                 shape = m_selectionGroup->transitionGroupShape(QPointF(snappedPos - m_selectionGroup->sceneBoundingRect().left(), 0));
 536                 collidingItems = scene()->items(shape, Qt::IntersectsItemShape);
 537                 collidingItems.removeAll(m_selectionGroup);
 538                 for (int i = 0; i < children.count(); i++) {
 539                     if (children.at(i)->type() == GROUPWIDGET) {
 540                         QList<QGraphicsItem *> subchildren = children.at(i)->childItems();
 541                         for (int j = 0; j < subchildren.count(); j++)
 542                             collidingItems.removeAll(subchildren.at(j));
 543                     }
 544                     collidingItems.removeAll(children.at(i));
 545                 }
 546                 offset = 0;
 547
 548                 for (int i = 0; i < collidingItems.count(); i++) {
 549                     if (collidingItems.at(i)->type() == TRANSITIONWIDGET && snappedPos < m_selectionGroup->sceneBoundingRect().left()) {
 550                         AbstractClipItem *item = static_cast <AbstractClipItem *>(collidingItems.at(i));
 551                         // Moving backward, determine best pos
 552                         QPainterPath clipPath;
 553                         clipPath.addRect(item->sceneBoundingRect());
 554                         QPainterPath res = shape.intersected(clipPath);
 555                         offset = qMax(offset, (int)(res.boundingRect().width() + 0.5));
 556                     }
 557                 }
 558
 559                 snappedPos += offset;
 560                 // make sure we have no collision
 561                 shape = m_selectionGroup->transitionGroupShape(QPointF(snappedPos - m_selectionGroup->sceneBoundingRect().left(), 0));
 562                 collidingItems = scene()->items(shape, Qt::IntersectsItemShape);
 563                 collidingItems.removeAll(m_selectionGroup);
 564                 for (int i = 0; i < children.count(); i++) {
 565                     if (children.at(i)->type() == GROUPWIDGET) {
 566                         QList<QGraphicsItem *> subchildren = children.at(i)->childItems();
 567                         for (int j = 0; j < subchildren.count(); j++)
 568                             collidingItems.removeAll(subchildren.at(j));
 569                     }
 570                     collidingItems.removeAll(children.at(i));
 571                 }
 572                 for (int i = 0; i < collidingItems.count(); i++) {
 573                     if (collidingItems.at(i)->type() == TRANSITIONWIDGET) {
 574                         collision = true;
 575                         break;
 576                     }
 577                 }
 578             }
 579
 580             if (!collision)
 581                 m_selectionGroup->translate(snappedPos - m_selectionGroup->sceneBoundingRect().left(), 0);
 582             //m_selectionGroup->setPos(mappedXPos + (((int) m_selectionGroup->boundingRect().topLeft().x() + 0.5) - mappedClick) , m_selectionGroup->pos().y());
 583         }
 584     }
 585
 586     if (m_tool == RAZORTOOL) {
 587         setCursor(m_razorCursor);
 588         //QGraphicsView::mouseMoveEvent(event);
 589         //return;
 590     } else if (m_tool == SPACERTOOL) {
 591         setCursor(m_spacerCursor);
 592         return;
 593     }
 594
 595     QList<QGraphicsItem *> itemList = items(event->pos());
 596     QGraphicsRectItem *item = NULL;
 597     OPERATIONTYPE opMode = NONE;
 598
 599     if (itemList.count() == 1 && itemList.at(0)->type() == GUIDEITEM) {
 600         opMode = MOVEGUIDE;
 601     } else for (int i = 0; i < itemList.count(); i++) {
 602             if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
 603                 item = (QGraphicsRectItem*) itemList.at(i);
 604                 break;
 605             }
 606         }
 607
 608     if (item && event->buttons() == Qt::NoButton) {
 609         AbstractClipItem *clip = static_cast <AbstractClipItem*>(item);
 610         if (m_tool == RAZORTOOL) {
 611             // razor tool over a clip, display current frame in monitor
 612             if (false && !m_blockRefresh && item->type() == AVWIDGET) {
 613                 //TODO: solve crash when showing frame when moving razor over clip
 614                 emit showClipFrame(((ClipItem *) item)->baseClip(), QPoint(), false, mappedXPos - (clip->startPos() - clip->cropStart()).frames(m_document->fps()));
 615             }
 616             event->accept();
 617             return;
 618         }
 619
 620         if (m_selectionGroup && clip->parentItem() == m_selectionGroup) {
 621             // all other modes break the selection, so the user probably wants to move it
 622             opMode = MOVE;
 623         } else {
 624             opMode = clip->operationMode(mapToScene(event->pos()));
 625         }
 626
 627         const double size = 5;
 628         if (opMode == m_moveOpMode) {
 629             QGraphicsView::mouseMoveEvent(event);
 630             return;
 631         } else {
 632             removeTipAnimation();
 633         }
 634         m_moveOpMode = opMode;
 635         setTipAnimation(clip, opMode, size);
 636         ClipItem *ci = NULL;
 637         if (item->type() == AVWIDGET)
 638             ci = static_cast <ClipItem *>(item);
 639         QString message;
 640         if (opMode == MOVE) {
 641             setCursor(Qt::OpenHandCursor);
 642             if (ci) {
 643                 message = ci->clipName() + i18n(":");
 644                 message.append(i18n(" Position:") + m_document->timecode().getDisplayTimecode(ci->info().startPos, KdenliveSettings::frametimecode()));
 645                 message.append(i18n(" Duration:") + m_document->timecode().getDisplayTimecode(ci->cropDuration(),  KdenliveSettings::frametimecode()));
 646                 if (clip->parentItem() && clip->parentItem()->type() == GROUPWIDGET) {
 647                     AbstractGroupItem *parent = static_cast <AbstractGroupItem *>(clip->parentItem());
 648                     if (clip->parentItem() == m_selectionGroup)
 649                         message.append(i18n(" Selection duration:"));
 650                     else
 651                         message.append(i18n(" Group duration:"));
 652                     message.append(m_document->timecode().getDisplayTimecode(parent->duration(), KdenliveSettings::frametimecode()));
 653                     if (parent->parentItem() && parent->parentItem()->type() == GROUPWIDGET) {
 654                         AbstractGroupItem *parent2 = static_cast <AbstractGroupItem *>(parent->parentItem());
 655                         message.append(i18n(" Selection duration:") + m_document->timecode().getDisplayTimecode(parent2->duration(), KdenliveSettings::frametimecode()));
 656                     }
 657                 }
 658             }
 659         } else if (opMode == RESIZESTART) {
 660             setCursor(KCursor("left_side", Qt::SizeHorCursor));
 661             if (ci)
 662                 message = i18n("Crop from start: ") + m_document->timecode().getDisplayTimecode(ci->cropStart(), KdenliveSettings::frametimecode());
 663             if (item->type() == AVWIDGET && item->parentItem() && item->parentItem() != m_selectionGroup)
 664                 message.append(i18n("Use Ctrl to resize only current item, otherwise all items in this group will be resized at once."));
 665         } else if (opMode == RESIZEEND) {
 666             setCursor(KCursor("right_side", Qt::SizeHorCursor));
 667             if (ci)
 668                 message = i18n("Duration: ") + m_document->timecode().getDisplayTimecode(ci->cropDuration(), KdenliveSettings::frametimecode());
 669             if (item->type() == AVWIDGET && item->parentItem() && item->parentItem() != m_selectionGroup)
 670                 message.append(i18n("Use Ctrl to resize only current item, otherwise all items in this group will be resized at once."));
 671         } else if (opMode == FADEIN || opMode == FADEOUT) {
 672             setCursor(Qt::PointingHandCursor);
 673             if (ci && opMode == FADEIN && ci->fadeIn()) {
 674                 message = i18n("Fade in duration: ");
 675                 message.append(m_document->timecode().getDisplayTimecodeFromFrames(ci->fadeIn(), KdenliveSettings::frametimecode()));
 676             } else if (ci && opMode == FADEOUT && ci->fadeOut()) {
 677                 message = i18n("Fade out duration: ");
 678                 message.append(m_document->timecode().getDisplayTimecodeFromFrames(ci->fadeOut(), KdenliveSettings::frametimecode()));
 679             } else {
 680                 message = i18n("Drag to add or resize a fade effect.");
 681             }
 682         } else if (opMode == TRANSITIONSTART || opMode == TRANSITIONEND) {
 683             setCursor(Qt::PointingHandCursor);
 684             message = i18n("Click to add a transition.");
 685         } else if (opMode == KEYFRAME) {
 686             setCursor(Qt::PointingHandCursor);
 687             emit displayMessage(i18n("Move keyframe above or below clip to remove it, double click to add a new one."), InformationMessage);
 688         }
 689
 690         if (!message.isEmpty())
 691             emit displayMessage(message, InformationMessage);
 692     } // no clip under mouse
 693     else if (m_tool == RAZORTOOL) {
 694         event->accept();
 695         return;
 696     } else if (opMode == MOVEGUIDE) {
 697         m_moveOpMode = opMode;
 698         setCursor(Qt::SplitHCursor);
 699     } else {
 700         removeTipAnimation();
 701         setCursor(Qt::ArrowCursor);
 702         if (event->buttons() != Qt::NoButton && event->modifiers() == Qt::NoModifier) {
 703             QGraphicsView::mouseMoveEvent(event);
 704             m_moveOpMode = SEEK;
 705             setCursorPos(mappedXPos);
 706             slotCheckPositionScrolling();
 707             return;
 708         } else m_moveOpMode = NONE;
 709     }
 710     QGraphicsView::mouseMoveEvent(event);
 711 }
 712
 713 // virtual
 714 void CustomTrackView::mousePressEvent(QMouseEvent * event)
 715 {
 716     setFocus(Qt::MouseFocusReason);
 717     m_menuPosition = QPoint();
 718
 719     // special cases (middle click button or ctrl / shift click
 720     if (event->button() == Qt::MidButton) {
 721         emit playMonitor();
 722         m_blockRefresh = false;
 723         m_operationMode = NONE;
 724         return;
 725     }
 726
 727     if (event->modifiers() & Qt::ShiftModifier) {
 728         // Rectangle selection
 729         setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
 730         setDragMode(QGraphicsView::RubberBandDrag);
 731         if (!(event->modifiers() & Qt::ControlModifier)) {
 732             resetSelectionGroup();
 733             scene()->clearSelection();
 734         }
 735         m_blockRefresh = false;
 736         m_operationMode = RUBBERSELECTION;
 737         QGraphicsView::mousePressEvent(event);
 738         return;
 739     }
 740
 741     m_blockRefresh = true;
 742     m_dragGuide = NULL;
 743
 744     if (m_tool != RAZORTOOL) activateMonitor();
 745     else if (m_document->renderer()->playSpeed() != 0.0) {
 746         m_document->renderer()->pause();
 747         return;
 748     }
 749     m_clickEvent = event->pos();
 750
 751     // check item under mouse
 752     QList<QGraphicsItem *> collisionList = items(m_clickEvent);
 753     if (event->modifiers() == Qt::ControlModifier && m_tool != SPACERTOOL && collisionList.count() == 0) {
 754         // Pressing Ctrl + left mouse button in an empty area scrolls the timeline
 755         setDragMode(QGraphicsView::ScrollHandDrag);
 756         QGraphicsView::mousePressEvent(event);
 757         m_blockRefresh = false;
 758         m_operationMode = NONE;
 759         return;
 760     }
 761
 762     // if a guide and a clip were pressed, just select the guide
 763     for (int i = 0; i < collisionList.count(); ++i) {
 764         if (collisionList.at(i)->type() == GUIDEITEM) {
 765             // a guide item was pressed
 766             m_dragGuide = (Guide *) collisionList.at(i);
 767             if (event->button() == Qt::LeftButton) { // move it
 768                 m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, true);
 769                 m_operationMode = MOVEGUIDE;
 770                 // deselect all clips so that only the guide will move
 771                 m_scene->clearSelection();
 772                 resetSelectionGroup(false);
 773                 updateSnapPoints(NULL);
 774                 QGraphicsView::mousePressEvent(event);
 775                 return;
 776             } else // show context menu
 777                 break;
 778         }
 779     }
 780
 781     // Find first clip, transition or group under mouse (when no guides selected)
 782     int ct = 0;
 783     AbstractGroupItem *dragGroup = NULL;
 784     AbstractClipItem *collisionClip = NULL;
 785     bool found = false;
 786     while (!m_dragGuide && ct < collisionList.count()) {
 787         if (collisionList.at(ct)->type() == AVWIDGET || collisionList.at(ct)->type() == TRANSITIONWIDGET) {
 788             collisionClip = static_cast <AbstractClipItem *>(collisionList.at(ct));
 789             if (collisionClip->isItemLocked())
 790                 break;
 791             if (collisionClip == m_dragItem)
 792                 collisionClip = NULL;
 793             else
 794                 m_dragItem = collisionClip;
 795             found = true;
 796             m_dragItemInfo = m_dragItem->info();
 797             if (m_dragItem->parentItem() && m_dragItem->parentItem()->type() == GROUPWIDGET && m_dragItem->parentItem() != m_selectionGroup) {
 798                 // kDebug()<<"// KLIK FOUND GRP: "<<m_dragItem->sceneBoundingRect();
 799                 dragGroup = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
 800             }
 801             break;
 802         }
 803         ct++;
 804     }
 805     if (!found) {
 806         if (m_dragItem) emit clipItemSelected(NULL);
 807         m_dragItem = NULL;
 808     }
 809 #if QT_VERSION >= 0x040600
 810     // Add shadow to dragged item, currently disabled because of painting artifacts
 811     //TODO: re-enable when fixed
 812     /*QGraphicsDropShadowEffect *eff = new QGraphicsDropShadowEffect();
 813     eff->setBlurRadius(5);
 814     eff->setOffset(3, 3);
 815     m_dragItem->setGraphicsEffect(eff);*/
 816 #endif
 817     if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
 818         // update transition menu action
 819         m_autoTransition->setChecked(static_cast<Transition *>(m_dragItem)->isAutomatic());
 820         m_autoTransition->setEnabled(true);
 821     } else m_autoTransition->setEnabled(false);
 822
 823     // context menu requested
 824     if (event->button() == Qt::RightButton) {
 825         if (m_dragItem) {
 826             if (dragGroup) dragGroup->setSelected(true);
 827             else if (!m_dragItem->isSelected()) {
 828                 resetSelectionGroup(false);
 829                 m_scene->clearSelection();
 830                 m_dragItem->setSelected(true);
 831             }
 832         } else if (!m_dragGuide) {
 833             // check if there is a guide close to mouse click
 834             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
 835             for (int i = 0; i < guidesCollisionList.count(); i++) {
 836                 if (guidesCollisionList.at(i)->type() == GUIDEITEM) {
 837                     m_dragGuide = static_cast <Guide *>(guidesCollisionList.at(i));
 838                     break;
 839                 }
 840             }
 841             // keep this to support multiple guides context menu in the future (?)
 842             /*if (guidesCollisionList.at(0)->type() != GUIDEITEM)
 843                 guidesCollisionList.removeAt(0);
 844             }
 845             if (!guidesCollisionList.isEmpty())
 846             m_dragGuide = static_cast <Guide *>(guidesCollisionList.at(0));*/
 847         }
 848
 849         m_operationMode = NONE;
 850         displayContextMenu(event->globalPos(), m_dragItem, dragGroup);
 851         m_menuPosition = m_clickEvent;
 852         m_dragItem = NULL;
 853         event->accept();
 854         return;
 855     }
 856
 857     // No item under click
 858     if (m_dragItem == NULL || m_tool == SPACERTOOL) {
 859         resetSelectionGroup(false);
 860         setCursor(Qt::ArrowCursor);
 861         m_scene->clearSelection();
 862         //event->accept();
 863         updateClipTypeActions(NULL);
 864         if (m_tool == SPACERTOOL) {
 865             QList<QGraphicsItem *> selection;
 866             if (event->modifiers() == Qt::ControlModifier) {
 867                 // Ctrl + click, select all items on track after click position
 868                 int track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
 869                 if (m_document->trackInfoAt(m_document->tracksCount() - track - 1).isLocked) {
 870                     // Cannot use spacer on locked track
 871                     emit displayMessage(i18n("Cannot use spacer in a locked track"), ErrorMessage);
 872                     return;
 873                 }
 874
 875                 QRectF rect(mapToScene(m_clickEvent).x(), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - mapToScene(m_clickEvent).x(), m_tracksHeight / 2 - 2);
 876
 877                 bool isOk;
 878                 selection = checkForGroups(rect, &isOk);
 879                 if (!isOk) {
 880                     // groups found on track, do not allow the move
 881                     emit displayMessage(i18n("Cannot use spacer in a track with a group"), ErrorMessage);
 882                     return;
 883                 }
 884
 885                 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;
 886             } else {
 887                 // Select all items on all tracks after click position
 888                 selection = items(event->pos().x(), 1, mapFromScene(sceneRect().width(), 0).x() - event->pos().x(), sceneRect().height());
 889                 kDebug() << "SELELCTING ELEMENTS WITHIN =" << event->pos().x() << "/" <<  1 << ", " << mapFromScene(sceneRect().width(), 0).x() - event->pos().x() << "/" << sceneRect().height();
 890             }
 891
 892             QList <GenTime> offsetList;
 893             // create group to hold selected items
 894             m_selectionGroup = new AbstractGroupItem(m_document->fps());
 895             scene()->addItem(m_selectionGroup);
 896
 897             for (int i = 0; i < selection.count(); i++) {
 898                 if (selection.at(i)->parentItem() == 0 && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET)) {
 899                     AbstractClipItem *item = static_cast<AbstractClipItem *>(selection.at(i));
 900                     if (item->isItemLocked()) continue;
 901                     offsetList.append(item->startPos());
 902                     offsetList.append(item->endPos());
 903                     m_selectionGroup->addToGroup(selection.at(i));
 904                     selection.at(i)->setFlag(QGraphicsItem::ItemIsMovable, false);
 905                 } else if (/*selection.at(i)->parentItem() == 0 && */selection.at(i)->type() == GROUPWIDGET) {
 906                     if (static_cast<AbstractGroupItem *>(selection.at(i))->isItemLocked()) continue;
 907                     QList<QGraphicsItem *> children = selection.at(i)->childItems();
 908                     for (int j = 0; j < children.count(); j++) {
 909                         AbstractClipItem *item = static_cast<AbstractClipItem *>(children.at(j));
 910                         offsetList.append(item->startPos());
 911                         offsetList.append(item->endPos());
 912                     }
 913                     m_selectionGroup->addToGroup(selection.at(i));
 914                     selection.at(i)->setFlag(QGraphicsItem::ItemIsMovable, false);
 915                 } else if (selection.at(i)->parentItem() && !selection.contains(selection.at(i)->parentItem())) {
 916                     if (static_cast<AbstractGroupItem *>(selection.at(i)->parentItem())->isItemLocked()) continue;
 917                     //AbstractGroupItem *grp = static_cast<AbstractGroupItem *>(selection.at(i)->parentItem());
 918                     m_selectionGroup->addToGroup(selection.at(i)->parentItem());
 919                     selection.at(i)->parentItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
 920                 }
 921             }
 922             m_spacerOffset = m_selectionGroup->sceneBoundingRect().left() - (int)(mapToScene(m_clickEvent).x());
 923             if (!offsetList.isEmpty()) {
 924                 qSort(offsetList);
 925                 QList <GenTime> cleandOffsetList;
 926                 GenTime startOffset = offsetList.takeFirst();
 927                 for (int k = 0; k < offsetList.size(); k++) {
 928                     GenTime newoffset = offsetList.at(k) - startOffset;
 929                     if (newoffset != GenTime() && !cleandOffsetList.contains(newoffset)) {
 930                         cleandOffsetList.append(newoffset);
 931                     }
 932                 }
 933                 updateSnapPoints(NULL, cleandOffsetList, true);
 934             }
 935             m_operationMode = SPACER;
 936         } else {
 937             setCursorPos((int)(mapToScene(event->x(), 0).x()));
 938         }
 939         //QGraphicsView::mousePressEvent(event);
 940         event->ignore();
 941         return;
 942     }
 943
 944     // Razor tool
 945     if (m_tool == RAZORTOOL && m_dragItem) {
 946         GenTime cutPos = GenTime((int)(mapToScene(event->pos()).x()), m_document->fps());
 947         if (m_dragItem->type() == TRANSITIONWIDGET) {
 948             emit displayMessage(i18n("Cannot cut a transition"), ErrorMessage);
 949         } else {
 950             m_document->renderer()->pause();
 951             if (m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
 952                 razorGroup((AbstractGroupItem *)m_dragItem->parentItem(), cutPos);
 953             } else {
 954                 AbstractClipItem *clip = static_cast <AbstractClipItem *>(m_dragItem);
 955                 RazorClipCommand* command = new RazorClipCommand(this, clip->info(), cutPos);
 956                 m_commandStack->push(command);
 957             }
 958             setDocumentModified();
 959         }
 960         m_dragItem = NULL;
 961         event->accept();
 962         return;
 963     }
 964
 965     bool itemSelected = false;
 966     if (m_dragItem->isSelected())
 967         itemSelected = true;
 968     else if (m_dragItem->parentItem() && m_dragItem->parentItem()->isSelected())
 969         itemSelected = true;
 970     else if (dragGroup && dragGroup->isSelected())
 971         itemSelected = true;
 972
 973     if (event->modifiers() == Qt::ControlModifier || itemSelected == false) {
 974         if (event->modifiers() != Qt::ControlModifier) {
 975             resetSelectionGroup(false);
 976             m_scene->clearSelection();
 977             // A refresh seems necessary otherwise in zoomed mode, some clips disappear
 978             viewport()->update();
 979         } else resetSelectionGroup();
 980         dragGroup = NULL;
 981         if (m_dragItem->parentItem() && m_dragItem->parentItem()->type() == GROUPWIDGET) {
 982             dragGroup = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
 983         }
 984         bool selected = !m_dragItem->isSelected();
 985         if (dragGroup)
 986             dragGroup->setSelected(selected);
 987         else
 988             m_dragItem->setSelected(selected);
 989
 990         groupSelectedItems();
 991         ClipItem *clip = static_cast <ClipItem *>(m_dragItem);
 992         updateClipTypeActions(dragGroup == NULL ? clip : NULL);
 993         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
 994     }
 995
 996     if (collisionClip != NULL || m_dragItem == NULL) {
 997         if (m_dragItem && m_dragItem->type() == AVWIDGET && !m_dragItem->isItemLocked()) {
 998             ClipItem *selected = static_cast <ClipItem*>(m_dragItem);
 999             emit clipItemSelected(selected);
1000         } else {
1001             emit clipItemSelected(NULL);
1002         }
1003     }
1004
1005     // If clicked item is selected, allow move
1006     if (event->modifiers() != Qt::ControlModifier && m_operationMode == NONE) QGraphicsView::mousePressEvent(event);
1007
1008     m_clickPoint = QPoint((int)(mapToScene(event->pos()).x() - m_dragItem->startPos().frames(m_document->fps())), (int)(event->pos().y() - m_dragItem->pos().y()));
1009     if (m_selectionGroup && m_dragItem->parentItem() == m_selectionGroup) {
1010         // all other modes break the selection, so the user probably wants to move it
1011         m_operationMode = MOVE;
1012     } else {
1013         m_operationMode = m_dragItem->operationMode(mapToScene(event->pos()));
1014     }
1015     m_controlModifier = (event->modifiers() == Qt::ControlModifier);
1016
1017     // Update snap points
1018     if (m_selectionGroup == NULL) {
1019         if (m_operationMode == RESIZEEND || m_operationMode == RESIZESTART)
1020             updateSnapPoints(NULL);
1021         else
1022             updateSnapPoints(m_dragItem);
1023     } else {
1024         QList <GenTime> offsetList;
1025         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1026         for (int i = 0; i < children.count(); i++) {
1027             if (children.at(i)->type() == AVWIDGET || children.at(i)->type() == TRANSITIONWIDGET) {
1028                 AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
1029                 offsetList.append(item->startPos());
1030                 offsetList.append(item->endPos());
1031             }
1032         }
1033         if (!offsetList.isEmpty()) {
1034             qSort(offsetList);
1035             GenTime startOffset = offsetList.takeFirst();
1036             QList <GenTime> cleandOffsetList;
1037             for (int k = 0; k < offsetList.size(); k++) {
1038                 GenTime newoffset = offsetList.at(k) - startOffset;
1039                 if (newoffset != GenTime() && !cleandOffsetList.contains(newoffset)) {
1040                     cleandOffsetList.append(newoffset);
1041                 }
1042             }
1043             updateSnapPoints(NULL, cleandOffsetList, true);
1044         }
1045     }
1046
1047     if (m_operationMode == KEYFRAME) {
1048         m_dragItem->updateSelectedKeyFrame();
1049         m_blockRefresh = false;
1050         return;
1051     } else if (m_operationMode == MOVE) {
1052         setCursor(Qt::ClosedHandCursor);
1053     } else if (m_operationMode == TRANSITIONSTART && event->modifiers() != Qt::ControlModifier) {
1054         ItemInfo info;
1055         info.startPos = m_dragItem->startPos();
1056         info.track = m_dragItem->track();
1057         int transitiontrack = getPreviousVideoTrack(info.track);
1058         ClipItem *transitionClip = NULL;
1059         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1060         if (transitionClip && transitionClip->endPos() < m_dragItem->endPos()) {
1061             info.endPos = transitionClip->endPos();
1062         } else {
1063             GenTime transitionDuration(65, m_document->fps());
1064             if (m_dragItem->cropDuration() < transitionDuration)
1065                 info.endPos = m_dragItem->endPos();
1066             else
1067                 info.endPos = info.startPos + transitionDuration;
1068         }
1069         if (info.endPos == info.startPos) info.endPos = info.startPos + GenTime(65, m_document->fps());
1070         // Check there is no other transition at that place
1071         double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1072         QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1073         QList<QGraphicsItem *> selection = m_scene->items(r);
1074         bool transitionAccepted = true;
1075         for (int i = 0; i < selection.count(); i++) {
1076             if (selection.at(i)->type() == TRANSITIONWIDGET) {
1077                 Transition *tr = static_cast <Transition *>(selection.at(i));
1078                 if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1079                     if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1080                 } else transitionAccepted = false;
1081             }
1082         }
1083         if (transitionAccepted) slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack);
1084         else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1085     } else if (m_operationMode == TRANSITIONEND && event->modifiers() != Qt::ControlModifier) {
1086         ItemInfo info;
1087         info.endPos = GenTime(m_dragItem->endPos().frames(m_document->fps()), m_document->fps());
1088         info.track = m_dragItem->track();
1089         int transitiontrack = getPreviousVideoTrack(info.track);
1090         ClipItem *transitionClip = NULL;
1091         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1092         if (transitionClip && transitionClip->startPos() > m_dragItem->startPos()) {
1093             info.startPos = transitionClip->startPos();
1094         } else {
1095             GenTime transitionDuration(65, m_document->fps());
1096             if (m_dragItem->cropDuration() < transitionDuration) info.startPos = m_dragItem->startPos();
1097             else info.startPos = info.endPos - transitionDuration;
1098         }
1099         if (info.endPos == info.startPos) info.startPos = info.endPos - GenTime(65, m_document->fps());
1100         QDomElement transition = MainWindow::transitions.getEffectByTag("luma", "dissolve").cloneNode().toElement();
1101         EffectsList::setParameter(transition, "reverse", "1");
1102
1103         // Check there is no other transition at that place
1104         double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1105         QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1106         QList<QGraphicsItem *> selection = m_scene->items(r);
1107         bool transitionAccepted = true;
1108         for (int i = 0; i < selection.count(); i++) {
1109             if (selection.at(i)->type() == TRANSITIONWIDGET) {
1110                 Transition *tr = static_cast <Transition *>(selection.at(i));
1111                 if (info.endPos - tr->endPos() > GenTime(5, m_document->fps())) {
1112                     if (tr->endPos() > info.startPos) info.startPos = tr->endPos();
1113                 } else transitionAccepted = false;
1114             }
1115         }
1116         if (transitionAccepted) slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack, transition);
1117         else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1118
1119     } else if ((m_operationMode == RESIZESTART || m_operationMode == RESIZEEND) && m_selectionGroup) {
1120         resetSelectionGroup(false);
1121         m_dragItem->setSelected(true);
1122     }
1123
1124     m_blockRefresh = false;
1125     //kDebug()<<pos;
1126     QGraphicsView::mousePressEvent(event);
1127 }
1128
1129 void CustomTrackView::rebuildGroup(int childTrack, GenTime childPos)
1130 {
1131     const QPointF p((int)childPos.frames(m_document->fps()), childTrack * m_tracksHeight + m_tracksHeight / 2);
1132     QList<QGraphicsItem *> list = scene()->items(p);
1133     AbstractGroupItem *group = NULL;
1134     for (int i = 0; i < list.size(); i++) {
1135         if (!list.at(i)->isEnabled()) continue;
1136         if (list.at(i)->type() == GROUPWIDGET) {
1137             group = static_cast <AbstractGroupItem *>(list.at(i));
1138             break;
1139         }
1140     }
1141     rebuildGroup(group);
1142 }
1143
1144 void CustomTrackView::rebuildGroup(AbstractGroupItem *group)
1145 {
1146     if (group) {
1147         resetSelectionGroup(false);
1148         m_scene->clearSelection();
1149
1150         QList <QGraphicsItem *> children = group->childItems();
1151         m_document->clipManager()->removeGroup(group);
1152         scene()->destroyItemGroup(group);
1153         for (int i = 0; i < children.count(); i++)
1154             children.at(i)->setSelected(true);
1155         groupSelectedItems(false, true);
1156     }
1157 }
1158
1159 void CustomTrackView::resetSelectionGroup(bool selectItems)
1160 {
1161     if (m_selectionGroup) {
1162         // delete selection group
1163         bool snap = KdenliveSettings::snaptopoints();
1164         KdenliveSettings::setSnaptopoints(false);
1165
1166         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1167         scene()->destroyItemGroup(m_selectionGroup);
1168         for (int i = 0; i < children.count(); i++) {
1169             if (children.at(i)->parentItem() == 0 && (children.at(i)->type() == AVWIDGET || children.at(i)->type() == TRANSITIONWIDGET)) {
1170                 if (!static_cast <AbstractClipItem *>(children.at(i))->isItemLocked()) {
1171                     children.at(i)->setFlag(QGraphicsItem::ItemIsMovable, true);
1172                     children.at(i)->setSelected(selectItems);
1173                 }
1174             } else if (children.at(i)->type() == GROUPWIDGET) {
1175                 children.at(i)->setFlag(QGraphicsItem::ItemIsMovable, true);
1176                 children.at(i)->setSelected(selectItems);
1177             }
1178         }
1179
1180         m_selectionGroup = NULL;
1181         KdenliveSettings::setSnaptopoints(snap);
1182     }
1183 }
1184
1185 void CustomTrackView::groupSelectedItems(bool force, bool createNewGroup)
1186 {
1187     if (m_selectionGroup) {
1188         kDebug() << "///// ERROR, TRYING TO OVERRIDE EXISTING GROUP";
1189         return;
1190     }
1191     QList<QGraphicsItem *> selection = m_scene->selectedItems();
1192     if (selection.isEmpty()) return;
1193     QRectF rectUnion;
1194     // Find top left position of selection
1195     for (int i = 0; i < selection.count(); i++) {
1196         if (selection.at(i)->parentItem() == 0 && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
1197             rectUnion = rectUnion.united(selection.at(i)->sceneBoundingRect());
1198         } else if (selection.at(i)->parentItem()) {
1199             rectUnion = rectUnion.united(selection.at(i)->parentItem()->sceneBoundingRect());
1200         }
1201     }
1202
1203     if (force || selection.count() > 1) {
1204         bool snap = KdenliveSettings::snaptopoints();
1205         KdenliveSettings::setSnaptopoints(false);
1206         if (createNewGroup) {
1207             AbstractGroupItem *newGroup = m_document->clipManager()->createGroup();
1208             newGroup->setPos(rectUnion.left(), rectUnion.top() - 1);
1209             QPointF diff = newGroup->pos();
1210             newGroup->translate(-diff.x(), -diff.y());
1211             //newGroup->translate((int) -rectUnion.left(), (int) -rectUnion.top() + 1);
1212
1213             scene()->addItem(newGroup);
1214
1215             // Check if we are trying to include a group in a group
1216             QList <AbstractGroupItem *> groups;
1217             for (int i = 0; i < selection.count(); i++) {
1218                 if (selection.at(i)->type() == GROUPWIDGET && !groups.contains(static_cast<AbstractGroupItem *>(selection.at(i))))
1219                     groups.append(static_cast<AbstractGroupItem *>(selection.at(i)));
1220                 else if (selection.at(i)->parentItem() && !groups.contains(static_cast<AbstractGroupItem *>(selection.at(i)->parentItem())))
1221                     groups.append(static_cast<AbstractGroupItem *>(selection.at(i)->parentItem()));
1222             }
1223             if (!groups.isEmpty()) {
1224                 // ungroup previous groups
1225                 while (!groups.isEmpty()) {
1226                     AbstractGroupItem *grp = groups.takeFirst();
1227                     m_document->clipManager()->removeGroup(grp);
1228                     scene()->destroyItemGroup(grp);
1229                 }
1230                 selection = m_scene->selectedItems();
1231             }
1232
1233             for (int i = 0; i < selection.count(); i++) {
1234                 if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
1235                     newGroup->addToGroup(selection.at(i));
1236                     selection.at(i)->setFlag(QGraphicsItem::ItemIsMovable, false);
1237                 }
1238             }
1239             KdenliveSettings::setSnaptopoints(snap);
1240         } else {
1241             m_selectionGroup = new AbstractGroupItem(m_document->fps());
1242             m_selectionGroup->setPos(rectUnion.left(), rectUnion.top() - 1);
1243             QPointF diff = m_selectionGroup->pos();
1244             //m_selectionGroup->translate((int) - rectUnion.left(), (int) -rectUnion.top() + 1);
1245             m_selectionGroup->translate(- diff.x(), -diff.y());
1246
1247             scene()->addItem(m_selectionGroup);
1248             for (int i = 0; i < selection.count(); i++) {
1249                 if (selection.at(i)->parentItem() == 0 && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
1250                     m_selectionGroup->addToGroup(selection.at(i));
1251                     selection.at(i)->setFlag(QGraphicsItem::ItemIsMovable, false);
1252                 }
1253             }
1254             KdenliveSettings::setSnaptopoints(snap);
1255             if (m_selectionGroup) {
1256                 m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
1257                 m_selectionGroupInfo.track = m_selectionGroup->track();
1258             }
1259         }
1260     } else resetSelectionGroup();
1261 }
1262
1263 void CustomTrackView::mouseDoubleClickEvent(QMouseEvent *event)
1264 {
1265     if (m_dragItem && m_dragItem->hasKeyFrames()) {
1266         /*if (m_moveOpMode == KEYFRAME) {
1267             // user double clicked on a keyframe, open edit dialog
1268             //TODO: update for effects with several values per keyframe
1269             QDialog d(parentWidget());
1270             Ui::KeyFrameDialog_UI view;
1271             view.setupUi(&d);
1272             view.kfr_position->setText(m_document->timecode().getTimecode(GenTime(m_dragItem->selectedKeyFramePos(), m_document->fps()) - m_dragItem->cropStart()));
1273             view.kfr_value->setValue(m_dragItem->selectedKeyFrameValue());
1274             view.kfr_value->setFocus();
1275             if (d.exec() == QDialog::Accepted) {
1276                 int pos = m_document->timecode().getFrameCount(view.kfr_position->text());
1277                 m_dragItem->updateKeyFramePos(GenTime(pos, m_document->fps()) + m_dragItem->cropStart(), (double) view.kfr_value->value() * m_dragItem->keyFrameFactor());
1278                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
1279                 QString previous = item->keyframes(item->selectedEffectIndex());
1280                 item->updateKeyframeEffect();
1281                 QString next = item->keyframes(item->selectedEffectIndex());
1282                 EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
1283                 m_commandStack->push(command);
1284                 updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
1285                 emit clipItemSelected(item, item->selectedEffectIndex());
1286             }
1287
1288         } else*/  {
1289             // add keyframe
1290             GenTime keyFramePos = GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
1291             int val = m_dragItem->addKeyFrame(keyFramePos, mapToScene(event->pos()).toPoint().y());
1292             ClipItem * item = static_cast <ClipItem *>(m_dragItem);
1293             //QString previous = item->keyframes(item->selectedEffectIndex());
1294             QDomElement oldEffect = item->selectedEffect().cloneNode().toElement();
1295             item->insertKeyframe(item->getEffectAtIndex(item->selectedEffectIndex()), keyFramePos.frames(m_document->fps()), val);
1296             //item->updateKeyframeEffect();
1297             //QString next = item->keyframes(item->selectedEffectIndex());
1298             QDomElement newEffect = item->selectedEffect().cloneNode().toElement();
1299             EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), oldEffect, newEffect, item->selectedEffectIndex(), false, false);
1300             //EditKeyFrameCommand *command = new EditKeyFrameCommand(this, m_dragItem->track(), m_dragItem->startPos(), item->selectedEffectIndex(), previous, next, false);
1301             m_commandStack->push(command);
1302             updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect());
1303             emit clipItemSelected(item, item->selectedEffectIndex());
1304         }
1305     } else if (m_dragItem && !m_dragItem->isItemLocked()) {
1306         editItemDuration();
1307     } else {
1308         QList<QGraphicsItem *> collisionList = items(event->pos());
1309         if (collisionList.count() == 1 && collisionList.at(0)->type() == GUIDEITEM) {
1310             Guide *editGuide = (Guide *) collisionList.at(0);
1311             if (editGuide) slotEditGuide(editGuide->info());
1312         }
1313     }
1314 }
1315
1316 void CustomTrackView::editItemDuration()
1317 {
1318     AbstractClipItem *item;
1319     if (m_dragItem) {
1320         item = m_dragItem;
1321     } else {
1322         if (m_scene->selectedItems().count() == 1) {
1323             item = static_cast <AbstractClipItem *>(m_scene->selectedItems().at(0));
1324         } else {
1325             if (m_scene->selectedItems().empty())
1326                 emit displayMessage(i18n("Cannot find clip to edit"), ErrorMessage);
1327             else
1328                 emit displayMessage(i18n("Cannot edit the duration of multiple items"), ErrorMessage);
1329             return;
1330         }
1331     }
1332
1333     if (!item) {
1334         emit displayMessage(i18n("Cannot find clip to edit"), ErrorMessage);
1335         return;
1336     }
1337
1338     if (item->type() == GROUPWIDGET || (item->parentItem() && item->parentItem()->type() == GROUPWIDGET)) {
1339         emit displayMessage(i18n("Cannot edit an item in a group"), ErrorMessage);
1340         return;
1341     }
1342
1343     if (!item->isItemLocked()) {
1344         GenTime minimum;
1345         GenTime maximum;
1346         if (item->type() == TRANSITIONWIDGET)
1347             getTransitionAvailableSpace(item, minimum, maximum);
1348         else
1349             getClipAvailableSpace(item, minimum, maximum);
1350
1351         ClipDurationDialog d(item, m_document->timecode(), minimum, maximum, this);
1352         if (d.exec() == QDialog::Accepted) {
1353             ItemInfo clipInfo = item->info();
1354             ItemInfo startInfo = clipInfo;
1355             if (item->type() == TRANSITIONWIDGET) {
1356                 // move & resize transition
1357                 clipInfo.startPos = d.startPos();
1358                 clipInfo.endPos = clipInfo.startPos + d.duration();
1359                 clipInfo.track = item->track();
1360                 MoveTransitionCommand *command = new MoveTransitionCommand(this, startInfo, clipInfo, true);
1361                 updateTrackDuration(clipInfo.track, command);
1362                 m_commandStack->push(command);
1363             } else {
1364                 // move and resize clip
1365                 ClipItem *clip = static_cast<ClipItem *>(item);
1366                 QUndoCommand *moveCommand = new QUndoCommand();
1367                 moveCommand->setText(i18n("Edit clip"));
1368                 if (d.duration() < item->cropDuration() || d.cropStart() != clipInfo.cropStart) {
1369                     // duration was reduced, so process it first
1370                     clipInfo.endPos = clipInfo.startPos + d.duration();
1371                     clipInfo.cropStart = d.cropStart();
1372
1373                     resizeClip(startInfo, clipInfo);
1374                     new ResizeClipCommand(this, startInfo, clipInfo, false, true, moveCommand);
1375                     adjustEffects(clip, startInfo, moveCommand);
1376                     new ResizeClipCommand(this, startInfo, clipInfo, false, true, moveCommand);
1377                 }
1378
1379                 if (d.startPos() != clipInfo.startPos) {
1380                     startInfo = clipInfo;
1381                     clipInfo.startPos = d.startPos();
1382                     clipInfo.endPos = item->endPos() + (clipInfo.startPos - startInfo.startPos);
1383                     new MoveClipCommand(this, startInfo, clipInfo, true, moveCommand);
1384                 }
1385
1386                 if (d.duration() > item->cropDuration()) {
1387                     // duration was increased, so process it after move
1388                     startInfo = clipInfo;
1389                     clipInfo.endPos = clipInfo.startPos + d.duration();
1390                     clipInfo.cropStart = d.cropStart();
1391
1392                     resizeClip(startInfo, clipInfo);
1393                     new ResizeClipCommand(this, startInfo, clipInfo, false, true, moveCommand);
1394                     adjustEffects(clip, startInfo, moveCommand);
1395                     new ResizeClipCommand(this, startInfo, clipInfo, false, true, moveCommand);
1396                 }
1397                 updateTrackDuration(clipInfo.track, moveCommand);
1398                 m_commandStack->push(moveCommand);
1399             }
1400         }
1401     } else {
1402         emit displayMessage(i18n("Item is locked"), ErrorMessage);
1403     }
1404 }
1405
1406 void CustomTrackView::editKeyFrame(const GenTime & /*pos*/, const int /*track*/, const int /*index*/, const QString & /*keyframes*/)
1407 {
1408     /*ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), track);
1409     if (clip) {
1410         clip->setKeyframes(index, keyframes);
1411         updateEffect(m_document->tracksCount() - clip->track(), clip->startPos(), clip->effectAt(index), index, false);
1412     } else emit displayMessage(i18n("Cannot find clip with keyframe"), ErrorMessage);*/
1413 }
1414
1415
1416 void CustomTrackView::displayContextMenu(QPoint pos, AbstractClipItem *clip, AbstractGroupItem *group)
1417 {
1418     m_deleteGuide->setEnabled(m_dragGuide != NULL);
1419     m_editGuide->setEnabled(m_dragGuide != NULL);
1420     m_markerMenu->clear();
1421     m_markerMenu->setEnabled(false);
1422     if (clip == NULL) {
1423         m_timelineContextMenu->popup(pos);
1424     } else if (group != NULL) {
1425         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1426         m_ungroupAction->setEnabled(true);
1427         updateClipTypeActions(NULL);
1428         m_timelineContextClipMenu->popup(pos);
1429     } else {
1430         m_ungroupAction->setEnabled(false);
1431         if (clip->type() == AVWIDGET) {
1432             ClipItem *item = static_cast <ClipItem*>(clip);
1433             //build go to marker menu
1434             if (item->baseClip()) {
1435                 QList <CommentedTime> markers = item->baseClip()->commentedSnapMarkers();
1436                 int offset = item->startPos().frames(m_document->fps());
1437                 if (!markers.isEmpty()) {
1438                     for (int i = 0; i < markers.count(); i++) {
1439                         int pos = (int) markers.at(i).time().frames(m_document->timecode().fps());
1440                         QString position = m_document->timecode().getTimecode(markers.at(i).time()) + ' ' + markers.at(i).comment();
1441                         QAction *go = m_markerMenu->addAction(position);
1442                         go->setData(pos + offset);
1443                     }
1444                 }
1445                 m_markerMenu->setEnabled(!m_markerMenu->isEmpty());
1446             }
1447             updateClipTypeActions(item);
1448             m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1449             m_timelineContextClipMenu->popup(pos);
1450         } else if (clip->type() == TRANSITIONWIDGET) {
1451             m_timelineContextTransitionMenu->popup(pos);
1452         }
1453     }
1454 }
1455
1456 void CustomTrackView::activateMonitor()
1457 {
1458     emit activateDocumentMonitor();
1459 }
1460
1461 void CustomTrackView::insertClipCut(DocClipBase *clip, int in, int out)
1462 {
1463     resetSelectionGroup();
1464     ItemInfo info;
1465     info.startPos = GenTime();
1466     info.cropStart = GenTime(in, m_document->fps());
1467     info.endPos = GenTime(out - in, m_document->fps());
1468     info.cropDuration = info.endPos - info.startPos;
1469     info.track = 0;
1470
1471     // Check if clip can be inserted at that position
1472     ItemInfo pasteInfo = info;
1473     pasteInfo.startPos = GenTime(m_cursorPos, m_document->fps());
1474     pasteInfo.endPos = pasteInfo.startPos + info.endPos;
1475     pasteInfo.track = selectedTrack();
1476     if (!canBePastedTo(pasteInfo, AVWIDGET)) {
1477         emit displayMessage(i18n("Cannot insert clip in timeline"), ErrorMessage);
1478         return;
1479     }
1480
1481     AddTimelineClipCommand *command = new AddTimelineClipCommand(this, clip->toXML(), clip->getId(), pasteInfo, EffectsList(), m_scene->editMode() == OVERWRITEEDIT, m_scene->editMode() == INSERTEDIT, true, false);
1482     updateTrackDuration(pasteInfo.track, command);
1483     m_commandStack->push(command);
1484
1485     selectClip(true, false);
1486     // Automatic audio split
1487     if (KdenliveSettings::splitaudio())
1488         splitAudio();
1489 }
1490
1491 bool CustomTrackView::insertDropClips(const QMimeData *data, const QPoint &pos)
1492 {
1493     if (data->hasFormat("kdenlive/clip")) {
1494         m_clipDrag = true;
1495         m_scene->clearSelection();
1496         resetSelectionGroup(false);
1497         QStringList list = QString(data->data("kdenlive/clip")).split(';');
1498         DocClipBase *clip = m_document->getBaseClip(list.at(0));
1499         if (clip == NULL) {
1500             kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << list.at(0);
1501             return false;
1502         }
1503         if (clip->getProducer() == NULL) {
1504             emit displayMessage(i18n("Clip not ready"), ErrorMessage);
1505             return false;
1506         }
1507         QPointF framePos = mapToScene(pos);
1508         ItemInfo info;
1509         info.startPos = GenTime();
1510         info.cropStart = GenTime(list.at(1).toInt(), m_document->fps());
1511         info.endPos = GenTime(list.at(2).toInt() - list.at(1).toInt(), m_document->fps());
1512         info.cropDuration = info.endPos - info.startPos;
1513         info.track = 0;
1514
1515         // Check if clip can be inserted at that position
1516         ItemInfo pasteInfo = info;
1517         pasteInfo.startPos = GenTime((int)(framePos.x() + 0.5), m_document->fps());
1518         pasteInfo.endPos = pasteInfo.startPos + info.endPos;
1519         pasteInfo.track = (int)(framePos.y() / m_tracksHeight);
1520         framePos.setX((int)(framePos.x() + 0.5));
1521         framePos.setY(pasteInfo.track * m_tracksHeight);
1522         if (!canBePastedTo(pasteInfo, AVWIDGET)) {
1523             return true;
1524         }
1525         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1526         ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0, 1, getFrameWidth());
1527         m_selectionGroup->addToGroup(item);
1528         item->setFlag(QGraphicsItem::ItemIsMovable, false);
1529
1530         QList <GenTime> offsetList;
1531         offsetList.append(info.endPos);
1532         updateSnapPoints(NULL, offsetList);
1533         m_selectionGroup->setPos(framePos);
1534         scene()->addItem(m_selectionGroup);
1535         m_selectionGroup->setSelected(true);
1536         return true;
1537     } else if (data->hasFormat("kdenlive/producerslist")) {
1538         m_clipDrag = true;
1539         QStringList ids = QString(data->data("kdenlive/producerslist")).split(';');
1540         m_scene->clearSelection();
1541         resetSelectionGroup(false);
1542
1543         QList <GenTime> offsetList;
1544         QList <ItemInfo> infoList;
1545         QPointF framePos = mapToScene(pos);
1546         GenTime start = GenTime((int)(framePos.x() + 0.5), m_document->fps());
1547         int track = (int)(framePos.y() / m_tracksHeight);
1548         framePos.setX((int)(framePos.x() + 0.5));
1549         framePos.setY(track * m_tracksHeight);
1550
1551         // Check if clips can be inserted at that position
1552         for (int i = 0; i < ids.size(); ++i) {
1553             DocClipBase *clip = m_document->getBaseClip(ids.at(i));
1554             if (clip == NULL) {
1555                 kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << ids.at(i);
1556                 return false;
1557             }
1558             if (clip->getProducer() == NULL) {
1559                 emit displayMessage(i18n("Clip not ready"), ErrorMessage);
1560                 return false;
1561             }
1562             ItemInfo info;
1563             info.startPos = start;
1564             info.cropDuration = clip->duration();
1565             info.endPos = info.startPos + info.cropDuration;
1566             info.track = track;
1567             infoList.append(info);
1568             start += clip->duration();
1569         }
1570         if (!canBePastedTo(infoList, AVWIDGET)) {
1571             return true;
1572         }
1573         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1574         start = GenTime();
1575         for (int i = 0; i < ids.size(); ++i) {
1576             DocClipBase *clip = m_document->getBaseClip(ids.at(i));
1577             ItemInfo info;
1578             info.startPos = start;
1579             info.cropDuration = clip->duration();
1580             info.endPos = info.startPos + info.cropDuration;
1581             info.track = 0;
1582             start += info.cropDuration;
1583             offsetList.append(start);
1584             ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0, 1, getFrameWidth(), false);
1585             item->setFlag(QGraphicsItem::ItemIsMovable, false);
1586             m_selectionGroup->addToGroup(item);
1587             if (!clip->isPlaceHolder()) m_waitingThumbs.append(item);
1588         }
1589
1590         updateSnapPoints(NULL, offsetList);
1591         m_selectionGroup->setPos(framePos);
1592         scene()->addItem(m_selectionGroup);
1593         //m_selectionGroup->setZValue(10);
1594         m_thumbsTimer.start();
1595         return true;
1596
1597     } else {
1598         // the drag is not a clip (may be effect, ...)
1599         m_clipDrag = false;
1600         return false;
1601     }
1602 }
1603
1604
1605
1606 void CustomTrackView::dragEnterEvent(QDragEnterEvent * event)
1607 {
1608     if (insertDropClips(event->mimeData(), event->pos())) {
1609       if (event->source() == this) {
1610              event->setDropAction(Qt::MoveAction);
1611              event->accept();
1612          } else {
1613              event->setDropAction(Qt::MoveAction);
1614              event->acceptProposedAction();
1615          }
1616     } else QGraphicsView::dragEnterEvent(event);
1617 }
1618
1619 bool CustomTrackView::itemCollision(AbstractClipItem *item, ItemInfo newPos)
1620 {
1621     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);
1622     QList<QGraphicsItem*> collindingItems = scene()->items(shape, Qt::IntersectsItemShape);
1623     collindingItems.removeAll(item);
1624     if (collindingItems.isEmpty()) return false;
1625     else {
1626         for (int i = 0; i < collindingItems.count(); i++) {
1627             QGraphicsItem *collision = collindingItems.at(i);
1628             if (collision->type() == item->type()) {
1629                 // Collision
1630                 kDebug() << "// COLLISIION DETECTED";
1631                 return true;
1632             }
1633         }
1634         return false;
1635     }
1636 }
1637
1638 void CustomTrackView::slotRefreshEffects(ClipItem *clip)
1639 {
1640     int track = m_document->tracksCount() - clip->track();
1641     GenTime pos = clip->startPos();
1642     if (!m_document->renderer()->mltRemoveEffect(track, pos, -1, false, false)) {
1643         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1644         return;
1645     }
1646     bool success = true;
1647     for (int i = 0; i < clip->effectsCount(); i++) {
1648         if (!m_document->renderer()->mltAddEffect(track, pos, getEffectArgs(clip->effect(i)), false)) success = false;
1649     }
1650     if (!success) emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1651     m_document->renderer()->doRefresh();
1652 }
1653
1654 void CustomTrackView::addEffect(int track, GenTime pos, QDomElement effect)
1655 {
1656     if (pos < GenTime()) {
1657         // Add track effect
1658         if (effect.attribute("id") == "speed") {
1659             emit displayMessage(i18n("Cannot add speed effect to track"), ErrorMessage);
1660             return;
1661         }
1662         clearSelection();
1663         m_document->addTrackEffect(track - 1, effect);
1664         m_document->renderer()->mltAddTrackEffect(track, getEffectArgs(effect));
1665         emit updateTrackEffectState(track - 1);
1666         emit showTrackEffects(track, m_document->trackInfoAt(track - 1));
1667         return;
1668     }
1669     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), m_document->tracksCount() - track);
1670     if (clip) {
1671         // Special case: speed effect
1672         if (effect.attribute("id") == "speed") {
1673             if (clip->clipType() != VIDEO && clip->clipType() != AV && clip->clipType() != PLAYLIST) {
1674                 emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1675                 return;
1676             }
1677             QLocale locale;
1678             double speed = locale.toDouble(EffectsList::parameter(effect, "speed")) / 100.0;
1679             int strobe = EffectsList::parameter(effect, "strobe").toInt();
1680             if (strobe == 0) strobe = 1;
1681             doChangeClipSpeed(clip->info(), clip->speedIndependantInfo(), speed, 1.0, strobe, clip->baseClip()->getId());
1682             EffectsParameterList params = clip->addEffect(effect);
1683             m_document->renderer()->mltAddEffect(track, pos, params);
1684             if (clip->isSelected()) emit clipItemSelected(clip);
1685             return;
1686         }
1687         EffectsParameterList params = clip->addEffect(effect);
1688         if (!m_document->renderer()->mltAddEffect(track, pos, params))
1689             emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1690         clip->setSelectedEffect(params.paramValue("kdenlive_ix").toInt());
1691         if (clip->isSelected()) emit clipItemSelected(clip);
1692     } else emit displayMessage(i18n("Cannot find clip to add effect"), ErrorMessage);
1693 }
1694
1695 void CustomTrackView::deleteEffect(int track, GenTime pos, QDomElement effect)
1696 {
1697     QString index = effect.attribute("kdenlive_ix");
1698     if (pos < GenTime()) {
1699         // Delete track effect
1700         if (m_document->renderer()->mltRemoveTrackEffect(track, index.toInt(), true)) {
1701             m_document->removeTrackEffect(track - 1, effect);
1702         }
1703         else emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1704         emit updateTrackEffectState(track - 1);
1705         emit showTrackEffects(track, m_document->trackInfoAt(track - 1));
1706         return;
1707     }
1708     // Special case: speed effect
1709     if (effect.attribute("id") == "speed") {
1710         ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), m_document->tracksCount() - track);
1711         if (clip) {
1712             doChangeClipSpeed(clip->info(), clip->speedIndependantInfo(), 1.0, clip->speed(), 1, clip->baseClip()->getId());
1713             clip->deleteEffect(index);
1714             emit clipItemSelected(clip);
1715             m_document->renderer()->mltRemoveEffect(track, pos, index.toInt(), true);
1716             return;
1717         }
1718     }
1719     if (!m_document->renderer()->mltRemoveEffect(track, pos, index.toInt(), true)) {
1720         kDebug() << "// ERROR REMOV EFFECT: " << index << ", DISABLE: " << effect.attribute("disable");
1721         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1722         return;
1723     }
1724     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), m_document->tracksCount() - track);
1725     if (clip) {
1726         clip->deleteEffect(index);
1727         emit clipItemSelected(clip);
1728     }
1729 }
1730
1731 void CustomTrackView::slotAddGroupEffect(QDomElement effect, AbstractGroupItem *group)
1732 {
1733     QList<QGraphicsItem *> itemList = group->childItems();
1734     QUndoCommand *effectCommand = new QUndoCommand();
1735     QString effectName;
1736     QDomElement namenode = effect.firstChildElement("name");
1737     if (!namenode.isNull()) effectName = i18n(namenode.text().toUtf8().data());
1738     else effectName = i18n("effect");
1739     effectCommand->setText(i18n("Add %1", effectName));
1740     for (int i = 0; i < itemList.count(); i++) {
1741         if (itemList.at(i)->type() == AVWIDGET) {
1742             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1743             if (effect.tagName() == "effectgroup") {
1744                 QDomNodeList effectlist = effect.elementsByTagName("effect");
1745                 for (int j = 0; j < effectlist.count(); j++) {
1746                     QDomElement subeffect = effectlist.at(j).toElement();
1747                     if (subeffect.hasAttribute("kdenlive_info")) {
1748                         // effect is in a group
1749                         EffectInfo effectInfo;
1750                         effectInfo.fromString(subeffect.attribute("kdenlive_info"));
1751                         if (effectInfo.groupIndex < 0) {
1752                             // group needs to be appended
1753                             effectInfo.groupIndex = item->nextFreeEffectGroupIndex();
1754                             subeffect.setAttribute("kdenlive_info", effectInfo.toString());
1755                         }
1756                     }
1757                     processEffect(item, subeffect, effectCommand);
1758                 }
1759             }
1760             else {
1761                 processEffect(item, effect, effectCommand);
1762             }
1763         }
1764     }
1765     if (effectCommand->childCount() > 0) {
1766         m_commandStack->push(effectCommand);
1767         setDocumentModified();
1768     } else delete effectCommand;
1769 }
1770
1771 void CustomTrackView::slotAddEffect(ClipItem *clip, QDomElement effect)
1772 {
1773     if (clip) slotAddEffect(effect, clip->startPos(), clip->track());
1774 }
1775
1776 void CustomTrackView::slotAddEffect(QDomElement effect, GenTime pos, int track)
1777 {
1778     QList<QGraphicsItem *> itemList;
1779     QUndoCommand *effectCommand = new QUndoCommand();
1780     QString effectName;
1781     if (effect.tagName() == "effectgroup") {
1782         effectName = effect.attribute("name");
1783     } else {
1784         QDomElement namenode = effect.firstChildElement("name");
1785         if (!namenode.isNull()) effectName = i18n(namenode.text().toUtf8().data());
1786         else effectName = i18n("effect");
1787     }
1788     effectCommand->setText(i18n("Add %1", effectName));
1789
1790     if (track == -1) itemList = scene()->selectedItems();
1791     if (itemList.isEmpty()) {
1792         ClipItem *clip = getClipItemAt((int) pos.frames(m_document->fps()), track);
1793         if (clip) itemList.append(clip);
1794         else emit displayMessage(i18n("Select a clip if you want to apply an effect"), ErrorMessage);
1795     }
1796
1797     //expand groups
1798     for (int i = 0; i < itemList.count(); i++) {
1799         if (itemList.at(i)->type() == GROUPWIDGET) {
1800             QList<QGraphicsItem *> subitems = itemList.at(i)->childItems();
1801             for (int j = 0; j < subitems.count(); j++) {
1802                 if (!itemList.contains(subitems.at(j))) itemList.append(subitems.at(j));
1803             }
1804         }
1805     }
1806
1807     for (int i = 0; i < itemList.count(); i++) {
1808         if (itemList.at(i)->type() == AVWIDGET) {
1809             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
1810             if (effect.tagName() == "effectgroup") {
1811                 QDomNodeList effectlist = effect.elementsByTagName("effect");
1812                 for (int j = 0; j < effectlist.count(); j++) {
1813                     QDomElement subeffect = effectlist.at(j).toElement();
1814                     if (subeffect.hasAttribute("kdenlive_info")) {
1815                         // effect is in a group
1816                         EffectInfo effectInfo;
1817                         effectInfo.fromString(subeffect.attribute("kdenlive_info"));
1818                         if (effectInfo.groupIndex < 0) {
1819                             // group needs to be appended
1820                             effectInfo.groupIndex = item->nextFreeEffectGroupIndex();
1821                             subeffect.setAttribute("kdenlive_info", effectInfo.toString());
1822                         }
1823                     }
1824                     processEffect(item, subeffect, effectCommand);
1825                 }
1826             }
1827             else processEffect(item, effect, effectCommand);
1828         }
1829     }
1830     if (effectCommand->childCount() > 0) {
1831         m_commandStack->push(effectCommand);
1832         setDocumentModified();
1833         if (effectCommand->childCount() == 1) {
1834             // Display newly added clip effect
1835             for (int i = 0; i < itemList.count(); i++) {
1836                 if (itemList.at(i)->type() == AVWIDGET) {
1837                     ClipItem *clip = static_cast<ClipItem *>(itemList.at(i));
1838                     clip->setSelectedEffect(clip->effectsCount());
1839                     if (!clip->isSelected()) {
1840                         clearSelection(false);
1841                         clip->setSelected(true);
1842                         emit clipItemSelected(clip);
1843                     }
1844                     break;
1845                 }
1846             }
1847         }
1848     } else delete effectCommand;
1849 }
1850
1851 void CustomTrackView::processEffect(ClipItem *item, QDomElement effect, QUndoCommand *effectCommand)
1852 {
1853     if (effect.attribute("type") == "audio") {
1854         // Don't add audio effects on video clips
1855         if (item->isVideoOnly() || (item->clipType() != AUDIO && item->clipType() != AV && item->clipType() != PLAYLIST)) {
1856             /* do not show error message when item is part of a group as the user probably knows what he does then
1857             * and the message is annoying when working with the split audio feature */
1858             if (!item->parentItem() || item->parentItem() == m_selectionGroup)
1859                 emit displayMessage(i18n("Cannot add an audio effect to this clip"), ErrorMessage);
1860             return;
1861         }
1862     } else if (effect.attribute("type") == "video" || !effect.hasAttribute("type")) {
1863         // Don't add video effect on audio clips
1864         if (item->isAudioOnly() || item->clipType() == AUDIO) {
1865             /* do not show error message when item is part of a group as the user probably knows what he does then
1866             * and the message is annoying when working with the split audio feature */
1867             if (!item->parentItem() || item->parentItem() == m_selectionGroup)
1868                 emit displayMessage(i18n("Cannot add a video effect to this clip"), ErrorMessage);
1869             return;
1870         }
1871     }
1872     if (effect.attribute("unique", "0") != "0" && item->hasEffect(effect.attribute("tag"), effect.attribute("id")) != -1) {
1873         emit displayMessage(i18n("Effect already present in clip"), ErrorMessage);
1874         return;
1875     }
1876     if (item->isItemLocked()) {
1877         return;
1878     }
1879
1880     if (effect.attribute("id") == "freeze" && m_cursorPos > item->startPos().frames(m_document->fps()) && m_cursorPos < item->endPos().frames(m_document->fps())) {
1881         item->initEffect(effect, m_cursorPos - item->startPos().frames(m_document->fps()));
1882     } else {
1883         item->initEffect(effect);
1884     }
1885     new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), effect, true, effectCommand);
1886 }
1887
1888 void CustomTrackView::slotDeleteEffect(ClipItem *clip, int track, QDomElement effect, bool affectGroup)
1889 {
1890     if (clip == NULL) {
1891         // delete track effect
1892         AddEffectCommand *command = new AddEffectCommand(this, track, GenTime(-1), effect, false);
1893         m_commandStack->push(command);
1894         setDocumentModified();
1895         return;
1896     }
1897     if (affectGroup && clip->parentItem() && clip->parentItem() == m_selectionGroup) {
1898         //clip is in a group, also remove the effect in other clips of the group
1899         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1900         QUndoCommand *delCommand = new QUndoCommand();
1901         QString effectName;
1902         QDomElement namenode = effect.firstChildElement("name");
1903         if (!namenode.isNull()) effectName = i18n(namenode.text().toUtf8().data());
1904         else effectName = i18n("effect");
1905         delCommand->setText(i18n("Delete %1", effectName));
1906
1907         //expand groups
1908         for (int i = 0; i < items.count(); i++) {
1909             if (items.at(i)->type() == GROUPWIDGET) {
1910                 QList<QGraphicsItem *> subitems = items.at(i)->childItems();
1911                 for (int j = 0; j < subitems.count(); j++) {
1912                     if (!items.contains(subitems.at(j))) items.append(subitems.at(j));
1913                 }
1914             }
1915         }
1916
1917         for (int i = 0; i < items.count(); i++) {
1918             if (items.at(i)->type() == AVWIDGET) {
1919                 ClipItem *item = static_cast <ClipItem *>(items.at(i));
1920                 int ix = item->hasEffect(effect.attribute("tag"), effect.attribute("id"));
1921                 if (ix != -1) {
1922                     QDomElement eff = item->effectAtIndex(ix);
1923                     new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), eff, false, delCommand);
1924                 }
1925             }
1926         }
1927         if (delCommand->childCount() > 0)
1928             m_commandStack->push(delCommand);
1929         else
1930             delete delCommand;
1931         setDocumentModified();
1932         return;
1933     }
1934     AddEffectCommand *command = new AddEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), effect, false);
1935     m_commandStack->push(command);
1936     setDocumentModified();
1937 }
1938
1939 void CustomTrackView::updateEffect(int track, GenTime pos, QDomElement insertedEffect, bool updateEffectStack)
1940 {
1941     if (insertedEffect.isNull()) {
1942         kDebug()<<"// Trying to add null effect";
1943         emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
1944         return;
1945     }
1946     int ix = insertedEffect.attribute("kdenlive_ix").toInt();
1947     QDomElement effect = insertedEffect.cloneNode().toElement();
1948     //kDebug() << "// update effect ix: " << effect.attribute("kdenlive_ix")<<", GAIN: "<<EffectsList::parameter(effect, "gain");
1949     if (pos < GenTime()) {
1950         // editing a track effect
1951         EffectsParameterList effectParams = getEffectArgs(effect);
1952         // check if we are trying to reset a keyframe effect
1953         /*if (effectParams.hasParam("keyframes") && effectParams.paramValue("keyframes").isEmpty()) {
1954             clip->initEffect(effect);
1955             effectParams = getEffectArgs(effect);
1956         }*/
1957         if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - track, pos, effectParams)) {
1958             emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
1959         }
1960         m_document->setTrackEffect(m_document->tracksCount() - track - 1, ix, effect);
1961         emit updateTrackEffectState(track);
1962         setDocumentModified();
1963         return;
1964
1965     }
1966     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), m_document->tracksCount() - track);
1967     if (clip) {
1968         // Special case: speed effect
1969         if (effect.attribute("id") == "speed") {
1970             if (effect.attribute("disable") == "1") {
1971                 doChangeClipSpeed(clip->info(), clip->speedIndependantInfo(), 1.0, clip->speed(), 1, clip->baseClip()->getId());
1972             } else {
1973                 QLocale locale;
1974                 double speed = locale.toDouble(EffectsList::parameter(effect, "speed")) / 100.0;
1975                 int strobe = EffectsList::parameter(effect, "strobe").toInt();
1976                 if (strobe == 0) strobe = 1;
1977                 doChangeClipSpeed(clip->info(), clip->speedIndependantInfo(), speed, clip->speed(), strobe, clip->baseClip()->getId());
1978             }
1979             clip->updateEffect(effect);
1980             if (updateEffectStack && clip->isSelected())
1981                 emit clipItemSelected(clip);
1982             if (ix == clip->selectedEffectIndex()) {
1983                 // make sure to update display of clip keyframes
1984                 clip->setSelectedEffect(ix);
1985             }
1986             return;
1987         }
1988
1989         EffectsParameterList effectParams = getEffectArgs(effect);
1990         // check if we are trying to reset a keyframe effect
1991         if (effectParams.hasParam("keyframes") && effectParams.paramValue("keyframes").isEmpty()) {
1992             clip->initEffect(effect);
1993             effectParams = getEffectArgs(effect);
1994         }
1995
1996         if (effect.attribute("tag") == "volume" || effect.attribute("tag") == "brightness") {
1997             // A fade effect was modified, update the clip
1998             if (effect.attribute("id") == "fadein" || effect.attribute("id") == "fade_from_black") {
1999                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
2000                 clip->setFadeIn(pos);
2001             }
2002             if (effect.attribute("id") == "fadeout" || effect.attribute("id") == "fade_to_black") {
2003                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
2004                 clip->setFadeOut(pos);
2005             }
2006         }
2007         bool success = m_document->renderer()->mltEditEffect(m_document->tracksCount() - clip->track(), clip->startPos(), effectParams);
2008
2009         if (success) {
2010             clip->updateEffect(effect);
2011             if (updateEffectStack && clip->isSelected()) {
2012                 emit clipItemSelected(clip);
2013             }
2014             if (ix == clip->selectedEffectIndex()) {
2015                 // make sure to update display of clip keyframes
2016                 clip->setSelectedEffect(ix);
2017             }
2018         }
2019         else emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2020     }
2021     else emit displayMessage(i18n("Cannot find clip to update effect"), ErrorMessage);
2022     setDocumentModified();
2023 }
2024
2025 void CustomTrackView::updateEffectState(int track, GenTime pos, QList <int> effectIndexes, bool disable, bool updateEffectStack)
2026 {
2027     if (pos < GenTime()) {
2028         // editing a track effect
2029         if (!m_document->renderer()->mltEnableEffects(m_document->tracksCount() - track, pos, effectIndexes, disable)) {
2030             emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2031             return;
2032         }
2033         m_document->enableTrackEffects(m_document->tracksCount() - track - 1, effectIndexes, disable);
2034         emit updateTrackEffectState(track);
2035         setDocumentModified();
2036         return;
2037     }
2038     // editing a clip effect
2039     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), m_document->tracksCount() - track);
2040     if (clip) {
2041         bool success = m_document->renderer()->mltEnableEffects(m_document->tracksCount() - clip->track(), clip->startPos(), effectIndexes, disable);
2042         if (success) {
2043             clip->enableEffects(effectIndexes, disable);
2044             if (updateEffectStack && clip->isSelected()) {
2045                 emit clipItemSelected(clip);
2046             }
2047             if (effectIndexes.contains(clip->selectedEffectIndex())) {
2048                 // make sure to update display of clip keyframes
2049                 clip->setSelectedEffect(clip->selectedEffectIndex());
2050             }
2051         }
2052         else emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2053     }
2054     else emit displayMessage(i18n("Cannot find clip to update effect"), ErrorMessage);
2055 }
2056
2057 void CustomTrackView::moveEffect(int track, GenTime pos, QList <int> oldPos, QList <int> newPos)
2058 {
2059     if (pos < GenTime()) {
2060         // Moving track effect
2061         int documentTrack = m_document->tracksCount() - track - 1;
2062         int max = m_document->getTrackEffects(documentTrack).count();
2063         int new_position = newPos.at(0);
2064         if (new_position > max) {
2065             new_position = max;
2066         }
2067         int old_position = oldPos.at(0);
2068         for (int i = 0; i < newPos.count(); i++) {
2069             QDomElement act = m_document->getTrackEffect(documentTrack, new_position);
2070             if (old_position > new_position) {
2071                 // Moving up, we need to adjust index
2072                 old_position = oldPos.at(i);
2073                 new_position = newPos.at(i);
2074             }
2075             QDomElement before = m_document->getTrackEffect(documentTrack, old_position);
2076             if (!act.isNull() && !before.isNull()) {
2077                 m_document->setTrackEffect(documentTrack, new_position, before);
2078                 m_document->renderer()->mltMoveEffect(m_document->tracksCount() - track, pos, old_position, new_position);
2079             } else emit displayMessage(i18n("Cannot move effect"), ErrorMessage);
2080         }
2081         emit showTrackEffects(m_document->tracksCount() - track, m_document->trackInfoAt(documentTrack));
2082         return;
2083     }
2084     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), m_document->tracksCount() - track);
2085     if (clip) {
2086         int new_position = newPos.at(0);
2087         if (new_position > clip->effectsCount()) {
2088             new_position = clip->effectsCount();
2089         }
2090         int old_position = oldPos.at(0);
2091         for (int i = 0; i < newPos.count(); i++) {
2092             QDomElement act = clip->effectAtIndex(new_position);
2093             if (old_position > new_position) {
2094                 // Moving up, we need to adjust index
2095                 old_position = oldPos.at(i);
2096                 new_position = newPos.at(i);
2097             }
2098             QDomElement before = clip->effectAtIndex(old_position);
2099             if (act.isNull() || before.isNull()) {
2100                 emit displayMessage(i18n("Cannot move effect"), ErrorMessage);
2101                 return;
2102             }
2103             clip->moveEffect(before, new_position);
2104             // special case: speed effect, which is a pseudo-effect, not appearing in MLT's effects
2105             if (act.attribute("id") == "speed") {
2106                 m_document->renderer()->mltUpdateEffectPosition(track, pos, old_position, new_position);
2107             } else if (before.attribute("id") == "speed") {
2108                 m_document->renderer()->mltUpdateEffectPosition(track, pos, new_position, old_position);
2109             } else m_document->renderer()->mltMoveEffect(track, pos, old_position, new_position);
2110         }
2111         clip->setSelectedEffect(newPos.at(0));
2112         emit clipItemSelected(clip);
2113         setDocumentModified();
2114     } else emit displayMessage(i18n("Cannot move effect"), ErrorMessage);
2115 }
2116
2117 void CustomTrackView::slotChangeEffectState(ClipItem *clip, int track, QList <int> effectIndexes, bool disable)
2118 {
2119     ChangeEffectStateCommand *command;
2120     if (clip == NULL) {
2121         // editing track effect
2122         command = new ChangeEffectStateCommand(this, m_document->tracksCount() - track, GenTime(-1), effectIndexes, disable, false, true);
2123     } else {
2124         // Check if we have a speed effect, disabling / enabling it needs a special procedure since it is a pseudoo effect
2125         QList <int> speedEffectIndexes;
2126         for (int i = 0; i < effectIndexes.count(); i++) {
2127             QDomElement effect = clip->effectAtIndex(effectIndexes.at(i));
2128             if (effect.attribute("id") == "speed") {
2129                 // speed effect
2130                 speedEffectIndexes << effectIndexes.at(i);
2131                 QDomElement newEffect = effect.cloneNode().toElement();
2132                 newEffect.setAttribute("disable", (int) disable);
2133                 EditEffectCommand *editcommand = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), effect, newEffect, effectIndexes.at(i), false, true);
2134                 m_commandStack->push(editcommand);
2135             }
2136         }
2137         for (int j = 0; j < speedEffectIndexes.count(); j++) {
2138             effectIndexes.removeAll(speedEffectIndexes.at(j));
2139         }
2140         command = new ChangeEffectStateCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), effectIndexes, disable, false, true);
2141     }
2142     m_commandStack->push(command);
2143     setDocumentModified();
2144 }
2145
2146 void CustomTrackView::slotChangeEffectPosition(ClipItem *clip, int track, QList <int> currentPos, int newPos)
2147 {
2148     MoveEffectCommand *command;
2149     if (clip == NULL) {
2150         // editing track effect
2151         command = new MoveEffectCommand(this, m_document->tracksCount() - track, GenTime(-1), currentPos, newPos);
2152     } else command = new MoveEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), currentPos, newPos);
2153     m_commandStack->push(command);
2154     setDocumentModified();
2155 }
2156
2157 void CustomTrackView::slotUpdateClipEffect(ClipItem *clip, int track, QDomElement oldeffect, QDomElement effect, int ix, bool refreshEffectStack)
2158 {
2159     EditEffectCommand *command;
2160     if (clip) command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldeffect, effect, ix, refreshEffectStack, true);
2161     else command = new EditEffectCommand(this, m_document->tracksCount() - track, GenTime(-1), oldeffect, effect, ix, refreshEffectStack, true);
2162     m_commandStack->push(command);
2163 }
2164
2165 void CustomTrackView::slotUpdateClipRegion(ClipItem *clip, int ix, QString region)
2166 {
2167     QDomElement effect = clip->getEffectAtIndex(ix);
2168     QDomElement oldeffect = effect.cloneNode().toElement();
2169     effect.setAttribute("region", region);
2170     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldeffect, effect, ix, true, true);
2171     m_commandStack->push(command);
2172 }
2173
2174 ClipItem *CustomTrackView::cutClip(ItemInfo info, GenTime cutTime, bool cut, bool execute)
2175 {
2176     if (cut) {
2177         // cut clip
2178         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
2179         if (!item || cutTime >= item->endPos() || cutTime <= item->startPos()) {
2180             emit displayMessage(i18n("Cannot find clip to cut"), ErrorMessage);
2181             if (item)
2182                 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);
2183             else
2184                 kDebug() << "/// ERROR NO CLIP at: " << info.startPos.frames(m_document->fps()) << ", track: " << info.track;
2185             m_blockRefresh = false;
2186             return NULL;
2187         }
2188
2189         if (execute) m_document->renderer()->mltCutClip(m_document->tracksCount() - info.track, cutTime);
2190         int cutPos = (int) cutTime.frames(m_document->fps());
2191         ItemInfo newPos;
2192         newPos.startPos = cutTime;
2193         newPos.endPos = info.endPos;
2194         newPos.cropStart = item->info().cropStart + (cutTime - info.startPos);
2195         newPos.track = info.track;
2196         newPos.cropDuration = newPos.endPos - newPos.startPos;
2197
2198         bool snap = KdenliveSettings::snaptopoints();
2199         KdenliveSettings::setSnaptopoints(false);
2200         ClipItem *dup = item->clone(newPos);
2201
2202         // remove unwanted effects
2203         // fade in from 2nd part of the clip
2204         int ix = dup->hasEffect(QString(), "fadein");
2205         if (ix != -1) {
2206             QDomElement oldeffect = dup->effectAtIndex(ix);
2207             dup->deleteEffect(oldeffect.attribute("kdenlive_ix"));
2208         }
2209         ix = dup->hasEffect(QString(), "fade_from_black");
2210         if (ix != -1) {
2211             QDomElement oldeffect = dup->effectAtIndex(ix);
2212             dup->deleteEffect(oldeffect.attribute("kdenlive_ix"));
2213         }
2214         // fade out from 1st part of the clip
2215         ix = item->hasEffect(QString(), "fadeout");
2216         if (ix != -1) {
2217             QDomElement oldeffect = item->effectAtIndex(ix);
2218             item->deleteEffect(oldeffect.attribute("kdenlive_ix"));
2219         }
2220         ix = item->hasEffect(QString(), "fade_to_black");
2221         if (ix != -1) {
2222             QDomElement oldeffect = item->effectAtIndex(ix);
2223             item->deleteEffect(oldeffect.attribute("kdenlive_ix"));
2224         }
2225
2226
2227         item->resizeEnd(cutPos);
2228         scene()->addItem(dup);
2229         if (item->checkKeyFrames())
2230             slotRefreshEffects(item);
2231         if (dup->checkKeyFrames())
2232             slotRefreshEffects(dup);
2233
2234         item->baseClip()->addReference();
2235         m_document->updateClip(item->baseClip()->getId());
2236         setDocumentModified();
2237         KdenliveSettings::setSnaptopoints(snap);
2238         if (execute && item->isSelected())
2239             emit clipItemSelected(item);
2240         return dup;
2241     } else {
2242         // uncut clip
2243
2244         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
2245         ClipItem *dup = getClipItemAt((int) cutTime.frames(m_document->fps()), info.track);
2246
2247         if (!item || !dup || item == dup) {
2248             emit displayMessage(i18n("Cannot find clip to uncut"), ErrorMessage);
2249             m_blockRefresh = false;
2250             return NULL;
2251         }
2252         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, cutTime) == false) {
2253             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(cutTime.frames(m_document->fps())), info.track), ErrorMessage);
2254             return NULL;
2255         }
2256
2257         bool snap = KdenliveSettings::snaptopoints();
2258         KdenliveSettings::setSnaptopoints(false);
2259
2260         // join fade effects again
2261         int ix = dup->hasEffect(QString(), "fadeout");
2262         if (ix != -1) {
2263             QDomElement effect = dup->effectAtIndex(ix);
2264             item->addEffect(effect);
2265         }
2266         ix = dup->hasEffect(QString(), "fade_to_black");
2267         if (ix != -1) {
2268             QDomElement effect = dup->effectAtIndex(ix);
2269             item->addEffect(effect);
2270         }
2271
2272         m_waitingThumbs.removeAll(dup);
2273         bool selected = item->isSelected();
2274         if (dup->isSelected()) {
2275             selected = true;
2276             item->setSelected(true);
2277             emit clipItemSelected(NULL);
2278         }
2279         dup->baseClip()->removeReference();
2280         m_document->updateClip(dup->baseClip()->getId());
2281         scene()->removeItem(dup);
2282         delete dup;
2283         dup = NULL;
2284
2285         ItemInfo clipinfo = item->info();
2286         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2287         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, info.endPos - info.startPos);
2288         if (success) {
2289             item->resizeEnd((int) info.endPos.frames(m_document->fps()));
2290             setDocumentModified();
2291         } else {
2292             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2293         }
2294         KdenliveSettings::setSnaptopoints(snap);
2295         if (execute && selected)
2296             emit clipItemSelected(item);
2297         return item;
2298     }
2299     //QTimer::singleShot(3000, this, SLOT(slotEnableRefresh()));
2300 }
2301
2302 void CustomTrackView::slotEnableRefresh()
2303 {
2304     m_blockRefresh = false;
2305 }
2306
2307 void CustomTrackView::slotAddTransitionToSelectedClips(QDomElement transition)
2308 {
2309     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2310     if (itemList.count() == 1) {
2311         if (itemList.at(0)->type() == AVWIDGET) {
2312             ClipItem *item = (ClipItem *) itemList.at(0);
2313             ItemInfo info;
2314             info.track = item->track();
2315             ClipItem *transitionClip = NULL;
2316             const int transitiontrack = getPreviousVideoTrack(info.track);
2317             GenTime pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
2318             if (pos < item->startPos() + item->cropDuration() / 2) {
2319                 // add transition to clip start
2320                 info.startPos = item->startPos();
2321                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
2322                 if (transitionClip && transitionClip->endPos() < item->endPos()) {
2323                     info.endPos = transitionClip->endPos();
2324                 } else info.endPos = info.startPos + GenTime(65, m_document->fps());
2325                 // Check there is no other transition at that place
2326                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
2327                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
2328                 QList<QGraphicsItem *> selection = m_scene->items(r);
2329                 bool transitionAccepted = true;
2330                 for (int i = 0; i < selection.count(); i++) {
2331                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
2332                         Transition *tr = static_cast <Transition *>(selection.at(i));
2333                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
2334                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
2335                         } else transitionAccepted = false;
2336                     }
2337                 }
2338                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
2339                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
2340
2341             } else {
2342                 // add transition to clip  end
2343                 info.endPos = item->endPos();
2344                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
2345                 if (transitionClip && transitionClip->startPos() > item->startPos()) {
2346                     info.startPos = transitionClip->startPos();
2347                 } else info.startPos = info.endPos - GenTime(65, m_document->fps());
2348                 if (transition.attribute("tag") == "luma") EffectsList::setParameter(transition, "reverse", "1");
2349                 else if (transition.attribute("id") == "slide") EffectsList::setParameter(transition, "invert", "1");
2350
2351                 // Check there is no other transition at that place
2352                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
2353                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
2354                 QList<QGraphicsItem *> selection = m_scene->items(r);
2355                 bool transitionAccepted = true;
2356                 for (int i = 0; i < selection.count(); i++) {
2357                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
2358                         Transition *tr = static_cast <Transition *>(selection.at(i));
2359                         if (info.endPos - tr->endPos() > GenTime(5, m_document->fps())) {
2360                             if (tr->endPos() > info.startPos) info.startPos = tr->endPos();
2361                         } else transitionAccepted = false;
2362                     }
2363                 }
2364                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
2365                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
2366             }
2367         }
2368     } else for (int i = 0; i < itemList.count(); i++) {
2369             if (itemList.at(i)->type() == AVWIDGET) {
2370                 ClipItem *item = (ClipItem *) itemList.at(i);
2371                 ItemInfo info;
2372                 info.startPos = item->startPos();
2373                 info.endPos = info.startPos + GenTime(65, m_document->fps());
2374                 info.track = item->track();
2375
2376                 // Check there is no other transition at that place
2377                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
2378                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
2379                 QList<QGraphicsItem *> selection = m_scene->items(r);
2380                 bool transitionAccepted = true;
2381                 for (int i = 0; i < selection.count(); i++) {
2382                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
2383                         Transition *tr = static_cast <Transition *>(selection.at(i));
2384                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
2385                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
2386                         } else transitionAccepted = false;
2387                     }
2388                 }
2389                 int transitiontrack = getPreviousVideoTrack(info.track);
2390                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
2391                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
2392             }
2393         }
2394 }
2395
2396 void CustomTrackView::slotAddTransition(ClipItem* /*clip*/, ItemInfo transitionInfo, int endTrack, QDomElement transition)
2397 {
2398     if (transitionInfo.startPos >= transitionInfo.endPos) {
2399         emit displayMessage(i18n("Invalid transition"), ErrorMessage);
2400         return;
2401     }
2402     AddTransitionCommand* command = new AddTransitionCommand(this, transitionInfo, endTrack, transition, false, true);
2403     m_commandStack->push(command);
2404     setDocumentModified();
2405 }
2406
2407 void CustomTrackView::addTransition(ItemInfo transitionInfo, int endTrack, QDomElement params, bool refresh)
2408 {
2409     Transition *tr = new Transition(transitionInfo, endTrack, m_document->fps(), params, true);
2410     //kDebug() << "---- ADDING transition " << params.attribute("value");
2411     if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, tr->toXML(), refresh)) {
2412         scene()->addItem(tr);
2413         setDocumentModified();
2414     } else {
2415         emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
2416         delete tr;
2417     }
2418 }
2419
2420 void CustomTrackView::deleteTransition(ItemInfo transitionInfo, int endTrack, QDomElement /*params*/, bool refresh)
2421 {
2422     Transition *item = getTransitionItemAt(transitionInfo.startPos, transitionInfo.track);
2423     if (!item) {
2424         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
2425         return;
2426     }
2427     m_document->renderer()->mltDeleteTransition(item->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, item->toXML(), refresh);
2428     if (m_dragItem == item) m_dragItem = NULL;
2429
2430 #if QT_VERSION >= 0x040600
2431     // animate item deletion
2432     item->closeAnimation();
2433 #else
2434     delete item;
2435 #endif
2436     emit transitionItemSelected(NULL);
2437     setDocumentModified();
2438 }
2439
2440 void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old)
2441 {
2442     //kDebug() << "TRANS UPDATE, TRACKS: " << old.attribute("transition_btrack") << ", NEW: " << tr->toXML().attribute("transition_btrack");
2443     QDomElement xml = tr->toXML();
2444     if (old.isNull() || xml.isNull()) {
2445         emit displayMessage(i18n("Cannot update transition"), ErrorMessage);
2446         return;
2447     }
2448     EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, xml, false);
2449     updateTrackDuration(tr->track(), command);
2450     m_commandStack->push(command);
2451     setDocumentModified();
2452 }
2453
2454 void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition, bool updateTransitionWidget)
2455 {
2456     Transition *item = getTransitionItemAt(pos, track);
2457     if (!item) {
2458         kWarning() << "Unable to find transition at pos :" << pos.frames(m_document->fps()) << ", ON track: " << track;
2459         return;
2460     }
2461
2462     bool force = false;
2463     if (oldTransition.attribute("transition_atrack") != transition.attribute("transition_atrack") || oldTransition.attribute("transition_btrack") != transition.attribute("transition_btrack"))
2464         force = true;
2465     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, force);
2466     //kDebug() << "ORIGINAL TRACK: "<< oldTransition.attribute("transition_btrack") << ", NEW TRACK: "<<transition.attribute("transition_btrack");
2467     item->setTransitionParameters(transition);
2468     if (updateTransitionWidget) {
2469         ItemInfo info = item->info();
2470         QPoint p;
2471         ClipItem *transitionClip = getClipItemAt(info.startPos, info.track);
2472         if (transitionClip && transitionClip->baseClip()) {
2473             QString size = transitionClip->baseClip()->getProperty("frame_size");
2474             double factor = transitionClip->baseClip()->getProperty("aspect_ratio").toDouble();
2475             if (factor == 0) factor = 1.0;
2476             p.setX((int)(size.section('x', 0, 0).toInt() * factor + 0.5));
2477             p.setY(size.section('x', 1, 1).toInt());
2478         }
2479         emit transitionItemSelected(item, getPreviousVideoTrack(info.track), p, true);
2480     }
2481     setDocumentModified();
2482 }
2483
2484 void CustomTrackView::dragMoveEvent(QDragMoveEvent * event)
2485 {
2486     if (m_clipDrag) {
2487         const QPointF pos = mapToScene(event->pos());
2488         if (m_selectionGroup) {
2489             m_selectionGroup->setPos(pos);
2490             emit mousePosition((int)(m_selectionGroup->scenePos().x() + 0.5));
2491             event->acceptProposedAction();
2492         } else {
2493             // Drag enter was not possible, try again at mouse position
2494             insertDropClips(event->mimeData(), event->pos());
2495             event->accept();
2496         }
2497     } else {
2498         QGraphicsView::dragMoveEvent(event);
2499     }
2500 }
2501
2502 void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event)
2503 {
2504     if (m_selectionGroup && m_clipDrag) {
2505         m_thumbsTimer.stop();
2506         m_waitingThumbs.clear();
2507         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
2508         qDeleteAll(items);
2509         scene()->destroyItemGroup(m_selectionGroup);
2510         m_selectionGroup = NULL;
2511     } else QGraphicsView::dragLeaveEvent(event);
2512 }
2513
2514 void CustomTrackView::dropEvent(QDropEvent * event)
2515 {
2516     if (m_selectionGroup && m_clipDrag) {
2517         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
2518         resetSelectionGroup();
2519         m_scene->clearSelection();
2520         bool hasVideoClip = false;
2521         QUndoCommand *addCommand = new QUndoCommand();
2522         addCommand->setText(i18n("Add timeline clip"));
2523         QList <ClipItem *> brokenClips;
2524
2525         for (int i = 0; i < items.count(); i++) {
2526             ClipItem *item = static_cast <ClipItem *>(items.at(i));
2527             if (!hasVideoClip && (item->clipType() == AV || item->clipType() == VIDEO)) hasVideoClip = true;
2528             if (items.count() == 1) {
2529                 updateClipTypeActions(item);
2530             } else {
2531                 updateClipTypeActions(NULL);
2532             }
2533
2534             //TODO: take care of edit mode for undo
2535             item->baseClip()->addReference();
2536             //item->setZValue(item->defaultZValue());
2537             m_document->updateClip(item->baseClip()->getId());
2538             ItemInfo info = item->info();
2539
2540             int tracknumber = m_document->tracksCount() - info.track - 1;
2541             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2542             if (isLocked) item->setItemLocked(true);
2543             ItemInfo clipInfo = info;
2544             clipInfo.track = m_document->tracksCount() - item->track();
2545
2546             int worked = m_document->renderer()->mltInsertClip(clipInfo, item->xml(), item->baseClip()->getProducer(item->track()), m_scene->editMode() == OVERWRITEEDIT, m_scene->editMode() == INSERTEDIT);
2547             if (worked == -1) {
2548                 emit displayMessage(i18n("Cannot insert clip in timeline"), ErrorMessage);
2549                 brokenClips.append(item);
2550                 continue;
2551             }
2552             adjustTimelineClips(m_scene->editMode(), item, ItemInfo(), addCommand);
2553
2554             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), m_scene->editMode() == OVERWRITEEDIT, m_scene->editMode() == INSERTEDIT, false, false, addCommand);
2555             updateTrackDuration(info.track, addCommand);
2556
2557             if (item->baseClip()->isTransparent() && getTransitionItemAtStart(info.startPos, info.track) == NULL) {
2558                 // add transparency transition
2559                 QDomElement trans = MainWindow::transitions.getEffectByTag("composite", "composite").cloneNode().toElement();
2560                 new AddTransitionCommand(this, info, getPreviousVideoTrack(info.track), trans, false, true, addCommand);
2561             }
2562             item->setSelected(true);
2563         }
2564         qDeleteAll(brokenClips);
2565         brokenClips.clear();
2566         if (addCommand->childCount() > 0) m_commandStack->push(addCommand);
2567         else delete addCommand;
2568
2569         // Automatic audio split
2570         if (KdenliveSettings::splitaudio())
2571             splitAudio();
2572         setDocumentModified();
2573
2574         /*
2575         // debug info
2576         QRectF rect(0, 1 * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
2577         QList<QGraphicsItem *> selection = m_scene->items(rect);
2578         QStringList timelineList;
2579
2580         kDebug()<<"// ITEMS on TRACK: "<<selection.count();
2581         for (int i = 0; i < selection.count(); i++) {
2582                if (selection.at(i)->type() == AVWIDGET) {
2583                    ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
2584                    int start = clip->startPos().frames(m_document->fps());
2585                    int end = clip->endPos().frames(m_document->fps());
2586                    timelineList.append(QString::number(start) + "-" + QString::number(end));
2587             }
2588         }
2589         kDebug() << "// COMPARE:\n" << timelineList << "\n-------------------";
2590         */
2591
2592         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
2593         if (items.count() > 1) {
2594             groupSelectedItems(true);
2595         } else if (items.count() == 1) {
2596             m_dragItem = static_cast <AbstractClipItem *>(items.at(0));
2597             emit clipItemSelected((ClipItem*)m_dragItem, false);
2598         }
2599         event->setDropAction(Qt::MoveAction);
2600         event->accept();
2601
2602         /// \todo enable when really working
2603 //        alignAudio();
2604
2605     } else QGraphicsView::dropEvent(event);
2606     setFocus();
2607 }
2608
2609 void CustomTrackView::adjustTimelineClips(EDITMODE mode, ClipItem *item, ItemInfo posinfo, QUndoCommand *command)
2610 {
2611     bool snap = KdenliveSettings::snaptopoints();
2612     KdenliveSettings::setSnaptopoints(false);
2613     if (mode == OVERWRITEEDIT) {
2614         // if we are in overwrite mode, move clips accordingly
2615         ItemInfo info;
2616         if (item == NULL) info = posinfo;
2617         else info = item->info();
2618         QRectF rect(info.startPos.frames(m_document->fps()), info.track * m_tracksHeight + m_tracksHeight / 2, (info.endPos - info.startPos).frames(m_document->fps()) - 1, 5);
2619         QList<QGraphicsItem *> selection = m_scene->items(rect);
2620         if (item) selection.removeAll(item);
2621         for (int i = 0; i < selection.count(); i++) {
2622             if (!selection.at(i)->isEnabled()) continue;
2623             if (selection.at(i)->type() == AVWIDGET) {
2624                 ClipItem *clip = static_cast<ClipItem *>(selection.at(i));
2625                 if (clip->startPos() < info.startPos) {
2626                     if (clip->endPos() > info.endPos) {
2627                         ItemInfo clipInfo = clip->info();
2628                         ItemInfo dupInfo = clipInfo;
2629                         GenTime diff = info.startPos - clipInfo.startPos;
2630                         dupInfo.startPos = info.startPos;
2631                         dupInfo.cropStart += diff;
2632                         dupInfo.cropDuration = clipInfo.endPos - info.startPos;
2633                         ItemInfo newdupInfo = dupInfo;
2634                         GenTime diff2 = info.endPos - info.startPos;
2635                         newdupInfo.startPos = info.endPos;
2636                         newdupInfo.cropStart += diff2;
2637                         newdupInfo.cropDuration = clipInfo.endPos - info.endPos;
2638                         new RazorClipCommand(this, clipInfo, info.startPos, false, command);
2639                         new ResizeClipCommand(this, dupInfo, newdupInfo, false, false, command);
2640                         ClipItem *dup = cutClip(clipInfo, info.startPos, true, false);
2641                         if (dup) dup->resizeStart(info.endPos.frames(m_document->fps()));
2642                     } else {
2643                         ItemInfo newclipInfo = clip->info();
2644                         newclipInfo.endPos = info.startPos;
2645                         new ResizeClipCommand(this, clip->info(), newclipInfo, false, false, command);
2646                         clip->resizeEnd(info.startPos.frames(m_document->fps()));
2647                     }
2648                 } else if (clip->endPos() <= info.endPos) {
2649                     new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), clip->info(), clip->effectList(), false, false, false, true, command);
2650                     m_waitingThumbs.removeAll(clip);
2651                     scene()->removeItem(clip);
2652                     delete clip;
2653                     clip = NULL;
2654                 } else {
2655                     ItemInfo newclipInfo = clip->info();
2656                     newclipInfo.startPos = info.endPos;
2657                     new ResizeClipCommand(this, clip->info(), newclipInfo, false, false, command);
2658                     clip->resizeStart(info.endPos.frames(m_document->fps()));
2659                 }
2660             }
2661         }
2662     } else if (mode == INSERTEDIT) {
2663         // if we are in push mode, move clips accordingly
2664         ItemInfo info;
2665         if (item == NULL) info = posinfo;
2666         else info = item->info();
2667         QRectF rect(info.startPos.frames(m_document->fps()), info.track * m_tracksHeight + m_tracksHeight / 2, (info.endPos - info.startPos).frames(m_document->fps()) - 1, 5);
2668         QList<QGraphicsItem *> selection = m_scene->items(rect);
2669         if (item) selection.removeAll(item);
2670         for (int i = 0; i < selection.count(); i++) {
2671             if (selection.at(i)->type() == AVWIDGET) {
2672                 ClipItem *clip = static_cast<ClipItem *>(selection.at(i));
2673                 if (clip->startPos() < info.startPos) {
2674                     if (clip->endPos() > info.startPos) {
2675                         ItemInfo clipInfo = clip->info();
2676                         ItemInfo dupInfo = clipInfo;
2677                         GenTime diff = info.startPos - clipInfo.startPos;
2678                         dupInfo.startPos = info.startPos;
2679                         dupInfo.cropStart += diff;
2680                         dupInfo.cropDuration = clipInfo.endPos - info.startPos;
2681                         new RazorClipCommand(this, clipInfo, info.startPos, false, command);
2682                         // Commented out; variable dup unused. --granjow
2683                         //ClipItem *dup = cutClip(clipInfo, info.startPos, true, false);
2684                         cutClip(clipInfo, info.startPos, true, false);
2685                     }
2686                 }
2687                 // TODO: add insertspacecommand
2688             }
2689         }
2690     }
2691
2692     KdenliveSettings::setSnaptopoints(snap);
2693 }
2694
2695
2696 void CustomTrackView::adjustTimelineTransitions(EDITMODE mode, Transition *item, QUndoCommand *command)
2697 {
2698     if (mode == OVERWRITEEDIT) {
2699         // if we are in overwrite or push mode, move clips accordingly
2700         bool snap = KdenliveSettings::snaptopoints();
2701         KdenliveSettings::setSnaptopoints(false);
2702         ItemInfo info = item->info();
2703         QRectF rect(info.startPos.frames(m_document->fps()), info.track * m_tracksHeight + m_tracksHeight, (info.endPos - info.startPos).frames(m_document->fps()) - 1, 5);
2704         QList<QGraphicsItem *> selection = m_scene->items(rect);
2705         selection.removeAll(item);
2706         for (int i = 0; i < selection.count(); i++) {
2707             if (!selection.at(i)->isEnabled()) continue;
2708             if (selection.at(i)->type() == TRANSITIONWIDGET) {
2709                 Transition *tr = static_cast<Transition *>(selection.at(i));
2710                 if (tr->startPos() < info.startPos) {
2711                     ItemInfo firstPos = tr->info();
2712                     ItemInfo newPos = firstPos;
2713                     firstPos.endPos = item->startPos();
2714                     newPos.startPos = item->endPos();
2715                     new MoveTransitionCommand(this, tr->info(), firstPos, true, command);
2716                     if (tr->endPos() > info.endPos) {
2717                         // clone transition
2718                         new AddTransitionCommand(this, newPos, tr->transitionEndTrack(), tr->toXML(), false, true, command);
2719                     }
2720                 } else if (tr->endPos() > info.endPos) {
2721                     // just resize
2722                     ItemInfo firstPos = tr->info();
2723                     firstPos.startPos = item->endPos();
2724                     new MoveTransitionCommand(this, tr->info(), firstPos, true, command);
2725                 } else {
2726                     // remove transition
2727                     new AddTransitionCommand(this, tr->info(), tr->transitionEndTrack(), tr->toXML(), true, true, command);
2728                 }
2729             }
2730         }
2731         KdenliveSettings::setSnaptopoints(snap);
2732     }
2733 }
2734
2735 QStringList CustomTrackView::mimeTypes() const
2736 {
2737     QStringList qstrList;
2738     // list of accepted mime types for drop
2739     qstrList.append("text/plain");
2740     qstrList.append("kdenlive/producerslist");
2741     qstrList.append("kdenlive/clip");
2742     return qstrList;
2743 }
2744
2745 Qt::DropActions CustomTrackView::supportedDropActions() const
2746 {
2747     // returns what actions are supported when dropping
2748     return Qt::MoveAction;
2749 }
2750
2751 void CustomTrackView::setDuration(int duration)
2752 {
2753     int diff = qAbs(duration - sceneRect().width());
2754     if (diff * matrix().m11() > -50) {
2755         if (matrix().m11() < 0.4) setSceneRect(0, 0, (duration + 100 / matrix().m11()), sceneRect().height());
2756         else setSceneRect(0, 0, (duration + 300), sceneRect().height());
2757     }
2758     m_projectDuration = duration;
2759 }
2760
2761 int CustomTrackView::duration() const
2762 {
2763     return m_projectDuration;
2764 }
2765
2766 void CustomTrackView::addTrack(TrackInfo type, int ix)
2767 {
2768     QList <TransitionInfo> transitionInfos;
2769     if (ix == -1 || ix == m_document->tracksCount()) {
2770         m_document->insertTrack(0, type);
2771         transitionInfos = m_document->renderer()->mltInsertTrack(1, type.type == VIDEOTRACK);
2772     } else {
2773         m_document->insertTrack(m_document->tracksCount() - ix, type);
2774         // insert track in MLT playlist
2775         transitionInfos = m_document->renderer()->mltInsertTrack(m_document->tracksCount() - ix, type.type == VIDEOTRACK);
2776
2777         double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
2778         QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
2779         QList<QGraphicsItem *> selection = m_scene->items(r);
2780         resetSelectionGroup();
2781
2782         m_selectionGroup = new AbstractGroupItem(m_document->fps());
2783         scene()->addItem(m_selectionGroup);
2784         for (int i = 0; i < selection.count(); i++) {
2785             if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
2786                 m_selectionGroup->addToGroup(selection.at(i));
2787                 selection.at(i)->setFlag(QGraphicsItem::ItemIsMovable, false);
2788             }
2789         }
2790         // Move graphic items
2791         m_selectionGroup->translate(0, m_tracksHeight);
2792
2793         // adjust track number
2794         Mlt::Tractor *tractor = m_document->renderer()->lockService();
2795         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2796         for (int i = 0; i < children.count(); i++) {
2797             if (children.at(i)->type() == GROUPWIDGET) {
2798                 AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
2799                 children << grp->childItems();
2800                 continue;
2801             }
2802             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
2803             item->updateItem();
2804             ItemInfo clipinfo = item->info();
2805             if (item->type() == AVWIDGET) {
2806                 ClipItem *clip = static_cast <ClipItem *>(item);
2807                 // slowmotion clips are not track dependant, so no need to update them
2808                 if (clip->speed() != 1.0) continue;
2809                 // We add a move clip command so that we get the correct producer for new track number
2810                 if (clip->clipType() == AV || clip->clipType() == AUDIO) {
2811                     Mlt::Producer *prod = clip->getProducer(clipinfo.track);
2812                     if (m_document->renderer()->mltUpdateClipProducer(tractor, (int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod) == false) {
2813                         // problem updating clip
2814                         emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", clipinfo.startPos.frames(m_document->fps()), clipinfo.track), ErrorMessage);
2815                     }
2816                 }
2817             } /*else if (item->type() == TRANSITIONWIDGET) {
2818                 Transition *tr = static_cast <Transition *>(item);
2819                 int track = tr->transitionEndTrack();
2820                 if (track >= ix) {
2821                     tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
2822                 }
2823             }*/
2824         }
2825         // Sync transition tracks with MLT playlist
2826         Transition *tr;
2827         TransitionInfo info;
2828         for (int i = 0; i < transitionInfos.count(); i++) {
2829             info = transitionInfos.at(i);
2830             tr = getTransitionItem(info);
2831             if (tr) tr->setForcedTrack(info.forceTrack, info.a_track);
2832             else kDebug()<<"// Cannot update TRANSITION AT: "<<info.b_track<<" / "<<info.startPos.frames(m_document->fps());
2833         }
2834
2835         resetSelectionGroup(false);
2836         m_document->renderer()->unlockService(tractor);
2837     }
2838
2839     int maxHeight = m_tracksHeight * m_document->tracksCount() * matrix().m22();
2840     for (int i = 0; i < m_guides.count(); i++) {
2841         QLineF l = m_guides.at(i)->line();
2842         l.setP2(QPointF(l.x2(), maxHeight));
2843         m_guides.at(i)->setLine(l);
2844     }
2845
2846     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight - 1);
2847     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_document->tracksCount());
2848     viewport()->update();
2849     //QTimer::singleShot(500, this, SIGNAL(trackHeightChanged()));
2850     //setFixedHeight(50 * m_tracksCount);
2851
2852     updateTrackNames(ix, true);
2853 }
2854
2855 void CustomTrackView::removeTrack(int ix)
2856 {
2857     // Delete track in MLT playlist
2858     m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
2859     m_document->deleteTrack(m_document->tracksCount() - ix - 1);
2860
2861     double startY = ix * (m_tracksHeight + 1) + m_tracksHeight / 2;
2862     QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
2863     QList<QGraphicsItem *> selection = m_scene->items(r);
2864
2865     resetSelectionGroup();
2866
2867     m_selectionGroup = new AbstractGroupItem(m_document->fps());
2868     scene()->addItem(m_selectionGroup);
2869     for (int i = 0; i < selection.count(); i++) {
2870         if ((!selection.at(i)->parentItem()) && (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET)) {
2871             m_selectionGroup->addToGroup(selection.at(i));
2872             selection.at(i)->setFlag(QGraphicsItem::ItemIsMovable, false);
2873         }
2874     }
2875     // Move graphic items
2876     qreal ydiff = 0 - (int) m_tracksHeight;
2877     m_selectionGroup->translate(0, ydiff);
2878     Mlt::Tractor *tractor = m_document->renderer()->lockService();
2879
2880     // adjust track number
2881     QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2882     //kDebug() << "// FOUND CLIPS TO MOVE: " << children.count();
2883     for (int i = 0; i < children.count(); i++) {
2884         if (children.at(i)->type() == GROUPWIDGET) {
2885             AbstractGroupItem *grp = static_cast<AbstractGroupItem*>(children.at(i));
2886             children << grp->childItems();
2887             continue;
2888         }
2889         if (children.at(i)->type() == AVWIDGET) {
2890             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
2891             clip->updateItem();
2892             ItemInfo clipinfo = clip->info();
2893             // We add a move clip command so that we get the correct producer for new track number
2894             if (clip->clipType() == AV || clip->clipType() == AUDIO || clip->clipType() == PLAYLIST) {
2895                 Mlt::Producer *prod = clip->getProducer(clipinfo.track);
2896                 if (prod == NULL || !m_document->renderer()->mltUpdateClipProducer(tractor, (int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), prod)) {
2897                     emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", clipinfo.startPos.frames(m_document->fps()), clipinfo.track), ErrorMessage);
2898                 }
2899             }
2900         } else if (children.at(i)->type() == TRANSITIONWIDGET) {
2901             Transition *tr = static_cast <Transition *>(children.at(i));
2902             tr->updateItem();
2903             int track = tr->transitionEndTrack();
2904             if (track >= ix) {
2905                 ItemInfo clipinfo = tr->info();
2906                 tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
2907             }
2908         }
2909     }
2910     resetSelectionGroup(false);
2911     m_document->renderer()->unlockService(tractor);
2912
2913     int maxHeight = m_tracksHeight * m_document->tracksCount() * matrix().m22();
2914     for (int i = 0; i < m_guides.count(); i++) {
2915         QLineF l = m_guides.at(i)->line();
2916         l.setP2(QPointF(l.x2(), maxHeight));
2917         m_guides.at(i)->setLine(l);
2918     }
2919     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight - 1);
2920     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_document->tracksCount());
2921
2922     m_selectedTrack = qMin(m_selectedTrack, m_document->tracksCount() - 1);
2923     viewport()->update();
2924
2925     updateTrackNames(ix, false);
2926     //QTimer::singleShot(500, this, SIGNAL(trackHeightChanged()));
2927 }
2928
2929 void CustomTrackView::configTracks(QList < TrackInfo > trackInfos)
2930 {
2931     for (int i = 0; i < trackInfos.count(); ++i) {
2932         m_document->setTrackType(i, trackInfos.at(i));
2933         m_document->renderer()->mltChangeTrackState(i + 1, m_document->trackInfoAt(i).isMute, m_document->trackInfoAt(i).isBlind);
2934         lockTrack(m_document->tracksCount() - i - 1, m_document->trackInfoAt(i).isLocked, false);
2935     }
2936
2937     viewport()->update();
2938     emit trackHeightChanged();
2939 }
2940
2941 void CustomTrackView::slotSwitchTrackAudio(int ix)
2942 {
2943     /*for (int i = 0; i < m_document->tracksCount(); i++)
2944         kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
2945     int tracknumber = m_document->tracksCount() - ix - 1;
2946     m_document->switchTrackAudio(tracknumber, !m_document->trackInfoAt(tracknumber).isMute);
2947     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isMute << m_document->trackInfoAt(tracknumber).isBlind;
2948     m_document->renderer()->mltChangeTrackState(tracknumber + 1, m_document->trackInfoAt(tracknumber).isMute, m_document->trackInfoAt(tracknumber).isBlind);
2949     setDocumentModified();
2950 }
2951
2952 void CustomTrackView::slotSwitchTrackLock(int ix)
2953 {
2954     int tracknumber = m_document->tracksCount() - ix - 1;
2955     LockTrackCommand *command = new LockTrackCommand(this, ix, !m_document->trackInfoAt(tracknumber).isLocked);
2956     m_commandStack->push(command);
2957 }
2958
2959
2960 void CustomTrackView::lockTrack(int ix, bool lock, bool requestUpdate)
2961 {
2962     int tracknumber = m_document->tracksCount() - ix - 1;
2963     m_document->switchTrackLock(tracknumber, lock);
2964     if (requestUpdate)
2965         emit doTrackLock(ix, lock);
2966     AbstractClipItem *clip = NULL;
2967     QList<QGraphicsItem *> selection = m_scene->items(0, ix * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), m_tracksHeight / 2 - 2);
2968
2969     for (int i = 0; i < selection.count(); i++) {
2970         if (selection.at(i)->type() == GROUPWIDGET && (AbstractGroupItem *)selection.at(i) != m_selectionGroup) {
2971             if (selection.at(i)->parentItem() && m_selectionGroup) {
2972                 selection.removeAll((QGraphicsItem*)m_selectionGroup);
2973                 resetSelectionGroup();
2974             }
2975
2976             bool changeGroupLock = true;
2977             bool hasClipOnTrack = false;
2978             QList <QGraphicsItem *> children =  selection.at(i)->childItems();
2979             for (int j = 0; j < children.count(); ++j) {
2980                 if (children.at(j)->isSelected()) {
2981                     if (children.at(j)->type() == AVWIDGET)
2982                         emit clipItemSelected(NULL);
2983                     else if (children.at(j)->type() == TRANSITIONWIDGET)
2984                         emit transitionItemSelected(NULL);
2985                     else
2986                         continue;
2987                 }
2988
2989                 AbstractClipItem * child = static_cast <AbstractClipItem *>(children.at(j));
2990                 if (child == m_dragItem)
2991                     m_dragItem = NULL;
2992
2993                 // only unlock group, if it is not locked by another track too
2994                 if (!lock && child->track() != ix && m_document->trackInfoAt(m_document->tracksCount() - child->track() - 1).isLocked)
2995                     changeGroupLock = false;
2996
2997                 // only (un-)lock if at least one clip is on the track
2998                 if (child->track() == ix)
2999                     hasClipOnTrack = true;
3000             }
3001             if (changeGroupLock && hasClipOnTrack)
3002                 ((AbstractGroupItem*)selection.at(i))->setItemLocked(lock);
3003         } else if((selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET)) {
3004             if (selection.at(i)->parentItem()) {
3005                 if (selection.at(i)->parentItem() == m_selectionGroup) {
3006                     selection.removeAll((QGraphicsItem*)m_selectionGroup);
3007                     resetSelectionGroup();
3008                 } else {
3009                     // groups are handled separately
3010                     continue;
3011                 }
3012             }
3013
3014             if (selection.at(i)->isSelected()) {
3015                 if (selection.at(i)->type() == AVWIDGET)
3016                     emit clipItemSelected(NULL);
3017                 else
3018                     emit transitionItemSelected(NULL);
3019             }
3020             clip = static_cast <AbstractClipItem *>(selection.at(i));
3021             clip->setItemLocked(lock);
3022             if (clip == m_dragItem)
3023                 m_dragItem = NULL;
3024         }
3025     }
3026     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isLocked;
3027     viewport()->update();
3028     setDocumentModified();
3029 }
3030
3031 void CustomTrackView::slotSwitchTrackVideo(int ix)
3032 {
3033     int tracknumber = m_document->tracksCount() - ix;
3034     m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
3035     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
3036     setDocumentModified();
3037 }
3038
3039 QList<QGraphicsItem *> CustomTrackView::checkForGroups(const QRectF &rect, bool *ok)
3040 {
3041     // Check there is no group going over several tracks there, or that would result in timeline corruption
3042     QList<QGraphicsItem *> selection = scene()->items(rect);
3043     *ok = true;
3044     int maxHeight = m_tracksHeight * 1.5;
3045     for (int i = 0; i < selection.count(); i++) {
3046         // Check that we don't try to move a group with clips on other tracks
3047         if (selection.at(i)->type() == GROUPWIDGET && (selection.at(i)->boundingRect().height() >= maxHeight)) {
3048             *ok = false;
3049             break;
3050         } else if (selection.at(i)->parentItem() && (selection.at(i)->parentItem()->boundingRect().height() >= maxHeight)) {
3051             *ok = false;
3052             break;
3053         }
3054     }
3055     return selection;
3056 }
3057
3058 void CustomTrackView::slotRemoveSpace()
3059 {
3060     GenTime pos;
3061     int track = 0;
3062     if (m_menuPosition.isNull()) {
3063         pos = GenTime(cursorPos(), m_document->fps());
3064
3065         TrackDialog d(m_document, parentWidget());
3066         d.comboTracks->setCurrentIndex(m_selectedTrack);
3067         d.label->setText(i18n("Track"));
3068         d.before_select->setHidden(true);
3069         d.setWindowTitle(i18n("Remove Space"));
3070         d.video_track->setHidden(true);
3071         d.audio_track->setHidden(true);
3072         if (d.exec() != QDialog::Accepted) return;
3073         track = d.comboTracks->currentIndex();
3074     } else {
3075         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
3076         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight);
3077     }
3078
3079     if (m_document->isTrackLocked(m_document->tracksCount() - track - 1)) {
3080         emit displayMessage(i18n("Cannot remove space in a locked track"), ErrorMessage);
3081         return;
3082     }
3083
3084     ClipItem *item = getClipItemAt(pos, track);
3085     if (item) {
3086         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);
3087         return;
3088     }
3089     int length = m_document->renderer()->mltGetSpaceLength(pos, m_document->tracksCount() - track, true);
3090     if (length <= 0) {
3091         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);
3092         return;
3093     }
3094
3095     // Make sure there is no group in the way
3096     QRectF rect(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight / 2 - 2);
3097
3098     bool isOk;
3099     QList<QGraphicsItem *> items = checkForGroups(rect, &isOk);
3100     if (!isOk) {
3101         // groups found on track, do not allow the move
3102         emit displayMessage(i18n("Cannot remove space in a track with a group"), ErrorMessage);
3103         return;
3104     }
3105
3106     QList<ItemInfo> clipsToMove;
3107     QList<ItemInfo> transitionsToMove;
3108
3109     for (int i = 0; i < items.count(); i++) {
3110         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
3111             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
3112             ItemInfo info = item->info();
3113             if (item->type() == AVWIDGET) {
3114                 clipsToMove.append(info);
3115             } else if (item->type() == TRANSITIONWIDGET) {
3116                 transitionsToMove.append(info);
3117             }
3118         }
3119     }
3120
3121     if (!transitionsToMove.isEmpty()) {
3122         // Make sure that by moving the items, we don't get a transition collision
3123         // Find first transition
3124         ItemInfo info = transitionsToMove.at(0);
3125         for (int i = 1; i < transitionsToMove.count(); i++)
3126             if (transitionsToMove.at(i).startPos < info.startPos) info = transitionsToMove.at(i);
3127
3128         // make sure there are no transitions on the way
3129         QRectF rect(info.startPos.frames(m_document->fps()) - length, track * m_tracksHeight + m_tracksHeight / 2, length - 1, m_tracksHeight / 2 - 2);
3130         items = scene()->items(rect);
3131         int transitionCorrection = -1;
3132         for (int i = 0; i < items.count(); i++) {
3133             if (items.at(i)->type() == TRANSITIONWIDGET) {
3134                 // There is a transition on the way
3135                 AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
3136                 int transitionEnd = item->endPos().frames(m_document->fps());
3137                 if (transitionEnd > transitionCorrection) transitionCorrection = transitionEnd;
3138             }
3139         }
3140
3141         if (transitionCorrection > 0) {
3142             // We need to fix the move length
3143             length = info.startPos.frames(m_document->fps()) - transitionCorrection;
3144         }
3145
3146         // Make sure we don't send transition before 0
3147         if (info.startPos.frames(m_document->fps()) < length) {
3148             // reduce length to maximum possible
3149             length = info.startPos.frames(m_document->fps());
3150         }
3151     }
3152
3153     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, GenTime(-length, m_document->fps()), true);
3154     updateTrackDuration(track, command);
3155     m_commandStack->push(command);
3156 }
3157
3158 void CustomTrackView::slotInsertSpace()
3159 {
3160     GenTime pos;
3161     int track = 0;
3162     if (m_menuPosition.isNull()) {
3163         pos = GenTime(cursorPos(), m_document->fps());
3164     } else {
3165         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
3166         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight) + 1;
3167     }
3168     SpacerDialog d(GenTime(65, m_document->fps()), m_document->timecode(), track, m_document->tracksList(), this);
3169     if (d.exec() != QDialog::Accepted) return;
3170     GenTime spaceDuration = d.selectedDuration();
3171     track = d.selectedTrack();
3172
3173     QList<QGraphicsItem *> items;
3174     if (track >= 0) {
3175         if (m_document->isTrackLocked(m_document->tracksCount() - track - 1)) {
3176             emit displayMessage(i18n("Cannot insert space in a locked track"), ErrorMessage);
3177             return;
3178         }
3179
3180         ClipItem *item = getClipItemAt(pos, track);
3181         if (item) pos = item->startPos();
3182
3183         // Make sure there is no group in the way
3184         QRectF rect(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight / 2 - 2);
3185         bool isOk;
3186         items = checkForGroups(rect, &isOk);
3187         if (!isOk) {
3188             // groups found on track, do not allow the move
3189             emit displayMessage(i18n("Cannot insert space in a track with a group"), ErrorMessage);
3190             return;
3191         }
3192     } else {
3193         QRectF rect(pos.frames(m_document->fps()), 0, sceneRect().width() - pos.frames(m_document->fps()), m_document->tracksCount() * m_tracksHeight);
3194         items = scene()->items(rect);
3195     }
3196
3197     QList<ItemInfo> clipsToMove;
3198     QList<ItemInfo> transitionsToMove;
3199
3200     for (int i = 0; i < items.count(); i++) {
3201         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
3202             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
3203             ItemInfo info = item->info();
3204             if (item->type() == AVWIDGET)
3205                 clipsToMove.append(info);
3206             else if (item->type() == TRANSITIONWIDGET)
3207                 transitionsToMove.append(info);
3208         }
3209     }
3210
3211     if (!clipsToMove.isEmpty() || !transitionsToMove.isEmpty()) {
3212         InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, spaceDuration, true);
3213         updateTrackDuration(track, command);
3214         m_commandStack->push(command);
3215     }
3216 }
3217
3218 void CustomTrackView::insertSpace(QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime &duration, const GenTime &offset)
3219 {
3220     int diff = duration.frames(m_document->fps());
3221     resetSelectionGroup();
3222     m_selectionGroup = new AbstractGroupItem(m_document->fps());
3223     scene()->addItem(m_selectionGroup);
3224     ClipItem *clip;
3225     Transition *transition;
3226
3227     // Create lists with start pos for each track
3228     QMap <int, int> trackClipStartList;
3229     QMap <int, int> trackTransitionStartList;
3230
3231     for (int i = 1; i < m_document->tracksCount() + 1; i++) {
3232         trackClipStartList[i] = -1;
3233         trackTransitionStartList[i] = -1;
3234     }
3235
3236     if (!clipsToMove.isEmpty()) for (int i = 0; i < clipsToMove.count(); i++) {
3237             clip = getClipItemAtStart(clipsToMove.at(i).startPos + offset, clipsToMove.at(i).track);
3238             if (clip) {
3239                 if (clip->parentItem()) {
3240                     m_selectionGroup->addToGroup(clip->parentItem());
3241                     clip->parentItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
3242                 } else {
3243                     m_selectionGroup->addToGroup(clip);
3244                     clip->setFlag(QGraphicsItem::ItemIsMovable, false);
3245                 }
3246                 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))
3247                     trackClipStartList[m_document->tracksCount() - clipsToMove.at(i).track] = clipsToMove.at(i).startPos.frames(m_document->fps());
3248             } else emit {
3249                     displayMessage(i18n("Cannot move clip at position %1, track %2", m_document->timecode().getTimecodeFromFrames((clipsToMove.at(i).startPos + offset).frames(m_document->fps())), clipsToMove.at(i).track), ErrorMessage);
3250                 }
3251             }
3252     if (!transToMove.isEmpty()) for (int i = 0; i < transToMove.count(); i++) {
3253             transition = getTransitionItemAtStart(transToMove.at(i).startPos + offset, transToMove.at(i).track);
3254             if (transition) {
3255                 if (transition->parentItem()) {
3256                     m_selectionGroup->addToGroup(transition->parentItem());
3257                     transition->parentItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
3258                 } else {
3259                     m_selectionGroup->addToGroup(transition);
3260                     transition->setFlag(QGraphicsItem::ItemIsMovable, false);
3261                 }
3262                 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))
3263                     trackTransitionStartList[m_document->tracksCount() - transToMove.at(i).track] = transToMove.at(i).startPos.frames(m_document->fps());
3264             } 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);
3265         }
3266     m_selectionGroup->translate(diff, 0);
3267
3268     // update items coordinates
3269     QList<QGraphicsItem *> itemList = m_selectionGroup->childItems();
3270
3271     for (int i = 0; i < itemList.count(); i++) {
3272         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
3273             static_cast < AbstractClipItem *>(itemList.at(i))->updateItem();
3274         } else if (itemList.at(i)->type() == GROUPWIDGET) {
3275             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
3276             for (int j = 0; j < children.count(); j++) {
3277                 AbstractClipItem * clp = static_cast < AbstractClipItem *>(children.at(j));
3278                 clp->updateItem();
3279             }
3280         }
3281     }
3282     resetSelectionGroup(false);
3283     if (track != -1)
3284         track = m_document->tracksCount() - track;
3285     m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, duration, offset);
3286 }
3287
3288 void CustomTrackView::deleteClip(const QString &clipId)
3289 {
3290     resetSelectionGroup();
3291     QList<QGraphicsItem *> itemList = items();
3292     QUndoCommand *deleteCommand = new QUndoCommand();
3293     int count = 0;
3294     for (int i = 0; i < itemList.count(); i++) {
3295         if (itemList.at(i)->type() == AVWIDGET) {
3296             ClipItem *item = (ClipItem *)itemList.at(i);
3297             if (item->clipProducer() == clipId) {
3298                 count++;
3299                 if (item->parentItem()) {
3300                     // Clip is in a group, destroy the group
3301                     new GroupClipsCommand(this, QList<ItemInfo>() << item->info(), QList<ItemInfo>(), false, deleteCommand);
3302                 }
3303                 new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false, true, true, deleteCommand);
3304             }
3305         }
3306     }
3307     deleteCommand->setText(i18np("Delete timeline clip", "Delete timeline clips", count));
3308     if (count == 0) {
3309         delete deleteCommand;
3310     } else {
3311         updateTrackDuration(-1, deleteCommand);
3312         m_commandStack->push(deleteCommand);
3313     }
3314 }
3315
3316 void CustomTrackView::setCursorPos(int pos, bool seek)
3317 {
3318     if (pos == m_cursorPos) return;
3319     emit cursorMoved((int)(m_cursorPos), (int)(pos));
3320     m_cursorPos = pos;
3321     if (seek) m_document->renderer()->seek(m_cursorPos);
3322     else if (m_autoScroll) checkScrolling();
3323     m_cursorLine->setPos(m_cursorPos, 0);
3324 }
3325
3326 void CustomTrackView::updateCursorPos()
3327 {
3328     m_cursorLine->setPos(m_cursorPos, 0);
3329 }
3330
3331 int CustomTrackView::cursorPos()
3332 {
3333     return (int)(m_cursorPos);
3334 }
3335
3336 void CustomTrackView::moveCursorPos(int delta)
3337 {
3338     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
3339     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
3340     m_cursorPos += delta;
3341     m_cursorLine->setPos(m_cursorPos, 0);
3342     m_document->renderer()->seek(m_cursorPos);
3343 }
3344
3345 void CustomTrackView::initCursorPos(int pos)
3346 {
3347     emit cursorMoved((int)(m_cursorPos), (int)(pos));
3348     m_cursorPos = pos;
3349     m_cursorLine->setPos(pos, 0);
3350     checkScrolling();
3351 }
3352
3353 void CustomTrackView::checkScrolling()
3354 {
3355     ensureVisible(m_cursorPos, verticalScrollBar()->value() + 10, 2, 2, 50, 0);
3356 }
3357
3358 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event)
3359 {
3360     if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
3361     QGraphicsView::mouseReleaseEvent(event);
3362     setViewportUpdateMode(QGraphicsView::MinimalViewportUpdate);
3363 #if QT_VERSION >= 0x040600
3364     if (m_dragItem) m_dragItem->setGraphicsEffect(NULL);
3365 #endif
3366     if (m_scrollTimer.isActive()) m_scrollTimer.stop();
3367     if (event->button() == Qt::MidButton) {
3368         return;
3369     }
3370     setDragMode(QGraphicsView::NoDrag);
3371     if (m_operationMode == MOVEGUIDE) {
3372         setCursor(Qt::ArrowCursor);
3373         m_operationMode = NONE;
3374         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
3375         GenTime newPos = GenTime(m_dragGuide->pos().x(), m_document->fps());
3376         if (newPos != m_dragGuide->position()) {
3377             EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), newPos, m_dragGuide->label(), false);
3378             m_commandStack->push(command);
3379             m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
3380             qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3381             m_document->syncGuides(m_guides);
3382         }
3383         m_dragGuide = NULL;
3384         m_dragItem = NULL;
3385         return;
3386     } else if (m_operationMode == SPACER && m_selectionGroup) {
3387         int track;
3388         if (event->modifiers() != Qt::ControlModifier) {
3389             // We are moving all tracks
3390             track = -1;
3391         } else track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
3392         GenTime timeOffset = GenTime((int)(m_selectionGroup->scenePos().x()), m_document->fps()) - m_selectionGroupInfo.startPos;
3393
3394         if (timeOffset != GenTime()) {
3395             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
3396
3397             QList<ItemInfo> clipsToMove;
3398             QList<ItemInfo> transitionsToMove;
3399
3400             // Create lists with start pos for each track
3401             QMap <int, int> trackClipStartList;
3402             QMap <int, int> trackTransitionStartList;
3403
3404             for (int i = 1; i < m_document->tracksCount() + 1; i++) {
3405                 trackClipStartList[i] = -1;
3406                 trackTransitionStartList[i] = -1;
3407             }
3408
3409             for (int i = 0; i < items.count(); i++) {
3410                 if (items.at(i)->type() == GROUPWIDGET)
3411                     items += items.at(i)->childItems();
3412             }
3413
3414             for (int i = 0; i < items.count(); i++) {
3415                 if (items.at(i)->type() == AVWIDGET) {
3416                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
3417                     ItemInfo info = item->info();
3418                     clipsToMove.append(info);
3419                     item->updateItem();
3420                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackClipStartList.value(m_document->tracksCount() - info.track))
3421                         trackClipStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
3422                 } else if (items.at(i)->type() == TRANSITIONWIDGET) {
3423                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
3424                     ItemInfo info = item->info();
3425                     transitionsToMove.append(info);
3426                     item->updateItem();
3427                     if (trackTransitionStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackTransitionStartList.value(m_document->tracksCount() - info.track))
3428                         trackTransitionStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
3429                 }
3430             }
3431             if (!clipsToMove.isEmpty() || !transitionsToMove.isEmpty()) {
3432                 InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, timeOffset, false);
3433                 updateTrackDuration(track, command);
3434                 m_commandStack->push(command);
3435                 if (track != -1) track = m_document->tracksCount() - track;
3436                 kDebug() << "SPACER TRACK:" << track;
3437                 m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, timeOffset, GenTime());
3438                 setDocumentModified();
3439             }
3440         }
3441         resetSelectionGroup(false);
3442         m_operationMode = NONE;
3443     } else if (m_operationMode == RUBBERSELECTION) {
3444         resetSelectionGroup();
3445         groupSelectedItems();
3446         m_operationMode = NONE;
3447     }
3448
3449     if (m_dragItem == NULL && m_selectionGroup == NULL) {
3450         emit transitionItemSelected(NULL);
3451         return;
3452     }
3453     ItemInfo info;
3454     if (m_dragItem) info = m_dragItem->info();
3455
3456     if (m_operationMode == MOVE) {
3457         setCursor(Qt::OpenHandCursor);
3458         if (m_dragItem->parentItem() == 0) {
3459             // we are moving one clip, easy
3460             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
3461                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
3462                 Mlt::Producer *prod = item->getProducer(info.track);
3463                 bool success = m_document->renderer()->mltMoveClip((int)(m_document->tracksCount() - m_dragItemInfo.track), (int)(m_document->tracksCount() - info.track), (int) m_dragItemInfo.startPos.frames(m_document->fps()), (int)(info.startPos.frames(m_document->fps())), prod, m_scene->editMode() == OVERWRITEEDIT, m_scene->editMode() == INSERTEDIT);
3464
3465                 if (success) {
3466                     QUndoCommand *moveCommand = new QUndoCommand();
3467                     moveCommand->setText(i18n("Move clip"));
3468                     adjustTimelineClips(m_scene->editMode(), item, ItemInfo(), moveCommand);
3469
3470                     int tracknumber = m_document->tracksCount() - item->track() - 1;
3471                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3472                     if (isLocked) item->setItemLocked(true);
3473                     new MoveClipCommand(this, m_dragItemInfo, info, false, moveCommand);
3474                     // Also move automatic transitions (on lower track)
3475                     Transition *startTransition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
3476                     ItemInfo startTrInfo;
3477                     ItemInfo newStartTrInfo;
3478                     bool moveStartTrans = false;
3479                     bool moveEndTrans = false;
3480                     if (startTransition && startTransition->isAutomatic()) {
3481                         startTrInfo = startTransition->info();
3482                         newStartTrInfo = startTrInfo;
3483                         newStartTrInfo.track = info.track;
3484                         newStartTrInfo.startPos = info.startPos;
3485                         if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtEnd(newStartTrInfo.endPos, m_document->tracksCount() - startTransition->transitionEndTrack())) {
3486                             // transition end should stay the same
3487                         } else {
3488                             // transition end should be adjusted to clip
3489                             newStartTrInfo.endPos = newStartTrInfo.endPos + (newStartTrInfo.startPos - startTrInfo.startPos);
3490                         }
3491                         if (newStartTrInfo.startPos < newStartTrInfo.endPos) moveStartTrans = true;
3492                     }
3493                     if (startTransition == NULL || startTransition->endPos() < m_dragItemInfo.endPos) {
3494                         // Check if there is a transition at clip end
3495                         Transition *tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
3496                         if (tr && tr->isAutomatic()) {
3497                             ItemInfo trInfo = tr->info();
3498                             ItemInfo newTrInfo = trInfo;
3499                             newTrInfo.track = info.track;
3500                             newTrInfo.endPos = m_dragItem->endPos();
3501                             if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtStart(trInfo.startPos, m_document->tracksCount() - tr->transitionEndTrack())) {
3502                                 // transition start should stay the same
3503                             } else {
3504                                 // transition start should be moved
3505                                 newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
3506                             }
3507                             if (newTrInfo.startPos < newTrInfo.endPos) {
3508                                 moveEndTrans = true;
3509                                 if (moveStartTrans) {
3510                                     // we have to move both transitions, remove the start one so that there is no collision
3511                                     new AddTransitionCommand(this, startTrInfo, startTransition->transitionEndTrack(), startTransition->toXML(), true, true, moveCommand);
3512                                 }
3513                                 adjustTimelineTransitions(m_scene->editMode(), tr, moveCommand);
3514                                 new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
3515                                 if (moveStartTrans) {
3516                                     // re-add transition in correct place
3517                                     int transTrack = startTransition->transitionEndTrack();
3518                                     if (m_dragItemInfo.track != info.track && !startTransition->forcedTrack()) {
3519                                         transTrack = getPreviousVideoTrack(info.track);
3520                                     }
3521                                     adjustTimelineTransitions(m_scene->editMode(), startTransition, moveCommand);
3522                                     new AddTransitionCommand(this, newStartTrInfo, transTrack, startTransition->toXML(), false, true, moveCommand);
3523                                 }
3524                             }
3525                         }
3526                     }
3527
3528                     if (moveStartTrans && !moveEndTrans) {
3529                         adjustTimelineTransitions(m_scene->editMode(), startTransition, moveCommand);
3530                         new MoveTransitionCommand(this, startTrInfo, newStartTrInfo, true, moveCommand);
3531                     }
3532
3533                     // Also move automatic transitions (on upper track)
3534                     Transition *tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
3535                     if (m_dragItemInfo.track == info.track && tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
3536                         ItemInfo trInfo = tr->info();
3537                         ItemInfo newTrInfo = trInfo;
3538                         newTrInfo.startPos = m_dragItem->startPos();
3539                         ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
3540                         if (!upperClip || !upperClip->baseClip()->isTransparent()) {
3541                             if (!getClipItemAtEnd(newTrInfo.endPos, tr->track())) {
3542                                 // transition end should be adjusted to clip on upper track
3543                                 newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
3544                             }
3545                             if (newTrInfo.startPos < newTrInfo.endPos) {
3546                                 adjustTimelineTransitions(m_scene->editMode(), tr, moveCommand);
3547                                 new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
3548                             }
3549                         }
3550                     }
3551                     if (m_dragItemInfo.track == info.track && (tr == NULL || tr->endPos() < m_dragItemInfo.endPos)) {
3552                         // Check if there is a transition at clip end
3553                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
3554                         if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
3555                             ItemInfo trInfo = tr->info();
3556                             ItemInfo newTrInfo = trInfo;
3557                             newTrInfo.endPos = m_dragItem->endPos();
3558                             kDebug() << "CLIP ENDS AT: " << newTrInfo.endPos.frames(25);
3559                             kDebug() << "CLIP STARTS AT: " << newTrInfo.startPos.frames(25);
3560                             ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
3561                             if (!upperClip || !upperClip->baseClip()->isTransparent()) {
3562                                 if (!getClipItemAtStart(trInfo.startPos, tr->track())) {
3563                                     // transition start should be moved
3564                                     newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
3565                                 }
3566                                 if (newTrInfo.startPos < newTrInfo.endPos) {
3567                                     adjustTimelineTransitions(m_scene->editMode(), tr, moveCommand);
3568                                     new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
3569                                 }
3570                             }
3571                         }
3572                     }
3573                     updateTrackDuration(info.track, moveCommand);
3574                     if (m_dragItemInfo.track != info.track)
3575                         updateTrackDuration(m_dragItemInfo.track, moveCommand);
3576                     m_commandStack->push(moveCommand);
3577                     //checkTrackSequence(m_dragItem->track());
3578                 } else {
3579                     // undo last move and emit error message
3580                     bool snap = KdenliveSettings::snaptopoints();
3581                     KdenliveSettings::setSnaptopoints(false);
3582                     item->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (int)(m_dragItemInfo.track * m_tracksHeight + 1));
3583                     KdenliveSettings::setSnaptopoints(snap);
3584                     emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps()))), ErrorMessage);
3585                 }
3586                 setDocumentModified();
3587             } else if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
3588                 Transition *transition = static_cast <Transition *>(m_dragItem);
3589                 transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
3590                 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)) {
3591                     // Moving transition failed, revert to previous position
3592                     emit displayMessage(i18n("Cannot move transition"), ErrorMessage);
3593                     transition->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (m_dragItemInfo.track) * m_tracksHeight + 1);
3594                 } else {
3595                     QUndoCommand *moveCommand = new QUndoCommand();
3596                     moveCommand->setText(i18n("Move transition"));
3597                     adjustTimelineTransitions(m_scene->editMode(), transition, moveCommand);
3598                     new MoveTransitionCommand(this, m_dragItemInfo, info, false, moveCommand);
3599                     updateTrackDuration(info.track, moveCommand);
3600                     if (m_dragItemInfo.track != info.track)
3601                         updateTrackDuration(m_dragItemInfo.track, moveCommand);
3602                     m_commandStack->push(moveCommand);
3603                     setDocumentModified();
3604                 }
3605             }
3606         } else {
3607             // Moving several clips. We need to delete them and readd them to new position,
3608             // or they might overlap each other during the move
3609             QGraphicsItemGroup *group;
3610             if (m_selectionGroup)
3611                 group = static_cast <QGraphicsItemGroup *>(m_selectionGroup);
3612             else
3613                 group = static_cast <QGraphicsItemGroup *>(m_dragItem->parentItem());
3614             QList<QGraphicsItem *> items = group->childItems();
3615
3616             QList<ItemInfo> clipsToMove;
3617             QList<ItemInfo> transitionsToMove;
3618
3619             GenTime timeOffset = GenTime(m_dragItem->scenePos().x(), m_document->fps()) - m_dragItemInfo.startPos;
3620             const int trackOffset = (int)(m_dragItem->scenePos().y() / m_tracksHeight) - m_dragItemInfo.track;
3621
3622             QUndoCommand *moveGroup = new QUndoCommand();
3623             moveGroup->setText(i18n("Move group"));
3624             if (timeOffset != GenTime() || trackOffset != 0) {
3625                 // remove items in MLT playlist
3626
3627                 // Expand groups
3628                 int max = items.count();
3629                 for (int i = 0; i < max; i++) {
3630                     if (items.at(i)->type() == GROUPWIDGET) {
3631                         items += items.at(i)->childItems();
3632                     }
3633                 }
3634                 m_document->renderer()->blockSignals(true);
3635                 for (int i = 0; i < items.count(); i++) {
3636                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
3637                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
3638                     ItemInfo info = item->info();
3639                     if (item->type() == AVWIDGET) {
3640                         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
3641                             // error, clip cannot be removed from playlist
3642                             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
3643                         } else {
3644                             clipsToMove.append(info);
3645                         }
3646                     } else {
3647                         transitionsToMove.append(info);
3648                         Transition *tr = static_cast <Transition*>(item);
3649                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
3650                     }
3651                 }
3652                 m_document->renderer()->blockSignals(false);
3653                 for (int i = 0; i < items.count(); i++) {
3654                     // re-add items in correct place
3655                     if (items.at(i)->type() != AVWIDGET && items.at(i)->type() != TRANSITIONWIDGET) continue;
3656                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
3657                     item->updateItem();
3658                     ItemInfo info = item->info();
3659                     int tracknumber = m_document->tracksCount() - info.track - 1;
3660                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
3661                     if (isLocked) {
3662                         group->removeFromGroup(item);
3663                         item->setItemLocked(true);
3664                     }
3665
3666                     if (item->type() == AVWIDGET) {
3667                         ClipItem *clip = static_cast <ClipItem*>(item);
3668                         int trackProducer = info.track;
3669                         info.track = m_document->tracksCount() - info.track;
3670                         adjustTimelineClips(m_scene->editMode(), clip, ItemInfo(), moveGroup);
3671                         m_document->renderer()->mltInsertClip(info, clip->xml(), clip->getProducer(trackProducer), m_scene->editMode() == OVERWRITEEDIT, m_scene->editMode() == INSERTEDIT);
3672                         for (int i = 0; i < clip->effectsCount(); i++) {
3673                             m_document->renderer()->mltAddEffect(info.track, info.startPos, getEffectArgs(clip->effect(i)), false);
3674                         }
3675                     } else {
3676                         Transition *tr = static_cast <Transition*>(item);
3677                         int newTrack = tr->transitionEndTrack();
3678                         if (!tr->forcedTrack()) {
3679                             newTrack = getPreviousVideoTrack(info.track);
3680                         }
3681                         tr->updateTransitionEndTrack(newTrack);
3682                         adjustTimelineTransitions(m_scene->editMode(), tr, moveGroup);
3683                         m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
3684                     }
3685                 }
3686                 new MoveGroupCommand(this, clipsToMove, transitionsToMove, timeOffset, trackOffset, false, moveGroup);
3687                 updateTrackDuration(-1, moveGroup);
3688                 m_commandStack->push(moveGroup);
3689
3690                 //QPointF top = group->sceneBoundingRect().topLeft();
3691                 //QPointF oldpos = m_selectionGroup->scenePos();
3692                 //kDebug()<<"SELECTION GRP POS: "<<m_selectionGroup->scenePos()<<", TOP: "<<top;
3693                 //group->setPos(top);
3694                 //TODO: get rid of the 3 lines below
3695                 if (m_selectionGroup) {
3696                     m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
3697                     m_selectionGroupInfo.track = m_selectionGroup->track();
3698
3699                     for (int i = 0; i < items.count(); ++i) {
3700                         if (items.at(i)->type() == GROUPWIDGET) {
3701                             rebuildGroup((AbstractGroupItem*)items.at(i));
3702                             items.removeAt(i);
3703                             --i;
3704                         }
3705                     }
3706                     for (int i = 0; i < items.count(); ++i) {
3707                         if (items.at(i)) {
3708                             items.at(i)->setSelected(true);
3709                             if (items.at(i)->parentItem())
3710                                 items.at(i)->parentItem()->setSelected(true);
3711                         }
3712                     }
3713                     resetSelectionGroup();
3714                     groupSelectedItems();
3715                 } else {
3716                     rebuildGroup((AbstractGroupItem *)group);
3717                 }
3718                 setDocumentModified();
3719             }
3720         }
3721         m_document->renderer()->doRefresh();
3722     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
3723         // resize start
3724         if (!m_controlModifier && m_dragItem->type() == AVWIDGET && m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
3725             AbstractGroupItem *parent = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
3726             if (parent) {
3727                 QUndoCommand *resizeCommand = new QUndoCommand();
3728                 resizeCommand->setText(i18n("Resize group"));
3729                 QList <QGraphicsItem *> items = parent->childItems();
3730                 QList <ItemInfo> infos = parent->resizeInfos();
3731                 parent->clearResizeInfos();
3732                 int itemcount = 0;
3733                 for (int i = 0; i < items.count(); ++i) {
3734                     AbstractClipItem *item = static_cast<AbstractClipItem *>(items.at(i));
3735                     if (item && item->type() == AVWIDGET) {
3736                         ItemInfo info = infos.at(itemcount);
3737                         prepareResizeClipStart(item, info, item->startPos().frames(m_document->fps()), false, resizeCommand);
3738                         ++itemcount;
3739                     }
3740                 }
3741                 m_commandStack->push(resizeCommand);
3742             }
3743         } else {
3744             prepareResizeClipStart(m_dragItem, m_dragItemInfo, m_dragItem->startPos().frames(m_document->fps()));
3745         }
3746     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
3747         // resize end
3748         if (!m_controlModifier && m_dragItem->type() == AVWIDGET && m_dragItem->parentItem() && m_dragItem->parentItem() != m_selectionGroup) {
3749             AbstractGroupItem *parent = static_cast <AbstractGroupItem *>(m_dragItem->parentItem());
3750             if (parent) {
3751                 QUndoCommand *resizeCommand = new QUndoCommand();
3752                 resizeCommand->setText(i18n("Resize group"));
3753                 QList <QGraphicsItem *> items = parent->childItems();
3754                 QList <ItemInfo> infos = parent->resizeInfos();
3755                 parent->clearResizeInfos();
3756                 int itemcount = 0;
3757                 for (int i = 0; i < items.count(); ++i) {
3758                     AbstractClipItem *item = static_cast<AbstractClipItem *>(items.at(i));
3759                     if (item && item->type() == AVWIDGET) {
3760                         ItemInfo info = infos.at(itemcount);
3761                         prepareResizeClipEnd(item, info, item->endPos().frames(m_document->fps()), false, resizeCommand);
3762                         ++itemcount;
3763                     }
3764                 }
3765                 updateTrackDuration(-1, resizeCommand);
3766                 m_commandStack->push(resizeCommand);
3767             }
3768         } else {
3769             prepareResizeClipEnd(m_dragItem, m_dragItemInfo, m_dragItem->endPos().frames(m_document->fps()));
3770         }
3771     } else if (m_operationMode == FADEIN) {
3772         // resize fade in effect
3773         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
3774         int ix = item->hasEffect("volume", "fadein");
3775         int ix2 = item->hasEffect("", "fade_from_black");
3776         if (ix != -1) {
3777             QDomElement oldeffect = item->effectAtIndex(ix);
3778             int start = item->cropStart().frames(m_document->fps());
3779             int end = item->fadeIn();
3780             if (end == 0) {
3781                 slotDeleteEffect(item, -1, oldeffect, false);
3782             } else {
3783                 end += start;
3784                 QDomElement effect = oldeffect.cloneNode().toElement();
3785                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3786                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3787                 slotUpdateClipEffect(item, -1, effect, oldeffect, ix);
3788                 emit clipItemSelected(item);
3789             }
3790         } else if (item->fadeIn() != 0 && ix2 == -1) {
3791             QDomElement effect;
3792             if (item->isVideoOnly() || (item->clipType() != AUDIO && item->clipType() != AV && item->clipType() != PLAYLIST)) {
3793                 // add video fade
3794                 effect = MainWindow::videoEffects.getEffectByTag("", "fade_from_black").cloneNode().toElement();
3795             } else effect = MainWindow::audioEffects.getEffectByTag("volume", "fadein").cloneNode().toElement();
3796             EffectsList::setParameter(effect, "out", QString::number(item->fadeIn()));
3797             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
3798         }
3799         if (ix2 != -1) {
3800             QDomElement oldeffect = item->effectAtIndex(ix2);
3801             int start = item->cropStart().frames(m_document->fps());
3802             int end = item->fadeIn();
3803             if (end == 0) {
3804                 slotDeleteEffect(item, -1, oldeffect, false);
3805             } else {
3806                 end += start;
3807                 QDomElement effect = oldeffect.cloneNode().toElement();
3808                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3809                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3810                 slotUpdateClipEffect(item, -1, effect, oldeffect, ix2);
3811                 emit clipItemSelected(item);
3812             }
3813         }
3814     } else if (m_operationMode == FADEOUT) {
3815         // resize fade in effect
3816         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
3817         int ix = item->hasEffect("volume", "fadeout");
3818         int ix2 = item->hasEffect("", "fade_to_black");
3819         if (ix != -1) {
3820             QDomElement oldeffect = item->effectAtIndex(ix);
3821             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
3822             int start = item->fadeOut();
3823             if (start == 0) {
3824                 slotDeleteEffect(item, -1, oldeffect, false);
3825             } else {
3826                 start = end - start;
3827                 QDomElement effect = oldeffect.cloneNode().toElement();
3828                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3829                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3830                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
3831                 slotUpdateClipEffect(item, -1, effect, oldeffect, ix);
3832                 emit clipItemSelected(item);
3833             }
3834         } else if (item->fadeOut() != 0 && ix2 == -1) {
3835             QDomElement effect;
3836             if (item->isVideoOnly() || (item->clipType() != AUDIO && item->clipType() != AV && item->clipType() != PLAYLIST)) {
3837                 // add video fade
3838                 effect = MainWindow::videoEffects.getEffectByTag("", "fade_to_black").cloneNode().toElement();
3839             } else effect = MainWindow::audioEffects.getEffectByTag("volume", "fadeout").cloneNode().toElement();
3840             EffectsList::setParameter(effect, "in", QString::number(item->fadeOut()));
3841             EffectsList::setParameter(effect, "out", QString::number(0));
3842             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
3843         }
3844         if (ix2 != -1) {
3845             QDomElement oldeffect = item->effectAtIndex(ix2);
3846             int end = (item->cropDuration() + item->cropStart()).frames(m_document->fps());
3847             int start = item->fadeOut();
3848             if (start == 0) {
3849                 slotDeleteEffect(item, -1, oldeffect, false);
3850             } else {
3851                 start = end - start;
3852                 QDomElement effect = oldeffect.cloneNode().toElement();
3853                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
3854                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
3855                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
3856                 slotUpdateClipEffect(item, -1, effect, oldeffect, ix2);
3857                 emit clipItemSelected(item);
3858             }
3859         }
3860     } else if (m_operationMode == KEYFRAME) {
3861         // update the MLT effect
3862         ClipItem * item = static_cast <ClipItem *>(m_dragItem);
3863         QDomElement oldEffect = item->selectedEffect().cloneNode().toElement();
3864
3865         // check if we want to remove keyframe
3866         double val = mapToScene(event->pos()).toPoint().y();
3867         QRectF br = item->sceneBoundingRect();
3868         double maxh = 100.0 / br.height();
3869         val = (br.bottom() - val) * maxh;
3870         int start = item->cropStart().frames(m_document->fps());
3871         int end = (item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1;
3872
3873         if ((val < -50 || val > 150) && item->editedKeyFramePos() != start && item->editedKeyFramePos() != end && item->keyFrameNumber() > 1) {
3874             //delete keyframe
3875             item->movedKeyframe(item->getEffectAtIndex(item->selectedEffectIndex()), item->selectedKeyFramePos(), -1, 0);
3876         } else {
3877             item->movedKeyframe(item->getEffectAtIndex(item->selectedEffectIndex()), item->selectedKeyFramePos(), item->editedKeyFramePos(), item->editedKeyFrameValue());
3878         }
3879
3880         QDomElement newEffect = item->selectedEffect().cloneNode().toElement();
3881         //item->updateKeyframeEffect();
3882         //QString next = item->keyframes(item->selectedEffectIndex());
3883         //EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
3884         EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), oldEffect, newEffect, item->selectedEffectIndex(), false, false);
3885
3886         m_commandStack->push(command);
3887         updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect());
3888         emit clipItemSelected(item);
3889     }
3890     if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET && m_dragItem->isSelected()) {
3891         // A transition is selected
3892         QPoint p;
3893         ClipItem *transitionClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track);
3894         if (transitionClip && transitionClip->baseClip()) {
3895             QString size = transitionClip->baseClip()->getProperty("frame_size");
3896             double factor = transitionClip->baseClip()->getProperty("aspect_ratio").toDouble();
3897             if (factor == 0) factor = 1.0;
3898             p.setX((int)(size.section('x', 0, 0).toInt() * factor + 0.5));
3899             p.setY(size.section('x', 1, 1).toInt());
3900         }
3901         emit transitionItemSelected(static_cast <Transition *>(m_dragItem), getPreviousVideoTrack(m_dragItem->track()), p);
3902     } else emit transitionItemSelected(NULL);
3903     if (m_operationMode != NONE && m_operationMode != MOVE) setDocumentModified();
3904     m_operationMode = NONE;
3905 }
3906
3907 void CustomTrackView::deleteClip(ItemInfo info, bool refresh)
3908 {
3909     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
3910     m_ct++;
3911     if (!item) kDebug()<<"// PROBLEM FINDING CLIP ITEM TO REMOVVE!!!!!!!!!";
3912     else kDebug()<<"// deleting CLIP: "<<info.startPos.frames(m_document->fps())<<", "<<item->baseClip()->fileURL();
3913     //m_document->renderer()->saveSceneList(QString("/tmp/error%1.mlt").arg(m_ct), QDomElement());
3914     if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
3915         emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
3916         kDebug()<<"CANNOT REMOVE: "<<info.startPos.frames(m_document->fps())<<", TK: "<<info.track;
3917         //m_document->renderer()->saveSceneList(QString("/tmp/error%1.mlt").arg(m_ct), QDomElement());
3918         return;
3919     }
3920     m_waitingThumbs.removeAll(item);
3921     item->stopThumbs();
3922     if (item->isSelected()) emit clipItemSelected(NULL);
3923     item->baseClip()->removeReference();
3924     m_document->updateClip(item->baseClip()->getId());
3925
3926     /*if (item->baseClip()->isTransparent()) {
3927         // also remove automatic transition
3928         Transition *tr = getTransitionItemAt(info.startPos, info.track);
3929         if (tr && tr->isAutomatic()) {
3930             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
3931             scene()->removeItem(tr);
3932             delete tr;
3933         }
3934     }*/
3935
3936     if (m_dragItem == item) m_dragItem = NULL;
3937
3938 #if QT_VERSION >= 0x040600
3939     // animate item deletion
3940     item->closeAnimation();
3941     /*if (refresh) item->closeAnimation();
3942     else {
3943         // no refresh, means we have several operations chained, we need to delete clip immediatly
3944         // so that it does not get in the way of the other
3945         delete item;
3946         item = NULL;
3947     }*/
3948 #else
3949     delete item;
3950     item = NULL;
3951 #endif
3952
3953     setDocumentModified();
3954     if (refresh) m_document->renderer()->doRefresh();
3955 }
3956
3957 void CustomTrackView::deleteSelectedClips()
3958 {
3959     resetSelectionGroup();
3960     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3961     if (itemList.count() == 0) {
3962         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
3963         return;
3964     }
3965     scene()->clearSelection();
3966     QUndoCommand *deleteSelected = new QUndoCommand();
3967
3968     int groupCount = 0;
3969     int clipCount = 0;
3970     int transitionCount = 0;
3971     // expand & destroy groups
3972     for (int i = 0; i < itemList.count(); i++) {
3973         if (itemList.at(i)->type() == GROUPWIDGET) {
3974             groupCount++;
3975             QList<QGraphicsItem *> children = itemList.at(i)->childItems();
3976             QList <ItemInfo> clipInfos;
3977             QList <ItemInfo> transitionInfos;
3978             for (int j = 0; j < children.count(); j++) {
3979                 if (children.at(j)->type() == AVWIDGET) {
3980                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
3981                     if (!clip->isItemLocked()) clipInfos.append(clip->info());
3982                 } else if (children.at(j)->type() == TRANSITIONWIDGET) {
3983                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
3984                     if (!clip->isItemLocked()) transitionInfos.append(clip->info());
3985                 }
3986                 if (itemList.contains(children.at(j))) {
3987                     children.removeAt(j);
3988                     j--;
3989                 }
3990             }
3991             itemList += children;
3992             if (clipInfos.count() > 0)
3993                 new GroupClipsCommand(this, clipInfos, transitionInfos, false, deleteSelected);
3994
3995         } else if (itemList.at(i)->parentItem() && itemList.at(i)->parentItem()->type() == GROUPWIDGET)
3996             itemList.insert(i + 1, itemList.at(i)->parentItem());
3997     }
3998
3999     for (int i = 0; i < itemList.count(); i++) {
4000         if (itemList.at(i)->type() == AVWIDGET) {
4001             clipCount++;
4002             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
4003             //kDebug()<<"// DELETE CLP AT: "<<item->info().startPos.frames(25);
4004             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false, true, true, deleteSelected);
4005             emit clipItemSelected(NULL);
4006         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
4007             transitionCount++;
4008             Transition *item = static_cast <Transition *>(itemList.at(i));
4009             //kDebug()<<"// DELETE TRANS AT: "<<item->info().startPos.frames(25);
4010             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
4011             emit transitionItemSelected(NULL);
4012         }
4013     }
4014     if (groupCount > 0 && clipCount == 0 && transitionCount == 0)
4015         deleteSelected->setText(i18np("Delete selected group", "Delete selected groups", groupCount));
4016     else if (clipCount > 0 && groupCount == 0 && transitionCount == 0)
4017         deleteSelected->setText(i18np("Delete selected clip", "Delete selected clips", clipCount));
4018     else if (transitionCount > 0 && groupCount == 0 && clipCount == 0)
4019         deleteSelected->setText(i18np("Delete selected transition", "Delete selected transitions", transitionCount));
4020     else deleteSelected->setText(i18n("Delete selected items"));
4021     updateTrackDuration(-1, deleteSelected);
4022     m_commandStack->push(deleteSelected);
4023 }
4024
4025
4026 void CustomTrackView::doChangeClipSpeed(ItemInfo info, ItemInfo speedIndependantInfo, const double speed, const double oldspeed, int strobe, const QString &id)
4027 {
4028     Q_UNUSED(id)
4029     //DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
4030
4031     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
4032     if (!item) {
4033         kDebug() << "ERROR: Cannot find clip for speed change";
4034         emit displayMessage(i18n("Cannot find clip for speed change"), ErrorMessage);
4035         return;
4036     }
4037     info.track = m_document->tracksCount() - item->track();
4038     int endPos = m_document->renderer()->mltChangeClipSpeed(info, speedIndependantInfo, speed, oldspeed, strobe, item->getProducer(item->track(), false));
4039     if (endPos >= 0) {
4040         item->setSpeed(speed, strobe);
4041         item->updateRectGeometry();
4042         if (item->cropDuration().frames(m_document->fps()) != endPos)
4043             item->resizeEnd((int) info.startPos.frames(m_document->fps()) + endPos - 1);
4044         updatePositionEffects(item, info);
4045         setDocumentModified();
4046     } else {
4047         emit displayMessage(i18n("Invalid clip"), ErrorMessage);
4048     }
4049 }
4050
4051 void CustomTrackView::cutSelectedClips()
4052 {
4053     QList<QGraphicsItem *> itemList = scene()->selectedItems();
4054     QList<AbstractGroupItem *> groups;
4055     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
4056     for (int i = 0; i < itemList.count(); ++i) {
4057         if (!itemList.at(i))
4058             continue;
4059         if (itemList.at(i)->type() == AVWIDGET) {
4060             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
4061             if (item->parentItem() && item->parentItem() != m_selectionGroup) {
4062                 AbstractGroupItem *group = static_cast <AbstractGroupItem *>(item->parentItem());
4063                 if (!groups.contains(group))
4064                     groups << group;
4065             } else if (currentPos > item->startPos() && currentPos < item->endPos()) {
4066                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos);
4067                 m_commandStack->push(command);
4068             }
4069         } else if (itemList.at(i)->type() == GROUPWIDGET && itemList.at(i) != m_selectionGroup) {
4070             AbstractGroupItem *group = static_cast<AbstractGroupItem *>(itemList.at(i));
4071             if (!groups.contains(group))
4072                 groups << group;
4073         }
4074     }
4075
4076     for (int i = 0; i < groups.count(); ++i)
4077         razorGroup(groups.at(i), currentPos);
4078 }
4079
4080 void CustomTrackView::razorGroup(AbstractGroupItem* group, GenTime cutPos)
4081 {
4082     if (group) {
4083         QList <QGraphicsItem *> children = group->childItems();
4084         QList <ItemInfo> clips1, transitions1;
4085         QList <ItemInfo> clipsCut, transitionsCut;
4086         QList <ItemInfo> clips2, transitions2;
4087         for (int i = 0; i < children.count(); ++i) {
4088             children.at(i)->setSelected(false);
4089             AbstractClipItem *child = static_cast <AbstractClipItem *>(children.at(i));
4090             if (child->type() == AVWIDGET) {
4091                 if (cutPos > child->endPos())
4092                     clips1 << child->info();
4093                 else if (cutPos < child->startPos())
4094                     clips2 << child->info();
4095                 else
4096                     clipsCut << child->info();
4097             } else {
4098                 if (cutPos > child->endPos())
4099                     transitions1 << child->info();
4100                 else if (cutPos < child->startPos())
4101                     transitions2 << child->info();
4102                 else
4103                     transitionsCut << child->info();
4104             }
4105         }
4106         if (clipsCut.isEmpty() && transitionsCut.isEmpty() && ((clips1.isEmpty() && transitions1.isEmpty()) || (clips2.isEmpty() && transitions2.isEmpty())))
4107             return;
4108         RazorGroupCommand *command = new RazorGroupCommand(this, clips1, transitions1, clipsCut, transitionsCut, clips2, transitions2, cutPos);
4109         m_commandStack->push(command);
4110     }
4111 }
4112
4113 void CustomTrackView::slotRazorGroup(QList <ItemInfo> clips1, QList <ItemInfo> transitions1, QList <ItemInfo> clipsCut, QList <ItemInfo> transitionsCut, QList <ItemInfo> clips2, QList <ItemInfo> transitions2, GenTime cutPos, bool cut)
4114 {
4115     if (cut) {
4116         for (int i = 0; i < clipsCut.count(); ++i) {
4117             ClipItem *clip = getClipItemAt(clipsCut.at(i).startPos.frames(m_document->fps()), clipsCut.at(i).track);
4118             if (clip) {
4119                 ClipItem *clipBehind = cutClip(clipsCut.at(i), cutPos, true);
4120                 clips1 << clip->info();
4121                 if (clipBehind != NULL)
4122                     clips2 << clipBehind->info();
4123             }
4124         }
4125         /* TODO: cut transitionsCut
4126          * For now just append them to group1 */
4127         transitions1 << transitionsCut;
4128         doGroupClips(clips1, transitions1, true);
4129         doGroupClips(clips2, transitions2, true);
4130     } else {
4131         /* we might also just use clipsCut.at(0)->parentItem().
4132          * Do this loop just in case something went wrong during cut */
4133         for (int i = 0; i < clipsCut.count(); ++i) {
4134             ClipItem *clip = getClipItemAt(cutPos.frames(m_document->fps()), clipsCut.at(i).track);
4135             if (clip && clip->parentItem() && clip->parentItem()->type() == GROUPWIDGET) {
4136                 AbstractGroupItem *group = static_cast <AbstractGroupItem *>(clip->parentItem());
4137                 QList <QGraphicsItem *> children = group->childItems();
4138                 QList <ItemInfo> groupClips;
4139                 QList <ItemInfo> groupTrans;
4140                 for (int j = 0; j < children.count(); ++j) {
4141                     if (children.at(j)->type() == AVWIDGET)
4142                         groupClips << ((AbstractClipItem *)children.at(j))->info();
4143                     else if (children.at(j)->type() == TRANSITIONWIDGET)
4144                         groupTrans << ((AbstractClipItem *)children.at(j))->info();
4145                 }
4146                 doGroupClips(groupClips, groupTrans, false);
4147                 break;
4148             }
4149         }
4150         for (int i = 0; i < clipsCut.count(); ++i)
4151             cutClip(clipsCut.at(i), cutPos, false);
4152         // TODO: uncut transitonsCut
4153         doGroupClips(QList <ItemInfo>() << clips1 << clipsCut << clips2, QList <ItemInfo>() << transitions1 << transitionsCut << transitions2, true);
4154     }
4155 }
4156
4157 void CustomTrackView::groupClips(bool group)
4158 {
4159     QList<QGraphicsItem *> itemList = scene()->selectedItems();
4160     QList <ItemInfo> clipInfos;
4161     QList <ItemInfo> transitionInfos;
4162
4163     // Expand groups
4164     int max = itemList.count();
4165     for (int i = 0; i < max; i++) {
4166         if (itemList.at(i)->type() == GROUPWIDGET) {
4167             itemList += itemList.at(i)->childItems();
4168         }
4169     }
4170
4171     for (int i = 0; i < itemList.count(); i++) {
4172         if (itemList.at(i)->type() == AVWIDGET) {
4173             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
4174             if (!clip->isItemLocked()) clipInfos.append(clip->info());
4175         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
4176             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
4177             if (!clip->isItemLocked()) transitionInfos.append(clip->info());
4178         }
4179     }
4180     if (clipInfos.count() > 0) {
4181         GroupClipsCommand *command = new GroupClipsCommand(this, clipInfos, transitionInfos, group);
4182         m_commandStack->push(command);
4183     }
4184 }
4185
4186 void CustomTrackView::doGroupClips(QList <ItemInfo> clipInfos, QList <ItemInfo> transitionInfos, bool group)
4187 {
4188     resetSelectionGroup();
4189     m_scene->clearSelection();
4190     if (!group) {
4191         for (int i = 0; i < clipInfos.count(); i++) {
4192             ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
4193             if (clip == NULL) continue;
4194             if (clip->parentItem() && clip->parentItem()->type() == GROUPWIDGET) {
4195                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
4196                 m_document->clipManager()->removeGroup(grp);
4197                 scene()->destroyItemGroup(grp);
4198             }
4199             clip->setFlag(QGraphicsItem::ItemIsMovable, true);
4200         }
4201         for (int i = 0; i < transitionInfos.count(); i++) {
4202             Transition *tr = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
4203             if (tr == NULL) continue;
4204             if (tr->parentItem() && tr->parentItem()->type() == GROUPWIDGET) {
4205                 AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(tr->parentItem());
4206                 m_document->clipManager()->removeGroup(grp);
4207                 scene()->destroyItemGroup(grp);
4208             }
4209             tr->setFlag(QGraphicsItem::ItemIsMovable, true);
4210         }
4211         setDocumentModified();
4212         return;
4213     }
4214
4215     QList <QGraphicsItemGroup *> groups;
4216     for (int i = 0; i < clipInfos.count(); i++) {
4217         ClipItem *clip = getClipItemAt(clipInfos.at(i).startPos, clipInfos.at(i).track);
4218         if (clip) {
4219             clip->setSelected(true);
4220         }
4221     }
4222     for (int i = 0; i < transitionInfos.count(); i++) {
4223         Transition *clip = getTransitionItemAt(transitionInfos.at(i).startPos, transitionInfos.at(i).track);
4224         if (clip) {
4225             clip->setSelected(true);
4226         }
4227     }
4228     groupSelectedItems(false, true);
4229     setDocumentModified();
4230 }
4231
4232 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects, bool overwrite, bool push, bool refresh)
4233 {
4234     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
4235     if (baseclip == NULL) {
4236         emit displayMessage(i18n("No clip copied"), ErrorMessage);
4237         return;
4238     }
4239
4240     if (baseclip->getProducer() == NULL) {
4241         // If the clip has no producer, we must wait until it is created...
4242         m_mutex.lock();
4243         emit displayMessage(i18n("Waiting for clip..."), InformationMessage);
4244         emit forceClipProcessing(clipId);
4245         qApp->processEvents();
4246         for (int i = 0; i < 10; i++) {
4247             if (baseclip->getProducer() == NULL) {
4248                 qApp->processEvents();
4249                 m_producerNotReady.wait(&m_mutex, 200);
4250             } else break;
4251         }
4252         if (baseclip->getProducer() == NULL) {
4253             emit displayMessage(i18n("Cannot insert clip..."), ErrorMessage);
4254             m_mutex.unlock();
4255             return;
4256         }
4257         emit displayMessage(QString(), InformationMessage);
4258         m_mutex.unlock();
4259     }
4260
4261     ClipItem *item = new ClipItem(baseclip, info, m_document->fps(), xml.attribute("speed", "1").toDouble(), xml.attribute("strobe", "1").toInt(), getFrameWidth());
4262     item->setEffectList(effects);
4263     if (xml.hasAttribute("audio_only")) item->setAudioOnly(true);
4264     else if (xml.hasAttribute("video_only")) item->setVideoOnly(true);
4265     scene()->addItem(item);
4266
4267     int producerTrack = info.track;
4268     int tracknumber = m_document->tracksCount() - info.track - 1;
4269     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
4270     if (isLocked) item->setItemLocked(true);
4271
4272     baseclip->addReference();
4273     m_document->updateClip(baseclip->getId());
4274     info.track = m_document->tracksCount() - info.track;
4275     m_document->renderer()->mltInsertClip(info, xml, item->getProducer(producerTrack), overwrite, push);
4276     for (int i = 0; i < item->effectsCount(); i++) {
4277         m_document->renderer()->mltAddEffect(info.track, info.startPos, getEffectArgs(item->effect(i)), false);
4278     }
4279     setDocumentModified();
4280     if (refresh)
4281         m_document->renderer()->doRefresh();
4282     if (!baseclip->isPlaceHolder())
4283         m_waitingThumbs.append(item);
4284     m_thumbsTimer.start();
4285 }
4286
4287 void CustomTrackView::slotUpdateClip(const QString &clipId, bool reload)
4288 {
4289     QMutexLocker locker(&m_mutex);
4290     QList<QGraphicsItem *> list = scene()->items();
4291     QList <ClipItem *>clipList;
4292     ClipItem *clip = NULL;
4293     DocClipBase *baseClip = NULL;
4294     Mlt::Tractor *tractor = m_document->renderer()->lockService();
4295     for (int i = 0; i < list.size(); ++i) {
4296         if (list.at(i)->type() == AVWIDGET) {
4297             clip = static_cast <ClipItem *>(list.at(i));
4298             if (clip->clipProducer() == clipId) {
4299                 if (baseClip == NULL) {
4300                     baseClip = clip->baseClip();
4301                 }
4302                 ItemInfo info = clip->info();
4303                 Mlt::Producer *prod = NULL;
4304                 if (clip->isAudioOnly()) prod = baseClip->audioProducer(info.track);
4305                 else if (clip->isVideoOnly()) prod = baseClip->videoProducer();
4306                 else prod = baseClip->getProducer(info.track);
4307                 if (reload && !m_document->renderer()->mltUpdateClip(tractor, info, clip->xml(), prod)) {
4308                     emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", info.startPos.frames(m_document->fps()), info.track), ErrorMessage);
4309                 }
4310                 else clipList.append(clip);
4311             }
4312         }
4313     }
4314     for (int i = 0; i < clipList.count(); i++)
4315         clipList.at(i)->refreshClip(true, true);
4316     m_document->renderer()->unlockService(tractor);
4317 }
4318
4319 ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track)
4320 {
4321     int framepos = (int)(pos.frames(m_document->fps()));
4322     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, track * m_tracksHeight + m_tracksHeight / 2));
4323     ClipItem *clip = NULL;
4324     for (int i = 0; i < list.size(); i++) {
4325         if (!list.at(i)->isEnabled()) continue;
4326         if (list.at(i)->type() == AVWIDGET) {
4327             ClipItem *test = static_cast <ClipItem *>(list.at(i));
4328             if (test->endPos() == pos) clip = test;
4329             break;
4330         }
4331     }
4332     return clip;
4333 }
4334
4335 ClipItem *CustomTrackView::getClipItemAtStart(GenTime pos, int track)
4336 {
4337     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2));
4338     ClipItem *clip = NULL;
4339     for (int i = 0; i < list.size(); i++) {
4340         if (!list.at(i)->isEnabled()) continue;
4341         if (list.at(i)->type() == AVWIDGET) {
4342             ClipItem *test = static_cast <ClipItem *>(list.at(i));
4343             if (test->startPos() == pos) clip = test;
4344             break;
4345         }
4346     }
4347     return clip;
4348 }
4349
4350 ClipItem *CustomTrackView::getClipItemAt(int pos, int track)
4351 {
4352     const QPointF p(pos, track * m_tracksHeight + m_tracksHeight / 2);
4353     QList<QGraphicsItem *> list = scene()->items(p);
4354     ClipItem *clip = NULL;
4355     for (int i = 0; i < list.size(); i++) {
4356         if (!list.at(i)->isEnabled()) continue;
4357         if (list.at(i)->type() == AVWIDGET) {
4358             clip = static_cast <ClipItem *>(list.at(i));
4359             break;
4360         }
4361     }
4362     return clip;
4363 }
4364
4365 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track)
4366 {
4367     return getClipItemAt((int) pos.frames(m_document->fps()), track);
4368 }
4369
4370
4371 Transition *CustomTrackView::getTransitionItem(TransitionInfo info)
4372 {
4373     int pos = info.startPos.frames(m_document->fps());
4374     int track = m_document->tracksCount() - info.b_track;
4375     return getTransitionItemAt(pos, track);
4376 }
4377
4378 Transition *CustomTrackView::getTransitionItemAt(int pos, int track)
4379 {
4380     const QPointF p(pos, track * m_tracksHeight + Transition::itemOffset() + 1);
4381     QList<QGraphicsItem *> list = scene()->items(p);
4382     Transition *clip = NULL;
4383     for (int i = 0; i < list.size(); i++) {
4384         if (!list.at(i)->isEnabled()) continue;
4385         if (list.at(i)->type() == TRANSITIONWIDGET) {
4386             clip = static_cast <Transition *>(list.at(i));
4387             break;
4388         }
4389     }
4390     return clip;
4391 }
4392
4393 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track)
4394 {
4395     return getTransitionItemAt(pos.frames(m_document->fps()), track);
4396 }
4397
4398 Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track)
4399 {
4400     int framepos = (int)(pos.frames(m_document->fps()));
4401     const QPointF p(framepos - 1, track * m_tracksHeight + Transition::itemOffset() + 1);
4402     QList<QGraphicsItem *> list = scene()->items(p);
4403     Transition *clip = NULL;
4404     for (int i = 0; i < list.size(); i++) {
4405         if (!list.at(i)->isEnabled()) continue;
4406         if (list.at(i)->type() == TRANSITIONWIDGET) {
4407             Transition *test = static_cast <Transition *>(list.at(i));
4408             if (test->endPos() == pos) clip = test;
4409             break;
4410         }
4411     }
4412     return clip;
4413 }
4414
4415 Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track)
4416 {
4417     const QPointF p(pos.frames(m_document->fps()), track * m_tracksHeight + Transition::itemOffset() + 1);
4418     QList<QGraphicsItem *> list = scene()->items(p);
4419     Transition *clip = NULL;
4420     for (int i = 0; i < list.size(); ++i) {
4421         if (!list.at(i)->isEnabled()) continue;
4422         if (list.at(i)->type() == TRANSITIONWIDGET) {
4423             Transition *test = static_cast <Transition *>(list.at(i));
4424             if (test->startPos() == pos) clip = test;
4425             break;
4426         }
4427     }
4428     return clip;
4429 }
4430
4431 bool CustomTrackView::moveClip(const ItemInfo &start, const ItemInfo &end, bool refresh, ItemInfo *out_actualEnd)
4432 {
4433     if (m_selectionGroup) resetSelectionGroup(false);
4434     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()), start.track);
4435     if (!item) {
4436         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);
4437         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";
4438         return false;
4439     }
4440     Mlt::Producer *prod = item->getProducer(end.track);
4441
4442 #ifdef DEBUG
4443     qDebug() << "Moving item " << (long)item << " from .. to:";
4444     qDebug() << item->info();
4445     qDebug() << start;
4446     qDebug() << end;
4447 #endif
4448     bool success = m_document->renderer()->mltMoveClip((int)(m_document->tracksCount() - start.track), (int)(m_document->tracksCount() - end.track),
4449                                                        (int) start.startPos.frames(m_document->fps()), (int)end.startPos.frames(m_document->fps()),
4450                                                        prod);
4451     if (success) {
4452         bool snap = KdenliveSettings::snaptopoints();
4453         KdenliveSettings::setSnaptopoints(false);
4454         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
4455
4456         int tracknumber = m_document->tracksCount() - end.track - 1;
4457         bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
4458         m_scene->clearSelection();
4459         if (isLocked) item->setItemLocked(true);
4460         else {
4461             if (item->isItemLocked()) item->setItemLocked(false);
4462             item->setSelected(true);
4463         }
4464         if (item->baseClip()->isTransparent()) {
4465             // Also move automatic transition
4466             Transition *tr = getTransitionItemAt(start.startPos, start.track);
4467             if (tr && tr->isAutomatic()) {
4468                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
4469                 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);
4470                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
4471             }
4472         }
4473         KdenliveSettings::setSnaptopoints(snap);
4474         setDocumentModified();
4475     } else {
4476         // undo last move and emit error message
4477         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
4478     }
4479     if (refresh) m_document->renderer()->doRefresh();
4480     if (out_actualEnd != NULL) {
4481         *out_actualEnd = item->info();
4482 #ifdef DEBUG
4483         qDebug() << "Actual end position updated:" << *out_actualEnd;
4484 #endif
4485     }
4486 #ifdef DEBUG
4487     qDebug() << item->info();
4488 #endif
4489     return success;
4490 }
4491
4492 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime &offset, const int trackOffset, bool reverseMove)
4493 {
4494     // Group Items
4495     resetSelectionGroup();
4496     m_scene->clearSelection();
4497
4498     m_selectionGroup = new AbstractGroupItem(m_document->fps());
4499     scene()->addItem(m_selectionGroup);
4500
4501     m_document->renderer()->blockSignals(true);
4502     for (int i = 0; i < startClip.count(); i++) {
4503         if (reverseMove) {
4504             startClip[i].startPos = startClip.at(i).startPos - offset;
4505             startClip[i].track = startClip.at(i).track - trackOffset;
4506         }
4507         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
4508         if (clip) {
4509             clip->setItemLocked(false);
4510             if (clip->parentItem()) {
4511                 m_selectionGroup->addToGroup(clip->parentItem());
4512                 clip->parentItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
4513             } else {
4514                 m_selectionGroup->addToGroup(clip);
4515                 clip->setFlag(QGraphicsItem::ItemIsMovable, false);
4516             }
4517             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
4518         } else kDebug() << "//MISSING CLIP AT: " << startClip.at(i).startPos.frames(25);
4519     }
4520     for (int i = 0; i < startTransition.count(); i++) {
4521         if (reverseMove) {
4522             startTransition[i].startPos = startTransition.at(i).startPos - offset;
4523             startTransition[i].track = startTransition.at(i).track - trackOffset;
4524         }
4525         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
4526         if (tr) {
4527             tr->setItemLocked(false);
4528             if (tr->parentItem()) {
4529                 m_selectionGroup->addToGroup(tr->parentItem());
4530                 tr->parentItem()->setFlag(QGraphicsItem::ItemIsMovable, false);
4531             } else {
4532                 m_selectionGroup->addToGroup(tr);
4533                 tr->setFlag(QGraphicsItem::ItemIsMovable, false);
4534             }
4535             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());
4536         } else kDebug() << "//MISSING TRANSITION AT: " << startTransition.at(i).startPos.frames(25);
4537     }
4538     m_document->renderer()->blockSignals(false);
4539
4540     if (m_selectionGroup) {
4541         bool snap = KdenliveSettings::snaptopoints();
4542         KdenliveSettings::setSnaptopoints(false);
4543
4544         m_selectionGroup->translate(offset.frames(m_document->fps()), trackOffset *(qreal) m_tracksHeight);
4545         //m_selectionGroup->moveBy(offset.frames(m_document->fps()), trackOffset *(qreal) m_tracksHeight);
4546
4547         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
4548         // Expand groups
4549         int max = children.count();
4550         for (int i = 0; i < max; i++) {
4551             if (children.at(i)->type() == GROUPWIDGET) {
4552                 children += children.at(i)->childItems();
4553                 //AbstractGroupItem *grp = static_cast<AbstractGroupItem *>(children.at(i));
4554                 //grp->moveBy(offset.frames(m_document->fps()), trackOffset *(qreal) m_tracksHeight);
4555                 /*m_document->clipManager()->removeGroup(grp);
4556                 m_scene->destroyItemGroup(grp);*/
4557                 children.removeAll(children.at(i));
4558                 i--;
4559             }
4560         }
4561
4562         for (int i = 0; i < children.count(); i++) {
4563             // re-add items in correct place
4564             if (children.at(i)->type() != AVWIDGET && children.at(i)->type() != TRANSITIONWIDGET) continue;
4565             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
4566             item->updateItem();
4567             ItemInfo info = item->info();
4568             int tracknumber = m_document->tracksCount() - info.track - 1;
4569             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
4570             if (isLocked)
4571                 item->setItemLocked(true);
4572             else if (item->isItemLocked())
4573                 item->setItemLocked(false);
4574
4575             if (item->type() == AVWIDGET) {
4576                 ClipItem *clip = static_cast <ClipItem*>(item);
4577                 int trackProducer = info.track;
4578                 info.track = m_document->tracksCount() - info.track;
4579                 m_document->renderer()->mltInsertClip(info, clip->xml(), clip->getProducer(trackProducer));
4580                 for (int i = 0; i < clip->effectsCount(); i++) {
4581                     m_document->renderer()->mltAddEffect(info.track, info.startPos, getEffectArgs(clip->effect(i)), false);
4582                 }
4583             } else if (item->type() == TRANSITIONWIDGET) {
4584                 Transition *tr = static_cast <Transition*>(item);
4585                 int newTrack;
4586                 if (!tr->forcedTrack()) {
4587                     newTrack = getPreviousVideoTrack(info.track);
4588                 } else {
4589                     newTrack = tr->transitionEndTrack() + trackOffset;
4590                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
4591                 }
4592                 tr->updateTransitionEndTrack(newTrack);
4593                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
4594             }
4595         }
4596
4597         resetSelectionGroup(false);
4598
4599         for (int i = 0; i < children.count(); i++) {
4600             if (children.at(i)->parentItem())
4601                 rebuildGroup((AbstractGroupItem*)children.at(i)->parentItem());
4602         }
4603         clearSelection();
4604
4605         KdenliveSettings::setSnaptopoints(snap);
4606         m_document->renderer()->doRefresh();
4607     } else kDebug() << "///////// WARNING; NO GROUP TO MOVE";
4608 }
4609
4610 void CustomTrackView::moveTransition(const ItemInfo &start, const ItemInfo &end, bool refresh)
4611 {
4612     Transition *item = getTransitionItemAt(start.startPos, start.track);
4613     if (!item) {
4614         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);
4615         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
4616         return;
4617     }
4618
4619     bool snap = KdenliveSettings::snaptopoints();
4620     KdenliveSettings::setSnaptopoints(false);
4621
4622     if (end.endPos - end.startPos == start.endPos - start.startPos) {
4623         // Transition was moved
4624         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
4625     } else if (end.endPos == start.endPos) {
4626         // Transition start resize
4627         item->resizeStart((int) end.startPos.frames(m_document->fps()));
4628     } else if (end.startPos == start.startPos) {
4629         // Transition end resize;
4630         kDebug() << "// resize END: " << end.endPos.frames(m_document->fps());
4631         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
4632     } else {
4633         // Move & resize
4634         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
4635         item->resizeStart((int) end.startPos.frames(m_document->fps()));
4636         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
4637     }
4638     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
4639     KdenliveSettings::setSnaptopoints(snap);
4640     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
4641     m_document->renderer()->mltMoveTransition(item->transitionTag(), m_document->tracksCount() - start.track, m_document->tracksCount() - item->track(), item->transitionEndTrack(), start.startPos, start.endPos, item->startPos(), item->endPos());
4642     if (m_dragItem && m_dragItem == item) {
4643         QPoint p;
4644         ClipItem *transitionClip = getClipItemAt(item->startPos(), item->track());
4645         if (transitionClip && transitionClip->baseClip()) {
4646             QString size = transitionClip->baseClip()->getProperty("frame_size");
4647             double factor = transitionClip->baseClip()->getProperty("aspect_ratio").toDouble();
4648             if (factor == 0) factor = 1.0;
4649             p.setX((int)(size.section('x', 0, 0).toInt() * factor + 0.5));
4650             p.setY(size.section('x', 1, 1).toInt());
4651         }
4652         emit transitionItemSelected(item, getPreviousVideoTrack(item->track()), p);
4653     }
4654     if (refresh) m_document->renderer()->doRefresh();
4655     setDocumentModified();
4656 }
4657
4658 void CustomTrackView::resizeClip(const ItemInfo &start, const ItemInfo &end, bool dontWorry)
4659 {
4660     bool resizeClipStart = (start.startPos != end.startPos);
4661     ClipItem *item = getClipItemAtStart(start.startPos, start.track);
4662     if (!item) {
4663         if (dontWorry) return;
4664         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);
4665         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
4666         return;
4667     }
4668     if (item->parentItem()) {
4669         // Item is part of a group, reset group
4670         resetSelectionGroup();
4671     }
4672
4673     bool snap = KdenliveSettings::snaptopoints();
4674     KdenliveSettings::setSnaptopoints(false);
4675
4676     if (resizeClipStart) {
4677         ItemInfo clipinfo = item->info();
4678         clipinfo.track = m_document->tracksCount() - clipinfo.track;
4679         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - clipinfo.startPos);
4680         if (success)
4681             item->resizeStart((int) end.startPos.frames(m_document->fps()));
4682         else
4683             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
4684     } else {
4685         ItemInfo clipinfo = item->info();
4686         clipinfo.track = m_document->tracksCount() - clipinfo.track;
4687         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
4688         if (success)
4689             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
4690         else
4691             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
4692     }
4693     if (!resizeClipStart && end.cropStart != start.cropStart) {
4694         kDebug() << "// RESIZE CROP, DIFF: " << (end.cropStart - start.cropStart).frames(25);
4695         ItemInfo clipinfo = end;
4696         clipinfo.track = m_document->tracksCount() - end.track;
4697         bool success = m_document->renderer()->mltResizeClipCrop(clipinfo, end.cropStart - start.cropStart);
4698         if (success) {
4699             item->setCropStart(end.cropStart);
4700             item->resetThumbs(true);
4701         }
4702     }
4703     m_document->renderer()->doRefresh();
4704     KdenliveSettings::setSnaptopoints(snap);
4705     setDocumentModified();
4706 }
4707
4708 void CustomTrackView::prepareResizeClipStart(AbstractClipItem* item, ItemInfo oldInfo, int pos, bool check, QUndoCommand *command)
4709 {
4710     if (pos == oldInfo.startPos.frames(m_document->fps()))
4711         return;
4712     bool snap = KdenliveSettings::snaptopoints();
4713     if (check) {
4714         KdenliveSettings::setSnaptopoints(false);
4715         item->resizeStart(pos);
4716         if (item->startPos().frames(m_document->fps()) != pos) {
4717             item->resizeStart(oldInfo.startPos.frames(m_document->fps()));
4718             emit displayMessage(i18n("Not possible to resize"), ErrorMessage);
4719             KdenliveSettings::setSnaptopoints(snap);
4720             return;
4721         }
4722         KdenliveSettings::setSnaptopoints(snap);
4723     }
4724
4725     bool hasParentCommand = false;
4726     if (command) {
4727         hasParentCommand = true;
4728     } else {
4729         command = new QUndoCommand();
4730         command->setText(i18n("Resize clip start"));
4731     }
4732
4733     // do this here, too, because otherwise undo won't update the group
4734     if (item->parentItem() && item->parentItem() != m_selectionGroup)
4735         new RebuildGroupCommand(this, item->info().track, item->endPos() - GenTime(1, m_document->fps()), command);
4736
4737     ItemInfo info = item->info();
4738     if (item->type() == AVWIDGET) {
4739         ItemInfo resizeinfo = oldInfo;
4740         resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
4741         bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, item->startPos() - oldInfo.startPos);
4742         if (success) {
4743             // Check if there is an automatic transition on that clip (lower track)
4744             Transition *transition = getTransitionItemAtStart(oldInfo.startPos, oldInfo.track);
4745             if (transition && transition->isAutomatic()) {
4746                 ItemInfo trInfo = transition->info();
4747                 ItemInfo newTrInfo = trInfo;
4748                 newTrInfo.startPos = item->startPos();
4749                 if (newTrInfo.startPos < newTrInfo.endPos)
4750                     new MoveTransitionCommand(this, trInfo, newTrInfo, true, command);
4751             }
4752             // Check if there is an automatic transition on that clip (upper track)
4753             transition = getTransitionItemAtStart(oldInfo.startPos, oldInfo.track - 1);
4754             if (transition && transition->isAutomatic() && (m_document->tracksCount() - transition->transitionEndTrack()) == oldInfo.track) {
4755                 ItemInfo trInfo = transition->info();
4756                 ItemInfo newTrInfo = trInfo;
4757                 newTrInfo.startPos = item->startPos();
4758                 ClipItem * upperClip = getClipItemAt(oldInfo.startPos, oldInfo.track - 1);
4759                 if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.startPos < newTrInfo.endPos)
4760                     new MoveTransitionCommand(this, trInfo, newTrInfo, true, command);
4761             }
4762
4763             ClipItem *clip = static_cast < ClipItem * >(item);
4764
4765             // Hack:
4766             // Since we must always resize clip before updating the keyframes, we
4767             // put a resize command before & after checking keyframes so that
4768             // we are sure the resize is performed before whenever we do or undo the action
4769             new ResizeClipCommand(this, oldInfo, info, false, true, command);
4770             adjustEffects(clip, oldInfo, command);
4771             new ResizeClipCommand(this, oldInfo, info, false, true, command);
4772             emit clipItemSelected(clip);
4773         } else {
4774             KdenliveSettings::setSnaptopoints(false);
4775             item->resizeStart((int) oldInfo.startPos.frames(m_document->fps()));
4776             KdenliveSettings::setSnaptopoints(snap);
4777             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
4778         }
4779     } else if (item->type() == TRANSITIONWIDGET) {
4780         Transition *transition = static_cast <Transition *>(item);
4781         if (!m_document->renderer()->mltMoveTransition(transition->transitionTag(), (int)(m_document->tracksCount() - oldInfo.track), (int)(m_document->tracksCount() - oldInfo.track), transition->transitionEndTrack(), oldInfo.startPos, oldInfo.endPos, info.startPos, info.endPos)) {
4782             // Cannot resize transition
4783             KdenliveSettings::setSnaptopoints(false);
4784             transition->resizeStart((int) oldInfo.startPos.frames(m_document->fps()));
4785             KdenliveSettings::setSnaptopoints(snap);
4786             emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
4787         } else {
4788             MoveTransitionCommand *moveCommand = new MoveTransitionCommand(this, oldInfo, info, false, command);
4789             if (command == NULL)
4790                 m_commandStack->push(moveCommand);
4791         }
4792
4793     }
4794     if (item->parentItem() && item->parentItem() != m_selectionGroup)
4795         new RebuildGroupCommand(this, item->info().track, item->endPos() - GenTime(1, m_document->fps()), command);
4796
4797     if (!hasParentCommand)
4798         m_commandStack->push(command);
4799 }
4800
4801 void CustomTrackView::prepareResizeClipEnd(AbstractClipItem* item, ItemInfo oldInfo, int pos, bool check, QUndoCommand *command)
4802 {
4803     if (pos == oldInfo.endPos.frames(m_document->fps()))
4804         return;
4805     bool snap = KdenliveSettings::snaptopoints();
4806     if (check) {
4807         KdenliveSettings::setSnaptopoints(false);
4808         item->resizeEnd(pos);
4809         if (item->endPos().frames(m_document->fps()) != pos) {
4810             item->resizeEnd(oldInfo.endPos.frames(m_document->fps()));
4811             emit displayMessage(i18n("Not possible to resize"), ErrorMessage);
4812             KdenliveSettings::setSnaptopoints(snap);
4813             return;
4814         }
4815         KdenliveSettings::setSnaptopoints(snap);
4816     }
4817
4818     bool hasParentCommand = false;
4819     if (command) {
4820         hasParentCommand = true;
4821     } else {
4822         command = new QUndoCommand();
4823     }
4824
4825     // do this here, too, because otherwise undo won't update the group
4826     if (item->parentItem() && item->parentItem() != m_selectionGroup)
4827         new RebuildGroupCommand(this, item->info().track, item->startPos(), command);
4828
4829     ItemInfo info = item->info();
4830     if (item->type() == AVWIDGET) {
4831         if (!hasParentCommand) command->setText(i18n("Resize clip end"));
4832         ItemInfo resizeinfo = info;
4833         resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
4834         bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.cropDuration);
4835         if (success) {
4836             // Check if there is an automatic transition on that clip (lower track)
4837             Transition *tr = getTransitionItemAtEnd(oldInfo.endPos, oldInfo.track);
4838             if (tr && tr->isAutomatic()) {
4839                 ItemInfo trInfo = tr->info();
4840                 ItemInfo newTrInfo = trInfo;
4841                 newTrInfo.endPos = item->endPos();
4842                 if (newTrInfo.endPos > newTrInfo.startPos)
4843                     new MoveTransitionCommand(this, trInfo, newTrInfo, true, command);
4844             }
4845
4846             // Check if there is an automatic transition on that clip (upper track)
4847             tr = getTransitionItemAtEnd(oldInfo.endPos, oldInfo.track - 1);
4848             if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == oldInfo.track) {
4849                 ItemInfo trInfo = tr->info();
4850                 ItemInfo newTrInfo = trInfo;
4851                 newTrInfo.endPos = item->endPos();
4852                 ClipItem * upperClip = getClipItemAtEnd(oldInfo.endPos, oldInfo.track - 1);
4853                 if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.endPos > newTrInfo.startPos)
4854                     new MoveTransitionCommand(this, trInfo, newTrInfo, true, command);
4855
4856             }
4857
4858             ClipItem *clip = static_cast < ClipItem * >(item);
4859
4860             // Hack:
4861             // Since we must always resize clip before updating the keyframes, we
4862             // put a resize command before & after checking keyframes so that
4863             // we are sure the resize is performed before whenever we do or undo the action
4864             new ResizeClipCommand(this, oldInfo, info, false, true, command);
4865             adjustEffects(clip, oldInfo, command);
4866             new ResizeClipCommand(this, oldInfo, info, false, true, command);
4867             emit clipItemSelected(clip);
4868         } else {
4869             KdenliveSettings::setSnaptopoints(false);
4870             item->resizeEnd((int) oldInfo.endPos.frames(m_document->fps()));
4871             KdenliveSettings::setSnaptopoints(true);
4872             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
4873         }
4874     } else if (item->type() == TRANSITIONWIDGET) {
4875         if (!hasParentCommand) command->setText(i18n("Resize transition end"));
4876         Transition *transition = static_cast <Transition *>(item);
4877         if (!m_document->renderer()->mltMoveTransition(transition->transitionTag(), (int)(m_document->tracksCount() - oldInfo.track), (int)(m_document->tracksCount() - oldInfo.track), transition->transitionEndTrack(), oldInfo.startPos, oldInfo.endPos, info.startPos, info.endPos)) {
4878             // Cannot resize transition
4879             KdenliveSettings::setSnaptopoints(false);
4880             transition->resizeEnd((int) oldInfo.endPos.frames(m_document->fps()));
4881             KdenliveSettings::setSnaptopoints(true);
4882             emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
4883         } else {
4884             // Check transition keyframes
4885             QDomElement old = transition->toXML();
4886             if (transition->updateKeyframes()) {
4887                 QDomElement xml = transition->toXML();
4888                 m_document->renderer()->mltUpdateTransition(xml.attribute("tag"), xml.attribute("tag"), xml.attribute("transition_btrack").toInt(), m_document->tracksCount() - xml.attribute("transition_atrack").toInt(), transition->startPos(), transition->endPos(), xml);
4889                 new EditTransitionCommand(this, transition->track(), transition->startPos(), old, xml, false, command);
4890             }
4891             new MoveTransitionCommand(this, oldInfo, info, false, command);
4892         }
4893     }
4894     if (item->parentItem() && item->parentItem() != m_selectionGroup)
4895         new RebuildGroupCommand(this, item->info().track, item->startPos(), command);
4896
4897     if (!hasParentCommand) {
4898         updateTrackDuration(oldInfo.track, command);
4899         m_commandStack->push(command);
4900     }
4901 }
4902
4903 void CustomTrackView::updatePositionEffects(ClipItem* item, ItemInfo info, bool standalone)
4904 {
4905     int end = item->fadeIn();
4906     if (end != 0) {
4907         // there is a fade in effect
4908         int effectPos = item->hasEffect("volume", "fadein");
4909         if (effectPos != -1) {
4910             QDomElement effect = item->getEffectAtIndex(effectPos);
4911             int start = item->cropStart().frames(m_document->fps());
4912             int max = item->cropDuration().frames(m_document->fps());
4913             if (end > max) {
4914                 // Make sure the fade effect is not longer than the clip
4915                 item->setFadeIn(max);
4916                 end = item->fadeIn();
4917             }
4918             end += start;
4919             EffectsList::setParameter(effect, "in", QString::number(start));
4920             EffectsList::setParameter(effect, "out", QString::number(end));
4921             if (standalone) {
4922                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), getEffectArgs(effect)))
4923                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
4924                 // if fade effect is displayed, update the effect edit widget with new clip duration
4925                 if (item->isSelected() && effectPos == item->selectedEffectIndex())
4926                     emit clipItemSelected(item);
4927             }
4928         }
4929         effectPos = item->hasEffect("brightness", "fade_from_black");
4930         if (effectPos != -1) {
4931             QDomElement effect = item->getEffectAtIndex(effectPos);
4932             int start = item->cropStart().frames(m_document->fps());
4933             int max = item->cropDuration().frames(m_document->fps());
4934             if (end > max) {
4935                 // Make sure the fade effect is not longer than the clip
4936                 item->setFadeIn(max);
4937                 end = item->fadeIn();
4938             }
4939             end += start;
4940             EffectsList::setParameter(effect, "in", QString::number(start));
4941             EffectsList::setParameter(effect, "out", QString::number(end));
4942             if (standalone) {
4943                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), getEffectArgs(effect)))
4944                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
4945                 // if fade effect is displayed, update the effect edit widget with new clip duration
4946                 if (item->isSelected() && effectPos == item->selectedEffectIndex())
4947                     emit clipItemSelected(item);
4948             }
4949         }
4950     }
4951
4952     int start = item->fadeOut();
4953     if (start != 0) {
4954         // there is a fade out effect
4955         int effectPos = item->hasEffect("volume", "fadeout");
4956         if (effectPos != -1) {
4957             QDomElement effect = item->getEffectAtIndex(effectPos);
4958             int max = item->cropDuration().frames(m_document->fps());
4959             int end = max + item->cropStart().frames(m_document->fps());
4960             if (start > max) {
4961                 // Make sure the fade effect is not longer than the clip
4962                 item->setFadeOut(max);
4963                 start = item->fadeOut();
4964             }
4965             start = end - start;
4966             EffectsList::setParameter(effect, "in", QString::number(start));
4967             EffectsList::setParameter(effect, "out", QString::number(end));
4968             if (standalone) {
4969                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), getEffectArgs(effect)))
4970                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
4971                 // if fade effect is displayed, update the effect edit widget with new clip duration
4972                 if (item->isSelected() && effectPos == item->selectedEffectIndex())
4973                     emit clipItemSelected(item);
4974             }
4975         }
4976         effectPos = item->hasEffect("brightness", "fade_to_black");
4977         if (effectPos != -1) {
4978             QDomElement effect = item->getEffectAtIndex(effectPos);
4979             int max = item->cropDuration().frames(m_document->fps());
4980             int end = max + item->cropStart().frames(m_document->fps());
4981             if (start > max) {
4982                 // Make sure the fade effect is not longer than the clip
4983                 item->setFadeOut(max);
4984                 start = item->fadeOut();
4985             }
4986             start = end - start;
4987             EffectsList::setParameter(effect, "in", QString::number(start));
4988             EffectsList::setParameter(effect, "out", QString::number(end));
4989             if (standalone) {
4990                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), getEffectArgs(effect)))
4991                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
4992                 // if fade effect is displayed, update the effect edit widget with new clip duration
4993                 if (item->isSelected() && effectPos == item->selectedEffectIndex())
4994                     emit clipItemSelected(item);
4995             }
4996         }
4997     }
4998
4999     int effectPos = item->hasEffect("freeze", "freeze");
5000     if (effectPos != -1) {
5001         // Freeze effect needs to be adjusted with clip resize
5002         int diff = (info.startPos - item->startPos()).frames(m_document->fps());
5003         QDomElement eff = item->getEffectAtIndex(effectPos);
5004         if (!eff.isNull() && diff != 0) {
5005             int freeze_pos = EffectsList::parameter(eff, "frame").toInt() + diff;
5006             EffectsList::setParameter(eff, "frame", QString::number(freeze_pos));
5007             if (standalone) {
5008                 if (item->isSelected() && item->selectedEffect().attribute("id") == "freeze") {
5009                     emit clipItemSelected(item);
5010                 }
5011             }
5012         }
5013     }
5014 }
5015
5016 double CustomTrackView::getSnapPointForPos(double pos)
5017 {
5018     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
5019 }
5020
5021 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected, QList <GenTime> offsetList, bool skipSelectedItems)
5022 {
5023     QList <GenTime> snaps;
5024     if (selected && offsetList.isEmpty()) offsetList.append(selected->cropDuration());
5025     QList<QGraphicsItem *> itemList = items();
5026     for (int i = 0; i < itemList.count(); i++) {
5027         if (itemList.at(i) == selected) continue;
5028         if (skipSelectedItems && itemList.at(i)->isSelected()) continue;
5029         if (itemList.at(i)->type() == AVWIDGET) {
5030             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
5031             GenTime start = item->startPos();
5032             GenTime end = item->endPos();
5033             snaps.append(start);
5034             snaps.append(end);
5035             if (!offsetList.isEmpty()) {
5036                 for (int j = 0; j < offsetList.size(); j++) {
5037                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
5038                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
5039                 }
5040             }
5041             // Add clip markers
5042             QList < GenTime > markers = item->snapMarkers();
5043             for (int j = 0; j < markers.size(); ++j) {
5044                 GenTime t = markers.at(j);
5045                 snaps.append(t);
5046                 if (!offsetList.isEmpty()) {
5047                     for (int k = 0; k < offsetList.size(); k++) {
5048                         if (t > offsetList.at(k)) snaps.append(t - offsetList.at(k));
5049                     }
5050                 }
5051             }
5052         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
5053             Transition *transition = static_cast <Transition*>(itemList.at(i));
5054             GenTime start = transition->startPos();
5055             GenTime end = transition->endPos();
5056             snaps.append(start);
5057             snaps.append(end);
5058             if (!offsetList.isEmpty()) {
5059                 for (int j = 0; j < offsetList.size(); j++) {
5060                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
5061                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
5062                 }
5063             }
5064         }
5065     }
5066
5067     // add cursor position
5068     GenTime pos = GenTime(m_cursorPos, m_document->fps());
5069     snaps.append(pos);
5070     if (!offsetList.isEmpty()) {
5071         for (int j = 0; j < offsetList.size(); j++) {
5072             snaps.append(pos - offsetList.at(j));
5073         }
5074     }
5075
5076     // add guides
5077     for (int i = 0; i < m_guides.count(); i++) {
5078         snaps.append(m_guides.at(i)->position());
5079         if (!offsetList.isEmpty()) {
5080             for (int j = 0; j < offsetList.size(); j++) {
5081                 snaps.append(m_guides.at(i)->position() - offsetList.at(j));
5082             }
5083         }
5084     }
5085
5086     // add render zone
5087     QPoint z = m_document->zone();
5088     snaps.append(GenTime(z.x(), m_document->fps()));
5089     snaps.append(GenTime(z.y(), m_document->fps()));
5090
5091     qSort(snaps);
5092     m_scene->setSnapList(snaps);
5093     //for (int i = 0; i < m_snapPoints.size(); ++i)
5094     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
5095 }
5096
5097 void CustomTrackView::slotSeekToPreviousSnap()
5098 {
5099     updateSnapPoints(NULL);
5100     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
5101     setCursorPos((int) res.frames(m_document->fps()));
5102     checkScrolling();
5103 }
5104
5105 void CustomTrackView::slotSeekToNextSnap()
5106 {
5107     updateSnapPoints(NULL);
5108     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
5109     setCursorPos((int) res.frames(m_document->fps()));
5110     checkScrolling();
5111 }
5112
5113 void CustomTrackView::clipStart()
5114 {
5115     AbstractClipItem *item = getMainActiveClip();
5116     if (item != NULL) {
5117         setCursorPos((int) item->startPos().frames(m_document->fps()));
5118         checkScrolling();
5119     }
5120 }
5121
5122 void CustomTrackView::clipEnd()
5123 {
5124     AbstractClipItem *item = getMainActiveClip();
5125     if (item != NULL) {
5126         setCursorPos((int) item->endPos().frames(m_document->fps()) - 1);
5127         checkScrolling();
5128     }
5129 }
5130
5131 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c)
5132 {
5133     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
5134     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t);
5135     m_commandStack->push(command);
5136 }
5137
5138 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position)
5139 {
5140     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position);
5141     m_commandStack->push(command);
5142 }
5143
5144 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id)
5145 {
5146     DocClipBase *base = m_document->clipManager()->getClipById(id);
5147     QList <CommentedTime> markers = base->commentedSnapMarkers();
5148
5149     if (markers.isEmpty()) {
5150         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
5151         return;
5152     }
5153     QUndoCommand *deleteMarkers = new QUndoCommand();
5154     deleteMarkers->setText("Delete clip markers");
5155
5156     for (int i = 0; i < markers.size(); i++) {
5157         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), deleteMarkers);
5158     }
5159     m_commandStack->push(deleteMarkers);
5160 }
5161
5162 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString &comment)
5163 {
5164     DocClipBase *base = m_document->clipManager()->getClipById(id);
5165     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
5166     else base->deleteSnapMarker(pos);
5167     emit updateClipMarkers(base);
5168     setDocumentModified();
5169     viewport()->update();
5170 }
5171
5172 int CustomTrackView::hasGuide(int pos, int offset)
5173 {
5174     for (int i = 0; i < m_guides.count(); i++) {
5175         int guidePos = m_guides.at(i)->position().frames(m_document->fps());
5176         if (qAbs(guidePos - pos) <= offset) return guidePos;
5177         else if (guidePos > pos) return -1;
5178     }
5179     return -1;
5180 }
5181
5182 void CustomTrackView::buildGuidesMenu(QMenu *goMenu) const
5183 {
5184     QAction *act;
5185     goMenu->clear();
5186     double fps = m_document->fps();
5187     for (int i = 0; i < m_guides.count(); i++) {
5188         act = goMenu->addAction(m_guides.at(i)->label() + "/" + Timecode::getStringTimecode(m_guides.at(i)->position().frames(fps), fps));
5189         act->setData(m_guides.at(i)->position().frames(m_document->fps()));
5190     }
5191     goMenu->setEnabled(!m_guides.isEmpty());
5192 }
5193
5194 void CustomTrackView::editGuide(const GenTime &oldPos, const GenTime &pos, const QString &comment)
5195 {
5196     if (oldPos > GenTime() && pos > GenTime()) {
5197         // move guide
5198         for (int i = 0; i < m_guides.count(); i++) {
5199             if (m_guides.at(i)->position() == oldPos) {
5200                 Guide *item = m_guides.at(i);
5201                 item->updateGuide(pos, comment);
5202                 break;
5203             }
5204         }
5205     } else if (pos > GenTime()) addGuide(pos, comment);
5206     else {
5207         // remove guide
5208         bool found = false;
5209         for (int i = 0; i < m_guides.count(); i++) {
5210             if (m_guides.at(i)->position() == oldPos) {
5211                 delete m_guides.takeAt(i);
5212                 found = true;
5213                 break;
5214             }
5215         }
5216         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
5217     }
5218     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
5219     m_document->syncGuides(m_guides);
5220 }
5221
5222 bool CustomTrackView::addGuide(const GenTime &pos, const QString &comment)
5223 {
5224     for (int i = 0; i < m_guides.count(); i++) {
5225         if (m_guides.at(i)->position() == pos) {
5226             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
5227             return false;
5228         }
5229     }
5230     Guide *g = new Guide(this, pos, comment, m_tracksHeight * m_document->tracksCount() * matrix().m22());
5231     scene()->addItem(g);
5232     m_guides.append(g);
5233     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
5234     m_document->syncGuides(m_guides);
5235     return true;
5236 }
5237
5238 void CustomTrackView::slotAddGuide(bool dialog)
5239 {
5240     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
5241     if (dialog) {
5242         MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
5243         if (d.exec() != QDialog::Accepted) return;
5244         marker = d.newMarker();
5245
5246     } else {
5247         marker.setComment(m_document->timecode().getDisplayTimecodeFromFrames(m_cursorPos, false));
5248     }
5249     if (addGuide(marker.time(), marker.comment())) {
5250         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), marker.time(), marker.comment(), false);
5251         m_commandStack->push(command);
5252     }
5253 }
5254
5255 void CustomTrackView::slotEditGuide(int guidePos)
5256 {
5257     GenTime pos;
5258     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
5259     else pos = GenTime(guidePos, m_document->fps());
5260     bool found = false;
5261     for (int i = 0; i < m_guides.count(); i++) {
5262         if (m_guides.at(i)->position() == pos) {
5263             slotEditGuide(m_guides.at(i)->info());
5264             found = true;
5265             break;
5266         }
5267     }
5268     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
5269 }
5270
5271 void CustomTrackView::slotEditGuide(CommentedTime guide)
5272 {
5273     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
5274     if (d.exec() == QDialog::Accepted) {
5275         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
5276         m_commandStack->push(command);
5277     }
5278 }
5279
5280
5281 void CustomTrackView::slotEditTimeLineGuide()
5282 {
5283     if (m_dragGuide == NULL) return;
5284     CommentedTime guide = m_dragGuide->info();
5285     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
5286     if (d.exec() == QDialog::Accepted) {
5287         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
5288         m_commandStack->push(command);
5289     }
5290 }
5291
5292 void CustomTrackView::slotDeleteGuide(int guidePos)
5293 {
5294     GenTime pos;
5295     if (guidePos == -1) pos = GenTime(m_cursorPos, m_document->fps());
5296     else pos = GenTime(guidePos, m_document->fps());
5297     bool found = false;
5298     for (int i = 0; i < m_guides.count(); i++) {
5299         if (m_guides.at(i)->position() == pos) {
5300             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
5301             m_commandStack->push(command);
5302             found = true;
5303             break;
5304         }
5305     }
5306     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
5307 }
5308
5309
5310 void CustomTrackView::slotDeleteTimeLineGuide()
5311 {
5312     if (m_dragGuide == NULL) return;
5313     EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(), QString(), true);
5314     m_commandStack->push(command);
5315 }
5316
5317
5318 void CustomTrackView::slotDeleteAllGuides()
5319 {
5320     QUndoCommand *deleteAll = new QUndoCommand();
5321     deleteAll->setText("Delete all guides");
5322     for (int i = 0; i < m_guides.count(); i++) {
5323         new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
5324     }
5325     m_commandStack->push(deleteAll);
5326 }
5327
5328 void CustomTrackView::setTool(PROJECTTOOL tool)
5329 {
5330     m_tool = tool;
5331 }
5332
5333 void CustomTrackView::setScale(double scaleFactor, double verticalScale)
5334 {
5335     QMatrix newmatrix;
5336     newmatrix = newmatrix.scale(scaleFactor, verticalScale);
5337     m_scene->setScale(scaleFactor, verticalScale);
5338     removeTipAnimation();
5339     bool adjust = false;
5340     if (verticalScale != matrix().m22()) adjust = true;
5341     setMatrix(newmatrix);
5342     if (adjust) {
5343         double newHeight = m_tracksHeight * m_document->tracksCount() * matrix().m22();
5344         m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), newHeight - 1);
5345         for (int i = 0; i < m_guides.count(); i++) {
5346             QLineF l = m_guides.at(i)->line();
5347             l.setP2(QPointF(l.x2(), newHeight));
5348             m_guides.at(i)->setLine(l);
5349         }
5350         setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_document->tracksCount());
5351     }
5352
5353     int diff = sceneRect().width() - m_projectDuration;
5354     if (diff * newmatrix.m11() < 50) {
5355         if (newmatrix.m11() < 0.4)
5356             setSceneRect(0, 0, (m_projectDuration + 100 / newmatrix.m11()), sceneRect().height());
5357         else
5358             setSceneRect(0, 0, (m_projectDuration + 300), sceneRect().height());
5359     }
5360     double verticalPos = mapToScene(QPoint(0, viewport()->height() / 2)).y();
5361     centerOn(QPointF(cursorPos(), verticalPos));
5362 }
5363
5364 void CustomTrackView::slotRefreshGuides()
5365 {
5366     if (KdenliveSettings::showmarkers()) {
5367         for (int i = 0; i < m_guides.count(); i++)
5368             m_guides.at(i)->update();
5369     }
5370 }
5371
5372 void CustomTrackView::drawBackground(QPainter * painter, const QRectF &rect)
5373 {
5374     painter->setClipRect(rect);
5375     QPen pen1 = painter->pen();
5376     pen1.setColor(palette().dark().color());
5377     painter->setPen(pen1);
5378     double min = rect.left();
5379     double max = rect.right();
5380     painter->drawLine(QPointF(min, 0), QPointF(max, 0));
5381     int maxTrack = m_document->tracksCount();
5382     QColor lockedColor = palette().button().color();
5383     QColor audioColor = palette().alternateBase().color();
5384     for (int i = 0; i < maxTrack; i++) {
5385         TrackInfo info = m_document->trackInfoAt(maxTrack - i - 1);
5386         if (info.isLocked || info.type == AUDIOTRACK || i == m_selectedTrack) {
5387             const QRectF track(min, m_tracksHeight * i + 1, max - min, m_tracksHeight - 1);
5388             if (i == m_selectedTrack)
5389                 painter->fillRect(track, m_activeTrackBrush.brush(this));
5390             else
5391                 painter->fillRect(track, info.isLocked ? lockedColor : audioColor);
5392         }
5393         painter->drawLine(QPointF(min, m_tracksHeight *(i + 1)), QPointF(max, m_tracksHeight *(i + 1)));
5394     }
5395 }
5396
5397 bool CustomTrackView::findString(const QString &text)
5398 {
5399     QString marker;
5400     for (int i = 0; i < m_searchPoints.size(); ++i) {
5401         marker = m_searchPoints.at(i).comment();
5402         if (marker.contains(text, Qt::CaseInsensitive)) {
5403             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
5404             int vert = verticalScrollBar()->value();
5405             int hor = cursorPos();
5406             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
5407             m_findIndex = i;
5408             return true;
5409         }
5410     }
5411     return false;
5412 }
5413
5414 void CustomTrackView::selectFound(QString track, QString pos)
5415 {
5416     setCursorPos(m_document->timecode().getFrameCount(pos), true);
5417     slotSelectTrack(track.toInt());
5418     selectClip(true);
5419     int vert = verticalScrollBar()->value();
5420     int hor = cursorPos();
5421     ensureVisible(hor, vert + 10, 2, 2, 50, 0);
5422 }
5423
5424 bool CustomTrackView::findNextString(const QString &text)
5425 {
5426     QString marker;
5427     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
5428         marker = m_searchPoints.at(i).comment();
5429         if (marker.contains(text, Qt::CaseInsensitive)) {
5430             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
5431             int vert = verticalScrollBar()->value();
5432             int hor = cursorPos();
5433             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
5434             m_findIndex = i;
5435             return true;
5436         }
5437     }
5438     m_findIndex = -1;
5439     return false;
5440 }
5441
5442 void CustomTrackView::initSearchStrings()
5443 {
5444     m_searchPoints.clear();
5445     QList<QGraphicsItem *> itemList = items();
5446     for (int i = 0; i < itemList.count(); i++) {
5447         // parse all clip names
5448         if (itemList.at(i)->type() == AVWIDGET) {
5449             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
5450             GenTime start = item->startPos();
5451             CommentedTime t(start, item->clipName());
5452             m_searchPoints.append(t);
5453             // add all clip markers
5454             QList < CommentedTime > markers = item->commentedSnapMarkers();
5455             m_searchPoints += markers;
5456         }
5457     }
5458
5459     // add guides
5460     for (int i = 0; i < m_guides.count(); i++)
5461         m_searchPoints.append(m_guides.at(i)->info());
5462
5463     qSort(m_searchPoints);
5464 }
5465
5466 void CustomTrackView::clearSearchStrings()
5467 {
5468     m_searchPoints.clear();
5469     m_findIndex = 0;
5470 }
5471
5472 QList<ItemInfo> CustomTrackView::findId(const QString &clipId)
5473 {
5474     QList<ItemInfo> matchingInfo;
5475     QList<QGraphicsItem *> itemList = items();
5476     for (int i = 0; i < itemList.count(); i++) {
5477         if (itemList.at(i)->type() == AVWIDGET) {
5478             ClipItem *item = (ClipItem *)itemList.at(i);
5479             if (item->clipProducer() == clipId)
5480                 matchingInfo << item->info();
5481         }
5482     }
5483     return matchingInfo;
5484 }
5485
5486 void CustomTrackView::copyClip()
5487 {
5488     qDeleteAll(m_copiedItems);
5489     m_copiedItems.clear();
5490     QList<QGraphicsItem *> itemList = scene()->selectedItems();
5491     if (itemList.count() == 0) {
5492         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
5493         return;
5494     }
5495     for (int i = 0; i < itemList.count(); i++) {
5496         if (itemList.at(i)->type() == AVWIDGET) {
5497             ClipItem *clip = static_cast <ClipItem *>(itemList.at(i));
5498             ClipItem *clone = clip->clone(clip->info());
5499             m_copiedItems.append(clone);
5500         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
5501             Transition *dup = static_cast <Transition *>(itemList.at(i));
5502             m_copiedItems.append(dup->clone());
5503         }
5504     }
5505 }
5506
5507 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const
5508 {
5509     if (m_scene->editMode() != NORMALEDIT) {
5510         // If we are in overwrite mode, always allow the move
5511         return true;
5512     }
5513     int height = m_tracksHeight - 2;
5514     int offset = 0;
5515     if (type == TRANSITIONWIDGET) {
5516         height = Transition::itemHeight();
5517         offset = Transition::itemOffset();
5518     }
5519     else if (type == AVWIDGET) {
5520         height = ClipItem::itemHeight();
5521         offset = ClipItem::itemOffset();
5522     }
5523     QRectF rect((double) info.startPos.frames(m_document->fps()), (double)(info.track * m_tracksHeight + 1 + offset), (double)(info.endPos - info.startPos).frames(m_document->fps()), (double) height);
5524     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
5525     for (int i = 0; i < collisions.count(); i++) {
5526         if (collisions.at(i)->type() == type) {
5527             return false;
5528         }
5529     }
5530     return true;
5531 }
5532
5533 bool CustomTrackView::canBePastedTo(QList <ItemInfo> infoList, int type) const
5534 {
5535     QPainterPath path;
5536     for (int i = 0; i < infoList.count(); i++) {
5537         const QRectF rect((double) infoList.at(i).startPos.frames(m_document->fps()), (double)(infoList.at(i).track * m_tracksHeight + 1), (double)(infoList.at(i).endPos - infoList.at(i).startPos).frames(m_document->fps()), (double)(m_tracksHeight - 1));
5538         path.addRect(rect);
5539     }
5540     QList<QGraphicsItem *> collisions = scene()->items(path);
5541     for (int i = 0; i < collisions.count(); i++) {
5542         if (collisions.at(i)->type() == type) return false;
5543     }
5544     return true;
5545 }
5546
5547 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
5548 {
5549     for (int i = 0; i < items.count(); i++) {
5550         ItemInfo info = items.at(i)->info();
5551         info.startPos += offset;
5552         info.endPos += offset;
5553         info.track += trackOffset;
5554         if (!canBePastedTo(info, items.at(i)->type())) return false;
5555     }
5556     return true;
5557 }
5558
5559 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const
5560 {
5561     QPainterPath movePath;
5562     movePath.moveTo(0, 0);
5563
5564     for (int i = 0; i < items.count(); i++) {
5565         ItemInfo info = items.at(i)->info();
5566         info.startPos = info.startPos + offset;
5567         info.endPos = info.endPos + offset;
5568         info.track = info.track + trackOffset;
5569         if (info.startPos < GenTime()) {
5570             // No clip should go below 0
5571             return false;
5572         }
5573         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));
5574         movePath.addRect(rect);
5575     }
5576     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
5577     for (int i = 0; i < collisions.count(); i++) {
5578         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
5579             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
5580             return false;
5581         }
5582     }
5583     return true;
5584 }
5585
5586
5587 void CustomTrackView::pasteClip()
5588 {
5589     if (m_copiedItems.count() == 0) {
5590         emit displayMessage(i18n("No clip copied"), ErrorMessage);
5591         return;
5592     }
5593     QPoint position;
5594     int track = -1;
5595     GenTime pos = GenTime(-1);
5596     if (m_menuPosition.isNull()) {
5597         position = mapFromGlobal(QCursor::pos());
5598         if (!contentsRect().contains(position) || mapToScene(position).y() / m_tracksHeight > m_document->tracksCount()) {
5599             track = m_selectedTrack;
5600             pos = GenTime(m_cursorPos, m_document->fps());
5601             /*emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
5602             return;*/
5603         }
5604     } else {
5605         position = m_menuPosition;
5606     }
5607
5608     if (pos == GenTime(-1))
5609         pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
5610     if (track == -1)
5611         track = (int)(mapToScene(position).y() / m_tracksHeight);
5612
5613     GenTime leftPos = m_copiedItems.at(0)->startPos();
5614     int lowerTrack = m_copiedItems.at(0)->track();
5615     int upperTrack = m_copiedItems.at(0)->track();
5616     for (int i = 1; i < m_copiedItems.count(); i++) {
5617         if (m_copiedItems.at(i)->startPos() < leftPos) leftPos = m_copiedItems.at(i)->startPos();
5618         if (m_copiedItems.at(i)->track() < lowerTrack) lowerTrack = m_copiedItems.at(i)->track();
5619         if (m_copiedItems.at(i)->track() > upperTrack) upperTrack = m_copiedItems.at(i)->track();
5620     }
5621
5622     GenTime offset = pos - leftPos;
5623     int trackOffset = track - lowerTrack;
5624
5625     if (lowerTrack + trackOffset < 0) trackOffset = 0 - lowerTrack;
5626     if (upperTrack + trackOffset > m_document->tracksCount() - 1) trackOffset = m_document->tracksCount() - upperTrack - 1;
5627     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
5628         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
5629         return;
5630     }
5631     QUndoCommand *pasteClips = new QUndoCommand();
5632     pasteClips->setText("Paste clips");
5633
5634     for (int i = 0; i < m_copiedItems.count(); i++) {
5635         // parse all clip names
5636         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
5637             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
5638             ItemInfo info = clip->info();
5639             info.startPos += offset;
5640             info.endPos += offset;
5641             info.track += trackOffset;
5642             if (canBePastedTo(info, AVWIDGET)) {
5643                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), m_scene->editMode() == OVERWRITEEDIT, m_scene->editMode() == INSERTEDIT, true, false, pasteClips);
5644             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
5645         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
5646             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
5647             ItemInfo info;
5648             info.startPos = tr->startPos() + offset;
5649             info.endPos = tr->endPos() + offset;
5650             info.track = tr->track() + trackOffset;
5651             int transitionEndTrack;
5652             if (!tr->forcedTrack()) transitionEndTrack = getPreviousVideoTrack(info.track);
5653             else transitionEndTrack = tr->transitionEndTrack();
5654             if (canBePastedTo(info, TRANSITIONWIDGET)) {
5655                 if (info.startPos >= info.endPos) {
5656                     emit displayMessage(i18n("Invalid transition"), ErrorMessage);
5657                 } else new AddTransitionCommand(this, info, transitionEndTrack, tr->toXML(), false, true, pasteClips);
5658             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
5659         }
5660     }
5661     updateTrackDuration(-1, pasteClips);
5662     m_commandStack->push(pasteClips);
5663 }
5664
5665 void CustomTrackView::pasteClipEffects()
5666 {
5667     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
5668         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
5669         return;
5670     }
5671     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
5672
5673     QUndoCommand *paste = new QUndoCommand();
5674     paste->setText("Paste effects");
5675
5676     QList<QGraphicsItem *> clips = scene()->selectedItems();
5677
5678     // expand groups
5679     for (int i = 0; i < clips.count(); ++i) {
5680         if (clips.at(i)->type() == GROUPWIDGET) {
5681             QList<QGraphicsItem *> children = clips.at(i)->childItems();
5682             for (int j = 0; j < children.count(); j++) {
5683                 if (children.at(j)->type() == AVWIDGET && !clips.contains(children.at(j))) {
5684                     clips.append(children.at(j));
5685                 }
5686             }
5687         }
5688     }
5689
5690     for (int i = 0; i < clips.count(); ++i) {
5691         if (clips.at(i)->type() == AVWIDGET) {
5692             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
5693             for (int j = 0; j < clip->effectsCount(); j++) {
5694                 QDomElement eff = clip->effect(j);
5695                 if (eff.attribute("unique", "0") == "0" || item->hasEffect(eff.attribute("tag"), eff.attribute("id")) == -1) {
5696                     adjustKeyfames(clip->cropStart(), item->cropStart(), item->cropDuration(), eff);
5697                     new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), eff, true, paste);
5698                 }
5699             }
5700         }
5701     }
5702     if (paste->childCount() > 0) m_commandStack->push(paste);
5703     else delete paste;
5704
5705     //adjust effects (fades, ...)
5706     for (int i = 0; i < clips.count(); ++i) {
5707         if (clips.at(i)->type() == AVWIDGET) {
5708             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
5709             updatePositionEffects(item, item->info());
5710         }
5711     }
5712 }
5713
5714
5715 void CustomTrackView::adjustKeyfames(GenTime oldstart, GenTime newstart, GenTime duration, QDomElement xml)
5716 {
5717     // parse parameters to check if we need to adjust to the new crop start
5718     int diff = (newstart - oldstart).frames(m_document->fps());
5719     int max = (newstart + duration).frames(m_document->fps());
5720     QLocale locale;
5721     QDomNodeList params = xml.elementsByTagName("parameter");
5722     for (int i = 0; i < params.count(); i++) {
5723         QDomElement e = params.item(i).toElement();
5724         if (!e.isNull() && (e.attribute("type") == "keyframe" || e.attribute("type") == "simplekeyframe")) {
5725             QString def = e.attribute("default");
5726             // Effect has a keyframe type parameter, we need to adjust the values
5727             QStringList keys = e.attribute("keyframes").split(";", QString::SkipEmptyParts);
5728             QStringList newKeyFrames;
5729             foreach(const QString &str, keys) {
5730                 int pos = str.section(':', 0, 0).toInt();
5731                 double val = str.section(':', 1, 1).toDouble();
5732                 pos += diff;
5733                 if (pos > max) {
5734                     newKeyFrames.append(QString::number(max) + ':' + locale.toString(val));
5735                     break;
5736                 } else newKeyFrames.append(QString::number(pos) + ':' + locale.toString(val));
5737             }
5738             //kDebug()<<"ORIGIN: "<<keys<<", FIXED: "<<newKeyFrames;
5739             e.setAttribute("keyframes", newKeyFrames.join(";"));
5740         }
5741     }
5742 }
5743
5744 ClipItem *CustomTrackView::getClipUnderCursor() const
5745 {
5746     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
5747     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
5748     for (int i = 0; i < collisions.count(); i++) {
5749         if (collisions.at(i)->type() == AVWIDGET) {
5750             return static_cast < ClipItem *>(collisions.at(i));
5751         }
5752     }
5753     return NULL;
5754 }
5755
5756 AbstractClipItem *CustomTrackView::getMainActiveClip() const
5757 {
5758     QList<QGraphicsItem *> clips = scene()->selectedItems();
5759     if (clips.isEmpty()) {
5760         return getClipUnderCursor();
5761     } else {
5762         AbstractClipItem *item = NULL;
5763         for (int i = 0; i < clips.count(); ++i) {
5764             if (clips.at(i)->type() == AVWIDGET) {
5765                 item = static_cast < AbstractClipItem *>(clips.at(i));
5766                 if (clips.count() > 1 && item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
5767             }
5768         }
5769         if (item) return item;
5770     }
5771     return NULL;
5772 }
5773
5774 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const
5775 {
5776     QList<QGraphicsItem *> clips = scene()->selectedItems();
5777     if (clips.isEmpty()) {
5778         return getClipUnderCursor();
5779     } else {
5780         ClipItem *item;
5781         // remove all items in the list that are not clips
5782         for (int i = 0; i < clips.count();) {
5783             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
5784             else i++;
5785         }
5786         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
5787         for (int i = 0; i < clips.count(); ++i) {
5788             if (clips.at(i)->type() == AVWIDGET) {
5789                 item = static_cast < ClipItem *>(clips.at(i));
5790                 if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos)
5791                     return item;
5792             }
5793         }
5794     }
5795     return NULL;
5796 }
5797
5798 void CustomTrackView::setInPoint()
5799 {
5800     AbstractClipItem *clip = getActiveClipUnderCursor(true);
5801     if (clip == NULL) {
5802         if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
5803             clip = m_dragItem;
5804         } else {
5805             emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
5806             return;
5807         }
5808     }
5809     prepareResizeClipStart(clip, clip->info(), m_cursorPos, true);
5810 }
5811
5812 void CustomTrackView::setOutPoint()
5813 {
5814     AbstractClipItem *clip = getActiveClipUnderCursor(true);
5815     if (clip == NULL) {
5816         if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
5817             clip = m_dragItem;
5818         } else {
5819             emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
5820             return;
5821         }
5822     }
5823     prepareResizeClipEnd(clip, clip->info(), m_cursorPos, true);
5824 }
5825
5826 void CustomTrackView::slotUpdateAllThumbs()
5827 {
5828     if (!isEnabled()) return;
5829     QList<QGraphicsItem *> itemList = items();
5830     //if (itemList.isEmpty()) return;
5831     ClipItem *item;
5832     const QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
5833     for (int i = 0; i < itemList.count(); i++) {
5834         if (itemList.at(i)->type() == AVWIDGET) {
5835             item = static_cast <ClipItem *>(itemList.at(i));
5836             if (item && item->isEnabled() && item->clipType() != COLOR && item->clipType() != AUDIO) {
5837                 // Check if we have a cached thumbnail
5838                 if (item->clipType() == IMAGE || item->clipType() == TEXT) {
5839                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
5840                     if (QFile::exists(thumb)) {
5841                         QPixmap pix(thumb);
5842                         if (pix.isNull()) KIO::NetAccess::del(KUrl(thumb), this);
5843                         item->slotSetStartThumb(pix);
5844                     }
5845                 } else {
5846                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
5847                     QString endThumb = startThumb;
5848                     startThumb.append(QString::number((int) item->speedIndependantCropStart().frames(m_document->fps())) + ".png");
5849                     endThumb.append(QString::number((int) (item->speedIndependantCropStart() + item->speedIndependantCropDuration()).frames(m_document->fps()) - 1) + ".png");
5850                     if (QFile::exists(startThumb)) {
5851                         QPixmap pix(startThumb);
5852                         if (pix.isNull()) KIO::NetAccess::del(KUrl(startThumb), this);
5853                         item->slotSetStartThumb(pix);
5854                     }
5855                     if (QFile::exists(endThumb)) {
5856                         QPixmap pix(endThumb);
5857                         if (pix.isNull()) KIO::NetAccess::del(KUrl(endThumb), this);
5858                         item->slotSetEndThumb(pix);
5859                     }
5860                 }
5861                 item->refreshClip(false, false);
5862             }
5863         }
5864     }
5865     viewport()->update();
5866 }
5867
5868 void CustomTrackView::saveThumbnails()
5869 {
5870     QList<QGraphicsItem *> itemList = items();
5871     ClipItem *item;
5872     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
5873     for (int i = 0; i < itemList.count(); i++) {
5874         if (itemList.at(i)->type() == AVWIDGET) {
5875             item = static_cast <ClipItem *>(itemList.at(i));
5876             if (item->clipType() != COLOR) {
5877                 // Check if we have a cached thumbnail
5878                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
5879                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
5880                     if (!QFile::exists(thumb)) {
5881                         QPixmap pix(item->startThumb());
5882                         pix.save(thumb);
5883                     }
5884                 } else {
5885                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
5886                     QString endThumb = startThumb;
5887                     startThumb.append(QString::number((int) item->speedIndependantCropStart().frames(m_document->fps())) + ".png");
5888                     endThumb.append(QString::number((int) (item->speedIndependantCropStart() + item->speedIndependantCropDuration()).frames(m_document->fps()) - 1) + ".png");
5889                     if (!QFile::exists(startThumb)) {
5890                         QPixmap pix(item->startThumb());
5891                         pix.save(startThumb);
5892                     }
5893                     if (!QFile::exists(endThumb)) {
5894                         QPixmap pix(item->endThumb());
5895                         pix.save(endThumb);
5896                     }
5897                 }
5898             }
5899         }
5900     }
5901 }
5902
5903
5904 void CustomTrackView::slotInsertTrack(int ix)
5905 {
5906     TrackDialog d(m_document, parentWidget());
5907     d.comboTracks->setCurrentIndex(ix);
5908     d.label->setText(i18n("Insert track"));
5909     d.setWindowTitle(i18n("Insert New Track"));
5910
5911     if (d.exec() == QDialog::Accepted) {
5912         ix = d.comboTracks->currentIndex();
5913         if (d.before_select->currentIndex() == 1)
5914             ix++;
5915         TrackInfo info;
5916         info.duration = 0;
5917         info.isMute = false;
5918         info.isLocked = false;
5919         info.effectsList = EffectsList(true);
5920         if (d.video_track->isChecked()) {
5921             info.type = VIDEOTRACK;
5922             info.isBlind = false;
5923         } else {
5924             info.type = AUDIOTRACK;
5925             info.isBlind = true;
5926         }
5927         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true);
5928         m_commandStack->push(addTrack);
5929         setDocumentModified();
5930     }
5931 }
5932
5933 void CustomTrackView::slotDeleteTrack(int ix)
5934 {
5935     if (m_document->tracksCount() < 2) return;
5936     TrackDialog d(m_document, parentWidget());
5937     d.comboTracks->setCurrentIndex(ix);
5938     d.label->setText(i18n("Delete track"));
5939     d.before_select->setHidden(true);
5940     d.setWindowTitle(i18n("Delete Track"));
5941     d.video_track->setHidden(true);
5942     d.audio_track->setHidden(true);
5943     if (d.exec() == QDialog::Accepted) {
5944         ix = d.comboTracks->currentIndex();
5945         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
5946         deleteTimelineTrack(ix, info);
5947         setDocumentModified();
5948         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false);
5949         m_commandStack->push(command);*/
5950     }
5951 }
5952
5953 void CustomTrackView::slotConfigTracks(int ix)
5954 {
5955     TracksConfigDialog d(m_document, ix, parentWidget());
5956     if (d.exec() == QDialog::Accepted) {
5957         ConfigTracksCommand *configTracks = new ConfigTracksCommand(this, m_document->tracksList(), d.tracksList());
5958         m_commandStack->push(configTracks);
5959         QList <int> toDelete = d.deletedTracks();
5960         for (int i = 0; i < toDelete.count(); ++i) {
5961             TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - toDelete.at(i) + i - 1);
5962             deleteTimelineTrack(toDelete.at(i) - i, info);
5963         }
5964         setDocumentModified();
5965     }
5966 }
5967
5968 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo)
5969 {
5970     if (m_document->tracksCount() < 2) return;
5971     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
5972     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
5973     QList<QGraphicsItem *> selection = m_scene->items(r);
5974     QUndoCommand *deleteTrack = new QUndoCommand();
5975     deleteTrack->setText("Delete track");
5976
5977     // Delete all clips in selected track
5978     for (int i = 0; i < selection.count(); i++) {
5979         if (selection.at(i)->type() == AVWIDGET) {
5980             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
5981             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false, false, true, deleteTrack);
5982             m_waitingThumbs.removeAll(item);
5983             m_scene->removeItem(item);
5984             delete item;
5985             item = NULL;
5986         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
5987             Transition *item =  static_cast <Transition *>(selection.at(i));
5988             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
5989             m_scene->removeItem(item);
5990             delete item;
5991             item = NULL;
5992         }
5993     }
5994
5995     new AddTrackCommand(this, ix, trackinfo, false, deleteTrack);
5996     m_commandStack->push(deleteTrack);
5997 }
5998
5999 void CustomTrackView::autoTransition()
6000 {
6001     QList<QGraphicsItem *> itemList = scene()->selectedItems();
6002     if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
6003         emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
6004         return;
6005     }
6006     Transition *tr = static_cast <Transition*>(itemList.at(0));
6007     tr->setAutomatic(!tr->isAutomatic());
6008     QDomElement transition = tr->toXML();
6009     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);
6010     setDocumentModified();
6011 }
6012
6013 void CustomTrackView::clipNameChanged(const QString &id, const QString &name)
6014 {
6015     QList<QGraphicsItem *> list = scene()->items();
6016     ClipItem *clip = NULL;
6017     for (int i = 0; i < list.size(); ++i) {
6018         if (list.at(i)->type() == AVWIDGET) {
6019             clip = static_cast <ClipItem *>(list.at(i));
6020             if (clip->clipProducer() == id) {
6021                 clip->setClipName(name);
6022             }
6023         }
6024     }
6025     viewport()->update();
6026 }
6027
6028 void CustomTrackView::getClipAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
6029 {
6030     minimum = GenTime();
6031     maximum = GenTime();
6032     QList<QGraphicsItem *> selection;
6033     selection = m_scene->items(0, item->track() * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
6034     selection.removeAll(item);
6035     for (int i = 0; i < selection.count(); i++) {
6036         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
6037         if (clip && clip->type() == AVWIDGET) {
6038             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
6039             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
6040         }
6041     }
6042 }
6043
6044 void CustomTrackView::getTransitionAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum)
6045 {
6046     minimum = GenTime();
6047     maximum = GenTime();
6048     QList<QGraphicsItem *> selection;
6049     selection = m_scene->items(0, (item->track() + 1) * m_tracksHeight, sceneRect().width(), 2);
6050     selection.removeAll(item);
6051     for (int i = 0; i < selection.count(); i++) {
6052         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
6053         if (clip && clip->type() == TRANSITIONWIDGET) {
6054             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
6055             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
6056         }
6057     }
6058 }
6059
6060 void CustomTrackView::loadGroups(const QDomNodeList &groups)
6061 {
6062     for (int i = 0; i < groups.count(); i++) {
6063         QDomNodeList children = groups.at(i).childNodes();
6064         scene()->clearSelection();
6065         for (int nodeindex = 0; nodeindex < children.count(); nodeindex++) {
6066             QDomElement elem = children.item(nodeindex).toElement();
6067             int pos = elem.attribute("position").toInt();
6068             int track = elem.attribute("track").toInt();
6069             if (elem.tagName() == "clipitem") {
6070                 ClipItem *clip = getClipItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
6071                 if (clip) clip->setSelected(true);
6072             } else {
6073                 Transition *clip = getTransitionItemAt(pos, track); //m_document->tracksCount() - transitiontrack);
6074                 if (clip) clip->setSelected(true);
6075             }
6076         }
6077         groupSelectedItems(false, true);
6078     }
6079 }
6080
6081 void CustomTrackView::splitAudio()
6082 {
6083     resetSelectionGroup();
6084     QList<QGraphicsItem *> selection = scene()->selectedItems();
6085     if (selection.isEmpty()) {
6086         emit displayMessage(i18n("You must select at least one clip for this action"), ErrorMessage);
6087         return;
6088     }
6089     QUndoCommand *splitCommand = new QUndoCommand();
6090     splitCommand->setText(i18n("Split audio"));
6091     for (int i = 0; i < selection.count(); i++) {
6092         if (selection.at(i)->type() == AVWIDGET) {
6093             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
6094             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
6095                 if (clip->parentItem()) {
6096                     emit displayMessage(i18n("Cannot split audio of grouped clips"), ErrorMessage);
6097                 } else {
6098                     EffectsList effects;
6099                     effects.clone(clip->effectList());
6100                     new SplitAudioCommand(this, clip->track(), clip->startPos(), effects, splitCommand);
6101                 }
6102             }
6103         }
6104     }
6105     if (splitCommand->childCount()) {
6106         updateTrackDuration(-1, splitCommand);
6107         m_commandStack->push(splitCommand);
6108     }
6109 }
6110
6111 void CustomTrackView::setAudioAlignReference()
6112 {
6113     QList<QGraphicsItem *> selection = scene()->selectedItems();
6114     if (selection.isEmpty() || selection.size() > 1) {
6115         emit displayMessage(i18n("You must select exactly one clip for the audio reference."), ErrorMessage);
6116         return;
6117     }
6118     if (m_audioCorrelator != NULL) {
6119         delete m_audioCorrelator;
6120     }
6121     if (selection.at(0)->type() == AVWIDGET) {
6122         ClipItem *clip = static_cast<ClipItem*>(selection.at(0));
6123         if (clip->clipType() == AV || clip->clipType() == AUDIO) {
6124             m_audioAlignmentReference = clip;
6125
6126             AudioEnvelope *envelope = new AudioEnvelope(clip->getProducer(clip->track()));
6127             m_audioCorrelator = new AudioCorrelation(envelope);
6128
6129
6130 #ifdef DEBUG
6131             envelope->drawEnvelope().save("kdenlive-audio-reference-envelope.png");
6132             envelope->dumpInfo();
6133 #endif
6134
6135
6136             emit displayMessage(i18n("Audio align reference set."), InformationMessage);
6137         }
6138         return;
6139     }
6140     emit displayMessage(i18n("Reference for audio alignment must contain audio data."), ErrorMessage);
6141 }
6142
6143 void CustomTrackView::alignAudio()
6144 {
6145     bool referenceOK = true;
6146     if (m_audioCorrelator == NULL) {
6147         referenceOK = false;
6148     }
6149     if (referenceOK) {
6150         if (!scene()->items().contains(m_audioAlignmentReference)) {
6151             // The reference item has been deleted from the timeline (or so)
6152             referenceOK = false;
6153         }
6154     }
6155     if (!referenceOK) {
6156         emit displayMessage(i18n("Audio alignment reference not yet set."), InformationMessage);
6157         return;
6158     }
6159
6160     int counter = 0;
6161     QList<QGraphicsItem *> selection = scene()->selectedItems();
6162     foreach (QGraphicsItem *item, selection) {
6163         if (item->type() == AVWIDGET) {
6164
6165             ClipItem *clip = static_cast<ClipItem*>(item);
6166             if (clip == m_audioAlignmentReference) {
6167                 continue;
6168             }
6169
6170             if (clip->clipType() == AV || clip->clipType() == AUDIO) {
6171                 AudioEnvelope *envelope = new AudioEnvelope(clip->getProducer(clip->track()),
6172                                                             clip->info().cropStart.frames(m_document->fps()),
6173                                                             clip->info().cropDuration.frames(m_document->fps()));
6174
6175                 // FFT only for larger vectors. We could use it all time, but for small vectors
6176                 // the (anyway not noticeable) overhead is smaller with a nested for loop correlation.
6177                 int index = m_audioCorrelator->addChild(envelope, envelope->envelopeSize() > 200);
6178                 int shift = m_audioCorrelator->getShift(index);
6179                 counter++;
6180
6181
6182 #ifdef DEBUG
6183                 m_audioCorrelator->info(index)->toImage().save("kdenlive-audio-align-cross-correlation.png");
6184                 envelope->drawEnvelope().save("kdenlive-audio-align-envelope.png");
6185                 envelope->dumpInfo();
6186
6187                 int targetPos = m_audioAlignmentReference->startPos().frames(m_document->fps()) + shift;
6188                 qDebug() << "Reference starts at " << m_audioAlignmentReference->startPos().frames(m_document->fps());
6189                 qDebug() << "We will start at " << targetPos;
6190                 qDebug() << "to shift by " << shift;
6191                 qDebug() << "(eventually)";
6192                 qDebug() << "(maybe)";
6193 #endif
6194
6195
6196                 QUndoCommand *moveCommand = new QUndoCommand();
6197
6198                 GenTime add(shift, m_document->fps());
6199                 ItemInfo start = clip->info();
6200
6201                 ItemInfo end = start;
6202                 end.startPos = m_audioAlignmentReference->startPos() + add - m_audioAlignmentReference->cropStart();
6203                 end.endPos = end.startPos + start.cropDuration;
6204
6205                 if ( end.startPos.seconds() < 0 ) {
6206                     // Clip would start before 0, so crop it first
6207                     GenTime cropBy = -end.startPos;
6208
6209 #ifdef DEBUG
6210                     qDebug() << "Need to crop clip. " << start;
6211                     qDebug() << "end.startPos: " << end.startPos.toString() << ", cropBy: " << cropBy.toString();
6212 #endif
6213
6214                     ItemInfo resized = start;
6215                     resized.startPos += cropBy;
6216
6217                     resizeClip(start, resized);
6218                     new ResizeClipCommand(this, start, resized, false, false, moveCommand);
6219
6220                     start = clip->info();
6221                     end.startPos += cropBy;
6222
6223 #ifdef DEBUG
6224                     qDebug() << "Clip cropped. " << start;
6225                     qDebug() << "Moving to: " << end;
6226 #endif
6227                 }
6228
6229                 if (itemCollision(clip, end)) {
6230                     delete moveCommand;
6231                     emit displayMessage(i18n("Unable to move clip due to collision."), ErrorMessage);
6232                     return;
6233                 }
6234
6235                 moveCommand->setText(i18n("Auto-align clip"));
6236                 new MoveClipCommand(this, start, end, true, moveCommand);
6237                 updateTrackDuration(clip->track(), moveCommand);
6238                 m_commandStack->push(moveCommand);
6239
6240             }
6241         }
6242     }
6243
6244     if (counter == 0) {
6245         emit displayMessage(i18n("No audio clips selected."), ErrorMessage);
6246     } else {
6247         emit displayMessage(i18n("Auto-aligned %1 clips.").arg(counter), InformationMessage);
6248     }
6249 }
6250
6251 void CustomTrackView::doSplitAudio(const GenTime &pos, int track, EffectsList effects, bool split)
6252 {
6253     ClipItem *clip = getClipItemAt(pos, track);
6254     if (clip == NULL) {
6255         kDebug() << "// Cannot find clip to split!!!";
6256         return;
6257     }
6258     if (split) {
6259         int start = pos.frames(m_document->fps());
6260         int freetrack = m_document->tracksCount() - track - 1;
6261
6262         // do not split audio when we are on an audio track
6263         if (m_document->trackInfoAt(freetrack).type == AUDIOTRACK)
6264             return;
6265
6266         for (; freetrack > 0; freetrack--) {
6267             //kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
6268             if (m_document->trackInfoAt(freetrack - 1).type == AUDIOTRACK && !m_document->trackInfoAt(freetrack - 1).isLocked) {
6269                 //kDebug() << "// CHK DOC TRK:" << freetrack << ", DUR:" << m_document->renderer()->mltTrackDuration(freetrack);
6270                 if (m_document->renderer()->mltTrackDuration(freetrack) < start || m_document->renderer()->mltGetSpaceLength(pos, freetrack, false) >= clip->cropDuration().frames(m_document->fps())) {
6271                     //kDebug() << "FOUND SPACE ON TRK: " << freetrack;
6272                     break;
6273                 }
6274             }
6275         }
6276         kDebug() << "GOT TRK: " << track;
6277         if (freetrack == 0) {
6278             emit displayMessage(i18n("No empty space to put clip audio"), ErrorMessage);
6279         } else {
6280             ItemInfo info = clip->info();
6281             info.track = m_document->tracksCount() - freetrack;
6282             addClip(clip->xml(), clip->clipProducer(), info, clip->effectList());
6283             scene()->clearSelection();
6284             clip->setSelected(true);
6285             ClipItem *audioClip = getClipItemAt(start, info.track);
6286             if (audioClip) {
6287                 Mlt::Tractor *tractor = m_document->renderer()->lockService();
6288                 clip->setVideoOnly(true);
6289                 if (m_document->renderer()->mltUpdateClipProducer(tractor, m_document->tracksCount() - track, start, clip->baseClip()->videoProducer()) == false) {
6290                     emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", start, track), ErrorMessage);
6291                 }
6292                 if (m_document->renderer()->mltUpdateClipProducer(tractor, m_document->tracksCount() - info.track, start, clip->baseClip()->audioProducer(info.track)) == false) {
6293                     emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", start, info.track), ErrorMessage);
6294                 }
6295                 m_document->renderer()->unlockService(tractor);
6296                 audioClip->setSelected(true);
6297                 audioClip->setAudioOnly(true);
6298
6299                 // keep video effects, move audio effects to audio clip
6300                 int videoIx = 0;
6301                 int audioIx = 0;
6302                 for (int i = 0; i < effects.count(); ++i) {
6303                     if (effects.at(i).attribute("type") == "audio") {
6304                         deleteEffect(m_document->tracksCount() - track, pos, clip->effect(videoIx));
6305                         audioIx++;
6306                     } else {
6307                         deleteEffect(freetrack, pos, audioClip->effect(audioIx));
6308                         videoIx++;
6309                     }
6310                 }
6311
6312                 groupSelectedItems(false, true);
6313             }
6314         }
6315     } else {
6316         // unsplit clip: remove audio part and change video part to normal clip
6317         if (clip->parentItem() == NULL || clip->parentItem()->type() != GROUPWIDGET) {
6318             kDebug() << "//CANNOT FIND CLP GRP";
6319             return;
6320         }
6321         AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(clip->parentItem());
6322         QList<QGraphicsItem *> children = grp->childItems();
6323         if (children.count() != 2) {
6324             kDebug() << "//SOMETHING IS WRONG WITH CLP GRP";
6325             return;
6326         }
6327         for (int i = 0; i < children.count(); i++) {
6328             if (children.at(i) != clip) {
6329                 ClipItem *clp = static_cast <ClipItem *>(children.at(i));
6330                 ItemInfo info = clip->info();
6331                 deleteClip(clp->info());
6332                 clip->setVideoOnly(false);
6333                 Mlt::Tractor *tractor = m_document->renderer()->lockService();
6334                 if (!m_document->renderer()->mltUpdateClipProducer(
6335                             tractor,
6336                             m_document->tracksCount() - info.track,
6337                             info.startPos.frames(m_document->fps()),
6338                             clip->baseClip()->getProducer(info.track))) {
6339
6340                     emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)",
6341                                              info.startPos.frames(m_document->fps()), info.track),
6342                                         ErrorMessage);
6343                 }
6344                 m_document->renderer()->unlockService(tractor);
6345
6346                 // re-add audio effects
6347                 for (int i = 0; i < effects.count(); ++i) {
6348                     if (effects.at(i).attribute("type") == "audio") {
6349                         addEffect(m_document->tracksCount() - track, pos, effects.at(i));
6350                     }
6351                 }
6352
6353                 break;
6354             }
6355         }
6356         clip->setFlag(QGraphicsItem::ItemIsMovable, true);
6357         m_document->clipManager()->removeGroup(grp);
6358         scene()->destroyItemGroup(grp);
6359     }
6360 }
6361
6362 void CustomTrackView::setVideoOnly()
6363 {
6364     resetSelectionGroup();
6365     QList<QGraphicsItem *> selection = scene()->selectedItems();
6366     if (selection.isEmpty()) {
6367         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
6368         return;
6369     }
6370     QUndoCommand *videoCommand = new QUndoCommand();
6371     videoCommand->setText(i18n("Video only"));
6372     for (int i = 0; i < selection.count(); i++) {
6373         if (selection.at(i)->type() == AVWIDGET) {
6374             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
6375             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
6376                 if (clip->parentItem()) {
6377                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
6378                 } else {
6379                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), true, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
6380                 }
6381             }
6382         }
6383     }
6384     m_commandStack->push(videoCommand);
6385 }
6386
6387 void CustomTrackView::setAudioOnly()
6388 {
6389     resetSelectionGroup();
6390     QList<QGraphicsItem *> selection = scene()->selectedItems();
6391     if (selection.isEmpty()) {
6392         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
6393         return;
6394     }
6395     QUndoCommand *videoCommand = new QUndoCommand();
6396     videoCommand->setText(i18n("Audio only"));
6397     for (int i = 0; i < selection.count(); i++) {
6398         if (selection.at(i)->type() == AVWIDGET) {
6399             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
6400             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
6401                 if (clip->parentItem()) {
6402                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
6403                 } else {
6404                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, true, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
6405                 }
6406             }
6407         }
6408     }
6409     m_commandStack->push(videoCommand);
6410 }
6411
6412 void CustomTrackView::setAudioAndVideo()
6413 {
6414     resetSelectionGroup();
6415     QList<QGraphicsItem *> selection = scene()->selectedItems();
6416     if (selection.isEmpty()) {
6417         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
6418         return;
6419     }
6420     QUndoCommand *videoCommand = new QUndoCommand();
6421     videoCommand->setText(i18n("Audio and Video"));
6422     for (int i = 0; i < selection.count(); i++) {
6423         if (selection.at(i)->type() == AVWIDGET) {
6424             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
6425             if (clip->clipType() == AV || clip->clipType() == PLAYLIST) {
6426                 if (clip->parentItem()) {
6427                     emit displayMessage(i18n("Cannot change grouped clips"), ErrorMessage);
6428                 } else {
6429                     new ChangeClipTypeCommand(this, clip->track(), clip->startPos(), false, false, clip->isVideoOnly(), clip->isAudioOnly(), videoCommand);
6430                 }
6431             }
6432         }
6433     }
6434     m_commandStack->push(videoCommand);
6435 }
6436
6437 void CustomTrackView::doChangeClipType(const GenTime &pos, int track, bool videoOnly, bool audioOnly)
6438 {
6439     ClipItem *clip = getClipItemAt(pos, track);
6440     if (clip == NULL) {
6441         kDebug() << "// Cannot find clip to split!!!";
6442         return;
6443     }
6444     Mlt::Tractor *tractor = m_document->renderer()->lockService();
6445     if (videoOnly) {
6446         int start = pos.frames(m_document->fps());
6447         clip->setVideoOnly(true);
6448         clip->setAudioOnly(false);
6449         if (m_document->renderer()->mltUpdateClipProducer(tractor, m_document->tracksCount() - track, start, clip->baseClip()->videoProducer()) == false) {
6450             emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", start, track), ErrorMessage);
6451         }
6452     } else if (audioOnly) {
6453         int start = pos.frames(m_document->fps());
6454         clip->setAudioOnly(true);
6455         clip->setVideoOnly(false);
6456         if (m_document->renderer()->mltUpdateClipProducer(tractor, m_document->tracksCount() - track, start, clip->baseClip()->audioProducer(track)) == false) {
6457             emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", start, track), ErrorMessage);
6458         }
6459     } else {
6460         int start = pos.frames(m_document->fps());
6461         clip->setAudioOnly(false);
6462         clip->setVideoOnly(false);
6463         if (m_document->renderer()->mltUpdateClipProducer(tractor, m_document->tracksCount() - track, start, clip->baseClip()->getProducer(track)) == false) {
6464             emit displayMessage(i18n("Cannot update clip (time: %1, track: %2)", start, track), ErrorMessage);
6465         }
6466     }
6467     m_document->renderer()->unlockService(tractor);
6468     clip->update();
6469     setDocumentModified();
6470 }
6471
6472 void CustomTrackView::updateClipTypeActions(ClipItem *clip)
6473 {
6474     if (clip == NULL || (clip->clipType() != AV && clip->clipType() != PLAYLIST)) {
6475         m_clipTypeGroup->setEnabled(false);
6476     } else {
6477         m_clipTypeGroup->setEnabled(true);
6478         QList <QAction *> actions = m_clipTypeGroup->actions();
6479         QString lookup;
6480         if (clip->isAudioOnly()) lookup = "clip_audio_only";
6481         else if (clip->isVideoOnly()) lookup = "clip_video_only";
6482         else  lookup = "clip_audio_and_video";
6483         for (int i = 0; i < actions.count(); i++) {
6484             if (actions.at(i)->data().toString() == lookup) {
6485                 actions.at(i)->setChecked(true);
6486                 break;
6487             }
6488         }
6489     }
6490 }
6491
6492 void CustomTrackView::slotGoToMarker(QAction *action)
6493 {
6494     int pos = action->data().toInt();
6495     setCursorPos(pos, true);
6496 }
6497
6498 void CustomTrackView::reloadTransitionLumas()
6499 {
6500     QString lumaNames;
6501     QString lumaFiles;
6502     QDomElement lumaTransition = MainWindow::transitions.getEffectByTag("luma", "luma");
6503     QDomNodeList params = lumaTransition.elementsByTagName("parameter");
6504     for (int i = 0; i < params.count(); i++) {
6505         QDomElement e = params.item(i).toElement();
6506         if (e.attribute("tag") == "resource") {
6507             lumaNames = e.attribute("paramlistdisplay");
6508             lumaFiles = e.attribute("paramlist");
6509             break;
6510         }
6511     }
6512
6513     QList<QGraphicsItem *> itemList = items();
6514     Transition *transitionitem;
6515     QDomElement transitionXml;
6516     for (int i = 0; i < itemList.count(); i++) {
6517         if (itemList.at(i)->type() == TRANSITIONWIDGET) {
6518             transitionitem = static_cast <Transition*>(itemList.at(i));
6519             transitionXml = transitionitem->toXML();
6520             if (transitionXml.attribute("id") == "luma" && transitionXml.attribute("tag") == "luma") {
6521                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
6522                 for (int i = 0; i < params.count(); i++) {
6523                     QDomElement e = params.item(i).toElement();
6524                     if (e.attribute("tag") == "resource") {
6525                         e.setAttribute("paramlistdisplay", lumaNames);
6526                         e.setAttribute("paramlist", lumaFiles);
6527                         break;
6528                     }
6529                 }
6530             }
6531             if (transitionXml.attribute("id") == "composite" && transitionXml.attribute("tag") == "composite") {
6532                 QDomNodeList params = transitionXml.elementsByTagName("parameter");
6533                 for (int i = 0; i < params.count(); i++) {
6534                     QDomElement e = params.item(i).toElement();
6535                     if (e.attribute("tag") == "luma") {
6536                         e.setAttribute("paramlistdisplay", lumaNames);
6537                         e.setAttribute("paramlist", lumaFiles);
6538                         break;
6539                     }
6540                 }
6541             }
6542         }
6543     }
6544     emit transitionItemSelected(NULL);
6545 }
6546
6547 double CustomTrackView::fps() const
6548 {
6549     return m_document->fps();
6550 }
6551
6552 void CustomTrackView::updateProjectFps()
6553 {
6554     // update all clips to the new fps
6555     resetSelectionGroup();
6556     scene()->clearSelection();
6557     m_dragItem = NULL;
6558     QList<QGraphicsItem *> itemList = items();
6559     for (int i = 0; i < itemList.count(); i++) {
6560         // remove all items and re-add them one by one
6561         if (itemList.at(i) != m_cursorLine && itemList.at(i)->parentItem() == NULL) m_scene->removeItem(itemList.at(i));
6562     }
6563     for (int i = 0; i < itemList.count(); i++) {
6564         if (itemList.at(i)->parentItem() == 0 && (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET)) {
6565             AbstractClipItem *clip = static_cast <AbstractClipItem *>(itemList.at(i));
6566             clip->updateFps(m_document->fps());
6567             m_scene->addItem(clip);
6568         } else if (itemList.at(i)->type() == GROUPWIDGET) {
6569             AbstractGroupItem *grp = static_cast <AbstractGroupItem *>(itemList.at(i));
6570             QList<QGraphicsItem *> children = grp->childItems();
6571             for (int j = 0; j < children.count(); j++) {
6572                 if (children.at(j)->type() == AVWIDGET || children.at(j)->type() == TRANSITIONWIDGET) {
6573                     AbstractClipItem *clip = static_cast <AbstractClipItem *>(children.at(j));
6574                     clip->setFlag(QGraphicsItem::ItemIsMovable, true);
6575                     clip->updateFps(m_document->fps());
6576                 }
6577             }
6578             m_document->clipManager()->removeGroup(grp);
6579             m_scene->addItem(grp);
6580             scene()->destroyItemGroup(grp);
6581             scene()->clearSelection();
6582             for (int j = 0; j < children.count(); j++) {
6583                 if (children.at(j)->type() == AVWIDGET || children.at(j)->type() == TRANSITIONWIDGET) {
6584                     //children.at(j)->setParentItem(0);
6585                     children.at(j)->setSelected(true);
6586                 }
6587             }
6588             groupSelectedItems(true, true);
6589         } else if (itemList.at(i)->type() == GUIDEITEM) {
6590             Guide *g = static_cast<Guide *>(itemList.at(i));
6591             g->updatePos();
6592             m_scene->addItem(g);
6593         }
6594     }
6595     viewport()->update();
6596 }
6597
6598 void CustomTrackView::slotTrackDown()
6599 {
6600     if (m_selectedTrack > m_document->tracksCount() - 2) m_selectedTrack = 0;
6601     else m_selectedTrack++;
6602     emit updateTrackHeaders();
6603     QRectF rect(mapToScene(QPoint(10, 0)).x(), m_selectedTrack * m_tracksHeight, 10, m_tracksHeight);
6604     ensureVisible(rect, 0, 0);
6605     viewport()->update();
6606 }
6607
6608 void CustomTrackView::slotTrackUp()
6609 {
6610     if (m_selectedTrack > 0) m_selectedTrack--;
6611     else m_selectedTrack = m_document->tracksCount() - 1;
6612     emit updateTrackHeaders();
6613     QRectF rect(mapToScene(QPoint(10, 0)).x(), m_selectedTrack * m_tracksHeight, 10, m_tracksHeight);
6614     ensureVisible(rect, 0, 0);
6615     viewport()->update();
6616 }
6617
6618 int CustomTrackView::selectedTrack() const
6619 {
6620     return m_selectedTrack;
6621 }
6622
6623 QStringList CustomTrackView::selectedClips() const
6624 {
6625     QStringList clipIds;
6626     QList<QGraphicsItem *> selection = m_scene->selectedItems();
6627     for (int i = 0; i < selection.count(); i++) {
6628         if (selection.at(i)->type() == AVWIDGET) {
6629             ClipItem *item = (ClipItem *)selection.at(i);
6630             clipIds << item->clipProducer();
6631         }
6632     }
6633     return clipIds;
6634 }
6635
6636 QList<ClipItem *> CustomTrackView::selectedClipItems() const
6637 {
6638     QList<ClipItem *> clips;
6639     QList<QGraphicsItem *> selection = m_scene->selectedItems();
6640     for (int i = 0; i < selection.count(); i++) {
6641         if (selection.at(i)->type() == AVWIDGET) {
6642             clips.append((ClipItem *)selection.at(i));
6643         }
6644     }
6645     return clips;
6646 }
6647
6648 void CustomTrackView::slotSelectTrack(int ix)
6649 {
6650     m_selectedTrack = qMax(0, ix);
6651     m_selectedTrack = qMin(ix, m_document->tracksCount() - 1);
6652     emit updateTrackHeaders();
6653     QRectF rect(mapToScene(QPoint(10, 0)).x(), m_selectedTrack * m_tracksHeight, 10, m_tracksHeight);
6654     ensureVisible(rect, 0, 0);
6655     viewport()->update();
6656 }
6657
6658 void CustomTrackView::slotSelectClipsInTrack()
6659 {
6660     QRectF rect(0, m_selectedTrack * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), m_tracksHeight / 2 - 1);
6661     QList<QGraphicsItem *> selection = m_scene->items(rect);
6662     m_scene->clearSelection();
6663     for (int i = 0; i < selection.count(); i++) {
6664         if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET || selection.at(i)->type() == GROUPWIDGET) {
6665             selection.at(i)->setSelected(true);
6666         }
6667     }
6668     resetSelectionGroup();
6669     groupSelectedItems();
6670 }
6671
6672 void CustomTrackView::slotSelectAllClips()
6673 {
6674     QList<QGraphicsItem *> selection = m_scene->items();
6675     m_scene->clearSelection();
6676     for (int i = 0; i < selection.count(); i++) {
6677         if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET  || selection.at(i)->type() == GROUPWIDGET) {
6678             selection.at(i)->setSelected(true);
6679         }
6680     }
6681     resetSelectionGroup();
6682     groupSelectedItems();
6683 }
6684
6685 void CustomTrackView::selectClip(bool add, bool group, int track, int pos)
6686 {
6687     QRectF rect;
6688     if (track != -1 && pos != -1)
6689         rect = QRectF(pos, track * m_tracksHeight + m_tracksHeight / 2, 1, 1);
6690     else
6691         rect = QRectF(m_cursorPos, m_selectedTrack * m_tracksHeight + m_tracksHeight / 2, 1, 1);
6692     QList<QGraphicsItem *> selection = m_scene->items(rect);
6693     resetSelectionGroup(group);
6694     if (!group) m_scene->clearSelection();
6695     for (int i = 0; i < selection.count(); i++) {
6696         if (selection.at(i)->type() == AVWIDGET) {
6697             selection.at(i)->setSelected(add);
6698             break;
6699         }
6700     }
6701     if (group) groupSelectedItems();
6702 }
6703
6704 void CustomTrackView::selectTransition(bool add, bool group)
6705 {
6706     QRectF rect(m_cursorPos, m_selectedTrack * m_tracksHeight + m_tracksHeight, 1, 1);
6707     QList<QGraphicsItem *> selection = m_scene->items(rect);
6708     resetSelectionGroup(group);
6709     if (!group) m_scene->clearSelection();
6710     for (int i = 0; i < selection.count(); i++) {
6711         if (selection.at(i)->type() == TRANSITIONWIDGET) {
6712             selection.at(i)->setSelected(add);
6713             break;
6714         }
6715     }
6716     if (group) groupSelectedItems();
6717 }
6718
6719 QStringList CustomTrackView::extractTransitionsLumas()
6720 {
6721     QStringList urls;
6722     QList<QGraphicsItem *> itemList = items();
6723     Transition *transitionitem;
6724     QDomElement transitionXml;
6725     for (int i = 0; i < itemList.count(); i++) {
6726         if (itemList.at(i)->type() == TRANSITIONWIDGET) {
6727             transitionitem = static_cast <Transition*>(itemList.at(i));
6728             transitionXml = transitionitem->toXML();
6729             // luma files in transitions can be in "resource" or "luma" property
6730             QString luma = EffectsList::parameter(transitionXml, "luma");
6731             if (luma.isEmpty()) luma = EffectsList::parameter(transitionXml, "resource");
6732             if (!luma.isEmpty()) urls << KUrl(luma).path();
6733         }
6734     }
6735     urls.removeDuplicates();
6736     return urls;
6737 }
6738
6739 void CustomTrackView::setEditMode(EDITMODE mode)
6740 {
6741     m_scene->setEditMode(mode);
6742 }
6743
6744 void CustomTrackView::checkTrackSequence(int track)
6745 {
6746     QList <int> times = m_document->renderer()->checkTrackSequence(m_document->tracksCount() - track);
6747     //track = m_document->tracksCount() -track;
6748     QRectF rect(0, track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
6749     QList<QGraphicsItem *> selection = m_scene->items(rect);
6750     QList <int> timelineList;
6751     timelineList.append(0);
6752     for (int i = 0; i < selection.count(); i++) {
6753         if (selection.at(i)->type() == AVWIDGET) {
6754             ClipItem *clip = static_cast <ClipItem *>(selection.at(i));
6755             int start = clip->startPos().frames(m_document->fps());
6756             int end = clip->endPos().frames(m_document->fps());
6757             if (!timelineList.contains(start)) timelineList.append(start);
6758             if (!timelineList.contains(end)) timelineList.append(end);
6759         }
6760     }
6761     qSort(timelineList);
6762     kDebug() << "// COMPARE:\n" << times << "\n" << timelineList << "\n-------------------";
6763     if (times != timelineList) KMessageBox::sorry(this, i18n("error"), i18n("TRACTOR"));
6764 }
6765
6766 void CustomTrackView::insertZoneOverwrite(QStringList data, int in)
6767 {
6768     if (data.isEmpty()) return;
6769     DocClipBase *clip = m_document->getBaseClip(data.at(0));
6770     ItemInfo info;
6771     info.startPos = GenTime(in, m_document->fps());
6772     info.cropStart = GenTime(data.at(1).toInt(), m_document->fps());
6773     info.endPos = info.startPos + GenTime(data.at(2).toInt(), m_document->fps()) - info.cropStart;
6774     info.cropDuration = info.endPos - info.startPos;
6775     info.track = m_selectedTrack;
6776     QUndoCommand *addCommand = new QUndoCommand();
6777     addCommand->setText(i18n("Insert clip"));
6778     adjustTimelineClips(OVERWRITEEDIT, NULL, info, addCommand);
6779     new AddTimelineClipCommand(this, clip->toXML(), clip->getId(), info, EffectsList(), true, false, true, false, addCommand);
6780     updateTrackDuration(info.track, addCommand);
6781     m_commandStack->push(addCommand);
6782
6783     selectClip(true, false, m_selectedTrack, in);
6784     // Automatic audio split
6785     if (KdenliveSettings::splitaudio())
6786         splitAudio();
6787 }
6788
6789 void CustomTrackView::clearSelection(bool emitInfo)
6790 {
6791     resetSelectionGroup();
6792     scene()->clearSelection();
6793     m_dragItem = NULL;
6794     if (emitInfo) emit clipItemSelected(NULL);
6795 }
6796
6797 void CustomTrackView::updatePalette()
6798 {
6799     m_activeTrackBrush = KStatefulBrush(KColorScheme::View, KColorScheme::ActiveBackground, KSharedConfig::openConfig(KdenliveSettings::colortheme()));
6800     if (m_cursorLine) {
6801         QPen pen1 = QPen();
6802         pen1.setWidth(1);
6803         pen1.setColor(palette().text().color());
6804         m_cursorLine->setPen(pen1);
6805     }
6806 }
6807
6808 void CustomTrackView::removeTipAnimation()
6809 {
6810     if (m_visualTip) {
6811         scene()->removeItem(m_visualTip);
6812         m_animationTimer->stop();
6813         delete m_animation;
6814         m_animation = NULL;
6815         delete m_visualTip;
6816         m_visualTip = NULL;
6817     }
6818 }
6819
6820 void CustomTrackView::setTipAnimation(AbstractClipItem *clip, OPERATIONTYPE mode, const double size)
6821 {
6822     if (m_visualTip == NULL) {
6823         QRectF rect = clip->sceneBoundingRect();
6824         m_animation = new QGraphicsItemAnimation;
6825         m_animation->setTimeLine(m_animationTimer);
6826         m_animation->setScaleAt(1, 1, 1);
6827         QPolygon polygon;
6828         switch (mode) {
6829         case FADEIN:
6830         case FADEOUT:
6831             m_visualTip = new QGraphicsEllipseItem(-size, -size, size * 2, size * 2);
6832             ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
6833             ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
6834             if (mode == FADEIN)
6835                 m_visualTip->setPos(rect.x() + ((ClipItem *) clip)->fadeIn(), rect.y());
6836             else
6837                 m_visualTip->setPos(rect.right() - ((ClipItem *) clip)->fadeOut(), rect.y());
6838
6839             m_animation->setScaleAt(.5, 2, 2);
6840             break;
6841         case RESIZESTART:
6842         case RESIZEEND:
6843             polygon << QPoint(0, - size * 2);
6844             if (mode == RESIZESTART)
6845                 polygon << QPoint(size * 2, 0);
6846             else
6847                 polygon << QPoint(- size * 2, 0);
6848             polygon << QPoint(0, size * 2);
6849             polygon << QPoint(0, - size * 2);
6850
6851             m_visualTip = new QGraphicsPolygonItem(polygon);
6852             ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
6853             ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
6854             if (mode == RESIZESTART)
6855                 m_visualTip->setPos(rect.x(), rect.y() + rect.height() / 2);
6856             else
6857                 m_visualTip->setPos(rect.right(), rect.y() + rect.height() / 2);
6858
6859             m_animation->setScaleAt(.5, 2, 1);
6860             break;
6861         case TRANSITIONSTART:
6862         case TRANSITIONEND:
6863             polygon << QPoint(0, - size * 2);
6864             if (mode == TRANSITIONSTART)
6865                 polygon << QPoint(size * 2, 0);
6866             else
6867                 polygon << QPoint(- size * 2, 0);
6868             polygon << QPoint(0, 0);
6869             polygon << QPoint(0, - size * 2);
6870
6871             m_visualTip = new QGraphicsPolygonItem(polygon);
6872             ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
6873             ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
6874             if (mode == TRANSITIONSTART)
6875                 m_visualTip->setPos(rect.x(), rect.bottom());
6876             else
6877                 m_visualTip->setPos(rect.right(), rect.bottom());
6878
6879             m_animation->setScaleAt(.5, 2, 2);
6880             break;
6881         default:
6882             delete m_animation;
6883             return;
6884         }
6885
6886         m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
6887         m_visualTip->setZValue(100);
6888         scene()->addItem(m_visualTip);
6889         m_animation->setItem(m_visualTip);
6890         m_animationTimer->start();
6891     }
6892 }
6893
6894 bool CustomTrackView::hasAudio(int track) const
6895 {
6896     QRectF rect(0, (double)(track * m_tracksHeight + 1), (double) sceneRect().width(), (double)(m_tracksHeight - 1));
6897     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
6898     QGraphicsItem *item;
6899     for (int i = 0; i < collisions.count(); i++) {
6900         item = collisions.at(i);
6901         if (!item->isEnabled()) continue;
6902         if (item->type() == AVWIDGET) {
6903             ClipItem *clip = static_cast <ClipItem *>(item);
6904             if (!clip->isVideoOnly() && (clip->clipType() == AUDIO || clip->clipType() == AV || clip->clipType() == PLAYLIST)) return true;
6905         }
6906     }
6907     return false;
6908 }
6909
6910 void CustomTrackView::slotAddTrackEffect(const QDomElement &effect, int ix)
6911 {
6912
6913     QUndoCommand *effectCommand = new QUndoCommand();
6914     QString effectName;
6915     if (effect.tagName() == "effectgroup") {
6916         effectName = effect.attribute("name");
6917     } else {
6918         QDomElement namenode = effect.firstChildElement("name");
6919         if (!namenode.isNull()) effectName = i18n(namenode.text().toUtf8().data());
6920         else effectName = i18n("effect");
6921     }
6922     effectCommand->setText(i18n("Add %1", effectName));
6923     if (effect.tagName() == "effectgroup") {
6924         QDomNodeList effectlist = effect.elementsByTagName("effect");
6925         for (int j = 0; j < effectlist.count(); j++) {
6926             QDomElement trackeffect = effectlist.at(j).toElement();
6927             if (trackeffect.attribute("unique", "0") != "0" && m_document->hasTrackEffect(m_document->tracksCount() - ix - 1, trackeffect.attribute("tag"), trackeffect.attribute("id")) != -1) {
6928                 emit displayMessage(i18n("Effect already present in track"), ErrorMessage);
6929                 continue;
6930             }
6931             new AddEffectCommand(this, m_document->tracksCount() - ix, GenTime(-1), trackeffect, true, effectCommand);
6932         }
6933     }
6934     else {
6935         if (effect.attribute("unique", "0") != "0" && m_document->hasTrackEffect(m_document->tracksCount() - ix - 1, effect.attribute("tag"), effect.attribute("id")) != -1) {
6936             emit displayMessage(i18n("Effect already present in track"), ErrorMessage);
6937             delete effectCommand;
6938             return;
6939         }
6940         new AddEffectCommand(this, m_document->tracksCount() - ix, GenTime(-1), effect, true, effectCommand);
6941     }
6942
6943     if (effectCommand->childCount() > 0) {
6944         m_commandStack->push(effectCommand);
6945         setDocumentModified();
6946     }
6947     else delete effectCommand;
6948 }
6949
6950
6951 EffectsParameterList CustomTrackView::getEffectArgs(const QDomElement &effect)
6952 {
6953     EffectsParameterList parameters;
6954     QLocale locale;
6955     parameters.addParam("tag", effect.attribute("tag"));
6956     //if (effect.hasAttribute("region")) parameters.addParam("region", effect.attribute("region"));
6957     parameters.addParam("kdenlive_ix", effect.attribute("kdenlive_ix"));
6958     parameters.addParam("kdenlive_info", effect.attribute("kdenlive_info"));
6959     parameters.addParam("id", effect.attribute("id"));
6960     if (effect.hasAttribute("src")) parameters.addParam("src", effect.attribute("src"));
6961     if (effect.hasAttribute("disable")) parameters.addParam("disable", effect.attribute("disable"));
6962     if (effect.hasAttribute("in")) parameters.addParam("in", effect.attribute("in"));
6963     if (effect.hasAttribute("out")) parameters.addParam("out", effect.attribute("out"));
6964     if (effect.attribute("id") == "region") {
6965         QDomNodeList subeffects = effect.elementsByTagName("effect");
6966         for (int i = 0; i < subeffects.count(); i++) {
6967             QDomElement subeffect = subeffects.at(i).toElement();
6968             int subeffectix = subeffect.attribute("region_ix").toInt();
6969             parameters.addParam(QString("filter%1").arg(subeffectix), subeffect.attribute("id"));
6970             parameters.addParam(QString("filter%1.tag").arg(subeffectix), subeffect.attribute("tag"));
6971             parameters.addParam(QString("filter%1.kdenlive_info").arg(subeffectix), subeffect.attribute("kdenlive_info"));
6972             QDomNodeList subparams = subeffect.elementsByTagName("parameter");
6973             adjustEffectParameters(parameters, subparams, QString("filter%1.").arg(subeffectix));
6974         }
6975     }
6976
6977     QDomNodeList params = effect.elementsByTagName("parameter");
6978     adjustEffectParameters(parameters, params);
6979
6980     return parameters;
6981 }
6982
6983
6984 void CustomTrackView::adjustEffectParameters(EffectsParameterList &parameters, QDomNodeList params, const QString &prefix)
6985 {
6986   QLocale locale;
6987   for (int i = 0; i < params.count(); i++) {
6988         QDomElement e = params.item(i).toElement();
6989         QString paramname = prefix + e.attribute("name");
6990         if (e.attribute("type") == "geometry" && !e.hasAttribute("fixed")) {
6991             // effects with geometry param need in / out synced with the clip, request it...
6992             parameters.addParam("_sync_in_out", "1");
6993         }
6994         if (e.attribute("type") == "simplekeyframe") {
6995             QStringList values = e.attribute("keyframes").split(";", QString::SkipEmptyParts);
6996             double factor = e.attribute("factor", "1").toDouble();
6997             double offset = e.attribute("offset", "0").toDouble();
6998             for (int j = 0; j < values.count(); j++) {
6999                 QString pos = values.at(j).section(':', 0, 0);
7000                 double val = (values.at(j).section(':', 1, 1).toDouble() - offset) / factor;
7001                 values[j] = pos + "=" + locale.toString(val);
7002             }
7003             // kDebug() << "/ / / /SENDING KEYFR:" << values;
7004             parameters.addParam(paramname, values.join(";"));
7005             /*parameters.addParam(e.attribute("name"), e.attribute("keyframes").replace(":", "="));
7006             parameters.addParam("max", e.attribute("max"));
7007             parameters.addParam("min", e.attribute("min"));
7008             parameters.addParam("factor", e.attribute("factor", "1"));*/
7009         } else if (e.attribute("type") == "keyframe") {
7010             kDebug() << "/ / / /SENDING KEYFR EFFECT TYPE";
7011             parameters.addParam("keyframes", e.attribute("keyframes"));
7012             parameters.addParam("max", e.attribute("max"));
7013             parameters.addParam("min", e.attribute("min"));
7014             parameters.addParam("factor", e.attribute("factor", "1"));
7015             parameters.addParam("offset", e.attribute("offset", "0"));
7016             parameters.addParam("starttag", e.attribute("starttag", "start"));
7017             parameters.addParam("endtag", e.attribute("endtag", "end"));
7018         } else if (e.attribute("namedesc").contains(';')) {
7019             QString format = e.attribute("format");
7020             QStringList separators = format.split("%d", QString::SkipEmptyParts);
7021             QStringList values = e.attribute("value").split(QRegExp("[,:;x]"));
7022             QString neu;
7023             QTextStream txtNeu(&neu);
7024             if (values.size() > 0)
7025                 txtNeu << (int)values[0].toDouble();
7026             for (int i = 0; i < separators.size() && i + 1 < values.size(); i++) {
7027                 txtNeu << separators[i];
7028                 txtNeu << (int)(values[i+1].toDouble());
7029             }
7030             parameters.addParam("start", neu);
7031         } else {
7032             if (e.attribute("factor", "1") != "1" || e.attribute("offset", "0") != "0") {
7033                 double fact;
7034                 if (e.attribute("factor").contains('%')) {
7035                     fact = ProfilesDialog::getStringEval(m_document->mltProfile(), e.attribute("factor"));
7036                 } else {
7037                     fact = e.attribute("factor", "1").toDouble();
7038                 }
7039                 double offset = e.attribute("offset", "0").toDouble();
7040                 parameters.addParam(paramname, locale.toString((e.attribute("value").toDouble() - offset) / fact));
7041             } else {
7042                 parameters.addParam(paramname, e.attribute("value"));
7043             }
7044         }
7045     }
7046 }
7047
7048
7049 void CustomTrackView::updateTrackNames(int track, bool added)
7050 {
7051     QList <TrackInfo> tracks = m_document->tracksList();
7052     int max = tracks.count();
7053     int docTrack = max - track - 1;
7054
7055     // count number of tracks of each type
7056     int videoTracks = 0;
7057     int audioTracks = 0;
7058     for (int i = max - 1; i >= 0; --i) {
7059         TrackInfo info = tracks.at(i);
7060         if (info.type == VIDEOTRACK)
7061             videoTracks++;
7062         else
7063             audioTracks++;
7064
7065         if (i <= docTrack) {
7066             QString type = (info.type == VIDEOTRACK ? "Video " : "Audio ");
7067             int typeNumber = (info.type == VIDEOTRACK ? videoTracks : audioTracks);
7068
7069             if (added) {
7070                 if (i == docTrack || info.trackName == type + QString::number(typeNumber - 1)) {
7071                     info.trackName = type + QString::number(typeNumber);
7072                     m_document->setTrackType(i, info);
7073                 }
7074             } else {
7075                 if (info.trackName == type + QString::number(typeNumber + 1)) {
7076                     info.trackName = type + QString::number(typeNumber);
7077                     m_document->setTrackType(i, info);
7078                 }
7079             }
7080         }
7081     }
7082     emit tracksChanged();
7083 }
7084
7085 void CustomTrackView::updateTrackDuration(int track, QUndoCommand *command)
7086 {
7087     Q_UNUSED(command)
7088
7089     QList<int> tracks;
7090     if (track >= 0) {
7091         tracks << m_document->tracksCount() - track - 1;
7092     } else {
7093         // negative track number -> update all tracks
7094         for (int i = 0; i < m_document->tracksCount(); ++i)
7095             tracks << i;
7096     }
7097     int t, duration;
7098     for (int i = 0; i < tracks.count(); ++i) {
7099         t = tracks.at(i);
7100         // t + 1 because of black background track
7101         duration = m_document->renderer()->mltTrackDuration(t + 1);
7102         if (duration != m_document->trackDuration(t)) {
7103             m_document->setTrackDuration(t, duration);
7104
7105             // update effects
7106             EffectsList effects = m_document->getTrackEffects(t);
7107             for (int j = 0; j < effects.count(); ++j) {
7108                 /* TODO
7109                  * - lookout for keyframable parameters and update them so all keyframes are in the new range (0 - duration)
7110                  * - update the effectstack if necessary
7111                  */
7112             }
7113         }
7114     }
7115 }
7116
7117 void CustomTrackView::slotRefreshThumbs(const QString &id, bool resetThumbs)
7118 {
7119     QList<QGraphicsItem *> list = scene()->items();
7120     ClipItem *clip = NULL;
7121     for (int i = 0; i < list.size(); ++i) {
7122         if (list.at(i)->type() == AVWIDGET) {
7123             clip = static_cast <ClipItem *>(list.at(i));
7124             if (clip->clipProducer() == id) {
7125                 clip->refreshClip(true, resetThumbs);
7126             }
7127         }
7128     }
7129 }
7130
7131 void CustomTrackView::adjustEffects(ClipItem* item, ItemInfo oldInfo, QUndoCommand* command)
7132 {
7133     QMap<int, QDomElement> effects = item->adjustEffectsToDuration(m_document->width(), m_document->height(), oldInfo);
7134
7135     if (effects.count()) {
7136         QMap<int, QDomElement>::const_iterator i = effects.constBegin();
7137         while (i != effects.constEnd()) {
7138             new EditEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), i.value(), item->effect(i.key()), i.key(), false, false, command);
7139             ++i;
7140         }
7141     }
7142 }
7143
7144
7145 void CustomTrackView::slotGotFilterJobResults(const QString &/*id*/, int startPos, int track, const QString &filter, stringMap filterParams)
7146 {
7147     ClipItem *clip = getClipItemAt(GenTime(startPos, m_document->fps()), track);
7148     if (clip == NULL) {
7149         emit displayMessage(i18n("Cannot find clip for effect update %1.", filter), ErrorMessage);
7150         return;
7151     }
7152     QDomElement newEffect;
7153     QDomElement effect = clip->getEffectAtIndex(clip->selectedEffectIndex());
7154     if (effect.attribute("id") == filter) {
7155         newEffect = effect.cloneNode().toElement();
7156         QMap<QString, QString>::const_iterator i = filterParams.constBegin();
7157         while (i != filterParams.constEnd()) {
7158             EffectsList::setParameter(newEffect, i.key(), i.value());
7159             kDebug()<<"// RESULT FILTER: "<<i.key()<<"="<< i.value();
7160             ++i;
7161         }
7162         EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), effect, newEffect, clip->selectedEffectIndex(), true, true);
7163         m_commandStack->push(command);
7164         emit clipItemSelected(clip);
7165     }
7166
7167 }
7168
7169