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