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 "customtrackscene.h"
  23 #include "docclipbase.h"
  24 #include "clipitem.h"
  25 #include "definitions.h"
  26 #include "moveclipcommand.h"
  27 #include "movetransitioncommand.h"
  28 #include "resizeclipcommand.h"
  29 #include "editguidecommand.h"
  30 #include "addtimelineclipcommand.h"
  31 #include "addeffectcommand.h"
  32 #include "editeffectcommand.h"
  33 #include "moveeffectcommand.h"
  34 #include "addtransitioncommand.h"
  35 #include "edittransitioncommand.h"
  36 #include "editkeyframecommand.h"
  37 #include "changespeedcommand.h"
  38 #include "addmarkercommand.h"
  39 #include "razorclipcommand.h"
  40 #include "kdenlivesettings.h"
  41 #include "transition.h"
  42 #include "clipmanager.h"
  43 #include "renderer.h"
  44 #include "markerdialog.h"
  45 #include "mainwindow.h"
  46 #include "ui_keyframedialog_ui.h"
  47 #include "clipdurationdialog.h"
  48 #include "abstractgroupitem.h"
  49 #include "insertspacecommand.h"
  50 #include "spacerdialog.h"
  51 #include "addtrackcommand.h"
  52 #include "changetrackcommand.h"
  53 #include "movegroupcommand.h"
  54 #include "ui_addtrack_ui.h"
  55 #include "initeffects.h"
  56 #include "locktrackcommand.h"
  57
  58 #include <KDebug>
  59 #include <KLocale>
  60 #include <KUrl>
  61 #include <KIcon>
  62 #include <KCursor>
  63
  64 #include <QMouseEvent>
  65 #include <QStylePainter>
  66 #include <QGraphicsItem>
  67 #include <QDomDocument>
  68 #include <QScrollBar>
  69 #include <QApplication>
  70 #include <QInputDialog>
  71
  72
  73 //TODO:
  74 // disable animation if user asked it in KDE's global settings
  75 // http://lists.kde.org/?l=kde-commits&m=120398724717624&w=2
  76 // needs something like below (taken from dolphin)
  77 // #include <kglobalsettings.h>
  78 // const bool animate = KGlobalSettings::graphicEffectsLevel() & KGlobalSettings::SimpleAnimationEffects;
  79 // const int duration = animate ? 1500 : 1;
  80
  81 CustomTrackView::CustomTrackView(KdenliveDoc *doc, CustomTrackScene* projectscene, QWidget *parent)
  82         : QGraphicsView(projectscene, parent), m_scene(projectscene), m_cursorPos(0), m_cursorLine(NULL), m_operationMode(NONE), m_dragItem(NULL), m_visualTip(NULL), m_moveOpMode(NONE), m_animation(NULL), m_projectDuration(0), m_clickPoint(QPoint()), m_document(doc), m_autoScroll(KdenliveSettings::autoscroll()), m_tracksHeight(KdenliveSettings::trackheight()), m_tool(SELECTTOOL), m_dragGuide(NULL), m_findIndex(0), m_menuPosition(QPoint()), m_blockRefresh(false), m_selectionGroup(NULL), m_selectedTrack(0), m_copiedItems(QList<AbstractClipItem *> ()), m_scrollOffset(0), m_changeSpeedAction(NULL), m_pasteEffectsAction(NULL), m_clipDrag(false) {
  83     if (doc) m_commandStack = doc->commandStack();
  84     else m_commandStack = NULL;
  85     setMouseTracking(true);
  86     setAcceptDrops(true);
  87     m_animationTimer = new QTimeLine(800);
  88     m_animationTimer->setFrameRange(0, 5);
  89     m_animationTimer->setUpdateInterval(100);
  90     m_animationTimer->setLoopCount(0);
  91     m_tipColor = QColor(0, 192, 0, 200);
  92     QColor border = QColor(255, 255, 255, 100);
  93     m_tipPen.setColor(border);
  94     m_tipPen.setWidth(3);
  95     setContentsMargins(0, 0, 0, 0);
  96     const int maxWidth = m_tracksHeight * m_document->tracksCount();
  97     setSceneRect(0, 0, sceneRect().width(), maxWidth);
  98     verticalScrollBar()->setMaximum(maxWidth);
  99     m_cursorLine = projectscene->addLine(0, 0, 0, maxWidth);
 100     m_cursorLine->setZValue(1000);
 101
 102     KIcon razorIcon("edit-cut");
 103     m_razorCursor = QCursor(razorIcon.pixmap(22, 22));
 104
 105     KIcon spacerIcon("kdenlive-spacer-tool");
 106     m_spacerCursor = QCursor(spacerIcon.pixmap(22, 22));
 107     verticalScrollBar()->setTracking(true);
 108     connect(verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(slotRefreshGuides()));
 109     connect(&m_scrollTimer, SIGNAL(timeout()), this, SLOT(slotCheckMouseScrolling()));
 110     m_scrollTimer.setInterval(100);
 111     m_scrollTimer.setSingleShot(true);
 112 }
 113
 114 CustomTrackView::~CustomTrackView() {
 115     qDeleteAll(m_guides);
 116 }
 117
 118 void CustomTrackView::setDocumentModified() {
 119     m_document->setModified(true);
 120 }
 121
 122 void CustomTrackView::setContextMenu(QMenu *timeline, QMenu *clip, QMenu *transition) {
 123     m_timelineContextMenu = timeline;
 124     m_timelineContextClipMenu = clip;
 125     QList <QAction *> list = m_timelineContextClipMenu->actions();
 126     for (int i = 0; i < list.count(); i++) {
 127         if (list.at(i)->data().toString() == "change_speed") m_changeSpeedAction = list.at(i);
 128         else if (list.at(i)->data().toString() == "paste_effects") m_pasteEffectsAction = list.at(i);
 129     }
 130
 131     m_timelineContextTransitionMenu = transition;
 132     list = m_timelineContextTransitionMenu->actions();
 133     for (int i = 0; i < list.count(); i++) {
 134         if (list.at(i)->data().toString() == "auto") {
 135             m_autoTransition = list.at(i);
 136             break;
 137         }
 138     }
 139 }
 140
 141 void CustomTrackView::checkAutoScroll() {
 142     m_autoScroll = KdenliveSettings::autoscroll();
 143 }
 144
 145 /*sQList <TrackInfo> CustomTrackView::tracksList() const {
 146     return m_scene->m_tracksList;
 147 }*/
 148
 149 void CustomTrackView::checkTrackHeight() {
 150     if (m_tracksHeight == KdenliveSettings::trackheight()) return;
 151     m_tracksHeight = KdenliveSettings::trackheight();
 152     emit trackHeightChanged();
 153     QList<QGraphicsItem *> itemList = items();
 154     ClipItem *item;
 155     Transition *transitionitem;
 156     bool snap = KdenliveSettings::snaptopoints();
 157     KdenliveSettings::setSnaptopoints(false);
 158     for (int i = 0; i < itemList.count(); i++) {
 159         if (itemList.at(i)->type() == AVWIDGET) {
 160             item = (ClipItem*) itemList.at(i);
 161             item->setRect(0, 0, item->rect().width(), m_tracksHeight - 1);
 162             item->setPos((qreal) item->startPos().frames(m_document->fps()), (qreal) item->track() * m_tracksHeight + 1);
 163             item->resetThumbs();
 164         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
 165             transitionitem = (Transition*) itemList.at(i);
 166             transitionitem->setRect(0, 0, transitionitem->rect().width(), m_tracksHeight / 3 * 2 - 1);
 167             transitionitem->setPos((qreal) transitionitem->startPos().frames(m_document->fps()), (qreal) transitionitem->track() * m_tracksHeight + m_tracksHeight / 3 * 2);
 168         }
 169     }
 170     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), m_tracksHeight * m_document->tracksCount());
 171
 172     for (int i = 0; i < m_guides.count(); i++) {
 173         QLineF l = m_guides.at(i)->line();
 174         l.setP2(QPointF(l.x2(), m_tracksHeight * m_document->tracksCount()));
 175         m_guides.at(i)->setLine(l);
 176     }
 177
 178     setSceneRect(0, 0, sceneRect().width(), m_tracksHeight * m_document->tracksCount());
 179 //     verticalScrollBar()->setMaximum(m_tracksHeight * m_document->tracksCount());
 180     KdenliveSettings::setSnaptopoints(snap);
 181     update();
 182 }
 183
 184 // virtual
 185 void CustomTrackView::resizeEvent(QResizeEvent * event) {
 186     QGraphicsView::resizeEvent(event);
 187 }
 188
 189 // virtual
 190 /** Zoom or move viewport on mousewheel
 191  *
 192  * If mousewheel+Ctrl, zooms in/out on the timeline.
 193  *
 194  * With Ctrl, moves viewport towards end of timeline if down/back,
 195  * opposite on up/forward.
 196  *
 197  * See also http://www.kdenlive.org/mantis/view.php?id=265 */
 198 void CustomTrackView::wheelEvent(QWheelEvent * e) {
 199     if (e->modifiers() == Qt::ControlModifier) {
 200         if (e->delta() > 0) emit zoomIn();
 201         else emit zoomOut();
 202     } else {
 203         if (e->delta() <= 0) horizontalScrollBar()->setValue(horizontalScrollBar()->value() + horizontalScrollBar()->singleStep());
 204         else  horizontalScrollBar()->setValue(horizontalScrollBar()->value() - horizontalScrollBar()->singleStep());
 205     }
 206 }
 207
 208 int CustomTrackView::getPreviousVideoTrack(int track) {
 209     track = m_document->tracksCount() - track - 1;
 210     track --;
 211     for (int i = track; i > -1; i--) {
 212         if (m_document->trackInfoAt(i).type == VIDEOTRACK) return i + 1;
 213     }
 214     return 0;
 215 }
 216
 217
 218 void CustomTrackView::slotCheckMouseScrolling() {
 219     if (m_scrollOffset == 0) {
 220         m_scrollTimer.stop();
 221         return;
 222     }
 223     horizontalScrollBar()->setValue(horizontalScrollBar()->value() + m_scrollOffset);
 224     m_scrollTimer.start();
 225 }
 226
 227 void CustomTrackView::slotCheckPositionScrolling() {
 228     // If mouse is at a border of the view, scroll
 229     if (m_moveOpMode != SEEK) return;
 230     int pos = cursorPos();
 231     if (mapFromScene(pos, 0).x() < 7) {
 232         horizontalScrollBar()->setValue(horizontalScrollBar()->value() - 2);
 233         setCursorPos(mapToScene(QPoint()).x() - 1);
 234         QTimer::singleShot(200, this, SLOT(slotCheckPositionScrolling()));
 235
 236     } else if (viewport()->width() - 5 < mapFromScene(pos + 1, 0).x()) {
 237         horizontalScrollBar()->setValue(horizontalScrollBar()->value() + 2);
 238         setCursorPos(mapToScene(viewport()->width(), 0).x() + 1);
 239         QTimer::singleShot(200, this, SLOT(slotCheckPositionScrolling()));
 240     }
 241 }
 242
 243
 244 // virtual
 245
 246 void CustomTrackView::mouseMoveEvent(QMouseEvent * event) {
 247     int pos = event->x();
 248     int mappedXPos = (int)(mapToScene(event->pos()).x() + 0.5);
 249     emit mousePosition(mappedXPos);
 250     if (event->buttons() & Qt::MidButton) return;
 251     if ((event->modifiers() == Qt::ControlModifier && m_tool != SPACERTOOL) || event->modifiers() == Qt::ShiftModifier) {
 252         QGraphicsView::mouseMoveEvent(event);
 253         m_moveOpMode = NONE;
 254         return;
 255     }
 256
 257     if (event->buttons() != Qt::NoButton) {
 258         bool move = (event->pos() - m_clickEvent).manhattanLength() >= QApplication::startDragDistance();
 259         if (m_dragItem && m_tool == SELECTTOOL) {
 260             if (m_operationMode == MOVE && move) {
 261                 QGraphicsView::mouseMoveEvent(event);
 262                 // If mouse is at a border of the view, scroll
 263                 if (pos < 5) {
 264                     m_scrollOffset = -30;
 265                     m_scrollTimer.start();
 266                 } else if (viewport()->width() - pos < 10) {
 267                     m_scrollOffset = 30;
 268                     m_scrollTimer.start();
 269                 } else if (m_scrollTimer.isActive()) m_scrollTimer.stop();
 270
 271             } else if (m_operationMode == RESIZESTART && move) {
 272                 double snappedPos = getSnapPointForPos(mappedXPos);
 273                 m_document->renderer()->pause();
 274                 m_dragItem->resizeStart((int)(snappedPos));
 275             } else if (m_operationMode == RESIZEEND && move) {
 276                 double snappedPos = getSnapPointForPos(mappedXPos);
 277                 m_document->renderer()->pause();
 278                 m_dragItem->resizeEnd((int)(snappedPos));
 279             } else if (m_operationMode == FADEIN && move) {
 280                 ((ClipItem*) m_dragItem)->setFadeIn((int)(mappedXPos - m_dragItem->startPos().frames(m_document->fps())));
 281             } else if (m_operationMode == FADEOUT && move) {
 282                 ((ClipItem*) m_dragItem)->setFadeOut((int)(m_dragItem->endPos().frames(m_document->fps()) - mappedXPos));
 283             } else if (m_operationMode == KEYFRAME && move) {
 284                 GenTime keyFramePos = GenTime(mappedXPos, m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
 285                 double pos = mapToScene(event->pos()).toPoint().y();
 286                 QRectF br = m_dragItem->sceneBoundingRect();
 287                 double maxh = 100.0 / br.height();
 288                 pos = (br.bottom() - pos) * maxh;
 289                 m_dragItem->updateKeyFramePos(keyFramePos, pos);
 290             }
 291
 292             if (m_animation) delete m_animation;
 293             m_animation = NULL;
 294             if (m_visualTip) delete m_visualTip;
 295             m_visualTip = NULL;
 296             return;
 297         } else if (m_operationMode == MOVEGUIDE) {
 298             if (m_animation) delete m_animation;
 299             m_animation = NULL;
 300             if (m_visualTip) delete m_visualTip;
 301             m_visualTip = NULL;
 302             QGraphicsView::mouseMoveEvent(event);
 303             return;
 304         } else if (m_operationMode == SPACER && move) {
 305             // spacer tool
 306             int mappedClick = (int)(mapToScene(m_clickEvent).x() + 0.5);
 307             m_selectionGroup->setPos(mappedXPos + (((int) m_selectionGroup->boundingRect().topLeft().x() + 0.5) - mappedClick) , m_selectionGroup->pos().y());
 308         }
 309     }
 310
 311     if (m_tool == RAZORTOOL) {
 312         setCursor(m_razorCursor);
 313         //QGraphicsView::mouseMoveEvent(event);
 314         //return;
 315     } else if (m_tool == SPACERTOOL) {
 316         setCursor(m_spacerCursor);
 317         return;
 318     }
 319
 320     QList<QGraphicsItem *> itemList = items(event->pos());
 321     QGraphicsRectItem *item = NULL;
 322     OPERATIONTYPE opMode = NONE;
 323
 324     if (itemList.count() == 1 && itemList.at(0)->type() == GUIDEITEM) {
 325         opMode = MOVEGUIDE;
 326     } else for (int i = 0; i < itemList.count(); i++) {
 327             if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
 328                 item = (QGraphicsRectItem*) itemList.at(i);
 329                 break;
 330             }
 331         }
 332
 333     if (item && event->buttons() == Qt::NoButton) {
 334         AbstractClipItem *clip = static_cast <AbstractClipItem*>(item);
 335         if (m_tool == RAZORTOOL) {
 336             // razor tool over a clip, display current frame in monitor
 337             if (!m_blockRefresh && item->type() == AVWIDGET) {
 338                 //TODO: solve crash when showing frame when moving razor over clip
 339                 //emit showClipFrame(((ClipItem *) item)->baseClip(), mapToScene(event->pos()).x() / m_scale - (clip->startPos() - clip->cropStart()).frames(m_document->fps()));
 340             }
 341             event->accept();
 342             return;
 343         }
 344         opMode = clip->operationMode(mapToScene(event->pos()));
 345         double size = 5;
 346         if (opMode == m_moveOpMode) {
 347             QGraphicsView::mouseMoveEvent(event);
 348             return;
 349         } else {
 350             if (m_visualTip) {
 351                 if (m_animation) delete m_animation;
 352                 m_animation = NULL;
 353                 m_animationTimer->stop();
 354                 delete m_visualTip;
 355                 m_visualTip = NULL;
 356             }
 357         }
 358         m_moveOpMode = opMode;
 359         if (opMode == MOVE) {
 360             setCursor(Qt::OpenHandCursor);
 361         } else if (opMode == RESIZESTART) {
 362             setCursor(KCursor("left_side", Qt::SizeHorCursor));
 363             if (m_visualTip == NULL) {
 364                 QRectF rect = clip->sceneBoundingRect();
 365                 QPolygon polygon;
 366                 polygon << QPoint(0, rect.height() / 2 - size * 2);
 367                 polygon << QPoint(size * 2, (int)(rect.height() / 2));
 368                 polygon << QPoint(0, (int)(rect.height() / 2 + size * 2));
 369                 polygon << QPoint(0, (int)(rect.height() / 2 - size * 2));
 370
 371                 m_visualTip = new QGraphicsPolygonItem(polygon);
 372                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 373                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 374                 m_visualTip->setPos(rect.x(), rect.y());
 375                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 376                 m_visualTip->setZValue(100);
 377                 m_animation = new QGraphicsItemAnimation;
 378                 m_animation->setItem(m_visualTip);
 379                 m_animation->setTimeLine(m_animationTimer);
 380                 double scale = 2.0;
 381                 m_animation->setScaleAt(.5, scale, 1);
 382                 //m_animation->setPosAt(.5, QPointF(rect.x() - rect.x() * scale, 0));
 383                 scale = 1.0;
 384                 m_animation->setScaleAt(1, scale, 1);
 385                 //m_animation->setPosAt(1, QPointF(rect.x() - rect.x() * scale, 0));
 386                 scene()->addItem(m_visualTip);
 387                 m_animationTimer->start();
 388             }
 389         } else if (opMode == RESIZEEND) {
 390             setCursor(KCursor("right_side", Qt::SizeHorCursor));
 391             if (m_visualTip == NULL) {
 392                 QRectF rect = clip->sceneBoundingRect();
 393                 QPolygon polygon;
 394                 polygon << QPoint(0, (int)(rect.height() / 2 - size * 2));
 395                 polygon << QPoint(- size * 2, (int)(rect.height() / 2));
 396                 polygon << QPoint(0, (int)(rect.height() / 2 + size * 2));
 397                 polygon << QPoint(0, (int)(rect.height() / 2 - size * 2));
 398
 399                 m_visualTip = new QGraphicsPolygonItem(polygon);
 400                 ((QGraphicsPolygonItem*) m_visualTip)->setBrush(m_tipColor);
 401                 ((QGraphicsPolygonItem*) m_visualTip)->setPen(m_tipPen);
 402                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 403                 m_visualTip->setPos(rect.right(), rect.y());
 404                 m_visualTip->setZValue(100);
 405                 m_animation = new QGraphicsItemAnimation;
 406                 m_animation->setItem(m_visualTip);
 407                 m_animation->setTimeLine(m_animationTimer);
 408                 double scale = 2.0;
 409                 m_animation->setScaleAt(.5, scale, 1);
 410                 scale = 1.0;
 411                 m_animation->setScaleAt(1, scale, 1);
 412                 scene()->addItem(m_visualTip);
 413                 m_animationTimer->start();
 414             }
 415         } else if (opMode == FADEIN) {
 416             if (m_visualTip == NULL) {
 417                 ClipItem *item = (ClipItem *) clip;
 418                 QRectF rect = clip->sceneBoundingRect();
 419                 m_visualTip = new QGraphicsEllipseItem(-size, -size, size * 2, size * 2);
 420                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 421                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 422                 m_visualTip->setPos(rect.x() + item->fadeIn(), rect.y());
 423                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 424                 m_visualTip->setZValue(100);
 425                 m_animation = new QGraphicsItemAnimation;
 426                 m_animation->setItem(m_visualTip);
 427                 m_animation->setTimeLine(m_animationTimer);
 428                 double scale = 2.0;
 429                 m_animation->setScaleAt(.5, scale, scale);
 430                 scale = 1.0;
 431                 m_animation->setScaleAt(1, scale, scale);
 432                 scene()->addItem(m_visualTip);
 433                 m_animationTimer->start();
 434             }
 435             setCursor(Qt::PointingHandCursor);
 436         } else if (opMode == FADEOUT) {
 437             if (m_visualTip == NULL) {
 438                 ClipItem *item = (ClipItem *) clip;
 439                 QRectF rect = clip->sceneBoundingRect();
 440                 m_visualTip = new QGraphicsEllipseItem(-size, -size, size * 2, size * 2);
 441                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 442                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 443                 m_visualTip->setPos(rect.right() - item->fadeOut(), rect.y());
 444                 m_visualTip->setFlags(QGraphicsItem::ItemIgnoresTransformations);
 445                 m_visualTip->setZValue(100);
 446                 m_animation = new QGraphicsItemAnimation;
 447                 m_animation->setItem(m_visualTip);
 448                 m_animation->setTimeLine(m_animationTimer);
 449                 double scale = 2.0;
 450                 m_animation->setScaleAt(.5, scale, scale);
 451                 scale = 1.0;
 452                 m_animation->setScaleAt(1, scale, scale);
 453                 scene()->addItem(m_visualTip);
 454                 m_animationTimer->start();
 455             }
 456             setCursor(Qt::PointingHandCursor);
 457         } else if (opMode == TRANSITIONSTART) {
 458             /*if (m_visualTip == NULL) {
 459                 QRectF rect = clip->sceneBoundingRect();
 460                 m_visualTip = new QGraphicsEllipseItem(-5, -5 , 10, 10);
 461                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 462                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 463                 m_visualTip->setZValue(100);
 464                 m_animation = new QGraphicsItemAnimation;
 465                 m_animation->setItem(m_visualTip);
 466                 m_animation->setTimeLine(m_animationTimer);
 467                 m_visualTip->setPos(rect.x() + 10, rect.y() + rect.height() / 2 + 12);
 468                 double scale = 2.0;
 469                 m_animation->setScaleAt(.5, scale, scale);
 470                 scale = 1.0;
 471                 m_animation->setScaleAt(1, scale, scale);
 472                 scene()->addItem(m_visualTip);
 473                 m_animationTimer->start();
 474             }*/
 475             setCursor(Qt::PointingHandCursor);
 476         } else if (opMode == TRANSITIONEND) {
 477             /*if (m_visualTip == NULL) {
 478                 QRectF rect = clip->sceneBoundingRect();
 479                 m_visualTip = new QGraphicsEllipseItem(-5, -5 , 10, 10);
 480                 ((QGraphicsEllipseItem*) m_visualTip)->setBrush(m_tipColor);
 481                 ((QGraphicsEllipseItem*) m_visualTip)->setPen(m_tipPen);
 482                 m_visualTip->setZValue(100);
 483                 m_animation = new QGraphicsItemAnimation;
 484                 m_animation->setItem(m_visualTip);
 485                 m_animation->setTimeLine(m_animationTimer);
 486                 m_visualTip->setPos(rect.x() + rect.width() - 10 , rect.y() + rect.height() / 2 + 12);
 487                 double scale = 2.0;
 488                 m_animation->setScaleAt(.5, scale, scale);
 489                 scale = 1.0;
 490                 m_animation->setScaleAt(1, scale, scale);
 491                 scene()->addItem(m_visualTip);
 492                 m_animationTimer->start();
 493             }*/
 494             setCursor(Qt::PointingHandCursor);
 495         } else if (opMode == KEYFRAME) {
 496             setCursor(Qt::PointingHandCursor);
 497         }
 498     } // no clip under mouse
 499     else if (m_tool == RAZORTOOL) {
 500         event->accept();
 501         return;
 502     } else if (opMode == MOVEGUIDE) {
 503         m_moveOpMode = opMode;
 504         setCursor(Qt::SplitHCursor);
 505     } else {
 506         if (event->buttons() != Qt::NoButton && event->modifiers() == Qt::NoModifier) {
 507             m_moveOpMode = SEEK;
 508             setCursorPos(mappedXPos);
 509             slotCheckPositionScrolling();
 510         } else m_moveOpMode = NONE;
 511         if (m_visualTip) {
 512             if (m_animation) delete m_animation;
 513             m_animationTimer->stop();
 514             m_animation = NULL;
 515             delete m_visualTip;
 516             m_visualTip = NULL;
 517
 518         }
 519         setCursor(Qt::ArrowCursor);
 520     }
 521     QGraphicsView::mouseMoveEvent(event);
 522 }
 523
 524 // virtual
 525 void CustomTrackView::mousePressEvent(QMouseEvent * event) {
 526     kDebug() << "mousePressEvent STARTED";
 527     m_menuPosition = QPoint();
 528     m_blockRefresh = true;
 529     bool collision = false;
 530
 531     if (m_tool != RAZORTOOL) activateMonitor();
 532     else if (m_document->renderer()->playSpeed() != 0.0) {
 533         m_document->renderer()->pause();
 534         return;
 535     }
 536     m_clickEvent = event->pos();
 537
 538     // special cases (middle click button or ctrl / shift click
 539     if (event->button() == Qt::MidButton) {
 540         m_document->renderer()->switchPlay();
 541         m_blockRefresh = false;
 542         m_operationMode = NONE;
 543         return;
 544     }
 545
 546     // check item under mouse
 547     QList<QGraphicsItem *> collisionList = items(event->pos());
 548
 549     if (event->modifiers() == Qt::ControlModifier && m_tool != SPACERTOOL && collisionList.count() == 0) {
 550         setDragMode(QGraphicsView::ScrollHandDrag);
 551         QGraphicsView::mousePressEvent(event);
 552         m_blockRefresh = false;
 553         m_operationMode = NONE;
 554         return;
 555     }
 556
 557     if (event->modifiers() == Qt::ShiftModifier && collisionList.count() == 0) {
 558         setDragMode(QGraphicsView::RubberBandDrag);
 559         QGraphicsView::mousePressEvent(event);
 560         m_blockRefresh = false;
 561         m_operationMode = RUBBERSELECTION;
 562         return;
 563     }
 564
 565     if (collisionList.count() == 1 && collisionList.at(0)->type() == GUIDEITEM) {
 566         // a guide item was pressed
 567         collisionList.at(0)->setFlag(QGraphicsItem::ItemIsMovable, true);
 568         m_dragItem = NULL;
 569         m_dragGuide = (Guide *) collisionList.at(0);
 570         collision = true;
 571         m_operationMode = MOVEGUIDE;
 572         // deselect all clips so that only the guide will move
 573         m_scene->clearSelection();
 574         resetSelectionGroup();
 575         updateSnapPoints(NULL);
 576         QGraphicsView::mousePressEvent(event);
 577         return;
 578     }
 579
 580     // Find first clip or transition under mouse
 581     int i = 0;
 582     m_dragItem = NULL;
 583     while (i < collisionList.count()) {
 584         if (collisionList.at(i)->type() == AVWIDGET || collisionList.at(i)->type() == TRANSITIONWIDGET) {
 585             m_dragItem = static_cast <AbstractClipItem *>(collisionList.at(i));
 586             m_dragItemInfo = m_dragItem->info();
 587             break;
 588         }
 589         i++;
 590     }
 591
 592     if (m_dragItem && m_dragItem->type() == TRANSITIONWIDGET) {
 593         // update transition menu action
 594         m_autoTransition->setChecked(static_cast<Transition *>(m_dragItem)->isAutomatic());
 595         m_autoTransition->setEnabled(true);
 596     } else m_autoTransition->setEnabled(false);
 597
 598     // context menu requested
 599     if (event->button() == Qt::RightButton) {
 600         if (m_dragItem) {
 601             if (!m_dragItem->isSelected()) {
 602                 resetSelectionGroup(false);
 603                 m_scene->clearSelection();
 604                 m_dragItem->setSelected(true);
 605             }
 606         }
 607         m_operationMode = NONE;
 608         displayContextMenu(event->globalPos(), m_dragItem);
 609         m_menuPosition = m_clickEvent;
 610         m_dragItem = NULL;
 611         event->accept();
 612         return;
 613     }
 614
 615     // No item under click
 616     if (m_dragItem == NULL || m_tool == SPACERTOOL) {
 617         resetSelectionGroup();
 618         setCursor(Qt::ArrowCursor);
 619         m_scene->clearSelection();
 620         event->accept();
 621         emit clipItemSelected(NULL);
 622         if (m_tool == SPACERTOOL) {
 623             QList<QGraphicsItem *> selection;
 624             if (event->modifiers() == Qt::ControlModifier) {
 625                 // Ctrl + click, select all items on track after click position
 626                 int track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
 627                 selection = items(m_clickEvent.x(), track * m_tracksHeight + m_tracksHeight / 2, mapFromScene(sceneRect().width(), 0).x() - m_clickEvent.x(), m_tracksHeight / 2 - 2);
 628
 629                 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;
 630             } else {
 631                 // Select all items on all tracks after click position
 632                 selection = items(event->pos().x(), 1, mapFromScene(sceneRect().width(), 0).x() - event->pos().x(), sceneRect().height());
 633                 kDebug() << "SELELCTING ELEMENTS WITHIN =" << event->pos().x() << "/" <<  1 << ", " << mapFromScene(sceneRect().width(), 0).x() - event->pos().x() << "/" << sceneRect().height();
 634             }
 635
 636             resetSelectionGroup(false);
 637             m_scene->clearSelection();
 638
 639             for (int i = 0; i < selection.count(); i++) {
 640                 if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
 641                     selection.at(i)->setSelected(true);
 642                 }
 643             }
 644             groupSelectedItems(true);
 645             m_operationMode = SPACER;
 646         } else setCursorPos((int)(mapToScene(event->x(), 0).x()));
 647         kDebug() << "END mousePress EVENT ";
 648         return;
 649     }
 650
 651     // Razor tool
 652     if (m_tool == RAZORTOOL) {
 653         if (m_dragItem->type() == TRANSITIONWIDGET) {
 654             emit displayMessage(i18n("Cannot cut a transition"), ErrorMessage);
 655             event->accept();
 656             m_dragItem = NULL;
 657             return;
 658         }
 659         AbstractClipItem *clip = static_cast <AbstractClipItem *>(m_dragItem);
 660         RazorClipCommand* command = new RazorClipCommand(this, clip->info(), GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()), true);
 661         m_document->renderer()->pause();
 662         m_commandStack->push(command);
 663         m_document->setModified(true);
 664         m_dragItem = NULL;
 665         event->accept();
 666         return;
 667     }
 668
 669
 670     if (m_dragItem->type() == AVWIDGET && !m_dragItem->isItemLocked()) emit clipItemSelected((ClipItem*) m_dragItem);
 671     else emit clipItemSelected(NULL);
 672
 673     if (event->modifiers() != Qt::ControlModifier && (m_dragItem->group() || m_dragItem->isSelected())) {
 674         // If clicked item is selected, allow move
 675         event->accept();
 676         if (m_selectionGroup) m_selectionGroup->setSelected(true);
 677         if (m_operationMode == NONE) QGraphicsView::mousePressEvent(event);
 678     } else {
 679         resetSelectionGroup();
 680         if (event->modifiers() != Qt::ControlModifier) m_scene->clearSelection();
 681         m_dragItem->setSelected(!m_dragItem->isSelected());
 682         groupSelectedItems();
 683         ClipItem *clip = static_cast <ClipItem *>(m_dragItem);
 684         m_changeSpeedAction->setEnabled(clip->clipType() == AV || clip->clipType() == VIDEO);
 685         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
 686     }
 687
 688     if (m_selectionGroup == NULL) updateSnapPoints(m_dragItem);
 689     else {
 690         QList <GenTime> offsetList;
 691         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
 692         for (int i = 0; i < children.count(); i++) {
 693             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
 694             offsetList.append(item->startPos());
 695             offsetList.append(item->endPos());
 696         }
 697         if (!offsetList.isEmpty()) {
 698             qSort(offsetList);
 699             GenTime startOffset = offsetList.takeFirst();
 700             QList <GenTime> cleandOffsetList;
 701             for (int k = 0; k < offsetList.size(); k++) {
 702                 GenTime newoffset = offsetList.at(k) - startOffset;
 703                 if (newoffset != GenTime() && !cleandOffsetList.contains(newoffset)) {
 704                     cleandOffsetList.append(newoffset);
 705                 }
 706             }
 707             updateSnapPoints(NULL, cleandOffsetList, true);
 708         }
 709     }
 710
 711     m_clickPoint = QPoint((int)(mapToScene(event->pos()).x() - m_dragItem->startPos().frames(m_document->fps())), (int)(event->pos().y() - m_dragItem->pos().y()));
 712     m_operationMode = m_dragItem->operationMode(mapToScene(event->pos()));
 713
 714     if (m_operationMode == KEYFRAME) {
 715         m_dragItem->updateSelectedKeyFrame();
 716         m_blockRefresh = false;
 717         return;
 718     } else if (m_operationMode == MOVE) {
 719         setCursor(Qt::ClosedHandCursor);
 720     } else if (m_operationMode == TRANSITIONSTART) {
 721         ItemInfo info;
 722         info.startPos = m_dragItem->startPos();
 723         info.track = m_dragItem->track();
 724         int transitiontrack = getPreviousVideoTrack(info.track);
 725         ClipItem *transitionClip = NULL;
 726         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
 727         if (transitionClip && transitionClip->endPos() < m_dragItem->endPos()) {
 728             info.endPos = transitionClip->endPos();
 729         } else info.endPos = info.startPos + GenTime(65, m_document->fps());
 730         if (info.endPos == info.startPos) info.endPos = info.startPos + GenTime(65, m_document->fps());
 731         // Check there is no other transition at that place
 732         double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
 733         QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
 734         QList<QGraphicsItem *> selection = m_scene->items(r);
 735         bool transitionAccepted = true;
 736         for (int i = 0; i < selection.count(); i++) {
 737             if (selection.at(i)->type() == TRANSITIONWIDGET) {
 738                 Transition *tr = static_cast <Transition *>(selection.at(i));
 739                 if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
 740                     if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
 741                 } else transitionAccepted = false;
 742             }
 743         }
 744         if (transitionAccepted) slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack);
 745         else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
 746     } else if (m_operationMode == TRANSITIONEND) {
 747         ItemInfo info;
 748         info.endPos = GenTime(m_dragItem->endPos().frames(m_document->fps()), m_document->fps());
 749         info.track = m_dragItem->track();
 750         int transitiontrack = getPreviousVideoTrack(info.track);
 751         ClipItem *transitionClip = NULL;
 752         if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
 753         if (transitionClip && transitionClip->startPos() > m_dragItem->startPos()) {
 754             info.startPos = transitionClip->startPos();
 755         } else info.startPos = info.endPos - GenTime(65, m_document->fps());
 756         if (info.endPos == info.startPos) info.startPos = info.endPos - GenTime(65, m_document->fps());
 757         QDomElement transition = MainWindow::transitions.getEffectByName("Luma").cloneNode().toElement();
 758         EffectsList::setParameter(transition, "reverse", "1");
 759
 760         // Check there is no other transition at that place
 761         double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
 762         QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
 763         QList<QGraphicsItem *> selection = m_scene->items(r);
 764         bool transitionAccepted = true;
 765         for (int i = 0; i < selection.count(); i++) {
 766             if (selection.at(i)->type() == TRANSITIONWIDGET) {
 767                 Transition *tr = static_cast <Transition *>(selection.at(i));
 768                 if (info.endPos - tr->endPos() > GenTime(5, m_document->fps())) {
 769                     if (tr->endPos() > info.startPos) info.startPos = tr->endPos();
 770                 } else transitionAccepted = false;
 771             }
 772         }
 773         if (transitionAccepted) slotAddTransition((ClipItem *) m_dragItem, info, transitiontrack, transition);
 774         else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
 775
 776     } else if ((m_operationMode == RESIZESTART || m_operationMode == RESIZEEND) && m_selectionGroup) {
 777         resetSelectionGroup(false);
 778         m_dragItem->setSelected(true);
 779     }
 780
 781     m_blockRefresh = false;
 782     //kDebug()<<pos;
 783     //QGraphicsView::mousePressEvent(event);
 784 }
 785
 786 void CustomTrackView::resetSelectionGroup(bool selectItems) {
 787     if (m_selectionGroup) {
 788         // delete selection group
 789         bool snap = KdenliveSettings::snaptopoints();
 790         KdenliveSettings::setSnaptopoints(false);
 791         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
 792         scene()->destroyItemGroup(m_selectionGroup);
 793         for (int i = 0; i < children.count(); i++) {
 794             if (!static_cast <AbstractClipItem *>(children.at(i))->isItemLocked()) {
 795                 children.at(i)->setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
 796                 children.at(i)->setSelected(selectItems);
 797             }
 798         }
 799         m_selectionGroup = NULL;
 800         KdenliveSettings::setSnaptopoints(snap);
 801     }
 802 }
 803
 804 void CustomTrackView::groupSelectedItems(bool force) {
 805     if (m_selectionGroup) {
 806         kDebug() << "///// ERROR, TRYING TO OVERRIDE EXISTING GROUP";
 807         return;
 808     }
 809     QList<QGraphicsItem *> selection = m_scene->selectedItems();
 810     QGraphicsItemGroup *group = m_scene->createItemGroup(selection);
 811     scene()->addItem(group);
 812     QPointF top = group->sceneBoundingRect().topLeft();
 813     m_scene->destroyItemGroup(group);
 814     if (force || selection.count() > 1) {
 815         bool snap = KdenliveSettings::snaptopoints();
 816         KdenliveSettings::setSnaptopoints(false);
 817         m_selectionGroup = new AbstractGroupItem(m_document->fps());
 818         m_selectionGroup->translate(-top.x(), -top.y() + 1);
 819         m_selectionGroup->setPos(top.x(), top.y() - 1);
 820         scene()->addItem(m_selectionGroup);
 821         for (int i = 0; i < selection.count(); i++) {
 822             if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
 823                 m_selectionGroup->addToGroup(selection.at(i));
 824                 selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
 825             }
 826         }
 827         KdenliveSettings::setSnaptopoints(snap);
 828
 829         if (m_selectionGroup) {
 830             /*bool snap = KdenliveSettings::snaptopoints();
 831             KdenliveSettings::setSnaptopoints(false);
 832             QPointF top = m_selectionGroup->sceneBoundingRect().topLeft();
 833             // kDebug()<<"SEL GRP TOP: "<<top;
 834             // Fix group item position
 835             m_selectionGroup->translate(-top.x(), -top.y());
 836             m_selectionGroup->setPos(top);*/
 837             m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
 838             m_selectionGroupInfo.track = m_selectionGroup->track();
 839             //KdenliveSettings::setSnaptopoints(snap);
 840         }
 841     } else resetSelectionGroup();
 842 }
 843
 844 void CustomTrackView::mouseDoubleClickEvent(QMouseEvent *event) {
 845     kDebug() << "++++++++++++ DBL CLK";
 846     if (m_dragItem && m_dragItem->hasKeyFrames()) {
 847         if (m_moveOpMode == KEYFRAME) {
 848             // user double clicked on a keyframe, open edit dialog
 849             QDialog d(parentWidget());
 850             Ui::KeyFrameDialog_UI view;
 851             view.setupUi(&d);
 852             view.kfr_position->setText(m_document->timecode().getTimecode(GenTime(m_dragItem->selectedKeyFramePos(), m_document->fps()) - m_dragItem->cropStart(), m_document->fps()));
 853             view.kfr_value->setValue(m_dragItem->selectedKeyFrameValue());
 854             view.kfr_value->setFocus();
 855             if (d.exec() == QDialog::Accepted) {
 856                 int pos = m_document->timecode().getFrameCount(view.kfr_position->text(), m_document->fps());
 857                 m_dragItem->updateKeyFramePos(GenTime(pos, m_document->fps()) + m_dragItem->cropStart(), (double) view.kfr_value->value() * m_dragItem->keyFrameFactor());
 858                 ClipItem *item = (ClipItem *)m_dragItem;
 859                 QString previous = item->keyframes(item->selectedEffectIndex());
 860                 item->updateKeyframeEffect();
 861                 QString next = item->keyframes(item->selectedEffectIndex());
 862                 EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
 863                 m_commandStack->push(command);
 864                 updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
 865             }
 866
 867         } else  {
 868             // add keyframe
 869             GenTime keyFramePos = GenTime((int)(mapToScene(event->pos()).x()), m_document->fps()) - m_dragItem->startPos() + m_dragItem->cropStart();
 870             m_dragItem->addKeyFrame(keyFramePos, mapToScene(event->pos()).toPoint().y());
 871             ClipItem * item = (ClipItem *) m_dragItem;
 872             QString previous = item->keyframes(item->selectedEffectIndex());
 873             item->updateKeyframeEffect();
 874             QString next = item->keyframes(item->selectedEffectIndex());
 875             EditKeyFrameCommand *command = new EditKeyFrameCommand(this, m_dragItem->track(), m_dragItem->startPos(), item->selectedEffectIndex(), previous, next, false);
 876             m_commandStack->push(command);
 877             updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
 878         }
 879     } else if (m_dragItem) {
 880         ClipDurationDialog d(m_dragItem, m_document->timecode(), this);
 881         GenTime minimum;
 882         GenTime maximum;
 883         if (m_dragItem->type() == TRANSITIONWIDGET) {
 884             getTransitionAvailableSpace(m_dragItem, minimum, maximum);
 885         } else {
 886             getClipAvailableSpace(m_dragItem, minimum, maximum);
 887         }
 888         //kDebug()<<"// GOT MOVE POS: "<<minimum.frames(25)<<" - "<<maximum.frames(25);
 889         d.setMargins(minimum, maximum);
 890         if (d.exec() == QDialog::Accepted) {
 891             if (m_dragItem->type() == TRANSITIONWIDGET) {
 892                 // move & resize transition
 893                 ItemInfo startInfo;
 894                 startInfo.startPos = m_dragItem->startPos();
 895                 startInfo.endPos = m_dragItem->endPos();
 896                 startInfo.track = m_dragItem->track();
 897                 ItemInfo endInfo;
 898                 endInfo.startPos = d.startPos();
 899                 endInfo.endPos = endInfo.startPos + d.duration();
 900                 endInfo.track = m_dragItem->track();
 901                 MoveTransitionCommand *command = new MoveTransitionCommand(this, startInfo, endInfo, true);
 902                 m_commandStack->push(command);
 903             } else {
 904                 // move and resize clip
 905                 QUndoCommand *moveCommand = new QUndoCommand();
 906                 moveCommand->setText(i18n("Edit clip"));
 907                 ItemInfo clipInfo = m_dragItem->info();
 908                 if (d.startPos() != clipInfo.startPos) {
 909                     ItemInfo startInfo = clipInfo;
 910                     clipInfo.startPos = d.startPos();
 911                     clipInfo.endPos = m_dragItem->endPos() + (clipInfo.startPos - startInfo.startPos);
 912                     new MoveClipCommand(this, startInfo, clipInfo, true, moveCommand);
 913                 }
 914                 if (d.duration() != m_dragItem->duration() || d.cropStart() != clipInfo.cropStart) {
 915                     ItemInfo startInfo = clipInfo;
 916                     clipInfo.endPos = clipInfo.startPos + d.duration();
 917                     clipInfo.cropStart = d.cropStart();
 918                     new ResizeClipCommand(this, startInfo, clipInfo, true, moveCommand);
 919                 }
 920                 m_commandStack->push(moveCommand);
 921             }
 922         }
 923     } else {
 924         QList<QGraphicsItem *> collisionList = items(event->pos());
 925         if (collisionList.count() == 1 && collisionList.at(0)->type() == GUIDEITEM) {
 926             Guide *editGuide = (Guide *) collisionList.at(0);
 927             if (editGuide) slotEditGuide(editGuide->info());
 928         }
 929     }
 930 }
 931
 932
 933 void CustomTrackView::editKeyFrame(const GenTime pos, const int track, const int index, const QString keyframes) {
 934     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()), track);
 935     if (clip) {
 936         clip->setKeyframes(index, keyframes);
 937         updateEffect(m_document->tracksCount() - clip->track(), clip->startPos(), clip->effectAt(index), index);
 938     } else emit displayMessage(i18n("Cannot find clip with keyframe"), ErrorMessage);
 939 }
 940
 941
 942 void CustomTrackView::displayContextMenu(QPoint pos, AbstractClipItem *clip) {
 943     if (clip == NULL) m_timelineContextMenu->popup(pos);
 944     else if (clip->type() == AVWIDGET) {
 945         ClipItem *item = static_cast <ClipItem*>(clip);
 946         m_changeSpeedAction->setEnabled(item->clipType() == AV || item->clipType() == VIDEO);
 947         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
 948         m_timelineContextClipMenu->popup(pos);
 949     } else if (clip->type() == TRANSITIONWIDGET) m_timelineContextTransitionMenu->popup(pos);
 950 }
 951
 952 void CustomTrackView::activateMonitor() {
 953     emit activateDocumentMonitor();
 954 }
 955
 956 void CustomTrackView::dragEnterEvent(QDragEnterEvent * event) {
 957     if (event->mimeData()->hasFormat("kdenlive/clip")) {
 958         m_clipDrag = true;
 959         resetSelectionGroup();
 960         QStringList list = QString(event->mimeData()->data("kdenlive/clip")).split(';');
 961         m_selectionGroup = new AbstractGroupItem(m_document->fps());
 962         QPoint pos = QPoint();
 963         DocClipBase *clip = m_document->getBaseClip(list.at(0));
 964         if (clip == NULL) kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << list.at(0);
 965         ItemInfo info;
 966         info.startPos = GenTime();
 967         info.cropStart = GenTime(list.at(1).toInt(), m_document->fps());
 968         info.endPos = GenTime(list.at(2).toInt() - list.at(1).toInt(), m_document->fps());
 969         info.track = (int)(1 / m_tracksHeight);
 970         ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0);
 971         m_selectionGroup->addToGroup(item);
 972         item->setFlags(QGraphicsItem::ItemIsSelectable);
 973         //TODO: check if we do not overlap another clip when first dropping in timeline
 974         // if (insertPossible(m_selectionGroup, event->pos()))
 975         QList <GenTime> offsetList;
 976         offsetList.append(info.endPos);
 977         updateSnapPoints(NULL, offsetList);
 978         scene()->addItem(m_selectionGroup);
 979         event->acceptProposedAction();
 980     } else if (event->mimeData()->hasFormat("kdenlive/producerslist")) {
 981         m_clipDrag = true;
 982         QStringList ids = QString(event->mimeData()->data("kdenlive/producerslist")).split(';');
 983         m_scene->clearSelection();
 984         resetSelectionGroup(false);
 985
 986         m_selectionGroup = new AbstractGroupItem(m_document->fps());
 987         QPoint pos = QPoint();
 988         GenTime start = GenTime();
 989         QList <GenTime> offsetList;
 990         for (int i = 0; i < ids.size(); ++i) {
 991             DocClipBase *clip = m_document->getBaseClip(ids.at(i));
 992             if (clip == NULL) kDebug() << " WARNING))))))))) CLIP NOT FOUND : " << ids.at(i);
 993             ItemInfo info;
 994             info.startPos = start;
 995             info.endPos = info.startPos + clip->duration();
 996             info.track = (int)(1 / m_tracksHeight);
 997             ClipItem *item = new ClipItem(clip, info, m_document->fps(), 1.0);
 998             start += clip->duration();
 999             offsetList.append(start);
1000             m_selectionGroup->addToGroup(item);
1001             item->setFlags(QGraphicsItem::ItemIsSelectable);
1002         }
1003         //TODO: check if we do not overlap another clip when first dropping in timeline
1004         //if (insertPossible(m_selectionGroup, event->pos()))
1005         updateSnapPoints(NULL, offsetList);
1006         scene()->addItem(m_selectionGroup);
1007         event->acceptProposedAction();
1008     } else {
1009         // the drag is not a clip (may be effect, ...)
1010         m_clipDrag = false;
1011         QGraphicsView::dragEnterEvent(event);
1012     }
1013 }
1014
1015
1016 bool CustomTrackView::insertPossible(AbstractGroupItem *group, const QPoint &pos) const {
1017     QPolygonF path;
1018     QList<QGraphicsItem *> children = group->childItems();
1019     for (int i = 0; i < children.count(); i++) {
1020         if (children.at(i)->type() == AVWIDGET) {
1021             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
1022             ItemInfo info = clip->info();
1023             kDebug() << " / / INSERT : " << pos.x();
1024             QRectF shape = QRectF(clip->startPos().frames(m_document->fps()), clip->track() * m_tracksHeight + 1, clip->duration().frames(m_document->fps()) - 0.02, m_tracksHeight - 1);
1025             kDebug() << " / / INSERT RECT: " << shape;
1026             path = path.united(QPolygonF(shape));
1027         }
1028     }
1029
1030     QList<QGraphicsItem*> collindingItems = scene()->items(path, Qt::IntersectsItemShape);
1031     if (collindingItems.isEmpty()) return true;
1032     else {
1033         for (int i = 0; i < collindingItems.count(); i++) {
1034             QGraphicsItem *collision = collindingItems.at(i);
1035             if (collision->type() == AVWIDGET) {
1036                 // Collision
1037                 kDebug() << "// COLLISIION DETECTED";
1038                 return false;
1039             }
1040         }
1041         return true;
1042     }
1043
1044 }
1045
1046 void CustomTrackView::slotRefreshEffects(ClipItem *clip) {
1047     int track = m_document->tracksCount() - clip->track();
1048     GenTime pos = clip->startPos();
1049     if (!m_document->renderer()->mltRemoveEffect(track, pos, "-1", false, false)) {
1050         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1051         return;
1052     }
1053     bool success = true;
1054     for (int i = 0; i < clip->effectsCount(); i++) {
1055         if (!m_document->renderer()->mltAddEffect(track, pos, clip->getEffectArgs(clip->effectAt(i)), false)) success = false;
1056     }
1057     if (!success) emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1058     m_document->renderer()->doRefresh();
1059 }
1060
1061 void CustomTrackView::addEffect(int track, GenTime pos, QDomElement effect) {
1062     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1063     if (clip) {
1064         if (!m_document->renderer()->mltAddEffect(track, pos, clip->addEffect(effect)))
1065             emit displayMessage(i18n("Problem adding effect to clip"), ErrorMessage);
1066         emit clipItemSelected(clip);
1067     } else emit displayMessage(i18n("Cannot find clip to add effect"), ErrorMessage);
1068 }
1069
1070 void CustomTrackView::deleteEffect(int track, GenTime pos, QDomElement effect) {
1071     QString index = effect.attribute("kdenlive_ix");
1072     if (!m_document->renderer()->mltRemoveEffect(track, pos, index, true) && effect.attribute("disabled") != "1") {
1073         kDebug() << "// ERROR REMOV EFFECT: " << index << ", DISABLE: " << effect.attribute("disabled");
1074         emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1075         return;
1076     }
1077     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1078     if (clip) {
1079         clip->deleteEffect(index);
1080         emit clipItemSelected(clip);
1081     }
1082 }
1083
1084 void CustomTrackView::slotAddGroupEffect(QDomElement effect, AbstractGroupItem *group) {
1085     QList<QGraphicsItem *> itemList = group->childItems();
1086     QUndoCommand *effectCommand = new QUndoCommand();
1087     QString effectName;
1088     QDomNode namenode = effect.elementsByTagName("name").item(0);
1089     if (!namenode.isNull()) effectName = i18n(namenode.toElement().text().toUtf8().data());
1090     else effectName = i18n("effect");
1091     effectCommand->setText(i18n("Add %1", effectName));
1092     int count = 0;
1093     for (int i = 0; i < itemList.count(); i++) {
1094         if (itemList.at(i)->type() == AVWIDGET) {
1095             ClipItem *item = (ClipItem *)itemList.at(i);
1096             if (item->hasEffect(effect.attribute("tag"), effect.attribute("id")) != -1 && effect.attribute("unique", "0") != "0") {
1097                 emit displayMessage(i18n("Effect already present in clip"), ErrorMessage);
1098                 continue;
1099             }
1100             if (item->isItemLocked()) {
1101                 continue;
1102             }
1103             item->initEffect(effect);
1104             if (effect.attribute("tag") == "ladspa") {
1105                 QString ladpsaFile = m_document->getLadspaFile();
1106                 initEffects::ladspaEffectFile(ladpsaFile, effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1107                 effect.setAttribute("src", ladpsaFile);
1108             }
1109             new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), effect, true, effectCommand);
1110             count++;
1111         }
1112     }
1113     if (count > 0) {
1114         m_commandStack->push(effectCommand);
1115         m_document->setModified(true);
1116     } else delete effectCommand;
1117 }
1118
1119 void CustomTrackView::slotAddEffect(QDomElement effect, GenTime pos, int track) {
1120     QList<QGraphicsItem *> itemList;
1121     QUndoCommand *effectCommand = new QUndoCommand();
1122     QString effectName;
1123     QDomNode namenode = effect.elementsByTagName("name").item(0);
1124     if (!namenode.isNull()) effectName = i18n(namenode.toElement().text().toUtf8().data());
1125     else effectName = i18n("effect");
1126     effectCommand->setText(i18n("Add %1", effectName));
1127     int count = 0;
1128     if (track == -1) itemList = scene()->selectedItems();
1129     if (itemList.isEmpty()) {
1130         ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, track);
1131         if (clip) itemList.append(clip);
1132         else emit displayMessage(i18n("Select a clip if you want to apply an effect"), ErrorMessage);
1133     }
1134     kDebug() << "// REQUESTING EFFECT ON CLIP: " << pos.frames(25) << ", TRK: " << track << "SELECTED ITEMS: " << itemList.count();
1135     for (int i = 0; i < itemList.count(); i++) {
1136         if (itemList.at(i)->type() == AVWIDGET) {
1137             ClipItem *item = (ClipItem *)itemList.at(i);
1138             if (item->hasEffect(effect.attribute("tag"), effect.attribute("id")) != -1 && effect.attribute("unique", "0") != "0") {
1139                 emit displayMessage(i18n("Effect already present in clip"), ErrorMessage);
1140                 continue;
1141             }
1142             if (item->isItemLocked()) {
1143                 continue;
1144             }
1145             item->initEffect(effect);
1146             if (effect.attribute("tag") == "ladspa") {
1147                 QString ladpsaFile = m_document->getLadspaFile();
1148                 initEffects::ladspaEffectFile(ladpsaFile, effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1149                 effect.setAttribute("src", ladpsaFile);
1150             }
1151             new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), effect, true, effectCommand);
1152             count++;
1153         }
1154     }
1155     if (count > 0) {
1156         m_commandStack->push(effectCommand);
1157         m_document->setModified(true);
1158     } else delete effectCommand;
1159 }
1160
1161 void CustomTrackView::slotDeleteEffect(ClipItem *clip, QDomElement effect) {
1162     AddEffectCommand *command = new AddEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), effect, false);
1163     m_commandStack->push(command);
1164     m_document->setModified(true);
1165 }
1166
1167 void CustomTrackView::updateEffect(int track, GenTime pos, QDomElement effect, int ix, bool triggeredByUser) {
1168     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1169     if (clip) {
1170         EffectsParameterList effectParams = clip->getEffectArgs(effect);
1171         if (effect.attribute("tag") == "ladspa") {
1172             // Update the ladspa affect file
1173             initEffects::ladspaEffectFile(effect.attribute("src"), effect.attribute("ladspaid").toInt(), getLadspaParams(effect));
1174         }
1175         // check if we are trying to reset a keyframe effect
1176         if (effectParams.hasParam("keyframes") && effectParams.paramValue("keyframes").isEmpty()) {
1177             clip->initEffect(effect);
1178             clip->setEffectAt(ix, effect);
1179             effectParams = clip->getEffectArgs(effect);
1180         }
1181         if (effectParams.paramValue("disabled") == "1") {
1182             if (m_document->renderer()->mltRemoveEffect(track, pos, effectParams.paramValue("kdenlive_ix"), false)) {
1183                 kDebug() << "//////  DISABLING EFFECT: " << ix << ", CURRENTLA: " << clip->selectedEffectIndex();
1184             } else emit displayMessage(i18n("Problem deleting effect"), ErrorMessage);
1185         } else if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - clip->track(), clip->startPos(), effectParams))
1186             emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
1187
1188         clip->setEffectAt(ix, effect);
1189         if (ix == clip->selectedEffectIndex()) {
1190             clip->setSelectedEffect(ix);
1191             if (!triggeredByUser) emit clipItemSelected(clip, ix);
1192         }
1193         if (effect.attribute("tag") == "volume" || effect.attribute("tag") == "brightness") {
1194             // A fade effect was modified, update the clip
1195             if (effect.attribute("id") == "fadein" || effect.attribute("id") == "fade_from_black") {
1196                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1197                 clip->setFadeIn(pos);
1198             }
1199             if (effect.attribute("id") == "fadeout" || effect.attribute("id") == "fade_to_black") {
1200                 int pos = effectParams.paramValue("out").toInt() - effectParams.paramValue("in").toInt();
1201                 clip->setFadeOut(pos);
1202             }
1203
1204         }
1205     }
1206     m_document->setModified(true);
1207 }
1208
1209 void CustomTrackView::moveEffect(int track, GenTime pos, int oldPos, int newPos) {
1210     ClipItem *clip = getClipItemAt((int)pos.frames(m_document->fps()) + 1, m_document->tracksCount() - track);
1211     if (clip) {
1212         m_document->renderer()->mltMoveEffect(track, pos, oldPos, newPos);
1213         QDomElement act = clip->effectAt(newPos - 1).cloneNode().toElement();
1214         QDomElement before = clip->effectAt(oldPos - 1).cloneNode().toElement();
1215         clip->setEffectAt(oldPos - 1, act);
1216         clip->setEffectAt(newPos - 1, before);
1217         emit clipItemSelected(clip, newPos - 1);
1218     }
1219     m_document->setModified(true);
1220 }
1221
1222 void CustomTrackView::slotChangeEffectState(ClipItem *clip, int effectPos, bool disable) {
1223     QDomElement effect = clip->effectAt(effectPos);
1224     QDomElement oldEffect = effect.cloneNode().toElement();
1225     effect.setAttribute("disabled", disable);
1226     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldEffect, effect, effectPos, true);
1227     m_commandStack->push(command);
1228     m_document->setModified(true);
1229 }
1230
1231 void CustomTrackView::slotChangeEffectPosition(ClipItem *clip, int currentPos, int newPos) {
1232     MoveEffectCommand *command = new MoveEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), currentPos, newPos, true);
1233     m_commandStack->push(command);
1234     m_document->setModified(true);
1235 }
1236
1237 void CustomTrackView::slotUpdateClipEffect(ClipItem *clip, QDomElement oldeffect, QDomElement effect, int ix) {
1238     EditEffectCommand *command = new EditEffectCommand(this, m_document->tracksCount() - clip->track(), clip->startPos(), oldeffect, effect, ix, true);
1239     m_commandStack->push(command);
1240 }
1241
1242 void CustomTrackView::cutClip(ItemInfo info, GenTime cutTime, bool cut) {
1243     if (cut) {
1244         // cut clip
1245         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
1246         if (!item || cutTime >= item->endPos() || cutTime <= item->startPos()) {
1247             emit displayMessage(i18n("Cannot find clip to cut"), ErrorMessage);
1248             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);
1249             m_blockRefresh = false;
1250             return;
1251         }
1252         if (item->parentItem()) {
1253             // Item is part of a group, reset group
1254             resetSelectionGroup();
1255         }
1256         kDebug() << "/////////  CUTTING CLIP : (" << item->startPos().frames(25) << "-" << item->endPos().frames(25) << "), INFO: (" << info.startPos.frames(25) << "-" << info.endPos.frames(25) << ")" << ", CUT: " << cutTime.frames(25);
1257
1258         m_document->renderer()->mltCutClip(m_document->tracksCount() - info.track, cutTime);
1259         int cutPos = (int) cutTime.frames(m_document->fps());
1260         ItemInfo newPos;
1261         double speed = item->speed();
1262         newPos.startPos = cutTime;
1263         newPos.endPos = info.endPos;
1264         if (speed == 1) newPos.cropStart = item->info().cropStart + (cutTime - info.startPos);
1265         else newPos.cropStart = item->info().cropStart + (cutTime - info.startPos) * speed;
1266         newPos.track = info.track;
1267         ClipItem *dup = item->clone(newPos);
1268         item->resizeEnd(cutPos, false);
1269         scene()->addItem(dup);
1270         if (item->checkKeyFrames()) slotRefreshEffects(item);
1271         if (dup->checkKeyFrames()) slotRefreshEffects(dup);
1272         item->baseClip()->addReference();
1273         m_document->updateClip(item->baseClip()->getId());
1274         kDebug() << "/////////  CUTTING CLIP RESULT: (" << item->startPos().frames(25) << "-" << item->endPos().frames(25) << "), DUP: (" << dup->startPos().frames(25) << "-" << dup->endPos().frames(25) << ")" << ", CUT: " << cutTime.frames(25);
1275         kDebug() << "//  CUTTING CLIP dONE";
1276     } else {
1277         // uncut clip
1278
1279         ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()), info.track);
1280         ClipItem *dup = getClipItemAt((int) cutTime.frames(m_document->fps()) + 1, info.track);
1281         if (!item || !dup || item == dup) {
1282             emit displayMessage(i18n("Cannot find clip to uncut"), ErrorMessage);
1283             m_blockRefresh = false;
1284             return;
1285         }
1286         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, cutTime) == false) {
1287             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(cutTime.frames(m_document->fps())), info.track), ErrorMessage);
1288             return;
1289         }
1290
1291         kDebug() << "// UNCUTTING CLIPS: ITEM 1 (" << item->startPos().frames(25) << "x" << item->endPos().frames(25) << ")";
1292         kDebug() << "// UNCUTTING CLIPS: ITEM 2 (" << dup->startPos().frames(25) << "x" << dup->endPos().frames(25) << ")";
1293         kDebug() << "// UNCUTTING CLIPS, INFO (" << info.startPos.frames(25) << "x" << info.endPos.frames(25) << ") , CUT: " << cutTime.frames(25);;
1294         //deleteClip(dup->info());
1295
1296
1297         if (dup->isSelected()) emit clipItemSelected(NULL);
1298         dup->baseClip()->removeReference();
1299         m_document->updateClip(dup->baseClip()->getId());
1300         scene()->removeItem(dup);
1301         delete dup;
1302
1303         ItemInfo clipinfo = item->info();
1304         clipinfo.track = m_document->tracksCount() - clipinfo.track;
1305         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, info.endPos - info.startPos);
1306         if (success) {
1307             item->resizeEnd((int) info.endPos.frames(m_document->fps()));
1308         } else
1309             emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
1310
1311     }
1312     QTimer::singleShot(3000, this, SLOT(slotEnableRefresh()));
1313 }
1314
1315 void CustomTrackView::slotEnableRefresh() {
1316     m_blockRefresh = false;
1317 }
1318
1319 void CustomTrackView::slotAddTransitionToSelectedClips(QDomElement transition) {
1320     QList<QGraphicsItem *> itemList = scene()->selectedItems();
1321     if (itemList.count() == 1) {
1322         if (itemList.at(0)->type() == AVWIDGET) {
1323             ClipItem *item = (ClipItem *) itemList.at(0);
1324             ItemInfo info;
1325             info.track = item->track();
1326             ClipItem *transitionClip = NULL;
1327             const int transitiontrack = getPreviousVideoTrack(info.track);
1328             GenTime pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1329             if (pos < item->startPos() + item->duration() / 2) {
1330                 // add transition to clip start
1331                 info.startPos = item->startPos();
1332                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.startPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1333                 if (transitionClip && transitionClip->endPos() < item->endPos()) {
1334                     info.endPos = transitionClip->endPos();
1335                 } else info.endPos = info.startPos + GenTime(65, m_document->fps());
1336                 // Check there is no other transition at that place
1337                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1338                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1339                 QList<QGraphicsItem *> selection = m_scene->items(r);
1340                 bool transitionAccepted = true;
1341                 for (int i = 0; i < selection.count(); i++) {
1342                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1343                         Transition *tr = static_cast <Transition *>(selection.at(i));
1344                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1345                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1346                         } else transitionAccepted = false;
1347                     }
1348                 }
1349                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1350                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1351
1352             } else {
1353                 // add transition to clip  end
1354                 info.endPos = item->endPos();
1355                 if (transitiontrack != 0) transitionClip = getClipItemAt((int) info.endPos.frames(m_document->fps()), m_document->tracksCount() - transitiontrack);
1356                 if (transitionClip && transitionClip->startPos() > item->startPos()) {
1357                     info.startPos = transitionClip->startPos();
1358                 } else info.startPos = info.endPos - GenTime(65, m_document->fps());
1359                 if (transition.attribute("tag") == "luma") EffectsList::setParameter(transition, "reverse", "1");
1360
1361                 // Check there is no other transition at that place
1362                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1363                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1364                 QList<QGraphicsItem *> selection = m_scene->items(r);
1365                 bool transitionAccepted = true;
1366                 for (int i = 0; i < selection.count(); i++) {
1367                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1368                         Transition *tr = static_cast <Transition *>(selection.at(i));
1369                         if (info.endPos - tr->endPos() > GenTime(5, m_document->fps())) {
1370                             if (tr->endPos() > info.startPos) info.startPos = tr->endPos();
1371                         } else transitionAccepted = false;
1372                     }
1373                 }
1374                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1375                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1376             }
1377         }
1378     } else for (int i = 0; i < itemList.count(); i++) {
1379             if (itemList.at(i)->type() == AVWIDGET) {
1380                 ClipItem *item = (ClipItem *) itemList.at(i);
1381                 ItemInfo info;
1382                 info.startPos = item->startPos();
1383                 info.endPos = info.startPos + GenTime(65, m_document->fps());
1384                 info.track = item->track();
1385
1386                 // Check there is no other transition at that place
1387                 double startY = info.track * m_tracksHeight + 1 + m_tracksHeight / 2;
1388                 QRectF r(info.startPos.frames(m_document->fps()), startY, (info.endPos - info.startPos).frames(m_document->fps()), m_tracksHeight / 2);
1389                 QList<QGraphicsItem *> selection = m_scene->items(r);
1390                 bool transitionAccepted = true;
1391                 for (int i = 0; i < selection.count(); i++) {
1392                     if (selection.at(i)->type() == TRANSITIONWIDGET) {
1393                         Transition *tr = static_cast <Transition *>(selection.at(i));
1394                         if (tr->startPos() - info.startPos > GenTime(5, m_document->fps())) {
1395                             if (tr->startPos() < info.endPos) info.endPos = tr->startPos();
1396                         } else transitionAccepted = false;
1397                     }
1398                 }
1399                 int transitiontrack = getPreviousVideoTrack(info.track);
1400                 if (transitionAccepted) slotAddTransition(item, info, transitiontrack, transition);
1401                 else emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1402             }
1403         }
1404 }
1405
1406 void CustomTrackView::slotAddTransition(ClipItem* /*clip*/, ItemInfo transitionInfo, int endTrack, QDomElement transition) {
1407     if (transitionInfo.startPos >= transitionInfo.endPos) {
1408         emit displayMessage(i18n("Invalid transition"), ErrorMessage);
1409         return;
1410     }
1411     AddTransitionCommand* command = new AddTransitionCommand(this, transitionInfo, endTrack, transition, false, true);
1412     m_commandStack->push(command);
1413     m_document->setModified(true);
1414 }
1415
1416 void CustomTrackView::addTransition(ItemInfo transitionInfo, int endTrack, QDomElement params) {
1417     Transition *tr = new Transition(transitionInfo, endTrack, m_document->fps(), params, true);
1418     //kDebug() << "---- ADDING transition " << params.attribute("value");
1419     if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, tr->toXML())) {
1420         scene()->addItem(tr);
1421         m_document->setModified(true);
1422     } else {
1423         emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1424         delete tr;
1425     }
1426 }
1427
1428 void CustomTrackView::deleteTransition(ItemInfo transitionInfo, int endTrack, QDomElement /*params*/) {
1429     Transition *item = getTransitionItemAt(transitionInfo.startPos, transitionInfo.track);
1430     if (!item) {
1431         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
1432         return;
1433     }
1434     m_document->renderer()->mltDeleteTransition(item->transitionTag(), endTrack, m_document->tracksCount() - transitionInfo.track, transitionInfo.startPos, transitionInfo.endPos, item->toXML());
1435     if (m_dragItem == item) m_dragItem = NULL;
1436     delete item;
1437     emit transitionItemSelected(NULL);
1438     m_document->setModified(true);
1439 }
1440
1441 void CustomTrackView::slotTransitionUpdated(Transition *tr, QDomElement old) {
1442     kDebug() << "TRANS UPDATE, TRACKS: " << old.attribute("transition_btrack") << ", NEW: " << tr->toXML().attribute("transition_btrack");
1443     EditTransitionCommand *command = new EditTransitionCommand(this, tr->track(), tr->startPos(), old, tr->toXML(), false);
1444     m_commandStack->push(command);
1445     m_document->setModified(true);
1446 }
1447
1448 void CustomTrackView::updateTransition(int track, GenTime pos, QDomElement oldTransition, QDomElement transition, bool updateTransitionWidget) {
1449     Transition *item = getTransitionItemAt(pos, track);
1450     if (!item) {
1451         kWarning() << "Unable to find transition at pos :" << pos.frames(m_document->fps()) << ", ON track: " << track;
1452         return;
1453     }
1454     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);
1455     //kDebug() << "ORIGINAL TRACK: "<< oldTransition.attribute("transition_btrack") << ", NEW TRACK: "<<transition.attribute("transition_btrack");
1456     item->setTransitionParameters(transition);
1457     if (updateTransitionWidget) emit transitionItemSelected(item, true);
1458     m_document->setModified(true);
1459 }
1460
1461 void CustomTrackView::dragMoveEvent(QDragMoveEvent * event) {
1462     event->setDropAction(Qt::IgnoreAction);
1463     const QPointF pos = mapToScene(event->pos());
1464     if (m_selectionGroup && m_clipDrag) {
1465         m_selectionGroup->setPos(pos.x(), pos.y());
1466         event->setDropAction(Qt::MoveAction);
1467         event->acceptProposedAction();
1468     } else {
1469         QGraphicsView::dragMoveEvent(event);
1470     }
1471 }
1472
1473 void CustomTrackView::dragLeaveEvent(QDragLeaveEvent * event) {
1474     if (m_selectionGroup && m_clipDrag) {
1475         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1476         qDeleteAll(items);
1477         scene()->destroyItemGroup(m_selectionGroup);
1478         m_selectionGroup = NULL;
1479     } else QGraphicsView::dragLeaveEvent(event);
1480 }
1481
1482 void CustomTrackView::dropEvent(QDropEvent * event) {
1483     if (m_selectionGroup && m_clipDrag) {
1484         QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1485         resetSelectionGroup();
1486         m_scene->clearSelection();
1487         bool hasVideoClip = false;
1488         for (int i = 0; i < items.count(); i++) {
1489             ClipItem *item = static_cast <ClipItem *>(items.at(i));
1490             if (!hasVideoClip && (item->clipType() == AV || item->clipType() == VIDEO)) hasVideoClip = true;
1491             AddTimelineClipCommand *command = new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, false);
1492             m_commandStack->push(command);
1493             item->baseClip()->addReference();
1494             m_document->updateClip(item->baseClip()->getId());
1495             ItemInfo info = item->info();
1496
1497             int tracknumber = m_document->tracksCount() - info.track - 1;
1498             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
1499             if (isLocked) item->setItemLocked(true);
1500
1501             if (item->baseClip()->isTransparent()) {
1502                 // add transparency transition
1503                 int endTrack = getPreviousVideoTrack(info.track);
1504                 Transition *tr = new Transition(info, endTrack, m_document->fps(), MainWindow::transitions.getEffectByTag("composite", "composite"), true);
1505                 if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML())) {
1506                     scene()->addItem(tr);
1507                 } else {
1508                     emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
1509                     delete tr;
1510                 }
1511             }
1512             info.track = m_document->tracksCount() - item->track();
1513             m_document->renderer()->mltInsertClip(info, item->xml(), item->baseClip()->producer(item->track()));
1514             item->setSelected(true);
1515         }
1516         m_changeSpeedAction->setEnabled(hasVideoClip);
1517         m_pasteEffectsAction->setEnabled(m_copiedItems.count() == 1);
1518         groupSelectedItems(true);
1519         m_document->setModified(true);
1520     } else QGraphicsView::dropEvent(event);
1521     setFocus();
1522 }
1523
1524
1525 QStringList CustomTrackView::mimeTypes() const {
1526     QStringList qstrList;
1527     // list of accepted mime types for drop
1528     qstrList.append("text/plain");
1529     qstrList.append("kdenlive/producerslist");
1530     qstrList.append("kdenlive/clip");
1531     return qstrList;
1532 }
1533
1534 Qt::DropActions CustomTrackView::supportedDropActions() const {
1535     // returns what actions are supported when dropping
1536     return Qt::MoveAction;
1537 }
1538
1539 void CustomTrackView::setDuration(int duration) {
1540     if (duration > sceneRect().width())
1541         setSceneRect(0, 0, (duration + 100), sceneRect().height());
1542     m_projectDuration = duration;
1543 }
1544
1545 int CustomTrackView::duration() const {
1546     return m_projectDuration;
1547 }
1548
1549 void CustomTrackView::addTrack(TrackInfo type, int ix) {
1550     if (ix == -1) m_document->insertTrack(ix, type);
1551     else {
1552         m_document->insertTrack(m_document->tracksCount() - ix, type);
1553         // insert track in MLT playlist
1554         m_document->renderer()->mltInsertTrack(m_document->tracksCount() - ix, type.type == VIDEOTRACK);
1555
1556         double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1557         QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1558         QList<QGraphicsItem *> selection = m_scene->items(r);
1559         resetSelectionGroup();
1560
1561         m_selectionGroup = new AbstractGroupItem(m_document->fps());
1562         scene()->addItem(m_selectionGroup);
1563         for (int i = 0; i < selection.count(); i++) {
1564             if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET)
1565                 m_selectionGroup->addToGroup(selection.at(i));
1566             selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1567         }
1568         // Move graphic items
1569         m_selectionGroup->translate(0, m_tracksHeight);
1570
1571         // adjust track number
1572         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1573         for (int i = 0; i < children.count(); i++) {
1574             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
1575             item->updateItem();
1576             ItemInfo clipinfo = item->info();
1577             if (item->type() == AVWIDGET) {
1578                 ClipItem *clip = static_cast <ClipItem *>(item);
1579                 // We add a move clip command so that we get the correct producer for new track number
1580                 if (clip->clipType() == AV || clip->clipType() == AUDIO) {
1581                     m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), clip->baseClip()->producer(clipinfo.track));
1582                     kDebug() << "// UPDATING CLIP TO TRACK PROD: " << clipinfo.track;
1583                 }
1584             } else if (item->type() == TRANSITIONWIDGET) {
1585                 Transition *tr = static_cast <Transition *>(item);
1586                 int track = tr->transitionEndTrack();
1587                 if (track >= ix) {
1588                     tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1589                 }
1590             }
1591         }
1592         resetSelectionGroup(false);
1593
1594     }
1595     int maxHeight = m_tracksHeight * m_document->tracksCount();
1596     for (int i = 0; i < m_guides.count(); i++) {
1597         QLineF l = m_guides.at(i)->line();
1598         l.setP2(QPointF(l.x2(), maxHeight));
1599         m_guides.at(i)->setLine(l);
1600     }
1601     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
1602     setSceneRect(0, 0, sceneRect().width(), maxHeight);
1603     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1604     viewport()->update();
1605     //setFixedHeight(50 * m_tracksCount);
1606 }
1607
1608 void CustomTrackView::removeTrack(int ix) {
1609     // Delete track in MLT playlist
1610     m_document->renderer()->mltDeleteTrack(m_document->tracksCount() - ix);
1611     m_document->deleteTrack(m_document->tracksCount() - ix - 1);
1612
1613     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
1614     QRectF r(0, startY, sceneRect().width(), sceneRect().height() - startY);
1615     QList<QGraphicsItem *> selection = m_scene->items(r);
1616
1617     resetSelectionGroup();
1618
1619     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1620     scene()->addItem(m_selectionGroup);
1621     for (int i = 0; i < selection.count(); i++) {
1622         if (selection.at(i)->type() == AVWIDGET || selection.at(i)->type() == TRANSITIONWIDGET) {
1623             m_selectionGroup->addToGroup(selection.at(i));
1624             selection.at(i)->setFlags(QGraphicsItem::ItemIsSelectable);
1625         }
1626     }
1627     // Move graphic items
1628     qreal ydiff = 0 - (int) m_tracksHeight;
1629     m_selectionGroup->translate(0, ydiff);
1630
1631     // adjust track number
1632     QList<QGraphicsItem *> children = m_selectionGroup->childItems();
1633     //kDebug() << "// FOUND CLIPS TO MOVE: " << children.count();
1634     for (int i = 0; i < children.count(); i++) {
1635         if (children.at(i)->type() == AVWIDGET) {
1636             ClipItem *clip = static_cast <ClipItem *>(children.at(i));
1637             clip->updateItem();
1638             ItemInfo clipinfo = clip->info();
1639             kDebug() << "// CLIP TRK IS: " << clipinfo.track;
1640             // We add a move clip command so that we get the correct producer for new track number
1641             if (clip->clipType() == AV || clip->clipType() == AUDIO)
1642                 m_document->renderer()->mltUpdateClipProducer((int)(m_document->tracksCount() - clipinfo.track), clipinfo.startPos.frames(m_document->fps()), clip->baseClip()->producer(clipinfo.track));
1643         } else if (children.at(i)->type() == TRANSITIONWIDGET) {
1644             Transition *tr = static_cast <Transition *>(children.at(i));
1645             tr->updateItem();
1646             int track = tr->transitionEndTrack();
1647             if (track >= ix) {
1648                 ItemInfo clipinfo = tr->info();
1649                 tr->updateTransitionEndTrack(getPreviousVideoTrack(clipinfo.track));
1650             }
1651         }
1652     }
1653     resetSelectionGroup(false);
1654
1655     int maxHeight = m_tracksHeight * m_document->tracksCount();
1656     for (int i = 0; i < m_guides.count(); i++) {
1657         QLineF l = m_guides.at(i)->line();
1658         l.setP2(QPointF(l.x2(), maxHeight));
1659         m_guides.at(i)->setLine(l);
1660     }
1661     m_cursorLine->setLine(m_cursorLine->line().x1(), 0, m_cursorLine->line().x1(), maxHeight);
1662     setSceneRect(0, 0, sceneRect().width(), maxHeight);
1663     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1664     viewport()->update();
1665 }
1666
1667 void CustomTrackView::changeTrack(int ix, TrackInfo type) {
1668     int tracknumber = m_document->tracksCount() - ix;
1669     m_document->setTrackType(tracknumber - 1, type);
1670     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1671     QTimer::singleShot(300, this, SIGNAL(trackHeightChanged()));
1672     viewport()->update();
1673 }
1674
1675
1676 void CustomTrackView::slotSwitchTrackAudio(int ix) {
1677     /*for (int i = 0; i < m_document->tracksCount(); i++)
1678         kDebug() << "TRK " << i << " STATE: " << m_document->trackInfoAt(i).isMute << m_document->trackInfoAt(i).isBlind;*/
1679     int tracknumber = m_document->tracksCount() - ix;
1680     m_document->switchTrackAudio(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isMute);
1681     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber - 1).isMute << m_document->trackInfoAt(tracknumber - 1).isBlind;
1682     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1683     m_document->setModified(true);
1684 }
1685
1686 void CustomTrackView::slotSwitchTrackLock(int ix) {
1687     int tracknumber = m_document->tracksCount() - ix - 1;
1688     LockTrackCommand *command = new LockTrackCommand(this, ix, !m_document->trackInfoAt(tracknumber).isLocked, true);
1689     m_commandStack->push(command);
1690 }
1691
1692
1693 void CustomTrackView::lockTrack(int ix, bool lock) {
1694     int tracknumber = m_document->tracksCount() - ix - 1;
1695     m_document->switchTrackLock(tracknumber, lock);
1696     emit doTrackLock(ix, lock);
1697     QList<QGraphicsItem *> selection = items(0, ix * m_tracksHeight + m_tracksHeight / 2, mapFromScene(sceneRect().width(), 0).x(), m_tracksHeight / 2 - 2);
1698
1699     for (int i = 0; i < selection.count(); i++) {
1700         if (selection.at(i)->type() != AVWIDGET && selection.at(i)->type() != TRANSITIONWIDGET) continue;
1701         if (selection.at(i)->isSelected()) {
1702             if (selection.at(i)->type() == AVWIDGET) emit clipItemSelected(NULL);
1703             else emit transitionItemSelected(NULL);
1704         }
1705         static_cast <AbstractClipItem *>(selection.at(i))->setItemLocked(lock);
1706     }
1707     kDebug() << "NEXT TRK STATE: " << m_document->trackInfoAt(tracknumber).isLocked;
1708     viewport()->update();
1709     m_document->setModified(true);
1710 }
1711
1712 void CustomTrackView::slotSwitchTrackVideo(int ix) {
1713     int tracknumber = m_document->tracksCount() - ix;
1714     m_document->switchTrackVideo(tracknumber - 1, !m_document->trackInfoAt(tracknumber - 1).isBlind);
1715     m_document->renderer()->mltChangeTrackState(tracknumber, m_document->trackInfoAt(tracknumber - 1).isMute, m_document->trackInfoAt(tracknumber - 1).isBlind);
1716     m_document->setModified(true);
1717 }
1718
1719 void CustomTrackView::slotRemoveSpace() {
1720     GenTime pos;
1721     int track = 0;
1722     if (m_menuPosition.isNull()) {
1723         pos = GenTime(cursorPos(), m_document->fps());
1724         bool ok;
1725         track = QInputDialog::getInteger(this, i18n("Remove Space"), i18n("Track"), 0, 0, m_document->tracksCount() - 1, 1, &ok);
1726         if (!ok) return;
1727     } else {
1728         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1729         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight);
1730     }
1731     ClipItem *item = getClipItemAt(pos, track);
1732     if (item) {
1733         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);
1734         return;
1735     }
1736     int length = m_document->renderer()->mltGetSpaceLength(pos, m_document->tracksCount() - track, true);
1737     //kDebug() << "// GOT LENGT; " << length;
1738     if (length <= 0) {
1739         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);
1740         return;
1741     }
1742
1743     QRectF r(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2, sceneRect().width() - pos.frames(m_document->fps()), m_tracksHeight / 2 - 1);
1744     QList<QGraphicsItem *> items = m_scene->items(r);
1745
1746     QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
1747     QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
1748
1749     for (int i = 0; i < items.count(); i++) {
1750         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
1751             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1752             ItemInfo info = item->info();
1753             if (item->type() == AVWIDGET) {
1754                 clipsToMove.append(info);
1755             } else if (item->type() == TRANSITIONWIDGET) {
1756                 transitionsToMove.append(info);
1757             }
1758         }
1759     }
1760
1761     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, GenTime(-length, m_document->fps()), true);
1762     m_commandStack->push(command);
1763 }
1764
1765 void CustomTrackView::slotInsertSpace() {
1766     GenTime pos;
1767     int track = 0;
1768     if (m_menuPosition.isNull()) {
1769         pos = GenTime(cursorPos(), m_document->fps());
1770     } else {
1771         pos = GenTime((int)(mapToScene(m_menuPosition).x()), m_document->fps());
1772         track = (int)(mapToScene(m_menuPosition).y() / m_tracksHeight) + 1;
1773     }
1774     SpacerDialog d(GenTime(65, m_document->fps()), m_document->timecode(), track, m_document->tracksCount(), this);
1775     if (d.exec() != QDialog::Accepted) return;
1776     GenTime spaceDuration = d.selectedDuration();
1777     track = d.selectedTrack();
1778     ClipItem *item = getClipItemAt(pos, track);
1779     if (item) pos = item->startPos();
1780
1781     int minh = 0;
1782     int maxh = sceneRect().height();
1783     if (track != -1) {
1784         minh = track * m_tracksHeight + m_tracksHeight / 2;
1785         maxh = m_tracksHeight / 2 - 1;
1786     }
1787
1788     QRectF r(pos.frames(m_document->fps()), minh, sceneRect().width() - pos.frames(m_document->fps()), maxh);
1789     QList<QGraphicsItem *> items = m_scene->items(r);
1790
1791     QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
1792     QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
1793
1794     for (int i = 0; i < items.count(); i++) {
1795         if (items.at(i)->type() == AVWIDGET || items.at(i)->type() == TRANSITIONWIDGET) {
1796             AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1797             ItemInfo info = item->info();
1798             if (item->type() == AVWIDGET) {
1799                 clipsToMove.append(info);
1800             } else if (item->type() == TRANSITIONWIDGET) {
1801                 transitionsToMove.append(info);
1802             }
1803         }
1804     }
1805
1806     InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, spaceDuration, true);
1807     m_commandStack->push(command);
1808 }
1809
1810 void CustomTrackView::insertSpace(QList<ItemInfo> clipsToMove, QList<ItemInfo> transToMove, int track, const GenTime duration, const GenTime offset) {
1811     int diff = duration.frames(m_document->fps());
1812     resetSelectionGroup();
1813     m_selectionGroup = new AbstractGroupItem(m_document->fps());
1814     scene()->addItem(m_selectionGroup);
1815     ClipItem *clip;
1816     Transition *transition;
1817
1818     kDebug() << "/// STARTING SPACE INSERT";
1819
1820
1821     // Create lists with start pos for each track
1822     QMap <int, int> trackClipStartList;
1823     QMap <int, int> trackTransitionStartList;
1824
1825     for (int i = 1; i < m_document->tracksCount() + 1; i++) {
1826         trackClipStartList[i] = -1;
1827         trackTransitionStartList[i] = -1;
1828     }
1829
1830     if (!clipsToMove.isEmpty()) for (int i = 0; i < clipsToMove.count(); i++) {
1831             kDebug() << "/// FETCHING CLIP: " << i;
1832             clip = getClipItemAtStart(clipsToMove.at(i).startPos + offset, clipsToMove.at(i).track);
1833             if (clip) {
1834                 m_selectionGroup->addToGroup(clip);
1835                 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))
1836                     trackClipStartList[m_document->tracksCount() - clipsToMove.at(i).track] = clipsToMove.at(i).startPos.frames(m_document->fps());
1837                 clip->setFlags(QGraphicsItem::ItemIsSelectable);
1838             } else emit displayMessage(i18n("Cannot move clip at position %1, track %2", m_document->timecode().getTimecodeFromFrames(clipsToMove.at(i).startPos.frames(m_document->fps())), clipsToMove.at(i).track), ErrorMessage);
1839         }
1840     if (!transToMove.isEmpty()) for (int i = 0; i < transToMove.count(); i++) {
1841             kDebug() << "/// FETCHING TRANS: " << i;
1842             transition = getTransitionItemAtStart(transToMove.at(i).startPos + offset, transToMove.at(i).track);
1843             if (transition) {
1844                 m_selectionGroup->addToGroup(transition);
1845                 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))
1846                     trackTransitionStartList[m_document->tracksCount() - transToMove.at(i).track] = transToMove.at(i).startPos.frames(m_document->fps());
1847                 transition->setFlags(QGraphicsItem::ItemIsSelectable);
1848             } 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);
1849         }
1850     kDebug() << "/// STARTING SPACE DONE";
1851     m_selectionGroup->translate(diff, 0);
1852     resetSelectionGroup(false);
1853     kDebug() << "/// STARTING SPACE DONE2";
1854     if (track != -1) track = m_document->tracksCount() - track;
1855     m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, duration, offset);
1856 }
1857
1858 void CustomTrackView::deleteClip(const QString &clipId) {
1859     QList<QGraphicsItem *> itemList = items();
1860     QUndoCommand *deleteCommand = new QUndoCommand();
1861     deleteCommand->setText(i18n("Delete timeline clips"));
1862     int count = 0;
1863     for (int i = 0; i < itemList.count(); i++) {
1864         if (itemList.at(i)->type() == AVWIDGET) {
1865             ClipItem *item = (ClipItem *)itemList.at(i);
1866             if (item->clipProducer() == clipId) {
1867                 count++;
1868                 new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteCommand);
1869                 //delete item;
1870             }
1871         }
1872     }
1873
1874 }
1875
1876 void CustomTrackView::setCursorPos(int pos, bool seek) {
1877     emit cursorMoved((int)(m_cursorPos), (int)(pos));
1878     m_cursorPos = pos;
1879     m_cursorLine->setPos(pos, 0);
1880     if (seek) m_document->renderer()->seek(GenTime(pos, m_document->fps()));
1881     else if (m_autoScroll) checkScrolling();
1882 }
1883
1884 void CustomTrackView::updateCursorPos() {
1885     m_cursorLine->setPos(m_cursorPos, 0);
1886 }
1887
1888 int CustomTrackView::cursorPos() {
1889     return (int)(m_cursorPos);
1890 }
1891
1892 void CustomTrackView::moveCursorPos(int delta) {
1893     if (m_cursorPos + delta < 0) delta = 0 - m_cursorPos;
1894     emit cursorMoved((int)(m_cursorPos), (int)((m_cursorPos + delta)));
1895     m_cursorPos += delta;
1896     m_cursorLine->setPos(m_cursorPos, 0);
1897     m_document->renderer()->seek(GenTime(m_cursorPos, m_document->fps()));
1898 }
1899
1900 void CustomTrackView::initCursorPos(int pos) {
1901     emit cursorMoved((int)(m_cursorPos), (int)(pos));
1902     m_cursorPos = pos;
1903     m_cursorLine->setPos(pos, 0);
1904     checkScrolling();
1905 }
1906
1907 void CustomTrackView::checkScrolling() {
1908     int vert = verticalScrollBar()->value();
1909     int hor = cursorPos();
1910     ensureVisible(hor, vert + 10, 2, 2, 50, 0);
1911 }
1912
1913 void CustomTrackView::mouseReleaseEvent(QMouseEvent * event) {
1914     if (m_moveOpMode == SEEK) m_moveOpMode = NONE;
1915     QGraphicsView::mouseReleaseEvent(event);
1916     if (m_scrollTimer.isActive()) m_scrollTimer.stop();
1917     if (event->button() == Qt::MidButton) {
1918         return;
1919     }
1920     setDragMode(QGraphicsView::NoDrag);
1921     if (m_operationMode == MOVEGUIDE) {
1922         setCursor(Qt::ArrowCursor);
1923         m_operationMode = NONE;
1924         m_dragGuide->setFlag(QGraphicsItem::ItemIsMovable, false);
1925         EditGuideCommand *command = new EditGuideCommand(this, m_dragGuide->position(), m_dragGuide->label(), GenTime(m_dragGuide->pos().x(), m_document->fps()), m_dragGuide->label(), false);
1926         m_commandStack->push(command);
1927         m_dragGuide->updateGuide(GenTime(m_dragGuide->pos().x(), m_document->fps()));
1928         m_dragGuide = NULL;
1929         m_dragItem = NULL;
1930         return;
1931     } else if (m_operationMode == SPACER) {
1932         int track = (int)(mapToScene(m_clickEvent).y() / m_tracksHeight);
1933         if (m_selectionGroup->sceneBoundingRect().height() > m_tracksHeight) {
1934             // We are moving all tracks
1935             track = -1;
1936         }
1937         GenTime timeOffset = GenTime(m_selectionGroup->scenePos().x(), m_document->fps()) - m_selectionGroupInfo.startPos;
1938         if (timeOffset != GenTime()) {
1939             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
1940
1941             QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
1942             QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
1943
1944             // Create lists with start pos for each track
1945             QMap <int, int> trackClipStartList;
1946             QMap <int, int> trackTransitionStartList;
1947
1948             for (int i = 1; i < m_document->tracksCount() + 1; i++) {
1949                 trackClipStartList[i] = -1;
1950                 trackTransitionStartList[i] = -1;
1951             }
1952
1953             for (int i = 0; i < items.count(); i++) {
1954                 AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
1955                 ItemInfo info = item->info();
1956                 if (item->type() == AVWIDGET) {
1957                     clipsToMove.append(info);
1958                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackClipStartList.value(m_document->tracksCount() - info.track))
1959                         trackClipStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
1960                 } else if (item->type() == TRANSITIONWIDGET) {
1961                     transitionsToMove.append(info);
1962                     if (trackClipStartList.value(m_document->tracksCount() - info.track) == -1 || info.startPos.frames(m_document->fps()) < trackTransitionStartList.value(m_document->tracksCount() - info.track))
1963                         trackTransitionStartList[m_document->tracksCount() - info.track] = info.startPos.frames(m_document->fps());
1964                 }
1965             }
1966
1967             InsertSpaceCommand *command = new InsertSpaceCommand(this, clipsToMove, transitionsToMove, track, timeOffset, false);
1968             m_commandStack->push(command);
1969             if (track != -1) track = m_document->tracksCount() - track;
1970             m_document->renderer()->mltInsertSpace(trackClipStartList, trackTransitionStartList, track, timeOffset, GenTime());
1971         }
1972         resetSelectionGroup(false);
1973         m_operationMode = NONE;
1974     } else if (m_operationMode == RUBBERSELECTION) {
1975         kDebug() << "// END RUBBER SELECT";
1976         resetSelectionGroup();
1977         groupSelectedItems();
1978         m_operationMode = NONE;
1979     }
1980
1981     if (m_dragItem == NULL && m_selectionGroup == NULL) {
1982         emit transitionItemSelected(NULL);
1983         return;
1984     }
1985     ItemInfo info;
1986     if (m_dragItem) info = m_dragItem->info();
1987
1988     if (m_operationMode == MOVE) {
1989         setCursor(Qt::OpenHandCursor);
1990
1991         if (m_selectionGroup == NULL) {
1992             // we are moving one clip, easy
1993             if (m_dragItem->type() == AVWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
1994                 ClipItem *item = static_cast <ClipItem *>(m_dragItem);
1995                 bool success = m_document->renderer()->mltMoveClip((int)(m_document->tracksCount() - m_dragItemInfo.track), (int)(m_document->tracksCount() - m_dragItem->track()), (int) m_dragItemInfo.startPos.frames(m_document->fps()), (int)(m_dragItem->startPos().frames(m_document->fps())), item->baseClip()->producer(info.track));
1996                 if (success) {
1997                     int tracknumber = m_document->tracksCount() - item->track() - 1;
1998                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
1999                     if (isLocked) item->setItemLocked(true);
2000
2001                     QUndoCommand *moveCommand = new QUndoCommand();
2002                     moveCommand->setText(i18n("Move clip"));
2003                     new MoveClipCommand(this, m_dragItemInfo, info, false, moveCommand);
2004                     // Also move automatic transitions (on lower track)
2005                     Transition *tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2006                     if (tr && tr->isAutomatic()) {
2007                         ItemInfo trInfo = tr->info();
2008                         ItemInfo newTrInfo = trInfo;
2009                         newTrInfo.track = info.track;
2010                         newTrInfo.startPos = m_dragItem->startPos();
2011                         if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtEnd(newTrInfo.endPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2012                             // transition end should stay the same
2013                         } else {
2014                             // transition end should be adjusted to clip
2015                             newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2016                         }
2017                         if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2018                     }
2019                     if (tr == NULL || tr->endPos() < m_dragItemInfo.endPos) {
2020                         // Check if there is a transition at clip end
2021                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2022                         if (tr && tr->isAutomatic()) {
2023                             ItemInfo trInfo = tr->info();
2024                             ItemInfo newTrInfo = trInfo;
2025                             newTrInfo.track = info.track;
2026                             newTrInfo.endPos = m_dragItem->endPos();
2027                             if (m_dragItemInfo.track == info.track && !item->baseClip()->isTransparent() && getClipItemAtStart(trInfo.startPos, m_document->tracksCount() - tr->transitionEndTrack())) {
2028                                 // transition start should stay the same
2029                             } else {
2030                                 // transition start should be moved
2031                                 newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2032                             }
2033                             if (newTrInfo.startPos < newTrInfo.endPos)
2034                                 new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2035                         }
2036                     }
2037                     // Also move automatic transitions (on upper track)
2038                     tr = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2039                     if (m_dragItemInfo.track == info.track && tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2040                         ItemInfo trInfo = tr->info();
2041                         ItemInfo newTrInfo = trInfo;
2042                         newTrInfo.startPos = m_dragItem->startPos();
2043                         ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2044                         if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2045                             if (!getClipItemAtEnd(newTrInfo.endPos, tr->track())) {
2046                                 // transition end should be adjusted to clip on upper track
2047                                 newTrInfo.endPos = newTrInfo.endPos + (newTrInfo.startPos - trInfo.startPos);
2048                             }
2049                             if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2050                         }
2051                     }
2052                     if (m_dragItemInfo.track == info.track && (tr == NULL || tr->endPos() < m_dragItemInfo.endPos)) {
2053                         // Check if there is a transition at clip end
2054                         tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2055                         if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2056                             ItemInfo trInfo = tr->info();
2057                             ItemInfo newTrInfo = trInfo;
2058                             newTrInfo.endPos = m_dragItem->endPos();
2059                             ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2060                             if (!upperClip || !upperClip->baseClip()->isTransparent()) {
2061                                 if (!getClipItemAtStart(trInfo.startPos, tr->track())) {
2062                                     // transition start should be moved
2063                                     newTrInfo.startPos = newTrInfo.startPos + (newTrInfo.endPos - trInfo.endPos);
2064                                 }
2065                                 if (newTrInfo.startPos < newTrInfo.endPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, moveCommand);
2066                             }
2067                         }
2068                     }
2069                     m_commandStack->push(moveCommand);
2070                 } else {
2071                     // undo last move and emit error message
2072                     MoveClipCommand *command = new MoveClipCommand(this, info, m_dragItemInfo, true);
2073                     m_commandStack->push(command);
2074                     emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(m_dragItemInfo.startPos.frames(m_document->fps()))), ErrorMessage);
2075                 }
2076             }
2077             if (m_dragItem->type() == TRANSITIONWIDGET && (m_dragItemInfo.startPos != info.startPos || m_dragItemInfo.track != info.track)) {
2078                 Transition *transition = static_cast <Transition *>(m_dragItem);
2079                 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)) {
2080                     // Moving transition failed, revert to previous position
2081                     emit displayMessage(i18n("Cannot move transition"), ErrorMessage);
2082                     transition->setPos((int) m_dragItemInfo.startPos.frames(m_document->fps()), (m_dragItemInfo.track) * m_tracksHeight + 1);
2083                 } else {
2084                     MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2085                     m_commandStack->push(command);
2086                     transition->updateTransitionEndTrack(getPreviousVideoTrack(m_dragItem->track()));
2087                 }
2088             }
2089         } else {
2090             // Moving several clips. We need to delete them and readd them to new position,
2091             // or they might overlap each other during the move
2092
2093             QList<QGraphicsItem *> items = m_selectionGroup->childItems();
2094
2095             QList<ItemInfo> clipsToMove = QList<ItemInfo> ();
2096             QList<ItemInfo> transitionsToMove = QList<ItemInfo> ();
2097
2098             GenTime timeOffset = GenTime(m_selectionGroup->scenePos().x(), m_document->fps()) - m_selectionGroupInfo.startPos;
2099             const int trackOffset = m_selectionGroup->track() - m_selectionGroupInfo.track;
2100             if (timeOffset != GenTime() || trackOffset != 0) {
2101                 QUndoCommand *moveClips = new QUndoCommand();
2102                 moveClips->setText(i18n("Move group"));
2103                 // remove items in MLT playlist
2104                 for (int i = 0; i < items.count(); i++) {
2105                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2106                     ItemInfo info = item->info();
2107                     if (item->type() == AVWIDGET) {
2108                         if (m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2109                             // error, clip cannot be removed from playlist
2110                             emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2111                         } else {
2112                             clipsToMove.append(info);
2113                         }
2114                     } else {
2115                         transitionsToMove.append(info);
2116                         Transition *tr = static_cast <Transition*>(item);
2117                         m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2118                     }
2119                 }
2120
2121                 for (int i = 0; i < items.count(); i++) {
2122                     // re-add items in correct place
2123                     AbstractClipItem *item = static_cast <AbstractClipItem *>(items.at(i));
2124                     item->updateItem();
2125                     ItemInfo info = item->info();
2126                     int tracknumber = m_document->tracksCount() - info.track - 1;
2127                     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2128                     if (isLocked) {
2129                         m_selectionGroup->removeFromGroup(item);
2130                         item->setItemLocked(true);
2131                     }
2132
2133                     if (item->type() == AVWIDGET) {
2134                         ClipItem *clip = static_cast <ClipItem*>(item);
2135                         info.track = m_document->tracksCount() - info.track;
2136                         m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer(info.track));
2137                         for (int i = 0; i < clip->effectsCount(); i++) {
2138                             m_document->renderer()->mltAddEffect(info.track, info.startPos, clip->getEffectArgs(clip->effectAt(i)), false);
2139                         }
2140                     } else {
2141                         Transition *tr = static_cast <Transition*>(item);
2142                         int newTrack = tr->transitionEndTrack();
2143                         if (!tr->forcedTrack()) {
2144                             newTrack = getPreviousVideoTrack(info.track);
2145                         }
2146                         tr->updateTransitionEndTrack(newTrack);
2147                         m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2148                     }
2149                 }
2150
2151                 new MoveGroupCommand(this, clipsToMove, transitionsToMove, timeOffset, trackOffset, false, moveClips);
2152                 m_commandStack->push(moveClips);
2153
2154                 QPointF top = m_selectionGroup->sceneBoundingRect().topLeft();
2155                 //QPointF oldpos = m_selectionGroup->scenePos();
2156                 //kDebug()<<"SELECTION GRP POS: "<<m_selectionGroup->scenePos()<<", TOP: "<<top;
2157                 m_selectionGroup->setPos(top);
2158                 m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2159                 m_selectionGroupInfo.track = m_selectionGroup->track();
2160             }
2161         }
2162
2163     } else if (m_operationMode == RESIZESTART && m_dragItem->startPos() != m_dragItemInfo.startPos) {
2164         // resize start
2165         if (m_dragItem->type() == AVWIDGET) {
2166             ItemInfo resizeinfo = m_dragItemInfo;
2167             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2168             bool success = m_document->renderer()->mltResizeClipStart(resizeinfo, m_dragItem->startPos() - m_dragItemInfo.startPos);
2169             if (success) {
2170                 QUndoCommand *resizeCommand = new QUndoCommand();
2171                 resizeCommand->setText(i18n("Resize clip"));
2172
2173                 // Check if there is an automatic transition on that clip (lower track)
2174                 Transition *transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track);
2175                 if (transition && transition->isAutomatic()) {
2176                     ItemInfo trInfo = transition->info();
2177                     ItemInfo newTrInfo = trInfo;
2178                     newTrInfo.startPos = m_dragItem->startPos();
2179                     if (newTrInfo.startPos < newTrInfo.endPos)
2180                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2181                 }
2182                 // Check if there is an automatic transition on that clip (upper track)
2183                 transition = getTransitionItemAtStart(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2184                 if (transition && transition->isAutomatic() && (m_document->tracksCount() - transition->transitionEndTrack()) == m_dragItemInfo.track) {
2185                     ItemInfo trInfo = transition->info();
2186                     ItemInfo newTrInfo = trInfo;
2187                     newTrInfo.startPos = m_dragItem->startPos();
2188                     ClipItem * upperClip = getClipItemAt(m_dragItemInfo.startPos, m_dragItemInfo.track - 1);
2189                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.startPos < newTrInfo.endPos) {
2190                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2191                     }
2192                 }
2193                 updateClipFade(static_cast <ClipItem *>(m_dragItem));
2194                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2195                 m_commandStack->push(resizeCommand);
2196             } else {
2197                 m_dragItem->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2198                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2199             }
2200         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2201             Transition *transition = static_cast <Transition *>(m_dragItem);
2202             if (!m_document->renderer()->mltMoveTransition(transition->transitionTag(), (int)(m_document->tracksCount() - m_dragItemInfo.track), (int)(m_document->tracksCount() - m_dragItemInfo.track), transition->transitionEndTrack(), m_dragItemInfo.startPos, m_dragItemInfo.endPos, info.startPos, info.endPos)) {
2203                 // Cannot resize transition
2204                 transition->resizeStart((int) m_dragItemInfo.startPos.frames(m_document->fps()));
2205                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2206             } else {
2207                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2208                 m_commandStack->push(command);
2209             }
2210
2211         }
2212
2213         //m_document->renderer()->doRefresh();
2214     } else if (m_operationMode == RESIZEEND && m_dragItem->endPos() != m_dragItemInfo.endPos) {
2215         // resize end
2216         if (m_dragItem->type() == AVWIDGET) {
2217             ItemInfo resizeinfo = info;
2218             resizeinfo.track = m_document->tracksCount() - resizeinfo.track;
2219             bool success = m_document->renderer()->mltResizeClipEnd(resizeinfo, resizeinfo.endPos - resizeinfo.startPos);
2220             if (success) {
2221                 QUndoCommand *resizeCommand = new QUndoCommand();
2222                 resizeCommand->setText(i18n("Resize clip"));
2223
2224                 // Check if there is an automatic transition on that clip (lower track)
2225                 Transition *tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track);
2226                 if (tr && tr->isAutomatic()) {
2227                     ItemInfo trInfo = tr->info();
2228                     ItemInfo newTrInfo = trInfo;
2229                     newTrInfo.endPos = m_dragItem->endPos();
2230                     if (newTrInfo.endPos > newTrInfo.startPos) new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2231                 }
2232
2233                 // Check if there is an automatic transition on that clip (upper track)
2234                 tr = getTransitionItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2235                 if (tr && tr->isAutomatic() && (m_document->tracksCount() - tr->transitionEndTrack()) == m_dragItemInfo.track) {
2236                     ItemInfo trInfo = tr->info();
2237                     ItemInfo newTrInfo = trInfo;
2238                     newTrInfo.endPos = m_dragItem->endPos();
2239                     ClipItem * upperClip = getClipItemAtEnd(m_dragItemInfo.endPos, m_dragItemInfo.track - 1);
2240                     if ((!upperClip || !upperClip->baseClip()->isTransparent()) && newTrInfo.endPos > newTrInfo.startPos) {
2241                         new MoveTransitionCommand(this, trInfo, newTrInfo, true, resizeCommand);
2242                     }
2243                 }
2244
2245                 new ResizeClipCommand(this, m_dragItemInfo, info, false, resizeCommand);
2246                 m_commandStack->push(resizeCommand);
2247                 updateClipFade(static_cast <ClipItem *>(m_dragItem), true);
2248             } else {
2249                 m_dragItem->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2250                 emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2251             }
2252         } else if (m_dragItem->type() == TRANSITIONWIDGET) {
2253             Transition *transition = static_cast <Transition *>(m_dragItem);
2254             if (!m_document->renderer()->mltMoveTransition(transition->transitionTag(), (int)(m_document->tracksCount() - m_dragItemInfo.track), (int)(m_document->tracksCount() - m_dragItemInfo.track), 0, m_dragItemInfo.startPos, m_dragItemInfo.endPos, info.startPos, info.endPos)) {
2255                 // Cannot resize transition
2256                 transition->resizeEnd((int) m_dragItemInfo.endPos.frames(m_document->fps()));
2257                 emit displayMessage(i18n("Cannot resize transition"), ErrorMessage);
2258             } else {
2259                 MoveTransitionCommand *command = new MoveTransitionCommand(this, m_dragItemInfo, info, false);
2260                 m_commandStack->push(command);
2261             }
2262         }
2263         //m_document->renderer()->doRefresh();
2264     } else if (m_operationMode == FADEIN) {
2265         // resize fade in effect
2266         ClipItem * item = (ClipItem *) m_dragItem;
2267         int ix = item->hasEffect("volume", "fadein");
2268         if (ix != -1) {
2269             QDomElement oldeffect = item->effectAt(ix);
2270             int start = item->cropStart().frames(m_document->fps());
2271             int end = item->fadeIn();
2272             if (end == 0) {
2273                 slotDeleteEffect(item, oldeffect);
2274             } else {
2275                 end += start;
2276                 QDomElement effect = oldeffect.cloneNode().toElement();
2277                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2278                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2279                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2280                 emit clipItemSelected(item, ix);
2281             }
2282         } else if (item->fadeIn() != 0 && item->hasEffect("", "fade_from_black") == -1) {
2283             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadein").cloneNode().toElement();
2284             EffectsList::setParameter(effect, "out", QString::number(item->fadeIn()));
2285             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2286         }
2287         ix = item->hasEffect("volume", "fade_from_black");
2288         if (ix != -1) {
2289             QDomElement oldeffect = item->effectAt(ix);
2290             int start = item->cropStart().frames(m_document->fps());
2291             int end = item->fadeIn();
2292             if (end == 0) {
2293                 slotDeleteEffect(item, oldeffect);
2294             } else {
2295                 end += start;
2296                 QDomElement effect = oldeffect.cloneNode().toElement();
2297                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2298                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2299                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2300                 emit clipItemSelected(item, ix);
2301             }
2302         }
2303     } else if (m_operationMode == FADEOUT) {
2304         // resize fade in effect
2305         ClipItem * item = (ClipItem *) m_dragItem;
2306         int ix = item->hasEffect("volume", "fadeout");
2307         if (ix != -1) {
2308             QDomElement oldeffect = item->effectAt(ix);
2309             int end = (item->duration() + item->cropStart()).frames(m_document->fps());
2310             int start = item->fadeOut();
2311             if (start == 0) {
2312                 slotDeleteEffect(item, oldeffect);
2313             } else {
2314                 start = end - start;
2315                 QDomElement effect = oldeffect.cloneNode().toElement();
2316                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2317                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2318                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2319                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2320                 emit clipItemSelected(item, ix);
2321             }
2322         } else if (item->fadeOut() != 0 && item->hasEffect("", "fade_to_black") == -1) {
2323             QDomElement effect = MainWindow::audioEffects.getEffectByTag("volume", "fadeout").cloneNode().toElement();
2324             EffectsList::setParameter(effect, "in", QString::number(item->fadeOut()));
2325             EffectsList::setParameter(effect, "out", QString::number(0));
2326             slotAddEffect(effect, m_dragItem->startPos(), m_dragItem->track());
2327         }
2328         ix = item->hasEffect("brightness", "fade_to_black");
2329         if (ix != -1) {
2330             QDomElement oldeffect = item->effectAt(ix);
2331             int end = (item->duration() + item->cropStart()).frames(m_document->fps());
2332             int start = item->fadeOut();
2333             if (start == 0) {
2334                 slotDeleteEffect(item, oldeffect);
2335             } else {
2336                 start = end - start;
2337                 QDomElement effect = oldeffect.cloneNode().toElement();
2338                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2339                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2340                 // kDebug()<<"EDIT FADE OUT : "<<start<<"x"<<end;
2341                 slotUpdateClipEffect(item, effect, oldeffect, ix);
2342                 emit clipItemSelected(item, ix);
2343             }
2344         }
2345     } else if (m_operationMode == KEYFRAME) {
2346         // update the MLT effect
2347         ClipItem * item = (ClipItem *) m_dragItem;
2348         QString previous = item->keyframes(item->selectedEffectIndex());
2349         item->updateKeyframeEffect();
2350         QString next = item->keyframes(item->selectedEffectIndex());
2351         EditKeyFrameCommand *command = new EditKeyFrameCommand(this, item->track(), item->startPos(), item->selectedEffectIndex(), previous, next, false);
2352         m_commandStack->push(command);
2353         updateEffect(m_document->tracksCount() - item->track(), item->startPos(), item->selectedEffect(), item->selectedEffectIndex());
2354     }
2355
2356     emit transitionItemSelected((m_dragItem && m_dragItem->type() == TRANSITIONWIDGET && m_dragItem->isSelected()) ? static_cast <Transition *>(m_dragItem) : NULL);
2357     m_document->setModified(true);
2358     m_operationMode = NONE;
2359 }
2360
2361 void CustomTrackView::deleteClip(ItemInfo info) {
2362     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
2363
2364     if (!item || m_document->renderer()->mltRemoveClip(m_document->tracksCount() - info.track, info.startPos) == false) {
2365         emit displayMessage(i18n("Error removing clip at %1 on track %2", m_document->timecode().getTimecodeFromFrames(info.startPos.frames(m_document->fps())), info.track), ErrorMessage);
2366         return;
2367     }
2368     if (item->isSelected()) emit clipItemSelected(NULL);
2369     item->baseClip()->removeReference();
2370     m_document->updateClip(item->baseClip()->getId());
2371
2372     if (item->baseClip()->isTransparent()) {
2373         // also remove automatic transition
2374         Transition *tr = getTransitionItemAt(info.startPos, info.track);
2375         if (tr && tr->isAutomatic()) {
2376             m_document->renderer()->mltDeleteTransition(tr->transitionTag(), tr->transitionEndTrack(), m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2377             scene()->removeItem(tr);
2378             delete tr;
2379         }
2380     }
2381     scene()->removeItem(item);
2382     if (m_dragItem == item) m_dragItem = NULL;
2383     delete item;
2384     m_document->renderer()->doRefresh();
2385 }
2386
2387 void CustomTrackView::deleteSelectedClips() {
2388     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2389     if (itemList.count() == 0) {
2390         emit displayMessage(i18n("Select clip to delete"), ErrorMessage);
2391         return;
2392     }
2393     QUndoCommand *deleteSelected = new QUndoCommand();
2394     deleteSelected->setText(i18n("Delete selected items"));
2395     bool resetGroup = false;
2396     for (int i = 0; i < itemList.count(); i++) {
2397         if (itemList.at(i)->type() == AVWIDGET) {
2398             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2399             if (item->parentItem()) resetGroup = true;
2400             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), true, true, deleteSelected);
2401         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2402             Transition *item = static_cast <Transition *>(itemList.at(i));
2403             if (item->parentItem()) resetGroup = true;
2404             ItemInfo info;
2405             info.startPos = item->startPos();
2406             info.endPos = item->endPos();
2407             info.track = item->track();
2408             new AddTransitionCommand(this, info, item->transitionEndTrack(), item->toXML(), true, true, deleteSelected);
2409         }
2410     }
2411     m_commandStack->push(deleteSelected);
2412     if (resetGroup) resetSelectionGroup();
2413 }
2414
2415 void CustomTrackView::changeClipSpeed() {
2416     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2417     if (itemList.count() == 0) {
2418         emit displayMessage(i18n("Select clip to change speed"), ErrorMessage);
2419         return;
2420     }
2421     QUndoCommand *changeSelected = new QUndoCommand();
2422     changeSelected->setText("Edit clip speed");
2423     int count = 0;
2424     int percent = -1;
2425     bool ok;
2426     for (int i = 0; i < itemList.count(); i++) {
2427         if (itemList.at(i)->type() == AVWIDGET) {
2428             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2429             ItemInfo info = item->info();
2430             if (percent == -1) percent = QInputDialog::getInteger(this, i18n("Edit Clip Speed"), i18n("New speed (percents)"), item->speed() * 100, 1, 10000, 1, &ok);
2431             if (!ok) break;
2432             double speed = (double) percent / 100.0;
2433             if (item->speed() != speed && (item->clipType() == VIDEO || item->clipType() == AV)) {
2434                 count++;
2435                 new ChangeSpeedCommand(this, info, item->speed(), speed, item->clipProducer(), true, changeSelected);
2436             }
2437         }
2438     }
2439     if (count > 0) m_commandStack->push(changeSelected);
2440     else delete changeSelected;
2441 }
2442
2443 void CustomTrackView::doChangeClipSpeed(ItemInfo info, const double speed, const double oldspeed, const QString &id) {
2444     DocClipBase *baseclip = m_document->clipManager()->getClipById(id);
2445     ClipItem *item = getClipItemAt((int) info.startPos.frames(m_document->fps()) + 1, info.track);
2446     if (!item) {
2447         kDebug() << "ERROR: Cannot find clip for speed change";
2448         emit displayMessage(i18n("Cannot find clip for speed change"), ErrorMessage);
2449         return;
2450     }
2451     info.track = m_document->tracksCount() - item->track();
2452     int endPos = m_document->renderer()->mltChangeClipSpeed(info, speed, oldspeed, baseclip->producer());
2453     if (endPos >= 0) {
2454         item->setSpeed(speed);
2455         item->updateRectGeometry();
2456         if (item->cropDuration().frames(m_document->fps()) > endPos)
2457             item->AbstractClipItem::resizeEnd(info.startPos.frames(m_document->fps()) + endPos, speed);
2458         m_document->setModified(true);
2459     } else emit displayMessage(i18n("Invalid clip"), ErrorMessage);
2460 }
2461
2462 void CustomTrackView::cutSelectedClips() {
2463     QList<QGraphicsItem *> itemList = scene()->selectedItems();
2464     GenTime currentPos = GenTime(m_cursorPos, m_document->fps());
2465     for (int i = 0; i < itemList.count(); i++) {
2466         if (itemList.at(i)->type() == AVWIDGET) {
2467             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2468             if (currentPos > item->startPos() && currentPos <  item->endPos()) {
2469                 RazorClipCommand *command = new RazorClipCommand(this, item->info(), currentPos, true);
2470                 m_commandStack->push(command);
2471             }
2472         }
2473     }
2474 }
2475
2476 void CustomTrackView::addClip(QDomElement xml, const QString &clipId, ItemInfo info, EffectsList effects) {
2477     DocClipBase *baseclip = m_document->clipManager()->getClipById(clipId);
2478     if (baseclip == NULL) {
2479         emit displayMessage(i18n("No clip copied"), ErrorMessage);
2480         return;
2481     }
2482     ClipItem *item = new ClipItem(baseclip, info, m_document->fps(), xml.attribute("speed", "1").toDouble());
2483     item->setEffectList(effects);
2484     scene()->addItem(item);
2485
2486     int tracknumber = m_document->tracksCount() - info.track - 1;
2487     bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2488     if (isLocked) item->setItemLocked(true);
2489
2490     if (item->baseClip()->isTransparent()) {
2491         // add transparency transition
2492         int endTrack = getPreviousVideoTrack(info.track);
2493         Transition *tr = new Transition(info, endTrack, m_document->fps(), MainWindow::transitions.getEffectByTag("composite", "composite"), true);
2494         if (m_document->renderer()->mltAddTransition(tr->transitionTag(), endTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML())) scene()->addItem(tr);
2495         else {
2496             emit displayMessage(i18n("Cannot add transition"), ErrorMessage);
2497             delete tr;
2498         }
2499
2500     }
2501
2502     baseclip->addReference();
2503     m_document->updateClip(baseclip->getId());
2504     info.track = m_document->tracksCount() - info.track;
2505     m_document->renderer()->mltInsertClip(info, xml, baseclip->producer(info.track));
2506     for (int i = 0; i < item->effectsCount(); i++) {
2507         m_document->renderer()->mltAddEffect(info.track, info.startPos, item->getEffectArgs(item->effectAt(i)), false);
2508     }
2509     m_document->renderer()->doRefresh();
2510 }
2511
2512 void CustomTrackView::slotUpdateClip(const QString &clipId) {
2513     QList<QGraphicsItem *> list = scene()->items();
2514     ClipItem *clip = NULL;
2515     for (int i = 0; i < list.size(); ++i) {
2516         if (list.at(i)->type() == AVWIDGET) {
2517             clip = static_cast <ClipItem *>(list.at(i));
2518             if (clip->clipProducer() == clipId) {
2519                 clip->refreshClip();
2520                 ItemInfo info = clip->info();
2521                 info.track = m_document->tracksCount() - clip->track();
2522                 m_document->renderer()->mltUpdateClip(info, clip->xml(), clip->baseClip()->producer());
2523             }
2524         }
2525     }
2526 }
2527
2528 ClipItem *CustomTrackView::getClipItemAtEnd(GenTime pos, int track) {
2529     int framepos = (int)(pos.frames(m_document->fps()));
2530     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, track * m_tracksHeight + m_tracksHeight / 2));
2531     ClipItem *clip = NULL;
2532     for (int i = 0; i < list.size(); i++) {
2533         if (list.at(i)->type() == AVWIDGET) {
2534             ClipItem *test = static_cast <ClipItem *>(list.at(i));
2535             if (test->endPos() == pos) clip = test;
2536             break;
2537         }
2538     }
2539     return clip;
2540 }
2541
2542 ClipItem *CustomTrackView::getClipItemAtStart(GenTime pos, int track) {
2543     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), track * m_tracksHeight + m_tracksHeight / 2));
2544     ClipItem *clip = NULL;
2545     for (int i = 0; i < list.size(); i++) {
2546         if (list.at(i)->type() == AVWIDGET) {
2547             ClipItem *test = static_cast <ClipItem *>(list.at(i));
2548             if (test->startPos() == pos) clip = test;
2549             break;
2550         }
2551     }
2552     return clip;
2553 }
2554
2555 ClipItem *CustomTrackView::getClipItemAt(int pos, int track) {
2556     QList<QGraphicsItem *> list = scene()->items(QPointF(pos , track * m_tracksHeight + m_tracksHeight / 2));
2557     ClipItem *clip = NULL;
2558     for (int i = 0; i < list.size(); i++) {
2559         if (list.at(i)->type() == AVWIDGET) {
2560             clip = static_cast <ClipItem *>(list.at(i));
2561             break;
2562         }
2563     }
2564     return clip;
2565 }
2566
2567 ClipItem *CustomTrackView::getClipItemAt(GenTime pos, int track) {
2568     int framepos = (int)(pos.frames(m_document->fps()));
2569     return getClipItemAt(framepos, track);
2570 }
2571
2572 Transition *CustomTrackView::getTransitionItemAt(GenTime pos, int track) {
2573     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight));
2574     Transition *clip = NULL;
2575     for (int i = 0; i < list.size(); i++) {
2576         if (list.at(i)->type() == TRANSITIONWIDGET) {
2577             clip = static_cast <Transition *>(list.at(i));
2578             break;
2579         }
2580     }
2581     return clip;
2582 }
2583
2584 Transition *CustomTrackView::getTransitionItemAtEnd(GenTime pos, int track) {
2585     int framepos = (int)(pos.frames(m_document->fps()));
2586     QList<QGraphicsItem *> list = scene()->items(QPointF(framepos - 1, (track + 1) * m_tracksHeight));
2587     Transition *clip = NULL;
2588     for (int i = 0; i < list.size(); i++) {
2589         if (list.at(i)->type() == TRANSITIONWIDGET) {
2590             Transition *test = static_cast <Transition *>(list.at(i));
2591             if (test->endPos() == pos) clip = test;
2592             break;
2593         }
2594     }
2595     return clip;
2596 }
2597
2598 Transition *CustomTrackView::getTransitionItemAtStart(GenTime pos, int track) {
2599     QList<QGraphicsItem *> list = scene()->items(QPointF(pos.frames(m_document->fps()), (track + 1) * m_tracksHeight));
2600     Transition *clip = NULL;
2601     for (int i = 0; i < list.size(); ++i) {
2602         if (list.at(i)->type() == TRANSITIONWIDGET) {
2603             Transition *test = static_cast <Transition *>(list.at(i));
2604             if (test->startPos() == pos) clip = test;
2605             break;
2606         }
2607     }
2608     return clip;
2609 }
2610
2611 void CustomTrackView::moveClip(const ItemInfo start, const ItemInfo end) {
2612     if (m_selectionGroup) resetSelectionGroup(false);
2613     ClipItem *item = getClipItemAt((int) start.startPos.frames(m_document->fps()) + 1, start.track);
2614     if (!item) {
2615         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);
2616         kDebug() << "----------------  ERROR, CANNOT find clip to move at.. ";
2617         return;
2618     }
2619     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()), item->baseClip()->producer(end.track));
2620     if (success) {
2621         bool snap = KdenliveSettings::snaptopoints();
2622         KdenliveSettings::setSnaptopoints(false);
2623         item->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2624
2625         int tracknumber = m_document->tracksCount() - end.track - 1;
2626         bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2627         m_scene->clearSelection();
2628         if (isLocked) item->setItemLocked(true);
2629         else {
2630             if (item->isItemLocked()) item->setItemLocked(false);
2631             item->setSelected(true);
2632         }
2633         if (item->baseClip()->isTransparent()) {
2634             // Also move automatic transition
2635             Transition *tr = getTransitionItemAt(start.startPos, start.track);
2636             if (tr && tr->isAutomatic()) {
2637                 tr->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2638                 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);
2639                 tr->setPos((int) end.startPos.frames(m_document->fps()), (int)(end.track * m_tracksHeight + 1));
2640             }
2641         }
2642         KdenliveSettings::setSnaptopoints(snap);
2643     } else {
2644         // undo last move and emit error message
2645         emit displayMessage(i18n("Cannot move clip to position %1", m_document->timecode().getTimecodeFromFrames(end.startPos.frames(m_document->fps()))), ErrorMessage);
2646     }
2647     kDebug() << " // MOVED CLIP TO: " << end.startPos.frames(25) << ", ITEM START: " << item->startPos().frames(25);
2648 }
2649
2650 void CustomTrackView::moveGroup(QList <ItemInfo> startClip, QList <ItemInfo> startTransition, const GenTime offset, const int trackOffset, bool reverseMove) {
2651     // Group Items
2652     kDebug() << "// GROUP MOVE; OFFSET: " << offset.frames(25) << ", TK OFF: " << trackOffset;
2653     resetSelectionGroup();
2654     m_scene->clearSelection();
2655     for (int i = 0; i < startClip.count(); i++) {
2656         if (reverseMove) {
2657             startClip[i].startPos = startClip.at(i).startPos - offset;
2658             startClip[i].track = startClip.at(i).track - trackOffset;
2659         }
2660         ClipItem *clip = getClipItemAt(startClip.at(i).startPos, startClip.at(i).track);
2661         if (clip) {
2662             clip->setItemLocked(false);
2663             clip->setSelected(true);
2664             m_document->renderer()->mltRemoveClip(m_document->tracksCount() - startClip.at(i).track, startClip.at(i).startPos);
2665         }
2666     }
2667     for (int i = 0; i < startTransition.count(); i++) {
2668         if (reverseMove) {
2669             startTransition[i].startPos = startTransition.at(i).startPos - offset;
2670             startTransition[i].track = startTransition.at(i).track - trackOffset;
2671         }
2672         Transition *tr = getTransitionItemAt(startTransition.at(i).startPos, startTransition.at(i).track);
2673         if (tr) {
2674             tr->setItemLocked(false);
2675             tr->setSelected(true);
2676             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());
2677         }
2678     }
2679     groupSelectedItems();
2680     if (m_selectionGroup) {
2681         QPointF pos = m_selectionGroup->pos();
2682         qreal posx = pos.x() + offset.frames(m_document->fps());
2683         qreal posy = pos.y() + trackOffset * (qreal) m_tracksHeight;
2684         bool snap = KdenliveSettings::snaptopoints();
2685         KdenliveSettings::setSnaptopoints(false);
2686
2687         m_selectionGroup->setPos(posx, posy);
2688
2689         QPointF top = m_selectionGroup->sceneBoundingRect().topLeft();
2690         m_selectionGroup->setPos(top);
2691         m_selectionGroupInfo.startPos = GenTime(m_selectionGroup->scenePos().x(), m_document->fps());
2692         m_selectionGroupInfo.track = m_selectionGroup->track();
2693
2694         QList<QGraphicsItem *> children = m_selectionGroup->childItems();
2695         for (int i = 0; i < children.count(); i++) {
2696             // re-add items in correct place
2697             AbstractClipItem *item = static_cast <AbstractClipItem *>(children.at(i));
2698             item->updateItem();
2699             ItemInfo info = item->info();
2700             int tracknumber = m_document->tracksCount() - info.track - 1;
2701             bool isLocked = m_document->trackInfoAt(tracknumber).isLocked;
2702             if (isLocked) item->setItemLocked(true);
2703             else if (item->isItemLocked()) item->setItemLocked(false);
2704
2705             if (item->type() == AVWIDGET) {
2706                 ClipItem *clip = static_cast <ClipItem*>(item);
2707                 info.track = m_document->tracksCount() - info.track;
2708                 m_document->renderer()->mltInsertClip(info, clip->xml(), clip->baseClip()->producer(info.track));
2709             } else {
2710                 Transition *tr = static_cast <Transition*>(item);
2711                 int newTrack = tr->transitionEndTrack();
2712                 kDebug() << "/// TRANSITION CURR TRK: " << newTrack;
2713                 if (!tr->forcedTrack()) {
2714                     newTrack += trackOffset;
2715                     if (newTrack < 0 || newTrack > m_document->tracksCount()) newTrack = getPreviousVideoTrack(info.track);
2716                 }
2717                 tr->updateTransitionEndTrack(newTrack);
2718                 kDebug() << "/// TRANSITION UPDATED TRK: " << newTrack;
2719                 m_document->renderer()->mltAddTransition(tr->transitionTag(), newTrack, m_document->tracksCount() - info.track, info.startPos, info.endPos, tr->toXML());
2720             }
2721         }
2722         KdenliveSettings::setSnaptopoints(snap);
2723     }
2724
2725 }
2726
2727 void CustomTrackView::moveTransition(const ItemInfo start, const ItemInfo end) {
2728     Transition *item = getTransitionItemAt(start.startPos, start.track);
2729     if (!item) {
2730         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);
2731         kDebug() << "----------------  ERROR, CANNOT find transition to move... ";// << startPos.x() * m_scale * FRAME_SIZE + 1 << ", " << startPos.y() * m_tracksHeight + m_tracksHeight / 2;
2732         return;
2733     }
2734     //kDebug() << "----------------  Move TRANSITION FROM: " << startPos.x() << ", END:" << endPos.x() << ",TRACKS: " << oldtrack << " TO " << newtrack;
2735     bool snap = KdenliveSettings::snaptopoints();
2736     KdenliveSettings::setSnaptopoints(false);
2737     //kDebug()<<"///  RESIZE TRANS START: ("<< startPos.x()<<"x"<< startPos.y()<<") / ("<<endPos.x()<<"x"<< endPos.y()<<")";
2738     if (end.endPos - end.startPos == start.endPos - start.startPos) {
2739         // Transition was moved
2740         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
2741     } else if (end.endPos == start.endPos) {
2742         // Transition start resize
2743         item->resizeStart((int) end.startPos.frames(m_document->fps()));
2744     } else if (end.startPos == start.startPos) {
2745         // Transition end resize;
2746         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2747     } else {
2748         // Move & resize
2749         item->setPos((int) end.startPos.frames(m_document->fps()), (end.track) * m_tracksHeight + 1);
2750         item->resizeStart((int) end.startPos.frames(m_document->fps()));
2751         item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2752     }
2753     //item->moveTransition(GenTime((int) (endPos.x() - startPos.x()), m_document->fps()));
2754     KdenliveSettings::setSnaptopoints(snap);
2755     item->updateTransitionEndTrack(getPreviousVideoTrack(end.track));
2756     m_document->renderer()->mltMoveTransition(item->transitionTag(), m_document->tracksCount() - start.track, m_document->tracksCount() - end.track, item->transitionEndTrack(), start.startPos, start.endPos, end.startPos, end.endPos);
2757 }
2758
2759 void CustomTrackView::resizeClip(const ItemInfo start, const ItemInfo end) {
2760     bool resizeClipStart = true;
2761     if (start.startPos == end.startPos) resizeClipStart = false;
2762     /*if (resizeClipStart) offset = 1;
2763     else offset = -1;*/
2764     ClipItem *item = getClipItemAt((int)(start.startPos.frames(m_document->fps())), start.track);
2765     if (!item) {
2766         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);
2767         kDebug() << "----------------  ERROR, CANNOT find clip to resize at... "; // << startPos;
2768         return;
2769     }
2770     if (item->parentItem()) {
2771         // Item is part of a group, reset group
2772         resetSelectionGroup();
2773     }
2774     bool snap = KdenliveSettings::snaptopoints();
2775     KdenliveSettings::setSnaptopoints(false);
2776     if (resizeClipStart && start.startPos != end.startPos) {
2777         ItemInfo clipinfo = item->info();
2778         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2779         bool success = m_document->renderer()->mltResizeClipStart(clipinfo, end.startPos - item->startPos());
2780         if (success) {
2781             kDebug() << "RESIZE CLP STRAT TO:" << end.startPos.frames(m_document->fps()) << ", OLD ST: " << start.startPos.frames(25);
2782             item->resizeStart((int) end.startPos.frames(m_document->fps()));
2783             updateClipFade(item);
2784         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2785     } else if (!resizeClipStart) {
2786         ItemInfo clipinfo = item->info();
2787         clipinfo.track = m_document->tracksCount() - clipinfo.track;
2788         bool success = m_document->renderer()->mltResizeClipEnd(clipinfo, end.endPos - clipinfo.startPos);
2789         if (success) {
2790             item->resizeEnd((int) end.endPos.frames(m_document->fps()));
2791             updateClipFade(item, true);
2792         } else emit displayMessage(i18n("Error when resizing clip"), ErrorMessage);
2793     }
2794     if (end.cropStart != start.cropStart) {
2795         kDebug() << "// RESIZE CROP, DIFF: " << (end.cropStart - start.cropStart).frames(25);
2796         ItemInfo clipinfo = end;
2797         clipinfo.track = m_document->tracksCount() - end.track;
2798         bool success = m_document->renderer()->mltResizeClipCrop(clipinfo, end.cropStart - start.cropStart);
2799         if (success) {
2800             item->setCropStart(end.cropStart);
2801             item->resetThumbs();
2802         }
2803     }
2804     m_document->renderer()->doRefresh();
2805     KdenliveSettings::setSnaptopoints(snap);
2806 }
2807
2808 void CustomTrackView::updateClipFade(ClipItem * item, bool updateFadeOut) {
2809     if (!updateFadeOut) {
2810         int end = item->fadeIn();
2811         if (end != 0) {
2812             // there is a fade in effect
2813             int effectPos = item->hasEffect("volume", "fadein");
2814             if (effectPos != -1) {
2815                 QDomElement oldeffect = item->effectAt(effectPos);
2816                 int start = item->cropStart().frames(m_document->fps());
2817                 int max = item->cropDuration().frames(m_document->fps());
2818                 if (end > max) {
2819                     item->setFadeIn(max);
2820                     end = item->fadeIn();
2821                 }
2822                 end += start;
2823                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2824                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2825                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
2826                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2827                 // if fade effect is displayed, update the effect edit widget with new clip duration
2828                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
2829             }
2830             effectPos = item->hasEffect("brightness", "fade_from_black");
2831             if (effectPos != -1) {
2832                 QDomElement oldeffect = item->effectAt(effectPos);
2833                 int start = item->cropStart().frames(m_document->fps());
2834                 int max = item->cropDuration().frames(m_document->fps());
2835                 if (end > max) {
2836                     item->setFadeIn(max);
2837                     end = item->fadeIn();
2838                 }
2839                 end += start;
2840                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2841                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2842                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
2843                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2844                 // if fade effect is displayed, update the effect edit widget with new clip duration
2845                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
2846             }
2847         }
2848     } else {
2849         int start = item->fadeOut();
2850         if (start != 0) {
2851             // there is a fade in effect
2852             int effectPos = item->hasEffect("volume", "fadeout");
2853             if (effectPos != -1) {
2854                 QDomElement oldeffect = item->effectAt(effectPos);
2855                 int end = (item->duration() - item->cropStart()).frames(m_document->fps());
2856                 int max = item->cropDuration().frames(m_document->fps());
2857                 if (end > max) {
2858                     item->setFadeOut(max);
2859                     start = item->fadeOut();
2860                 }
2861                 start = end - start;
2862                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2863                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2864                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
2865                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2866                 // if fade effect is displayed, update the effect edit widget with new clip duration
2867                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
2868             }
2869             effectPos = item->hasEffect("brightness", "fade_to_black");
2870             if (effectPos != -1) {
2871                 QDomElement oldeffect = item->effectAt(effectPos);
2872                 int end = (item->duration() - item->cropStart()).frames(m_document->fps());
2873                 int max = item->cropDuration().frames(m_document->fps());
2874                 if (end > max) {
2875                     item->setFadeOut(max);
2876                     start = item->fadeOut();
2877                 }
2878                 start = end - start;
2879                 EffectsList::setParameter(oldeffect, "in", QString::number(start));
2880                 EffectsList::setParameter(oldeffect, "out", QString::number(end));
2881                 if (!m_document->renderer()->mltEditEffect(m_document->tracksCount() - item->track(), item->startPos(), item->getEffectArgs(oldeffect)))
2882                     emit displayMessage(i18n("Problem editing effect"), ErrorMessage);
2883                 // if fade effect is displayed, update the effect edit widget with new clip duration
2884                 if (item->isSelected() && effectPos == item->selectedEffectIndex()) emit clipItemSelected(item, effectPos);
2885             }
2886         }
2887     }
2888 }
2889
2890 double CustomTrackView::getSnapPointForPos(double pos) {
2891     return m_scene->getSnapPointForPos(pos, KdenliveSettings::snaptopoints());
2892 }
2893
2894 void CustomTrackView::updateSnapPoints(AbstractClipItem *selected, QList <GenTime> offsetList, bool skipSelectedItems) {
2895     QList <GenTime> snaps;
2896     if (selected && offsetList.isEmpty()) offsetList.append(selected->duration());
2897     QList<QGraphicsItem *> itemList = items();
2898     for (int i = 0; i < itemList.count(); i++) {
2899         if (itemList.at(i) == selected) continue;
2900         if (skipSelectedItems && itemList.at(i)->isSelected()) continue;
2901         if (itemList.at(i)->type() == AVWIDGET) {
2902             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
2903             GenTime start = item->startPos();
2904             GenTime end = item->endPos();
2905             snaps.append(start);
2906             snaps.append(end);
2907             if (!offsetList.isEmpty()) {
2908                 for (int j = 0; j < offsetList.size(); j++) {
2909                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
2910                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
2911                 }
2912             }
2913             // Add clip markers
2914             QList < GenTime > markers = item->snapMarkers();
2915             for (int j = 0; j < markers.size(); ++j) {
2916                 GenTime t = markers.at(j);
2917                 snaps.append(t);
2918                 if (!offsetList.isEmpty()) {
2919                     for (int k = 0; k < offsetList.size(); k++) {
2920                         if (t > offsetList.at(k)) snaps.append(t - offsetList.at(k));
2921                     }
2922                 }
2923             }
2924         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
2925             Transition *transition = static_cast <Transition*>(itemList.at(i));
2926             GenTime start = transition->startPos();
2927             GenTime end = transition->endPos();
2928             snaps.append(start);
2929             snaps.append(end);
2930             if (!offsetList.isEmpty()) {
2931                 for (int j = 0; j < offsetList.size(); j++) {
2932                     if (start > offsetList.at(j)) snaps.append(start - offsetList.at(j));
2933                     if (end > offsetList.at(j)) snaps.append(end - offsetList.at(j));
2934                 }
2935             }
2936         }
2937     }
2938
2939     // add cursor position
2940     GenTime pos = GenTime(m_cursorPos, m_document->fps());
2941     snaps.append(pos);
2942     if (!offsetList.isEmpty()) {
2943         for (int j = 0; j < offsetList.size(); j++) {
2944             snaps.append(pos - offsetList.at(j));
2945         }
2946     }
2947
2948     // add guides
2949     for (int i = 0; i < m_guides.count(); i++) {
2950         snaps.append(m_guides.at(i)->position());
2951         if (!offsetList.isEmpty()) {
2952             for (int j = 0; j < offsetList.size(); j++) {
2953                 snaps.append(m_guides.at(i)->position() - offsetList.at(j));
2954             }
2955         }
2956     }
2957
2958     qSort(snaps);
2959     m_scene->setSnapList(snaps);
2960     //for (int i = 0; i < m_snapPoints.size(); ++i)
2961     //    kDebug() << "SNAP POINT: " << m_snapPoints.at(i).frames(25);
2962 }
2963
2964 void CustomTrackView::slotSeekToPreviousSnap() {
2965     updateSnapPoints(NULL);
2966     GenTime res = m_scene->previousSnapPoint(GenTime(m_cursorPos, m_document->fps()));
2967     setCursorPos((int) res.frames(m_document->fps()));
2968     checkScrolling();
2969 }
2970
2971 void CustomTrackView::slotSeekToNextSnap() {
2972     updateSnapPoints(NULL);
2973     GenTime res = m_scene->nextSnapPoint(GenTime(m_cursorPos, m_document->fps()));
2974     setCursorPos((int) res.frames(m_document->fps()));
2975     checkScrolling();
2976 }
2977
2978 void CustomTrackView::clipStart() {
2979     ClipItem *item = getMainActiveClip();
2980     if (item != NULL) {
2981         setCursorPos((int) item->startPos().frames(m_document->fps()));
2982         checkScrolling();
2983     }
2984 }
2985
2986 void CustomTrackView::clipEnd() {
2987     ClipItem *item = getMainActiveClip();
2988     if (item != NULL) {
2989         setCursorPos((int) item->endPos().frames(m_document->fps()) - 1);
2990         checkScrolling();
2991     }
2992 }
2993
2994 void CustomTrackView::slotAddClipMarker(const QString &id, GenTime t, QString c) {
2995     QString oldcomment = m_document->clipManager()->getClipById(id)->markerComment(t);
2996     AddMarkerCommand *command = new AddMarkerCommand(this, oldcomment, c, id, t, true);
2997     m_commandStack->push(command);
2998 }
2999
3000 void CustomTrackView::slotDeleteClipMarker(const QString &comment, const QString &id, const GenTime &position) {
3001     AddMarkerCommand *command = new AddMarkerCommand(this, comment, QString(), id, position, true);
3002     m_commandStack->push(command);
3003 }
3004
3005 void CustomTrackView::slotDeleteAllClipMarkers(const QString &id) {
3006     DocClipBase *base = m_document->clipManager()->getClipById(id);
3007     QList <CommentedTime> markers = base->commentedSnapMarkers();
3008
3009     if (markers.isEmpty()) {
3010         emit displayMessage(i18n("Clip has no markers"), ErrorMessage);
3011         return;
3012     }
3013     QUndoCommand *deleteMarkers = new QUndoCommand();
3014     deleteMarkers->setText("Delete clip markers");
3015
3016     for (int i = 0; i < markers.size(); i++) {
3017         new AddMarkerCommand(this, markers.at(i).comment(), QString(), id, markers.at(i).time(), true, deleteMarkers);
3018     }
3019     m_commandStack->push(deleteMarkers);
3020 }
3021
3022 void CustomTrackView::addMarker(const QString &id, const GenTime &pos, const QString comment) {
3023     DocClipBase *base = m_document->clipManager()->getClipById(id);
3024     if (!comment.isEmpty()) base->addSnapMarker(pos, comment);
3025     else base->deleteSnapMarker(pos);
3026     m_document->setModified(true);
3027     viewport()->update();
3028 }
3029
3030 bool sortGuidesList(const Guide *g1 , const Guide *g2) {
3031     return (*g1).position() < (*g2).position();
3032 }
3033
3034 void CustomTrackView::editGuide(const GenTime oldPos, const GenTime pos, const QString &comment) {
3035     if (oldPos > GenTime() && pos > GenTime()) {
3036         // move guide
3037         for (int i = 0; i < m_guides.count(); i++) {
3038             if (m_guides.at(i)->position() == oldPos) {
3039                 Guide *item = m_guides.at(i);
3040                 item->updateGuide(pos, comment);
3041                 break;
3042             }
3043         }
3044     } else if (pos > GenTime()) addGuide(pos, comment);
3045     else {
3046         // remove guide
3047         bool found = false;
3048         for (int i = 0; i < m_guides.count(); i++) {
3049             if (m_guides.at(i)->position() == oldPos) {
3050                 Guide *item = m_guides.takeAt(i);
3051                 delete item;
3052                 found = true;
3053                 break;
3054             }
3055         }
3056         if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3057     }
3058     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3059     m_document->syncGuides(m_guides);
3060 }
3061
3062 bool CustomTrackView::addGuide(const GenTime pos, const QString &comment) {
3063     for (int i = 0; i < m_guides.count(); i++) {
3064         if (m_guides.at(i)->position() == pos) {
3065             emit displayMessage(i18n("A guide already exists at position %1", m_document->timecode().getTimecodeFromFrames(pos.frames(m_document->fps()))), ErrorMessage);
3066             return false;
3067         }
3068     }
3069     Guide *g = new Guide(this, pos, comment, m_document->fps(), m_tracksHeight * m_document->tracksCount());
3070     scene()->addItem(g);
3071     m_guides.append(g);
3072     qSort(m_guides.begin(), m_guides.end(), sortGuidesList);
3073     m_document->syncGuides(m_guides);
3074     return true;
3075 }
3076
3077 void CustomTrackView::slotAddGuide() {
3078     CommentedTime marker(GenTime(m_cursorPos, m_document->fps()), i18n("Guide"));
3079     MarkerDialog d(NULL, marker, m_document->timecode(), i18n("Add Guide"), this);
3080     if (d.exec() != QDialog::Accepted) return;
3081     if (addGuide(d.newMarker().time(), d.newMarker().comment())) {
3082         EditGuideCommand *command = new EditGuideCommand(this, GenTime(), QString(), d.newMarker().time(), d.newMarker().comment(), false);
3083         m_commandStack->push(command);
3084     }
3085 }
3086
3087 void CustomTrackView::slotEditGuide() {
3088     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3089     bool found = false;
3090     for (int i = 0; i < m_guides.count(); i++) {
3091         if (m_guides.at(i)->position() == pos) {
3092             slotEditGuide(m_guides.at(i)->info());
3093             found = true;
3094             break;
3095         }
3096     }
3097     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3098 }
3099
3100 void CustomTrackView::slotEditGuide(CommentedTime guide) {
3101     MarkerDialog d(NULL, guide, m_document->timecode(), i18n("Edit Guide"), this);
3102     if (d.exec() == QDialog::Accepted) {
3103         EditGuideCommand *command = new EditGuideCommand(this, guide.time(), guide.comment(), d.newMarker().time(), d.newMarker().comment(), true);
3104         m_commandStack->push(command);
3105     }
3106 }
3107
3108
3109 void CustomTrackView::slotDeleteGuide() {
3110     GenTime pos = GenTime(m_cursorPos, m_document->fps());
3111     bool found = false;
3112     for (int i = 0; i < m_guides.count(); i++) {
3113         if (m_guides.at(i)->position() == pos) {
3114             EditGuideCommand *command = new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true);
3115             m_commandStack->push(command);
3116             found = true;
3117             break;
3118         }
3119     }
3120     if (!found) emit displayMessage(i18n("No guide at cursor time"), ErrorMessage);
3121 }
3122
3123 void CustomTrackView::slotDeleteAllGuides() {
3124     QUndoCommand *deleteAll = new QUndoCommand();
3125     deleteAll->setText("Delete all guides");
3126     for (int i = 0; i < m_guides.count(); i++) {
3127         new EditGuideCommand(this, m_guides.at(i)->position(), m_guides.at(i)->label(), GenTime(), QString(), true, deleteAll);
3128     }
3129     m_commandStack->push(deleteAll);
3130 }
3131
3132 void CustomTrackView::setTool(PROJECTTOOL tool) {
3133     m_tool = tool;
3134 }
3135
3136 void CustomTrackView::setScale(double scaleFactor) {
3137     QMatrix matrix;
3138     matrix = matrix.scale(scaleFactor, 1);
3139     m_scene->setScale(scaleFactor);
3140     //scale(scaleFactor, 1);
3141     m_animationTimer->stop();
3142     if (m_visualTip) {
3143         delete m_visualTip;
3144         m_visualTip = NULL;
3145     }
3146     if (m_animation) {
3147         delete m_animation;
3148         m_animation = NULL;
3149     }
3150     /*double pos = cursorPos() / m_scale;
3151     m_scale = scaleFactor;
3152     m_scene->setScale(m_scale);
3153     int vert = verticalScrollBar()->value();
3154     kDebug() << " HHHHHHHH  SCALING: " << m_scale;
3155     QList<QGraphicsItem *> itemList = items();
3156     for (int i = 0; i < itemList.count(); i++) {
3157         if (itemList.at(i)->type() == AVWIDGET || itemList.at(i)->type() == TRANSITIONWIDGET) {
3158             AbstractClipItem *clip = (AbstractClipItem *)itemList.at(i);
3159             clip->setRect(0, 0, (qreal) clip->duration().frames(m_document->fps()) * m_scale - .5, clip->rect().height());
3160             clip->setPos((qreal) clip->startPos().frames(m_document->fps()) * m_scale, clip->pos().y());
3161         }
3162     }
3163
3164     for (int i = 0; i < m_guides.count(); i++) {
3165         m_guides.at(i)->updatePosition(m_scale);
3166     }
3167
3168     setSceneRect(0, 0, (m_projectDuration + 100) * m_scale, sceneRect().height());
3169     updateCursorPos();*/
3170     setMatrix(matrix);
3171     centerOn(QPointF(cursorPos(), m_tracksHeight));
3172     //verticalScrollBar()->setValue(vert);*/
3173 }
3174
3175 void CustomTrackView::slotRefreshGuides() {
3176     if (KdenliveSettings::showmarkers()) {
3177         kDebug() << "// refresh GUIDES";
3178         for (int i = 0; i < m_guides.count(); i++) {
3179             m_guides.at(i)->update();
3180         }
3181     }
3182 }
3183
3184 void CustomTrackView::drawBackground(QPainter * painter, const QRectF & rect) {
3185     QColor base = palette().button().color();
3186     QRectF r = rect;
3187     r.setWidth(r.width() + 1);
3188     painter->setClipRect(r);
3189     painter->drawLine(r.left(), 0, r.right(), 0);
3190     uint max = m_document->tracksCount();
3191     for (uint i = 0; i < max;i++) {
3192         if (m_document->trackInfoAt(max - i - 1).isLocked == true) painter->fillRect(r.left(), m_tracksHeight * i + 1, r.right() - r.left() + 1, m_tracksHeight - 1, QBrush(QColor(250, 250, 100)));
3193         else if (m_document->trackInfoAt(max - i - 1).type == AUDIOTRACK) painter->fillRect(r.left(), m_tracksHeight * i + 1, r.right() - r.left() + 1, m_tracksHeight - 1, QBrush(QColor(240, 240, 255)));
3194         painter->drawLine(r.left(), m_tracksHeight * (i + 1), r.right(), m_tracksHeight * (i + 1));
3195     }
3196     int lowerLimit = m_tracksHeight * m_document->tracksCount() + 1;
3197     if (height() > lowerLimit)
3198         painter->fillRect(QRectF(r.left(), lowerLimit, r.width(), height() - lowerLimit), QBrush(base));
3199 }
3200
3201 bool CustomTrackView::findString(const QString &text) {
3202     QString marker;
3203     for (int i = 0; i < m_searchPoints.size(); ++i) {
3204         marker = m_searchPoints.at(i).comment();
3205         if (marker.contains(text, Qt::CaseInsensitive)) {
3206             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3207             int vert = verticalScrollBar()->value();
3208             int hor = cursorPos();
3209             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3210             m_findIndex = i;
3211             return true;
3212         }
3213     }
3214     return false;
3215 }
3216
3217 bool CustomTrackView::findNextString(const QString &text) {
3218     QString marker;
3219     for (int i = m_findIndex + 1; i < m_searchPoints.size(); ++i) {
3220         marker = m_searchPoints.at(i).comment();
3221         if (marker.contains(text, Qt::CaseInsensitive)) {
3222             setCursorPos(m_searchPoints.at(i).time().frames(m_document->fps()), true);
3223             int vert = verticalScrollBar()->value();
3224             int hor = cursorPos();
3225             ensureVisible(hor, vert + 10, 2, 2, 50, 0);
3226             m_findIndex = i;
3227             return true;
3228         }
3229     }
3230     m_findIndex = -1;
3231     return false;
3232 }
3233
3234 void CustomTrackView::initSearchStrings() {
3235     m_searchPoints.clear();
3236     QList<QGraphicsItem *> itemList = items();
3237     for (int i = 0; i < itemList.count(); i++) {
3238         // parse all clip names
3239         if (itemList.at(i)->type() == AVWIDGET) {
3240             ClipItem *item = static_cast <ClipItem *>(itemList.at(i));
3241             GenTime start = item->startPos();
3242             CommentedTime t(start, item->clipName());
3243             m_searchPoints.append(t);
3244             // add all clip markers
3245             QList < CommentedTime > markers = item->commentedSnapMarkers();
3246             m_searchPoints += markers;
3247         }
3248     }
3249
3250     // add guides
3251     for (int i = 0; i < m_guides.count(); i++) {
3252         m_searchPoints.append(m_guides.at(i)->info());
3253     }
3254
3255     qSort(m_searchPoints);
3256 }
3257
3258 void CustomTrackView::clearSearchStrings() {
3259     m_searchPoints.clear();
3260     m_findIndex = 0;
3261 }
3262
3263 void CustomTrackView::copyClip() {
3264     while (m_copiedItems.count() > 0) {
3265         delete m_copiedItems.takeFirst();
3266     }
3267     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3268     if (itemList.count() == 0) {
3269         emit displayMessage(i18n("Select a clip before copying"), ErrorMessage);
3270         return;
3271     }
3272     for (int i = 0; i < itemList.count(); i++) {
3273         if (itemList.at(i)->type() == AVWIDGET) {
3274             ClipItem *dup = static_cast <ClipItem *>(itemList.at(i));
3275             m_copiedItems.append(dup->clone(dup->info()));
3276         } else if (itemList.at(i)->type() == TRANSITIONWIDGET) {
3277             Transition *dup = static_cast <Transition *>(itemList.at(i));
3278             m_copiedItems.append(dup->clone());
3279         }
3280     }
3281 }
3282
3283 bool CustomTrackView::canBePastedTo(ItemInfo info, int type) const {
3284     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));
3285     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3286     for (int i = 0; i < collisions.count(); i++) {
3287         if (collisions.at(i)->type() == type) return false;
3288     }
3289     return true;
3290 }
3291
3292 bool CustomTrackView::canBePasted(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
3293     for (int i = 0; i < items.count(); i++) {
3294         ItemInfo info = items.at(i)->info();
3295         info.startPos += offset;
3296         info.endPos += offset;
3297         info.track += trackOffset;
3298         if (!canBePastedTo(info, items.at(i)->type())) return false;
3299     }
3300     return true;
3301 }
3302
3303 bool CustomTrackView::canBeMoved(QList<AbstractClipItem *> items, GenTime offset, int trackOffset) const {
3304     QPainterPath movePath;
3305     movePath.moveTo(0, 0);
3306
3307     for (int i = 0; i < items.count(); i++) {
3308         ItemInfo info = items.at(i)->info();
3309         info.startPos = info.startPos + offset;
3310         info.endPos = info.endPos + offset;
3311         info.track = info.track + trackOffset;
3312         if (info.startPos < GenTime()) {
3313             // No clip should go below 0
3314             return false;
3315         }
3316         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));
3317         movePath.addRect(rect);
3318     }
3319     QList<QGraphicsItem *> collisions = scene()->items(movePath, Qt::IntersectsItemBoundingRect);
3320     for (int i = 0; i < collisions.count(); i++) {
3321         if ((collisions.at(i)->type() == AVWIDGET || collisions.at(i)->type() == TRANSITIONWIDGET) && !items.contains(static_cast <AbstractClipItem *>(collisions.at(i)))) {
3322             kDebug() << "  ////////////   CLIP COLLISION, MOVE NOT ALLOWED";
3323             return false;
3324         }
3325     }
3326     return true;
3327 }
3328
3329 void CustomTrackView::pasteClip() {
3330     if (m_copiedItems.count() == 0) {
3331         emit displayMessage(i18n("No clip copied"), ErrorMessage);
3332         return;
3333     }
3334     QPoint position;
3335     if (m_menuPosition.isNull()) {
3336         position = mapFromGlobal(QCursor::pos());
3337         if (!underMouse() || position.y() > m_tracksHeight * m_document->tracksCount()) {
3338             emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3339             return;
3340         }
3341     } else position = m_menuPosition;
3342     GenTime pos = GenTime((int)(mapToScene(position).x()), m_document->fps());
3343     int track = (int)(position.y() / m_tracksHeight);
3344     ItemInfo first = m_copiedItems.at(0)->info();
3345
3346     GenTime offset = pos - first.startPos;
3347     int trackOffset = track - first.track;
3348
3349     if (!canBePasted(m_copiedItems, offset, trackOffset)) {
3350         emit displayMessage(i18n("Cannot paste selected clips"), ErrorMessage);
3351         return;
3352     }
3353     QUndoCommand *pasteClips = new QUndoCommand();
3354     pasteClips->setText("Paste clips");
3355
3356     for (int i = 0; i < m_copiedItems.count(); i++) {
3357         // parse all clip names
3358         if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == AVWIDGET) {
3359             ClipItem *clip = static_cast <ClipItem *>(m_copiedItems.at(i));
3360             ItemInfo info;
3361             info.startPos = clip->startPos() + offset;
3362             info.endPos = clip->endPos() + offset;
3363             info.cropStart = clip->cropStart();
3364             info.track = clip->track() + trackOffset;
3365             if (canBePastedTo(info, AVWIDGET)) {
3366                 new AddTimelineClipCommand(this, clip->xml(), clip->clipProducer(), info, clip->effectList(), true, false, pasteClips);
3367             } else emit displayMessage(i18n("Cannot paste clip to selected place"), ErrorMessage);
3368         } else if (m_copiedItems.at(i) && m_copiedItems.at(i)->type() == TRANSITIONWIDGET) {
3369             Transition *tr = static_cast <Transition *>(m_copiedItems.at(i));
3370             ItemInfo info;
3371             info.startPos = tr->startPos() + offset;
3372             info.endPos = tr->endPos() + offset;
3373             info.track = tr->track() + trackOffset;
3374             if (canBePastedTo(info, TRANSITIONWIDGET)) {
3375                 if (info.startPos >= info.endPos) {
3376                     emit displayMessage(i18n("Invalid transition"), ErrorMessage);
3377                 } else new AddTransitionCommand(this, info, tr->transitionEndTrack() + trackOffset, tr->toXML(), false, true, pasteClips);
3378             } else emit displayMessage(i18n("Cannot paste transition to selected place"), ErrorMessage);
3379         }
3380     }
3381     m_commandStack->push(pasteClips);
3382 }
3383
3384 void CustomTrackView::pasteClipEffects() {
3385     if (m_copiedItems.count() != 1 || m_copiedItems.at(0)->type() != AVWIDGET) {
3386         emit displayMessage(i18n("You must copy exactly one clip before pasting effects"), ErrorMessage);
3387         return;
3388     }
3389     ClipItem *clip = static_cast < ClipItem *>(m_copiedItems.at(0));
3390     EffectsList effects = clip->effectList();
3391
3392     QUndoCommand *paste = new QUndoCommand();
3393     paste->setText("Paste effects");
3394
3395     QList<QGraphicsItem *> clips = scene()->selectedItems();
3396     for (int i = 0; i < clips.count(); ++i) {
3397         if (clips.at(i)->type() == AVWIDGET) {
3398             ClipItem *item = static_cast < ClipItem *>(clips.at(i));
3399             for (int i = 0; i < clip->effectsCount(); i++) {
3400                 new AddEffectCommand(this, m_document->tracksCount() - item->track(), item->startPos(), clip->effectAt(i), true, paste);
3401             }
3402         }
3403     }
3404     m_commandStack->push(paste);
3405 }
3406
3407
3408 ClipItem *CustomTrackView::getClipUnderCursor() const {
3409     QRectF rect((double) m_cursorPos, 0.0, 1.0, (double)(m_tracksHeight * m_document->tracksCount()));
3410     QList<QGraphicsItem *> collisions = scene()->items(rect, Qt::IntersectsItemBoundingRect);
3411     for (int i = 0; i < collisions.count(); i++) {
3412         if (collisions.at(i)->type() == AVWIDGET) {
3413             return static_cast < ClipItem *>(collisions.at(i));
3414         }
3415     }
3416     return NULL;
3417 }
3418
3419 ClipItem *CustomTrackView::getMainActiveClip() const {
3420     QList<QGraphicsItem *> clips = scene()->selectedItems();
3421     if (clips.isEmpty()) {
3422         return getClipUnderCursor();
3423     } else {
3424         ClipItem *item = NULL;
3425         for (int i = 0; i < clips.count(); ++i) {
3426             if (clips.at(i)->type() == AVWIDGET)
3427                 item = static_cast < ClipItem *>(clips.at(i));
3428             if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos) break;
3429         }
3430         if (item) return item;
3431     }
3432     return NULL;
3433 }
3434
3435 ClipItem *CustomTrackView::getActiveClipUnderCursor(bool allowOutsideCursor) const {
3436     QList<QGraphicsItem *> clips = scene()->selectedItems();
3437     if (clips.isEmpty()) {
3438         return getClipUnderCursor();
3439     } else {
3440         ClipItem *item;
3441         // remove all items in the list that are not clips
3442         for (int i = 0; i < clips.count();) {
3443             if (clips.at(i)->type() != AVWIDGET) clips.removeAt(i);
3444             else i++;
3445         }
3446         if (clips.count() == 1 && allowOutsideCursor) return static_cast < ClipItem *>(clips.at(0));
3447         for (int i = 0; i < clips.count(); ++i) {
3448             if (clips.at(i)->type() == AVWIDGET) {
3449                 item = static_cast < ClipItem *>(clips.at(i));
3450                 if (item->startPos().frames(m_document->fps()) <= m_cursorPos && item->endPos().frames(m_document->fps()) >= m_cursorPos)
3451                     return item;
3452             }
3453         }
3454     }
3455     return NULL;
3456 }
3457
3458 void CustomTrackView::setInPoint() {
3459     ClipItem *clip = getActiveClipUnderCursor(true);
3460     if (clip == NULL) {
3461         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
3462         return;
3463     }
3464     ItemInfo startInfo = clip->info();
3465     ItemInfo endInfo = startInfo;
3466     endInfo.startPos = GenTime(m_cursorPos, m_document->fps());
3467     if (endInfo.startPos >= startInfo.endPos) {
3468         // Check for invalid resize
3469         emit displayMessage(i18n("Invalid action"), ErrorMessage);
3470         return;
3471     } else if (endInfo.startPos < startInfo.startPos) {
3472         int length = m_document->renderer()->mltGetSpaceLength(endInfo.startPos, m_document->tracksCount() - startInfo.track, false);
3473         if (length < (startInfo.startPos - endInfo.startPos).frames(m_document->fps())) {
3474             emit displayMessage(i18n("Invalid action"), ErrorMessage);
3475             return;
3476         }
3477     }
3478     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
3479     m_commandStack->push(command);
3480 }
3481
3482 void CustomTrackView::setOutPoint() {
3483     ClipItem *clip = getActiveClipUnderCursor(true);
3484     if (clip == NULL) {
3485         emit displayMessage(i18n("You must select one clip for this action"), ErrorMessage);
3486         return;
3487     }
3488     ItemInfo startInfo = clip->info();
3489     ItemInfo endInfo = clip->info();
3490     endInfo.endPos = GenTime(m_cursorPos, m_document->fps());
3491     if (endInfo.endPos <= startInfo.startPos) {
3492         // Check for invalid resize
3493         emit displayMessage(i18n("Invalid action"), ErrorMessage);
3494         return;
3495     } else if (endInfo.endPos > startInfo.endPos) {
3496         int length = m_document->renderer()->mltGetSpaceLength(endInfo.endPos, m_document->tracksCount() - startInfo.track, false);
3497         if (length < (endInfo.endPos - startInfo.endPos).frames(m_document->fps())) {
3498             emit displayMessage(i18n("Invalid action"), ErrorMessage);
3499             return;
3500         }
3501     }
3502
3503
3504
3505     ResizeClipCommand *command = new ResizeClipCommand(this, startInfo, endInfo, true);
3506     m_commandStack->push(command);
3507 }
3508
3509 void CustomTrackView::slotUpdateAllThumbs() {
3510     QList<QGraphicsItem *> itemList = items();
3511     //if (itemList.isEmpty()) return;
3512     ClipItem *item;
3513     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
3514     for (int i = 0; i < itemList.count(); i++) {
3515         if (itemList.at(i)->type() == AVWIDGET) {
3516             item = static_cast <ClipItem *>(itemList.at(i));
3517             if (item->clipType() != COLOR) {
3518                 // Check if we have a cached thumbnail
3519                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
3520                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
3521                     if (QFile::exists(thumb)) {
3522                         QPixmap pix(thumb);
3523                         item->slotSetStartThumb(pix);
3524                         item->slotSetEndThumb(pix);
3525                     }
3526                 } else {
3527                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
3528                     QString endThumb = startThumb;
3529                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
3530                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
3531                     if (QFile::exists(startThumb)) {
3532                         QPixmap pix(startThumb);
3533                         item->slotSetStartThumb(pix);
3534                     }
3535                     if (QFile::exists(endThumb)) {
3536                         QPixmap pix(endThumb);
3537                         item->slotSetEndThumb(pix);
3538                     }
3539                 }
3540             }
3541             item->refreshClip();
3542             qApp->processEvents();
3543         }
3544     }
3545     viewport()->update();
3546 }
3547
3548 void CustomTrackView::saveThumbnails() {
3549     QList<QGraphicsItem *> itemList = items();
3550     ClipItem *item;
3551     QString thumbBase = m_document->projectFolder().path() + "/thumbs/";
3552     for (int i = 0; i < itemList.count(); i++) {
3553         if (itemList.at(i)->type() == AVWIDGET) {
3554             item = static_cast <ClipItem *>(itemList.at(i));
3555             if (item->clipType() != COLOR) {
3556                 // Check if we have a cached thumbnail
3557                 if (item->clipType() == IMAGE || item->clipType() == TEXT || item->clipType() == AUDIO) {
3558                     QString thumb = thumbBase + item->baseClip()->getClipHash() + "_0.png";
3559                     if (!QFile::exists(thumb)) {
3560                         QPixmap pix(item->startThumb());
3561                         pix.save(thumb);
3562                     }
3563                 } else {
3564                     QString startThumb = thumbBase + item->baseClip()->getClipHash() + '_';
3565                     QString endThumb = startThumb;
3566                     startThumb.append(QString::number(item->cropStart().frames(m_document->fps())) + ".png");
3567                     endThumb.append(QString::number((item->cropStart() + item->cropDuration()).frames(m_document->fps()) - 1) + ".png");
3568                     if (!QFile::exists(startThumb)) {
3569                         QPixmap pix(item->startThumb());
3570                         pix.save(startThumb);
3571                     }
3572                     if (!QFile::exists(endThumb)) {
3573                         QPixmap pix(item->endThumb());
3574                         pix.save(endThumb);
3575                     }
3576                 }
3577             }
3578         }
3579     }
3580 }
3581
3582
3583 void CustomTrackView::slotInsertTrack(int ix) {
3584     kDebug() << "// INSERTING TRK: " << ix;
3585     QDialog d(parentWidget());
3586     Ui::AddTrack_UI view;
3587     view.setupUi(&d);
3588     view.track_nb->setMaximum(m_document->tracksCount() - 1);
3589     view.track_nb->setValue(ix);
3590     d.setWindowTitle(i18n("Insert Track"));
3591
3592     if (d.exec() == QDialog::Accepted) {
3593         ix = view.track_nb->value();
3594         if (view.before_select->currentIndex() == 1) {
3595             ix++;
3596         }
3597         TrackInfo info;
3598         if (view.video_track->isChecked()) {
3599             info.type = VIDEOTRACK;
3600             info.isMute = false;
3601             info.isBlind = false;
3602             info.isLocked = false;
3603         } else {
3604             info.type = AUDIOTRACK;
3605             info.isMute = false;
3606             info.isBlind = true;
3607             info.isLocked = false;
3608         }
3609         AddTrackCommand *addTrack = new AddTrackCommand(this, ix, info, true, true);
3610         m_commandStack->push(addTrack);
3611         m_document->setModified(true);
3612     }
3613 }
3614
3615 void CustomTrackView::slotDeleteTrack(int ix) {
3616     bool ok;
3617     ix = QInputDialog::getInteger(this, i18n("Remove Track"), i18n("Track"), ix, 0, m_document->tracksCount() - 1, 1, &ok);
3618     if (ok) {
3619         TrackInfo info = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
3620         deleteTimelineTrack(ix, info);
3621         m_document->setModified(true);
3622         /*AddTrackCommand* command = new AddTrackCommand(this, ix, info, false, true);
3623         m_commandStack->push(command);*/
3624     }
3625 }
3626
3627 void CustomTrackView::slotChangeTrack(int ix) {
3628     QDialog d(parentWidget());
3629     Ui::AddTrack_UI view;
3630     view.setupUi(&d);
3631     view.label->setText(i18n("Change track"));
3632     view.before_select->setHidden(true);
3633     view.track_nb->setMaximum(m_document->tracksCount() - 1);
3634     view.track_nb->setValue(ix);
3635     d.setWindowTitle(i18n("Change Track Type"));
3636
3637     if (d.exec() == QDialog::Accepted) {
3638         TrackInfo info;
3639         info.isLocked = false;
3640         info.isMute = false;
3641         ix = view.track_nb->value();
3642
3643         if (view.video_track->isChecked()) {
3644             info.type = VIDEOTRACK;
3645             info.isBlind = false;
3646         } else {
3647             info.type = AUDIOTRACK;
3648             info.isBlind = true;
3649         }
3650         changeTimelineTrack(ix, info);
3651         m_document->setModified(true);
3652     }
3653 }
3654
3655
3656 void CustomTrackView::deleteTimelineTrack(int ix, TrackInfo trackinfo) {
3657     double startY = ix * m_tracksHeight + 1 + m_tracksHeight / 2;
3658     QRectF r(0, startY, sceneRect().width(), m_tracksHeight / 2 - 1);
3659     QList<QGraphicsItem *> selection = m_scene->items(r);
3660     QUndoCommand *deleteTrack = new QUndoCommand();
3661     deleteTrack->setText("Delete track");
3662
3663     // Delete all clips in selected track
3664     for (int i = 0; i < selection.count(); i++) {
3665         if (selection.at(i)->type() == AVWIDGET) {
3666             ClipItem *item =  static_cast <ClipItem *>(selection.at(i));
3667             new AddTimelineClipCommand(this, item->xml(), item->clipProducer(), item->info(), item->effectList(), false, true, deleteTrack);
3668             m_scene->removeItem(item);
3669             delete item;
3670             item = NULL;
3671         } else if (selection.at(i)->type() == TRANSITIONWIDGET) {
3672             Transition *item =  static_cast <Transition *>(selection.at(i));
3673             new AddTransitionCommand(this, item->info(), item->transitionEndTrack(), item->toXML(), true, false, deleteTrack);
3674             m_scene->removeItem(item);
3675             delete item;
3676             item = NULL;
3677         }
3678     }
3679
3680     new AddTrackCommand(this, ix, trackinfo, false, true, deleteTrack);
3681     m_commandStack->push(deleteTrack);
3682 }
3683
3684 void CustomTrackView::changeTimelineTrack(int ix, TrackInfo trackinfo) {
3685     TrackInfo oldinfo = m_document->trackInfoAt(m_document->tracksCount() - ix - 1);
3686     ChangeTrackCommand *changeTrack = new ChangeTrackCommand(this, ix, oldinfo, trackinfo, true);
3687     m_commandStack->push(changeTrack);
3688 }
3689
3690 void CustomTrackView::autoTransition() {
3691     QList<QGraphicsItem *> itemList = scene()->selectedItems();
3692     if (itemList.count() != 1 || itemList.at(0)->type() != TRANSITIONWIDGET) {
3693         emit displayMessage(i18n("You must select one transition for this action"), ErrorMessage);
3694         return;
3695     }
3696     Transition *tr = static_cast <Transition*>(itemList.at(0));
3697     tr->setAutomatic(!tr->isAutomatic());
3698     QDomElement transition = tr->toXML();
3699     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);
3700 }
3701
3702
3703 QStringList CustomTrackView::getLadspaParams(QDomElement effect) const {
3704     QStringList result;
3705     QDomNodeList params = effect.elementsByTagName("parameter");
3706     for (int i = 0; i < params.count(); i++) {
3707         QDomElement e = params.item(i).toElement();
3708         if (!e.isNull() && e.attribute("type") == "constant") {
3709             if (e.hasAttribute("factor")) {
3710                 double factor = e.attribute("factor").toDouble();
3711                 double value = e.attribute("value").toDouble();
3712                 value = value / factor;
3713                 result.append(QString::number(value));
3714             } else result.append(e.attribute("value"));
3715         }
3716     }
3717     return result;
3718 }
3719
3720 void CustomTrackView::clipNameChanged(const QString id, const QString name) {
3721     QList<QGraphicsItem *> list = scene()->items();
3722     ClipItem *clip = NULL;
3723     for (int i = 0; i < list.size(); ++i) {
3724         if (list.at(i)->type() == AVWIDGET) {
3725             clip = static_cast <ClipItem *>(list.at(i));
3726             if (clip->clipProducer() == id) {
3727                 clip->setClipName(name);
3728             }
3729         }
3730     }
3731     viewport()->update();
3732 }
3733
3734 void CustomTrackView::getClipAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum) {
3735     minimum = GenTime();
3736     maximum = GenTime();
3737     QList<QGraphicsItem *> selection;
3738     selection = m_scene->items(0, item->track() * m_tracksHeight + m_tracksHeight / 2, sceneRect().width(), 2);
3739     selection.removeAll(item);
3740     for (int i = 0; i < selection.count(); i++) {
3741         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
3742         if (clip && clip->type() == AVWIDGET) {
3743             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
3744             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
3745         }
3746     }
3747 }
3748
3749 void CustomTrackView::getTransitionAvailableSpace(AbstractClipItem *item, GenTime &minimum, GenTime &maximum) {
3750     minimum = GenTime();
3751     maximum = GenTime();
3752     QList<QGraphicsItem *> selection;
3753     selection = m_scene->items(0, (item->track() + 1) * m_tracksHeight, sceneRect().width(), 2);
3754     selection.removeAll(item);
3755     for (int i = 0; i < selection.count(); i++) {
3756         AbstractClipItem *clip = static_cast <AbstractClipItem *>(selection.at(i));
3757         if (clip && clip->type() == TRANSITIONWIDGET) {
3758             if (clip->endPos() <= item->startPos() && clip->endPos() > minimum) minimum = clip->endPos();
3759             if (clip->startPos() > item->startPos() && (clip->startPos() < maximum || maximum == GenTime())) maximum = clip->startPos();
3760         }
3761     }
3762 }
3763
3764 #include "customtrackview.moc"