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

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