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