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