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

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